The checking assertion added for PR118765
https://gcc.gnu.org/cgit/gcc/commit/?id=accbc1b90bd942aa36ac1485a21056b774ce02df
did indeed catch some case I hadn't considered. I think there
might be other cases in the C FE where we test for !TYPE_NAME
and where this might be slightly wrong, but I only touched
cases where this is now exposed by C23.
Bootstrapped and regression tested for x86_64.
Martin
c: fix checking for a tag for variably modified tagged types [PR119612]
The checking assertion added for PR118765 did not take into account
that add_decl_expr can change TYPE_NAME to a TYPE_DECL with no name
for certain cases of variably modified types. This also implies that we
might sometimes not reliably detect the absence of a tag when only
considering TYPE_NAME. This patch introduces a new helper function
c_type_tag to reliable compute the tag for a tagged types and uses it
for code where the switch to C23 may cause regressions.
PR c/119612
gcc/c/ChangeLog:
* c-tree.h (c_type_tag): Add prototype.
* c-typeck.cc (c_type_tag): New function.
(tagged_types_tu_compatible_p, composite_type_internal): Use
c_type_tag.
* c-decl.cc (c_struct_hasher::hash, previous_tag): Use c_type_tag.
testsuite/ChangeLog:
* gcc.dg/gnu23-tag-6.c: New test.
* gcc.dg/pr119612.c: New test.
diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc
index c778c7febfa..8c420f22976 100644
--- a/gcc/c/c-decl.cc
+++ b/gcc/c/c-decl.cc
@@ -659,7 +659,8 @@ c_struct_hasher::hash (tree type)
inchash::hash hstate;
hstate.add_int (TREE_CODE (type));
- hstate.add_object (TYPE_NAME (type));
+ tree tag = c_type_tag (type);
+ hstate.add_object (tag);
return hstate.end ();
}
@@ -2073,7 +2074,7 @@ static tree
previous_tag (tree type)
{
struct c_binding *b = NULL;
- tree name = TYPE_NAME (type);
+ tree name = c_type_tag (type);
if (name)
b = I_TAG_BINDING (name);
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 743ec5cbae6..2098120de29 100644
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -795,6 +795,7 @@ c_type_unspecified_p (tree t)
}
extern bool char_type_p (tree);
+extern tree c_type_tag (const_tree t);
extern tree c_objc_common_truthvalue_conversion (location_t, tree,
tree = integer_type_node);
extern tree require_complete_type (location_t, tree);
diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
index 19e79b554dc..3870e8a1558 100644
--- a/gcc/c/c-typeck.cc
+++ b/gcc/c/c-typeck.cc
@@ -577,7 +577,7 @@ c_build_functype_attribute_variant (tree ntype, tree otype,
tree attrs)
}
/* Given a type which could be a typedef name, make sure to return the
- original type. */
+ original type. See set_underlying_type. */
static const_tree
c_type_original (const_tree t)
{
@@ -591,6 +591,26 @@ c_type_original (const_tree t)
return t;
}
+/* Return the tag for a tagged type. */
+tree
+c_type_tag (const_tree t)
+{
+ gcc_assert (RECORD_OR_UNION_TYPE_P (t) || TREE_CODE (t) == ENUMERAL_TYPE);
+ const_tree orig = c_type_original (t);
+ tree name = TYPE_NAME (orig);
+ if (!name)
+ return NULL_TREE;
+ if (TREE_CODE (name) == TYPE_DECL)
+ {
+ /* A TYPE_DECL added by add_decl_expr. */
+ gcc_checking_assert (!DECL_NAME (name));
+ return NULL_TREE;
+ }
+ gcc_checking_assert (TREE_CODE (name) == IDENTIFIER_NODE);
+ return name;
+}
+
+
/* Return the composite type of two compatible types.
@@ -744,7 +764,7 @@ composite_type_internal (tree t1, tree t2, struct
composite_cache* cache)
if (flag_isoc23 && !comptypes_same_p (t1, t2))
{
/* Go to the original type to get the right tag. */
- tree tag = TYPE_NAME (c_type_original (const_cast<tree> (t1)));
+ tree tag = c_type_tag (t1);
gcc_checking_assert (COMPLETE_TYPE_P (t1) && COMPLETE_TYPE_P (t2));
gcc_checking_assert (!tag || comptypes (t1, t2));
@@ -1807,17 +1827,7 @@ tagged_types_tu_compatible_p (const_tree t1, const_tree
t2,
{
tree s1, s2;
- /* We have to verify that the tags of the types are the same. This
- is harder than it looks because this may be a typedef, so we have
- to go look at the original type. */
- t1 = c_type_original (t1);
- t2 = c_type_original (t2);
- gcc_checking_assert (!TYPE_NAME (t1)
- || TREE_CODE (TYPE_NAME (t1)) == IDENTIFIER_NODE);
- gcc_checking_assert (!TYPE_NAME (t2)
- || TREE_CODE (TYPE_NAME (t2)) == IDENTIFIER_NODE);
-
- if (TYPE_NAME (t1) != TYPE_NAME (t2))
+ if (c_type_tag (t1) != c_type_tag (t2))
return false;
/* When forming equivalence classes for TYPE_CANONICAL in C23, we treat
@@ -1828,7 +1838,7 @@ tagged_types_tu_compatible_p (const_tree t1, const_tree
t2,
/* Different types without tag are incompatible except as an anonymous
field or when forming equivalence classes for TYPE_CANONICAL. */
- if (!data->anon_field && !data->equiv && NULL_TREE == TYPE_NAME (t1))
+ if (!data->anon_field && !data->equiv && NULL_TREE == c_type_tag (t1))
return false;
if (!data->anon_field && TYPE_STUB_DECL (t1) != TYPE_STUB_DECL (t2))
diff --git a/gcc/testsuite/gcc.dg/gnu23-tag-6.c
b/gcc/testsuite/gcc.dg/gnu23-tag-6.c
new file mode 100644
index 00000000000..b28c7b3bad9
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/gnu23-tag-6.c
@@ -0,0 +1,27 @@
+/* { dg-do compile } */
+/* { dg-options "-std=gnu23" } */
+
+int f(int n)
+{
+ struct foo { struct { char (*x)[n]; }; } a;
+ {
+ struct foo { struct { char (*x)[n]; }; } b = a;
+ }
+}
+
+int g(int n)
+{
+ struct foo { struct { char (*x)[n]; }; } a;
+ {
+ struct foo { struct { char (*x)[n]; }; } *b = &a;
+ }
+}
+
+int h(int n)
+{
+ struct foo { struct { struct bar { char (*x)[n]; }* p; }; } a;
+ {
+ struct foo { struct { struct bar { char (*x)[n]; }* p; }; } *b
= &a;
+ }
+}
+
diff --git a/gcc/testsuite/gcc.dg/pr119612.c b/gcc/testsuite/gcc.dg/pr119612.c
new file mode 100644
index 00000000000..82bc5d99ce7
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr119612.c
@@ -0,0 +1,9 @@
+/* PR c/119612
+ * { dg-do compile }
+ * { dg-options "-std=gnu23" }
+ * */
+
+int n = 3;
+void a(struct { char (*p)[n]; } *); /* { dg-warning "anonymous struct" } */
+void b(struct { char (*p)[n]; } *); /* { dg-warning "anonymous struct" } */
+
