tree-ssa-alias.c (aliasing_component_refs_p): Continue looking for comparaible types...

	* tree-ssa-alias.c (aliasing_component_refs_p): Continue looking
	for comparaible types in the second direction even if first one
	hits incomparable type.

From-SVN: r270938

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 161e966b0d4fbeb4920bb4d910429a93173ff0aa..ac9a600912d169472106217d46adf22e791435e6 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2019-05-03  Jan Hubicka  <hubicka@ucw.cz>
+
+       * tree-ssa-alias.c (aliasing_component_refs_p): Continue looking
+       for comparaible types in the second direction even if first one
+       hits incomparable type.
+
 2019-05-07  Richard Biener  <rguenther@suse.de>
 
        PR lto/90369
@@ -189,6 +195,7 @@
        and macros.
        * config/i386/t-i386: Define dependencies for new files.
 
+>>>>>>> .r270937
 2019-05-03  Richard Earnshaw  <rearnsha@arm.com>
 
        PR target/89400

diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 4d00d381542c6ddb01f375529244130cb2f144b1..1947710eba6a80b8451da68a85f4a5f8b723147c 100644 (file)
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -795,7 +795,7 @@ aliasing_component_refs_p (tree ref1,
   tree base1, base2;
   tree type1, type2;
   tree *refp;
-  int same_p;
+  int same_p, same_p2;
 
   /* Choose bases and base types to search for.  */
   base1 = ref1;
@@ -814,10 +814,7 @@ aliasing_component_refs_p (tree ref1,
         && same_type_for_tbaa (TREE_TYPE (*refp), type1) == 0)
     refp = &TREE_OPERAND (*refp, 0);
   same_p = same_type_for_tbaa (TREE_TYPE (*refp), type1);
-  /* If we couldn't compare types we have to bail out.  */
-  if (same_p == -1)
-    return true;
-  else if (same_p == 1)
+  if (same_p == 1)
     {
       poly_int64 offadj, sztmp, msztmp;
       bool reverse;
@@ -827,26 +824,31 @@ aliasing_component_refs_p (tree ref1,
       offset1 -= offadj;
       return ranges_maybe_overlap_p (offset1, max_size1, offset2, max_size2);
     }
+
   /* If we didn't find a common base, try the other way around.  */
   refp = &ref1;
   while (handled_component_p (*refp)
         && same_type_for_tbaa (TREE_TYPE (*refp), type2) == 0)
     refp = &TREE_OPERAND (*refp, 0);
-  same_p = same_type_for_tbaa (TREE_TYPE (*refp), type2);
-  /* If we couldn't compare types we have to bail out.  */
-  if (same_p == -1)
-    return true;
-  else if (same_p == 1)
+  same_p2 = same_type_for_tbaa (TREE_TYPE (*refp), type2);
+  if (same_p2 == 1)
     {
       poly_int64 offadj, sztmp, msztmp;
       bool reverse;
+
       get_ref_base_and_extent (*refp, &offadj, &sztmp, &msztmp, &reverse);
       offset1 -= offadj;
       get_ref_base_and_extent (base2, &offadj, &sztmp, &msztmp, &reverse);
       offset2 -= offadj;
-      return ranges_maybe_overlap_p (offset1, max_size1, offset2, max_size2);
+      return ranges_maybe_overlap_p (offset1, max_size1,
+                                    offset2, max_size2);
     }
 
+  /* In the remaining test we assume that there is no overlapping type
+     at all.  So if we are unsure, we need to give up.  */
+  if (same_p == -1 || same_p2 == -1)
+    return true;
+
   /* If we have two type access paths B1.path1 and B2.path2 they may
      only alias if either B1 is in B2.path2 or B2 is in B1.path1.
      But we can still have a path that goes B1.path1...B2.path2 with