merge from gcc

diff --git a/include/ChangeLog b/include/ChangeLog
index 820c696..42546be 100644 (file)
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -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.

diff --git a/include/demangle.h b/include/demangle.h
index c062455..53f6c54 100644 (file)
--- a/include/demangle.h
+++ b/include/demangle.h
@@ -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)

diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog
index 0e88ea3..0b8977c 100644 (file)
--- a/libiberty/ChangeLog
+++ b/libiberty/ChangeLog
@@ -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

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 7e951cc..3fc5266 100644 (file)
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -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) == '>')

diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected
index 5ce0377..c94eb3c 100644 (file)
--- a/libiberty/testsuite/demangle-expected
+++ b/libiberty/testsuite/demangle-expected
@@ -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.
 #

diff --git a/libiberty/testsuite/test-demangle.c b/libiberty/testsuite/test-demangle.c
index 1c982d6..11d9729 100644 (file)
--- a/libiberty/testsuite/test-demangle.c
+++ b/libiberty/testsuite/test-demangle.c
@@ -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)