diff options
Diffstat (limited to 'libiberty')
| -rw-r--r-- | libiberty/ChangeLog | 50 | ||||
| -rw-r--r-- | libiberty/cp-demangle.c | 355 | ||||
| -rw-r--r-- | libiberty/testsuite/demangle-expected | 18 |
3 files changed, 298 insertions, 125 deletions
diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog index 57672be305..42994f445a 100644 --- a/libiberty/ChangeLog +++ b/libiberty/ChangeLog @@ -1,3 +1,53 @@ +2003-12-04 Ian Lance Taylor <ian@wasabisystems.com> + + * cp-demangle.c (IS_UPPER, IS_LOWER): Define. + (d_last_char): Define new macro. + (d_make_name): Reject an empty name. + (d_prefix, d_unqualified_name, d_type): Use new IS_* macros. + (d_substitution, d_print_identifier): Likewise. + (d_print_comp) [D_COMP_OPERATOR]: Likewise. + (d_print_comp) [D_COMP_TEMPLATE]: Use new d_last_char macro. + (d_print_mod) Use new d_last_char macro. + (d_print_cast): Use new d_last_char macro. + (is_ctor_or_dtor): Don't leak memory. + + Fix handling of member function modifiers: + * cp-demangle.c (enum d_comp_type): Add D_COMP_RESTRICT_THIS, + D_COMP_VOLATILE_THIS, and D_COMP_CONST_THIS. + (d_dump): Dump new d_comp_type values. + (d_make_comp): Accept new d_comp_type values. + (has_return_type): Only accept _THIS variants of qualifiers. + (d_encoding): Without DMGL_PARAMS, only remove _THIS variants of + qualifiers. + (d_cv_qualifiers): Add member_fn parameter. Change all callers. + (d_print_comp) [D_COMP_TYPED_NAME]: Rather than removing + qualifiers and printing them at the end, add _THIS qualifiers to + the modifier list. + (d_print_comp) [D_COMP_*_THIS]: New cases. + (d_print_comp) [D_COMP_PTRMEM_TYPE]: Remove special handling of + qualifiers. + (d_print_mod_list): Add suffix parameter. Change all callers. + Keep walking the list even if the current modifier has been + printed. + (d_print_mod): Handle new _THIS qualifiers. + (d_print_function_type): Handle new _THIS qualifiers when deciding + whether to print a parenthesis. Put a space before the + parenthesis in some cases. Call d_print_mod_list again at the + end, passing suffix as 1. + (is_ctor_or_dtor): Look for new _THIS qualifiers. + * testsuite/demangle-expected: Add test case. + + Fix for PR gcc/13304: + * cp-demangle.c (d_print_comp) [D_COMP_TEMPLATE]: If the character + before the '<' is itself a '<', insert a space. + (d_print_cast): Likewise. + * testsuite/demangle-expected: Add test case. + + Fix for PR gcc/13244: + * cp-demangle.c (d_print_comp) [D_COMP_BINARY]: Wrap an expression + which uses the '>' operator in an extra layer of parens. + * testsuite/demangle-expected: Add test case. + 2003-12-03 Ian Lance Taylor <ian@wasabisystems.com> * floatformat.c: Include "config.h" and <string.h> if available. diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c index 0fe568faf0..a5835df549 100644 --- a/libiberty/cp-demangle.c +++ b/libiberty/cp-demangle.c @@ -28,6 +28,43 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* This code implements a demangler for the g++ V3 ABI. The ABI is + described on this web page: + http://www.codesourcery.com/cxx-abi/abi.html#mangling + + This code was written while looking at the demangler written by + Alex Samuel <samuel@codesourcery.com>. + + This code first pulls the mangled name apart into a list of + components, and then walks the list generating the demangled + name. + + This file will normally define the following functions, q.v.: + char *cplus_demangle_v3(const char *mangled, int options) + char *java_demangle_v3(const char *mangled) + enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) + enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name) + + Preprocessor macros you can define while compiling this file: + + IN_LIBGCC2 + If defined, this file defines the following function, q.v.: + char *__cxa_demangle (const char *mangled, char *buf, size_t *len, + int *status) + instead of cplus_demangle_v3() and java_demangle_v3(). + + IN_GLIBCPP_V3 + If defined, this file defines only __cxa_demangle(). + + STANDALONE_DEMANGLER + If defined, this file defines a main() function which demangles + any arguments, or, if none, demangles stdin. + + CP_DEMANGLE_DEBUG + If defined, turns on debugging mode, which prints information on + stdout about the mangled string. This is not generally useful. +*/ + #ifdef HAVE_CONFIG_H #include "config.h" #endif @@ -45,19 +82,18 @@ #include "libiberty.h" #include "demangle.h" -/* This code implements a demangler for the g++ V3 ABI. The ABI is - described on this web page: - http://www.codesourcery.com/cxx-abi/abi.html#mangling - - This code was written while looking at the demangler written by - Alex Samuel <samuel@codesourcery.com>. +/* We avoid pulling in the ctype tables, to prevent pulling in + additional unresolved symbols when this code is used in a library. + FIXME: Is this really a valid reason? This comes from the original + V3 demangler code. - This code first pulls the mangled name apart into a list of - components, and then walks the list generating the demangled - name. */ + As of this writing this file has the following undefined references + when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy, + strcpy, strcat, strlen. */ -/* Avoid pulling in the ctype tables for this simple usage. */ #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') +#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z') +#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z') /* The prefix prepended by GCC to an identifier represnting the anonymous namespace. */ @@ -155,6 +191,12 @@ enum d_comp_type D_COMP_VOLATILE, /* The const qualifier. */ D_COMP_CONST, + /* The restrict qualifier modifying a member function. */ + D_COMP_RESTRICT_THIS, + /* The volatile qualifier modifying a member function. */ + D_COMP_VOLATILE_THIS, + /* The const qualifier modifying a member function. */ + D_COMP_CONST_THIS, /* A vendor qualifier. */ D_COMP_VENDOR_TYPE_QUAL, /* A pointer. */ @@ -389,6 +431,9 @@ struct d_print_info } \ while (0) +#define d_last_char(dpi) \ + ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1]) + #ifdef CP_DEMANGLE_DEBUG static void d_dump PARAMS ((struct d_comp *, int)); #endif @@ -430,7 +475,7 @@ static int d_call_offset PARAMS ((struct d_info *, int)); static struct d_comp *d_ctor_dtor_name PARAMS ((struct d_info *)); static struct d_comp *d_type PARAMS ((struct d_info *)); static struct d_comp **d_cv_qualifiers PARAMS ((struct d_info *, - struct d_comp **)); + struct d_comp **, int)); static struct d_comp *d_function_type PARAMS ((struct d_info *)); static struct d_comp *d_bare_function_type PARAMS ((struct d_info *, int)); static struct d_comp *d_class_enum_type PARAMS ((struct d_info *)); @@ -456,7 +501,7 @@ static void d_print_comp PARAMS ((struct d_print_info *, static void d_print_identifier PARAMS ((struct d_print_info *, const char *, int)); static void d_print_mod_list PARAMS ((struct d_print_info *, - struct d_print_mod *)); + struct d_print_mod *, int)); static void d_print_mod PARAMS ((struct d_print_info *, const struct d_comp *)); static void d_print_function_type PARAMS ((struct d_print_info *, @@ -572,6 +617,15 @@ d_dump (dc, indent) case D_COMP_CONST: printf ("const\n"); break; + case D_COMP_RESTRICT_THIS: + printf ("restrict this\n"); + break; + case D_COMP_VOLATILE_THIS: + printf ("volatile this\n"); + break; + case D_COMP_CONST_THIS: + printf ("const this\n"); + break; case D_COMP_VENDOR_TYPE_QUAL: printf ("vendor type qualifier\n"); break; @@ -725,6 +779,9 @@ d_make_comp (di, type, left, right) case D_COMP_RESTRICT: case D_COMP_VOLATILE: case D_COMP_CONST: + case D_COMP_RESTRICT_THIS: + case D_COMP_VOLATILE_THIS: + case D_COMP_CONST_THIS: break; /* Other types should not be seen here. */ @@ -751,6 +808,8 @@ d_make_name (di, s, len) { struct d_comp *p; + if (s == NULL || len == 0) + return NULL; p = d_make_empty (di, D_COMP_NAME); if (p != NULL) { @@ -922,10 +981,9 @@ has_return_type (dc) return 0; case D_COMP_TEMPLATE: return ! is_ctor_dtor_or_conversion (d_left (dc)); - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: + case D_COMP_RESTRICT_THIS: + case D_COMP_VOLATILE_THIS: + case D_COMP_CONST_THIS: return has_return_type (d_left (dc)); } } @@ -981,9 +1039,9 @@ d_encoding (di, top_level) /* Strip off any initial CV-qualifiers, as they really apply to the `this' parameter, and they were not output by the v2 demangler without DMGL_PARAMS. */ - while (dc->type == D_COMP_RESTRICT - || dc->type == D_COMP_VOLATILE - || dc->type == D_COMP_CONST) + while (dc->type == D_COMP_RESTRICT_THIS + || dc->type == D_COMP_VOLATILE_THIS + || dc->type == D_COMP_CONST_THIS) dc = d_left (dc); return dc; } @@ -1092,7 +1150,7 @@ d_nested_name (di) if (d_next_char (di) != 'N') return NULL; - pret = d_cv_qualifiers (di, &ret); + pret = d_cv_qualifiers (di, &ret, 1); if (pret == NULL) return NULL; @@ -1139,7 +1197,7 @@ d_prefix (di) comb_type = D_COMP_QUAL_NAME; if (IS_DIGIT (peek) - || (peek >= 'a' && peek <= 'z') + || IS_LOWER (peek) || peek == 'C' || peek == 'D') dc = d_unqualified_name (di); @@ -1186,7 +1244,7 @@ d_unqualified_name (di) peek = d_peek_char (di); if (IS_DIGIT (peek)) return d_source_name (di); - else if (peek >= 'a' && peek <= 'z') + else if (IS_LOWER (peek)) return d_operator_name (di); else if (peek == 'C' || peek == 'D') return d_ctor_dtor_name (di); @@ -1648,7 +1706,7 @@ d_type (di) { struct d_comp **pret; - pret = d_cv_qualifiers (di, &ret); + pret = d_cv_qualifiers (di, &ret, 0); if (pret == NULL) return NULL; *pret = d_type (di); @@ -1716,7 +1774,7 @@ d_type (di) peek_next = d_peek_next_char (di); if (IS_DIGIT (peek_next) || peek_next == '_' - || (peek_next >= 'A' && peek_next <= 'Z')) + || IS_UPPER (peek_next)) { ret = d_substitution (di); /* The substituted name may have been a template name and @@ -1782,9 +1840,10 @@ d_type (di) /* <CV-qualifiers> ::= [r] [V] [K] */ static struct d_comp ** -d_cv_qualifiers (di, pret) +d_cv_qualifiers (di, pret, member_fn) struct d_info *di; struct d_comp **pret; + int member_fn; { char peek; @@ -1795,11 +1854,11 @@ d_cv_qualifiers (di, pret) d_advance (di, 1); if (peek == 'r') - t = D_COMP_RESTRICT; + t = member_fn ? D_COMP_RESTRICT_THIS: D_COMP_RESTRICT; else if (peek == 'V') - t = D_COMP_VOLATILE; + t = member_fn ? D_COMP_VOLATILE_THIS : D_COMP_VOLATILE; else - t = D_COMP_CONST; + t = member_fn ? D_COMP_CONST_THIS: D_COMP_CONST; *pret = d_make_comp (di, t, NULL, NULL); if (*pret == NULL) @@ -1970,7 +2029,7 @@ d_pointer_to_member_type (di) with g++, we need to pull off the CV-qualifiers here, in order to avoid calling add_substitution() in d_type(). */ - pmem = d_cv_qualifiers (di, &mem); + pmem = d_cv_qualifiers (di, &mem, 1); if (pmem == NULL) return NULL; *pmem = d_type (di); @@ -2316,7 +2375,7 @@ d_substitution (di) return NULL; c = d_next_char (di); - if (c == '_' || IS_DIGIT (c) || (c >= 'A' && c <= 'Z')) + if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) { int id; @@ -2327,7 +2386,7 @@ d_substitution (di) { if (IS_DIGIT (c)) id = id * 36 + c - '0'; - else if (c >= 'A' && c <= 'Z') + else if (IS_UPPER (c)) id = id * 36 + c - 'A' + 10; else return NULL; @@ -2527,28 +2586,40 @@ d_print_comp (dpi, dc) case D_COMP_TYPED_NAME: { - const struct d_comp *typed_name; - struct d_print_mod dpm; + struct d_print_mod *hold_modifiers; + struct d_comp *typed_name; + struct d_print_mod adpm[4]; + unsigned int i; struct d_print_template dpt; /* Pass the name down to the type so that it can be printed in - the right place for the type. If the name has - CV-qualifiers, they are really method qualifiers; pull them - off now and print them after everything else. Note that we - don't handle D_COMP_VENDOR_TYPE_QUAL here; it's not - accepted by d_cv_qualifiers() either. */ + the right place for the type. We also have to pass down + any CV-qualifiers, which apply to the this parameter. */ + hold_modifiers = dpi->modifiers; + i = 0; typed_name = d_left (dc); - while (typed_name != NULL - && (typed_name->type == D_COMP_RESTRICT - || typed_name->type == D_COMP_VOLATILE - || typed_name->type == D_COMP_CONST)) - typed_name = d_left (typed_name); + while (typed_name != NULL) + { + if (i >= sizeof adpm / sizeof adpm[0]) + { + d_print_error (dpi); + return; + } - dpm.next = dpi->modifiers; - dpi->modifiers = &dpm; - dpm.mod = typed_name; - dpm.printed = 0; - dpm.templates = dpi->templates; + adpm[i].next = dpi->modifiers; + dpi->modifiers = &adpm[i]; + adpm[i].mod = typed_name; + adpm[i].printed = 0; + adpm[i].templates = dpi->templates; + ++i; + + if (typed_name->type != D_COMP_RESTRICT_THIS + && typed_name->type != D_COMP_VOLATILE_THIS + && typed_name->type != D_COMP_CONST_THIS) + break; + + typed_name = d_left (typed_name); + } /* If typed_name is a template, then it applies to the function type as well. */ @@ -2564,26 +2635,19 @@ d_print_comp (dpi, dc) if (typed_name->type == D_COMP_TEMPLATE) dpi->templates = dpt.next; - /* If the modifier didn't get printed by the type, print it + /* If the modifiers didn't get printed by the type, print them now. */ - if (! dpm.printed) + while (i > 0) { - d_append_char (dpi, ' '); - d_print_comp (dpi, typed_name); + --i; + if (! adpm[i].printed) + { + d_append_char (dpi, ' '); + d_print_mod (dpi, adpm[i].mod); + } } - dpi->modifiers = dpm.next; - - /* Now print any CV-qualifiers on the type. */ - typed_name = d_left (dc); - while (typed_name != NULL - && (typed_name->type == D_COMP_RESTRICT - || typed_name->type == D_COMP_VOLATILE - || typed_name->type == D_COMP_CONST)) - { - d_print_mod (dpi, typed_name); - typed_name = d_left (typed_name); - } + dpi->modifiers = hold_modifiers; return; } @@ -2600,11 +2664,13 @@ d_print_comp (dpi, dc) dpi->modifiers = NULL; d_print_comp (dpi, d_left (dc)); + if (d_last_char (dpi) == '<') + d_append_char (dpi, ' '); d_append_char (dpi, '<'); d_print_comp (dpi, d_right (dc)); /* Avoid generating two consecutive '>' characters, to avoid the C++ syntactic ambiguity. */ - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] == '>') + if (d_last_char (dpi) == '>') d_append_char (dpi, ' '); d_append_char (dpi, '>'); @@ -2737,6 +2803,9 @@ d_print_comp (dpi, dc) case D_COMP_RESTRICT: case D_COMP_VOLATILE: case D_COMP_CONST: + case D_COMP_RESTRICT_THIS: + case D_COMP_VOLATILE_THIS: + case D_COMP_CONST_THIS: case D_COMP_VENDOR_TYPE_QUAL: case D_COMP_POINTER: case D_COMP_REFERENCE: @@ -2832,27 +2901,15 @@ d_print_comp (dpi, dc) case D_COMP_PTRMEM_TYPE: { - const struct d_comp *target_type; struct d_print_mod dpm; - /* Pass the name down to the type so that it can be printed in - the right place for the type. If the type has - CV-qualifiers, they are really method qualifiers; pull them - off now and print them after everything else. */ - target_type = d_right (dc); - while (target_type != NULL - && (target_type->type == D_COMP_RESTRICT - || target_type->type == D_COMP_VOLATILE - || target_type->type == D_COMP_CONST)) - target_type = d_left (target_type); - dpm.next = dpi->modifiers; dpi->modifiers = &dpm; dpm.mod = dc; dpm.printed = 0; dpm.templates = dpi->templates; - d_print_comp (dpi, target_type); + d_print_comp (dpi, d_right (dc)); /* If the modifier didn't get printed by the type, print it now. */ @@ -2865,17 +2922,6 @@ d_print_comp (dpi, dc) dpi->modifiers = dpm.next; - /* Now print any CV-qualifiers on the type. */ - target_type = d_right (dc); - while (target_type != NULL - && (target_type->type == D_COMP_RESTRICT - || target_type->type == D_COMP_VOLATILE - || target_type->type == D_COMP_CONST)) - { - d_print_mod (dpi, target_type); - target_type = d_left (target_type); - } - return; } @@ -2895,7 +2941,7 @@ d_print_comp (dpi, dc) d_append_string (dpi, "operator"); c = dc->u.s_operator.op->name[0]; - if (c >= 'a' && c <= 'z') + if (IS_LOWER (c)) d_append_char (dpi, ' '); d_append_string (dpi, dc->u.s_operator.op->name); return; @@ -2933,6 +2979,14 @@ d_print_comp (dpi, dc) d_print_error (dpi); return; } + + /* We wrap an expression which uses the greater-than operator in + an extra layer of parens so that it does not get confused + with the '>' which ends the template parameters. */ + if (d_left (dc)->type == D_COMP_OPERATOR + && strcmp (d_left (dc)->u.s_operator.op->name, ">") == 0) + d_append_char (dpi, '('); + d_append_char (dpi, '('); d_print_comp (dpi, d_left (d_right (dc))); d_append_string (dpi, ") "); @@ -2940,6 +2994,11 @@ d_print_comp (dpi, dc) d_append_string (dpi, " ("); d_print_comp (dpi, d_right (d_right (dc))); d_append_char (dpi, ')'); + + if (d_left (dc)->type == D_COMP_OPERATOR + && strcmp (d_left (dc)->u.s_operator.op->name, ">") == 0) + d_append_char (dpi, ')'); + return; case D_COMP_BINARY_ARGS: @@ -3064,7 +3123,7 @@ d_print_identifier (dpi, name, len) { int dig; - if (*q >= '0' && *q <= '9') + if (IS_DIGIT (*q)) dig = *q - '0'; else if (*q >= 'A' && *q <= 'F') dig = *q - 'A' + 10; @@ -3090,18 +3149,30 @@ d_print_identifier (dpi, name, len) } } -/* Print a list of modifiers. */ +/* Print a list of modifiers. SUFFIX is 1 if we are printing + qualifiers on this after printing a function. */ static void -d_print_mod_list (dpi, mods) +d_print_mod_list (dpi, mods, suffix) struct d_print_info *dpi; struct d_print_mod *mods; + int suffix; { struct d_print_template *hold_dpt; - if (mods == NULL || mods->printed || d_print_saw_error (dpi)) + if (mods == NULL || d_print_saw_error (dpi)) return; + if (mods->printed + || (! suffix + && (mods->mod->type == D_COMP_RESTRICT_THIS + || mods->mod->type == D_COMP_VOLATILE_THIS + || mods->mod->type == D_COMP_CONST_THIS))) + { + d_print_mod_list (dpi, mods->next, suffix); + return; + } + mods->printed = 1; hold_dpt = dpi->templates; @@ -3124,7 +3195,7 @@ d_print_mod_list (dpi, mods) dpi->templates = hold_dpt; - d_print_mod_list (dpi, mods->next); + d_print_mod_list (dpi, mods->next, suffix); } /* Print a modifier. */ @@ -3137,12 +3208,15 @@ d_print_mod (dpi, mod) switch (mod->type) { case D_COMP_RESTRICT: + case D_COMP_RESTRICT_THIS: d_append_string (dpi, " restrict"); return; case D_COMP_VOLATILE: + case D_COMP_VOLATILE_THIS: d_append_string (dpi, " volatile"); return; case D_COMP_CONST: + case D_COMP_CONST_THIS: d_append_string (dpi, " const"); return; case D_COMP_VENDOR_TYPE_QUAL: @@ -3164,7 +3238,7 @@ d_print_mod (dpi, mod) d_append_string (dpi, "imaginary "); return; case D_COMP_PTRMEM_TYPE: - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] != '(') + if (d_last_char (dpi) != '(') d_append_char (dpi, ' '); d_print_comp (dpi, d_left (mod)); d_append_string (dpi, "::*"); @@ -3213,6 +3287,10 @@ d_print_function_type (dpi, dc, mods) case D_COMP_PTRMEM_TYPE: need_paren = 1; break; + case D_COMP_RESTRICT_THIS: + case D_COMP_VOLATILE_THIS: + case D_COMP_CONST_THIS: + break; default: break; } @@ -3224,9 +3302,23 @@ d_print_function_type (dpi, dc, mods) need_paren = 1; if (need_paren) - d_append_char (dpi, '('); + { + switch (d_last_char (dpi)) + { + case ' ': + case '(': + case '*': + break; - d_print_mod_list (dpi, mods); + default: + d_append_char (dpi, ' '); + break; + } + + d_append_char (dpi, '('); + } + + d_print_mod_list (dpi, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3237,6 +3329,8 @@ d_print_function_type (dpi, dc, mods) d_print_comp (dpi, d_right (dc)); d_append_char (dpi, ')'); + + d_print_mod_list (dpi, mods, 1); } /* Print an array type, except for the element type. */ @@ -3277,7 +3371,7 @@ d_print_array_type (dpi, dc, mods) if (need_paren) d_append_string (dpi, " ("); - d_print_mod_list (dpi, mods); + d_print_mod_list (dpi, mods, 0); if (need_paren) d_append_char (dpi, ')'); @@ -3337,11 +3431,13 @@ d_print_cast (dpi, dc) dpi->templates = dpt.next; + if (d_last_char (dpi) == '<') + d_append_char (dpi, ' '); d_append_char (dpi, '<'); d_print_comp (dpi, d_right (d_left (dc))); /* Avoid generating two consecutive '>' characters, to avoid the C++ syntactic ambiguity. */ - if (dpi->buf != NULL && dpi->buf[dpi->len - 1] == '>') + if (d_last_char (dpi) == '>') d_append_char (dpi, ' '); d_append_char (dpi, '>'); @@ -3653,6 +3749,7 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) { struct d_info di; struct d_comp *dc; + int ret; *ctor_kind = (enum gnu_v3_ctor_kinds) 0; *dtor_kind = (enum gnu_v3_dtor_kinds) 0; @@ -3662,36 +3759,44 @@ is_ctor_or_dtor (mangled, ctor_kind, dtor_kind) dc = d_mangled_name (&di, 1); - if (dc == NULL || d_peek_char (&di) != '\0') - return 0; - - while (dc != NULL) + ret = 0; + if (d_peek_char (&di) == '\0') { - switch (dc->type) + while (dc != NULL) { - default: - return 0; - case D_COMP_TYPED_NAME: - case D_COMP_TEMPLATE: - case D_COMP_RESTRICT: - case D_COMP_VOLATILE: - case D_COMP_CONST: - case D_COMP_VENDOR_TYPE_QUAL: - dc = d_left (dc); - break; - case D_COMP_QUAL_NAME: - dc = d_right (dc); - break; - case D_COMP_CTOR: - *ctor_kind = dc->u.s_ctor.kind; - return 1; - case D_COMP_DTOR: - *dtor_kind = dc->u.s_dtor.kind; - return 1; + switch (dc->type) + { + default: + dc = NULL; + break; + case D_COMP_TYPED_NAME: + case D_COMP_TEMPLATE: + case D_COMP_RESTRICT_THIS: + case D_COMP_VOLATILE_THIS: + case D_COMP_CONST_THIS: + dc = d_left (dc); + break; + case D_COMP_QUAL_NAME: + dc = d_right (dc); + break; + case D_COMP_CTOR: + *ctor_kind = dc->u.s_ctor.kind; + ret = 1; + dc = NULL; + break; + case D_COMP_DTOR: + *dtor_kind = dc->u.s_dtor.kind; + ret = 1; + dc = NULL; + break; + } } } - return 0; + free (di.subs); + free (di.comps); + + return ret; } /* Return whether NAME is the mangled form of a g++ V3 ABI constructor diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected index bb90aa01ae..c47c6aea5f 100644 --- a/libiberty/testsuite/demangle-expected +++ b/libiberty/testsuite/demangle-expected @@ -2883,10 +2883,28 @@ void __gnu_debug::_Error_formatter::_M_format_word<unsigned long>(char*, int, ch --format=gnu-v3 _ZSt18uninitialized_copyIN9__gnu_cxx17__normal_iteratorIPSt4pairISsPFbP6sqlitePPcEESt6vectorIS9_SaIS9_EEEESE_ET0_T_SG_SF_ __gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > > std::uninitialized_copy<__gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > >, __gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > > >(__gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > >, __gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > >, __gnu_cxx::__normal_iterator<std::pair<std::string, bool (*)(sqlite*, char**)>*, std::vector<std::pair<std::string, bool (*)(sqlite*, char**)>, std::allocator<std::pair<std::string, bool (*)(sqlite*, char**)> > > >) +# # The new demangler used to fail on this. --format=gnu-v3 _Z1fP1cIPFiiEE f(c<int (*)(int)>*) +# +# Wrap expressions using '>' in an extra layer of parens to avoid +# confusion with the '>' which ends the template parameters. +--format=gnu-v3 +_Z4dep9ILi3EEvP3fooIXgtT_Li2EEE +void dep9<3>(foo<((3) > (2))>*) +# +# Watch out for templated version of `operator<'--it needs an extra +# space. +--format=gnu-v3 +_ZStltI9file_pathSsEbRKSt4pairIT_T0_ES6_ +bool std::operator< <file_path, std::string>(std::pair<file_path, std::string> const&, std::pair<file_path, std::string> const&) +# +# More hairy qualifier handling. +--format=gnu-v3 +_Z9hairyfuncM1YKFPVPFrPA2_PM1XKFKPA3_ilEPcEiE +hairyfunc(int (* const (X::** (* restrict (* volatile*(Y::*)(int) const)(char*)) [2])(long) const) [3]) # # This caused an infinite loop. # |
