riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Import libiberty from gcc 

PR 29200
include/
	* ansidecl.h,
	* demangle.h: Import from gcc.
libiberty/
	* cp-demangle.c,
	* testsuite/demangle-expected: Import from gcc.
binutils-2_39-branch
Alan Modra 4 years ago
parent
42745ac582
commit
2918df9368
4 changed files with 294 additions and 182 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 41
      include/ansidecl.h
  2. 9
      include/demangle.h
  3. 349
      libiberty/cp-demangle.c
  4. 77
      libiberty/testsuite/demangle-expected

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. */

349
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')
{
/* 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));

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

Write Preview
Loading…
Cancel
Save