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
#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.
When building with C++11 and above, the methods are explicitly
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. */
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,
};
/* Types which are only used internally. */

353
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_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')
if (d_peek_char (di) == 'S')
{
/* 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
{
/* 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
return NULL;
if (ret == NULL)
ret = dc;
else
ret = d_make_comp (di, comb_type, ret, dc);
if (peek != 'S' && d_peek_char (di) != 'E' && subst)
{
if (! d_add_substitution (di, ret))
return NULL;
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;
}
return ret;
}
/* <unqualified-name> ::= <operator-name>
::= <ctor-dtor-name>
::= <source-name>
::= <local-source-name>
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')
{
code = DEMANGLE_COMPONENT_MODULE_PARTITION;
d_advance (di, 1);
}
<local-source-name> ::= L <source-name> <discriminator>
*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> ::= [<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));

77
libiberty/testsuite/demangle-expected
View file

@ -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