tree-optimization/116585 - SSA corruption with split_constant_offset

split_constant_offset when looking through SSA defs can end up
picking SSA leafs that are subject to abnormal coalescing.  This
can lead to downstream consumers to insert code based on the
result (like from dataref analysis) in places that violate constraints
for abnormal coalescing.  It's best to not expand defs whose operands
are subject to abnormal coalescing - and not either do something when
a subexpression has operands like that already.

	PR tree-optimization/116585
	* tree-data-ref.cc (split_constant_offset_1): When either
	operand is subject to abnormal coalescing do no further
	processing.

	* gcc.dg/torture/pr116585.c: New testcase.

diff --git a/gcc/testsuite/gcc.dg/torture/pr116585.c b/gcc/testsuite/gcc.dg/torture/pr116585.c
new file mode 100644 (file)
index 0000000..108c481
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr116585.c
@@ -0,0 +1,32 @@
+/* { dg-do compile } */
+
+char *s1, *s2;
+extern int* my_alloc (int);
+extern int _setjmp ();
+extern void bar();
+void foo(int s1len, int s2len)
+{
+  int e;
+  e = _setjmp ();
+    {
+      int l, i;
+      int *md = my_alloc(((sizeof(int)) * (s1len + 1) * (s2len)));
+      s1len++;
+      for (; s1len; l)
+       for (; s2len; l)
+         for (; s1len; i)
+           {
+             int j = 1;
+             for (; j < s2len; j++)
+               {
+                 int cost;
+                 if (s1[1] == s2[1])
+                   cost = 0;
+                 else
+                   cost = 1;
+                 md[j * s1len ] = ((cost));
+               }
+           }
+      bar();
+    }
+}

diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
index 48798f458b803fd4d4261c152245f8d9f0dc5224..26e6d9a565721646feb93efa8ab0a49a2afe5b9c 100644 (file)
--- a/gcc/tree-data-ref.cc
+++ b/gcc/tree-data-ref.cc
@@ -766,6 +766,14 @@ split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
   if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type))
     return false;
 
+  if (TREE_CODE (op0) == SSA_NAME
+      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op0))
+    return false;
+  if (op1
+      && TREE_CODE (op1) == SSA_NAME
+      && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op1))
+    return false;
+
   switch (code)
     {
     case INTEGER_CST:
@@ -861,9 +869,6 @@ split_constant_offset_1 (tree type, tree op0, enum tree_code code, tree op1,
 
     case SSA_NAME:
       {
-       if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (op0))
-         return false;
-
        gimple *def_stmt = SSA_NAME_DEF_STMT (op0);
        enum tree_code subcode;