Fix type compatibility for types with flexible array member 2/2 [PR113688,PR114713...

For checking or computing TYPE_CANONICAL, ignore the array size when it is
the last element of a structure or union.  To not get errors because of
an inconsistent number of members, zero-sized arrays which are the last
element are not ignored anymore when checking the fields of a struct.

	PR c/113688
	PR c/114014
	PR c/114713
	PR c/117724

gcc/ChangeLog:
	* tree.cc (gimple_canonical_types_compatible_p): Add exception.

gcc/lto/ChangeLog:
	* lto-common.cc (hash_canonical_type): Add exception.

gcc/testsuite/ChangeLog:
	* gcc.dg/pr113688.c: New test.
	* gcc.dg/pr114014.c: New test.
	* gcc.dg/pr114713.c: New test.
	* gcc.dg/pr117724.c: New test.

(cherry picked from commit d46c7f313b5a30ee04080f249e31e12987d50aa2)

diff --git a/gcc/lto/lto-common.cc b/gcc/lto/lto-common.cc
index f6e08b51dcaf7cd976e7f88ba474c817ec5011e2..7697a7d6ea02bf0c730c074b8ead342c4bfd92a8 100644 (file)
--- a/gcc/lto/lto-common.cc
+++ b/gcc/lto/lto-common.cc
@@ -333,7 +333,11 @@ hash_canonical_type (tree type)
            && (! DECL_SIZE (f)
                || ! integer_zerop (DECL_SIZE (f))))
          {
-           iterative_hash_canonical_type (TREE_TYPE (f), hstate);
+           tree t = TREE_TYPE (f);
+           if (!TREE_CHAIN (f)
+               && TREE_CODE (t) == ARRAY_TYPE)
+             t = TREE_TYPE  (t);
+           iterative_hash_canonical_type (t, hstate);
            nf++;
          }
 

diff --git a/gcc/testsuite/gcc.dg/pr113688.c b/gcc/testsuite/gcc.dg/pr113688.c
new file mode 100644 (file)
index 0000000..8dee8c8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr113688.c
@@ -0,0 +1,8 @@
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+struct S{int x,y[1];}*a;
+int main(void){
+       struct S{int x,y[];};
+}
+

diff --git a/gcc/testsuite/gcc.dg/pr114014.c b/gcc/testsuite/gcc.dg/pr114014.c
new file mode 100644 (file)
index 0000000..1531ffa
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr114014.c
@@ -0,0 +1,14 @@
+/* PR c/114014
+ * { dg-do compile }
+ * { dg-options "-std=gnu23 -g" } */
+
+struct r {
+  int a;
+  char b[];
+};
+struct r {
+  int a;
+  char b[0];
+};
+
+

diff --git a/gcc/testsuite/gcc.dg/pr114713.c b/gcc/testsuite/gcc.dg/pr114713.c
new file mode 100644 (file)
index 0000000..78e3237
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr114713.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-require-effective-target lto } */
+/* { dg-options "-std=c23 -flto -O2" } */
+
+struct foo { int x; char a[]; };
+
+void test_bar(void* b);
+
+__attribute__((noinline))
+int test_foo(struct foo* a, void* b)
+{
+        a->x = 1;
+        test_bar(b);
+        return a->x;
+}
+
+int main()
+{
+        struct foo y;
+
+        if (2 != test_foo(&y, &y))
+                __builtin_abort();
+
+        return 0;
+}
+
+// TU2
+struct foo { int x; char a[0]; };
+
+void test_bar(void* b)
+{
+        struct foo *p = b;
+        p->x = 2;
+}
+

diff --git a/gcc/testsuite/gcc.dg/pr117724.c b/gcc/testsuite/gcc.dg/pr117724.c
new file mode 100644 (file)
index 0000000..d631dae
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr117724.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-g" } */
+
+struct {
+  unsigned long len;
+  unsigned long size;
+  char data[];
+};                     /* { dg-warning "unnamed struct" } */
+struct {
+  struct {
+    unsigned long len;
+    unsigned long size;
+    char data[6];
+  };
+};                     /* { dg-warning "unnamed struct" } */
+

diff --git a/gcc/tree.cc b/gcc/tree.cc
index f202187754a627ae4867c6117b040cd7dc9542a2..a4c62e1f068152cf875cfadcda2a3584b9b4b50e 100644 (file)
--- a/gcc/tree.cc
+++ b/gcc/tree.cc
@@ -13901,7 +13901,7 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
     {
     case ARRAY_TYPE:
       /* Array types are the same if the element types are the same and
-        the number of elements are the same.  */
+        minimum and maximum index are the same.  */
       if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2),
                                                trust_type_canonical)
          || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
@@ -13995,23 +13995,46 @@ gimple_canonical_types_compatible_p (const_tree t1, const_tree t2,
             f1 || f2;
             f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
          {
-           /* Skip non-fields and zero-sized fields.  */
+           /* Skip non-fields and zero-sized fields, except zero-sized
+              arrays at the end.  */
            while (f1 && (TREE_CODE (f1) != FIELD_DECL
                          || (DECL_SIZE (f1)
-                             && integer_zerop (DECL_SIZE (f1)))))
+                             && integer_zerop (DECL_SIZE (f1))
+                             && (TREE_CHAIN (f1)
+                                 || TREE_CODE (TREE_TYPE (f1))
+                                    != ARRAY_TYPE))))
              f1 = TREE_CHAIN (f1);
            while (f2 && (TREE_CODE (f2) != FIELD_DECL
                          || (DECL_SIZE (f2)
-                             && integer_zerop (DECL_SIZE (f2)))))
+                             && integer_zerop (DECL_SIZE (f2))
+                             && (TREE_CHAIN (f2)
+                                 || TREE_CODE (TREE_TYPE (f2))
+                                    != ARRAY_TYPE))))
              f2 = TREE_CHAIN (f2);
            if (!f1 || !f2)
              break;
-           /* The fields must have the same name, offset and type.  */
+
+           tree t1 = TREE_TYPE (f1);
+           tree t2 = TREE_TYPE (f2);
+
+           /* If the last element are arrays, we only compare the element
+              types.  */
+           if (TREE_CHAIN (f1) == NULL_TREE && TREE_CODE (t1) == ARRAY_TYPE
+               && TREE_CHAIN (f2) == NULL_TREE && TREE_CODE (t2) == ARRAY_TYPE)
+             {
+               /* If both arrays have zero size, this is a match.  */
+               if (DECL_SIZE (f1) && integer_zerop (DECL_SIZE (f1))
+                   && DECL_SIZE (f2) && integer_zerop (DECL_SIZE (f2)))
+                 return true;
+
+               t1 = TREE_TYPE (t1);
+               t2 = TREE_TYPE (t2);
+             }
+
            if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
                || !gimple_compare_field_offset (f1, f2)
                || !gimple_canonical_types_compatible_p
-                     (TREE_TYPE (f1), TREE_TYPE (f2),
-                      trust_type_canonical))
+                     (t1, t2, trust_type_canonical))
              return false;
          }