tree-optimization/110799 - fix bug in code hoisting

Code hoisting part of GIMPLE PRE failed to adjust the TBAA behavior
of common loads in the case the alias set of the ref was the same
but the base alias set was not.  It also failed to adjust the
base behavior, assuming it would match.  The following plugs this
hole.

	PR tree-optimization/110799
	* tree-ssa-pre.cc (compute_avail): More thoroughly match
	up TBAA behavior of redundant loads.

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

diff --git a/gcc/testsuite/gcc.dg/torture/pr110799.c b/gcc/testsuite/gcc.dg/torture/pr110799.c
new file mode 100644 (file)
index 0000000..53f06f0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr110799.c
@@ -0,0 +1,46 @@
+/* { dg-do run { target { { *-*-linux* *-*-gnu* *-*-uclinux* } && mmap } } } */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+struct S {
+    int a;
+};
+struct M {
+    int a, b;
+};
+
+int __attribute__((noipa))
+f(struct S *p, int c, int d)
+{
+  int r;
+  if (c)
+    {
+      if (d)
+       r = p->a;
+      else
+       r = ((struct M*)p)->a;
+    }
+  else
+    r = ((struct M*)p)->b;
+  return r;
+}
+
+int main ()
+{
+  long pgsz = sysconf(_SC_PAGESIZE);
+  if (pgsz < sizeof (struct M))
+    return 0;
+  char *p = mmap ((void *) 0, 2 * pgsz, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
+                 -1, 0);
+  if (p == MAP_FAILED)
+    return 0;
+  if (mprotect (p, pgsz, PROT_READ | PROT_WRITE))
+    return 0;
+  struct S *q = (struct S *)(p + pgsz) - 1;
+  q->a = 42;
+  if (f (q, 1, 1) != 42)
+    abort ();
+  return 0;
+}

diff --git a/gcc/tree-ssa-pre.cc b/gcc/tree-ssa-pre.cc
index e33c5ba80e277b5538683af8dc5b6b7db35ee1ee..0f2e458395c8bd3ad46d44eee581cbede6ff53a4 100644 (file)
--- a/gcc/tree-ssa-pre.cc
+++ b/gcc/tree-ssa-pre.cc
@@ -4217,8 +4217,10 @@ compute_avail (function *fun)
                      /* TBAA behavior is an obvious part so make sure
                         that the hashtable one covers this as well
                         by adjusting the ref alias set and its base.  */
-                     if (ref->set == set
-                         || alias_set_subset_of (set, ref->set))
+                     if ((ref->set == set
+                          || alias_set_subset_of (set, ref->set))
+                         && (ref->base_set == base_set
+                             || alias_set_subset_of (base_set, ref->base_set)))
                        ;
                      else if (ref1->opcode != ref2->opcode
                               || (ref1->opcode != MEM_REF
@@ -4230,16 +4232,19 @@ compute_avail (function *fun)
                          operands.release ();
                          continue;
                        }
-                     else if (alias_set_subset_of (ref->set, set))
+                     else if (ref->set == set
+                              || alias_set_subset_of (ref->set, set))
                        {
+                         tree reft = reference_alias_ptr_type (rhs1);
                          ref->set = set;
+                         ref->base_set = set;
                          if (ref1->opcode == MEM_REF)
                            ref1->op0
-                             = wide_int_to_tree (TREE_TYPE (ref2->op0),
+                             = wide_int_to_tree (reft,
                                                  wi::to_wide (ref1->op0));
                          else
                            ref1->op2
-                             = wide_int_to_tree (TREE_TYPE (ref2->op2),
+                             = wide_int_to_tree (reft,
                                                  wi::to_wide (ref1->op2));
                        }
                      else