Fix misoptimization of CONSTRUCTOR with reverse SSO

fold_ctor_reference already punts on a CONSTRUCTOR whose type has reverse
storage order, but it can be invoked in a couple of places on a CONSTRUCTOR
with native storage order that has been wrapped in a VIEW_CONVERT_EXPR to a
type with reverse storage order; this would require a post adjustment that
does not currently exist, thus yield wrong code for this admittedly quite
pathological (but supported) case.

gcc/
	* gimple-fold.cc (fold_const_aggregate_ref_1) <COMPONENT_REF>:
	Bail out immediately if the reference has reverse storage order.
	* tree-ssa-sccvn.cc (fully_constant_vn_reference_p): Likewise.
gcc/testsuite/
	* gnat.dg/sso20.adb: New test.

diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc
index 2507e23f2d7cbde42beb3b0c5079e716d30790df..c5c8e227037a4af55ebfe859581c474beddefe98 100644 (file)
--- a/gcc/gimple-fold.cc
+++ b/gcc/gimple-fold.cc
@@ -10117,19 +10117,21 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
       base = get_ref_base_and_extent (t, &offset, &size, &max_size, &reverse);
       ctor = get_base_constructor (base, &offset, valueize);
 
+      /* We cannot determine ctor.  */
+      if (!ctor)
+       return NULL_TREE;
       /* Empty constructor.  Always fold to 0.  */
       if (ctor == error_mark_node)
        return build_zero_cst (TREE_TYPE (t));
-      /* We do not know precise address.  */
+      /* We do not know precise access.  */
       if (!known_size_p (max_size) || maybe_ne (max_size, size))
        return NULL_TREE;
-      /* We cannot determine ctor.  */
-      if (!ctor)
-       return NULL_TREE;
-
       /* Out of bound array access.  Value is undefined, but don't fold.  */
       if (maybe_lt (offset, 0))
        return NULL_TREE;
+      /* Access with reverse storage order.  */
+      if (reverse)
+       return NULL_TREE;
 
       tem = fold_ctor_reference (TREE_TYPE (t), ctor, offset, size, base);
       if (tem)
@@ -10149,7 +10151,6 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
              && offset.is_constant (&coffset)
              && (coffset % BITS_PER_UNIT != 0
                  || csize % BITS_PER_UNIT != 0)
-             && !reverse
              && BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN)
            {
              poly_int64 bitoffset;

diff --git a/gcc/testsuite/gnat.dg/sso20.adb b/gcc/testsuite/gnat.dg/sso20.adb
new file mode 100644 (file)
index 0000000..34980d3
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/sso20.adb
@@ -0,0 +1,29 @@
+--  { dg-do run }
+--  { dg-options "-O" }
+
+with Ada.Unchecked_Conversion;
+with Interfaces;  use Interfaces;
+with System;      use System;
+
+procedure SSO20 is
+
+  type Bytes_Ref is array (1 .. 4) of Unsigned_8
+    with Convention => Ada_Pass_By_Reference;
+
+  type U32_BE is record
+    Value : Unsigned_32;
+  end record
+    with
+      Pack,
+      Bit_Order            => High_Order_First,
+      Scalar_Storage_Order => High_Order_First;
+
+  function Conv is new Ada.Unchecked_Conversion (Bytes_Ref, U32_BE);
+
+  function Value (B : Bytes_Ref) return Unsigned_32 is (Conv (B).Value);
+
+begin
+  if Value ((16#11#, 16#22#, 16#33#, 16#44#)) /= 16#11223344# then
+     raise Program_Error;
+  end if;
+end;

diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index f7f50c3de994da1f8a7d7c94458e21f0dc260990..9cdbf3da77220ad3f3c1a3166d1efacdcdecf9a5 100644 (file)
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -1615,6 +1615,8 @@ fully_constant_vn_reference_p (vn_reference_t ref)
              ++i;
              break;
            }
+         if (operands[i].reverse)
+           return NULL_TREE;
          if (known_eq (operands[i].off, -1))
            return NULL_TREE;
          off += operands[i].off;