version 1.6, 2020/04/03 17:51:16 |
version 1.7, 2022/12/23 17:09:27 |
|
|
/* Demangler for g++ V3 ABI. |
/* Demangler for g++ V3 ABI. |
Copyright (C) 2003-2018 Free Software Foundation, Inc. |
Copyright (C) 2003-2020 Free Software Foundation, Inc. |
Written by Ian Lance Taylor <ian@wasabisystems.com>. |
Written by Ian Lance Taylor <ian@wasabisystems.com>. |
|
|
This file is part of the libiberty library, which is part of GCC. |
This file is part of the libiberty library, which is part of GCC. |
Line 192 static void d_init_info (const char *, i |
|
Line 192 static void d_init_info (const char *, i |
|
#else |
#else |
#ifdef __STDC__ |
#ifdef __STDC__ |
#ifdef __STDC_VERSION__ |
#ifdef __STDC_VERSION__ |
#if __STDC_VERSION__ >= 199901L |
#if __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ |
#define CP_DYNAMIC_ARRAYS |
#define CP_DYNAMIC_ARRAYS |
#endif /* __STDC__VERSION >= 199901L */ |
#endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */ |
#endif /* defined (__STDC_VERSION__) */ |
#endif /* defined (__STDC_VERSION__) */ |
#endif /* defined (__STDC__) */ |
#endif /* defined (__STDC__) */ |
#endif /* ! defined (__GNUC__) */ |
#endif /* ! defined (__GNUC__) */ |
Line 517 d_growable_string_callback_adapter (cons |
|
Line 517 d_growable_string_callback_adapter (cons |
|
|
|
static void |
static void |
d_print_init (struct d_print_info *, demangle_callbackref, void *, |
d_print_init (struct d_print_info *, demangle_callbackref, void *, |
const struct demangle_component *); |
struct demangle_component *); |
|
|
static inline void d_print_error (struct d_print_info *); |
static inline void d_print_error (struct d_print_info *); |
|
|
Line 625 d_dump (struct demangle_component *dc, i |
|
Line 625 d_dump (struct demangle_component *dc, i |
|
case DEMANGLE_COMPONENT_TEMPLATE_PARAM: |
case DEMANGLE_COMPONENT_TEMPLATE_PARAM: |
printf ("template parameter %ld\n", dc->u.s_number.number); |
printf ("template parameter %ld\n", dc->u.s_number.number); |
return; |
return; |
|
case DEMANGLE_COMPONENT_TPARM_OBJ: |
|
printf ("template parameter object\n"); |
|
break; |
case DEMANGLE_COMPONENT_FUNCTION_PARAM: |
case DEMANGLE_COMPONENT_FUNCTION_PARAM: |
printf ("function parameter %ld\n", dc->u.s_number.number); |
printf ("function parameter %ld\n", dc->u.s_number.number); |
return; |
return; |
Line 858 CP_STATIC_IF_GLIBCPP_V3 |
|
Line 861 CP_STATIC_IF_GLIBCPP_V3 |
|
int |
int |
cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len) |
cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len) |
{ |
{ |
if (p == NULL || s == NULL || len == 0) |
if (p == NULL || s == NULL || len <= 0) |
return 0; |
return 0; |
p->d_printing = 0; |
p->d_printing = 0; |
|
p->d_counting = 0; |
p->type = DEMANGLE_COMPONENT_NAME; |
p->type = DEMANGLE_COMPONENT_NAME; |
p->u.s_name.s = s; |
p->u.s_name.s = s; |
p->u.s_name.len = len; |
p->u.s_name.len = len; |
Line 877 cplus_demangle_fill_extended_operator (s |
|
Line 881 cplus_demangle_fill_extended_operator (s |
|
if (p == NULL || args < 0 || name == NULL) |
if (p == NULL || args < 0 || name == NULL) |
return 0; |
return 0; |
p->d_printing = 0; |
p->d_printing = 0; |
|
p->d_counting = 0; |
p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; |
p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; |
p->u.s_extended_operator.args = args; |
p->u.s_extended_operator.args = args; |
p->u.s_extended_operator.name = name; |
p->u.s_extended_operator.name = name; |
Line 897 cplus_demangle_fill_ctor (struct demangl |
|
Line 902 cplus_demangle_fill_ctor (struct demangl |
|
|| (int) kind > gnu_v3_object_ctor_group) |
|| (int) kind > gnu_v3_object_ctor_group) |
return 0; |
return 0; |
p->d_printing = 0; |
p->d_printing = 0; |
|
p->d_counting = 0; |
p->type = DEMANGLE_COMPONENT_CTOR; |
p->type = DEMANGLE_COMPONENT_CTOR; |
p->u.s_ctor.kind = kind; |
p->u.s_ctor.kind = kind; |
p->u.s_ctor.name = name; |
p->u.s_ctor.name = name; |
Line 917 cplus_demangle_fill_dtor (struct demangl |
|
Line 923 cplus_demangle_fill_dtor (struct demangl |
|
|| (int) kind > gnu_v3_object_dtor_group) |
|| (int) kind > gnu_v3_object_dtor_group) |
return 0; |
return 0; |
p->d_printing = 0; |
p->d_printing = 0; |
|
p->d_counting = 0; |
p->type = DEMANGLE_COMPONENT_DTOR; |
p->type = DEMANGLE_COMPONENT_DTOR; |
p->u.s_dtor.kind = kind; |
p->u.s_dtor.kind = kind; |
p->u.s_dtor.name = name; |
p->u.s_dtor.name = name; |
Line 934 d_make_empty (struct d_info *di) |
|
Line 941 d_make_empty (struct d_info *di) |
|
return NULL; |
return NULL; |
p = &di->comps[di->next_comp]; |
p = &di->comps[di->next_comp]; |
p->d_printing = 0; |
p->d_printing = 0; |
|
p->d_counting = 0; |
++di->next_comp; |
++di->next_comp; |
return p; |
return p; |
} |
} |
Line 1007 d_make_comp (struct d_info *di, enum dem |
|
Line 1015 d_make_comp (struct d_info *di, enum dem |
|
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: |
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: |
case DEMANGLE_COMPONENT_NULLARY: |
case DEMANGLE_COMPONENT_NULLARY: |
case DEMANGLE_COMPONENT_TRINARY_ARG2: |
case DEMANGLE_COMPONENT_TRINARY_ARG2: |
|
case DEMANGLE_COMPONENT_TPARM_OBJ: |
if (left == NULL) |
if (left == NULL) |
return NULL; |
return NULL; |
break; |
break; |
Line 1326 d_encoding (struct d_info *di, int top_l |
|
Line 1335 d_encoding (struct d_info *di, int top_l |
|
really apply here; this happens when parsing a class |
really apply here; this happens when parsing a class |
which is local to a function. */ |
which is local to a function. */ |
if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) |
if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) |
while (is_fnqual_component_type (d_right (dc)->type)) |
{ |
d_right (dc) = d_left (d_right (dc)); |
while (d_right (dc) != NULL |
|
&& is_fnqual_component_type (d_right (dc)->type)) |
|
d_right (dc) = d_left (d_right (dc)); |
|
|
|
if (d_right (dc) == NULL) |
|
dc = NULL; |
|
} |
} |
} |
else |
else |
{ |
{ |
Line 1707 d_number (struct d_info *di) |
|
Line 1722 d_number (struct d_info *di) |
|
} |
} |
if (ret > ((INT_MAX - (peek - '0')) / 10)) |
if (ret > ((INT_MAX - (peek - '0')) / 10)) |
return -1; |
return -1; |
ret = ret * 10 + peek - '0'; |
ret = ret * 10 + (peek - '0'); |
d_advance (di, 1); |
d_advance (di, 1); |
peek = d_peek_char (di); |
peek = d_peek_char (di); |
} |
} |
Line 2007 d_java_resource (struct d_info *di) |
|
Line 2022 d_java_resource (struct d_info *di) |
|
::= TT <type> |
::= TT <type> |
::= TI <type> |
::= TI <type> |
::= TS <type> |
::= TS <type> |
|
::= TA <template-arg> |
::= GV <(object) name> |
::= GV <(object) name> |
::= T <call-offset> <(base) encoding> |
::= T <call-offset> <(base) encoding> |
::= Tc <call-offset> <call-offset> <(base) encoding> |
::= Tc <call-offset> <call-offset> <(base) encoding> |
Line 2099 d_special_name (struct d_info *di) |
|
Line 2115 d_special_name (struct d_info *di) |
|
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), NULL); |
|
|
|
case 'A': |
|
return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ, |
|
d_template_arg (di), NULL); |
|
|
default: |
default: |
return NULL; |
return NULL; |
} |
} |
Line 2355 cplus_demangle_builtin_types[D_BUILTIN_T |
|
Line 2375 cplus_demangle_builtin_types[D_BUILTIN_T |
|
/* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT }, |
/* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT }, |
/* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT }, |
/* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT }, |
/* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT }, |
/* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT }, |
/* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT }, |
/* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT }, |
/* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT }, |
/* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT }, |
/* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"), |
/* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT }, |
|
/* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"), |
D_PRINT_DEFAULT }, |
D_PRINT_DEFAULT }, |
}; |
}; |
|
|
Line 2645 cplus_demangle_type (struct d_info *di) |
|
Line 2666 cplus_demangle_type (struct d_info *di) |
|
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]); |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]); |
di->expansion += ret->u.s_builtin.type->len; |
di->expansion += ret->u.s_builtin.type->len; |
break; |
break; |
|
case 'u': |
|
/* char8_t */ |
|
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]); |
|
di->expansion += ret->u.s_builtin.type->len; |
|
break; |
case 's': |
case 's': |
/* char16_t */ |
/* char16_t */ |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]); |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]); |
di->expansion += ret->u.s_builtin.type->len; |
di->expansion += ret->u.s_builtin.type->len; |
break; |
break; |
case 'i': |
case 'i': |
/* char32_t */ |
/* char32_t */ |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]); |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]); |
di->expansion += ret->u.s_builtin.type->len; |
di->expansion += ret->u.s_builtin.type->len; |
break; |
break; |
|
|
Line 2678 cplus_demangle_type (struct d_info *di) |
|
Line 2704 cplus_demangle_type (struct d_info *di) |
|
|
|
case 'n': |
case 'n': |
/* decltype(nullptr) */ |
/* decltype(nullptr) */ |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]); |
ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]); |
di->expansion += ret->u.s_builtin.type->len; |
di->expansion += ret->u.s_builtin.type->len; |
break; |
break; |
|
|
Line 2843 d_ref_qualifier (struct d_info *di, stru |
|
Line 2869 d_ref_qualifier (struct d_info *di, stru |
|
static struct demangle_component * |
static struct demangle_component * |
d_function_type (struct d_info *di) |
d_function_type (struct d_info *di) |
{ |
{ |
struct demangle_component *ret; |
struct demangle_component *ret = NULL; |
|
|
if (! d_check_char (di, 'F')) |
if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) |
return NULL; |
|
if (d_peek_char (di) == 'Y') |
|
{ |
{ |
/* Function has C linkage. We don't print this information. |
if (di->recursion_level > DEMANGLE_RECURSION_LIMIT) |
FIXME: We should print it in verbose mode. */ |
/* FIXME: There ought to be a way to report |
d_advance (di, 1); |
that the recursion limit has been reached. */ |
|
return NULL; |
|
|
|
di->recursion_level ++; |
} |
} |
ret = d_bare_function_type (di, 1); |
|
ret = d_ref_qualifier (di, ret); |
|
|
|
if (! d_check_char (di, 'E')) |
if (d_check_char (di, 'F')) |
return NULL; |
{ |
|
if (d_peek_char (di) == 'Y') |
|
{ |
|
/* Function has C linkage. We don't print this information. |
|
FIXME: We should print it in verbose mode. */ |
|
d_advance (di, 1); |
|
} |
|
ret = d_bare_function_type (di, 1); |
|
ret = d_ref_qualifier (di, ret); |
|
|
|
if (! d_check_char (di, 'E')) |
|
ret = NULL; |
|
} |
|
|
|
if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) |
|
di->recursion_level --; |
return ret; |
return ret; |
} |
} |
|
|
Line 3327 d_expression_1 (struct d_info *di) |
|
Line 3367 d_expression_1 (struct d_info *di) |
|
{ |
{ |
/* Brace-enclosed initializer list, untyped or typed. */ |
/* Brace-enclosed initializer list, untyped or typed. */ |
struct demangle_component *type = NULL; |
struct demangle_component *type = NULL; |
|
d_advance (di, 2); |
if (peek == 't') |
if (peek == 't') |
type = cplus_demangle_type (di); |
type = cplus_demangle_type (di); |
if (!d_peek_next_char (di)) |
if (!d_peek_char (di) || !d_peek_next_char (di)) |
return NULL; |
return NULL; |
d_advance (di, 2); |
|
return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST, |
return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST, |
type, d_exprlist (di, 'E')); |
type, d_exprlist (di, 'E')); |
} |
} |
Line 3542 d_expr_primary (struct d_info *di) |
|
Line 3582 d_expr_primary (struct d_info *di) |
|
&& type->u.s_builtin.type->print != D_PRINT_DEFAULT) |
&& type->u.s_builtin.type->print != D_PRINT_DEFAULT) |
di->expansion -= type->u.s_builtin.type->len; |
di->expansion -= type->u.s_builtin.type->len; |
|
|
|
if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE |
|
&& strcmp (type->u.s_builtin.type->name, |
|
cplus_demangle_builtin_types[33].name) == 0) |
|
{ |
|
if (d_peek_char (di) == 'E') |
|
{ |
|
d_advance (di, 1); |
|
return type; |
|
} |
|
} |
|
|
/* Rather than try to interpret the literal value, we just |
/* Rather than try to interpret the literal value, we just |
collect it as a string. Note that it's possible to have a |
collect it as a string. Note that it's possible to have a |
floating point literal here. The ABI specifies that the |
floating point literal here. The ABI specifies that the |
Line 4032 d_growable_string_callback_adapter (cons |
|
Line 4083 d_growable_string_callback_adapter (cons |
|
are larger than the actual numbers encountered. */ |
are larger than the actual numbers encountered. */ |
|
|
static void |
static void |
d_count_templates_scopes (int *num_templates, int *num_scopes, |
d_count_templates_scopes (struct d_print_info *dpi, |
const struct demangle_component *dc) |
struct demangle_component *dc) |
{ |
{ |
if (dc == NULL) |
if (dc == NULL || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT) |
return; |
return; |
|
|
|
++ dc->d_counting; |
|
|
switch (dc->type) |
switch (dc->type) |
{ |
{ |
case DEMANGLE_COMPONENT_NAME: |
case DEMANGLE_COMPONENT_NAME: |
Line 4052 d_count_templates_scopes (int *num_templ |
|
Line 4105 d_count_templates_scopes (int *num_templ |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_TEMPLATE: |
case DEMANGLE_COMPONENT_TEMPLATE: |
(*num_templates)++; |
dpi->num_copy_templates++; |
goto recurse_left_right; |
goto recurse_left_right; |
|
|
case DEMANGLE_COMPONENT_REFERENCE: |
case DEMANGLE_COMPONENT_REFERENCE: |
case DEMANGLE_COMPONENT_RVALUE_REFERENCE: |
case DEMANGLE_COMPONENT_RVALUE_REFERENCE: |
if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) |
if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) |
(*num_scopes)++; |
dpi->num_saved_scopes++; |
goto recurse_left_right; |
goto recurse_left_right; |
|
|
case DEMANGLE_COMPONENT_QUAL_NAME: |
case DEMANGLE_COMPONENT_QUAL_NAME: |
Line 4101 d_count_templates_scopes (int *num_templ |
|
Line 4154 d_count_templates_scopes (int *num_templ |
|
case DEMANGLE_COMPONENT_VECTOR_TYPE: |
case DEMANGLE_COMPONENT_VECTOR_TYPE: |
case DEMANGLE_COMPONENT_ARGLIST: |
case DEMANGLE_COMPONENT_ARGLIST: |
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: |
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: |
|
case DEMANGLE_COMPONENT_TPARM_OBJ: |
case DEMANGLE_COMPONENT_INITIALIZER_LIST: |
case DEMANGLE_COMPONENT_INITIALIZER_LIST: |
case DEMANGLE_COMPONENT_CAST: |
case DEMANGLE_COMPONENT_CAST: |
case DEMANGLE_COMPONENT_CONVERSION: |
case DEMANGLE_COMPONENT_CONVERSION: |
Line 4122 d_count_templates_scopes (int *num_templ |
|
Line 4176 d_count_templates_scopes (int *num_templ |
|
case DEMANGLE_COMPONENT_TAGGED_NAME: |
case DEMANGLE_COMPONENT_TAGGED_NAME: |
case DEMANGLE_COMPONENT_CLONE: |
case DEMANGLE_COMPONENT_CLONE: |
recurse_left_right: |
recurse_left_right: |
d_count_templates_scopes (num_templates, num_scopes, |
/* PR 89394 - Check for too much recursion. */ |
d_left (dc)); |
if (dpi->recursion > DEMANGLE_RECURSION_LIMIT) |
d_count_templates_scopes (num_templates, num_scopes, |
/* FIXME: There ought to be a way to report to the |
d_right (dc)); |
user that the recursion limit has been reached. */ |
|
return; |
|
|
|
++ dpi->recursion; |
|
d_count_templates_scopes (dpi, d_left (dc)); |
|
d_count_templates_scopes (dpi, d_right (dc)); |
|
-- dpi->recursion; |
break; |
break; |
|
|
case DEMANGLE_COMPONENT_CTOR: |
case DEMANGLE_COMPONENT_CTOR: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, dc->u.s_ctor.name); |
dc->u.s_ctor.name); |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_DTOR: |
case DEMANGLE_COMPONENT_DTOR: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, dc->u.s_dtor.name); |
dc->u.s_dtor.name); |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: |
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, dc->u.s_extended_operator.name); |
dc->u.s_extended_operator.name); |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_FIXED_TYPE: |
case DEMANGLE_COMPONENT_FIXED_TYPE: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, dc->u.s_fixed.length); |
dc->u.s_fixed.length); |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: |
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: |
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: |
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, d_left (dc)); |
d_left (dc)); |
|
break; |
break; |
|
|
case DEMANGLE_COMPONENT_LAMBDA: |
case DEMANGLE_COMPONENT_LAMBDA: |
case DEMANGLE_COMPONENT_DEFAULT_ARG: |
case DEMANGLE_COMPONENT_DEFAULT_ARG: |
d_count_templates_scopes (num_templates, num_scopes, |
d_count_templates_scopes (dpi, dc->u.s_unary_num.sub); |
dc->u.s_unary_num.sub); |
|
break; |
break; |
} |
} |
} |
} |
Line 4166 d_count_templates_scopes (int *num_templ |
|
Line 4220 d_count_templates_scopes (int *num_templ |
|
|
|
static void |
static void |
d_print_init (struct d_print_info *dpi, demangle_callbackref callback, |
d_print_init (struct d_print_info *dpi, demangle_callbackref callback, |
void *opaque, const struct demangle_component *dc) |
void *opaque, struct demangle_component *dc) |
{ |
{ |
dpi->len = 0; |
dpi->len = 0; |
dpi->last_char = '\0'; |
dpi->last_char = '\0'; |
Line 4192 d_print_init (struct d_print_info *dpi, |
|
Line 4246 d_print_init (struct d_print_info *dpi, |
|
dpi->next_copy_template = 0; |
dpi->next_copy_template = 0; |
dpi->num_copy_templates = 0; |
dpi->num_copy_templates = 0; |
|
|
d_count_templates_scopes (&dpi->num_copy_templates, |
d_count_templates_scopes (dpi, dc); |
&dpi->num_saved_scopes, dc); |
/* If we did not reach the recursion limit, then reset the |
|
current recursion value back to 0, so that we can print |
|
the templates. */ |
|
if (dpi->recursion < DEMANGLE_RECURSION_LIMIT) |
|
dpi->recursion = 0; |
dpi->num_copy_templates *= dpi->num_saved_scopes; |
dpi->num_copy_templates *= dpi->num_saved_scopes; |
|
|
dpi->current_template = NULL; |
dpi->current_template = NULL; |
Line 4727 d_print_comp_inner (struct d_print_info |
|
Line 4785 d_print_comp_inner (struct d_print_info |
|
typed_name = d_right (typed_name); |
typed_name = d_right (typed_name); |
if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) |
if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) |
typed_name = typed_name->u.s_unary_num.sub; |
typed_name = typed_name->u.s_unary_num.sub; |
if (typed_name == NULL) |
while (typed_name != NULL |
{ |
&& is_fnqual_component_type (typed_name->type)) |
d_print_error (dpi); |
|
return; |
|
} |
|
while (is_fnqual_component_type (typed_name->type)) |
|
{ |
{ |
if (i >= sizeof adpm / sizeof adpm[0]) |
if (i >= sizeof adpm / sizeof adpm[0]) |
{ |
{ |
Line 4751 d_print_comp_inner (struct d_print_info |
|
Line 4805 d_print_comp_inner (struct d_print_info |
|
|
|
typed_name = d_left (typed_name); |
typed_name = d_left (typed_name); |
} |
} |
|
if (typed_name == NULL) |
|
{ |
|
d_print_error (dpi); |
|
return; |
|
} |
} |
} |
|
|
/* If typed_name is a template, then it applies to the |
/* If typed_name is a template, then it applies to the |
Line 4872 d_print_comp_inner (struct d_print_info |
|
Line 4931 d_print_comp_inner (struct d_print_info |
|
} |
} |
return; |
return; |
|
|
|
case DEMANGLE_COMPONENT_TPARM_OBJ: |
|
d_append_string (dpi, "template parameter object for "); |
|
d_print_comp (dpi, options, d_left (dc)); |
|
return; |
|
|
case DEMANGLE_COMPONENT_CTOR: |
case DEMANGLE_COMPONENT_CTOR: |
d_print_comp (dpi, options, dc->u.s_ctor.name); |
d_print_comp (dpi, options, dc->u.s_ctor.name); |
return; |
return; |
Line 5931 d_print_mod (struct d_print_info *dpi, i |
|
Line 5995 d_print_mod (struct d_print_info *dpi, i |
|
d_append_string (dpi, "&&"); |
d_append_string (dpi, "&&"); |
return; |
return; |
case DEMANGLE_COMPONENT_COMPLEX: |
case DEMANGLE_COMPONENT_COMPLEX: |
d_append_string (dpi, "complex "); |
d_append_string (dpi, " _Complex"); |
return; |
return; |
case DEMANGLE_COMPONENT_IMAGINARY: |
case DEMANGLE_COMPONENT_IMAGINARY: |
d_append_string (dpi, "imaginary "); |
d_append_string (dpi, " _Imaginary"); |
return; |
return; |
case DEMANGLE_COMPONENT_PTRMEM_TYPE: |
case DEMANGLE_COMPONENT_PTRMEM_TYPE: |
if (d_last_char (dpi) != '(') |
if (d_last_char (dpi) != '(') |
Line 6172 cplus_demangle_init_info (const char *ma |
|
Line 6236 cplus_demangle_init_info (const char *ma |
|
|
|
di->n = mangled; |
di->n = mangled; |
|
|
/* We can not need more components than twice the number of chars in |
/* We cannot need more components than twice the number of chars in |
the mangled string. Most components correspond directly to |
the mangled string. Most components correspond directly to |
chars, but the ARGLIST types are exceptions. */ |
chars, but the ARGLIST types are exceptions. */ |
di->num_comps = 2 * len; |
di->num_comps = 2 * len; |
di->next_comp = 0; |
di->next_comp = 0; |
|
|
/* Similarly, we can not need more substitutions than there are |
/* Similarly, we cannot need more substitutions than there are |
chars in the mangled string. */ |
chars in the mangled string. */ |
di->num_subs = len; |
di->num_subs = len; |
di->next_sub = 0; |
di->next_sub = 0; |
Line 6188 cplus_demangle_init_info (const char *ma |
|
Line 6252 cplus_demangle_init_info (const char *ma |
|
di->expansion = 0; |
di->expansion = 0; |
di->is_expression = 0; |
di->is_expression = 0; |
di->is_conversion = 0; |
di->is_conversion = 0; |
|
di->recursion_level = 0; |
} |
} |
|
|
/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI |
/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI |
Line 6227 d_demangle_callback (const char *mangled |
|
Line 6292 d_demangle_callback (const char *mangled |
|
|
|
cplus_demangle_init_info (mangled, options, strlen (mangled), &di); |
cplus_demangle_init_info (mangled, options, strlen (mangled), &di); |
|
|
|
/* PR 87675 - Check for a mangled string that is so long |
|
that we do not have enough stack space to demangle it. */ |
|
if (((options & DMGL_NO_RECURSE_LIMIT) == 0) |
|
/* This check is a bit arbitrary, since what we really want to do is to |
|
compare the sizes of the di.comps and di.subs arrays against the |
|
amount of stack space remaining. But there is no portable way to do |
|
this, so instead we use the recursion limit as a guide to the maximum |
|
size of the arrays. */ |
|
&& (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT) |
|
{ |
|
/* FIXME: We need a way to indicate that a stack limit has been reached. */ |
|
return 0; |
|
} |
|
|
{ |
{ |
#ifdef CP_DYNAMIC_ARRAYS |
#ifdef CP_DYNAMIC_ARRAYS |
__extension__ struct demangle_component comps[di.num_comps]; |
__extension__ struct demangle_component comps[di.num_comps]; |