[binutils] Update libiberty demangling. (BZ 727453)
Nicholas Clifton
nickc at fedoraproject.org
Tue Aug 2 13:13:30 UTC 2011
commit e39b494e58d3a3a8bc15fb69a2bb1630c577ad74
Author: Nick Clifton <nickc at redhat.com>
Date: Tue Aug 2 14:14:01 2011 +0100
Update libiberty demangling. (BZ 727453)
binutils-2.21.53.0.1-demangle.patch | 1062 +++++++++++++++++++++++++++++++++++
binutils.spec | 7 +-
2 files changed, 1068 insertions(+), 1 deletions(-)
---
diff --git a/binutils-2.21.53.0.1-demangle.patch b/binutils-2.21.53.0.1-demangle.patch
new file mode 100644
index 0000000..4e2f8eb
--- /dev/null
+++ b/binutils-2.21.53.0.1-demangle.patch
@@ -0,0 +1,1062 @@
+diff -rup /usr/src/debug/binutils-2.21.53.0.1/libiberty//cp-demangle.c /usr/src/debug/gcc-4.6.1-20110715/libiberty/cp-demangle.c
+--- binutils-2.21.53.0.1/libiberty//cp-demangle.c 2011-07-17 22:38:06.000000000 +0200
++++ gcc-4.6.1-20110715/libiberty/cp-demangle.c 2011-03-15 15:32:36.000000000 +0100
+@@ -278,6 +278,8 @@ 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];
+@@ -434,7 +436,7 @@ static void
+ d_growable_string_callback_adapter (const char *, size_t, void *);
+
+ static void
+-d_print_init (struct d_print_info *, demangle_callbackref, void *);
++d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
+
+ static inline void d_print_error (struct d_print_info *);
+
+@@ -452,32 +454,32 @@ static inline void d_append_string (stru
+ static inline char d_last_char (struct d_print_info *);
+
+ static void
+-d_print_comp (struct d_print_info *, int, const struct demangle_component *);
++d_print_comp (struct d_print_info *, 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 *, int, struct d_print_mod *, int);
++d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
+
+ static void
+-d_print_mod (struct d_print_info *, int, const struct demangle_component *);
++d_print_mod (struct d_print_info *, const struct demangle_component *);
+
+ static void
+-d_print_function_type (struct d_print_info *, int,
++d_print_function_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
+
+ static void
+-d_print_array_type (struct d_print_info *, int,
++d_print_array_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
+
+ static void
+-d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
++d_print_expr_op (struct d_print_info *, const struct demangle_component *);
+
+ static void
+-d_print_cast (struct d_print_info *, int, const struct demangle_component *);
++d_print_cast (struct d_print_info *, const struct demangle_component *);
+
+ static int d_demangle_callback (const char *, int,
+ demangle_callbackref, void *);
+@@ -2738,18 +2740,10 @@ d_expression (struct d_info *di)
+ /* Function parameter used in a late-specified return type. */
+ int index;
+ d_advance (di, 2);
+- if (d_peek_char (di) == 'T')
+- {
+- /* 'this' parameter. */
+- d_advance (di, 1);
+- index = 0;
+- }
+- else
+- {
+- index = d_compact_number (di) + 1;
+- if (index == 0)
+- return NULL;
+- }
++ index = d_compact_number (di);
++ if (index < 0)
++ return NULL;
++
+ return d_make_function_param (di, index);
+ }
+ else if (IS_DIGIT (peek)
+@@ -3299,9 +3293,10 @@ d_growable_string_callback_adapter (cons
+ /* Initialize a print information structure. */
+
+ static void
+-d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
+- void *opaque)
++d_print_init (struct d_print_info *dpi, int options,
++ demangle_callbackref callback, void *opaque)
+ {
++ dpi->options = options;
+ dpi->len = 0;
+ dpi->last_char = '\0';
+ dpi->templates = NULL;
+@@ -3397,9 +3392,9 @@ cplus_demangle_print_callback (int optio
+ {
+ struct d_print_info dpi;
+
+- d_print_init (&dpi, callback, opaque);
++ d_print_init (&dpi, options, callback, opaque);
+
+- d_print_comp (&dpi, options, dc);
++ d_print_comp (&dpi, dc);
+
+ d_print_flush (&dpi);
+
+@@ -3542,7 +3537,7 @@ d_pack_length (const struct demangle_com
+ if needed. */
+
+ static void
+-d_print_subexpr (struct d_print_info *dpi, int options,
++d_print_subexpr (struct d_print_info *dpi,
+ const struct demangle_component *dc)
+ {
+ int simple = 0;
+@@ -3551,7 +3546,7 @@ d_print_subexpr (struct d_print_info *dp
+ simple = 1;
+ if (!simple)
+ d_append_char (dpi, '(');
+- d_print_comp (dpi, options, dc);
++ d_print_comp (dpi, dc);
+ if (!simple)
+ d_append_char (dpi, ')');
+ }
+@@ -3559,13 +3554,9 @@ d_print_subexpr (struct d_print_info *dp
+ /* Subroutine to handle components. */
+
+ static void
+-d_print_comp (struct d_print_info *dpi, int options,
++d_print_comp (struct d_print_info *dpi,
+ const struct demangle_component *dc)
+ {
+- /* Magic variable to let reference smashing skip over the next modifier
+- without needing to modify *dc. */
+- const struct demangle_component *mod_inner = NULL;
+-
+ if (dc == NULL)
+ {
+ d_print_error (dpi);
+@@ -3577,7 +3568,7 @@ d_print_comp (struct d_print_info *dpi,
+ switch (dc->type)
+ {
+ case DEMANGLE_COMPONENT_NAME:
+- if ((options & DMGL_JAVA) == 0)
++ if ((dpi->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);
+@@ -3585,12 +3576,12 @@ d_print_comp (struct d_print_info *dpi,
+
+ case DEMANGLE_COMPONENT_QUAL_NAME:
+ case DEMANGLE_COMPONENT_LOCAL_NAME:
+- d_print_comp (dpi, options, d_left (dc));
+- if ((options & DMGL_JAVA) == 0)
++ d_print_comp (dpi, d_left (dc));
++ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_string (dpi, "::");
+ else
+ d_append_char (dpi, '.');
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_TYPED_NAME:
+@@ -3680,7 +3671,7 @@ d_print_comp (struct d_print_info *dpi,
+ }
+ }
+
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+
+ if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
+ dpi->templates = dpt.next;
+@@ -3693,7 +3684,7 @@ d_print_comp (struct d_print_info *dpi,
+ if (! adpm[i].printed)
+ {
+ d_append_char (dpi, ' ');
+- d_print_mod (dpi, options, adpm[i].mod);
++ d_print_mod (dpi, adpm[i].mod);
+ }
+ }
+
+@@ -3716,7 +3707,7 @@ d_print_comp (struct d_print_info *dpi,
+
+ dcl = d_left (dc);
+
+- if ((options & DMGL_JAVA) != 0
++ if ((dpi->options & DMGL_JAVA) != 0
+ && dcl->type == DEMANGLE_COMPONENT_NAME
+ && dcl->u.s_name.len == 6
+ && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
+@@ -3724,16 +3715,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, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ d_append_string (dpi, "[]");
+ }
+ else
+ {
+- d_print_comp (dpi, options, dcl);
++ d_print_comp (dpi, dcl);
+ if (d_last_char (dpi) == '<')
+ d_append_char (dpi, ' ');
+ d_append_char (dpi, '<');
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ /* Avoid generating two consecutive '>' characters, to avoid
+ the C++ syntactic ambiguity. */
+ if (d_last_char (dpi) == '>')
+@@ -3768,7 +3759,7 @@ d_print_comp (struct d_print_info *dpi,
+ hold_dpt = dpi->templates;
+ dpi->templates = hold_dpt->next;
+
+- d_print_comp (dpi, options, a);
++ d_print_comp (dpi, a);
+
+ dpi->templates = hold_dpt;
+
+@@ -3776,79 +3767,79 @@ d_print_comp (struct d_print_info *dpi,
+ }
+
+ case DEMANGLE_COMPONENT_CTOR:
+- d_print_comp (dpi, options, dc->u.s_ctor.name);
++ d_print_comp (dpi, dc->u.s_ctor.name);
+ return;
+
+ case DEMANGLE_COMPONENT_DTOR:
+ d_append_char (dpi, '~');
+- d_print_comp (dpi, options, dc->u.s_dtor.name);
++ d_print_comp (dpi, dc->u.s_dtor.name);
+ return;
+
+ case DEMANGLE_COMPONENT_VTABLE:
+ d_append_string (dpi, "vtable for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_VTT:
+ d_append_string (dpi, "VTT for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
+ d_append_string (dpi, "construction vtable for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ d_append_string (dpi, "-in-");
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_TYPEINFO:
+ d_append_string (dpi, "typeinfo for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_TYPEINFO_NAME:
+ d_append_string (dpi, "typeinfo name for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_TYPEINFO_FN:
+ d_append_string (dpi, "typeinfo fn for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_THUNK:
+ d_append_string (dpi, "non-virtual thunk to ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
+ d_append_string (dpi, "virtual thunk to ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_COVARIANT_THUNK:
+ d_append_string (dpi, "covariant return thunk to ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_JAVA_CLASS:
+ d_append_string (dpi, "java Class for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_GUARD:
+ d_append_string (dpi, "guard variable for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_REFTEMP:
+ d_append_string (dpi, "reference temporary for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
+ d_append_string (dpi, "hidden alias for ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_SUB_STD:
+@@ -3875,43 +3866,22 @@ d_print_comp (struct d_print_info *dpi,
+ break;
+ if (pdpm->mod->type == dc->type)
+ {
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+ }
+ }
+ }
+ }
+- goto modifier;
+-
+- case DEMANGLE_COMPONENT_REFERENCE:
+- case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
+- {
+- /* Handle reference smashing: & + && = &. */
+- const struct demangle_component *sub = d_left (dc);
+- if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
+- {
+- struct demangle_component *a = d_lookup_template_argument (dpi, sub);
+- if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
+- a = d_index_template_argument (a, dpi->pack_index);
+- sub = a;
+- }
+-
+- if (sub->type == DEMANGLE_COMPONENT_REFERENCE
+- || sub->type == dc->type)
+- dc = sub;
+- else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
+- mod_inner = d_left (sub);
+- }
+ /* Fall through. */
+-
+ case DEMANGLE_COMPONENT_RESTRICT_THIS:
+ case DEMANGLE_COMPONENT_VOLATILE_THIS:
+ case DEMANGLE_COMPONENT_CONST_THIS:
+ case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+ case DEMANGLE_COMPONENT_POINTER:
++ case DEMANGLE_COMPONENT_REFERENCE:
++ case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
+ case DEMANGLE_COMPONENT_COMPLEX:
+ case DEMANGLE_COMPONENT_IMAGINARY:
+- modifier:
+ {
+ /* We keep a list of modifiers on the stack. */
+ struct d_print_mod dpm;
+@@ -3922,15 +3892,12 @@ d_print_comp (struct d_print_info *dpi,
+ dpm.printed = 0;
+ dpm.templates = dpi->templates;
+
+- if (!mod_inner)
+- mod_inner = d_left (dc);
+-
+- d_print_comp (dpi, options, mod_inner);
++ d_print_comp (dpi, d_left (dc));
+
+ /* If the modifier didn't get printed by the type, print it
+ now. */
+ if (! dpm.printed)
+- d_print_mod (dpi, options, dc);
++ d_print_mod (dpi, dc);
+
+ dpi->modifiers = dpm.next;
+
+@@ -3938,7 +3905,7 @@ d_print_comp (struct d_print_info *dpi,
+ }
+
+ case DEMANGLE_COMPONENT_BUILTIN_TYPE:
+- if ((options & DMGL_JAVA) == 0)
++ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_buffer (dpi, dc->u.s_builtin.type->name,
+ dc->u.s_builtin.type->len);
+ else
+@@ -3947,21 +3914,16 @@ d_print_comp (struct d_print_info *dpi,
+ return;
+
+ case DEMANGLE_COMPONENT_VENDOR_TYPE:
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_FUNCTION_TYPE:
+ {
+- if ((options & DMGL_RET_POSTFIX) != 0)
+- d_print_function_type (dpi,
+- options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+- dc, dpi->modifiers);
++ if ((dpi->options & DMGL_RET_POSTFIX) != 0)
++ d_print_function_type (dpi, dc, dpi->modifiers);
+
+ /* Print return type if present */
+- 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)
++ if (d_left (dc) != NULL)
+ {
+ struct d_print_mod dpm;
+
+@@ -3973,8 +3935,7 @@ d_print_comp (struct d_print_info *dpi,
+ dpm.printed = 0;
+ dpm.templates = dpi->templates;
+
+- d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+- d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+
+ dpi->modifiers = dpm.next;
+
+@@ -3983,14 +3944,12 @@ 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 ((options & DMGL_RET_POSTFIX) == 0)
++ if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+ d_append_char (dpi, ' ');
+ }
+
+- if ((options & DMGL_RET_POSTFIX) == 0)
+- d_print_function_type (dpi,
+- options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
+- dc, dpi->modifiers);
++ if ((dpi->options & DMGL_RET_POSTFIX) == 0)
++ d_print_function_type (dpi, dc, dpi->modifiers);
+
+ return;
+ }
+@@ -4043,7 +4002,7 @@ d_print_comp (struct d_print_info *dpi,
+ pdpm = pdpm->next;
+ }
+
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+
+ dpi->modifiers = hold_modifiers;
+
+@@ -4053,10 +4012,10 @@ d_print_comp (struct d_print_info *dpi,
+ while (i > 1)
+ {
+ --i;
+- d_print_mod (dpi, options, adpm[i].mod);
++ d_print_mod (dpi, adpm[i].mod);
+ }
+
+- d_print_array_type (dpi, options, dc, dpi->modifiers);
++ d_print_array_type (dpi, dc, dpi->modifiers);
+
+ return;
+ }
+@@ -4072,12 +4031,12 @@ d_print_comp (struct d_print_info *dpi,
+ dpm.printed = 0;
+ dpm.templates = dpi->templates;
+
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+
+ /* If the modifier didn't get printed by the type, print it
+ now. */
+ if (! dpm.printed)
+- d_print_mod (dpi, options, dc);
++ d_print_mod (dpi, dc);
+
+ dpi->modifiers = dpm.next;
+
+@@ -4091,7 +4050,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, options, dc->u.s_fixed.length);
++ d_print_comp (dpi, dc->u.s_fixed.length);
+ d_append_char (dpi, ' ');
+ }
+ if (dc->u.s_fixed.accum)
+@@ -4103,7 +4062,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, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ if (d_right (dc) != NULL)
+ {
+ size_t len;
+@@ -4115,7 +4074,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, options, d_right (dc));
++ d_print_comp (dpi, 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)
+@@ -4138,63 +4097,24 @@ d_print_comp (struct d_print_info *dpi,
+
+ case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
+ d_append_string (dpi, "operator ");
+- d_print_comp (dpi, options, dc->u.s_extended_operator.name);
++ d_print_comp (dpi, dc->u.s_extended_operator.name);
+ return;
+
+ case DEMANGLE_COMPONENT_CAST:
+ d_append_string (dpi, "operator ");
+- d_print_cast (dpi, options, dc);
++ d_print_cast (dpi, dc);
+ return;
+
+ case DEMANGLE_COMPONENT_UNARY:
+- if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
+- && d_left (dc)->u.s_operator.op->len == 1
+- && d_left (dc)->u.s_operator.op->name[0] == '&'
+- && d_right (dc)->type == DEMANGLE_COMPONENT_TYPED_NAME
+- && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_QUAL_NAME
+- && d_right (d_right (dc))->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+- {
+- /* Address of a function (therefore in an expression context) must
+- have its argument list suppressed.
+-
+- unary operator ... dc
+- operator & ... d_left (dc)
+- typed name ... d_right (dc)
+- qualified name ... d_left (d_right (dc))
+- <names>
+- function type ... d_right (d_right (dc))
+- argument list
+- <arguments> */
+-
+- d_print_expr_op (dpi, options, d_left (dc));
+- d_print_comp (dpi, options, d_left (d_right (dc)));
+- return;
+- }
+- else if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
+- && d_left (dc)->u.s_operator.op->len == 1
+- && d_left (dc)->u.s_operator.op->name[0] == '&'
+- && d_right (dc)->type == DEMANGLE_COMPONENT_QUAL_NAME)
+- {
+- /* Keep also already processed variant without the argument list.
+-
+- unary operator ... dc
+- operator & ... d_left (dc)
+- qualified name ... d_right (dc)
+- <names> */
+-
+- d_print_expr_op (dpi, options, d_left (dc));
+- d_print_comp (dpi, options, d_right (dc));
+- return;
+- }
+- else if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
+- d_print_expr_op (dpi, options, d_left (dc));
++ if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
++ d_print_expr_op (dpi, d_left (dc));
+ else
+ {
+ d_append_char (dpi, '(');
+- d_print_cast (dpi, options, d_left (dc));
++ d_print_cast (dpi, d_left (dc));
+ d_append_char (dpi, ')');
+ }
+- d_print_subexpr (dpi, options, d_right (dc));
++ d_print_subexpr (dpi, d_right (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_BINARY:
+@@ -4212,32 +4132,18 @@ d_print_comp (struct d_print_info *dpi,
+ && d_left (dc)->u.s_operator.op->name[0] == '>')
+ d_append_char (dpi, '(');
+
+- if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
+- && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
+- {
+- /* Function call used in an expression should not have printed types
+- of the function arguments. Values of the function arguments still
+- get printed below. */
+-
+- const struct demangle_component *func = d_left (d_right (dc));
+-
+- if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
+- d_print_error (dpi);
+- d_print_subexpr (dpi, options, d_left (func));
+- }
+- else
+- d_print_subexpr (dpi, options, d_left (d_right (dc)));
++ d_print_subexpr (dpi, 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, options, d_right (d_right (dc)));
++ d_print_comp (dpi, 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, options, d_left (dc));
+- d_print_subexpr (dpi, options, d_right (d_right (dc)));
++ d_print_expr_op (dpi, d_left (dc));
++ d_print_subexpr (dpi, d_right (d_right (dc)));
+ }
+
+ if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
+@@ -4259,11 +4165,11 @@ d_print_comp (struct d_print_info *dpi,
+ d_print_error (dpi);
+ return;
+ }
+- 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_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_append_string (dpi, " : ");
+- d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
++ d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
+ return;
+
+ case DEMANGLE_COMPONENT_TRINARY_ARG1:
+@@ -4294,7 +4200,7 @@ d_print_comp (struct d_print_info *dpi,
+ {
+ if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
+ d_append_char (dpi, '-');
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ switch (tp)
+ {
+ default:
+@@ -4344,13 +4250,13 @@ d_print_comp (struct d_print_info *dpi,
+ }
+
+ d_append_char (dpi, '(');
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, 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, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+ if (tp == D_PRINT_FLOAT)
+ d_append_char (dpi, ']');
+ }
+@@ -4362,12 +4268,12 @@ d_print_comp (struct d_print_info *dpi,
+
+ case DEMANGLE_COMPONENT_JAVA_RESOURCE:
+ d_append_string (dpi, "java resource ");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_COMPOUND_NAME:
+- d_print_comp (dpi, options, d_left (dc));
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_left (dc));
++ d_print_comp (dpi, d_right (dc));
+ return;
+
+ case DEMANGLE_COMPONENT_CHARACTER:
+@@ -4376,7 +4282,7 @@ d_print_comp (struct d_print_info *dpi,
+
+ case DEMANGLE_COMPONENT_DECLTYPE:
+ d_append_string (dpi, "decltype (");
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ d_append_char (dpi, ')');
+ return;
+
+@@ -4390,7 +4296,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, options, d_left (dc));
++ d_print_subexpr (dpi, d_left (dc));
+ d_append_string (dpi, "...");
+ return;
+ }
+@@ -4400,7 +4306,7 @@ d_print_comp (struct d_print_info *dpi,
+ for (i = 0; i < len; ++i)
+ {
+ dpi->pack_index = i;
+- d_print_comp (dpi, options, dc);
++ d_print_comp (dpi, dc);
+ if (i < len-1)
+ d_append_string (dpi, ", ");
+ }
+@@ -4408,32 +4314,24 @@ d_print_comp (struct d_print_info *dpi,
+ return;
+
+ case DEMANGLE_COMPONENT_FUNCTION_PARAM:
+- {
+- long num = dc->u.s_number.number;
+- if (num == 0)
+- d_append_string (dpi, "this");
+- else
+- {
+- d_append_string (dpi, "{parm#");
+- d_append_num (dpi, num);
+- d_append_char (dpi, '}');
+- }
+- }
++ d_append_string (dpi, "{parm#");
++ d_append_num (dpi, dc->u.s_number.number + 1);
++ d_append_char (dpi, '}');
+ return;
+
+ case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
+ d_append_string (dpi, "global constructors keyed to ");
+- d_print_comp (dpi, options, dc->u.s_binary.left);
++ d_print_comp (dpi, dc->u.s_binary.left);
+ return;
+
+ case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
+ d_append_string (dpi, "global destructors keyed to ");
+- d_print_comp (dpi, options, dc->u.s_binary.left);
++ d_print_comp (dpi, dc->u.s_binary.left);
+ return;
+
+ case DEMANGLE_COMPONENT_LAMBDA:
+ d_append_string (dpi, "{lambda(");
+- d_print_comp (dpi, options, dc->u.s_unary_num.sub);
++ d_print_comp (dpi, 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, '}');
+@@ -4507,7 +4405,7 @@ d_print_java_identifier (struct d_print_
+ qualifiers on this after printing a function. */
+
+ static void
+-d_print_mod_list (struct d_print_info *dpi, int options,
++d_print_mod_list (struct d_print_info *dpi,
+ struct d_print_mod *mods, int suffix)
+ {
+ struct d_print_template *hold_dpt;
+@@ -4521,7 +4419,7 @@ d_print_mod_list (struct d_print_info *d
+ || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
+ || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
+ {
+- d_print_mod_list (dpi, options, mods->next, suffix);
++ d_print_mod_list (dpi, mods->next, suffix);
+ return;
+ }
+
+@@ -4532,13 +4430,13 @@ d_print_mod_list (struct d_print_info *d
+
+ if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+ {
+- d_print_function_type (dpi, options, mods->mod, mods->next);
++ d_print_function_type (dpi, mods->mod, mods->next);
+ dpi->templates = hold_dpt;
+ return;
+ }
+ else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
+ {
+- d_print_array_type (dpi, options, mods->mod, mods->next);
++ d_print_array_type (dpi, mods->mod, mods->next);
+ dpi->templates = hold_dpt;
+ return;
+ }
+@@ -4554,10 +4452,10 @@ d_print_mod_list (struct d_print_info *d
+
+ hold_modifiers = dpi->modifiers;
+ dpi->modifiers = NULL;
+- d_print_comp (dpi, options, d_left (mods->mod));
++ d_print_comp (dpi, d_left (mods->mod));
+ dpi->modifiers = hold_modifiers;
+
+- if ((options & DMGL_JAVA) == 0)
++ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_string (dpi, "::");
+ else
+ d_append_char (dpi, '.');
+@@ -4577,23 +4475,23 @@ d_print_mod_list (struct d_print_info *d
+ || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
+ dc = d_left (dc);
+
+- d_print_comp (dpi, options, dc);
++ d_print_comp (dpi, dc);
+
+ dpi->templates = hold_dpt;
+ return;
+ }
+
+- d_print_mod (dpi, options, mods->mod);
++ d_print_mod (dpi, mods->mod);
+
+ dpi->templates = hold_dpt;
+
+- d_print_mod_list (dpi, options, mods->next, suffix);
++ d_print_mod_list (dpi, mods->next, suffix);
+ }
+
+ /* Print a modifier. */
+
+ static void
+-d_print_mod (struct d_print_info *dpi, int options,
++d_print_mod (struct d_print_info *dpi,
+ const struct demangle_component *mod)
+ {
+ switch (mod->type)
+@@ -4612,11 +4510,11 @@ d_print_mod (struct d_print_info *dpi, i
+ return;
+ case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
+ d_append_char (dpi, ' ');
+- d_print_comp (dpi, options, d_right (mod));
++ d_print_comp (dpi, d_right (mod));
+ return;
+ case DEMANGLE_COMPONENT_POINTER:
+ /* There is no pointer symbol in Java. */
+- if ((options & DMGL_JAVA) == 0)
++ if ((dpi->options & DMGL_JAVA) == 0)
+ d_append_char (dpi, '*');
+ return;
+ case DEMANGLE_COMPONENT_REFERENCE:
+@@ -4634,22 +4532,22 @@ d_print_mod (struct d_print_info *dpi, i
+ case DEMANGLE_COMPONENT_PTRMEM_TYPE:
+ if (d_last_char (dpi) != '(')
+ d_append_char (dpi, ' ');
+- d_print_comp (dpi, options, d_left (mod));
++ d_print_comp (dpi, d_left (mod));
+ d_append_string (dpi, "::*");
+ return;
+ case DEMANGLE_COMPONENT_TYPED_NAME:
+- d_print_comp (dpi, options, d_left (mod));
++ d_print_comp (dpi, d_left (mod));
+ return;
+ case DEMANGLE_COMPONENT_VECTOR_TYPE:
+ d_append_string (dpi, " __vector(");
+- d_print_comp (dpi, options, d_left (mod));
++ d_print_comp (dpi, 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, options, mod);
++ d_print_comp (dpi, mod);
+ return;
+ }
+ }
+@@ -4657,7 +4555,7 @@ d_print_mod (struct d_print_info *dpi, i
+ /* Print a function type, except for the return type. */
+
+ static void
+-d_print_function_type (struct d_print_info *dpi, int options,
++d_print_function_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
+ {
+@@ -4717,7 +4615,7 @@ d_print_function_type (struct d_print_in
+ hold_modifiers = dpi->modifiers;
+ dpi->modifiers = NULL;
+
+- d_print_mod_list (dpi, options, mods, 0);
++ d_print_mod_list (dpi, mods, 0);
+
+ if (need_paren)
+ d_append_char (dpi, ')');
+@@ -4725,11 +4623,11 @@ d_print_function_type (struct d_print_in
+ d_append_char (dpi, '(');
+
+ if (d_right (dc) != NULL)
+- d_print_comp (dpi, options, d_right (dc));
++ d_print_comp (dpi, d_right (dc));
+
+ d_append_char (dpi, ')');
+
+- d_print_mod_list (dpi, options, mods, 1);
++ d_print_mod_list (dpi, mods, 1);
+
+ dpi->modifiers = hold_modifiers;
+ }
+@@ -4737,7 +4635,7 @@ d_print_function_type (struct d_print_in
+ /* Print an array type, except for the element type. */
+
+ static void
+-d_print_array_type (struct d_print_info *dpi, int options,
++d_print_array_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
+ {
+@@ -4771,7 +4669,7 @@ d_print_array_type (struct d_print_info
+ if (need_paren)
+ d_append_string (dpi, " (");
+
+- d_print_mod_list (dpi, options, mods, 0);
++ d_print_mod_list (dpi, mods, 0);
+
+ if (need_paren)
+ d_append_char (dpi, ')');
+@@ -4783,7 +4681,7 @@ d_print_array_type (struct d_print_info
+ d_append_char (dpi, '[');
+
+ if (d_left (dc) != NULL)
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+
+ d_append_char (dpi, ']');
+ }
+@@ -4791,24 +4689,24 @@ d_print_array_type (struct d_print_info
+ /* Print an operator in an expression. */
+
+ static void
+-d_print_expr_op (struct d_print_info *dpi, int options,
++d_print_expr_op (struct d_print_info *dpi,
+ 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, options, dc);
++ d_print_comp (dpi, dc);
+ }
+
+ /* Print a cast. */
+
+ static void
+-d_print_cast (struct d_print_info *dpi, int options,
++d_print_cast (struct d_print_info *dpi,
+ const struct demangle_component *dc)
+ {
+ if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
+- d_print_comp (dpi, options, d_left (dc));
++ d_print_comp (dpi, d_left (dc));
+ else
+ {
+ struct d_print_mod *hold_dpm;
+@@ -4826,14 +4724,14 @@ d_print_cast (struct d_print_info *dpi,
+ dpi->templates = &dpt;
+ dpt.template_decl = d_left (dc);
+
+- d_print_comp (dpi, options, d_left (d_left (dc)));
++ d_print_comp (dpi, 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, options, d_right (d_left (dc)));
++ d_print_comp (dpi, d_right (d_left (dc)));
+ /* Avoid generating two consecutive '>' characters, to avoid
+ the C++ syntactic ambiguity. */
+ if (d_last_char (dpi) == '>')
+Only in /usr/src/debug/binutils-2.21.53.0.1/libiberty/: cp-demint.c
+diff -rup /usr/src/debug/binutils-2.21.53.0.1/libiberty//cplus-dem.c /usr/src/debug/gcc-4.6.1-20110715/libiberty/cplus-dem.c
+--- binutils-2.21.53.0.1/libiberty//cplus-dem.c 2011-05-08 16:17:47.000000000 +0200
++++ gcc-4.6.1-20110715/libiberty/cplus-dem.c 2011-03-15 15:32:36.000000000 +0100
+@@ -1311,7 +1311,8 @@ delete_non_B_K_work_stuff (struct work_s
+ int i;
+
+ for (i = 0; i < work->ntmpl_args; i++)
+- free ((char*) work->tmpl_argvec[i]);
++ if (work->tmpl_argvec[i])
++ free ((char*) work->tmpl_argvec[i]);
+
+ free ((char*) work->tmpl_argvec);
+ work->tmpl_argvec = NULL;
+Only in /usr/src/debug/binutils-2.21.53.0.1/libiberty/: crc32.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: fibheap.c
+diff -rup /usr/src/debug/binutils-2.21.53.0.1/libiberty//filename_cmp.c /usr/src/debug/gcc-4.6.1-20110715/libiberty/filename_cmp.c
+--- binutils-2.21.53.0.1/libiberty//filename_cmp.c 2011-07-17 22:38:06.000000000 +0200
++++ gcc-4.6.1-20110715/libiberty/filename_cmp.c 2011-03-15 15:32:36.000000000 +0100
+@@ -50,27 +50,19 @@ and backward slashes are equal.
+ int
+ filename_cmp (const char *s1, const char *s2)
+ {
+-#if !defined(HAVE_DOS_BASED_FILE_SYSTEM) \
+- && !defined(HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
++#ifndef HAVE_DOS_BASED_FILE_SYSTEM
+ return strcmp(s1, s2);
+ #else
+ for (;;)
+ {
+- int c1 = *s1;
+- int c2 = *s2;
++ int c1 = TOLOWER (*s1);
++ int c2 = TOLOWER (*s2);
+
+-#if defined (HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
+- c1 = TOLOWER (c1);
+- c2 = TOLOWER (c2);
+-#endif
+-
+-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ /* On DOS-based file systems, the '/' and the '\' are equivalent. */
+ if (c1 == '/')
+ c1 = '\\';
+ if (c2 == '/')
+ c2 = '\\';
+-#endif
+
+ if (c1 != c2)
+ return (c1 - c2);
+@@ -108,29 +100,21 @@ and backward slashes are equal.
+ int
+ filename_ncmp (const char *s1, const char *s2, size_t n)
+ {
+-#if !defined(HAVE_DOS_BASED_FILE_SYSTEM) \
+- && !defined(HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
++#ifndef HAVE_DOS_BASED_FILE_SYSTEM
+ return strncmp(s1, s2, n);
+ #else
+ if (!n)
+ return 0;
+ for (; n > 0; --n)
+ {
+- int c1 = *s1;
+- int c2 = *s2;
++ int c1 = TOLOWER (*s1);
++ int c2 = TOLOWER (*s2);
+
+-#if defined (HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
+- c1 = TOLOWER (c1);
+- c2 = TOLOWER (c2);
+-#endif
+-
+-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
+ /* On DOS-based file systems, the '/' and the '\' are equivalent. */
+ if (c1 == '/')
+ c1 = '\\';
+ if (c2 == '/')
+ c2 = '\\';
+-#endif
+
+ if (c1 == '\0' || c1 != c2)
+ return (c1 - c2);
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: fopen_unlocked.c
+Only in /usr/src/debug/binutils-2.21.53.0.1/libiberty/: objalloc.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: partition.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: pex-common.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: pex-common.h
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: pex-unix.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: physmem.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: regex.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: setproctitle.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: simple-object.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: simple-object-coff.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: simple-object-common.h
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: simple-object-elf.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: simple-object-mach-o.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: splay-tree.c
+Only in /usr/src/debug/binutils-2.21.53.0.1/libiberty/: xatexit.c
+Only in /usr/src/debug/gcc-4.6.1-20110715/libiberty: xmemdup.c
diff --git a/binutils.spec b/binutils.spec
index c95f9a9..82b7d3a 100644
--- a/binutils.spec
+++ b/binutils.spec
@@ -17,7 +17,7 @@
Summary: A GNU collection of binary utilities
Name: %{?cross}binutils%{?_with_debug:-debug}
Version: 2.21.53.0.1
-Release: 2%{?dist}
+Release: 3%{?dist}
License: GPLv3+
Group: Development/Tools
URL: http://sources.redhat.com/binutils
@@ -32,6 +32,7 @@ Patch06: binutils-2.20.51.0.10-copy-osabi.patch
Patch07: binutils-2.20.51.0.10-sec-merge-emit.patch
Patch08: binutils-2.20.51.0.2-build-id.patch
Patch09: binutils-2.21.53.0.1-debug_macro.patch
+Patch10: binutils-2.21.53.0.1-demangle.patch
%define gold_arches %ix86 x86_64
@@ -131,6 +132,7 @@ using libelf instead of BFD.
%patch07 -p0 -b .sec-merge-emit~
%patch08 -p0 -b .build-id~
%patch09 -p0 -b .debug_macro~
+%patch10 -p1 -b .demangle~
# We cannot run autotools as there is an exact requirement of autoconf-2.59.
@@ -420,6 +422,9 @@ exit 0
%endif # %{isnative}
%changelog
+* Tue Aug 02 2011 Nick Clifton <nickc at redhat.com> - 2.21.53.0.1-3
+- Update libierty demangling. (BZ 727453)
+
* Wed Jul 27 2011 Nick Clifton <nickc at redhat.com> - 2.21.53.0.1-2
- Import Jakub Jelinek's patch to add support for displaying the contents of .debug_macro sections.
More information about the scm-commits
mailing list