c23: construct composite type for tagged types

Support for constructing composite types for structs and unions
in C23.

gcc/c:
	* c-typeck.cc (composite_type_internal): Adapted from
	composite_type to support structs and unions.
	(composite_type): New wrapper function.
	(build_conditional_operator): Return composite type.
	* c-decl.cc (finish_struct): Allow NULL for
	enclosing_struct_parse_info.

gcc/testsuite:
	* gcc.dg/c23-tag-alias-6.c: New test.
	* gcc.dg/c23-tag-alias-7.c: New test.
	* gcc.dg/c23-tag-composite-1.c: New test.
	* gcc.dg/c23-tag-composite-2.c: New test.
	* gcc.dg/c23-tag-composite-3.c: New test.
	* gcc.dg/c23-tag-composite-4.c: New test.
	* gcc.dg/c23-tag-composite-5.c: New test.
	* gcc.dg/c23-tag-composite-6.c: New test.
	* gcc.dg/c23-tag-composite-7.c: New test.
	* gcc.dg/c23-tag-composite-8.c: New test.
	* gcc.dg/c23-tag-composite-9.c: New test.
	* gcc.dg/c23-tag-composite-10.c: New test.
	* gcc.dg/gnu23-tag-composite-1.c: New test.
	* gcc.dg/gnu23-tag-composite-2.c: New test.
	* gcc.dg/gnu23-tag-composite-3.c: New test.
	* gcc.dg/gnu23-tag-composite-4.c: New test.
	* gcc.dg/gnu23-tag-composite-5.c: New test.

diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index 6639ec35e5f87e4353b5e112dc34ff4a56b5ad4f..b72738ea04ad4e44585b28c68443cabc24178eed 100644 (file)
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -9674,7 +9674,7 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
     }
 
   /* Check for consistency with previous definition.  */
-  if (flag_isoc23)
+  if (flag_isoc23 && NULL != enclosing_struct_parse_info)
     {
       tree vistype = previous_tag (t);
       if (vistype
@@ -9744,16 +9744,19 @@ finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
   if (warn_cxx_compat)
     warn_cxx_compat_finish_struct (fieldlist, TREE_CODE (t), loc);
 
-  delete struct_parse_info;
+  if (NULL != enclosing_struct_parse_info)
+    {
+      delete struct_parse_info;
 
-  struct_parse_info = enclosing_struct_parse_info;
+      struct_parse_info = enclosing_struct_parse_info;
 
-  /* If this struct is defined inside a struct, add it to
-     struct_types.  */
-  if (warn_cxx_compat
-      && struct_parse_info != NULL
-      && !in_sizeof && !in_typeof && !in_alignof)
-    struct_parse_info->struct_types.safe_push (t);
+      /* If this struct is defined inside a struct, add it to
+        struct_types.  */
+      if (warn_cxx_compat
+         && struct_parse_info != NULL
+         && !in_sizeof && !in_typeof && !in_alignof)
+       struct_parse_info->struct_types.safe_push (t);
+     }
 
   return t;
 }

diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 1c817297d1c3316b8447e7906fd7a6985b6d9256..2d9139d09d24902aabcd9f85b76833d4dad4aefb 100644 (file)
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -381,8 +381,15 @@ build_functype_attribute_variant (tree ntype, tree otype, tree attrs)
    nonzero; if that isn't so, this may crash.  In particular, we
    assume that qualifiers match.  */
 
+struct composite_cache {
+  tree t1;
+  tree t2;
+  tree composite;
+  struct composite_cache* next;
+};
+
 tree
-composite_type (tree t1, tree t2)
+composite_type_internal (tree t1, tree t2, struct composite_cache* cache)
 {
   enum tree_code code1;
   enum tree_code code2;
@@ -427,7 +434,8 @@ composite_type (tree t1, tree t2)
       {
        tree pointed_to_1 = TREE_TYPE (t1);
        tree pointed_to_2 = TREE_TYPE (t2);
-       tree target = composite_type (pointed_to_1, pointed_to_2);
+       tree target = composite_type_internal (pointed_to_1,
+                                              pointed_to_2, cache);
         t1 = build_pointer_type_for_mode (target, TYPE_MODE (t1), false);
        t1 = build_type_attribute_variant (t1, attributes);
        return qualify_type (t1, t2);
@@ -435,7 +443,8 @@ composite_type (tree t1, tree t2)
 
     case ARRAY_TYPE:
       {
-       tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
+       tree elt = composite_type_internal (TREE_TYPE (t1), TREE_TYPE (t2),
+                                           cache);
        int quals;
        tree unqual_elt;
        tree d1 = TYPE_DOMAIN (t1);
@@ -503,9 +512,87 @@ composite_type (tree t1, tree t2)
        return build_type_attribute_variant (t1, attributes);
       }
 
-    case ENUMERAL_TYPE:
     case RECORD_TYPE:
     case UNION_TYPE:
+      if (flag_isoc23 && !comptypes_same_p (t1, t2))
+       {
+         gcc_checking_assert (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2));
+         gcc_checking_assert (!TYPE_NAME (t1) || comptypes (t1, t2));
+
+         /* If a composite type for these two types is already under
+            construction, return it.  */
+
+         for (struct composite_cache *c = cache; c != NULL; c = c->next)
+           if (c->t1 == t1 && c->t2 == t2)
+              return c->composite;
+
+         /* Otherwise, create a new type node and link it into the cache.  */
+
+         tree n = make_node (code1);
+         TYPE_NAME (n) = TYPE_NAME (t1);
+
+         struct composite_cache cache2 = { t1, t2, n, cache };
+         cache = &cache2;
+
+         tree f1 = TYPE_FIELDS (t1);
+         tree f2 = TYPE_FIELDS (t2);
+         tree fields = NULL_TREE;
+
+         for (tree a = f1, b = f2; a && b;
+              a = DECL_CHAIN (a), b = DECL_CHAIN (b))
+           {
+             tree ta = TREE_TYPE (a);
+             tree tb = TREE_TYPE (b);
+
+             if (DECL_C_BIT_FIELD (a))
+               {
+                 ta = DECL_BIT_FIELD_TYPE (a);
+                 tb = DECL_BIT_FIELD_TYPE (b);
+               }
+
+             gcc_assert (DECL_NAME (a) == DECL_NAME (b));
+             gcc_checking_assert (!DECL_NAME (a) || comptypes (ta, tb));
+
+             tree t = composite_type_internal (ta, tb, cache);
+             tree f = build_decl (input_location, FIELD_DECL, DECL_NAME (a), t);
+
+             DECL_PACKED (f) = DECL_PACKED (a);
+             SET_DECL_ALIGN (f, DECL_ALIGN (a));
+             DECL_ATTRIBUTES (f) = DECL_ATTRIBUTES (a);
+             C_DECL_VARIABLE_SIZE (f) = C_TYPE_VARIABLE_SIZE (t);
+
+             finish_decl (f, input_location, NULL, NULL, NULL);
+
+             if (DECL_C_BIT_FIELD (a))
+               {
+                 /* This will be processed by finish_struct.  */
+                 SET_DECL_C_BIT_FIELD (f);
+                 DECL_INITIAL (f) = build_int_cst (integer_type_node,
+                                                   tree_to_uhwi (DECL_SIZE (a)));
+                 DECL_NONADDRESSABLE_P (f) = true;
+                 DECL_PADDING_P (f) = !DECL_NAME (a);
+               }
+
+             DECL_CHAIN (f) = fields;
+             fields = f;
+           }
+
+         fields = nreverse (fields);
+
+         /* Setup the struct/union type.  Because we inherit all variably
+            modified components, we can ignore the size expression.  */
+         tree expr = NULL_TREE;
+         n = finish_struct(input_location, n, fields, attributes, NULL, &expr);
+
+         n = qualify_type (n, t1);
+
+         gcc_checking_assert (!TYPE_NAME (n) || comptypes (n, t1));
+         gcc_checking_assert (!TYPE_NAME (n) || comptypes (n, t2));
+
+         return n;
+       }
+      /* FALLTHRU */
+    case ENUMERAL_TYPE:
       if (attributes != NULL)
        {
          /* Try harder not to create a new aggregate type.  */
@@ -520,7 +607,8 @@ composite_type (tree t1, tree t2)
       /* Function types: prefer the one that specified arg types.
         If both do, merge the arg types.  Also merge the return types.  */
       {
-       tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
+       tree valtype = composite_type_internal (TREE_TYPE (t1),
+                                               TREE_TYPE (t2), cache);
        tree p1 = TYPE_ARG_TYPES (t1);
        tree p2 = TYPE_ARG_TYPES (t2);
        int len;
@@ -565,6 +653,16 @@ composite_type (tree t1, tree t2)
        for (; p1 && p1 != void_list_node;
             p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
          {
+            tree mv1 = TREE_VALUE (p1);
+            if (mv1 && mv1 != error_mark_node
+                && TREE_CODE (mv1) != ARRAY_TYPE)
+              mv1 = TYPE_MAIN_VARIANT (mv1);
+
+            tree mv2 = TREE_VALUE (p2);
+            if (mv2 && mv2 != error_mark_node
+                && TREE_CODE (mv2) != ARRAY_TYPE)
+              mv2 = TYPE_MAIN_VARIANT (mv2);
+
            /* A null type means arg type is not specified.
               Take whatever the other function type has.  */
            if (TREE_VALUE (p1) == NULL_TREE)
@@ -585,10 +683,6 @@ composite_type (tree t1, tree t2)
                && TREE_VALUE (p1) != TREE_VALUE (p2))
              {
                tree memb;
-               tree mv2 = TREE_VALUE (p2);
-               if (mv2 && mv2 != error_mark_node
-                   && TREE_CODE (mv2) != ARRAY_TYPE)
-                 mv2 = TYPE_MAIN_VARIANT (mv2);
                for (memb = TYPE_FIELDS (TREE_VALUE (p1));
                     memb; memb = DECL_CHAIN (memb))
                  {
@@ -598,8 +692,9 @@ composite_type (tree t1, tree t2)
                      mv3 = TYPE_MAIN_VARIANT (mv3);
                    if (comptypes (mv3, mv2))
                      {
-                       TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
-                                                        TREE_VALUE (p2));
+                       TREE_VALUE (n) = composite_type_internal (TREE_TYPE (memb),
+                                                                 TREE_VALUE (p2),
+                                                                 cache);
                        pedwarn (input_location, OPT_Wpedantic,
                                 "function types not truly compatible in ISO C");
                        goto parm_done;
@@ -610,10 +705,6 @@ composite_type (tree t1, tree t2)
                && TREE_VALUE (p2) != TREE_VALUE (p1))
              {
                tree memb;
-               tree mv1 = TREE_VALUE (p1);
-               if (mv1 && mv1 != error_mark_node
-                   && TREE_CODE (mv1) != ARRAY_TYPE)
-                 mv1 = TYPE_MAIN_VARIANT (mv1);
                for (memb = TYPE_FIELDS (TREE_VALUE (p2));
                     memb; memb = DECL_CHAIN (memb))
                  {
@@ -623,15 +714,17 @@ composite_type (tree t1, tree t2)
                      mv3 = TYPE_MAIN_VARIANT (mv3);
                    if (comptypes (mv3, mv1))
                      {
-                       TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
-                                                        TREE_VALUE (p1));
+                       TREE_VALUE (n)
+                               = composite_type_internal (TREE_TYPE (memb),
+                                                          TREE_VALUE (p1),
+                                                          cache);
                        pedwarn (input_location, OPT_Wpedantic,
                                 "function types not truly compatible in ISO C");
                        goto parm_done;
                      }
                  }
              }
-           TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
+           TREE_VALUE (n) = composite_type_internal (mv1, mv2, cache);
          parm_done: ;
          }
 
@@ -643,7 +736,13 @@ composite_type (tree t1, tree t2)
     default:
       return build_type_attribute_variant (t1, attributes);
     }
+}
 
+tree
+composite_type (tree t1, tree t2)
+{
+  struct composite_cache cache = { };
+  return composite_type_internal (t1, t2, &cache);
 }
 
 /* Return the type of a conditional expression between pointers to
@@ -5566,6 +5665,11 @@ build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
     result_type = type2;
   else if (code1 == POINTER_TYPE && code2 == NULLPTR_TYPE)
     result_type = type1;
+  else if (RECORD_OR_UNION_TYPE_P (type1) && RECORD_OR_UNION_TYPE_P (type2)
+          && comptypes (TYPE_MAIN_VARIANT (type1),
+                        TYPE_MAIN_VARIANT (type2)))
+    result_type = composite_type (TYPE_MAIN_VARIANT (type1),
+                                 TYPE_MAIN_VARIANT (type2));
 
   if (!result_type)
     {

diff --git a/gcc/testsuite/gcc.dg/c23-tag-alias-6.c b/gcc/testsuite/gcc.dg/c23-tag-alias-6.c
new file mode 100644 (file)
index 0000000..586965f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-alias-6.c
@@ -0,0 +1,32 @@
+/* { dg-do run }
+ * { dg-options "-std=c23 -O2" }
+ */
+
+
+/* These tests check that a composite type for a struct
+ * can alias the original definition.  */
+
+struct foo { int (*y)[]; int x; } s;
+
+int test_foo(struct foo* a, void* b)
+{
+       a->x = 1;
+
+       struct foo { int (*y)[1]; int x; } t;
+       typeof(*(1 ? &s: &t)) *p = b;
+       p->x = 2;
+
+       return a->x;
+}
+
+
+int main()
+{
+       struct foo y;
+
+       if (2 != test_foo(&y, &y))
+               __builtin_abort();
+
+       return 0;
+}
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-alias-7.c b/gcc/testsuite/gcc.dg/c23-tag-alias-7.c
new file mode 100644 (file)
index 0000000..3316008
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-alias-7.c
@@ -0,0 +1,34 @@
+/* { dg-do run }
+ * { dg-options "-std=gnu23 -O2" }
+ */
+
+
+/* This test fails when the bitfield is not marked
+   nonaddressable in the composite type.  */
+
+struct foo { int x :3; } x;
+
+[[gnu::noinline,gnu::noipa]]
+int test_foo1(struct foo* a, void* b)
+{
+       a->x = 1;
+
+       struct foo { int x :3; } y;
+       typeof(*(1 ? &x : &y)) *z = b;
+
+       z->x = 2;
+
+       return a->x;
+}
+
+int main()
+{
+       struct foo y;
+
+       if (2 != test_foo1(&y, &y))
+               __builtin_abort();
+
+       return 0;
+}
+
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-1.c b/gcc/testsuite/gcc.dg/c23-tag-composite-1.c
new file mode 100644 (file)
index 0000000..d79c8ee
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-1.c
@@ -0,0 +1,26 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c23" } */
+
+void b(void)
+{
+       int n = 3;
+
+         extern struct f { char (*x)[3]; char (*y)[]; } q;
+       { extern struct f { char (*x)[]; char (*y)[4]; } q; 
+         _Static_assert(3 == sizeof(*q.x), "");
+         _Static_assert(4 == sizeof(*q.y), "");
+       }
+       { extern struct f { char (*x)[2]; char (*y)[]; } q; (void)q; }  /* { dg-error "conflicting" } */
+
+       { struct f { char (*x)[n]; char (*y)[3]; }* qp = &q; (void)*qp; }
+       (void)q;
+
+         static struct g { int a; char buf[n]; } *p; (void)p;
+       { static struct g { int a; char buf[3]; } *p; (void)p; }
+
+         static struct h { int a; void (*s)(char buf[n]); } *t; (void)t;
+       { static struct h { int a; void (*s)(char buf[3]); } *t; (void)t; }
+}
+
+
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-10.c b/gcc/testsuite/gcc.dg/c23-tag-composite-10.c
new file mode 100644 (file)
index 0000000..736ab2a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-10.c
@@ -0,0 +1,35 @@
+/* { dg-do run } */
+/* { dg-options "-std=c23" } */
+
+// test padding works correctly
+
+static struct fo { 
+       int a :1; 
+       long  :3; 
+       int b: 1;
+} x = { };
+
+static void foo(void* p)
+{
+       struct fo { 
+               int a :1; 
+               long  :3; 
+               int b: 1;
+       } y;
+
+       typeof(*(1 ? &x : &y))* z = p;
+       __builtin_clear_padding(z);
+}
+
+int main()
+{
+       struct fo *p = __builtin_malloc(sizeof *p);
+       __builtin_memset(p, 0xFFFF, sizeof *p);
+       foo(p);
+       p->a = 0;
+       p->b = 0;
+       if (0 != __builtin_memcmp(p, &x, sizeof *p))
+               __builtin_abort();
+       return 0;
+}
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-2.c b/gcc/testsuite/gcc.dg/c23-tag-composite-2.c
new file mode 100644 (file)
index 0000000..0b06c57
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c23" } */
+
+
+struct foo { int (*(*i)(void))[]; } x;
+
+
+void f(void)
+{ 
+       const struct foo { int (*(*i)())[3]; } y;
+       _Static_assert(3 * sizeof(int) == sizeof(*((1 ? &x : &y)->i())), "");
+}
+
+void g(struct foo { int x; } a);
+void g(const struct foo { int x; } a);
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-3.c b/gcc/testsuite/gcc.dg/c23-tag-composite-3.c
new file mode 100644 (file)
index 0000000..2c1c699
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-3.c
@@ -0,0 +1,50 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" }
+ */
+
+// bit-fields
+
+extern struct foo { int x:3; } x;
+struct foo { int x:3; } y;
+
+void f()
+{
+       extern typeof(*(1 ? &x : &y)) x;
+       &x.x;                                   /* { dg-error "bit-field" } */
+}
+
+
+void g()
+{
+       struct foo { int x:3; } z;
+       extern typeof(*(1 ? &x : &z)) x;
+       &x.x;                                   /* { dg-error "bit-field" } */
+}
+
+struct foo { int x:2; };                       /* { dg-error "redefinition" } */
+
+extern struct bar { int x:3; } a;
+
+void h()
+{
+       struct bar { signed int x:3; } b;
+       extern typeof(*(1 ? &a : &b)) a;        
+       &a.x;                                   /* { dg-error "bit-field" } */
+}
+
+void i()
+{
+       struct bar { unsigned int x:3; } c;
+       (1 ? &a : &c);                          /* { dg-error "mismatch" } */
+}
+
+struct bar { unsigned int x:3; } d;            /* { dg-error "redefinition" } */
+struct bar { signed int x:3; } e;              /* { dg-error "redefinition" } */
+
+
+struct bas { int x:2; int :0; int z:1; };
+struct bas { int x:2; int :0; int z:1; };
+struct bas { int x:2; int :1; int z:1; };      /* { dg-error "redefinition" } */
+
+
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-4.c b/gcc/testsuite/gcc.dg/c23-tag-composite-4.c
new file mode 100644 (file)
index 0000000..2cc4b06
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-4.c
@@ -0,0 +1,21 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" } 
+ */
+
+// conditional operator
+
+void f(void)
+{
+       struct foo { int x; } a;
+       struct foo { int x; } b;
+       1 ? a : b;
+}
+
+struct bar { int x; } a;
+
+void g(void)
+{
+       struct bar { int x; } b;
+       1 ? a : b;
+}
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-5.c b/gcc/testsuite/gcc.dg/c23-tag-composite-5.c
new file mode 100644 (file)
index 0000000..3e48207
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-5.c
@@ -0,0 +1,25 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" } 
+ */
+
+// anonymous structs / unions
+
+extern struct foo { int (*x)[]; struct { int y; }; } a;
+extern struct foo { int (*x)[]; struct { int y; }; } a;
+extern struct bar { int (*x)[]; union { int y; }; } b;
+extern struct bar { int (*x)[]; union { int y; }; } b;
+
+void f(void)
+{
+       struct foo { int (*x)[1]; struct { int y; }; } c;
+       extern typeof(*(1 ? &a : &c)) a;
+       a.y;
+
+       struct bar { int (*x)[1]; union { int y; }; } d;
+       extern typeof(*(1 ? &b : &d)) b;
+       b.y;
+}
+
+
+struct foo { int (*x)[]; union { int y; }; };          /* { dg-error "redefinition" } */
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-6.c b/gcc/testsuite/gcc.dg/c23-tag-composite-6.c
new file mode 100644 (file)
index 0000000..999bec6
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-6.c
@@ -0,0 +1,18 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" } 
+ */
+
+// alignment
+
+extern struct foo { char x; alignas(int) char y; } a;
+extern struct foo { char x; alignas(int) char y; } a;
+
+void f()
+{
+       extern struct foo { char x; alignas(int) char y; } b;
+       extern typeof(*(1 ? &a : &b)) a;
+       static_assert(alignof(a.y) == alignof(int));
+}
+
+
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-7.c b/gcc/testsuite/gcc.dg/c23-tag-composite-7.c
new file mode 100644 (file)
index 0000000..a097619
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-7.c
@@ -0,0 +1,20 @@
+/* { dg-do run }
+ * { dg-options "-std=c23" }
+ */
+
+// bit-fields
+
+struct foo { char (*y)[]; unsigned x:3; } x;
+
+int main()
+{
+       struct foo { char (*y)[1]; unsigned x:3; } y;
+
+       typeof(*(1 ? &x : &y)) a;
+       a.x = 8;                        /* { dg-warning "changes value" } */
+
+       if (a.x)
+               __builtin_abort();
+}
+
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-8.c b/gcc/testsuite/gcc.dg/c23-tag-composite-8.c
new file mode 100644 (file)
index 0000000..5c61119
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-8.c
@@ -0,0 +1,15 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c23" } */
+
+// adapted from PR c/11428.
+
+struct s { int m : 1; char (*y)[]; } s;
+
+int
+foo (void *q)
+{
+       struct s { int m : 1; char (*y)[1]; } t;
+       typeof(1 ? &s : &t) p = q;
+       return !p->m;
+}
+

diff --git a/gcc/testsuite/gcc.dg/c23-tag-composite-9.c b/gcc/testsuite/gcc.dg/c23-tag-composite-9.c
new file mode 100644 (file)
index 0000000..46300ee
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/c23-tag-composite-9.c
@@ -0,0 +1,19 @@
+/* { dg-do compile } */
+/* { dg-options "-std=c23 -Wc++-compat" } */
+
+// test that DECL_BIT_FIELD_TYPE is set correctly
+
+enum e { A, B, C };
+struct s { enum e m : 3; char (*y)[]; } s = { };
+
+void f(enum e);
+
+void foo ()
+{
+       struct s { enum e m : 3; char (*y)[1]; } t = { };
+       f(s.m);
+       f(t.m);
+       typeof(*(1 ? &s : &t)) u = { };
+       f(u.m);                 // should not warn
+}
+

diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-composite-1.c b/gcc/testsuite/gcc.dg/gnu23-tag-composite-1.c
new file mode 100644 (file)
index 0000000..7ffaa8a
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-composite-1.c
@@ -0,0 +1,45 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" } 
+ */
+
+// packed structs
+
+struct foo {
+       char a;
+       int b [[gnu::packed]];
+       char d;
+       int c [[gnu::packed]];
+};
+
+struct foo {
+       char a;
+       int b [[gnu::packed]];
+       char d;
+       int c [[gnu::packed]];
+};
+
+extern struct foo x;
+
+void g()
+{
+       struct foo {
+               char a;
+               int b [[gnu::packed]];
+               char d;
+               int c [[gnu::packed]];
+       };
+
+       extern struct foo y;
+       extern typeof(*(1 ? &x : &y)) x;
+}
+
+void h()
+{
+       struct foo {
+               char a;
+               int b;
+               char d;
+               int c;
+       }* z = &x;              /* { dg-error "incompatible" } */
+}
+

diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-composite-2.c b/gcc/testsuite/gcc.dg/gnu23-tag-composite-2.c
new file mode 100644 (file)
index 0000000..61f2fee
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-composite-2.c
@@ -0,0 +1,30 @@
+/* { dg-do compile }
+ * { dg-options "-std=c23" } 
+ */
+
+// attributes
+
+struct [[gnu::designated_init]] buf { char x; };
+
+struct buf s = { 0 };                          /* { dg-warning "positional" } */
+
+void j()
+{
+       struct buf { char x; } t = { 0 };
+       typeof(*(1 ? &s : &t)) u = { 0 };       /* { dg-warning "positional" } */
+       typeof(*(1 ? &t : &s)) v = { 0 };       /* { dg-warning "positional" } */
+}
+
+
+struct bar { struct buf y; };
+extern struct bar a;
+struct bar a = { { 0 } };                      /* { dg-warning "positional" } */
+
+void k()
+{
+       struct buf { char x; } t = { 0 };
+       struct bar { struct buf y; } b;
+       extern typeof(*(1 ? &a : &b)) a;
+       typeof(*(1 ? &a : &b)) c = { { 0 } };   /* { dg-warning "positional" } */
+}
+

diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-composite-3.c b/gcc/testsuite/gcc.dg/gnu23-tag-composite-3.c
new file mode 100644 (file)
index 0000000..f69e9ee
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-composite-3.c
@@ -0,0 +1,24 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -std=gnu23" } */
+
+// struct with variably-modified member
+
+struct s { char (*y)[]; } s;
+
+int
+foo ()
+{
+       int n = 10;
+       struct s { char (*y)[n]; } t;
+       typeof(*(1 ? &s : &t)) u;
+       return sizeof(*u.y);
+}
+
+int main()
+{
+       if (10 != foo())
+               __builtin_abort();
+
+       return 0;
+}
+

diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-composite-4.c b/gcc/testsuite/gcc.dg/gnu23-tag-composite-4.c
new file mode 100644 (file)
index 0000000..f3cb736
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-composite-4.c
@@ -0,0 +1,28 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -std=gnu23" } */
+
+// struct with variable size
+
+
+
+int
+foo ()
+{
+       int n = 10;
+       struct s { char buf[n]; } s;
+       {
+               int m = 10;
+               struct s { char buf[m]; } t;
+               typeof(*(1 ? &s : &t)) u;
+               return sizeof(u.buf);
+       }
+}
+
+int main()
+{
+       if (10 != foo())
+               __builtin_abort();
+
+       return 0;
+}
+

diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-composite-5.c b/gcc/testsuite/gcc.dg/gnu23-tag-composite-5.c
new file mode 100644 (file)
index 0000000..5b09ade
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-composite-5.c
@@ -0,0 +1,29 @@
+/* { dg-do compile } 
+   { dg-options "-std=c23" } */
+
+// test that structs of variable size are detected correctly
+
+void f(int n)
+{
+       struct bar { char buf[n]; };
+       struct foo { struct bar y; } a;
+       {
+               struct bar { char buf[n]; };
+               struct foo { struct bar y; } b;
+
+               typeof((1 ? &a : &b)->y) c = { 0 };     /* { dg-error "variable-sized object may not be initialized" } */
+       }
+}
+
+void g(int n)
+{
+       struct bar { char buf[n]; };
+       struct foo { struct bar y; } a;
+       {
+               struct bar { char buf[2]; };
+               struct foo { struct bar y; } b;
+
+               typeof((1 ? &a : &b)->y) c = { 0 };     // composite type is not of variable size
+       }
+}
+