diff options
Diffstat (limited to 'libiberty')
| -rw-r--r-- | libiberty/cp-demangle.c | 349 | ||||
| -rw-r--r-- | libiberty/testsuite/demangle-expected | 77 |
2 files changed, 286 insertions, 140 deletions
diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index 6dff7d2..d06d80d 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -425,13 +425,16 @@ is_ctor_dtor_or_conversion (struct demangle_component *); static struct demangle_component *d_encoding (struct d_info *, int); -static struct demangle_component *d_name (struct d_info *); +static struct demangle_component *d_name (struct d_info *, int substable); static struct demangle_component *d_nested_name (struct d_info *); +static int d_maybe_module_name (struct d_info *, struct demangle_component **); + static struct demangle_component *d_prefix (struct d_info *, int); -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); static struct demangle_component *d_source_name (struct d_info *); @@ -462,7 +465,7 @@ static struct demangle_component * d_bare_function_type (struct d_info *, int); static struct demangle_component * -d_class_enum_type (struct d_info *); +d_class_enum_type (struct d_info *, int); static struct demangle_component *d_array_type (struct d_info *); @@ -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 == NULL || right == NULL) return NULL; break; @@ -1020,6 +1024,8 @@ d_make_comp (struct d_info *di, enum demangle_component_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 == NULL) return NULL; break; @@ -1028,6 +1034,8 @@ d_make_comp (struct d_info *di, enum demangle_component_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 == NULL) return NULL; break; @@ -1322,7 +1330,7 @@ d_encoding (struct d_info *di, int top_level) dc = d_special_name (di); else { - dc = d_name (di); + dc = d_name (di, 0); if (!dc) /* Failed already. */; @@ -1416,80 +1424,74 @@ d_abi_tags (struct d_info *di, struct demangle_component *dc) */ static struct demangle_component * -d_name (struct d_info *di) +d_name (struct d_info *di, int substable) { char peek = d_peek_char (di); - struct demangle_component *dc; + struct demangle_component *dc = NULL; + struct demangle_component *module = NULL; + int subst = 0; switch (peek) { case 'N': - return d_nested_name (di); + dc = d_nested_name (di); + break; case 'Z': - return d_local_name (di); + dc = d_local_name (di); + break; case 'U': - return d_unqualified_name (di); + dc = d_unqualified_name (di, NULL, NULL); + break; case 'S': { - int subst; - - if (d_peek_next_char (di) != 't') - { - dc = d_substitution (di, 0); - subst = 1; - } - else + if (d_peek_next_char (di) == 't') { d_advance (di, 2); - dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, - d_make_name (di, "std", 3), - d_unqualified_name (di)); + dc = d_make_name (di, "std", 3); di->expansion += 3; - subst = 0; } - if (d_peek_char (di) != 'I') - { - /* The grammar does not permit this case to occur if we - called d_substitution() above (i.e., subst == 1). We - don't bother to check. */ - } - else + if (d_peek_char (di) == 'S') { - /* This is <template-args>, which means that we just saw - <unscoped-template-name>, which is a substitution - candidate if we didn't just get it from a - substitution. */ - if (! subst) + module = d_substitution (di, 0); + if (!module) + return NULL; + if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME + || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION)) { - if (! d_add_substitution (di, dc)) + if (dc) return NULL; + subst = 1; + dc = module; + module = NULL; } - dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, - d_template_args (di)); } - - return dc; } + /* FALLTHROUGH */ case 'L': default: - dc = d_unqualified_name (di); + if (!subst) + dc = d_unqualified_name (di, dc, module); if (d_peek_char (di) == 'I') { /* This is <template-args>, which means that we just saw <unscoped-template-name>, which is a substitution candidate. */ - if (! d_add_substitution (di, dc)) + if (!subst && !d_add_substitution (di, dc)) return NULL; dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, d_template_args (di)); + subst = 0; } - return dc; + break; } + if (substable && !subst && !d_add_substitution (di, dc)) + return NULL; + return dc; } /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E @@ -1545,54 +1547,42 @@ d_nested_name (struct d_info *di) if not (in an unresolved-name). */ static struct demangle_component * -d_prefix (struct d_info *di, int subst) +d_prefix (struct d_info *di, int substable) { struct demangle_component *ret = NULL; - while (1) + for (;;) { - char peek; - enum demangle_component_type comb_type; - struct demangle_component *dc; - - peek = d_peek_char (di); - if (peek == '\0') - return NULL; + char peek = d_peek_char (di); /* The older code accepts a <local-name> here, but I don't see that in the grammar. The older code does not accept a <template-param> here. */ - comb_type = DEMANGLE_COMPONENT_QUAL_NAME; - if (peek == 'D') + if (peek == 'D' + && (d_peek_next_char (di) == 'T' + || d_peek_next_char (di) == 't')) { - char peek2 = d_peek_next_char (di); - if (peek2 == 'T' || peek2 == 't') - /* Decltype. */ - dc = cplus_demangle_type (di); - else - /* Destructor name. */ - dc = d_unqualified_name (di); + /* Decltype. */ + if (ret) + return NULL; + ret = cplus_demangle_type (di); } - else if (IS_DIGIT (peek) - || IS_LOWER (peek) - || peek == 'C' - || peek == 'U' - || peek == 'L') - dc = d_unqualified_name (di); - else if (peek == 'S') - dc = d_substitution (di, 1); else if (peek == 'I') { if (ret == NULL) return NULL; - comb_type = DEMANGLE_COMPONENT_TEMPLATE; - dc = d_template_args (di); + struct demangle_component *dc = d_template_args (di); + if (!dc) + return NULL; + ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc); } else if (peek == 'T') - dc = d_template_param (di); - else if (peek == 'E') - return ret; + { + if (ret) + return NULL; + ret = d_template_param (di); + } else if (peek == '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 == NULL) return NULL; d_advance (di, 1); - continue; } else + { + struct demangle_component *module = NULL; + if (peek == 'S') + { + module = d_substitution (di, 1); + if (!module) + return NULL; + if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME + || module->type == DEMANGLE_COMPONENT_MODULE_PARTITION)) + { + if (ret) + return NULL; + ret = module; + continue; + } + } + ret = d_unqualified_name (di, ret, module); + } + + if (!ret) + break; + + if (d_peek_char (di) == 'E') + break; + + if (substable && !d_add_substitution (di, ret)) return NULL; + } - if (ret == NULL) - ret = dc; - else - ret = d_make_comp (di, comb_type, ret, dc); + return ret; +} - if (peek != 'S' && d_peek_char (di) != 'E' && subst) +static int +d_maybe_module_name (struct d_info *di, struct demangle_component **name) +{ + while (d_peek_char (di) == 'W') + { + d_advance (di, 1); + enum demangle_component_type code = DEMANGLE_COMPONENT_MODULE_NAME; + if (d_peek_char (di) == 'P') { - if (! d_add_substitution (di, ret)) - return NULL; + code = DEMANGLE_COMPONENT_MODULE_PARTITION; + d_advance (di, 1); } + + *name = d_make_comp (di, code, *name, d_source_name (di)); + if (!*name) + return 0; + if (!d_add_substitution (di, *name)) + return 0; } + return 1; } -/* <unqualified-name> ::= <operator-name> - ::= <ctor-dtor-name> - ::= <source-name> - ::= <local-source-name> - - <local-source-name> ::= L <source-name> <discriminator> +/* <unqualified-name> ::= [<module-name>] <operator-name> [<abi-tags>] + ::= [<module-name>] <ctor-dtor-name> [<abi-tags>] + ::= [<module-name>] <source-name> [<abi-tags>] + ::= [<module-name>] <local-source-name> [<abi-tags>] + ::= [<module-name>] DC <source-name>+ E [<abi-tags>] + <local-source-name> ::= L <source-name> <discriminator> [<abi-tags>] */ 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; + if (!d_maybe_module_name (di, &module)) + return NULL; + peek = d_peek_char (di); if (IS_DIGIT (peek)) ret = d_source_name (di); @@ -1655,6 +1687,28 @@ d_unqualified_name (struct d_info *di) d_source_name (di)); } } + else if (peek == 'D' && d_peek_next_char (di) == 'C') + { + // structured binding + d_advance (di, 2); + struct demangle_component *prev = NULL; + do + { + struct demangle_component *next = + d_make_comp (di, DEMANGLE_COMPONENT_STRUCTURED_BINDING, + d_source_name (di), NULL); + if (prev) + d_right (prev) = next; + else + ret = next; + prev = next; + } + while (prev && d_peek_char (di) != 'E'); + if (prev) + d_advance (di, 1); + else + ret = NULL; + } else if (peek == 'C' || peek == 'D') ret = d_ctor_dtor_name (di); else if (peek == 'L') @@ -1684,8 +1738,13 @@ d_unqualified_name (struct d_info *di) else return NULL; + if (module) + ret = d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module); if (d_peek_char (di) == 'B') ret = d_abi_tags (di, ret); + if (scope) + ret = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret); + return ret; } @@ -2126,11 +2185,11 @@ d_special_name (struct d_info *di) case 'H': return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, - d_name (di), NULL); + d_name (di, 0), NULL); case 'W': return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, - d_name (di), NULL); + d_name (di, 0), NULL); 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); case 'R': { - struct demangle_component *name = d_name (di); + struct demangle_component *name = 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); + case 'I': + { + struct demangle_component *module = 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 = d_function_type (di); break; - 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 = d_class_enum_type (di); - break; - case 'A': ret = d_array_type (di); break; @@ -2558,39 +2618,6 @@ cplus_demangle_type (struct d_info *di) } break; - case 'S': - /* If this is a special substitution, then it is the start of - <class-enum-type>. */ - { - char peek_next; - - peek_next = d_peek_next_char (di); - if (IS_DIGIT (peek_next) - || peek_next == '_' - || IS_UPPER (peek_next)) - { - ret = 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) == 'I') - ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, - d_template_args (di)); - else - can_subst = 0; - } - else - { - ret = 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 != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD) - can_subst = 0; - } - } - break; - case 'O': d_advance (di, 1); ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE, @@ -2731,7 +2758,7 @@ cplus_demangle_type (struct d_info *di) break; default: - return NULL; + return d_class_enum_type (di, 1); } if (can_subst) @@ -3004,9 +3031,9 @@ d_bare_function_type (struct d_info *di, int has_return_type) /* <class-enum-type> ::= <name> */ 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); } /* <array-type> ::= A <(positive dimension) number> _ <(element) type> @@ -3335,11 +3362,11 @@ d_unresolved_name (struct d_info *di) } else type = cplus_demangle_type (di); - name = d_unqualified_name (di); + name = d_unqualified_name (di, type, NULL); if (d_peek_char (di) == 'I') name = 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; } /* <expression> ::= <(unary) operator-name> <expression> @@ -3408,7 +3435,7 @@ d_expression_1 (struct d_info *di) /* operator-function-id, i.e. operator+(t). */ d_advance (di, 2); - name = d_unqualified_name (di); + name = d_unqualified_name (di, NULL, NULL); if (name == NULL) return NULL; if (d_peek_char (di) == 'I') @@ -3516,7 +3543,7 @@ d_expression_1 (struct d_info *di) /* fold-expression. */ left = d_operator_name (di); else if (!strcmp (code, "di")) - left = d_unqualified_name (di); + left = d_unqualified_name (di, NULL, NULL); else left = 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 = d_unqualified_name (di); + right = d_unqualified_name (di, NULL, NULL); if (d_peek_char (di) == 'I') right = 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; } - name = d_name (di); + name = d_name (di, 0); 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; case DEMANGLE_COMPONENT_TEMPLATE: @@ -4284,6 +4315,7 @@ d_count_templates_scopes (struct d_print_info *dpi, case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: + case DEMANGLE_COMPONENT_MODULE_ENTITY: d_count_templates_scopes (dpi, d_left (dc)); break; @@ -4850,6 +4882,38 @@ d_print_comp_inner (struct d_print_info *dpi, int options, d_append_char (dpi, ']'); return; + case DEMANGLE_COMPONENT_STRUCTURED_BINDING: + d_append_char (dpi, '['); + for (;;) + { + d_print_comp (dpi, options, d_left (dc)); + dc = 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 = dc->type == 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 options, d_print_comp (dpi, options, dc->u.s_dtor.name); return; + 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/demangle-expected index de54ad7..351af34 100644 --- a/libiberty/testsuite/demangle-expected +++ b/libiberty/testsuite/demangle-expected @@ -1493,3 +1493,80 @@ decltype ({parm#1}.A::x) f<A>(A) _Z2f6IP1AEDtptfp_gssr1A1BE1xET_ decltype ({parm#1}->(::A::B::x)) f6<A*>(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<One@FOO>::M(One@FOO*) + +_ZNW3FOO3TPLIS_3OneE1NIS_3TwoEEvPS1_PT_ +void TPL@FOO<One@FOO>::N<Two@FOO>(One@FOO*, Two@FOO*) + +_ZN3NMSW3FOO3TPLINS_S0_3OneEE1MEPS2_ +NMS::TPL@FOO<NMS::One@FOO>::M(NMS::One@FOO*) + +_ZN3NMSW3FOO3TPLINS_S0_3OneEE1NINS_S0_3TwoEEEvPS2_PT_ +void NMS::TPL@FOO<NMS::One@FOO>::N<NMS::Two@FOO>(NMS::One@FOO*, NMS::Two@FOO*) + +_ZNStW3STD9allocatorIiE1MEPi +std::allocator@STD<int>::M(int*) + +_ZNStW3STD9allocatorIiE1NIfEEPT_Pi +float* std::allocator@STD<int>::N<float>(int*) + +_ZNStW3STD9allocatorI4PoohE1MEPS1_ +std::allocator@STD<Pooh>::M(Pooh*) + +_ZNStW3STD9allocatorI4PoohE1NI6PigletEEPT_PS1_ +Piglet* std::allocator@STD<Pooh>::N<Piglet>(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 |