alias.c (record_component_aliases): Do not simplify pointed-to types of ODR types

	* alias.c (record_component_aliases): Do not simplify pointed-to
	types of ODR types
	* testsuite/g++.dg/lto/alias-4_0.C

From-SVN: r273552

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5c69a63..26c647f 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2019-07-17  Jan Hubicka  <hubicka@ucw.cz>
+
+       * alias.c (record_component_aliases): Do not simplify pointed-to
+       types of ODR types 
+
 2019-07-17  Uroš Bizjak  <ubizjak@gmail.com>
 
        * config/i386/i386.md (*andqi_2_maybe_si): Handle potential

diff --git a/gcc/alias.c b/gcc/alias.c
index eece84a..2755df7 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -1202,47 +1202,52 @@ record_component_aliases (tree type)
     case RECORD_TYPE:
     case UNION_TYPE:
     case QUAL_UNION_TYPE:
-      for (field = TYPE_FIELDS (type); field != 0; field = DECL_CHAIN (field))
-       if (TREE_CODE (field) == FIELD_DECL && !DECL_NONADDRESSABLE_P (field))
-         {
-           /* LTO type merging does not make any difference between 
-              component pointer types.  We may have
-
-              struct foo {int *a;};
-
-              as TYPE_CANONICAL of 
-
-              struct bar {float *a;};
-
-              Because accesses to int * and float * do not alias, we would get
-              false negative when accessing the same memory location by
-              float ** and bar *. We thus record the canonical type as:
-
-              struct {void *a;};
-
-              void * is special cased and works as a universal pointer type.
-              Accesses to it conflicts with accesses to any other pointer
-              type.  */
-           tree t = TREE_TYPE (field);
-           if (in_lto_p)
-             {
-               /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
-                  element type and that type has to be normalized to void *,
-                  too, in the case it is a pointer. */
-               while (!canonical_type_used_p (t) && !POINTER_TYPE_P (t))
-                 {
-                   gcc_checking_assert (TYPE_STRUCTURAL_EQUALITY_P (t));
-                   t = TREE_TYPE (t);
-                 }
-               if (POINTER_TYPE_P (t))
-                 t = ptr_type_node;
-               else if (flag_checking)
-                 gcc_checking_assert (get_alias_set (t)
-                                      == get_alias_set (TREE_TYPE (field)));
-             }
-
-           record_alias_subset (superset, get_alias_set (t));
-         }
+      {
+       /* LTO non-ODR type merging does not make any difference between 
+          component pointer types.  We may have
+
+          struct foo {int *a;};
+
+          as TYPE_CANONICAL of 
+
+          struct bar {float *a;};
+
+          Because accesses to int * and float * do not alias, we would get
+          false negative when accessing the same memory location by
+          float ** and bar *. We thus record the canonical type as:
+
+          struct {void *a;};
+
+          void * is special cased and works as a universal pointer type.
+          Accesses to it conflicts with accesses to any other pointer
+          type.  */
+       bool void_pointers = in_lto_p
+                            && (!odr_type_p (type)
+                                || !odr_based_tbaa_p (type));
+       for (field = TYPE_FIELDS (type); field != 0; field = DECL_CHAIN (field))
+         if (TREE_CODE (field) == FIELD_DECL && !DECL_NONADDRESSABLE_P (field))
+           {
+             tree t = TREE_TYPE (field);
+             if (void_pointers)
+               {
+                 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
+                    element type and that type has to be normalized to void *,
+                    too, in the case it is a pointer. */
+                 while (!canonical_type_used_p (t) && !POINTER_TYPE_P (t))
+                   {
+                     gcc_checking_assert (TYPE_STRUCTURAL_EQUALITY_P (t));
+                     t = TREE_TYPE (t);
+                   }
+                 if (POINTER_TYPE_P (t))
+                   t = ptr_type_node;
+                 else if (flag_checking)
+                   gcc_checking_assert (get_alias_set (t)
+                                        == get_alias_set (TREE_TYPE (field)));
+               }
+
+             record_alias_subset (superset, get_alias_set (t));
+           }
+      }
       break;
 
     case COMPLEX_TYPE:

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 2d7a6bf..d3d7107 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,7 @@
+2019-07-17  Jan Hubicka  <hubicka@ucw.cz>
+
+       * g++.dg/lto/alias-4_0.C
+
 2019-07-17  Richard Biener  <rguenther@suse.de>
 
        PR tree-optimization/91178

diff --git a/gcc/testsuite/g++.dg/lto/alias-4_0.C b/gcc/testsuite/g++.dg/lto/alias-4_0.C
new file mode 100644 (file)
index 0000000..410c314
--- /dev/null
+++ b/gcc/testsuite/g++.dg/lto/alias-4_0.C
@@ -0,0 +1,31 @@
+/* { dg-lto-do run } */
+/* { dg-lto-options { { -O3 -flto -fno-early-inlining } } } */
+__attribute__ ((used))
+short *ptr_init, **ptr=&ptr_init;
+
+__attribute__ ((used))
+struct a {
+  int *aptr;
+} a, *aptr=&a;
+
+void
+write_ptr ()
+{
+  *aptr = a;
+}
+
+__attribute__ ((used))
+void
+test ()
+{
+  *ptr = (short int *)0;
+  write_ptr ();
+  if (!__builtin_constant_p (*ptr == (void *)0))
+    __builtin_abort ();
+}
+int
+main()
+{
+  test ();
+  return 0;
+}