On Sun, Aug 10, 2025 at 03:33:26PM -0700, Jason Merrill wrote: > On 8/8/25 9:46 AM, Nathaniel Shead wrote: > > Bootstrapped and regtested on x86_64-pc-linux-gnu, OK for trunk? > > > > Alternatively, if preferred I also experimented with a patch that > > cached the property as a TYPE_LANG_FLAG for ENUMERAL_TYPEs, which > > was possibly slightly neater at the cost of using up a flag bit. > > I've attached this alternative patch as well. > > > > Let me know if you have any suggestions on the ABI front as well; I > > wasn't able to find any open issue for this on the github, but I'm happy > > to make an issue if you like. > > Please do. I might suggest a production > > <unnamed-enum> ::= UE </underlying/ type> </enumerator/ source-name> > > to distinguish these types from actual named types and reduce potential > collisions. > > Apart from mangling the patch looks fine.
Thanks, here's an updated version using the mangling proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/205. Bootstrapped and regtested on x86_64-pc-linux-gnu, OK for trunk? -- >8 -- We currently list P2115R0 as implemented, but only the modules changes had been done. This patch implements the linkage changes so that unnamed unscoped enums will use the name of the first enumerator for linkage purposes. This is (strictly speaking) a breaking change, as code that previously relied on unnamed enumerations being internal linkage may have overloads using those types become exposed and clash with other functions in a different TU that have been similarly exposed. As such this feature is only implemented for C++20. No ABI flag warning is provided, partly because C++20 is still an experimental standard, but also because any affected functions could not have been part of an ABI until this change anyway. A number of testcases that are testing for behaviour of no-linkage types are adjusted to use an enumeration with no values, so that the pre-C++20 and post-C++20 behaviour is equivalently tested. In terms of implementation, I had originally considered adjusting the DECL_NAME of the enum, as with 'name_unnamed_type', but this ended up being more complicated as it had unwanted interactions with the existing modules streaming and with name lookup and diagnostic messages. This patch instead uses a new function to derive this case. The standard says that ([dcl.enum] p11) such an enum "...is denoted, for linkage purposes, by its underlying type and its first enumerator", so we need to add a new mangling production as well to handle this. PR c++/120503 PR c++/120824 gcc/cp/ChangeLog: * cp-tree.h (TYPE_UNNAMED_P): Adjust for enums with enumerators for linkage purposes. (enum_with_enumerator_for_linkage_p): Declare. * decl.cc (name_unnamed_type): Adjust assertions to handle enums with enumerators for linkage purposes. (grokdeclarator): Use a typedef name for enums with enumerators for linkage purposes. (enum_with_enumerator_for_linkage_p): New function. (finish_enum_value_list): Reset type linkage for enums with enumerators for linkage purposes. * mangle.cc (write_unnamed_enum_name): New function. (write_unqualified_name): Handle enums with enumerators for linkage purposes. * tree.cc (decl_linkage): Fixup unnamed enums. gcc/testsuite/ChangeLog: * g++.dg/abi/mangle32.C: Remove enumerator list. * g++.dg/cpp0x/linkage2.C: Likewise. * g++.dg/ext/vector26.C: Likewise. * g++.dg/other/anon3.C: Likewise. * g++.dg/abi/mangle82.C: New test. * g++.dg/modules/enum-15_a.C: New test. * g++.dg/modules/enum-15_b.C: New test. include/ChangeLog: * demangle.h (enum demangle_component_type): Add enumeration DEMANGLE_COMPONENT_UNNAMED_ENUM. libiberty/ChangeLog: * cp-demangle.c (d_unnamed_enum): New function. (d_unqualified_name): Call it. (cplus_demangle_type): Handle unscoped unnamed types (Ue, Ul, etc.) (d_count_templates_scopes): Handle unnamed enums. (d_find_pack): Likewise. (d_print_comp_inner): Print unnamed enums. * testsuite/demangle-expected: Add tests. gcc/testsuite/ChangeLog: * g++.dg/abi/mangle32.C: Adjust for unnamed enums with enumerators sometimes having linkage. * g++.dg/cpp0x/linkage2.C: Likewise. * g++.dg/ext/vector26.C: Likewise. * g++.dg/other/anon3.C: Likewise. * g++.dg/abi/mangle82.C: New test. * g++.dg/modules/enum-15_a.C: New test. * g++.dg/modules/enum-15_b.C: New test. Signed-off-by: Nathaniel Shead <nathanielosh...@gmail.com> Reviewed-by: Jason Merrill <ja...@redhat.com> --- gcc/cp/cp-tree.h | 4 +- gcc/cp/decl.cc | 28 +++++++++-- gcc/cp/mangle.cc | 16 +++++- gcc/cp/tree.cc | 4 +- gcc/testsuite/g++.dg/abi/mangle32.C | 4 +- gcc/testsuite/g++.dg/abi/mangle82.C | 29 +++++++++++ gcc/testsuite/g++.dg/cpp0x/linkage2.C | 6 +-- gcc/testsuite/g++.dg/ext/vector26.C | 2 +- gcc/testsuite/g++.dg/modules/enum-15_a.C | 10 ++++ gcc/testsuite/g++.dg/modules/enum-15_b.C | 18 +++++++ gcc/testsuite/g++.dg/other/anon3.C | 2 +- include/demangle.h | 2 + libiberty/cp-demangle.c | 63 +++++++++++++++++++++--- libiberty/testsuite/demangle-expected | 7 +++ 14 files changed, 174 insertions(+), 21 deletions(-) create mode 100644 gcc/testsuite/g++.dg/abi/mangle82.C create mode 100644 gcc/testsuite/g++.dg/modules/enum-15_a.C create mode 100644 gcc/testsuite/g++.dg/modules/enum-15_b.C diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index fb8e0d8d98e..090f08a78fc 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -2330,7 +2330,8 @@ enum languages { lang_c, lang_cplusplus }; /* Nonzero if NODE, a TYPE, has no name for linkage purposes. */ #define TYPE_UNNAMED_P(NODE) \ (TYPE_ANON_P (NODE) \ - && !IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE))) + && !IDENTIFIER_LAMBDA_P (TYPE_LINKAGE_IDENTIFIER (NODE)) \ + && !enum_with_enumerator_for_linkage_p (NODE)) /* The _DECL for this _TYPE. */ #define TYPE_MAIN_DECL(NODE) (TYPE_STUB_DECL (TYPE_MAIN_VARIANT (NODE))) @@ -7298,6 +7299,7 @@ extern tree xref_tag (tag_types, tree, bool tpl_header_p = false); extern void xref_basetypes (tree, tree); extern tree start_enum (tree, tree, tree, tree, bool, bool *); +extern bool enum_with_enumerator_for_linkage_p (tree); extern void finish_enum_value_list (tree); extern void finish_enum (tree); extern tree build_enumerator (tree, tree, tree, tree, location_t); diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index cb3ebfff429..2f5c4646bb4 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -12677,7 +12677,8 @@ mark_inline_variable (tree decl, location_t loc) void name_unnamed_type (tree type, tree decl) { - gcc_assert (TYPE_UNNAMED_P (type)); + gcc_assert (TYPE_UNNAMED_P (type) + || enum_with_enumerator_for_linkage_p (type)); /* Replace the anonymous decl with the real decl. Be careful not to rename other typedefs (such as the self-reference) of type. */ @@ -12700,7 +12701,8 @@ name_unnamed_type (tree type, tree decl) /* Check that our job is done, and that it would fail if we attempted to do it again. */ - gcc_assert (!TYPE_UNNAMED_P (type)); + gcc_assert (!TYPE_UNNAMED_P (type) + && !enum_with_enumerator_for_linkage_p (type)); } /* Check that decltype(auto) was well-formed: only plain decltype(auto) @@ -14950,7 +14952,10 @@ grokdeclarator (const cp_declarator *declarator, && unqualified_id && TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL - && TYPE_UNNAMED_P (type) + && (TYPE_UNNAMED_P (type) + /* An enum may have previously used an enumerator for linkage + purposes, but we want the typedef name to take priority. */ + || enum_with_enumerator_for_linkage_p (type)) && declspecs->type_definition_p && attributes_naming_typedef_ok (*attrlist) && cp_type_quals (type) == TYPE_UNQUALIFIED) @@ -17793,6 +17798,18 @@ start_enum (tree name, tree enumtype, tree underlying_type, return enumtype; } +/* Returns true if TYPE is an enum that uses an enumerator name for + linkage purposes. */ + +bool +enum_with_enumerator_for_linkage_p (tree type) +{ + return (cxx_dialect >= cxx20 + && UNSCOPED_ENUM_P (type) + && TYPE_ANON_P (type) + && TYPE_VALUES (type)); +} + /* After processing and defining all the values of an enumeration type, install their decls in the enumeration type. ENUMTYPE is the type object. */ @@ -18023,6 +18040,11 @@ finish_enum_value_list (tree enumtype) fixup_type_variants (current_class_type); } + /* P2115: An unnamed enum uses the name of its first enumerator for + linkage purposes; reset the type linkage if that is the case. */ + if (enum_with_enumerator_for_linkage_p (enumtype)) + reset_type_linkage (enumtype); + /* Finish debugging output for this type. */ rest_of_type_compilation (enumtype, namespace_bindings_p ()); diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc index 13d5dedebd2..4128e053fc8 100644 --- a/gcc/cp/mangle.cc +++ b/gcc/cp/mangle.cc @@ -203,6 +203,7 @@ static void write_conversion_operator_name (const tree); static void write_source_name (tree); static void write_literal_operator_name (tree); static void write_unnamed_type_name (const tree); +static void write_unnamed_enum_name (const tree); static void write_closure_type_name (const tree); static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *, const unsigned int); @@ -1591,7 +1592,9 @@ write_unqualified_name (tree decl) tree type = TREE_TYPE (decl); if (TREE_CODE (decl) == TYPE_DECL - && TYPE_UNNAMED_P (type)) + && enum_with_enumerator_for_linkage_p (type)) + write_unnamed_enum_name (type); + else if (TREE_CODE (decl) == TYPE_DECL && TYPE_UNNAMED_P (type)) write_unnamed_type_name (type); else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (type)) write_closure_type_name (type); @@ -1820,6 +1823,17 @@ write_unnamed_type_name (const tree type) write_compact_number (discriminator); } +/* <unnamed-enum-name> ::= Ue <underlying type> <enumerator source-name> */ + +static void +write_unnamed_enum_name (const tree type) +{ + MANGLE_TRACE_TREE ("unnamed-enum-name", type); + write_string ("Ue"); + write_type (ENUM_UNDERLYING_TYPE (type)); + write_source_name (DECL_NAME (TREE_VALUE (TYPE_VALUES (type)))); +} + /* ABI issue #47: if a function template parameter is not "natural" for its argument we must mangle the parameter. */ diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index d56d73fe217..59d626c86d5 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -6394,8 +6394,8 @@ decl_linkage (tree decl) if (NAMESPACE_SCOPE_P (decl) && (!DECL_NAME (decl) || IDENTIFIER_ANON_P (DECL_NAME (decl)))) { - if (TREE_CODE (decl) == TYPE_DECL && !TYPE_ANON_P (TREE_TYPE (decl))) - /* This entity has a typedef name for linkage purposes. */; + if (TREE_CODE (decl) == TYPE_DECL && !TYPE_UNNAMED_P (TREE_TYPE (decl))) + /* This entity has a name for linkage purposes. */; else if (DECL_DECOMPOSITION_P (decl) && DECL_DECOMP_IS_BASE (decl)) /* Namespace-scope structured bindings can have linkage. */; else if (TREE_CODE (decl) == NAMESPACE_DECL && cxx_dialect >= cxx11) diff --git a/gcc/testsuite/g++.dg/abi/mangle32.C b/gcc/testsuite/g++.dg/abi/mangle32.C index 4c5b33b8b4d..edb542e28c1 100644 --- a/gcc/testsuite/g++.dg/abi/mangle32.C +++ b/gcc/testsuite/g++.dg/abi/mangle32.C @@ -15,7 +15,7 @@ void f(B) { } struct C { typedef struct { }* D; - typedef enum { e }* E; + typedef enum { }* E; }; // { dg-final { scan-assembler "_Z2g1PN1CUt_E" } } @@ -31,7 +31,7 @@ void h2(T t) { } inline void j() { - typedef enum { f }* F; + typedef enum { }* F; // { dg-final { scan-assembler "_Z2h1IPZ1jvEUt_EvT_" } } h1(F()); typedef struct { }* G; diff --git a/gcc/testsuite/g++.dg/abi/mangle82.C b/gcc/testsuite/g++.dg/abi/mangle82.C new file mode 100644 index 00000000000..42df1b979b9 --- /dev/null +++ b/gcc/testsuite/g++.dg/abi/mangle82.C @@ -0,0 +1,29 @@ +// PR c++/120503 +// Implement P2115r0 "merging definitions of unnamed unscoped enums" +// { dg-do compile { target c++14 } } + +template<auto V> int Frob () { return int (V); } + +enum { A = (unsigned int)12345, B = 0 }; +template int Frob<A> (); +template int Frob<B> (); +// { dg-final { scan-assembler {_Z4FrobITnDaLUej1A12345EEiv:} { target c++20 } } } +// { dg-final { scan-assembler {_Z4FrobITnDaL8._anon_012345EEiv:} { target c++17_down } } } +// { dg-final { scan-assembler {_Z4FrobITnDaLUej1A0EEiv:} { target c++20 } } } +// { dg-final { scan-assembler {_Z4FrobITnDaL8._anon_00EEiv:} { target c++17_down } } } + +enum { C = 5 } typedef X; +template int Frob<C> (); +// typedef name 'X' should take precedence +// { dg-final { scan-assembler {_Z4FrobITnDaL1X5EEiv:} } } + +typedef enum : long long { D = 8 }* Y; +template int Frob<D> (); +// but 'Y' is not a typedef name here +// { dg-final { scan-assembler {_Z4FrobITnDaLUex1D8EEiv:} { target c++20 } } } +// { dg-final { scan-assembler {_Z4FrobITnDaL8._anon_28EEiv:} { target c++17_down } } } + +enum : int { E }; +void foo(decltype(E), decltype(E)) {} +// { dg-final { scan-assembler {_Z3fooUei1ES_:} { target c++20 } } } +// { dg-final { scan-assembler {_Z3foo8._anon_3S_:} { target c++17_down } } } diff --git a/gcc/testsuite/g++.dg/cpp0x/linkage2.C b/gcc/testsuite/g++.dg/cpp0x/linkage2.C index 34a36c45a58..0ec2cec8a99 100644 --- a/gcc/testsuite/g++.dg/cpp0x/linkage2.C +++ b/gcc/testsuite/g++.dg/cpp0x/linkage2.C @@ -16,9 +16,9 @@ template <typename T> struct B { template <typename T> T B<T>::t2 = { }; -enum { E1 } e1; // OK, defined -extern enum { E2 } e2; // { dg-error "never defined" } -extern "C" enum { E3 } e3; // OK, extern "C" +enum { } e1; // OK, defined +extern enum { } e2; // { dg-error "never defined" } +extern "C" enum { } e3; // OK, extern "C" void f() { struct A { int x; }; // no linkage diff --git a/gcc/testsuite/g++.dg/ext/vector26.C b/gcc/testsuite/g++.dg/ext/vector26.C index 1d7a1e47160..95cae393fb5 100644 --- a/gcc/testsuite/g++.dg/ext/vector26.C +++ b/gcc/testsuite/g++.dg/ext/vector26.C @@ -3,7 +3,7 @@ // gets internal linkage. // { dg-options "-mmmx" { target { { i?86-*-* x86_64-*-* } && ilp32 } } } */ -typedef enum { e } T __attribute__((vector_size(8))); +typedef enum { } T __attribute__((vector_size(8))); static void foo(T t) {} void bar (T t) {} // { dg-error "no linkage" "" { target { ! c++11 } } } // { dg-final { scan-assembler-not "globl\[ \t]*_Z3bar" { target c++11 } } } diff --git a/gcc/testsuite/g++.dg/modules/enum-15_a.C b/gcc/testsuite/g++.dg/modules/enum-15_a.C new file mode 100644 index 00000000000..e59a73a09e9 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/enum-15_a.C @@ -0,0 +1,10 @@ +// PR c++/120824 +// { dg-additional-options "-fmodules -Wno-global-module -std=c++20" } +// { dg-module-cmi M } + +module; +enum { E }; +enum { F }; +export module M; +export using ::E; +export using ::F; diff --git a/gcc/testsuite/g++.dg/modules/enum-15_b.C b/gcc/testsuite/g++.dg/modules/enum-15_b.C new file mode 100644 index 00000000000..43d7865e749 --- /dev/null +++ b/gcc/testsuite/g++.dg/modules/enum-15_b.C @@ -0,0 +1,18 @@ +// PR c++/120824 +// { dg-additional-options "-fmodules -Wno-global-module -std=c++20" } +// { dg-module-cmi !bad } + +module; +enum { E }; +namespace { + enum { G }; // { dg-message "internal" } +} +export module bad; +import M; +inline void ok() { + auto a = E; + auto b = F; +} +inline void err() { // { dg-error "TU-local" } + auto c = G; +} diff --git a/gcc/testsuite/g++.dg/other/anon3.C b/gcc/testsuite/g++.dg/other/anon3.C index d33eb413ccf..36bf2d64520 100644 --- a/gcc/testsuite/g++.dg/other/anon3.C +++ b/gcc/testsuite/g++.dg/other/anon3.C @@ -4,4 +4,4 @@ // { dg-do compile } -enum { a = 3 } x; // { dg-warning "unnamed type" "" { target { ! c++11 } } } +enum { } x; // { dg-warning "unnamed type" "" { target { ! c++11 } } } diff --git a/include/demangle.h b/include/demangle.h index 34e760ab65d..a22e69858ce 100644 --- a/include/demangle.h +++ b/include/demangle.h @@ -435,6 +435,8 @@ enum demangle_component_type DEMANGLE_COMPONENT_DEFAULT_ARG, /* An unnamed type. */ DEMANGLE_COMPONENT_UNNAMED_TYPE, + /* An unnamed enum. */ + DEMANGLE_COMPONENT_UNNAMED_ENUM, /* A transactional clone. This has one subtree, the encoding for which it is providing alternative linkage. */ DEMANGLE_COMPONENT_TRANSACTION_CLONE, diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index 1922046a62e..4fe6a2b9e69 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -499,6 +499,8 @@ static struct demangle_component *d_lambda (struct d_info *); static struct demangle_component *d_unnamed_type (struct d_info *); +static struct demangle_component *d_unnamed_enum (struct d_info *); + static struct demangle_component * d_clone_suffix (struct d_info *, struct demangle_component *); @@ -1799,6 +1801,9 @@ d_unqualified_name (struct d_info *di, struct demangle_component *scope, { switch (d_peek_next_char (di)) { + case 'e': + ret = d_unnamed_enum (di); + break; case 'l': ret = d_lambda (di); break; @@ -2728,13 +2733,20 @@ cplus_demangle_type (struct d_info *di) break; case 'U': - d_advance (di, 1); - ret = d_source_name (di); - if (d_peek_char (di) == 'I') - ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, - d_template_args (di)); - ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, - cplus_demangle_type (di), ret); + peek = d_peek_next_char (di); + if (IS_DIGIT (peek)) + { + d_advance (di, 1); + ret = d_source_name (di); + if (d_peek_char (di) == 'I') + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, + d_template_args (di)); + ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, + cplus_demangle_type (di), ret); + } + else + /* Could be a closure type or an unnamed enum. */ + ret = d_unqualified_name (di, NULL, NULL); break; case 'D': @@ -4090,6 +4102,33 @@ d_unnamed_type (struct d_info *di) return ret; } +/* <unnamed-enum-name> ::= Ue <underlying type> <enumerator source-name> */ + +static struct demangle_component * +d_unnamed_enum (struct d_info *di) +{ + if (! d_check_char (di, 'U')) + return NULL; + if (! d_check_char (di, 'e')) + return NULL; + + struct demangle_component *underlying = cplus_demangle_type (di); + struct demangle_component *name = d_source_name (di); + + struct demangle_component *ret = d_make_empty (di); + if (ret) + { + ret->type = DEMANGLE_COMPONENT_UNNAMED_ENUM; + d_left (ret) = underlying; + d_right (ret) = name; + } + + if (! d_add_substitution (di, ret)) + return NULL; + + return ret; +} + /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]* */ @@ -4396,6 +4435,7 @@ d_count_templates_scopes (struct d_print_info *dpi, case DEMANGLE_COMPONENT_CHARACTER: case DEMANGLE_COMPONENT_NUMBER: case DEMANGLE_COMPONENT_UNNAMED_TYPE: + case DEMANGLE_COMPONENT_UNNAMED_ENUM: case DEMANGLE_COMPONENT_STRUCTURED_BINDING: case DEMANGLE_COMPONENT_MODULE_NAME: case DEMANGLE_COMPONENT_MODULE_PARTITION: @@ -4780,6 +4820,7 @@ d_find_pack (struct d_print_info *dpi, case DEMANGLE_COMPONENT_CHARACTER: case DEMANGLE_COMPONENT_FUNCTION_PARAM: case DEMANGLE_COMPONENT_UNNAMED_TYPE: + case DEMANGLE_COMPONENT_UNNAMED_ENUM: case DEMANGLE_COMPONENT_DEFAULT_ARG: case DEMANGLE_COMPONENT_NUMBER: return NULL; @@ -6258,6 +6299,14 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_append_char (dpi, '}'); return; + case DEMANGLE_COMPONENT_UNNAMED_ENUM: + d_append_string (dpi, "{enum:"); + d_print_comp (dpi, options, d_left (dc)); + d_append_string (dpi, "{"); + d_print_comp (dpi, options, d_right (dc)); + d_append_string (dpi, "}}"); + return; + case DEMANGLE_COMPONENT_CLONE: d_print_comp (dpi, options, d_left (dc)); d_append_string (dpi, " [clone "); diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected index 0f7b97a6d0a..e5cd8ec8a77 100644 --- a/libiberty/testsuite/demangle-expected +++ b/libiberty/testsuite/demangle-expected @@ -1709,3 +1709,10 @@ void S::bar<5, int>(this S, int) _ZNH1S3bazERKS_ S::baz(this S const&) + +_Z3fooUlvE_ +foo({lambda()#1}) + +# P2115R0 unnamed enums +_Z3fooUei1ES_ +foo({enum:int{E}}, {enum:int{E}}) -- 2.47.0
