git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

demangler: Reorganize for module demangling 

Module demangling requires some changes in how substitutions are
handled.  This adjusts things to make that possible.

	libiberty/
	* cp-demangle.c (d_name): Add SUBSTABLE parameter,
	push substitution if requested. Adjust unscoped name handling.
	(d_prefix): Reorder main loop. Adjust all calls.
	(d_unqualified_name): Add SCOPE parameter, create qualified
	name here. Adjust all calls.
	(cplus_demangle_type): Do not handle 'S' here, leave all
	to d_class_enum_type.
	(d_class_enum_type): Add SUBSTABLE parameter.
This commit is contained in:
Nathan Sidwell 2022-03-08 10:53:39 -08:00
parent 86f64400a5
commit 65851d65fb
1 changed files with 84 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
libiberty/cp-demangle.c
View File

@ -425,13 +425,14 @@ 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 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);
static struct demangle_component *d_source_name (struct d_info *); static struct demangle_component *d_source_name (struct d_info *);
@ -462,7 +463,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 *);
@ -1323,7 +1324,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. */;
@ -1417,80 +1418,64 @@ 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;
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);
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')
{
/* 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 else
{ {
/* This is <template-args>, which means that we just saw dc = d_substitution (di, 0);
<unscoped-template-name>, which is a substitution if (!dc)
candidate if we didn't just get it from a return NULL;
substitution. */ subst = 1;
if (! subst)
{
if (! d_add_substitution (di, dc))
return 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);
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;
} }
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 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
@ -1546,54 +1531,51 @@ 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); /* Decltype. */
if (peek2 == 'T' || peek2 == 't') if (ret)
/* Decltype. */ return NULL;
dc = cplus_demangle_type (di); ret = cplus_demangle_type (di);
else
/* Destructor name. */
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') else if (peek == 'S')
dc = d_substitution (di, 1); {
if (ret)
return NULL;
ret = d_substitution (di, 1);
if (!ret)
return NULL;
continue;
}
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
@ -1602,22 +1584,21 @@ 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);
continue;
} }
else else
ret = d_unqualified_name (di, ret);
if (!ret)
break;
if (d_peek_char (di) == 'E')
break;
if (substable && !d_add_substitution (di, ret))
return NULL; 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;
}
} }
return ret;
} }
/* <unqualified-name> ::= <operator-name> [<abi-tags>] /* <unqualified-name> ::= <operator-name> [<abi-tags>]
@ -1629,7 +1610,7 @@ d_prefix (struct d_info *di, int subst)
*/ */
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 *ret; struct demangle_component *ret;
char peek; char peek;
@ -1709,6 +1690,9 @@ d_unqualified_name (struct d_info *di)
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;
} }
@ -2149,11 +2133,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,
@ -2169,11 +2153,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));
} }
@ -2504,13 +2488,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;
@ -2581,39 +2558,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,
@ -2754,7 +2698,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)
@ -3027,9 +2971,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>
@ -3358,11 +3302,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);
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>
@ -3431,7 +3375,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);
if (name == NULL) if (name == NULL)
return NULL; return NULL;
if (d_peek_char (di) == 'I') if (d_peek_char (di) == 'I')
@ -3539,7 +3483,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);
else else
left = d_expression_1 (di); left = d_expression_1 (di);
if (!strcmp (code, "cl")) if (!strcmp (code, "cl"))
@ -3557,7 +3501,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);
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));
@ -3767,7 +3711,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