From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1062) id 11EF03857C48; Tue, 31 May 2022 11:45:31 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 11EF03857C48 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Alan Modra To: bfd-cvs@sourceware.org, gdb-cvs@sourceware.org Subject: [binutils-gdb] Import libiberty from gcc X-Act-Checkin: binutils-gdb X-Git-Author: Alan Modra X-Git-Refname: refs/heads/master X-Git-Oldrev: 42745ac5821471e8b953d24730c82c3cefa72d67 X-Git-Newrev: 2918df9368abdedffe2e2be1c93c760d85d545ab Message-Id: <20220531114531.11EF03857C48@sourceware.org> Date: Tue, 31 May 2022 11:45:31 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 31 May 2022 11:45:31 -0000 https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D2918df9368ab= dedffe2e2be1c93c760d85d545ab commit 2918df9368abdedffe2e2be1c93c760d85d545ab Author: Alan Modra Date: Tue May 31 16:59:12 2022 +0930 Import libiberty from gcc =20 PR 29200 include/ * ansidecl.h, * demangle.h: Import from gcc. libiberty/ * cp-demangle.c, * testsuite/demangle-expected: Import from gcc. Diff: --- include/ansidecl.h | 41 ---- include/demangle.h | 9 +- libiberty/cp-demangle.c | 349 ++++++++++++++++++++----------= ---- libiberty/testsuite/demangle-expected | 77 ++++++++ 4 files changed, 294 insertions(+), 182 deletions(-) diff --git a/include/ansidecl.h b/include/ansidecl.h index 46fe3ffabd9..056a03ebb6e 100644 --- a/include/ansidecl.h +++ b/include/ansidecl.h @@ -321,47 +321,6 @@ So instead we use the macro below and test it against = specific values. */ #define CONSTEXPR #endif =20 -/* C++11 adds the ability to add "override" after an implementation of a - virtual function in a subclass, to: - (A) document that this is an override of a virtual function - (B) allow the compiler to issue a warning if it isn't (e.g. a mismatch - of the type signature). - - Similarly, it allows us to add a "final" to indicate that no subclass - may subsequently override the vfunc. - - Provide OVERRIDE and FINAL as macros, allowing us to get these benefits - when compiling with C++11 support, but without requiring C++11. - - For gcc, use "-std=3Dc++11" to enable C++11 support; gcc 6 onwards enab= les - this by default (actually GNU++14). */ - -#if defined __cplusplus -# if __cplusplus >=3D 201103 - /* C++11 claims to be available: use it. Final/override were only - implemented in 4.7, though. */ -# if GCC_VERSION < 4007 -# define OVERRIDE -# define FINAL -# else -# define OVERRIDE override -# define FINAL final -# endif -# elif GCC_VERSION >=3D 4007 - /* G++ 4.7 supports __final in C++98. */ -# define OVERRIDE -# define FINAL __final -# else - /* No C++11 support; leave the macros empty. */ -# define OVERRIDE -# define FINAL -# endif -#else - /* No C++11 support; leave the macros empty. */ -# define OVERRIDE -# define FINAL -#endif - /* A macro to disable the copy constructor and assignment operator. When building with C++11 and above, the methods are explicitly deleted, causing a compile-time error if something tries to copy. diff --git a/include/demangle.h b/include/demangle.h index 402308f769f..e2aa4a971ff 100644 --- a/include/demangle.h +++ b/include/demangle.h @@ -449,7 +449,14 @@ enum demangle_component_type /* A cloned function. */ DEMANGLE_COMPONENT_CLONE, DEMANGLE_COMPONENT_NOEXCEPT, - DEMANGLE_COMPONENT_THROW_SPEC + DEMANGLE_COMPONENT_THROW_SPEC, + + DEMANGLE_COMPONENT_STRUCTURED_BINDING, + + DEMANGLE_COMPONENT_MODULE_NAME, + DEMANGLE_COMPONENT_MODULE_PARTITION, + DEMANGLE_COMPONENT_MODULE_ENTITY, + DEMANGLE_COMPONENT_MODULE_INIT, }; =20 /* Types which are only used internally. */ diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index 6dff7d28fcf..d06d80d1fee 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -425,13 +425,16 @@ is_ctor_dtor_or_conversion (struct demangle_component= *); =20 static struct demangle_component *d_encoding (struct d_info *, int); =20 -static struct demangle_component *d_name (struct d_info *); +static struct demangle_component *d_name (struct d_info *, int substable); =20 static struct demangle_component *d_nested_name (struct d_info *); =20 +static int d_maybe_module_name (struct d_info *, struct demangle_component= **); + static struct demangle_component *d_prefix (struct d_info *, int); =20 -static struct demangle_component *d_unqualified_name (struct d_info *); +static struct demangle_component *d_unqualified_name (struct d_info *, + struct demangle_component *scope, struct demangle_component *module); =20 static struct demangle_component *d_source_name (struct d_info *); =20 @@ -462,7 +465,7 @@ static struct demangle_component * d_bare_function_type (struct d_info *, int); =20 static struct demangle_component * -d_class_enum_type (struct d_info *); +d_class_enum_type (struct d_info *, int); =20 static struct demangle_component *d_array_type (struct d_info *); =20 @@ -983,6 +986,7 @@ d_make_comp (struct d_info *di, enum demangle_component= _type type, case DEMANGLE_COMPONENT_COMPOUND_NAME: case DEMANGLE_COMPONENT_VECTOR_TYPE: case DEMANGLE_COMPONENT_CLONE: + case DEMANGLE_COMPONENT_MODULE_ENTITY: if (left =3D=3D NULL || right =3D=3D NULL) return NULL; break; @@ -1020,6 +1024,8 @@ d_make_comp (struct d_info *di, enum demangle_compone= nt_type type, case DEMANGLE_COMPONENT_NULLARY: case DEMANGLE_COMPONENT_TRINARY_ARG2: case DEMANGLE_COMPONENT_TPARM_OBJ: + case DEMANGLE_COMPONENT_STRUCTURED_BINDING: + case DEMANGLE_COMPONENT_MODULE_INIT: if (left =3D=3D NULL) return NULL; break; @@ -1028,6 +1034,8 @@ d_make_comp (struct d_info *di, enum demangle_compone= nt_type type, empty. */ case DEMANGLE_COMPONENT_ARRAY_TYPE: case DEMANGLE_COMPONENT_INITIALIZER_LIST: + case DEMANGLE_COMPONENT_MODULE_NAME: + case DEMANGLE_COMPONENT_MODULE_PARTITION: if (right =3D=3D NULL) return NULL; break; @@ -1322,7 +1330,7 @@ d_encoding (struct d_info *di, int top_level) dc =3D d_special_name (di); else { - dc =3D d_name (di); + dc =3D d_name (di, 0); =20 if (!dc) /* Failed already. */; @@ -1416,80 +1424,74 @@ d_abi_tags (struct d_info *di, struct demangle_comp= onent *dc) */ =20 static struct demangle_component * -d_name (struct d_info *di) +d_name (struct d_info *di, int substable) { char peek =3D d_peek_char (di); - struct demangle_component *dc; + struct demangle_component *dc =3D NULL; + struct demangle_component *module =3D NULL; + int subst =3D 0; =20 switch (peek) { case 'N': - return d_nested_name (di); + dc =3D d_nested_name (di); + break; =20 case 'Z': - return d_local_name (di); + dc =3D d_local_name (di); + break; =20 case 'U': - return d_unqualified_name (di); + dc =3D d_unqualified_name (di, NULL, NULL); + break; =20 case 'S': { - int subst; - - if (d_peek_next_char (di) !=3D 't') - { - dc =3D d_substitution (di, 0); - subst =3D 1; - } - else + if (d_peek_next_char (di) =3D=3D 't') { d_advance (di, 2); - dc =3D d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, - d_make_name (di, "std", 3), - d_unqualified_name (di)); + dc =3D d_make_name (di, "std", 3); di->expansion +=3D 3; - subst =3D 0; } =20 - if (d_peek_char (di) !=3D 'I') - { - /* The grammar does not permit this case to occur if we - called d_substitution() above (i.e., subst =3D=3D 1). We - don't bother to check. */ - } - else + if (d_peek_char (di) =3D=3D 'S') { - /* This is , which means that we just saw - , which is a substitution - candidate if we didn't just get it from a - substitution. */ - if (! subst) + module =3D d_substitution (di, 0); + if (!module) + return NULL; + if (!(module->type =3D=3D DEMANGLE_COMPONENT_MODULE_NAME + || module->type =3D=3D DEMANGLE_COMPONENT_MODULE_PARTITION)) { - if (! d_add_substitution (di, dc)) + if (dc) return NULL; + subst =3D 1; + dc =3D module; + module =3D NULL; } - dc =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, - d_template_args (di)); } - - return dc; } + /* FALLTHROUGH */ =20 case 'L': default: - dc =3D d_unqualified_name (di); + if (!subst) + dc =3D d_unqualified_name (di, dc, module); if (d_peek_char (di) =3D=3D 'I') { /* This is , which means that we just saw , which is a substitution candidate. */ - if (! d_add_substitution (di, dc)) + if (!subst && !d_add_substitution (di, dc)) return NULL; dc =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, d_template_args (di)); + subst =3D 0; } - return dc; + break; } + if (substable && !subst && !d_add_substitution (di, dc)) + return NULL; + return dc; } =20 /* ::=3D N [] [] E @@ -1545,54 +1547,42 @@ d_nested_name (struct d_info *di) if not (in an unresolved-name). */ =20 static struct demangle_component * -d_prefix (struct d_info *di, int subst) +d_prefix (struct d_info *di, int substable) { struct demangle_component *ret =3D NULL; =20 - while (1) + for (;;) { - char peek; - enum demangle_component_type comb_type; - struct demangle_component *dc; - - peek =3D d_peek_char (di); - if (peek =3D=3D '\0') - return NULL; + char peek =3D d_peek_char (di); =20 /* The older code accepts a here, but I don't see that in the grammar. The older code does not accept a here. */ =20 - comb_type =3D DEMANGLE_COMPONENT_QUAL_NAME; - if (peek =3D=3D 'D') + if (peek =3D=3D 'D' + && (d_peek_next_char (di) =3D=3D 'T' + || d_peek_next_char (di) =3D=3D 't')) { - char peek2 =3D d_peek_next_char (di); - if (peek2 =3D=3D 'T' || peek2 =3D=3D 't') - /* Decltype. */ - dc =3D cplus_demangle_type (di); - else - /* Destructor name. */ - dc =3D d_unqualified_name (di); + /* Decltype. */ + if (ret) + return NULL; + ret =3D cplus_demangle_type (di); } - else if (IS_DIGIT (peek) - || IS_LOWER (peek) - || peek =3D=3D 'C' - || peek =3D=3D 'U' - || peek =3D=3D 'L') - dc =3D d_unqualified_name (di); - else if (peek =3D=3D 'S') - dc =3D d_substitution (di, 1); else if (peek =3D=3D 'I') { if (ret =3D=3D NULL) return NULL; - comb_type =3D DEMANGLE_COMPONENT_TEMPLATE; - dc =3D d_template_args (di); + struct demangle_component *dc =3D d_template_args (di); + if (!dc) + return NULL; + ret =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc); } else if (peek =3D=3D 'T') - dc =3D d_template_param (di); - else if (peek =3D=3D 'E') - return ret; + { + if (ret) + return NULL; + ret =3D d_template_param (di); + } else if (peek =3D=3D 'M') { /* Initializer scope for a lambda. We don't need to represent @@ -1601,38 +1591,80 @@ d_prefix (struct d_info *di, int subst) if (ret =3D=3D NULL) return NULL; d_advance (di, 1); - continue; } else + { + struct demangle_component *module =3D NULL; + if (peek =3D=3D 'S') + { + module =3D d_substitution (di, 1); + if (!module) + return NULL; + if (!(module->type =3D=3D DEMANGLE_COMPONENT_MODULE_NAME + || module->type =3D=3D DEMANGLE_COMPONENT_MODULE_PARTITION)) + { + if (ret) + return NULL; + ret =3D module; + continue; + } + } + ret =3D d_unqualified_name (di, ret, module); + } + + if (!ret) + break; + + if (d_peek_char (di) =3D=3D 'E') + break; + + if (substable && !d_add_substitution (di, ret)) return NULL; + } =20 - if (ret =3D=3D NULL) - ret =3D dc; - else - ret =3D d_make_comp (di, comb_type, ret, dc); + return ret; +} =20 - if (peek !=3D 'S' && d_peek_char (di) !=3D 'E' && subst) +static int +d_maybe_module_name (struct d_info *di, struct demangle_component **name) +{ + while (d_peek_char (di) =3D=3D 'W') + { + d_advance (di, 1); + enum demangle_component_type code =3D DEMANGLE_COMPONENT_MODULE_NAME; + if (d_peek_char (di) =3D=3D 'P') { - if (! d_add_substitution (di, ret)) - return NULL; + code =3D DEMANGLE_COMPONENT_MODULE_PARTITION; + d_advance (di, 1); } + + *name =3D d_make_comp (di, code, *name, d_source_name (di)); + if (!*name) + return 0; + if (!d_add_substitution (di, *name)) + return 0; } + return 1; } =20 -/* ::=3D - ::=3D - ::=3D - ::=3D =20 - - ::=3D L +/* ::=3D [] [] + ::=3D [] [] + ::=3D [] [] + ::=3D [] [] + ::=3D [] DC + E [] + ::=3D L [] */ =20 static struct demangle_component * -d_unqualified_name (struct d_info *di) +d_unqualified_name (struct d_info *di, struct demangle_component *scope, + struct demangle_component *module) { struct demangle_component *ret; char peek; =20 + if (!d_maybe_module_name (di, &module)) + return NULL; + peek =3D d_peek_char (di); if (IS_DIGIT (peek)) ret =3D d_source_name (di); @@ -1655,6 +1687,28 @@ d_unqualified_name (struct d_info *di) d_source_name (di)); } } + else if (peek =3D=3D 'D' && d_peek_next_char (di) =3D=3D 'C') + { + // structured binding + d_advance (di, 2); + struct demangle_component *prev =3D NULL; + do + { + struct demangle_component *next =3D=20 + d_make_comp (di, DEMANGLE_COMPONENT_STRUCTURED_BINDING, + d_source_name (di), NULL); + if (prev) + d_right (prev) =3D next; + else + ret =3D next; + prev =3D next; + } + while (prev && d_peek_char (di) !=3D 'E'); + if (prev) + d_advance (di, 1); + else + ret =3D NULL; + } else if (peek =3D=3D 'C' || peek =3D=3D 'D') ret =3D d_ctor_dtor_name (di); else if (peek =3D=3D 'L') @@ -1684,8 +1738,13 @@ d_unqualified_name (struct d_info *di) else return NULL; =20 + if (module) + ret =3D d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module= ); if (d_peek_char (di) =3D=3D 'B') ret =3D d_abi_tags (di, ret); + if (scope) + ret =3D d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret); + return ret; } =20 @@ -2126,11 +2185,11 @@ d_special_name (struct d_info *di) =20 case 'H': return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, - d_name (di), NULL); + d_name (di, 0), NULL); =20 case 'W': return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, - d_name (di), NULL); + d_name (di, 0), NULL); =20 case 'A': return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ, @@ -2146,11 +2205,11 @@ d_special_name (struct d_info *di) { case 'V': return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, - d_name (di), NULL); + d_name (di, 0), NULL); =20 case 'R': { - struct demangle_component *name =3D d_name (di); + struct demangle_component *name =3D d_name (di, 0); return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name, d_number_component (di)); } @@ -2159,6 +2218,14 @@ d_special_name (struct d_info *di) return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, d_encoding (di, 0), NULL); =20 + case 'I': + { + struct demangle_component *module =3D NULL; + if (!d_maybe_module_name (di, &module) || !module) + return NULL; + return d_make_comp (di, DEMANGLE_COMPONENT_MODULE_INIT, + module, NULL); + } case 'T': switch (d_next_char (di)) { @@ -2481,13 +2548,6 @@ cplus_demangle_type (struct d_info *di) ret =3D d_function_type (di); break; =20 - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - case 'N': - case 'Z': - ret =3D d_class_enum_type (di); - break; - case 'A': ret =3D d_array_type (di); break; @@ -2558,39 +2618,6 @@ cplus_demangle_type (struct d_info *di) } break; =20 - case 'S': - /* If this is a special substitution, then it is the start of - . */ - { - char peek_next; - - peek_next =3D d_peek_next_char (di); - if (IS_DIGIT (peek_next) - || peek_next =3D=3D '_' - || IS_UPPER (peek_next)) - { - ret =3D d_substitution (di, 0); - /* The substituted name may have been a template name and - may be followed by tepmlate args. */ - if (d_peek_char (di) =3D=3D 'I') - ret =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, - d_template_args (di)); - else - can_subst =3D 0; - } - else - { - ret =3D d_class_enum_type (di); - /* If the substitution was a complete type, then it is not - a new substitution candidate. However, if the - substitution was followed by template arguments, then - the whole thing is a substitution candidate. */ - if (ret !=3D NULL && ret->type =3D=3D DEMANGLE_COMPONENT_SUB_STD) - can_subst =3D 0; - } - } - break; - case 'O': d_advance (di, 1); ret =3D d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE, @@ -2731,7 +2758,7 @@ cplus_demangle_type (struct d_info *di) break; =20 default: - return NULL; + return d_class_enum_type (di, 1); } =20 if (can_subst) @@ -3004,9 +3031,9 @@ d_bare_function_type (struct d_info *di, int has_retu= rn_type) /* ::=3D */ =20 static struct demangle_component * -d_class_enum_type (struct d_info *di) +d_class_enum_type (struct d_info *di, int substable) { - return d_name (di); + return d_name (di, substable); } =20 /* ::=3D A <(positive dimension) number> _ <(element) type> @@ -3335,11 +3362,11 @@ d_unresolved_name (struct d_info *di) } else type =3D cplus_demangle_type (di); - name =3D d_unqualified_name (di); + name =3D d_unqualified_name (di, type, NULL); if (d_peek_char (di) =3D=3D 'I') name =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, d_template_args (di)); - return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); + return name; } =20 /* ::=3D <(unary) operator-name> @@ -3408,7 +3435,7 @@ d_expression_1 (struct d_info *di) /* operator-function-id, i.e. operator+(t). */ d_advance (di, 2); =20 - name =3D d_unqualified_name (di); + name =3D d_unqualified_name (di, NULL, NULL); if (name =3D=3D NULL) return NULL; if (d_peek_char (di) =3D=3D 'I') @@ -3516,7 +3543,7 @@ d_expression_1 (struct d_info *di) /* fold-expression. */ left =3D d_operator_name (di); else if (!strcmp (code, "di")) - left =3D d_unqualified_name (di); + left =3D d_unqualified_name (di, NULL, NULL); else left =3D d_expression_1 (di); if (!strcmp (code, "cl")) @@ -3534,7 +3561,7 @@ d_expression_1 (struct d_info *di) d_unqualified_name rather than d_expression_1 here for old mangled names that didn't add 'on' before operator names. */ - right =3D d_unqualified_name (di); + right =3D d_unqualified_name (di, NULL, NULL); if (d_peek_char (di) =3D=3D 'I') right =3D d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, right, d_template_args (di)); @@ -3744,7 +3771,7 @@ d_local_name (struct d_info *di) return NULL; } =20 - name =3D d_name (di); + name =3D d_name (di, 0); =20 if (name /* Lambdas and unnamed types have internal discriminators @@ -4179,6 +4206,10 @@ 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_STRUCTURED_BINDING: + case DEMANGLE_COMPONENT_MODULE_NAME: + case DEMANGLE_COMPONENT_MODULE_PARTITION: + case DEMANGLE_COMPONENT_MODULE_INIT: break; =20 case DEMANGLE_COMPONENT_TEMPLATE: @@ -4284,6 +4315,7 @@ d_count_templates_scopes (struct d_print_info *dpi, =20 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + case DEMANGLE_COMPONENT_MODULE_ENTITY: d_count_templates_scopes (dpi, d_left (dc)); break; =20 @@ -4850,6 +4882,38 @@ d_print_comp_inner (struct d_print_info *dpi, int op= tions, d_append_char (dpi, ']'); return; =20 + case DEMANGLE_COMPONENT_STRUCTURED_BINDING: + d_append_char (dpi, '['); + for (;;) + { + d_print_comp (dpi, options, d_left (dc)); + dc =3D d_right (dc); + if (!dc) + break; + d_append_string (dpi, ", "); + } + d_append_char (dpi, ']'); + return; + + case DEMANGLE_COMPONENT_MODULE_ENTITY: + d_print_comp (dpi, options, d_left (dc)); + d_append_char (dpi, '@'); + d_print_comp (dpi, options, d_right (dc)); + return; + + case DEMANGLE_COMPONENT_MODULE_NAME: + case DEMANGLE_COMPONENT_MODULE_PARTITION: + { + if (d_left (dc)) + d_print_comp (dpi, options, d_left (dc)); + char c =3D dc->type =3D=3D DEMANGLE_COMPONENT_MODULE_PARTITION + ? ':' : d_left (dc) ? '.' : 0; + if (c) + d_append_char (dpi, c); + d_print_comp (dpi, options, d_right (dc)); + } + return; + case DEMANGLE_COMPONENT_QUAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME: d_print_comp (dpi, options, d_left (dc)); @@ -5081,6 +5145,11 @@ d_print_comp_inner (struct d_print_info *dpi, int op= tions, d_print_comp (dpi, options, dc->u.s_dtor.name); return; =20 + case DEMANGLE_COMPONENT_MODULE_INIT: + d_append_string (dpi, "initializer for module "); + d_print_comp (dpi, options, d_left (dc)); + return; + case DEMANGLE_COMPONENT_VTABLE: d_append_string (dpi, "vtable for "); d_print_comp (dpi, options, d_left (dc)); diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/de= mangle-expected index de54ad73cc8..351af349219 100644 --- a/libiberty/testsuite/demangle-expected +++ b/libiberty/testsuite/demangle-expected @@ -1493,3 +1493,80 @@ decltype ({parm#1}.A::x) f(A) =20 _Z2f6IP1AEDtptfp_gssr1A1BE1xET_ decltype ({parm#1}->(::A::B::x)) f6(A*) + +# Structured Bindings +_ZDC1a1bE +[a, b] + +_ZNStDC1aEE +std::[a] + +_ZN3NMSDC1aEE +NMS::[a] + +# Modules +_ZN5Outer5InnerW3FOO2FnERNS0_1XE +Outer::Inner::Fn@FOO(Outer::Inner::X&) + +_ZN5OuterW3FOO5Inner2FnERNS1_1XE +Outer::Inner@FOO::Fn(Outer::Inner@FOO::X&) + +_ZN4Quux4TotoW3FooW3Bar3BazEPNS0_S2_5PlughE +Quux::Toto::Baz@Foo.Bar(Quux::Toto::Plugh@Foo.Bar*) + +_ZW6Module1fNS_1a1bENS0_1cE +f@Module(a@Module::b, a@Module::c) + +_ZN3BobW3FOOW3BAR3BarEPS1_1APNS_S1_1BE +Bob::Bar@FOO.BAR(A@FOO.BAR*, Bob::B@FOO.BAR*) + +_ZW3FOOW3BAR3FooPS0_1APN3BobS0_1BE +Foo@FOO.BAR(A@FOO.BAR*, Bob::B@FOO.BAR*) + +_ZN3BobW3FOOW3BAZ3FooEPS0_W3BAR1APNS_S2_1BE +Bob::Foo@FOO.BAZ(A@FOO.BAR*, Bob::B@FOO.BAR*) + +_ZW3FOOW3BAZ3BarPS_W3BAR1APN3BobS1_1BE +Bar@FOO.BAZ(A@FOO.BAR*, Bob::B@FOO.BAR*) + +_ZNW3FOO3TPLIS_3OneE1MEPS1_ +TPL@FOO::M(One@FOO*) + +_ZNW3FOO3TPLIS_3OneE1NIS_3TwoEEvPS1_PT_ +void TPL@FOO::N(One@FOO*, Two@FOO*) + +_ZN3NMSW3FOO3TPLINS_S0_3OneEE1MEPS2_ +NMS::TPL@FOO::M(NMS::One@FOO*) + +_ZN3NMSW3FOO3TPLINS_S0_3OneEE1NINS_S0_3TwoEEEvPS2_PT_ +void NMS::TPL@FOO::N(NMS::One@FOO*, NMS::Two@F= OO*) + +_ZNStW3STD9allocatorIiE1MEPi +std::allocator@STD::M(int*) + +_ZNStW3STD9allocatorIiE1NIfEEPT_Pi +float* std::allocator@STD::N(int*) + +_ZNStW3STD9allocatorI4PoohE1MEPS1_ +std::allocator@STD::M(Pooh*) + +_ZNStW3STD9allocatorI4PoohE1NI6PigletEEPT_PS1_ +Piglet* std::allocator@STD::N(Pooh*) + +_ZW3FooDC1a1bE +[a, b]@Foo + +_ZN1NW3FooDC1a1bEE +N::[a, b]@Foo + +_ZN3NMSW3MOD3FooB3ABIEv +NMS::Foo@MOD[abi:ABI]() + +_ZGIW3Foo +initializer for module Foo + +_ZGIW3FooW3Bar +initializer for module Foo.Bar + +_ZGIW3FooWP3BarW3Baz +initializer for module Foo:Bar.Baz