[Ada] Improve optimization of "=" on bit-packed arrays

[Ada] Improve optimization of "=" on bit-packed arrays

[Pierre-Marie de Rodat]

[-- Attachment #1: Type: text/plain, Size: 519 bytes --]

This patch fixes a performance regression, introduced by a previous bug
fix.  That fix had the unintended side effect of removing the
optimization in cases where the two operands are of two different
compiler-generated modular types.

Tested on x86_64-pc-linux-gnu, committed on trunk

gcc/ada/

	* exp_pakd.adb (Expand_Packed_Eq): Replace the check for *same*
	modular type, with a check for any modular type, and assert that
	the two types have the same modulus and so on.
	* exp_pakd.ads: Minor comment improvements.

[-- Attachment #2: patch.diff --]
[-- Type: text/x-diff, Size: 2969 bytes --]

diff --git a/gcc/ada/exp_pakd.adb b/gcc/ada/exp_pakd.adb
--- a/gcc/ada/exp_pakd.adb
+++ b/gcc/ada/exp_pakd.adb
@@ -1930,9 +1930,17 @@ package body Exp_Pakd is
       --  modular case we guarantee that the unused bits are always zeroes.
       --  We do have to compare the lengths because we could be comparing
       --  two different subtypes of the same base type. We can only do this
-      --  if the PATs on both sides are the same.
+      --  if the PATs on both sides are modular (in which case they are
+      --  necessarily structurally the same -- same Modulus and so on);
+      --  otherwise, we have a case where the right operand is not of
+      --  compile time known size.
+
+      if Is_Modular_Integer_Type (PAT)
+        and then Is_Modular_Integer_Type (Etype (R))
+      then
+         pragma Assert (RM_Size (Etype (R)) = RM_Size (PAT));
+         pragma Assert (Modulus (Etype (R)) = Modulus (PAT));
 
-      if Is_Modular_Integer_Type (PAT) and then PAT = Etype (R) then
          Rewrite (N,
            Make_And_Then (Loc,
              Left_Opnd =>


diff --git a/gcc/ada/exp_pakd.ads b/gcc/ada/exp_pakd.ads
--- a/gcc/ada/exp_pakd.ads
+++ b/gcc/ada/exp_pakd.ads
@@ -41,7 +41,8 @@ package Exp_Pakd is
 
    --  This packed array type has the name xxxPn, where xxx is the name
    --  of the packed type, and n is the component size. The expanded
-   --  declaration declares a type that is one of the following:
+   --  declaration declares a type that is one of the following (sizes
+   --  below are in bytes):
 
    --    For an unconstrained array with component size 1,2,4 or any other
    --    odd component size. These are the cases in which we do not need
@@ -49,10 +50,10 @@ package Exp_Pakd is
 
    --      type xxxPn is new Packed_Bytes1;
 
-   --    For an unconstrained array with component size that is divisible
-   --    by 2, but not divisible by 4 (other than 2 itself). These are the
-   --    cases in which we can generate better code if the underlying array
-   --    is 2-byte aligned (see System.Pack_14 in file s-pack14 for example).
+   --    For an unconstrained array with component size greater than 2, that is
+   --    divisible by 2, but not divisible by 4. These are the cases in which
+   --    we can generate better code if the underlying array is 2-byte aligned
+   --    (see System.Pack_14 in file s-pack14 for example).
 
    --      type xxxPn is new Packed_Bytes2;
 
@@ -942,7 +943,7 @@ package Exp_Pakd is
    --  N is an N_Op_Eq node where the operands are packed arrays whose
    --  representation is an array-of-bytes type (the case where a modular
    --  type is used for the representation does not require any special
-   --  handling, because in the modular case, unused bits are zeroes.
+   --  handling, because in the modular case, unused bits are zeroes).
 
    procedure Expand_Packed_Not (N : Node_Id);
    --  N is an N_Op_Not node where the operand is packed array of Boolean