FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Import libiberty from gcc

Browse source 
PR 29200
include/
	* ansidecl.h,
	* demangle.h: Import from gcc.
libiberty/
	* cp-demangle.c,
	* testsuite/demangle-expected: Import from gcc.
This commit is contained in:
Alan Modra 2022-05-31 16:59:12 +09:30
parent 42745ac582
commit 2918df9368
4 changed files with 296 additions and 184 deletions
Download patch file Download diff file Expand all files Collapse all files

41
include/ansidecl.h
View file

@ -321,47 +321,6 @@ So instead we use the macro below and test it against specific values. */
#define CONSTEXPR #define CONSTEXPR
#endif #endif
/* 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=c++11" to enable C++11 support; gcc 6 onwards enables
this by default (actually GNU++14). */
#if defined __cplusplus
# if __cplusplus >= 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 >= 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. /* A macro to disable the copy constructor and assignment operator.
When building with C++11 and above, the methods are explicitly When building with C++11 and above, the methods are explicitly
deleted, causing a compile-time error if something tries to copy. deleted, causing a compile-time error if something tries to copy.

9
include/demangle.h
View file

@ -449,7 +449,14 @@ enum demangle_component_type
/* A cloned function. */ /* A cloned function. */
DEMANGLE_COMPONENT_CLONE, DEMANGLE_COMPONENT_CLONE,
DEMANGLE_COMPONENT_NOEXCEPT, 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,
}; };
/* Types which are only used internally. */ /* Types which are only used internally. */

351
libiberty/cp-demangle.c
View file

@ -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_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 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_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 *); 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); d_bare_function_type (struct d_info *, int);
static struct demangle_component * 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 *); 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_COMPOUND_NAME:
case DEMANGLE_COMPONENT_VECTOR_TYPE: case DEMANGLE_COMPONENT_VECTOR_TYPE:
case DEMANGLE_COMPONENT_CLONE: case DEMANGLE_COMPONENT_CLONE:
case DEMANGLE_COMPONENT_MODULE_ENTITY:
if (left == NULL || right == NULL) if (left == NULL || right == NULL)
return NULL; return NULL;
break; break;
@ -1020,6 +1024,8 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
case DEMANGLE_COMPONENT_NULLARY: case DEMANGLE_COMPONENT_NULLARY:
case DEMANGLE_COMPONENT_TRINARY_ARG2: case DEMANGLE_COMPONENT_TRINARY_ARG2:
case DEMANGLE_COMPONENT_TPARM_OBJ: case DEMANGLE_COMPONENT_TPARM_OBJ:
case DEMANGLE_COMPONENT_STRUCTURED_BINDING:
case DEMANGLE_COMPONENT_MODULE_INIT:
if (left == NULL) if (left == NULL)
return NULL; return NULL;
break; break;
@ -1028,6 +1034,8 @@ d_make_comp (struct d_info *di, enum demangle_component_type type,
empty. */ empty. */
case DEMANGLE_COMPONENT_ARRAY_TYPE: case DEMANGLE_COMPONENT_ARRAY_TYPE:
case DEMANGLE_COMPONENT_INITIALIZER_LIST: case DEMANGLE_COMPONENT_INITIALIZER_LIST:
case DEMANGLE_COMPONENT_MODULE_NAME:
case DEMANGLE_COMPONENT_MODULE_PARTITION:
if (right == NULL) if (right == NULL)
return NULL; return NULL;
break; break;
@ -1322,7 +1330,7 @@ d_encoding (struct d_info *di, int top_level)
dc = d_special_name (di); dc = d_special_name (di);
else else
{ {
dc = d_name (di); dc = d_name (di, 0);
if (!dc) if (!dc)
/* Failed already. */; /* Failed already. */;
@ -1416,81 +1424,75 @@ d_abi_tags (struct d_info *di, struct demangle_component *dc)
*/ */
static struct demangle_component * static struct demangle_component *
d_name (struct d_info *di) d_name (struct d_info *di, int substable)
{ {
char peek = d_peek_char (di); 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) switch (peek)
{ {
case 'N': case 'N':
return d_nested_name (di); dc = d_nested_name (di);
break;
case 'Z': case 'Z':
return d_local_name (di); dc = d_local_name (di);
break;
case 'U': case 'U':
return d_unqualified_name (di); dc = d_unqualified_name (di, NULL, NULL);
break;
case 'S': case 'S':
{ {
int subst; if (d_peek_next_char (di) == 't')
if (d_peek_next_char (di) != 't')
{
dc = d_substitution (di, 0);
subst = 1;
}
else
{ {
d_advance (di, 2); d_advance (di, 2);
dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, dc = d_make_name (di, "std", 3);
d_make_name (di, "std", 3),
d_unqualified_name (di));
di->expansion += 3; di->expansion += 3;
subst = 0;
} }
if (d_peek_char (di) != 'I') if (d_peek_char (di) == 'S')
{ {
/* The grammar does not permit this case to occur if we module = d_substitution (di, 0);
called d_substitution() above (i.e., subst == 1). We if (!module)
don't bother to check. */
}
else
{
/* 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)
{
if (! d_add_substitution (di, dc))
return NULL; return NULL;
if (!(module->type == DEMANGLE_COMPONENT_MODULE_NAME
|| module->type == DEMANGLE_COMPONENT_MODULE_PARTITION))
{
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': case 'L':
default: default:
dc = d_unqualified_name (di); if (!subst)
dc = d_unqualified_name (di, dc, module);
if (d_peek_char (di) == 'I') if (d_peek_char (di) == 'I')
{ {
/* This is <template-args>, which means that we just saw /* This is <template-args>, which means that we just saw
<unscoped-template-name>, which is a substitution <unscoped-template-name>, which is a substitution
candidate. */ candidate. */
if (! d_add_substitution (di, dc)) if (!subst && !d_add_substitution (di, dc))
return NULL; return NULL;
dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
d_template_args (di)); d_template_args (di));
subst = 0;
} }
break;
}
if (substable && !subst && !d_add_substitution (di, dc))
return NULL;
return dc; return dc;
} }
}
/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
@ -1545,54 +1547,42 @@ d_nested_name (struct d_info *di)
if not (in an unresolved-name). */ if not (in an unresolved-name). */
static struct demangle_component * 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; struct demangle_component *ret = NULL;
while (1) for (;;)
{ {
char peek; char peek = d_peek_char (di);
enum demangle_component_type comb_type;
struct demangle_component *dc;
peek = d_peek_char (di);
if (peek == '\0')
return NULL;
/* The older code accepts a <local-name> here, but I don't see /* The older code accepts a <local-name> here, but I don't see
that in the grammar. The older code does not accept a that in the grammar. The older code does not accept a
<template-param> here. */ <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. */ /* Decltype. */
dc = cplus_demangle_type (di); if (ret)
else return NULL;
/* Destructor name. */ ret = cplus_demangle_type (di);
dc = d_unqualified_name (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') else if (peek == 'I')
{ {
if (ret == NULL) if (ret == NULL)
return NULL; return NULL;
comb_type = DEMANGLE_COMPONENT_TEMPLATE; struct demangle_component *dc = d_template_args (di);
dc = d_template_args (di); if (!dc)
return NULL;
ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, dc);
} }
else if (peek == 'T') else if (peek == 'T')
dc = d_template_param (di); {
else if (peek == 'E') if (ret)
return ret; return NULL;
ret = d_template_param (di);
}
else if (peek == 'M') else if (peek == 'M')
{ {
/* Initializer scope for a lambda. We don't need to represent /* 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) if (ret == NULL)
return NULL; return NULL;
d_advance (di, 1); d_advance (di, 1);
}
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; continue;
} }
else }
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; return NULL;
}
if (ret == NULL) return ret;
ret = dc; }
else
ret = d_make_comp (di, comb_type, ret, dc);
if (peek != 'S' && d_peek_char (di) != 'E' && subst) static int
d_maybe_module_name (struct d_info *di, struct demangle_component **name)
{ {
if (! d_add_substitution (di, ret)) while (d_peek_char (di) == 'W')
return NULL; {
} d_advance (di, 1);
} enum demangle_component_type code = DEMANGLE_COMPONENT_MODULE_NAME;
if (d_peek_char (di) == 'P')
{
code = DEMANGLE_COMPONENT_MODULE_PARTITION;
d_advance (di, 1);
} }
/* <unqualified-name> ::= <operator-name> *name = d_make_comp (di, code, *name, d_source_name (di));
::= <ctor-dtor-name> if (!*name)
::= <source-name> return 0;
::= <local-source-name> if (!d_add_substitution (di, *name))
return 0;
}
return 1;
}
<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 * 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; struct demangle_component *ret;
char peek; char peek;
if (!d_maybe_module_name (di, &module))
return NULL;
peek = d_peek_char (di); peek = d_peek_char (di);
if (IS_DIGIT (peek)) if (IS_DIGIT (peek))
ret = d_source_name (di); ret = d_source_name (di);
@ -1655,6 +1687,28 @@ d_unqualified_name (struct d_info *di)
d_source_name (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') else if (peek == 'C' || peek == 'D')
ret = d_ctor_dtor_name (di); ret = d_ctor_dtor_name (di);
else if (peek == 'L') else if (peek == 'L')
@ -1684,8 +1738,13 @@ d_unqualified_name (struct d_info *di)
else else
return NULL; return NULL;
if (module)
ret = d_make_comp (di, DEMANGLE_COMPONENT_MODULE_ENTITY, ret, module);
if (d_peek_char (di) == 'B') if (d_peek_char (di) == 'B')
ret = d_abi_tags (di, ret); ret = d_abi_tags (di, ret);
if (scope)
ret = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, scope, ret);
return ret; return ret;
} }
@ -2126,11 +2185,11 @@ d_special_name (struct d_info *di)
case 'H': case 'H':
return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
d_name (di), NULL); d_name (di, 0), NULL);
case 'W': case 'W':
return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
d_name (di), NULL); d_name (di, 0), NULL);
case 'A': case 'A':
return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ, return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
@ -2146,11 +2205,11 @@ d_special_name (struct d_info *di)
{ {
case 'V': case 'V':
return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
d_name (di), NULL); d_name (di, 0), NULL);
case 'R': 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, return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
d_number_component (di)); d_number_component (di));
} }
@ -2159,6 +2218,14 @@ d_special_name (struct d_info *di)
return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
d_encoding (di, 0), NULL); 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': case 'T':
switch (d_next_char (di)) switch (d_next_char (di))
{ {
@ -2481,13 +2548,6 @@ cplus_demangle_type (struct d_info *di)
ret = d_function_type (di); ret = d_function_type (di);
break; 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': case 'A':
ret = d_array_type (di); ret = d_array_type (di);
break; break;
@ -2558,39 +2618,6 @@ cplus_demangle_type (struct d_info *di)
} }
break; 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': case 'O':
d_advance (di, 1); d_advance (di, 1);
ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE, ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
@ -2731,7 +2758,7 @@ cplus_demangle_type (struct d_info *di)
break; break;
default: default:
return NULL; return d_class_enum_type (di, 1);
} }
if (can_subst) if (can_subst)
@ -3004,9 +3031,9 @@ d_bare_function_type (struct d_info *di, int has_return_type)
/* <class-enum-type> ::= <name> */ /* <class-enum-type> ::= <name> */
static struct demangle_component * 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> /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
@ -3335,11 +3362,11 @@ d_unresolved_name (struct d_info *di)
} }
else else
type = cplus_demangle_type (di); type = cplus_demangle_type (di);
name = d_unqualified_name (di); name = d_unqualified_name (di, type, NULL);
if (d_peek_char (di) == 'I') if (d_peek_char (di) == 'I')
name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, name = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d_template_args (di)); d_template_args (di));
return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); return name;
} }
/* <expression> ::= <(unary) operator-name> <expression> /* <expression> ::= <(unary) operator-name> <expression>
@ -3408,7 +3435,7 @@ d_expression_1 (struct d_info *di)
/* operator-function-id, i.e. operator+(t). */ /* operator-function-id, i.e. operator+(t). */
d_advance (di, 2); d_advance (di, 2);
name = d_unqualified_name (di); name = d_unqualified_name (di, NULL, NULL);
if (name == NULL) if (name == NULL)
return NULL; return NULL;
if (d_peek_char (di) == 'I') if (d_peek_char (di) == 'I')
@ -3516,7 +3543,7 @@ d_expression_1 (struct d_info *di)
/* fold-expression. */ /* fold-expression. */
left = d_operator_name (di); left = d_operator_name (di);
else if (!strcmp (code, "di")) else if (!strcmp (code, "di"))
left = d_unqualified_name (di); left = d_unqualified_name (di, NULL, NULL);
else else
left = d_expression_1 (di); left = d_expression_1 (di);
if (!strcmp (code, "cl")) 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 d_unqualified_name rather than d_expression_1 here for
old mangled names that didn't add 'on' before operator old mangled names that didn't add 'on' before operator
names. */ names. */
right = d_unqualified_name (di); right = d_unqualified_name (di, NULL, NULL);
if (d_peek_char (di) == 'I') if (d_peek_char (di) == 'I')
right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
right, d_template_args (di)); right, d_template_args (di));
@ -3744,7 +3771,7 @@ d_local_name (struct d_info *di)
return NULL; return NULL;
} }
name = d_name (di); name = d_name (di, 0);
if (name if (name
/* Lambdas and unnamed types have internal discriminators /* 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_CHARACTER:
case DEMANGLE_COMPONENT_NUMBER: case DEMANGLE_COMPONENT_NUMBER:
case DEMANGLE_COMPONENT_UNNAMED_TYPE: 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; break;
case DEMANGLE_COMPONENT_TEMPLATE: 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_CONSTRUCTORS:
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
case DEMANGLE_COMPONENT_MODULE_ENTITY:
d_count_templates_scopes (dpi, d_left (dc)); d_count_templates_scopes (dpi, d_left (dc));
break; break;
@ -4850,6 +4882,38 @@ d_print_comp_inner (struct d_print_info *dpi, int options,
d_append_char (dpi, ']'); d_append_char (dpi, ']');
return; 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_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME: case DEMANGLE_COMPONENT_LOCAL_NAME:
d_print_comp (dpi, options, d_left (dc)); 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); d_print_comp (dpi, options, dc->u.s_dtor.name);
return; 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: case DEMANGLE_COMPONENT_VTABLE:
d_append_string (dpi, "vtable for "); d_append_string (dpi, "vtable for ");
d_print_comp (dpi, options, d_left (dc)); d_print_comp (dpi, options, d_left (dc));

77
libiberty/testsuite/demangle-expected
View file

@ -1493,3 +1493,80 @@ decltype ({parm#1}.A::x) f<A>(A)
_Z2f6IP1AEDtptfp_gssr1A1BE1xET_ _Z2f6IP1AEDtptfp_gssr1A1BE1xET_
decltype ({parm#1}->(::A::B::x)) f6<A*>(A*) 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