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

merge from gcc

binutils-2_22-branch
DJ Delorie 15 years ago
parent
02d1f5acc5
commit
ddee5e46a4
6 changed files with 194 additions and 124 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. 5
      include/ChangeLog
  2. 8
      include/demangle.h
  3. 23
      libiberty/ChangeLog
  4. 243
      libiberty/cp-demangle.c
  5. 27
      libiberty/testsuite/demangle-expected
  6. 12
      libiberty/testsuite/test-demangle.c

5
include/ChangeLog
View File

@ -1,3 +1,8 @@
2011-06-13 Jan Kratochvil <jan.kratochvil@redhat.com>
* demangle.h (DMGL_RET_POSTFIX): Extend the comment.
(DMGL_RET_DROP): New.
2011-06-13 Walter Lee <walt@tilera.com>
* dis-asm.h (print_insn_tilegx): Declare.

8
include/demangle.h
View File

@ -45,7 +45,13 @@ extern "C" {
#define DMGL_VERBOSE (1 << 3) /* Include implementation details. */
#define DMGL_TYPES (1 << 4) /* Also try to demangle type encodings. */
#define DMGL_RET_POSTFIX (1 << 5) /* Print function return types (when
present) after function signature */
present) after function signature.
It applies only to the toplevel
function type. */
#define DMGL_RET_DROP (1 << 6) /* Suppress printing function return
types, even if present. It applies
only to the toplevel function type.
*/
#define DMGL_AUTO (1 << 8)
#define DMGL_GNU (1 << 9)

23
libiberty/ChangeLog
View File

@ -1,3 +1,26 @@
2011-06-13 Jan Kratochvil <jan.kratochvil@redhat.com>
* cp-demangle.c (d_print_comp) <DEMANGLE_COMPONENT_FUNCTION_TYPE>:
Suppress d_print_mod for DMGL_RET_POSTFIX.
* testsuite/demangle-expected: New testcases for --ret-postfix.
2011-06-13 Jan Kratochvil <jan.kratochvil@redhat.com>
* cp-demangle.c (d_print_comp) <DEMANGLE_COMPONENT_FUNCTION_TYPE>: Do
not pass DMGL_RET_POSTFIX or DMGL_RET_DROP. Support DMGL_RET_DROP.
* testsuite/demangle-expected: New testcases for --ret-drop.
* testsuite/test-demangle.c: Document --ret-drop in a comment.
(main): New variable ret_drop, fill it, call cplus_demangle with it.
2011-06-13 Jan Kratochvil <jan.kratochvil@redhat.com>
* cp-demangle.c (struct d_print_info): Remove field options.
(d_print_init): Remove parameter options.
(cplus_demangle_print_callback): Update all the callers.
(d_print_comp, d_print_mod_list, d_print_mod, d_print_function_type)
(d_print_array_type, d_print_expr_op, d_print_cast, d_print_subexpr):
Add parameter options, update all the callers.
2011-04-20 Jim Meyering <meyering@redhat.com>
* cp-demint.c (cplus_demangle_v3_components): Remove useless

243
libiberty/cp-demangle.c
View File

@ -278,8 +278,6 @@ struct d_growable_string
enum { D_PRINT_BUFFER_LENGTH = 256 };
struct d_print_info
{
/* The options passed to the demangler. */
int options;
/* Fixed-length allocated buffer for demangled data, flushed to the
callback with a NUL termination once full. */
char buf[D_PRINT_BUFFER_LENGTH];
@ -436,7 +434,7 @@ static void
d_growable_string_callback_adapter (const char *, size_t, void *);
static void
d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
d_print_init (struct d_print_info *, demangle_callbackref, void *);
static inline void d_print_error (struct d_print_info *);
@ -454,32 +452,32 @@ static inline void d_append_string (struct d_print_info *, const char *);
static inline char d_last_char (struct d_print_info *);
static void
d_print_comp (struct d_print_info *, const struct demangle_component *);
d_print_comp (struct d_print_info *, int, const struct demangle_component *);
static void
d_print_java_identifier (struct d_print_info *, const char *, int);
static void
d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
static void
d_print_mod (struct d_print_info *, const struct demangle_component *);
d_print_mod (struct d_print_info *, int, const struct demangle_component *);
static void
d_print_function_type (struct d_print_info *,
d_print_function_type (struct d_print_info *, int,
const struct demangle_component *,
struct d_print_mod *);
static void
d_print_array_type (struct d_print_info *,
d_print_array_type (struct d_print_info *, int,
const struct demangle_component *,
struct d_print_mod *);
static void
d_print_expr_op (struct d_print_info *, const struct demangle_component *);
d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
static void
d_print_cast (struct d_print_info *, const struct demangle_component *);
d_print_cast (struct d_print_info *, int, const struct demangle_component *);
static int d_demangle_callback (const char *, int,
demangle_callbackref, void *);
@ -3293,10 +3291,9 @@ d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
/* Initialize a print information structure. */
static void
d_print_init (struct d_print_info *dpi, int options,
demangle_callbackref callback, void *opaque)
d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
void *opaque)
{
dpi->options = options;
dpi->len = 0;
dpi->last_char = '\0';
dpi->templates = NULL;
@ -3392,9 +3389,9 @@ cplus_demangle_print_callback (int options,
{
struct d_print_info dpi;
d_print_init (&dpi, options, callback, opaque);
d_print_init (&dpi, callback, opaque);
d_print_comp (&dpi, dc);
d_print_comp (&dpi, options, dc);
d_print_flush (&dpi);
@ -3537,7 +3534,7 @@ d_pack_length (const struct demangle_component *dc)
if needed. */
static void
d_print_subexpr (struct d_print_info *dpi,
d_print_subexpr (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
int simple = 0;
@ -3546,7 +3543,7 @@ d_print_subexpr (struct d_print_info *dpi,
simple = 1;
if (!simple)
d_append_char (dpi, '(');
d_print_comp (dpi, dc);
d_print_comp (dpi, options, dc);
if (!simple)
d_append_char (dpi, ')');
}
@ -3554,7 +3551,7 @@ d_print_subexpr (struct d_print_info *dpi,
/* Subroutine to handle components. */
static void
d_print_comp (struct d_print_info *dpi,
d_print_comp (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (dc == NULL)
@ -3568,7 +3565,7 @@ d_print_comp (struct d_print_info *dpi,
switch (dc->type)
{
case DEMANGLE_COMPONENT_NAME:
if ((dpi->options & DMGL_JAVA) == 0)
if ((options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
else
d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
@ -3576,12 +3573,12 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
d_print_comp (dpi, d_left (dc));
if ((dpi->options & DMGL_JAVA) == 0)
d_print_comp (dpi, options, d_left (dc));
if ((options & DMGL_JAVA) == 0)
d_append_string (dpi, "::");
else
d_append_char (dpi, '.');
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
return;
case DEMANGLE_COMPONENT_TYPED_NAME:
@ -3671,7 +3668,7 @@ d_print_comp (struct d_print_info *dpi,
}
}
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
dpi->templates = dpt.next;
@ -3684,7 +3681,7 @@ d_print_comp (struct d_print_info *dpi,
if (! adpm[i].printed)
{
d_append_char (dpi, ' ');
d_print_mod (dpi, adpm[i].mod);
d_print_mod (dpi, options, adpm[i].mod);
}
}
@ -3707,7 +3704,7 @@ d_print_comp (struct d_print_info *dpi,
dcl = d_left (dc);
if ((dpi->options & DMGL_JAVA) != 0
if ((options & DMGL_JAVA) != 0
&& dcl->type == DEMANGLE_COMPONENT_NAME
&& dcl->u.s_name.len == 6
&& strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
@ -3715,16 +3712,16 @@ d_print_comp (struct d_print_info *dpi,
/* Special-case Java arrays, so that JArray<TYPE> appears
instead as TYPE[]. */
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
d_append_string (dpi, "[]");
}
else
{
d_print_comp (dpi, dcl);
d_print_comp (dpi, options, dcl);
if (d_last_char (dpi) == '<')
d_append_char (dpi, ' ');
d_append_char (dpi, '<');
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
if (d_last_char (dpi) == '>')
@ -3759,7 +3756,7 @@ d_print_comp (struct d_print_info *dpi,
hold_dpt = dpi->templates;
dpi->templates = hold_dpt->next;
d_print_comp (dpi, a);
d_print_comp (dpi, options, a);
dpi->templates = hold_dpt;
@ -3767,79 +3764,79 @@ d_print_comp (struct d_print_info *dpi,
}
case DEMANGLE_COMPONENT_CTOR:
d_print_comp (dpi, dc->u.s_ctor.name);
d_print_comp (dpi, options, dc->u.s_ctor.name);
return;
case DEMANGLE_COMPONENT_DTOR:
d_append_char (dpi, '~');
d_print_comp (dpi, dc->u.s_dtor.name);
d_print_comp (dpi, options, dc->u.s_dtor.name);
return;
case DEMANGLE_COMPONENT_VTABLE:
d_append_string (dpi, "vtable for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_VTT:
d_append_string (dpi, "VTT for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
d_append_string (dpi, "construction vtable for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
d_append_string (dpi, "-in-");
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
return;
case DEMANGLE_COMPONENT_TYPEINFO:
d_append_string (dpi, "typeinfo for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_TYPEINFO_NAME:
d_append_string (dpi, "typeinfo name for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_TYPEINFO_FN:
d_append_string (dpi, "typeinfo fn for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_THUNK:
d_append_string (dpi, "non-virtual thunk to ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
d_append_string (dpi, "virtual thunk to ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_COVARIANT_THUNK:
d_append_string (dpi, "covariant return thunk to ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_JAVA_CLASS:
d_append_string (dpi, "java Class for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_GUARD:
d_append_string (dpi, "guard variable for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_REFTEMP:
d_append_string (dpi, "reference temporary for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
d_append_string (dpi, "hidden alias for ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_SUB_STD:
@ -3866,7 +3863,7 @@ d_print_comp (struct d_print_info *dpi,
break;
if (pdpm->mod->type == dc->type)
{
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
}
}
@ -3892,12 +3889,12 @@ d_print_comp (struct d_print_info *dpi,
dpm.printed = 0;
dpm.templates = dpi->templates;
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
d_print_mod (dpi, dc);
d_print_mod (dpi, options, dc);
dpi->modifiers = dpm.next;
@ -3905,7 +3902,7 @@ d_print_comp (struct d_print_info *dpi,
}
case DEMANGLE_COMPONENT_BUILTIN_TYPE:
if ((dpi->options & DMGL_JAVA) == 0)
if ((options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_builtin.type->name,
dc->u.s_builtin.type->len);
else
@ -3914,16 +3911,21 @@ d_print_comp (struct d_print_info *dpi,
return;
case DEMANGLE_COMPONENT_VENDOR_TYPE:
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
{
if ((dpi->options & DMGL_RET_POSTFIX) != 0)
d_print_function_type (dpi, dc, dpi->modifiers);
if ((options & DMGL_RET_POSTFIX) != 0)
d_print_function_type (dpi,
options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
dc, dpi->modifiers);
/* Print return type if present */
if (d_left (dc) != NULL)
if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
d_left (dc));
else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
{
struct d_print_mod dpm;
@ -3935,7 +3937,8 @@ d_print_comp (struct d_print_info *dpi,
dpm.printed = 0;
dpm.templates = dpi->templates;
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
d_left (dc));
dpi->modifiers = dpm.next;
@ -3944,12 +3947,14 @@ d_print_comp (struct d_print_info *dpi,
/* In standard prefix notation, there is a space between the
return type and the function signature. */
if ((dpi->options & DMGL_RET_POSTFIX) == 0)
if ((options & DMGL_RET_POSTFIX) == 0)
d_append_char (dpi, ' ');
}
if ((dpi->options & DMGL_RET_POSTFIX) == 0)
d_print_function_type (dpi, dc, dpi->modifiers);
if ((options & DMGL_RET_POSTFIX) == 0)
d_print_function_type (dpi,
options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
dc, dpi->modifiers);
return;
}
@ -4002,7 +4007,7 @@ d_print_comp (struct d_print_info *dpi,
pdpm = pdpm->next;
}
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
dpi->modifiers = hold_modifiers;
@ -4012,10 +4017,10 @@ d_print_comp (struct d_print_info *dpi,
while (i > 1)
{
--i;
d_print_mod (dpi, adpm[i].mod);
d_print_mod (dpi, options, adpm[i].mod);
}
d_print_array_type (dpi, dc, dpi->modifiers);
d_print_array_type (dpi, options, dc, dpi->modifiers);
return;
}
@ -4031,12 +4036,12 @@ d_print_comp (struct d_print_info *dpi,
dpm.printed = 0;
dpm.templates = dpi->templates;
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
d_print_mod (dpi, dc);
d_print_mod (dpi, options, dc);
dpi->modifiers = dpm.next;
@ -4050,7 +4055,7 @@ d_print_comp (struct d_print_info *dpi,
if (dc->u.s_fixed.length->u.s_builtin.type
!= &cplus_demangle_builtin_types['i'-'a'])
{
d_print_comp (dpi, dc->u.s_fixed.length);
d_print_comp (dpi, options, dc->u.s_fixed.length);
d_append_char (dpi, ' ');
}
if (dc->u.s_fixed.accum)
@ -4062,7 +4067,7 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_ARGLIST:
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
if (d_left (dc) != NULL)
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
if (d_right (dc) != NULL)
{
size_t len;
@ -4074,7 +4079,7 @@ d_print_comp (struct d_print_info *dpi,
d_append_string (dpi, ", ");
len = dpi->len;
flush_count = dpi->flush_count;
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
/* If that didn't print anything (which can happen with empty
template argument packs), remove the comma and space. */
if (dpi->flush_count == flush_count && dpi->len == len)
@ -4097,24 +4102,24 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d_append_string (dpi, "operator ");
d_print_comp (dpi, dc->u.s_extended_operator.name);
d_print_comp (dpi, options, dc->u.s_extended_operator.name);
return;
case DEMANGLE_COMPONENT_CAST:
d_append_string (dpi, "operator ");
d_print_cast (dpi, dc);
d_print_cast (dpi, options, dc);
return;
case DEMANGLE_COMPONENT_UNARY:
if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
d_print_expr_op (dpi, d_left (dc));
d_print_expr_op (dpi, options, d_left (dc));
else
{
d_append_char (dpi, '(');
d_print_cast (dpi, d_left (dc));
d_print_cast (dpi, options, d_left (dc));
d_append_char (dpi, ')');
}
d_print_subexpr (dpi, d_right (dc));
d_print_subexpr (dpi, options, d_right (dc));
return;
case DEMANGLE_COMPONENT_BINARY:
@ -4132,18 +4137,18 @@ d_print_comp (struct d_print_info *dpi,
&& d_left (dc)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, '(');
d_print_subexpr (dpi, d_left (d_right (dc)));
d_print_subexpr (dpi, options, d_left (d_right (dc)));
if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
{
d_append_char (dpi, '[');
d_print_comp (dpi, d_right (d_right (dc)));
d_print_comp (dpi, options, d_right (d_right (dc)));
d_append_char (dpi, ']');
}
else
{
if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
d_print_expr_op (dpi, d_left (dc));
d_print_subexpr (dpi, d_right (d_right (dc)));
d_print_expr_op (dpi, options, d_left (dc));
d_print_subexpr (dpi, options, d_right (d_right (dc)));
}
if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
@ -4165,11 +4170,11 @@ d_print_comp (struct d_print_info *dpi,
d_print_error (dpi);
return;
}
d_print_subexpr (dpi, d_left (d_right (dc)));
d_print_expr_op (dpi, d_left (dc));
d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
d_print_subexpr (dpi, options, d_left (d_right (dc)));
d_print_expr_op (dpi, options, d_left (dc));
d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
d_append_string (dpi, " : ");
d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
return;
case DEMANGLE_COMPONENT_TRINARY_ARG1:
@ -4200,7 +4205,7 @@ d_print_comp (struct d_print_info *dpi,
{
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
switch (tp)
{
default:
@ -4250,13 +4255,13 @@ d_print_comp (struct d_print_info *dpi,
}
d_append_char (dpi, '(');
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
d_append_char (dpi, ')');
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, '[');
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, ']');
}
@ -4268,12 +4273,12 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_JAVA_RESOURCE:
d_append_string (dpi, "java resource ");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
return;
case DEMANGLE_COMPONENT_COMPOUND_NAME:
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_left (dc));
d_print_comp (dpi, options, d_right (dc));
return;
case DEMANGLE_COMPONENT_CHARACTER:
@ -4282,7 +4287,7 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_DECLTYPE:
d_append_string (dpi, "decltype (");
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
d_append_char (dpi, ')');
return;
@ -4296,7 +4301,7 @@ d_print_comp (struct d_print_info *dpi,
/* d_find_pack won't find anything if the only packs involved
in this expansion are function parameter packs; in that
case, just print the pattern and "...". */
d_print_subexpr (dpi, d_left (dc));
d_print_subexpr (dpi, options, d_left (dc));
d_append_string (dpi, "...");
return;
}
@ -4306,7 +4311,7 @@ d_print_comp (struct d_print_info *dpi,
for (i = 0; i < len; ++i)
{
dpi->pack_index = i;
d_print_comp (dpi, dc);
d_print_comp (dpi, options, dc);
if (i < len-1)
d_append_string (dpi, ", ");
}
@ -4321,17 +4326,17 @@ d_print_comp (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
d_append_string (dpi, "global constructors keyed to ");
d_print_comp (dpi, dc->u.s_binary.left);
d_print_comp (dpi, options, dc->u.s_binary.left);
return;
case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
d_append_string (dpi, "global destructors keyed to ");
d_print_comp (dpi, dc->u.s_binary.left);
d_print_comp (dpi, options, dc->u.s_binary.left);
return;
case DEMANGLE_COMPONENT_LAMBDA:
d_append_string (dpi, "{lambda(");
d_print_comp (dpi, dc->u.s_unary_num.sub);
d_print_comp (dpi, options, dc->u.s_unary_num.sub);
d_append_string (dpi, ")#");
d_append_num (dpi, dc->u.s_unary_num.num + 1);
d_append_char (dpi, '}');
@ -4405,7 +4410,7 @@ d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
qualifiers on this after printing a function. */
static void
d_print_mod_list (struct d_print_info *dpi,
d_print_mod_list (struct d_print_info *dpi, int options,
struct d_print_mod *mods, int suffix)
{
struct d_print_template *hold_dpt;
@ -4419,7 +4424,7 @@ d_print_mod_list (struct d_print_info *dpi,
|| mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
{
d_print_mod_list (dpi, mods->next, suffix);
d_print_mod_list (dpi, options, mods->next, suffix);
return;
}
@ -4430,13 +4435,13 @@ d_print_mod_list (struct d_print_info *dpi,
if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
{
d_print_function_type (dpi, mods->mod, mods->next);
d_print_function_type (dpi, options, mods->mod, mods->next);
dpi->templates = hold_dpt;
return;
}
else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
{
d_print_array_type (dpi, mods->mod, mods->next);
d_print_array_type (dpi, options, mods->mod, mods->next);
dpi->templates = hold_dpt;
return;
}
@ -4452,10 +4457,10 @@ d_print_mod_list (struct d_print_info *dpi,
hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;
d_print_comp (dpi, d_left (mods->mod));
d_print_comp (dpi, options, d_left (mods->mod));
dpi->modifiers = hold_modifiers;
if ((dpi->options & DMGL_JAVA) == 0)
if ((options & DMGL_JAVA) == 0)
d_append_string (dpi, "::");
else
d_append_char (dpi, '.');
@ -4475,23 +4480,23 @@ d_print_mod_list (struct d_print_info *dpi,
|| dc->type == DEMANGLE_COMPONENT_CONST_THIS)
dc = d_left (dc);
d_print_comp (dpi, dc);
d_print_comp (dpi, options, dc);
dpi->templates = hold_dpt;
return;
}
d_print_mod (dpi, mods->mod);
d_print_mod (dpi, options, mods->mod);
dpi->templates = hold_dpt;
d_print_mod_list (dpi, mods->next, suffix);
d_print_mod_list (dpi, options, mods->next, suffix);
}
/* Print a modifier. */
static void
d_print_mod (struct d_print_info *dpi,
d_print_mod (struct d_print_info *dpi, int options,
const struct demangle_component *mod)
{
switch (mod->type)
@ -4510,11 +4515,11 @@ d_print_mod (struct d_print_info *dpi,
return;
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d_append_char (dpi, ' ');
d_print_comp (dpi, d_right (mod));
d_print_comp (dpi, options, d_right (mod));
return;
case DEMANGLE_COMPONENT_POINTER:
/* There is no pointer symbol in Java. */
if ((dpi->options & DMGL_JAVA) == 0)
if ((options & DMGL_JAVA) == 0)
d_append_char (dpi, '*');
return;
case DEMANGLE_COMPONENT_REFERENCE:
@ -4532,22 +4537,22 @@ d_print_mod (struct d_print_info *dpi,
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
if (d_last_char (dpi) != '(')
d_append_char (dpi, ' ');
d_print_comp (dpi, d_left (mod));
d_print_comp (dpi, options, d_left (mod));
d_append_string (dpi, "::*");
return;
case DEMANGLE_COMPONENT_TYPED_NAME:
d_print_comp (dpi, d_left (mod));
d_print_comp (dpi, options, d_left (mod));
return;
case DEMANGLE_COMPONENT_VECTOR_TYPE:
d_append_string (dpi, " __vector(");
d_print_comp (dpi, d_left (mod));
d_print_comp (dpi, options, d_left (mod));
d_append_char (dpi, ')');
return;
default:
/* Otherwise, we have something that won't go back on the
modifier stack, so we can just print it. */
d_print_comp (dpi, mod);
d_print_comp (dpi, options, mod);
return;
}
}
@ -4555,7 +4560,7 @@ d_print_mod (struct d_print_info *dpi,
/* Print a function type, except for the return type. */
static void
d_print_function_type (struct d_print_info *dpi,
d_print_function_type (struct d_print_info *dpi, int options,
const struct demangle_component *dc,
struct d_print_mod *mods)
{
@ -4615,7 +4620,7 @@ d_print_function_type (struct d_print_info *dpi,
hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;
d_print_mod_list (dpi, mods, 0);
d_print_mod_list (dpi, options, mods, 0);
if (need_paren)
d_append_char (dpi, ')');
@ -4623,11 +4628,11 @@ d_print_function_type (struct d_print_info *dpi,
d_append_char (dpi, '(');
if (d_right (dc) != NULL)
d_print_comp (dpi, d_right (dc));
d_print_comp (dpi, options, d_right (dc));
d_append_char (dpi, ')');
d_print_mod_list (dpi, mods, 1);
d_print_mod_list (dpi, options, mods, 1);
dpi->modifiers = hold_modifiers;
}
@ -4635,7 +4640,7 @@ d_print_function_type (struct d_print_info *dpi,
/* Print an array type, except for the element type. */
static void
d_print_array_type (struct d_print_info *dpi,
d_print_array_type (struct d_print_info *dpi, int options,
const struct demangle_component *dc,
struct d_print_mod *mods)
{
@ -4669,7 +4674,7 @@ d_print_array_type (struct d_print_info *dpi,
if (need_paren)
d_append_string (dpi, " (");
d_print_mod_list (dpi, mods, 0);
d_print_mod_list (dpi, options, mods, 0);
if (need_paren)
d_append_char (dpi, ')');
@ -4681,7 +4686,7 @@ d_print_array_type (struct d_print_info *dpi,
d_append_char (dpi, '[');
if (d_left (dc) != NULL)
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
d_append_char (dpi, ']');
}
@ -4689,24 +4694,24 @@ d_print_array_type (struct d_print_info *dpi,
/* Print an operator in an expression. */
static void
d_print_expr_op (struct d_print_info *dpi,
d_print_expr_op (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
d_append_buffer (dpi, dc->u.s_operator.op->name,
dc->u.s_operator.op->len);
else
d_print_comp (dpi, dc);
d_print_comp (dpi, options, dc);
}
/* Print a cast. */
static void
d_print_cast (struct d_print_info *dpi,
d_print_cast (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
d_print_comp (dpi, d_left (dc));
d_print_comp (dpi, options, d_left (dc));
else
{
struct d_print_mod *hold_dpm;
@ -4724,14 +4729,14 @@ d_print_cast (struct d_print_info *dpi,
dpi->templates = &dpt;
dpt.template_decl = d_left (dc);
d_print_comp (dpi, d_left (d_left (dc)));
d_print_comp (dpi, options, d_left (d_left (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)));
d_print_comp (dpi, options, d_right (d_left (dc)));
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
if (d_last_char (dpi) == '>')

27
libiberty/testsuite/demangle-expected
View File

@ -3959,6 +3959,33 @@ f(decltype(nullptr))
--format=gnu-v3
_ZN5aaaaa6bbbbbb5cccccIN23ddddddddddddddddddddddd3eeeENS2_4ffff16ggggggggggggggggENS0_9hhhhhhhhhES6_S6_S6_S6_S6_S6_S6_EE
aaaaa::bbbbbb::ccccc<ddddddddddddddddddddddd::eee, ddddddddddddddddddddddd::ffff::gggggggggggggggg, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh, aaaaa::bbbbbb::hhhhhhhhh>
--format=gnu-v3
_Z5outerIsEcPFilE
char outer<short>(int (*)(long))
--format=gnu-v3
_Z5outerPFsiEl
outer(short (*)(int), long)
--format=gnu-v3
_Z6outer2IsEPFilES1_
int (*outer2<short>(int (*)(long)))(long)
--format=gnu-v3 --ret-postfix
_Z5outerIsEcPFilE
outer<short>(int (*)(long))char
--format=gnu-v3 --ret-postfix
_Z5outerPFsiEl
outer(short (*)(int), long)
--format=gnu-v3 --ret-postfix
_Z6outer2IsEPFilES1_
outer2<short>(int (*)(long))int (*)(long)
--format=gnu-v3 --ret-drop
_Z5outerIsEcPFilE
outer<short>(int (*)(long))
--format=gnu-v3 --ret-drop
_Z5outerPFsiEl
outer(short (*)(int), long)
--format=gnu-v3 --ret-drop
_Z6outer2IsEPFilES1_
outer2<short>(int (*)(long))
#
# Ada (GNAT) tests.
#

12
libiberty/testsuite/test-demangle.c
View File

@ -159,6 +159,7 @@ exp: %s\n",
output is an integer representing ctor_kind.
--is-v3-dtor Likewise, but for dtors.
--ret-postfix Passes the DMGL_RET_POSTFIX option
--ret-drop Passes the DMGL_RET_DROP option
For compatibility, just in case it matters, the options line may be
empty, to mean --format=auto. If it doesn't start with --, then it
@ -174,7 +175,7 @@ main(argc, argv)
int no_params;
int is_v3_ctor;
int is_v3_dtor;
int ret_postfix;
int ret_postfix, ret_drop;
struct line format;
struct line input;
struct line expect;
@ -209,6 +210,7 @@ main(argc, argv)
no_params = 0;
ret_postfix = 0;
ret_drop = 0;
is_v3_ctor = 0;
is_v3_dtor = 0;
if (format.data[0] == '\0')
@ -265,6 +267,8 @@ main(argc, argv)
is_v3_dtor = 1;
else if (strcmp (opt, "--ret-postfix") == 0)
ret_postfix = 1;
else if (strcmp (opt, "--ret-drop") == 0)
ret_drop = 1;
else
{
printf ("FAIL at line %d: unrecognized option %s\n",
@ -307,9 +311,9 @@ main(argc, argv)
cplus_demangle_set_style (style);
result = cplus_demangle (inp,
DMGL_PARAMS|DMGL_ANSI|DMGL_TYPES
|(ret_postfix ? DMGL_RET_POSTFIX : 0));
result = cplus_demangle (inp, (DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES
| (ret_postfix ? DMGL_RET_POSTFIX : 0)
| (ret_drop ? DMGL_RET_DROP : 0)));
if (result
? strcmp (result, expect.data)

Write Preview
Loading…
Cancel
Save