Changeset 78bbe4c in rtems-tools


Ignore:
Timestamp:
Aug 16, 2017, 8:09:59 AM (2 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
master
Children:
f2bb439
Parents:
0ea1c27
git-author:
Chris Johns <chrisj@…> (08/16/17 08:09:59)
git-committer:
Chris Johns <chrisj@…> (08/16/17 08:18:35)
Message:

linkers/exe-info Support ARM static constructors.

Note, ARM destructors are registered at runtime and currently not
easly found.

Update libiberty to get a newer demangler.

Closes #3102.

Files:
7 added
26 edited

Legend:

Unmodified
Added
Removed
  • linkers/rtems-exeinfo.cpp

    r0ea1c27 r78bbe4c  
    5757  {
    5858    /**
    59      * Sections we decode.
    60      */
    61     const char* init_sections[] =
     59     * Default section list.
     60     */
     61    const char* default_init[] =
    6262    {
    6363      ".rtemsroset",
    6464      ".ctors",
     65      ".init",
    6566      0
    6667    };
    6768
    68     const char* fini_sections[] =
     69    const char* default_fini[] =
    6970    {
    7071      ".dtors",
     72      ".fini",
    7173      0
    7274    };
    7375
    7476    /**
     77     * ARM section list.
     78     */
     79    const char* arm_init[] =
     80    {
     81      ".rtemsroset",
     82      ".init_array",
     83      0
     84    };
     85
     86    const char* arm_fini[] =
     87    {
     88      ".fini_array",
     89      0
     90    };
     91
     92    /**
    7593     * An executable section's address, offset, size and alignment.
    7694     */
    7795    struct section
    7896    {
    79       const files::section& sec;      //< The executable's section.
    80       buffer::buffer        data;     //< The section's data.
     97      const files::section& sec;        //< The executable's section.
     98      buffer::buffer        data;       //< The section's data.
     99      files::byteorder      byteorder;  //< The image's byteorder.
    81100
    82101      /**
    83102       * Construct the section.
    84103       */
    85       section (const files::section& sec);
     104      section (const files::section& sec, files::byteorder byteorder);
    86105
    87106      /**
     
    112131    struct image
    113132    {
    114       files::object    exe;       //< The object file that is the executable.
    115       symbols::table   symbols;   //< The synbols for a map.
    116       symbols::addrtab addresses; //< The symbols keyed by address.
    117       files::sections  secs;      //< The sections in the executable.
     133      files::object    exe;         //< The object file that is the executable.
     134      symbols::table   symbols;     //< The synbols for a map.
     135      symbols::addrtab addresses;   //< The symbols keyed by address.
     136      files::sections  secs;        //< The sections in the executable.
     137      const char**     init;        //< The init section's list for the machinetype.
     138      const char**     fini;        //< The fini section's list for the machinetype.
     139
    118140
    119141      /**
     
    148170    };
    149171
    150     section::section (const files::section& sec)
     172    section::section (const files::section& sec, files::byteorder byteorder)
    151173      : sec (sec),
    152         data (sec.size)
     174        data (sec.size),
     175        byteorder (byteorder)
    153176    {
    154177    }
     
    219242                      << " added" << std::endl;
    220243
    221           section sec (fsec);
     244          section sec (fsec, img.exe.get_byteorder ());
    222245          img.exe.seek (fsec.offset);
    223246          sec.data.read (img.exe, fsec.size);
     
    229252
    230253    image::image (const std::string exe_name)
    231       : exe (exe_name)
     254      : exe (exe_name),
     255        init (0),
     256        fini (0)
    232257    {
    233258      /*
     
    240265        throw rld::error ("Not valid: " + exe.name ().full (),
    241266                          "init::image");
     267
     268      /*
     269       * Set up the section lists for the machiner type.
     270       */
     271      switch (exe.elf ().machinetype ())
     272      {
     273        case EM_ARM:
     274          init = arm_init;
     275          fini = arm_fini;
     276          break;
     277        default:
     278          init  = default_init;
     279          fini  = default_fini;
     280          break;
     281      }
    242282
    243283      /*
     
    260300    {
    261301      std::cout << "Sections: " << secs.size () << std::endl;
     302
     303      size_t max_section_name = 0;
     304
     305      for (files::sections::const_iterator si = secs.begin ();
     306           si != secs.end ();
     307           ++si)
     308      {
     309        const files::section& sec = *si;
     310        if (sec.name.length() > max_section_name)
     311          max_section_name = sec.name.length();
     312      }
    262313
    263314      for (files::sections::const_iterator si = secs.begin ();
     
    287338
    288339        std::cout << "  " << std::left
    289                   << std::setw (15) << sec.name
     340                  << std::setw (max_section_name) << sec.name
    290341                  << " " << flags
    291342                  << std::right << std::hex << std::setfill ('0')
    292                   << " address: 0x" << std::setw (8) << sec.address
     343                  << " addr: 0x" << std::setw (8) << sec.address
    293344                  << " 0x" << std::setw (8) << sec.address + sec.size
    294345                  << std::dec << std::setfill (' ')
    295                   << " size: " << std::setw (7) << sec.size
     346                  << " size: " << std::setw (10) << sec.size
    296347                  << " align: " << std::setw (3) << sec.alignment
    297                   << " relocs: " << std::setw (4) << sec.relocs.size ()
     348                  << " relocs: " << std::setw (6) << sec.relocs.size ()
    298349                  << std::endl;
    299350      }
     
    305356    image::output_init ()
    306357    {
    307       output_init_fini ("Init", init_sections);
     358      output_init_fini ("Init", init);
    308359    }
    309360
     
    311362    image::output_fini ()
    312363    {
    313       output_init_fini ("Fini", fini_sections);
     364      output_init_fini ("Fini", fini);
    314365    }
    315366
     
    348399          if (sym)
    349400          {
    350             /*
    351              * C++ is adding '_GLOBAL__sub_I_' to the label. If present, strip
    352              * and check the label.
    353              */
    354401            std::string label = sym->name ();
    355             if (rld::starts_with (label, "_GLOBAL__sub_I_"))
    356               label = rld::find_replace (label, "_GLOBAL__sub_I_", "");
    357402            if (rld::symbols::is_cplusplus (label))
    358403              rld::symbols::demangle_name (label, label);
  • rtemstoolkit/libiberty/ansidecl.h

    r0ea1c27 r78bbe4c  
    11/* ANSI and traditional C compatability macros
    2    Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
    3    2002, 2003, 2004, 2005, 2006, 2007, 2009
    4    Free Software Foundation, Inc.
     2   Copyright (C) 1991-2017 Free Software Foundation, Inc.
    53   This file is part of the GNU C Library.
    64
     
    2523   Macro                ANSI C definition       Traditional C definition
    2624   -----                ---- - ----------       ----------- - ----------
    27    ANSI_PROTOTYPES      1                       not defined
    2825   PTR                  `void *'                `char *'
    29    PTRCONST             `void *const'           `char *'
    30    LONG_DOUBLE          `long double'           `double'
    3126   const                not defined             `'
    3227   volatile             not defined             `'
    3328   signed               not defined             `'
    34    VA_START(ap, var)    va_start(ap, var)       va_start(ap)
    35 
    36    Note that it is safe to write "void foo();" indicating a function
    37    with no return value, in all K+R compilers we have been able to test.
    38 
    39    For declaring functions with prototypes, we also provide these:
    40 
    41    PARAMS ((prototype))
    42    -- for functions which take a fixed number of arguments.  Use this
    43    when declaring the function.  When defining the function, write a
    44    K+R style argument list.  For example:
    45 
    46         char *strcpy PARAMS ((char *dest, char *source));
    47         ...
    48         char *
    49         strcpy (dest, source)
    50              char *dest;
    51              char *source;
    52         { ... }
    53 
    54 
    55    VPARAMS ((prototype, ...))
    56    -- for functions which take a variable number of arguments.  Use
    57    PARAMS to declare the function, VPARAMS to define it.  For example:
    58 
    59         int printf PARAMS ((const char *format, ...));
    60         ...
    61         int
    62         printf VPARAMS ((const char *format, ...))
    63         {
    64            ...
    65         }
    66 
    67    For writing functions which take variable numbers of arguments, we
    68    also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
    69    hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
    70    thoroughly than the simple VA_START() macro mentioned above.
    71 
    72    VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
    73    Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
    74    corresponding to the list of fixed arguments.  Then use va_arg
    75    normally to get the variable arguments, or pass your va_list object
    76    around.  You do not declare the va_list yourself; VA_OPEN does it
    77    for you.
    78 
    79    Here is a complete example:
    80 
    81         int
    82         printf VPARAMS ((const char *format, ...))
    83         {
    84            int result;
    85 
    86            VA_OPEN (ap, format);
    87            VA_FIXEDARG (ap, const char *, format);
    88 
    89            result = vfprintf (stdout, format, ap);
    90            VA_CLOSE (ap);
    91 
    92            return result;
    93         }
    94 
    95 
    96    You can declare variables either before or after the VA_OPEN,
    97    VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
    98    and end of a block.  They must appear at the same nesting level,
    99    and any variables declared after VA_OPEN go out of scope at
    100    VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
    101    argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
    102    pairs in a single function in case you need to traverse the
    103    argument list more than once.
    10429
    10530   For ease of writing code which uses GCC extensions but needs to be
     
    10732   simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
    10833   wrappers around __attribute__.  Also, __extension__ will be #defined
    109    to nothing if it doesn't work.  See below.
    110 
    111    This header also defines a lot of obsolete macros:
    112    CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
    113    AND, DOTS, NOARGS.  Don't use them.  */
     34   to nothing if it doesn't work.  See below.  */
    11435
    11536#ifndef _ANSIDECL_H
     
    15071   was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
    15172
    152 #define ANSI_PROTOTYPES 1
    15373#define PTR             void *
    154 #define PTRCONST        void *const
    155 #define LONG_DOUBLE     long double
    156 
    157 /* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
    158    a #ifndef.  */
    159 #ifndef PARAMS
    160 #define PARAMS(ARGS)            ARGS
    161 #endif
    162 
    163 #define VPARAMS(ARGS)           ARGS
    164 #define VA_START(VA_LIST, VAR)  va_start(VA_LIST, VAR)
    165 
    166 /* variadic function helper macros */
    167 /* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
    168    use without inhibiting further decls and without declaring an
    169    actual variable.  */
    170 #define VA_OPEN(AP, VAR)        { va_list AP; va_start(AP, VAR); { struct Qdmy
    171 #define VA_CLOSE(AP)            } va_end(AP); }
    172 #define VA_FIXEDARG(AP, T, N)   struct Qdmy
    173  
     74
    17475#undef const
    17576#undef volatile
     
    17980   it too, but it's not in C89.  */
    18081#undef inline
    181 #if __STDC_VERSION__ > 199901L || defined(__cplusplus)
     82#if __STDC_VERSION__ >= 199901L || defined(__cplusplus) || (defined(__SUNPRO_C) && defined(__C99FEATURES__))
    18283/* it's a keyword */
    18384#else
     
    18990#endif
    19091
    191 /* These are obsolete.  Do not use.  */
    192 #ifndef IN_GCC
    193 #define CONST           const
    194 #define VOLATILE        volatile
    195 #define SIGNED          signed
    196 
    197 #define PROTO(type, name, arglist)      type name arglist
    198 #define EXFUN(name, proto)              name proto
    199 #define DEFUN(name, arglist, args)      name(args)
    200 #define DEFUN_VOID(name)                name(void)
    201 #define AND             ,
    202 #define DOTS            , ...
    203 #define NOARGS          void
    204 #endif /* ! IN_GCC */
    205 
    20692#else   /* Not ANSI C.  */
    20793
    208 #undef  ANSI_PROTOTYPES
    20994#define PTR             char *
    210 #define PTRCONST        PTR
    211 #define LONG_DOUBLE     double
    212 
    213 #define PARAMS(args)            ()
    214 #define VPARAMS(args)           (va_alist) va_dcl
    215 #define VA_START(va_list, var)  va_start(va_list)
    216 
    217 #define VA_OPEN(AP, VAR)                { va_list AP; va_start(AP); { struct Qdmy
    218 #define VA_CLOSE(AP)                    } va_end(AP); }
    219 #define VA_FIXEDARG(AP, TYPE, NAME)     TYPE NAME = va_arg(AP, TYPE)
    22095
    22196/* some systems define these in header files for non-ansi mode */
     
    229104#define inline
    230105
    231 #ifndef IN_GCC
    232 #define CONST
    233 #define VOLATILE
    234 #define SIGNED
    235 
    236 #define PROTO(type, name, arglist)      type name ()
    237 #define EXFUN(name, proto)              name()
    238 #define DEFUN(name, arglist, args)      name arglist args;
    239 #define DEFUN_VOID(name)                name()
    240 #define AND             ;
    241 #define DOTS
    242 #define NOARGS
    243 #endif /* ! IN_GCC */
    244 
    245106#endif  /* ANSI C.  */
    246107
     
    280141#endif
    281142
     143/* Similarly to ARG_UNUSED below.  Prior to GCC 3.4, the C++ frontend
     144   couldn't parse attributes placed after the identifier name, and now
     145   the entire compiler is built with C++.  */
    282146#ifndef ATTRIBUTE_UNUSED
    283 #define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
     147#if GCC_VERSION >= 3004
     148#  define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
     149#else
     150#define ATTRIBUTE_UNUSED
     151#endif
    284152#endif /* ATTRIBUTE_UNUSED */
    285153
     
    304172# endif /* GNUC >= 3.3 */
    305173#endif /* ATTRIBUTE_NONNULL */
     174
     175/* Attribute `returns_nonnull' was valid as of gcc 4.9.  */
     176#ifndef ATTRIBUTE_RETURNS_NONNULL
     177# if (GCC_VERSION >= 4009)
     178#  define ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__))
     179# else
     180#  define ATTRIBUTE_RETURNS_NONNULL
     181# endif /* GNUC >= 4.9 */
     182#endif /* ATTRIBUTE_RETURNS_NONNULL */
    306183
    307184/* Attribute `pure' was valid as of gcc 3.0.  */
     
    376253#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */
    377254
    378 /* Useful for structures whose layout must much some binary specification
     255/* Useful for structures whose layout must match some binary specification
    379256   regardless of the alignment and padding qualities of the compiler.  */
    380257#ifndef ATTRIBUTE_PACKED
     
    397274# endif /* GNUC >= 4.3 */
    398275#endif /* ATTRIBUTE_HOT */
     276
     277/* Attribute 'no_sanitize_undefined' was valid as of gcc 4.9.  */
     278#ifndef ATTRIBUTE_NO_SANITIZE_UNDEFINED
     279# if (GCC_VERSION >= 4009)
     280#  define ATTRIBUTE_NO_SANITIZE_UNDEFINED __attribute__ ((no_sanitize_undefined))
     281# else
     282#  define ATTRIBUTE_NO_SANITIZE_UNDEFINED
     283# endif /* GNUC >= 4.9 */
     284#endif /* ATTRIBUTE_NO_SANITIZE_UNDEFINED */
    399285
    400286/* We use __extension__ in some places to suppress -pedantic warnings
     
    417303#endif
    418304
     305/* Be conservative and only use enum bitfields with C++ or GCC.
     306   FIXME: provide a complete autoconf test for buggy enum bitfields.  */
     307
     308#ifdef __cplusplus
     309#define ENUM_BITFIELD(TYPE) enum TYPE
     310#elif (GCC_VERSION > 2000)
     311#define ENUM_BITFIELD(TYPE) __extension__ enum TYPE
     312#else
     313#define ENUM_BITFIELD(TYPE) unsigned int
     314#endif
     315
     316#if __cpp_constexpr >= 200704
     317#define CONSTEXPR constexpr
     318#else
     319#define CONSTEXPR
     320#endif
     321
     322/* C++11 adds the ability to add "override" after an implementation of a
     323   virtual function in a subclass, to:
     324     (A) document that this is an override of a virtual function
     325     (B) allow the compiler to issue a warning if it isn't (e.g. a mismatch
     326         of the type signature).
     327
     328   Similarly, it allows us to add a "final" to indicate that no subclass
     329   may subsequently override the vfunc.
     330
     331   Provide OVERRIDE and FINAL as macros, allowing us to get these benefits
     332   when compiling with C++11 support, but without requiring C++11.
     333
     334   For gcc, use "-std=c++11" to enable C++11 support; gcc 6 onwards enables
     335   this by default (actually GNU++14).  */
     336
     337#if __cplusplus >= 201103
     338/* C++11 claims to be available: use it.  final/override were only
     339   implemented in 4.7, though.  */
     340# if GCC_VERSION < 4007
     341#  define OVERRIDE
     342#  define FINAL
     343# else
     344#  define OVERRIDE override
     345#  define FINAL final
     346# endif
     347#elif GCC_VERSION >= 4007
     348/* G++ 4.7 supports __final in C++98.  */
     349# define OVERRIDE
     350# define FINAL __final
     351#else
     352/* No C++11 support; leave the macros empty: */
     353# define OVERRIDE
     354# define FINAL
     355#endif
     356
    419357#ifdef __cplusplus
    420358}
  • rtemstoolkit/libiberty/concat.c

    r0ea1c27 r78bbe4c  
    11/* Concatenate variable number of strings.
    2    Copyright (C) 1991, 1994, 2001, 2011 Free Software Foundation, Inc.
     2   Copyright (C) 1991-2017 Free Software Foundation, Inc.
    33   Written by Fred Fish @ Cygnus Support
    44
     
    2626
    2727Concatenate zero or more of strings and return the result in freshly
    28 @code{xmalloc}ed memory.  Returns @code{NULL} if insufficient memory is
    29 available.  The argument list is terminated by the first @code{NULL}
    30 pointer encountered.  Pointers to empty strings are ignored.
     28@code{xmalloc}ed memory.  The argument list is terminated by the first
     29@code{NULL} pointer encountered.  Pointers to empty strings are ignored.
    3130
    3231@end deftypefn
    33 
    34 NOTES
    35 
    36         This function uses xmalloc() which is expected to be a front end
    37         function to malloc() that deals with low memory situations.  In
    38         typical use, if malloc() returns NULL then xmalloc() diverts to an
    39         error handler routine which never returns, and thus xmalloc will
    40         never return a NULL pointer.  If the client application wishes to
    41         deal with low memory situations itself, it should supply an xmalloc
    42         that just directly invokes malloc and blindly returns whatever
    43         malloc returns.
    4432
    4533*/
     
    10391{
    10492  unsigned long length;
    105 
    106   VA_OPEN (args, first);
    107   VA_FIXEDARG (args, const char *, first);
     93  va_list args;
     94
     95  va_start (args, first);
    10896  length = vconcat_length (first, args);
    109   VA_CLOSE (args);
     97  va_end (args);
    11098
    11199  return length;
     
    118106{
    119107  char *save_dst;
    120 
    121   VA_OPEN (args, first);
    122   VA_FIXEDARG (args, char *, dst);
    123   VA_FIXEDARG (args, const char *, first);
     108  va_list args;
     109
     110  va_start (args, first);
    124111  vconcat_copy (dst, first, args);
    125112  save_dst = dst; /* With K&R C, dst goes out of scope here.  */
    126   VA_CLOSE (args);
     113  va_end (args);
    127114
    128115  return save_dst;
     
    142129concat_copy2 (const char *first, ...)
    143130{
    144   VA_OPEN (args, first);
    145   VA_FIXEDARG (args, const char *, first);
     131  va_list args;
     132  va_start (args, first);
    146133  vconcat_copy (libiberty_concat_ptr, first, args);
    147   VA_CLOSE (args);
     134  va_end (args);
    148135
    149136  return libiberty_concat_ptr;
     
    154141{
    155142  char *newstr;
     143  va_list args;
    156144
    157145  /* First compute the size of the result and get sufficient memory.  */
    158   VA_OPEN (args, first);
    159   VA_FIXEDARG (args, const char *, first);
     146  va_start (args, first);
    160147  newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
    161   VA_CLOSE (args);
     148  va_end (args);
    162149
    163150  /* Now copy the individual pieces to the result string. */
    164   VA_OPEN (args, first);
    165   VA_FIXEDARG (args, const char *, first);
     151  va_start (args, first);
    166152  vconcat_copy (newstr, first, args);
    167   VA_CLOSE (args);
     153  va_end (args);
    168154
    169155  return newstr;
     
    192178{
    193179  char *newstr;
     180  va_list args;
    194181
    195182  /* First compute the size of the result and get sufficient memory.  */
    196   VA_OPEN (args, first);
    197   VA_FIXEDARG (args, char *, optr);
    198   VA_FIXEDARG (args, const char *, first);
     183  va_start (args, first);
    199184  newstr = XNEWVEC (char, vconcat_length (first, args) + 1);
    200   VA_CLOSE (args);
     185  va_end (args);
    201186
    202187  /* Now copy the individual pieces to the result string. */
    203   VA_OPEN (args, first);
    204   VA_FIXEDARG (args, char *, optr);
    205   VA_FIXEDARG (args, const char *, first);
     188  va_start (args, first);
    206189  vconcat_copy (newstr, first, args);
    207190  if (optr) /* Done before VA_CLOSE so optr stays in scope for K&R C.  */
    208191    free (optr);
    209   VA_CLOSE (args);
     192  va_end (args);
    210193
    211194  return newstr;
  • rtemstoolkit/libiberty/cp-demangle.c

    r0ea1c27 r78bbe4c  
    11/* Demangler for g++ V3 ABI.
    2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
    3    Free Software Foundation, Inc.
     2   Copyright (C) 2003-2017 Free Software Foundation, Inc.
    43   Written by Ian Lance Taylor <ian@wasabisystems.com>.
    54
     
    9493      If defined, turns on debugging mode, which prints information on
    9594      stdout about the mangled string.  This is not generally useful.
    96 */
     95
     96   CHECK_DEMANGLER
     97      If defined, additional sanity checks will be performed.  It will
     98      cause some slowdown, but will allow to catch out-of-bound access
     99      errors earlier.  This macro is intended for testing and debugging.  */
    97100
    98101#if defined (_AIX) && !defined (__GNUC__)
     
    125128#endif /* HAVE_ALLOCA_H */
    126129
     130#ifdef HAVE_LIMITS_H
     131#include <limits.h>
     132#endif
     133#ifndef INT_MAX
     134# define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */
     135#endif
     136
    127137#include "ansidecl.h"
    128138#include "libiberty.h"
     
    163173
    164174#define cplus_demangle_print d_print
    165 static char *d_print (int, const struct demangle_component *, int, size_t *);
     175static char *d_print (int, struct demangle_component *, int, size_t *);
    166176
    167177#define cplus_demangle_print_callback d_print_callback
    168 static int d_print_callback (int, const struct demangle_component *,
     178static int d_print_callback (int, struct demangle_component *,
    169179                             demangle_callbackref, void *);
    170180
     
    255265  struct d_print_mod *next;
    256266  /* The modifier.  */
    257   const struct demangle_component *mod;
     267  struct demangle_component *mod;
    258268  /* Whether this modifier was printed.  */
    259269  int printed;
     
    276286};
    277287
     288/* Stack of components, innermost first, used to avoid loops.  */
     289
     290struct d_component_stack
     291{
     292  /* This component.  */
     293  const struct demangle_component *dc;
     294  /* This component's parent.  */
     295  const struct d_component_stack *parent;
     296};
     297
     298/* A demangle component and some scope captured when it was first
     299   traversed.  */
     300
     301struct d_saved_scope
     302{
     303  /* The component whose scope this is.  */
     304  const struct demangle_component *container;
     305  /* The list of templates, if any, that was current when this
     306     scope was captured.  */
     307  struct d_print_template *templates;
     308};
     309
     310/* Checkpoint structure to allow backtracking.  This holds copies
     311   of the fields of struct d_info that need to be restored
     312   if a trial parse needs to be backtracked over.  */
     313
     314struct d_info_checkpoint
     315{
     316  const char *n;
     317  int next_comp;
     318  int next_sub;
     319  int expansion;
     320};
     321
     322/* Maximum number of times d_print_comp may be called recursively.  */
     323#define MAX_RECURSION_COUNT 1024
     324
    278325enum { D_PRINT_BUFFER_LENGTH = 256 };
    279326struct d_print_info
    280327{
    281   /* The options passed to the demangler.  */
    282   int options;
    283328  /* Fixed-length allocated buffer for demangled data, flushed to the
    284329     callback with a NUL termination once full.  */
     
    300345  /* Set to 1 if we saw a demangling error.  */
    301346  int demangle_failure;
     347  /* Number of times d_print_comp was recursively called.  Should not
     348     be bigger than MAX_RECURSION_COUNT.  */
     349  int recursion;
     350  /* Non-zero if we're printing a lambda argument.  A template
     351     parameter reference actually means 'auto'.  */
     352  int is_lambda_arg;
    302353  /* The current index into any template argument packs we are using
    303      for printing.  */
     354     for printing, or -1 to print the whole pack.  */
    304355  int pack_index;
     356  /* Number of d_print_flush calls so far.  */
     357  unsigned long int flush_count;
     358  /* Stack of components, innermost first, used to avoid loops.  */
     359  const struct d_component_stack *component_stack;
     360  /* Array of saved scopes for evaluating substitutions.  */
     361  struct d_saved_scope *saved_scopes;
     362  /* Index of the next unused saved scope in the above array.  */
     363  int next_saved_scope;
     364  /* Number of saved scopes in the above array.  */
     365  int num_saved_scopes;
     366  /* Array of templates for saving into scopes.  */
     367  struct d_print_template *copy_templates;
     368  /* Index of the next unused copy template in the above array.  */
     369  int next_copy_template;
     370  /* Number of copy templates in the above array.  */
     371  int num_copy_templates;
     372  /* The nearest enclosing template, if any.  */
     373  const struct demangle_component *current_template;
    305374};
    306375
     
    321390
    322391static struct demangle_component *
     392d_make_demangle_mangled_name (struct d_info *, const char *);
     393
     394static struct demangle_component *
    323395d_make_builtin_type (struct d_info *,
    324396                     const struct demangle_builtin_type_info *);
     
    341413
    342414static struct demangle_component *
    343 d_make_template_param (struct d_info *, long);
     415d_make_template_param (struct d_info *, int);
    344416
    345417static struct demangle_component *
     
    364436static struct demangle_component *d_source_name (struct d_info *);
    365437
    366 static long d_number (struct d_info *);
     438static int d_number (struct d_info *);
    367439
    368440static struct demangle_component *d_identifier (struct d_info *, int);
     
    371443
    372444static struct demangle_component *d_special_name (struct d_info *);
     445
     446static struct demangle_component *d_parmlist (struct d_info *);
    373447
    374448static int d_call_offset (struct d_info *, int);
     
    380454
    381455static struct demangle_component *
     456d_ref_qualifier (struct d_info *, struct demangle_component *);
     457
     458static struct demangle_component *
    382459d_function_type (struct d_info *);
    383460
     
    390467static struct demangle_component *d_array_type (struct d_info *);
    391468
     469static struct demangle_component *d_vector_type (struct d_info *);
     470
    392471static struct demangle_component *
    393472d_pointer_to_member_type (struct d_info *);
     
    397476
    398477static struct demangle_component *d_template_args (struct d_info *);
     478static struct demangle_component *d_template_args_1 (struct d_info *);
    399479
    400480static struct demangle_component *
     
    408488
    409489static int d_discriminator (struct d_info *);
     490
     491static struct demangle_component *d_lambda (struct d_info *);
     492
     493static struct demangle_component *d_unnamed_type (struct d_info *);
     494
     495static struct demangle_component *
     496d_clone_suffix (struct d_info *, struct demangle_component *);
    410497
    411498static int
     
    413500
    414501static struct demangle_component *d_substitution (struct d_info *, int);
     502
     503static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
     504
     505static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
    415506
    416507static void d_growable_string_init (struct d_growable_string *, size_t);
     
    426517
    427518static void
    428 d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
     519d_print_init (struct d_print_info *, demangle_callbackref, void *,
     520              const struct demangle_component *);
    429521
    430522static inline void d_print_error (struct d_print_info *);
     
    444536
    445537static void
    446 d_print_comp (struct d_print_info *, const struct demangle_component *);
     538d_print_comp (struct d_print_info *, int, struct demangle_component *);
    447539
    448540static void
     
    450542
    451543static void
    452 d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
     544d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
    453545
    454546static void
    455 d_print_mod (struct d_print_info *, const struct demangle_component *);
     547d_print_mod (struct d_print_info *, int, struct demangle_component *);
    456548
    457549static void
    458 d_print_function_type (struct d_print_info *,
    459                        const struct demangle_component *,
     550d_print_function_type (struct d_print_info *, int,
     551                       struct demangle_component *,
    460552                       struct d_print_mod *);
    461553
    462554static void
    463 d_print_array_type (struct d_print_info *,
    464                     const struct demangle_component *,
     555d_print_array_type (struct d_print_info *, int,
     556                    struct demangle_component *,
    465557                    struct d_print_mod *);
    466558
    467559static void
    468 d_print_expr_op (struct d_print_info *, const struct demangle_component *);
    469 
    470 static void
    471 d_print_cast (struct d_print_info *, const struct demangle_component *);
     560d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
     561
     562static void d_print_cast (struct d_print_info *, int,
     563                          struct demangle_component *);
     564static void d_print_conversion (struct d_print_info *, int,
     565                                struct demangle_component *);
    472566
    473567static int d_demangle_callback (const char *, int,
     
    475569static char *d_demangle (const char *, int, size_t *);
    476570
     571/* True iff TYPE is a demangling component representing a
     572   function-type-qualifier.  */
     573
     574static int
     575is_fnqual_component_type (enum demangle_component_type type)
     576{
     577  return (type == DEMANGLE_COMPONENT_RESTRICT_THIS
     578          || type == DEMANGLE_COMPONENT_VOLATILE_THIS
     579          || type == DEMANGLE_COMPONENT_CONST_THIS
     580          || type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
     581          || type == DEMANGLE_COMPONENT_TRANSACTION_SAFE
     582          || type == DEMANGLE_COMPONENT_NOEXCEPT
     583          || type == DEMANGLE_COMPONENT_THROW_SPEC
     584          || type == DEMANGLE_COMPONENT_REFERENCE_THIS);
     585}
     586
     587#define FNQUAL_COMPONENT_CASE                           \
     588    case DEMANGLE_COMPONENT_RESTRICT_THIS:              \
     589    case DEMANGLE_COMPONENT_VOLATILE_THIS:              \
     590    case DEMANGLE_COMPONENT_CONST_THIS:                 \
     591    case DEMANGLE_COMPONENT_REFERENCE_THIS:             \
     592    case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:      \
     593    case DEMANGLE_COMPONENT_TRANSACTION_SAFE:           \
     594    case DEMANGLE_COMPONENT_NOEXCEPT:                   \
     595    case DEMANGLE_COMPONENT_THROW_SPEC
     596
    477597#ifdef CP_DEMANGLE_DEBUG
    478598
     
    497617      printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
    498618      return;
     619    case DEMANGLE_COMPONENT_TAGGED_NAME:
     620      printf ("tagged name\n");
     621      d_dump (dc->u.s_binary.left, indent + 2);
     622      d_dump (dc->u.s_binary.right, indent + 2);
     623      return;
    499624    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    500625      printf ("template parameter %ld\n", dc->u.s_number.number);
     626      return;
     627    case DEMANGLE_COMPONENT_FUNCTION_PARAM:
     628      printf ("function parameter %ld\n", dc->u.s_number.number);
    501629      return;
    502630    case DEMANGLE_COMPONENT_CTOR:
     
    574702      printf ("hidden alias\n");
    575703      break;
     704    case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     705      printf ("transaction clone\n");
     706      break;
     707    case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
     708      printf ("non-transaction clone\n");
     709      break;
    576710    case DEMANGLE_COMPONENT_RESTRICT:
    577711      printf ("restrict\n");
     
    592726      printf ("const this\n");
    593727      break;
     728    case DEMANGLE_COMPONENT_REFERENCE_THIS:
     729      printf ("reference this\n");
     730      break;
     731    case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
     732      printf ("rvalue reference this\n");
     733      break;
     734    case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
     735      printf ("transaction_safe this\n");
     736      break;
    594737    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    595738      printf ("vendor type qualifier\n");
     
    623766      break;
    624767    case DEMANGLE_COMPONENT_FIXED_TYPE:
    625       printf ("fixed-point type\n");
     768      printf ("fixed-point type, accum? %d, sat? %d\n",
     769              dc->u.s_fixed.accum, dc->u.s_fixed.sat);
     770      d_dump (dc->u.s_fixed.length, indent + 2);
    626771      break;
    627772    case DEMANGLE_COMPONENT_ARGLIST:
     
    631776      printf ("template argument list\n");
    632777      break;
     778    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
     779      printf ("initializer list\n");
     780      break;
    633781    case DEMANGLE_COMPONENT_CAST:
    634782      printf ("cast\n");
    635783      break;
     784    case DEMANGLE_COMPONENT_CONVERSION:
     785      printf ("conversion operator\n");
     786      break;
     787    case DEMANGLE_COMPONENT_NULLARY:
     788      printf ("nullary operator\n");
     789      break;
    636790    case DEMANGLE_COMPONENT_UNARY:
    637791      printf ("unary operator\n");
     
    667821      printf ("character '%c'\n",  dc->u.s_character.character);
    668822      return;
     823    case DEMANGLE_COMPONENT_NUMBER:
     824      printf ("number %ld\n", dc->u.s_number.number);
     825      return;
    669826    case DEMANGLE_COMPONENT_DECLTYPE:
    670827      printf ("decltype\n");
     
    673830      printf ("pack expansion\n");
    674831      break;
     832    case DEMANGLE_COMPONENT_TLS_INIT:
     833      printf ("tls init function\n");
     834      break;
     835    case DEMANGLE_COMPONENT_TLS_WRAPPER:
     836      printf ("tls wrapper function\n");
     837      break;
     838    case DEMANGLE_COMPONENT_DEFAULT_ARG:
     839      printf ("default argument %d\n", dc->u.s_unary_num.num);
     840      d_dump (dc->u.s_unary_num.sub, indent+2);
     841      return;
     842    case DEMANGLE_COMPONENT_LAMBDA:
     843      printf ("lambda %d\n", dc->u.s_unary_num.num);
     844      d_dump (dc->u.s_unary_num.sub, indent+2);
     845      return;
    675846    }
    676847
     
    689860  if (p == NULL || s == NULL || len == 0)
    690861    return 0;
     862  p->d_printing = 0;
    691863  p->type = DEMANGLE_COMPONENT_NAME;
    692864  p->u.s_name.s = s;
     
    704876  if (p == NULL || args < 0 || name == NULL)
    705877    return 0;
     878  p->d_printing = 0;
    706879  p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
    707880  p->u.s_extended_operator.args = args;
     
    721894      || name == NULL
    722895      || (int) kind < gnu_v3_complete_object_ctor
    723       || (int) kind > gnu_v3_complete_object_allocating_ctor)
     896      || (int) kind > gnu_v3_object_ctor_group)
    724897    return 0;
     898  p->d_printing = 0;
    725899  p->type = DEMANGLE_COMPONENT_CTOR;
    726900  p->u.s_ctor.kind = kind;
     
    740914      || name == NULL
    741915      || (int) kind < gnu_v3_deleting_dtor
    742       || (int) kind > gnu_v3_base_object_dtor)
     916      || (int) kind > gnu_v3_object_dtor_group)
    743917    return 0;
     918  p->d_printing = 0;
    744919  p->type = DEMANGLE_COMPONENT_DTOR;
    745920  p->u.s_dtor.kind = kind;
     
    758933    return NULL;
    759934  p = &di->comps[di->next_comp];
     935  p->d_printing = 0;
    760936  ++di->next_comp;
    761937  return p;
     
    780956    case DEMANGLE_COMPONENT_LOCAL_NAME:
    781957    case DEMANGLE_COMPONENT_TYPED_NAME:
     958    case DEMANGLE_COMPONENT_TAGGED_NAME:
    782959    case DEMANGLE_COMPONENT_TEMPLATE:
    783960    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
     
    789966    case DEMANGLE_COMPONENT_TRINARY:
    790967    case DEMANGLE_COMPONENT_TRINARY_ARG1:
    791     case DEMANGLE_COMPONENT_TRINARY_ARG2:
    792968    case DEMANGLE_COMPONENT_LITERAL:
    793969    case DEMANGLE_COMPONENT_LITERAL_NEG:
    794970    case DEMANGLE_COMPONENT_COMPOUND_NAME:
     971    case DEMANGLE_COMPONENT_VECTOR_TYPE:
     972    case DEMANGLE_COMPONENT_CLONE:
    795973      if (left == NULL || right == NULL)
    796974        return NULL;
     
    808986    case DEMANGLE_COMPONENT_JAVA_CLASS:
    809987    case DEMANGLE_COMPONENT_GUARD:
     988    case DEMANGLE_COMPONENT_TLS_INIT:
     989    case DEMANGLE_COMPONENT_TLS_WRAPPER:
    810990    case DEMANGLE_COMPONENT_REFTEMP:
    811991    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
     992    case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     993    case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
    812994    case DEMANGLE_COMPONENT_POINTER:
    813995    case DEMANGLE_COMPONENT_REFERENCE:
     
    817999    case DEMANGLE_COMPONENT_VENDOR_TYPE:
    8181000    case DEMANGLE_COMPONENT_CAST:
     1001    case DEMANGLE_COMPONENT_CONVERSION:
    8191002    case DEMANGLE_COMPONENT_JAVA_RESOURCE:
    8201003    case DEMANGLE_COMPONENT_DECLTYPE:
     
    8221005    case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
    8231006    case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
     1007    case DEMANGLE_COMPONENT_NULLARY:
     1008    case DEMANGLE_COMPONENT_TRINARY_ARG2:
    8241009      if (left == NULL)
    8251010        return NULL;
     
    8291014         empty.  */
    8301015    case DEMANGLE_COMPONENT_ARRAY_TYPE:
     1016    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
    8311017      if (right == NULL)
    8321018        return NULL;
     
    8391025    case DEMANGLE_COMPONENT_VOLATILE:
    8401026    case DEMANGLE_COMPONENT_CONST:
    841     case DEMANGLE_COMPONENT_RESTRICT_THIS:
    842     case DEMANGLE_COMPONENT_VOLATILE_THIS:
    843     case DEMANGLE_COMPONENT_CONST_THIS:
    8441027    case DEMANGLE_COMPONENT_ARGLIST:
    8451028    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
     1029    FNQUAL_COMPONENT_CASE:
    8461030      break;
    8471031
     
    8591043    }
    8601044  return p;
     1045}
     1046
     1047/* Add a new demangle mangled name component.  */
     1048
     1049static struct demangle_component *
     1050d_make_demangle_mangled_name (struct d_info *di, const char *s)
     1051{
     1052  if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
     1053    return d_make_name (di, s, strlen (s));
     1054  d_advance (di, 2);
     1055  return d_encoding (di, 0);
    8611056}
    8621057
     
    9231118}
    9241119
     1120static struct demangle_component *
     1121d_make_default_arg (struct d_info *di, int num,
     1122                    struct demangle_component *sub)
     1123{
     1124  struct demangle_component *p = d_make_empty (di);
     1125  if (p)
     1126    {
     1127      p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
     1128      p->u.s_unary_num.num = num;
     1129      p->u.s_unary_num.sub = sub;
     1130    }
     1131  return p;
     1132}
     1133
    9251134/* Add a new constructor component.  */
    9261135
     
    9541163
    9551164static struct demangle_component *
    956 d_make_template_param (struct d_info *di, long i)
     1165d_make_template_param (struct d_info *di, int i)
    9571166{
    9581167  struct demangle_component *p;
     
    9701179
    9711180static struct demangle_component *
    972 d_make_function_param (struct d_info *di, long i)
     1181d_make_function_param (struct d_info *di, int i)
    9731182{
    9741183  struct demangle_component *p;
     
    10001209}
    10011210
    1002 /* <mangled-name> ::= _Z <encoding>
     1211/* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
    10031212
    10041213   TOP_LEVEL is non-zero when called at the top level.  */
     
    10081217cplus_demangle_mangled_name (struct d_info *di, int top_level)
    10091218{
     1219  struct demangle_component *p;
     1220
    10101221  if (! d_check_char (di, '_')
    10111222      /* Allow missing _ if not at toplevel to work around a
     
    10161227  if (! d_check_char (di, 'Z'))
    10171228    return NULL;
    1018   return d_encoding (di, top_level);
     1229  p = d_encoding (di, top_level);
     1230
     1231  /* If at top level and parsing parameters, check for a clone
     1232     suffix.  */
     1233  if (top_level && (di->options & DMGL_PARAMS) != 0)
     1234    while (d_peek_char (di) == '.'
     1235           && (IS_LOWER (d_peek_next_char (di))
     1236               || d_peek_next_char (di) == '_'
     1237               || IS_DIGIT (d_peek_next_char (di))))
     1238      p = d_clone_suffix (di, p);
     1239
     1240  return p;
    10191241}
    10201242
     
    10391261    case DEMANGLE_COMPONENT_TEMPLATE:
    10401262      return ! is_ctor_dtor_or_conversion (d_left (dc));
    1041     case DEMANGLE_COMPONENT_RESTRICT_THIS:
    1042     case DEMANGLE_COMPONENT_VOLATILE_THIS:
    1043     case DEMANGLE_COMPONENT_CONST_THIS:
     1263    FNQUAL_COMPONENT_CASE:
    10441264      return has_return_type (d_left (dc));
    10451265    }
     
    10631283    case DEMANGLE_COMPONENT_CTOR:
    10641284    case DEMANGLE_COMPONENT_DTOR:
    1065     case DEMANGLE_COMPONENT_CAST:
     1285    case DEMANGLE_COMPONENT_CONVERSION:
    10661286      return 1;
    10671287    }
     
    10971317          while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
    10981318                 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
    1099                  || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
     1319                 || dc->type == DEMANGLE_COMPONENT_CONST_THIS
     1320                 || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
     1321                 || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
    11001322            dc = d_left (dc);
    11011323
    11021324          /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
    1103              there may be CV-qualifiers on its right argument which
     1325             there may be function-qualifiers on its right argument which
    11041326             really apply here; this happens when parsing a class
    11051327             which is local to a function.  */
     
    11091331
    11101332              dcr = d_right (dc);
    1111               while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
    1112                      || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
    1113                      || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
     1333              while (is_fnqual_component_type (dcr->type))
    11141334                dcr = d_left (dcr);
    11151335              dc->u.s_binary.right = dcr;
     
    11271347}
    11281348
     1349/* <tagged-name> ::= <name> B <source-name> */
     1350
     1351static struct demangle_component *
     1352d_abi_tags (struct d_info *di, struct demangle_component *dc)
     1353{
     1354  struct demangle_component *hold_last_name;
     1355  char peek;
     1356
     1357  /* Preserve the last name, so the ABI tag doesn't clobber it.  */
     1358  hold_last_name = di->last_name;
     1359
     1360  while (peek = d_peek_char (di),
     1361         peek == 'B')
     1362    {
     1363      struct demangle_component *tag;
     1364      d_advance (di, 1);
     1365      tag = d_source_name (di);
     1366      dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
     1367    }
     1368
     1369  di->last_name = hold_last_name;
     1370
     1371  return dc;
     1372}
     1373
    11291374/* <name> ::= <nested-name>
    11301375          ::= <unscoped-name>
     
    11531398      return d_local_name (di);
    11541399
    1155     case 'L':
     1400    case 'U':
    11561401      return d_unqualified_name (di);
    1157        
     1402
    11581403    case 'S':
    11591404      {
     
    11991444      }
    12001445
     1446    case 'L':
    12011447    default:
    12021448      dc = d_unqualified_name (di);
     
    12151461}
    12161462
    1217 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
    1218                  ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
     1463/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
     1464                 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
    12191465*/
    12201466
     
    12241470  struct demangle_component *ret;
    12251471  struct demangle_component **pret;
     1472  struct demangle_component *rqual;
    12261473
    12271474  if (! d_check_char (di, 'N'))
     
    12321479    return NULL;
    12331480
     1481  /* Parse the ref-qualifier now and then attach it
     1482     once we have something to attach it to.  */
     1483  rqual = d_ref_qualifier (di, NULL);
     1484
    12341485  *pret = d_prefix (di);
    12351486  if (*pret == NULL)
    12361487    return NULL;
    12371488
     1489  if (rqual)
     1490    {
     1491      d_left (rqual) = ret;
     1492      ret = rqual;
     1493    }
     1494
    12381495  if (! d_check_char (di, 'E'))
    12391496    return NULL;
     
    12451502            ::= <template-prefix> <template-args>
    12461503            ::= <template-param>
     1504            ::= <decltype>
    12471505            ::=
    12481506            ::= <substitution>
     
    12731531
    12741532      comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
    1275       if (IS_DIGIT (peek)
     1533      if (peek == 'D')
     1534        {
     1535          char peek2 = d_peek_next_char (di);
     1536          if (peek2 == 'T' || peek2 == 't')
     1537            /* Decltype.  */
     1538            dc = cplus_demangle_type (di);
     1539          else
     1540            /* Destructor name.  */
     1541            dc = d_unqualified_name (di);
     1542        }
     1543      else if (IS_DIGIT (peek)
    12761544          || IS_LOWER (peek)
    12771545          || peek == 'C'
    1278           || peek == 'D'
     1546          || peek == 'U'
    12791547          || peek == 'L')
    12801548        dc = d_unqualified_name (di);
     
    12921560      else if (peek == 'E')
    12931561        return ret;
     1562      else if (peek == 'M')
     1563        {
     1564          /* Initializer scope for a lambda.  We don't need to represent
     1565             this; the normal code will just treat the variable as a type
     1566             scope, which gives appropriate output.  */
     1567          if (ret == NULL)
     1568            return NULL;
     1569          d_advance (di, 1);
     1570          continue;
     1571        }
    12941572      else
    12951573        return NULL;
     
    13191597d_unqualified_name (struct d_info *di)
    13201598{
     1599  struct demangle_component *ret;
    13211600  char peek;
    13221601
    13231602  peek = d_peek_char (di);
    13241603  if (IS_DIGIT (peek))
    1325     return d_source_name (di);
     1604    ret = d_source_name (di);
    13261605  else if (IS_LOWER (peek))
    13271606    {
    1328       struct demangle_component *ret;
    1329 
     1607      if (peek == 'o' && d_peek_next_char (di) == 'n')
     1608        d_advance (di, 2);
    13301609      ret = d_operator_name (di);
    13311610      if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
    1332         di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
    1333       return ret;
     1611        {
     1612          di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
     1613          if (!strcmp (ret->u.s_operator.op->code, "li"))
     1614            ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
     1615                               d_source_name (di));
     1616        }
    13341617    }
    13351618  else if (peek == 'C' || peek == 'D')
    1336     return d_ctor_dtor_name (di);
     1619    ret = d_ctor_dtor_name (di);
    13371620  else if (peek == 'L')
    13381621    {
    1339       struct demangle_component * ret;
    1340 
    13411622      d_advance (di, 1);
    13421623
     
    13461627      if (! d_discriminator (di))
    13471628        return NULL;
    1348       return ret;
     1629    }
     1630  else if (peek == 'U')
     1631    {
     1632      switch (d_peek_next_char (di))
     1633        {
     1634        case 'l':
     1635          ret = d_lambda (di);
     1636          break;
     1637        case 't':
     1638          ret = d_unnamed_type (di);
     1639          break;
     1640        default:
     1641          return NULL;
     1642        }
    13491643    }
    13501644  else
    13511645    return NULL;
     1646
     1647  if (d_peek_char (di) == 'B')
     1648    ret = d_abi_tags (di, ret);
     1649  return ret;
    13521650}
    13531651
     
    13571655d_source_name (struct d_info *di)
    13581656{
    1359   long len;
     1657  int len;
    13601658  struct demangle_component *ret;
    13611659
     
    13701668/* number ::= [n] <(non-negative decimal integer)>  */
    13711669
    1372 static long
     1670static int
    13731671d_number (struct d_info *di)
    13741672{
    13751673  int negative;
    13761674  char peek;
    1377   long ret;
     1675  int ret;
    13781676
    13791677  negative = 0;
     
    13951693          return ret;
    13961694        }
     1695      if (ret > ((INT_MAX - (peek - '0')) / 10))
     1696        return -1;
    13971697      ret = ret * 10 + peek - '0';
    13981698      d_advance (di, 1);
    13991699      peek = d_peek_char (di);
    14001700    }
     1701}
     1702
     1703/* Like d_number, but returns a demangle_component.  */
     1704
     1705static struct demangle_component *
     1706d_number_component (struct d_info *di)
     1707{
     1708  struct demangle_component *ret = d_make_empty (di);
     1709  if (ret)
     1710    {
     1711      ret->type = DEMANGLE_COMPONENT_NUMBER;
     1712      ret->u.s_number.number = d_number (di);
     1713    }
     1714  return ret;
    14011715}
    14021716
     
    14471761                 ::= cv <type>
    14481762                 ::= v <digit> <source-name>
    1449 */
     1763
     1764   This list is sorted for binary search.  */
    14501765
    14511766#define NL(s) s, (sizeof s) - 1
     
    14591774  { "ad", NL ("&"),         1 },
    14601775  { "an", NL ("&"),         2 },
     1776  { "at", NL ("alignof "),   1 },
     1777  { "az", NL ("alignof "),   1 },
     1778  { "cc", NL ("const_cast"), 2 },
    14611779  { "cl", NL ("()"),        2 },
    14621780  { "cm", NL (","),         2 },
    14631781  { "co", NL ("~"),         1 },
    14641782  { "dV", NL ("/="),        2 },
    1465   { "da", NL ("delete[]"),  1 },
     1783  { "da", NL ("delete[] "), 1 },
     1784  { "dc", NL ("dynamic_cast"), 2 },
    14661785  { "de", NL ("*"),         1 },
    1467   { "dl", NL ("delete"),    1 },
     1786  { "dl", NL ("delete "),   1 },
     1787  { "ds", NL (".*"),        2 },
    14681788  { "dt", NL ("."),         2 },
    14691789  { "dv", NL ("/"),         2 },
     
    14711791  { "eo", NL ("^"),         2 },
    14721792  { "eq", NL ("=="),        2 },
     1793  { "fL", NL ("..."),       3 },
     1794  { "fR", NL ("..."),       3 },
     1795  { "fl", NL ("..."),       2 },
     1796  { "fr", NL ("..."),       2 },
    14731797  { "ge", NL (">="),        2 },
     1798  { "gs", NL ("::"),        1 },
    14741799  { "gt", NL (">"),         2 },
    14751800  { "ix", NL ("[]"),        2 },
    14761801  { "lS", NL ("<<="),       2 },
    14771802  { "le", NL ("<="),        2 },
     1803  { "li", NL ("operator\"\" "), 1 },
    14781804  { "ls", NL ("<<"),        2 },
    14791805  { "lt", NL ("<"),         2 },
     
    14831809  { "ml", NL ("*"),         2 },
    14841810  { "mm", NL ("--"),        1 },
    1485   { "na", NL ("new[]"),     1 },
     1811  { "na", NL ("new[]"),     3 },
    14861812  { "ne", NL ("!="),        2 },
    14871813  { "ng", NL ("-"),         1 },
    14881814  { "nt", NL ("!"),         1 },
    1489   { "nw", NL ("new"),       1 },
     1815  { "nw", NL ("new"),       3 },
    14901816  { "oR", NL ("|="),        2 },
    14911817  { "oo", NL ("||"),        2 },
     
    15001826  { "rM", NL ("%="),        2 },
    15011827  { "rS", NL (">>="),       2 },
     1828  { "rc", NL ("reinterpret_cast"), 2 },
    15021829  { "rm", NL ("%"),         2 },
    15031830  { "rs", NL (">>"),        2 },
     1831  { "sP", NL ("sizeof..."), 1 },
     1832  { "sZ", NL ("sizeof..."), 1 },
     1833  { "sc", NL ("static_cast"), 2 },
    15041834  { "st", NL ("sizeof "),   1 },
    15051835  { "sz", NL ("sizeof "),   1 },
    1506   { "at", NL ("alignof "),   1 },
    1507   { "az", NL ("alignof "),   1 },
     1836  { "tr", NL ("throw"),     0 },
     1837  { "tw", NL ("throw "),    1 },
    15081838  { NULL, NULL, 0,          0 }
    15091839};
     
    15201850    return d_make_extended_operator (di, c2 - '0', d_source_name (di));
    15211851  else if (c1 == 'c' && c2 == 'v')
    1522     return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
    1523                         cplus_demangle_type (di), NULL);
     1852    {
     1853      struct demangle_component *type;
     1854      int was_conversion = di->is_conversion;
     1855      struct demangle_component *res;
     1856
     1857      di->is_conversion = ! di->is_expression;
     1858      type = cplus_demangle_type (di);
     1859      if (di->is_conversion)
     1860        res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
     1861      else
     1862        res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
     1863      di->is_conversion = was_conversion;
     1864      return res;
     1865    }
    15241866  else
    15251867    {
     
    15711913  struct demangle_component *p = NULL;
    15721914  struct demangle_component *next = NULL;
    1573   long len, i;
     1915  int len, i;
    15741916  char c;
    15751917  const char *str;
     
    16632005                  ::= GA <encoding>
    16642006                  ::= Gr <resource name>
     2007                  ::= GTt <encoding>
     2008                  ::= GTn <encoding>
    16652009*/
    16662010
     
    17112055          {
    17122056            struct demangle_component *derived_type;
    1713             long offset;
     2057            int offset;
    17142058            struct demangle_component *base_type;
    17152059
     
    17352079                              cplus_demangle_type (di), NULL);
    17362080
     2081        case 'H':
     2082          return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
     2083                              d_name (di), NULL);
     2084
     2085        case 'W':
     2086          return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
     2087                              d_name (di), NULL);
     2088
    17372089        default:
    17382090          return NULL;
     
    17472099
    17482100        case 'R':
    1749           return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
    1750                               NULL);
     2101          {
     2102            struct demangle_component *name = d_name (di);
     2103            return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
     2104                                d_number_component (di));
     2105          }
    17512106
    17522107        case 'A':
    17532108          return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
    17542109                              d_encoding (di, 0), NULL);
     2110
     2111        case 'T':
     2112          switch (d_next_char (di))
     2113            {
     2114            case 'n':
     2115              return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
     2116                                  d_encoding (di, 0), NULL);
     2117            default:
     2118              /* ??? The proposal is that other letters (such as 'h') stand
     2119                 for different variants of transaction cloning, such as
     2120                 compiling directly for hardware transaction support.  But
     2121                 they still should all be transactional clones of some sort
     2122                 so go ahead and call them that.  */
     2123            case 't':
     2124              return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
     2125                                  d_encoding (di, 0), NULL);
     2126            }
    17552127
    17562128        case 'r':
     
    18252197      {
    18262198        enum gnu_v3_ctor_kinds kind;
     2199        int inheriting = 0;
     2200
     2201        if (d_peek_next_char (di) == 'I')
     2202          {
     2203            inheriting = 1;
     2204            d_advance (di, 1);
     2205          }
    18272206
    18282207        switch (d_peek_next_char (di))
     
    18372216            kind = gnu_v3_complete_object_allocating_ctor;
    18382217            break;
     2218          case '4':
     2219            kind = gnu_v3_unified_ctor;
     2220            break;
     2221          case '5':
     2222            kind = gnu_v3_object_ctor_group;
     2223            break;
    18392224          default:
    18402225            return NULL;
    18412226          }
     2227
    18422228        d_advance (di, 2);
     2229
     2230        if (inheriting)
     2231          cplus_demangle_type (di);
     2232
    18432233        return d_make_ctor (di, kind, di->last_name);
    18442234      }
     
    18592249            kind = gnu_v3_base_object_dtor;
    18602250            break;
     2251          /*  digit '3' is not used */
     2252          case '4':
     2253            kind = gnu_v3_unified_dtor;
     2254            break;
     2255          case '5':
     2256            kind = gnu_v3_object_dtor_group;
     2257            break;
    18612258          default:
    18622259            return NULL;
     
    18692266      return NULL;
    18702267    }
     2268}
     2269
     2270/* True iff we're looking at an order-insensitive type-qualifier, including
     2271   function-type-qualifiers.  */
     2272
     2273static int
     2274next_is_type_qual (struct d_info *di)
     2275{
     2276  char peek = d_peek_char (di);
     2277  if (peek == 'r' || peek == 'V' || peek == 'K')
     2278    return 1;
     2279  if (peek == 'D')
     2280    {
     2281      peek = d_peek_next_char (di);
     2282      if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
     2283        return 1;
     2284    }
     2285  return 0;
    18712286}
    18722287
     
    19292344  /* 30 */ { NL ("char16_t"),   NL ("char16_t"),        D_PRINT_DEFAULT },
    19302345  /* 31 */ { NL ("char32_t"),   NL ("char32_t"),        D_PRINT_DEFAULT },
     2346  /* 32 */ { NL ("decltype(nullptr)"),  NL ("decltype(nullptr)"),
     2347             D_PRINT_DEFAULT },
    19312348};
    19322349
     
    19542371     names.  */
    19552372
    1956   peek = d_peek_char (di);
    1957   if (peek == 'r' || peek == 'V' || peek == 'K')
     2373  if (next_is_type_qual (di))
    19582374    {
    19592375      struct demangle_component **pret;
     
    19622378      if (pret == NULL)
    19632379        return NULL;
    1964       *pret = cplus_demangle_type (di);
    1965       if (! *pret || ! d_add_substitution (di, ret))
     2380      if (d_peek_char (di) == 'F')
     2381        {
     2382          /* cv-qualifiers before a function type apply to 'this',
     2383             so avoid adding the unqualified function type to
     2384             the substitution list.  */
     2385          *pret = d_function_type (di);
     2386        }
     2387      else
     2388        *pret = cplus_demangle_type (di);
     2389      if (!*pret)
     2390        return NULL;
     2391      if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
     2392          || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
     2393        {
     2394          /* Move the ref-qualifier outside the cv-qualifiers so that
     2395             they are printed in the right order.  */
     2396          struct demangle_component *fn = d_left (*pret);
     2397          d_left (*pret) = ret;
     2398          ret = *pret;
     2399          *pret = fn;
     2400        }
     2401      if (! d_add_substitution (di, ret))
    19662402        return NULL;
    19672403      return ret;
     
    19702406  can_subst = 1;
    19712407
     2408  peek = d_peek_char (di);
    19722409  switch (peek)
    19732410    {
     
    20122449      if (d_peek_char (di) == 'I')
    20132450        {
    2014           /* This is <template-template-param> <template-args>.  The
    2015              <template-template-param> part is a substitution
     2451          /* This may be <template-template-param> <template-args>.
     2452             If this is the type for a conversion operator, we can
     2453             have a <template-template-param> here only by following
     2454             a derivation like this:
     2455
     2456             <nested-name>
     2457             -> <template-prefix> <template-args>
     2458             -> <prefix> <template-unqualified-name> <template-args>
     2459             -> <unqualified-name> <template-unqualified-name> <template-args>
     2460             -> <source-name> <template-unqualified-name> <template-args>
     2461             -> <source-name> <operator-name> <template-args>
     2462             -> <source-name> cv <type> <template-args>
     2463             -> <source-name> cv <template-template-param> <template-args> <template-args>
     2464
     2465             where the <template-args> is followed by another.
     2466             Otherwise, we must have a derivation like this:
     2467
     2468             <nested-name>
     2469             -> <template-prefix> <template-args>
     2470             -> <prefix> <template-unqualified-name> <template-args>
     2471             -> <unqualified-name> <template-unqualified-name> <template-args>
     2472             -> <source-name> <template-unqualified-name> <template-args>
     2473             -> <source-name> <operator-name> <template-args>
     2474             -> <source-name> cv <type> <template-args>
     2475             -> <source-name> cv <template-param> <template-args>
     2476
     2477             where we need to leave the <template-args> to be processed
     2478             by d_prefix (following the <template-prefix>).
     2479
     2480             The <template-template-param> part is a substitution
    20162481             candidate.  */
    2017           if (! d_add_substitution (di, ret))
    2018             return NULL;
    2019           ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
    2020                              d_template_args (di));
     2482          if (! di->is_conversion)
     2483            {
     2484              if (! d_add_substitution (di, ret))
     2485                return NULL;
     2486              ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
     2487                                 d_template_args (di));
     2488            }
     2489          else
     2490            {
     2491              struct demangle_component *args;
     2492              struct d_info_checkpoint checkpoint;
     2493
     2494              d_checkpoint (di, &checkpoint);
     2495              args = d_template_args (di);
     2496              if (d_peek_char (di) == 'I')
     2497                {
     2498                  if (! d_add_substitution (di, ret))
     2499                    return NULL;
     2500                  ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
     2501                                     args);
     2502                }
     2503              else
     2504                d_backtrack (di, &checkpoint);
     2505            }
    20212506        }
    20222507      break;
     
    20882573      d_advance (di, 1);
    20892574      ret = d_source_name (di);
     2575      if (d_peek_char (di) == 'I')
     2576        ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
     2577                           d_template_args (di));
    20902578      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
    20912579                         cplus_demangle_type (di), ret);
     
    21052593          if (ret && d_next_char (di) != 'E')
    21062594            ret = NULL;
     2595          can_subst = 1;
    21072596          break;
    21082597         
     
    21112600          ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
    21122601                             cplus_demangle_type (di), NULL);
     2602          can_subst = 1;
    21132603          break;
    2114          
     2604
     2605        case 'a':
     2606          /* auto */
     2607          ret = d_make_name (di, "auto", 4);
     2608          break;
     2609        case 'c':
     2610          /* decltype(auto) */
     2611          ret = d_make_name (di, "decltype(auto)", 14);
     2612          break;
     2613
    21152614        case 'f':
    21162615          /* 32-bit decimal floating point */
     
    21522651            d_number (di);
    21532652          ret->u.s_fixed.length = cplus_demangle_type (di);
     2653          if (ret->u.s_fixed.length == NULL)
     2654            return NULL;
    21542655          d_number (di);
    21552656          peek = d_next_char (di);
     
    21572658          break;
    21582659
     2660        case 'v':
     2661          ret = d_vector_type (di);
     2662          can_subst = 1;
     2663          break;
     2664
     2665        case 'n':
     2666          /* decltype(nullptr) */
     2667          ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
     2668          di->expansion += ret->u.s_builtin.type->len;
     2669          break;
     2670
    21592671        default:
    21602672          return NULL;
     
    21752687}
    21762688
    2177 /* <CV-qualifiers> ::= [r] [V] [K] */
     2689/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
    21782690
    21792691static struct demangle_component **
     
    21812693                 struct demangle_component **pret, int member_fn)
    21822694{
     2695  struct demangle_component **pstart;
    21832696  char peek;
    21842697
     2698  pstart = pret;
    21852699  peek = d_peek_char (di);
    2186   while (peek == 'r' || peek == 'V' || peek == 'K')
     2700  while (next_is_type_qual (di))
    21872701    {
    21882702      enum demangle_component_type t;
     2703      struct demangle_component *right = NULL;
    21892704
    21902705      d_advance (di, 1);
     
    22032718          di->expansion += sizeof "volatile";
    22042719        }
    2205       else
     2720      else if (peek == 'K')
    22062721        {
    22072722          t = (member_fn
     
    22102725          di->expansion += sizeof "const";
    22112726        }
    2212 
    2213       *pret = d_make_comp (di, t, NULL, NULL);
     2727      else
     2728        {
     2729          peek = d_next_char (di);
     2730          if (peek == 'x')
     2731            {
     2732              t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
     2733              di->expansion += sizeof "transaction_safe";
     2734            }
     2735          else if (peek == 'o'
     2736                   || peek == 'O')
     2737            {
     2738              t = DEMANGLE_COMPONENT_NOEXCEPT;
     2739              di->expansion += sizeof "noexcept";
     2740              if (peek == 'O')
     2741                {
     2742                  right = d_expression (di);
     2743                  if (right == NULL)
     2744                    return NULL;
     2745                  if (! d_check_char (di, 'E'))
     2746                    return NULL;
     2747                }
     2748            }
     2749          else if (peek == 'w')
     2750            {
     2751              t = DEMANGLE_COMPONENT_THROW_SPEC;
     2752              di->expansion += sizeof "throw";
     2753              right = d_parmlist (di);
     2754              if (right == NULL)
     2755                return NULL;
     2756              if (! d_check_char (di, 'E'))
     2757                return NULL;
     2758            }
     2759          else
     2760            return NULL;
     2761        }
     2762
     2763      *pret = d_make_comp (di, t, NULL, right);
    22142764      if (*pret == NULL)
    22152765        return NULL;
     
    22192769    }
    22202770
     2771  if (!member_fn && peek == 'F')
     2772    {
     2773      while (pstart != pret)
     2774        {
     2775          switch ((*pstart)->type)
     2776            {
     2777            case DEMANGLE_COMPONENT_RESTRICT:
     2778              (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
     2779              break;
     2780            case DEMANGLE_COMPONENT_VOLATILE:
     2781              (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
     2782              break;
     2783            case DEMANGLE_COMPONENT_CONST:
     2784              (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
     2785              break;
     2786            default:
     2787              break;
     2788            }
     2789          pstart = &d_left (*pstart);
     2790        }
     2791    }
     2792
    22212793  return pret;
    22222794}
    22232795
    2224 /* <function-type> ::= F [Y] <bare-function-type> E  */
     2796/* <ref-qualifier> ::= R
     2797                   ::= O */
     2798
     2799static struct demangle_component *
     2800d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
     2801{
     2802  struct demangle_component *ret = sub;
     2803  char peek;
     2804
     2805  peek = d_peek_char (di);
     2806  if (peek == 'R' || peek == 'O')
     2807    {
     2808      enum demangle_component_type t;
     2809      if (peek == 'R')
     2810        {
     2811          t = DEMANGLE_COMPONENT_REFERENCE_THIS;
     2812          di->expansion += sizeof "&";
     2813        }
     2814      else
     2815        {
     2816          t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
     2817          di->expansion += sizeof "&&";
     2818        }
     2819      d_advance (di, 1);
     2820
     2821      ret = d_make_comp (di, t, ret, NULL);
     2822    }
     2823
     2824  return ret;
     2825}
     2826
     2827/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E  */
    22252828
    22262829static struct demangle_component *
     
    22382841    }
    22392842  ret = d_bare_function_type (di, 1);
     2843  ret = d_ref_qualifier (di, ret);
     2844
    22402845  if (! d_check_char (di, 'E'))
    22412846    return NULL;
     
    22432848}
    22442849
    2245 /* <bare-function-type> ::= [J]<type>+  */
    2246 
    2247 static struct demangle_component *
    2248 d_bare_function_type (struct d_info *di, int has_return_type)
    2249 {
    2250   struct demangle_component *return_type;
     2850/* <type>+ */
     2851
     2852static struct demangle_component *
     2853d_parmlist (struct d_info *di)
     2854{
    22512855  struct demangle_component *tl;
    22522856  struct demangle_component **ptl;
    2253   char peek;
    2254 
    2255   /* Detect special qualifier indicating that the first argument
    2256      is the return type.  */
    2257   peek = d_peek_char (di);
    2258   if (peek == 'J')
    2259     {
    2260       d_advance (di, 1);
    2261       has_return_type = 1;
    2262     }
    2263 
    2264   return_type = NULL;
     2857
    22652858  tl = NULL;
    22662859  ptl = &tl;
     
    22692862      struct demangle_component *type;
    22702863
    2271       peek = d_peek_char (di);
    2272       if (peek == '\0' || peek == 'E')
     2864      char peek = d_peek_char (di);
     2865      if (peek == '\0' || peek == 'E' || peek == '.')
     2866        break;
     2867      if ((peek == 'R' || peek == 'O')
     2868          && d_peek_next_char (di) == 'E')
     2869        /* Function ref-qualifier, not a ref prefix for a parameter type.  */
    22732870        break;
    22742871      type = cplus_demangle_type (di);
    22752872      if (type == NULL)
    22762873        return NULL;
    2277       if (has_return_type)
    2278         {
    2279           return_type = type;
    2280           has_return_type = 0;
    2281         }
    2282       else
    2283         {
    2284           *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
    2285           if (*ptl == NULL)
    2286             return NULL;
    2287           ptl = &d_right (*ptl);
    2288         }
     2874      *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
     2875      if (*ptl == NULL)
     2876        return NULL;
     2877      ptl = &d_right (*ptl);
    22892878    }
    22902879
     
    23012890    {
    23022891      di->expansion -= d_left (tl)->u.s_builtin.type->len;
    2303       tl = NULL;
    2304     }
    2305 
    2306   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
     2892      d_left (tl) = NULL;
     2893    }
     2894
     2895  return tl;
     2896}
     2897
     2898/* <bare-function-type> ::= [J]<type>+  */
     2899
     2900static struct demangle_component *
     2901d_bare_function_type (struct d_info *di, int has_return_type)
     2902{
     2903  struct demangle_component *return_type;
     2904  struct demangle_component *tl;
     2905  char peek;
     2906
     2907  /* Detect special qualifier indicating that the first argument
     2908     is the return type.  */
     2909  peek = d_peek_char (di);
     2910  if (peek == 'J')
     2911    {
     2912      d_advance (di, 1);
     2913      has_return_type = 1;
     2914    }
     2915
     2916  if (has_return_type)
     2917    {
     2918      return_type = cplus_demangle_type (di);
     2919      if (return_type == NULL)
     2920        return NULL;
     2921    }
     2922  else
     2923    return_type = NULL;
     2924
     2925  tl = d_parmlist (di);
     2926  if (tl == NULL)
     2927    return NULL;
     2928
     2929  return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
     2930                      return_type, tl);
    23072931}
    23082932
     
    23602984}
    23612985
     2986/* <vector-type> ::= Dv <number> _ <type>
     2987                 ::= Dv _ <expression> _ <type> */
     2988
     2989static struct demangle_component *
     2990d_vector_type (struct d_info *di)
     2991{
     2992  char peek;
     2993  struct demangle_component *dim;
     2994
     2995  peek = d_peek_char (di);
     2996  if (peek == '_')
     2997    {
     2998      d_advance (di, 1);
     2999      dim = d_expression (di);
     3000    }
     3001  else
     3002    dim = d_number_component (di);
     3003
     3004  if (dim == NULL)
     3005    return NULL;
     3006
     3007  if (! d_check_char (di, '_'))
     3008    return NULL;
     3009
     3010  return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
     3011                      cplus_demangle_type (di));
     3012}
     3013
    23623014/* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
    23633015
     
    23673019  struct demangle_component *cl;
    23683020  struct demangle_component *mem;
    2369   struct demangle_component **pmem;
    23703021
    23713022  if (! d_check_char (di, 'M'))
     
    23733024
    23743025  cl = cplus_demangle_type (di);
    2375 
    2376   /* The ABI specifies that any type can be a substitution source, and
    2377      that M is followed by two types, and that when a CV-qualified
    2378      type is seen both the base type and the CV-qualified types are
    2379      substitution sources.  The ABI also specifies that for a pointer
    2380      to a CV-qualified member function, the qualifiers are attached to
    2381      the second type.  Given the grammar, a plain reading of the ABI
    2382      suggests that both the CV-qualified member function and the
    2383      non-qualified member function are substitution sources.  However,
    2384      g++ does not work that way.  g++ treats only the CV-qualified
    2385      member function as a substitution source.  FIXME.  So to work
    2386      with g++, we need to pull off the CV-qualifiers here, in order to
    2387      avoid calling add_substitution() in cplus_demangle_type().  But
    2388      for a CV-qualified member which is not a function, g++ does
    2389      follow the ABI, so we need to handle that case here by calling
    2390      d_add_substitution ourselves.  */
    2391 
    2392   pmem = d_cv_qualifiers (di, &mem, 1);
    2393   if (pmem == NULL)
     3026  if (cl == NULL)
    23943027    return NULL;
    2395   *pmem = cplus_demangle_type (di);
    2396   if (*pmem == NULL)
     3028
     3029  /* The ABI says, "The type of a non-static member function is considered
     3030     to be different, for the purposes of substitution, from the type of a
     3031     namespace-scope or static member function whose type appears
     3032     similar. The types of two non-static member functions are considered
     3033     to be different, for the purposes of substitution, if the functions
     3034     are members of different classes. In other words, for the purposes of
     3035     substitution, the class of which the function is a member is
     3036     considered part of the type of function."
     3037
     3038     For a pointer to member function, this call to cplus_demangle_type
     3039     will end up adding a (possibly qualified) non-member function type to
     3040     the substitution table, which is not correct; however, the member
     3041     function type will never be used in a substitution, so putting the
     3042     wrong type in the substitution table is harmless.  */
     3043
     3044  mem = cplus_demangle_type (di);
     3045  if (mem == NULL)
    23973046    return NULL;
    23983047
    2399   if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
    2400     {
    2401       if (! d_add_substitution (di, mem))
    2402         return NULL;
    2403     }
    2404 
    24053048  return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
     3049}
     3050
     3051/* <non-negative number> _ */
     3052
     3053static int
     3054d_compact_number (struct d_info *di)
     3055{
     3056  int num;
     3057  if (d_peek_char (di) == '_')
     3058    num = 0;
     3059  else if (d_peek_char (di) == 'n')
     3060    return -1;
     3061  else
     3062    num = d_number (di) + 1;
     3063
     3064  if (num < 0 || ! d_check_char (di, '_'))
     3065    return -1;
     3066  return num;
    24063067}
    24073068
     
    24133074d_template_param (struct d_info *di)
    24143075{
    2415   long param;
     3076  int param;
    24163077
    24173078  if (! d_check_char (di, 'T'))
    24183079    return NULL;
    24193080
    2420   if (d_peek_char (di) == '_')
    2421     param = 0;
    2422   else
    2423     {
    2424       param = d_number (di);
    2425       if (param < 0)
    2426         return NULL;
    2427       param += 1;
    2428     }
    2429 
    2430   if (! d_check_char (di, '_'))
     3081  param = d_compact_number (di);
     3082  if (param < 0)
    24313083    return NULL;
    24323084
    2433   ++di->did_subs;
    2434 
    24353085  return d_make_template_param (di, param);
    24363086}
     
    24403090static struct demangle_component *
    24413091d_template_args (struct d_info *di)
     3092{
     3093  if (d_peek_char (di) != 'I'
     3094      && d_peek_char (di) != 'J')
     3095    return NULL;
     3096  d_advance (di, 1);
     3097
     3098  return d_template_args_1 (di);
     3099}
     3100
     3101/* <template-arg>* E  */
     3102
     3103static struct demangle_component *
     3104d_template_args_1 (struct d_info *di)
    24423105{
    24433106  struct demangle_component *hold_last_name;
     
    24493112     constructor or destructor.  */
    24503113  hold_last_name = di->last_name;
    2451 
    2452   if (! d_check_char (di, 'I'))
    2453     return NULL;
    24543114
    24553115  if (d_peek_char (di) == 'E')
     
    25103170
    25113171    case 'I':
     3172    case 'J':
    25123173      /* An argument pack.  */
    25133174      return d_template_args (di);
     
    25183179}
    25193180
    2520 /* Subroutine of <expression> ::= cl <expression>+ E */
    2521 
    2522 static struct demangle_component *
    2523 d_exprlist (struct d_info *di)
     3181/* Parse a sequence of expressions until we hit the terminator
     3182   character.  */
     3183
     3184static struct demangle_component *
     3185d_exprlist (struct d_info *di, char terminator)
    25243186{
    25253187  struct demangle_component *list = NULL;
    25263188  struct demangle_component **p = &list;
    25273189
    2528   if (d_peek_char (di) == 'E')
     3190  if (d_peek_char (di) == terminator)
    25293191    {
    25303192      d_advance (di, 1);
     
    25433205      p = &d_right (*p);
    25443206
    2545       if (d_peek_char (di) == 'E')
     3207      if (d_peek_char (di) == terminator)
    25463208        {
    25473209          d_advance (di, 1);
     
    25513213
    25523214  return list;
     3215}
     3216
     3217/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
     3218   dynamic_cast, static_cast or reinterpret_cast.  */
     3219
     3220static int
     3221op_is_new_cast (struct demangle_component *op)
     3222{
     3223  const char *code = op->u.s_operator.op->code;
     3224  return (code[1] == 'c'
     3225          && (code[0] == 's' || code[0] == 'd'
     3226              || code[0] == 'c' || code[0] == 'r'));
    25533227}
    25543228
     
    25643238*/
    25653239
    2566 static struct demangle_component *
    2567 d_expression (struct d_info *di)
     3240static inline struct demangle_component *
     3241d_expression_1 (struct d_info *di)
    25683242{
    25693243  char peek;
     
    25933267      d_advance (di, 2);
    25943268      return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
    2595                           d_expression (di), NULL);
     3269                          d_expression_1 (di), NULL);
    25963270    }
    25973271  else if (peek == 'f' && d_peek_next_char (di) == 'p')
     
    26003274      int index;
    26013275      d_advance (di, 2);
    2602       if (d_peek_char (di) == '_')
    2603         index = 1;
     3276      if (d_peek_char (di) == 'T')
     3277        {
     3278          /* 'this' parameter.  */
     3279          d_advance (di, 1);
     3280          index = 0;
     3281        }
    26043282      else
    26053283        {
    2606           index = d_number (di);
    2607           if (index < 0)
     3284          index = d_compact_number (di);
     3285          if (index == INT_MAX || index == -1)
    26083286            return NULL;
    2609           index += 2;
     3287          index++;
    26103288        }
    2611 
    2612       if (! d_check_char (di, '_'))
    2613         return NULL;
    2614 
    26153289      return d_make_function_param (di, index);
    26163290    }
    2617   else if (IS_DIGIT (peek))
     3291  else if (IS_DIGIT (peek)
     3292           || (peek == 'o' && d_peek_next_char (di) == 'n'))
    26183293    {
    26193294      /* We can get an unqualified name as an expression in the case of
    2620          a dependent member access, i.e. decltype(T().i).  */
    2621       struct demangle_component *name = d_unqualified_name (di);
     3295         a dependent function call, i.e. decltype(f(t)).  */
     3296      struct demangle_component *name;
     3297
     3298      if (peek == 'o')
     3299        /* operator-function-id, i.e. operator+(t).  */
     3300        d_advance (di, 2);
     3301
     3302      name = d_unqualified_name (di);
    26223303      if (name == NULL)
    26233304        return NULL;
     
    26283309        return name;
    26293310    }
     3311  else if ((peek == 'i' || peek == 't')
     3312           && d_peek_next_char (di) == 'l')
     3313    {
     3314      /* Brace-enclosed initializer list, untyped or typed.  */
     3315      struct demangle_component *type = NULL;
     3316      if (peek == 't')
     3317        type = cplus_demangle_type (di);
     3318      if (!d_peek_next_char (di))
     3319        return NULL;
     3320      d_advance (di, 2);
     3321      return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
     3322                          type, d_exprlist (di, 'E'));
     3323    }
    26303324  else
    26313325    {
    26323326      struct demangle_component *op;
     3327      const char *code = NULL;
    26333328      int args;
    26343329
     
    26383333
    26393334      if (op->type == DEMANGLE_COMPONENT_OPERATOR)
    2640         di->expansion += op->u.s_operator.op->len - 2;
    2641 
    2642       if (op->type == DEMANGLE_COMPONENT_OPERATOR
    2643           && strcmp (op->u.s_operator.op->code, "st") == 0)
    2644         return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
    2645                             cplus_demangle_type (di));
     3335        {
     3336          code = op->u.s_operator.op->code;
     3337          di->expansion += op->u.s_operator.op->len - 2;
     3338          if (strcmp (code, "st") == 0)
     3339            return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
     3340                                cplus_demangle_type (di));
     3341        }
    26463342
    26473343      switch (op->type)
     
    26623358      switch (args)
    26633359        {
     3360        case 0:
     3361          return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
     3362
    26643363        case 1:
    26653364          {
    26663365            struct demangle_component *operand;
     3366            int suffix = 0;
     3367
     3368            if (code && (code[0] == 'p' || code[0] == 'm')
     3369                && code[1] == code[0])
     3370              /* pp_ and mm_ are the prefix variants.  */
     3371              suffix = !d_check_char (di, '_');
     3372
    26673373            if (op->type == DEMANGLE_COMPONENT_CAST
    26683374                && d_check_char (di, '_'))
    2669               operand = d_exprlist (di);
     3375              operand = d_exprlist (di, 'E');
     3376            else if (code && !strcmp (code, "sP"))
     3377              operand = d_template_args_1 (di);
    26703378            else
    2671               operand = d_expression (di);
    2672             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
    2673                                 operand);
     3379              operand = d_expression_1 (di);
     3380
     3381            if (suffix)
     3382              /* Indicate the suffix variant for d_print_comp.  */
     3383              return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
     3384                                  d_make_comp (di,
     3385                                               DEMANGLE_COMPONENT_BINARY_ARGS,
     3386                                               operand, operand));
     3387            else
     3388              return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
     3389                                  operand);
    26743390          }
    26753391        case 2:
     
    26783394            struct demangle_component *right;
    26793395
    2680             left = d_expression (di);
    2681             if (!strcmp (op->u.s_operator.op->code, "cl"))
    2682               right = d_exprlist (di);
     3396            if (code == NULL)
     3397              return NULL;
     3398            if (op_is_new_cast (op))
     3399              left = cplus_demangle_type (di);
     3400            else if (code[0] == 'f')
     3401              /* fold-expression.  */
     3402              left = d_operator_name (di);
    26833403            else
    2684               right = d_expression (di);
     3404              left = d_expression_1 (di);
     3405            if (!strcmp (code, "cl"))
     3406              right = d_exprlist (di, 'E');
     3407            else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
     3408              {
     3409                right = d_unqualified_name (di);
     3410                if (d_peek_char (di) == 'I')
     3411                  right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
     3412                                       right, d_template_args (di));
     3413              }
     3414            else
     3415              right = d_expression_1 (di);
    26853416
    26863417            return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
     
    26933424            struct demangle_component *first;
    26943425            struct demangle_component *second;
    2695 
    2696             first = d_expression (di);
    2697             second = d_expression (di);
     3426            struct demangle_component *third;
     3427
     3428            if (code == NULL)
     3429              return NULL;
     3430            else if (!strcmp (code, "qu"))
     3431              {
     3432                /* ?: expression.  */
     3433                first = d_expression_1 (di);
     3434                second = d_expression_1 (di);
     3435                third = d_expression_1 (di);
     3436                if (third == NULL)
     3437                  return NULL;
     3438              }
     3439            else if (code[0] == 'f')
     3440              {
     3441                /* fold-expression.  */
     3442                first = d_operator_name (di);
     3443                second = d_expression_1 (di);
     3444                third = d_expression_1 (di);
     3445                if (third == NULL)
     3446                  return NULL;
     3447              }
     3448            else if (code[0] == 'n')
     3449              {
     3450                /* new-expression.  */
     3451                if (code[1] != 'w' && code[1] != 'a')
     3452                  return NULL;
     3453                first = d_exprlist (di, '_');
     3454                second = cplus_demangle_type (di);
     3455                if (d_peek_char (di) == 'E')
     3456                  {
     3457                    d_advance (di, 1);
     3458                    third = NULL;
     3459                  }
     3460                else if (d_peek_char (di) == 'p'
     3461                         && d_peek_next_char (di) == 'i')
     3462                  {
     3463                    /* Parenthesized initializer.  */
     3464                    d_advance (di, 2);
     3465                    third = d_exprlist (di, 'E');
     3466                  }
     3467                else if (d_peek_char (di) == 'i'
     3468                         && d_peek_next_char (di) == 'l')
     3469                  /* initializer-list.  */
     3470                  third = d_expression_1 (di);
     3471                else
     3472                  return NULL;
     3473              }
     3474            else
     3475              return NULL;
    26983476            return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
    26993477                                d_make_comp (di,
     
    27023480                                             d_make_comp (di,
    27033481                                                          DEMANGLE_COMPONENT_TRINARY_ARG2,
    2704                                                           second,
    2705                                                           d_expression (di))));
     3482                                                          second, third)));
    27063483          }
    27073484        default:
     
    27093486        }
    27103487    }
     3488}
     3489
     3490static struct demangle_component *
     3491d_expression (struct d_info *di)
     3492{
     3493  struct demangle_component *ret;
     3494  int was_expression = di->is_expression;
     3495
     3496  di->is_expression = 1;
     3497  ret = d_expression_1 (di);
     3498  di->is_expression = was_expression;
     3499  return ret;
    27113500}
    27123501
     
    27763565/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
    27773566                ::= Z <(function) encoding> E s [<discriminator>]
     3567                ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
    27783568*/
    27793569
     
    28033593    {
    28043594      struct demangle_component *name;
     3595      int num = -1;
     3596
     3597      if (d_peek_char (di) == 'd')
     3598        {
     3599          /* Default argument scope: d <number> _.  */
     3600          d_advance (di, 1);
     3601          num = d_compact_number (di);
     3602          if (num < 0)
     3603            return NULL;
     3604        }
    28053605
    28063606      name = d_name (di);
    2807       if (! d_discriminator (di))
    2808         return NULL;
     3607      if (name)
     3608        switch (name->type)
     3609          {
     3610            /* Lambdas and unnamed types have internal discriminators.  */
     3611          case DEMANGLE_COMPONENT_LAMBDA:
     3612          case DEMANGLE_COMPONENT_UNNAMED_TYPE:
     3613            break;
     3614          default:
     3615            if (! d_discriminator (di))
     3616              return NULL;
     3617          }
     3618      if (num >= 0)
     3619        name = d_make_default_arg (di, num, name);
    28093620      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
    28103621    }
    28113622}
    28123623
    2813 /* <discriminator> ::= _ <(non-negative) number>
     3624/* <discriminator> ::= _ <number>    # when number < 10
     3625                   ::= __ <number> _ # when number >= 10
     3626
     3627   <discriminator> ::= _ <number>    # when number >=10
     3628   is also accepted to support gcc versions that wrongly mangled that way.
    28143629
    28153630   We demangle the discriminator, but we don't print it out.  FIXME:
     
    28193634d_discriminator (struct d_info *di)
    28203635{
    2821   long discrim;
     3636  int discrim, num_underscores = 1;
    28223637
    28233638  if (d_peek_char (di) != '_')
    28243639    return 1;
    28253640  d_advance (di, 1);
     3641  if (d_peek_char (di) == '_')
     3642    {
     3643      ++num_underscores;
     3644      d_advance (di, 1);
     3645    }
     3646
    28263647  discrim = d_number (di);
    28273648  if (discrim < 0)
    28283649    return 0;
     3650  if (num_underscores > 1 && discrim >= 10)
     3651    {
     3652      if (d_peek_char (di) == '_')
     3653        d_advance (di, 1);
     3654      else
     3655        return 0;
     3656    }
     3657
    28293658  return 1;
     3659}
     3660
     3661/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
     3662
     3663static struct demangle_component *
     3664d_lambda (struct d_info *di)
     3665{
     3666  struct demangle_component *tl;
     3667  struct demangle_component *ret;
     3668  int num;
     3669
     3670  if (! d_check_char (di, 'U'))
     3671    return NULL;
     3672  if (! d_check_char (di, 'l'))
     3673    return NULL;
     3674
     3675  tl = d_parmlist (di);
     3676  if (tl == NULL)
     3677    return NULL;
     3678
     3679  if (! d_check_char (di, 'E'))
     3680    return NULL;
     3681
     3682  num = d_compact_number (di);
     3683  if (num < 0)
     3684    return NULL;
     3685
     3686  ret = d_make_empty (di);
     3687  if (ret)
     3688    {
     3689      ret->type = DEMANGLE_COMPONENT_LAMBDA;
     3690      ret->u.s_unary_num.sub = tl;
     3691      ret->u.s_unary_num.num = num;
     3692    }
     3693
     3694  if (! d_add_substitution (di, ret))
     3695    return NULL;
     3696
     3697  return ret;
     3698}
     3699
     3700/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
     3701
     3702static struct demangle_component *
     3703d_unnamed_type (struct d_info *di)
     3704{
     3705  struct demangle_component *ret;
     3706  int num;
     3707
     3708  if (! d_check_char (di, 'U'))
     3709    return NULL;
     3710  if (! d_check_char (di, 't'))
     3711    return NULL;
     3712
     3713  num = d_compact_number (di);
     3714  if (num < 0)
     3715    return NULL;
     3716
     3717  ret = d_make_empty (di);
     3718  if (ret)
     3719    {
     3720      ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
     3721      ret->u.s_number.number = num;
     3722    }
     3723
     3724  if (! d_add_substitution (di, ret))
     3725    return NULL;
     3726
     3727  return ret;
     3728}
     3729
     3730/* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
     3731*/
     3732
     3733static struct demangle_component *
     3734d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
     3735{
     3736  const char *suffix = d_str (di);
     3737  const char *pend = suffix;
     3738  struct demangle_component *n;
     3739
     3740  if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
     3741    {
     3742      pend += 2;
     3743      while (IS_LOWER (*pend) || *pend == '_')
     3744        ++pend;
     3745    }
     3746  while (*pend == '.' && IS_DIGIT (pend[1]))
     3747    {
     3748      pend += 2;
     3749      while (IS_DIGIT (*pend))
     3750        ++pend;
     3751    }
     3752  d_advance (di, pend - suffix);
     3753  n = d_make_name (di, suffix, pend - suffix);
     3754  return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
    28303755}
    28313756
     
    29273852        return NULL;
    29283853
    2929       ++di->did_subs;
    2930 
    29313854      return di->subs[id];
    29323855    }
     
    29553878              const char *s;
    29563879              int len;
     3880              struct demangle_component *dc;
    29573881
    29583882              if (p->set_last_name != NULL)
     
    29703894                }
    29713895              di->expansion += len;
    2972               return d_make_sub (di, s, len);
     3896              dc = d_make_sub (di, s, len);
     3897              if (d_peek_char (di) == 'B')
     3898                {
     3899                  /* If there are ABI tags on the abbreviation, it becomes
     3900                     a substitution candidate.  */
     3901                  dc = d_abi_tags (di, dc);
     3902                  if (! d_add_substitution (di, dc))
     3903                    return NULL;
     3904                }
     3905              return dc;
    29733906            }
    29743907        }
     
    29763909      return NULL;
    29773910    }
     3911}
     3912
     3913static void
     3914d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
     3915{
     3916  checkpoint->n = di->n;
     3917  checkpoint->next_comp = di->next_comp;
     3918  checkpoint->next_sub = di->next_sub;
     3919  checkpoint->expansion = di->expansion;
     3920}
     3921
     3922static void
     3923d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
     3924{
     3925  di->n = checkpoint->n;
     3926  di->next_comp = checkpoint->next_comp;
     3927  di->next_sub = checkpoint->next_sub;
     3928  di->expansion = checkpoint->expansion;
    29783929}
    29793930
     
    30544005}
    30554006
     4007/* Walk the tree, counting the number of templates encountered, and
     4008   the number of times a scope might be saved.  These counts will be
     4009   used to allocate data structures for d_print_comp, so the logic
     4010   here must mirror the logic d_print_comp will use.  It is not
     4011   important that the resulting numbers are exact, so long as they
     4012   are larger than the actual numbers encountered.  */
     4013
     4014static void
     4015d_count_templates_scopes (int *num_templates, int *num_scopes,
     4016                          const struct demangle_component *dc)
     4017{
     4018  if (dc == NULL)
     4019    return;
     4020
     4021  switch (dc->type)
     4022    {
     4023    case DEMANGLE_COMPONENT_NAME:
     4024    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
     4025    case DEMANGLE_COMPONENT_FUNCTION_PARAM:
     4026    case DEMANGLE_COMPONENT_SUB_STD:
     4027    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
     4028    case DEMANGLE_COMPONENT_OPERATOR:
     4029    case DEMANGLE_COMPONENT_CHARACTER:
     4030    case DEMANGLE_COMPONENT_NUMBER:
     4031    case DEMANGLE_COMPONENT_UNNAMED_TYPE:
     4032      break;
     4033
     4034    case DEMANGLE_COMPONENT_TEMPLATE:
     4035      (*num_templates)++;
     4036      goto recurse_left_right;
     4037
     4038    case DEMANGLE_COMPONENT_REFERENCE:
     4039    case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
     4040      if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
     4041        (*num_scopes)++;
     4042      goto recurse_left_right;
     4043
     4044    case DEMANGLE_COMPONENT_QUAL_NAME:
     4045    case DEMANGLE_COMPONENT_LOCAL_NAME:
     4046    case DEMANGLE_COMPONENT_TYPED_NAME:
     4047    case DEMANGLE_COMPONENT_VTABLE:
     4048    case DEMANGLE_COMPONENT_VTT:
     4049    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
     4050    case DEMANGLE_COMPONENT_TYPEINFO:
     4051    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
     4052    case DEMANGLE_COMPONENT_TYPEINFO_FN:
     4053    case DEMANGLE_COMPONENT_THUNK:
     4054    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
     4055    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
     4056    case DEMANGLE_COMPONENT_JAVA_CLASS:
     4057    case DEMANGLE_COMPONENT_GUARD:
     4058    case DEMANGLE_COMPONENT_TLS_INIT:
     4059    case DEMANGLE_COMPONENT_TLS_WRAPPER:
     4060    case DEMANGLE_COMPONENT_REFTEMP:
     4061    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
     4062    case DEMANGLE_COMPONENT_RESTRICT:
     4063    case DEMANGLE_COMPONENT_VOLATILE:
     4064    case DEMANGLE_COMPONENT_CONST:
     4065    case DEMANGLE_COMPONENT_RESTRICT_THIS:
     4066    case DEMANGLE_COMPONENT_VOLATILE_THIS:
     4067    case DEMANGLE_COMPONENT_CONST_THIS:
     4068    case DEMANGLE_COMPONENT_REFERENCE_THIS:
     4069    case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
     4070    case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
     4071    case DEMANGLE_COMPONENT_NOEXCEPT:
     4072    case DEMANGLE_COMPONENT_THROW_SPEC:
     4073    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     4074    case DEMANGLE_COMPONENT_POINTER:
     4075    case DEMANGLE_COMPONENT_COMPLEX:
     4076    case DEMANGLE_COMPONENT_IMAGINARY:
     4077    case DEMANGLE_COMPONENT_VENDOR_TYPE:
     4078    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
     4079    case DEMANGLE_COMPONENT_ARRAY_TYPE:
     4080    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     4081    case DEMANGLE_COMPONENT_VECTOR_TYPE:
     4082    case DEMANGLE_COMPONENT_ARGLIST:
     4083    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
     4084    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
     4085    case DEMANGLE_COMPONENT_CAST:
     4086    case DEMANGLE_COMPONENT_CONVERSION:
     4087    case DEMANGLE_COMPONENT_NULLARY:
     4088    case DEMANGLE_COMPONENT_UNARY:
     4089    case DEMANGLE_COMPONENT_BINARY:
     4090    case DEMANGLE_COMPONENT_BINARY_ARGS:
     4091    case DEMANGLE_COMPONENT_TRINARY:
     4092    case DEMANGLE_COMPONENT_TRINARY_ARG1:
     4093    case DEMANGLE_COMPONENT_TRINARY_ARG2:
     4094    case DEMANGLE_COMPONENT_LITERAL:
     4095    case DEMANGLE_COMPONENT_LITERAL_NEG:
     4096    case DEMANGLE_COMPONENT_JAVA_RESOURCE:
     4097    case DEMANGLE_COMPONENT_COMPOUND_NAME:
     4098    case DEMANGLE_COMPONENT_DECLTYPE:
     4099    case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     4100    case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
     4101    case DEMANGLE_COMPONENT_PACK_EXPANSION:
     4102    case DEMANGLE_COMPONENT_TAGGED_NAME:
     4103    case DEMANGLE_COMPONENT_CLONE:
     4104    recurse_left_right:
     4105      d_count_templates_scopes (num_templates, num_scopes,
     4106                                d_left (dc));
     4107      d_count_templates_scopes (num_templates, num_scopes,
     4108                                d_right (dc));
     4109      break;
     4110
     4111    case DEMANGLE_COMPONENT_CTOR:
     4112      d_count_templates_scopes (num_templates, num_scopes,
     4113                                dc->u.s_ctor.name);
     4114      break;
     4115
     4116    case DEMANGLE_COMPONENT_DTOR:
     4117      d_count_templates_scopes (num_templates, num_scopes,
     4118                                dc->u.s_dtor.name);
     4119      break;
     4120
     4121    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
     4122      d_count_templates_scopes (num_templates, num_scopes,
     4123                                dc->u.s_extended_operator.name);
     4124      break;
     4125
     4126    case DEMANGLE_COMPONENT_FIXED_TYPE:
     4127      d_count_templates_scopes (num_templates, num_scopes,
     4128                                dc->u.s_fixed.length);
     4129      break;
     4130
     4131    case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
     4132    case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
     4133      d_count_templates_scopes (num_templates, num_scopes,
     4134                                d_left (dc));
     4135      break;
     4136
     4137    case DEMANGLE_COMPONENT_LAMBDA:
     4138    case DEMANGLE_COMPONENT_DEFAULT_ARG:
     4139      d_count_templates_scopes (num_templates, num_scopes,
     4140                                dc->u.s_unary_num.sub);
     4141      break;
     4142    }
     4143}
     4144
    30564145/* Initialize a print information structure.  */
    30574146
    30584147static void
    3059 d_print_init (struct d_print_info *dpi, int options,
    3060               demangle_callbackref callback, void *opaque)
    3061 {
    3062   dpi->options = options;
     4148d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
     4149              void *opaque, const struct demangle_component *dc)
     4150{
    30634151  dpi->len = 0;
    30644152  dpi->last_char = '\0';
    30654153  dpi->templates = NULL;
    30664154  dpi->modifiers = NULL;
     4155  dpi->pack_index = 0;
     4156  dpi->flush_count = 0;
    30674157
    30684158  dpi->callback = callback;
     
    30704160
    30714161  dpi->demangle_failure = 0;
     4162  dpi->recursion = 0;
     4163  dpi->is_lambda_arg = 0;
     4164
     4165  dpi->component_stack = NULL;
     4166
     4167  dpi->saved_scopes = NULL;
     4168  dpi->next_saved_scope = 0;
     4169  dpi->num_saved_scopes = 0;
     4170
     4171  dpi->copy_templates = NULL;
     4172  dpi->next_copy_template = 0;
     4173  dpi->num_copy_templates = 0;
     4174
     4175  d_count_templates_scopes (&dpi->num_copy_templates,
     4176                            &dpi->num_saved_scopes, dc);
     4177  dpi->num_copy_templates *= dpi->num_saved_scopes;
     4178
     4179  dpi->current_template = NULL;
    30724180}
    30734181
     
    30944202  dpi->callback (dpi->buf, dpi->len, dpi->opaque);
    30954203  dpi->len = 0;
     4204  dpi->flush_count++;
    30964205}
    30974206
     
    31214230{
    31224231  d_append_buffer (dpi, s, strlen (s));
     4232}
     4233
     4234static inline void
     4235d_append_num (struct d_print_info *dpi, int l)
     4236{
     4237  char buf[25];
     4238  sprintf (buf,"%d", l);
     4239  d_append_string (dpi, buf);
    31234240}
    31244241
     
    31414258int
    31424259cplus_demangle_print_callback (int options,
    3143                                const struct demangle_component *dc,
     4260                               struct demangle_component *dc,
    31444261                               demangle_callbackref callback, void *opaque)
    31454262{
    31464263  struct d_print_info dpi;
    31474264
    3148   d_print_init (&dpi, options, callback, opaque);
    3149 
    3150   d_print_comp (&dpi, dc);
     4265  d_print_init (&dpi, callback, opaque, dc);
     4266
     4267  {
     4268#ifdef CP_DYNAMIC_ARRAYS
     4269    /* Avoid zero-length VLAs, which are prohibited by the C99 standard
     4270       and flagged as errors by Address Sanitizer.  */
     4271    __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
     4272                                              ? dpi.num_saved_scopes : 1];
     4273    __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
     4274                                                ? dpi.num_copy_templates : 1];
     4275
     4276    dpi.saved_scopes = scopes;
     4277    dpi.copy_templates = temps;
     4278#else
     4279    dpi.saved_scopes = alloca (dpi.num_saved_scopes
     4280                               * sizeof (*dpi.saved_scopes));
     4281    dpi.copy_templates = alloca (dpi.num_copy_templates
     4282                                 * sizeof (*dpi.copy_templates));
     4283#endif
     4284
     4285    d_print_comp (&dpi, options, dc);
     4286  }
    31514287
    31524288  d_print_flush (&dpi);
     
    31654301CP_STATIC_IF_GLIBCPP_V3
    31664302char *
    3167 cplus_demangle_print (int options, const struct demangle_component *dc,
     4303cplus_demangle_print (int options, struct demangle_component *dc,
    31684304                      int estimate, size_t *palc)
    31694305{
     
    31864322
    31874323/* Returns the I'th element of the template arglist ARGS, or NULL on
    3188    failure.  */
     4324   failure.  If I is negative, return the entire arglist.  */
    31894325
    31904326static struct demangle_component *
     
    31924328{
    31934329  struct demangle_component *a;
     4330
     4331  if (i < 0)
     4332    /* Print the whole argument pack.  */
     4333    return args;
    31944334
    31954335  for (a = args;
     
    32484388      return NULL;
    32494389     
     4390    case DEMANGLE_COMPONENT_LAMBDA:
    32504391    case DEMANGLE_COMPONENT_NAME:
     4392    case DEMANGLE_COMPONENT_TAGGED_NAME:
    32514393    case DEMANGLE_COMPONENT_OPERATOR:
    32524394    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
     
    32544396    case DEMANGLE_COMPONENT_CHARACTER:
    32554397    case DEMANGLE_COMPONENT_FUNCTION_PARAM:
     4398    case DEMANGLE_COMPONENT_UNNAMED_TYPE:
     4399    case DEMANGLE_COMPONENT_FIXED_TYPE:
     4400    case DEMANGLE_COMPONENT_DEFAULT_ARG:
     4401    case DEMANGLE_COMPONENT_NUMBER:
    32564402      return NULL;
    32574403
     
    32864432}
    32874433
     4434/* Returns the number of template args in DC, expanding any pack expansions
     4435   found there.  */
     4436
     4437static int
     4438d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
     4439{
     4440  int count = 0;
     4441  for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
     4442       dc = d_right (dc))
     4443    {
     4444      struct demangle_component *elt = d_left (dc);
     4445      if (elt == NULL)
     4446        break;
     4447      if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
     4448        {
     4449          struct demangle_component *a = d_find_pack (dpi, d_left (elt));
     4450          count += d_pack_length (a);
     4451        }
     4452      else
     4453        ++count;
     4454    }
     4455  return count;
     4456}
     4457
    32884458/* DC is a component of a mangled expression.  Print it, wrapped in parens
    32894459   if needed.  */
    32904460
    32914461static void
    3292 d_print_subexpr (struct d_print_info *dpi,
    3293                  const struct demangle_component *dc)
     4462d_print_subexpr (struct d_print_info *dpi, int options,
     4463                 struct demangle_component *dc)
    32944464{
    32954465  int simple = 0;
    32964466  if (dc->type == DEMANGLE_COMPONENT_NAME
     4467      || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
     4468      || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
    32974469      || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
    32984470    simple = 1;
    32994471  if (!simple)
    33004472    d_append_char (dpi, '(');
    3301   d_print_comp (dpi, dc);
     4473  d_print_comp (dpi, options, dc);
    33024474  if (!simple)
    33034475    d_append_char (dpi, ')');
    33044476}
    33054477
     4478/* Save the current scope.  */
     4479
     4480static void
     4481d_save_scope (struct d_print_info *dpi,
     4482              const struct demangle_component *container)
     4483{
     4484  struct d_saved_scope *scope;
     4485  struct d_print_template *src, **link;
     4486
     4487  if (dpi->next_saved_scope >= dpi->num_saved_scopes)
     4488    {
     4489      d_print_error (dpi);
     4490      return;
     4491    }
     4492  scope = &dpi->saved_scopes[dpi->next_saved_scope];
     4493  dpi->next_saved_scope++;
     4494
     4495  scope->container = container;
     4496  link = &scope->templates;
     4497
     4498  for (src = dpi->templates; src != NULL; src = src->next)
     4499    {
     4500      struct d_print_template *dst;
     4501
     4502      if (dpi->next_copy_template >= dpi->num_copy_templates)
     4503        {
     4504          d_print_error (dpi);
     4505          return;
     4506        }
     4507      dst = &dpi->copy_templates[dpi->next_copy_template];
     4508      dpi->next_copy_template++;
     4509
     4510      dst->template_decl = src->template_decl;
     4511      *link = dst;
     4512      link = &dst->next;
     4513    }
     4514
     4515  *link = NULL;
     4516}
     4517
     4518/* Attempt to locate a previously saved scope.  Returns NULL if no
     4519   corresponding saved scope was found.  */
     4520
     4521static struct d_saved_scope *
     4522d_get_saved_scope (struct d_print_info *dpi,
     4523                   const struct demangle_component *container)
     4524{
     4525  int i;
     4526
     4527  for (i = 0; i < dpi->next_saved_scope; i++)
     4528    if (dpi->saved_scopes[i].container == container)
     4529      return &dpi->saved_scopes[i];
     4530
     4531  return NULL;
     4532}
     4533
     4534/* If DC is a C++17 fold-expression, print it and return true; otherwise
     4535   return false.  */
     4536
     4537static int
     4538d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
     4539                               struct demangle_component *dc)
     4540{
     4541  struct demangle_component *ops, *operator_, *op1, *op2;
     4542  int save_idx;
     4543
     4544  const char *fold_code = d_left (dc)->u.s_operator.op->code;
     4545  if (fold_code[0] != 'f')
     4546    return 0;
     4547
     4548  ops = d_right (dc);
     4549  operator_ = d_left (ops);
     4550  op1 = d_right (ops);
     4551  op2 = 0;
     4552  if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
     4553    {
     4554      op2 = d_right (op1);
     4555      op1 = d_left (op1);
     4556    }
     4557
     4558  /* Print the whole pack.  */
     4559  save_idx = dpi->pack_index;
     4560  dpi->pack_index = -1;
     4561
     4562  switch (fold_code[1])
     4563    {
     4564      /* Unary left fold, (... + X).  */
     4565    case 'l':
     4566      d_append_string (dpi, "(...");
     4567      d_print_expr_op (dpi, options, operator_);
     4568      d_print_subexpr (dpi, options, op1);
     4569      d_append_char (dpi, ')');
     4570      break;
     4571
     4572      /* Unary right fold, (X + ...).  */
     4573    case 'r':
     4574      d_append_char (dpi, '(');
     4575      d_print_subexpr (dpi, options, op1);
     4576      d_print_expr_op (dpi, options, operator_);
     4577      d_append_string (dpi, "...)");
     4578      break;
     4579
     4580      /* Binary left fold, (42 + ... + X).  */
     4581    case 'L':
     4582      /* Binary right fold, (X + ... + 42).  */
     4583    case 'R':
     4584      d_append_char (dpi, '(');
     4585      d_print_subexpr (dpi, options, op1);
     4586      d_print_expr_op (dpi, options, operator_);
     4587      d_append_string (dpi, "...");
     4588      d_print_expr_op (dpi, options, operator_);
     4589      d_print_subexpr (dpi, options, op2);
     4590      d_append_char (dpi, ')');
     4591      break;
     4592    }
     4593
     4594  dpi->pack_index = save_idx;
     4595  return 1;
     4596}
     4597
    33064598/* Subroutine to handle components.  */
    33074599
    33084600static void
    3309 d_print_comp (struct d_print_info *dpi,
    3310               const struct demangle_component *dc)
    3311 {
     4601d_print_comp_inner (struct d_print_info *dpi, int options,
     4602                    struct demangle_component *dc)
     4603{
     4604  /* Magic variable to let reference smashing skip over the next modifier
     4605     without needing to modify *dc.  */
     4606  struct demangle_component *mod_inner = NULL;
     4607
     4608  /* Variable used to store the current templates while a previously
     4609     captured scope is used.  */
     4610  struct d_print_template *saved_templates;
     4611
     4612  /* Nonzero if templates have been stored in the above variable.  */
     4613  int need_template_restore = 0;
     4614
    33124615  if (dc == NULL)
    33134616    {
     
    33214624    {
    33224625    case DEMANGLE_COMPONENT_NAME:
    3323       if ((dpi->options & DMGL_JAVA) == 0)
     4626      if ((options & DMGL_JAVA) == 0)
    33244627        d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
    33254628      else
     
    33274630      return;
    33284631
     4632    case DEMANGLE_COMPONENT_TAGGED_NAME:
     4633      d_print_comp (dpi, options, d_left (dc));
     4634      d_append_string (dpi, "[abi:");
     4635      d_print_comp (dpi, options, d_right (dc));
     4636      d_append_char (dpi, ']');
     4637      return;
     4638
    33294639    case DEMANGLE_COMPONENT_QUAL_NAME:
    33304640    case DEMANGLE_COMPONENT_LOCAL_NAME:
    3331       d_print_comp (dpi, d_left (dc));
    3332       if ((dpi->options & DMGL_JAVA) == 0)
     4641      d_print_comp (dpi, options, d_left (dc));
     4642      if ((options & DMGL_JAVA) == 0)
    33334643        d_append_string (dpi, "::");
    33344644      else
    33354645        d_append_char (dpi, '.');
    3336       d_print_comp (dpi, d_right (dc));
     4646      {
     4647        struct demangle_component *local_name = d_right (dc);
     4648        if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
     4649          {
     4650            d_append_string (dpi, "{default arg#");
     4651            d_append_num (dpi, local_name->u.s_unary_num.num + 1);
     4652            d_append_string (dpi, "}::");
     4653            local_name = local_name->u.s_unary_num.sub;
     4654          }
     4655        d_print_comp (dpi, options, local_name);
     4656      }
    33374657      return;
    33384658
     
    33674687            ++i;
    33684688
    3369             if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
    3370                 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
    3371                 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
     4689            if (!is_fnqual_component_type (typed_name->type))
    33724690              break;
    33734691
     
    33994717
    34004718            local_name = d_right (typed_name);
    3401             while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
    3402                    || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
    3403                    || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
     4719            if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
     4720              local_name = local_name->u.s_unary_num.sub;
     4721            if (local_name == NULL)
     4722              {
     4723                d_print_error (dpi);
     4724                return;
     4725              }
     4726            while (is_fnqual_component_type (local_name->type))
    34044727              {
    34054728                if (i >= sizeof adpm / sizeof adpm[0])
     
    34224745          }
    34234746
    3424         d_print_comp (dpi, d_right (dc));
     4747        d_print_comp (dpi, options, d_right (dc));
    34254748
    34264749        if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
     
    34354758              {
    34364759                d_append_char (dpi, ' ');
    3437                 d_print_mod (dpi, adpm[i].mod);
     4760                d_print_mod (dpi, options, adpm[i].mod);
    34384761              }
    34394762          }
     
    34484771        struct d_print_mod *hold_dpm;
    34494772        struct demangle_component *dcl;
     4773        const struct demangle_component *hold_current;
     4774
     4775        /* This template may need to be referenced by a cast operator
     4776           contained in its subtree.  */
     4777        hold_current = dpi->current_template;
     4778        dpi->current_template = dc;
    34504779
    34514780        /* Don't push modifiers into a template definition.  Doing so
     
    34584787        dcl = d_left (dc);
    34594788
    3460         if ((dpi->options & DMGL_JAVA) != 0
     4789        if ((options & DMGL_JAVA) != 0
    34614790            && dcl->type == DEMANGLE_COMPONENT_NAME
    34624791            && dcl->u.s_name.len == 6
     
    34664795               instead as TYPE[].  */
    34674796
    3468             d_print_comp (dpi, d_right (dc));
     4797            d_print_comp (dpi, options, d_right (dc));
    34694798            d_append_string (dpi, "[]");
    34704799          }
    34714800        else
    34724801          {
    3473             d_print_comp (dpi, dcl);
     4802            d_print_comp (dpi, options, dcl);
    34744803            if (d_last_char (dpi) == '<')
    34754804              d_append_char (dpi, ' ');
    34764805            d_append_char (dpi, '<');
    3477             d_print_comp (dpi, d_right (dc));
     4806            d_print_comp (dpi, options, d_right (dc));
    34784807            /* Avoid generating two consecutive '>' characters, to avoid
    34794808               the C++ syntactic ambiguity.  */
     
    34844813
    34854814        dpi->modifiers = hold_dpm;
     4815        dpi->current_template = hold_current;
    34864816
    34874817        return;
     
    34894819
    34904820    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
    3491       {
    3492         struct d_print_template *hold_dpt;
    3493         struct demangle_component *a = d_lookup_template_argument (dpi, dc);
    3494 
    3495         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
    3496           a = d_index_template_argument (a, dpi->pack_index);
    3497 
    3498         if (a == NULL)
    3499           {
    3500             d_print_error (dpi);
    3501             return;
    3502           }
    3503 
    3504         /* While processing this parameter, we need to pop the list of
    3505            templates.  This is because the template parameter may
    3506            itself be a reference to a parameter of an outer
    3507            template.  */
    3508 
    3509         hold_dpt = dpi->templates;
    3510         dpi->templates = hold_dpt->next;
    3511 
    3512         d_print_comp (dpi, a);
    3513 
    3514         dpi->templates = hold_dpt;
    3515 
    3516         return;
    3517       }
     4821      if (dpi->is_lambda_arg)
     4822        {
     4823          /* Show the template parm index, as that's how g++ displays
     4824             these, and future proofs us against potential
     4825             '[]<typename T> (T *a, T *b) {...}'.  */
     4826          d_append_buffer (dpi, "auto:", 5);
     4827          d_append_num (dpi, dc->u.s_number.number + 1);
     4828        }
     4829      else
     4830        {
     4831          struct d_print_template *hold_dpt;
     4832          struct demangle_component *a = d_lookup_template_argument (dpi, dc);
     4833
     4834          if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
     4835            a = d_index_template_argument (a, dpi->pack_index);
     4836
     4837          if (a == NULL)
     4838            {
     4839              d_print_error (dpi);
     4840              return;
     4841            }
     4842
     4843          /* While processing this parameter, we need to pop the list
     4844             of templates.  This is because the template parameter may
     4845             itself be a reference to a parameter of an outer
     4846             template.  */
     4847
     4848          hold_dpt = dpi->templates;
     4849          dpi->templates = hold_dpt->next;
     4850
     4851          d_print_comp (dpi, options, a);
     4852
     4853          dpi->templates = hold_dpt;
     4854        }
     4855      return;
    35184856
    35194857    case DEMANGLE_COMPONENT_CTOR:
    3520       d_print_comp (dpi, dc->u.s_ctor.name);
     4858      d_print_comp (dpi, options, dc->u.s_ctor.name);
    35214859      return;
    35224860
    35234861    case DEMANGLE_COMPONENT_DTOR:
    35244862      d_append_char (dpi, '~');
    3525       d_print_comp (dpi, dc->u.s_dtor.name);
     4863      d_print_comp (dpi, options, dc->u.s_dtor.name);
    35264864      return;
    35274865
    35284866    case DEMANGLE_COMPONENT_VTABLE:
    35294867      d_append_string (dpi, "vtable for ");
    3530       d_print_comp (dpi, d_left (dc));
     4868      d_print_comp (dpi, options, d_left (dc));
    35314869      return;
    35324870
    35334871    case DEMANGLE_COMPONENT_VTT:
    35344872      d_append_string (dpi, "VTT for ");
    3535       d_print_comp (dpi, d_left (dc));
     4873      d_print_comp (dpi, options, d_left (dc));
    35364874      return;
    35374875
    35384876    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
    35394877      d_append_string (dpi, "construction vtable for ");
    3540       d_print_comp (dpi, d_left (dc));
     4878      d_print_comp (dpi, options, d_left (dc));
    35414879      d_append_string (dpi, "-in-");
    3542       d_print_comp (dpi, d_right (dc));
     4880      d_print_comp (dpi, options, d_right (dc));
    35434881      return;
    35444882
    35454883    case DEMANGLE_COMPONENT_TYPEINFO:
    35464884      d_append_string (dpi, "typeinfo for ");
    3547       d_print_comp (dpi, d_left (dc));
     4885      d_print_comp (dpi, options, d_left (dc));
    35484886      return;
    35494887
    35504888    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
    35514889      d_append_string (dpi, "typeinfo name for ");
    3552       d_print_comp (dpi, d_left (dc));
     4890      d_print_comp (dpi, options, d_left (dc));
    35534891      return;
    35544892
    35554893    case DEMANGLE_COMPONENT_TYPEINFO_FN:
    35564894      d_append_string (dpi, "typeinfo fn for ");
    3557       d_print_comp (dpi, d_left (dc));
     4895      d_print_comp (dpi, options, d_left (dc));
    35584896      return;
    35594897
    35604898    case DEMANGLE_COMPONENT_THUNK:
    35614899      d_append_string (dpi, "non-virtual thunk to ");
    3562       d_print_comp (dpi, d_left (dc));
     4900      d_print_comp (dpi, options, d_left (dc));
    35634901      return;
    35644902
    35654903    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
    35664904      d_append_string (dpi, "virtual thunk to ");
    3567       d_print_comp (dpi, d_left (dc));
     4905      d_print_comp (dpi, options, d_left (dc));
    35684906      return;
    35694907
    35704908    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
    35714909      d_append_string (dpi, "covariant return thunk to ");
    3572       d_print_comp (dpi, d_left (dc));
     4910      d_print_comp (dpi, options, d_left (dc));
    35734911      return;
    35744912
    35754913    case DEMANGLE_COMPONENT_JAVA_CLASS:
    35764914      d_append_string (dpi, "java Class for ");
    3577       d_print_comp (dpi, d_left (dc));
     4915      d_print_comp (dpi, options, d_left (dc));
    35784916      return;
    35794917
    35804918    case DEMANGLE_COMPONENT_GUARD:
    35814919      d_append_string (dpi, "guard variable for ");
    3582       d_print_comp (dpi, d_left (dc));
     4920      d_print_comp (dpi, options, d_left (dc));
     4921      return;
     4922
     4923    case DEMANGLE_COMPONENT_TLS_INIT:
     4924      d_append_string (dpi, "TLS init function for ");
     4925      d_print_comp (dpi, options, d_left (dc));
     4926      return;
     4927
     4928    case DEMANGLE_COMPONENT_TLS_WRAPPER:
     4929      d_append_string (dpi, "TLS wrapper function for ");
     4930      d_print_comp (dpi, options, d_left (dc));
    35834931      return;
    35844932
    35854933    case DEMANGLE_COMPONENT_REFTEMP:
    3586       d_append_string (dpi, "reference temporary for ");
    3587       d_print_comp (dpi, d_left (dc));
     4934      d_append_string (dpi, "reference temporary #");
     4935      d_print_comp (dpi, options, d_right (dc));
     4936      d_append_string (dpi, " for ");
     4937      d_print_comp (dpi, options, d_left (dc));
    35884938      return;
    35894939
    35904940    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
    35914941      d_append_string (dpi, "hidden alias for ");
    3592       d_print_comp (dpi, d_left (dc));
     4942      d_print_comp (dpi, options, d_left (dc));
     4943      return;
     4944
     4945    case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     4946      d_append_string (dpi, "transaction clone for ");
     4947      d_print_comp (dpi, options, d_left (dc));
     4948      return;
     4949
     4950    case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
     4951      d_append_string (dpi, "non-transaction clone for ");
     4952      d_print_comp (dpi, options, d_left (dc));
    35934953      return;
    35944954
     
    36174977                if (pdpm->mod->type == dc->type)
    36184978                  {
    3619                     d_print_comp (dpi, d_left (dc));
     4979                    d_print_comp (dpi, options, d_left (dc));
    36204980                    return;
    36214981                  }
     
    36234983          }
    36244984      }
     4985      goto modifier;
     4986
     4987    case DEMANGLE_COMPONENT_REFERENCE:
     4988    case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
     4989      {
     4990        /* Handle reference smashing: & + && = &.  */
     4991        struct demangle_component *sub = d_left (dc);
     4992        if (!dpi->is_lambda_arg
     4993            && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
     4994          {
     4995            struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
     4996            struct demangle_component *a;
     4997
     4998            if (scope == NULL)
     4999              {
     5000                /* This is the first time SUB has been traversed.
     5001                   We need to capture the current templates so
     5002                   they can be restored if SUB is reentered as a
     5003                   substitution.  */
     5004                d_save_scope (dpi, sub);
     5005                if (d_print_saw_error (dpi))
     5006                  return;
     5007              }
     5008            else
     5009              {
     5010                const struct d_component_stack *dcse;
     5011                int found_self_or_parent = 0;
     5012
     5013                /* This traversal is reentering SUB as a substition.
     5014                   If we are not beneath SUB or DC in the tree then we
     5015                   need to restore SUB's template stack temporarily.  */
     5016                for (dcse = dpi->component_stack; dcse != NULL;
     5017                     dcse = dcse->parent)
     5018                  {
     5019                    if (dcse->dc == sub
     5020                        || (dcse->dc == dc
     5021                            && dcse != dpi->component_stack))
     5022                      {
     5023                        found_self_or_parent = 1;
     5024                        break;
     5025                      }
     5026                  }
     5027
     5028                if (!found_self_or_parent)
     5029                  {
     5030                    saved_templates = dpi->templates;
     5031                    dpi->templates = scope->templates;
     5032                    need_template_restore = 1;
     5033                  }
     5034              }
     5035
     5036            a = d_lookup_template_argument (dpi, sub);
     5037            if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
     5038              a = d_index_template_argument (a, dpi->pack_index);
     5039
     5040            if (a == NULL)
     5041              {
     5042                if (need_template_restore)
     5043                  dpi->templates = saved_templates;
     5044
     5045                d_print_error (dpi);
     5046                return;
     5047              }
     5048
     5049            sub = a;
     5050          }
     5051
     5052        if (sub->type == DEMANGLE_COMPONENT_REFERENCE
     5053            || sub->type == dc->type)
     5054          dc = sub;
     5055        else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
     5056          mod_inner = d_left (sub);
     5057      }
    36255058      /* Fall through.  */
    3626     case DEMANGLE_COMPONENT_RESTRICT_THIS:
    3627     case DEMANGLE_COMPONENT_VOLATILE_THIS:
    3628     case DEMANGLE_COMPONENT_CONST_THIS:
     5059
    36295060    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    36305061    case DEMANGLE_COMPONENT_POINTER:
    3631     case DEMANGLE_COMPONENT_REFERENCE:
    3632     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
    36335062    case DEMANGLE_COMPONENT_COMPLEX:
    36345063    case DEMANGLE_COMPONENT_IMAGINARY:
     5064    FNQUAL_COMPONENT_CASE:
     5065    modifier:
    36355066      {
    36365067        /* We keep a list of modifiers on the stack.  */
     
    36435074        dpm.templates = dpi->templates;
    36445075
    3645         d_print_comp (dpi, d_left (dc));
     5076        if (!mod_inner)
     5077          mod_inner = d_left (dc);
     5078
     5079        d_print_comp (dpi, options, mod_inner);
    36465080
    36475081        /* If the modifier didn't get printed by the type, print it
    36485082           now.  */
    36495083        if (! dpm.printed)
    3650           d_print_mod (dpi, dc);
     5084          d_print_mod (dpi, options, dc);
    36515085
    36525086        dpi->modifiers = dpm.next;
     5087
     5088        if (need_template_restore)
     5089          dpi->templates = saved_templates;
    36535090
    36545091        return;
     
    36565093
    36575094    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
    3658       if ((dpi->options & DMGL_JAVA) == 0)
     5095      if ((options & DMGL_JAVA) == 0)
    36595096        d_append_buffer (dpi, dc->u.s_builtin.type->name,
    36605097                         dc->u.s_builtin.type->len);
     
    36655102
    36665103    case DEMANGLE_COMPONENT_VENDOR_TYPE:
    3667       d_print_comp (dpi, d_left (dc));
     5104      d_print_comp (dpi, options, d_left (dc));
    36685105      return;
    36695106
    36705107    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
    36715108      {
    3672         if ((dpi->options & DMGL_RET_POSTFIX) != 0)
    3673           d_print_function_type (dpi, dc, dpi->modifiers);
     5109        if ((options & DMGL_RET_POSTFIX) != 0)
     5110          d_print_function_type (dpi,
     5111                                 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
     5112                                 dc, dpi->modifiers);
    36745113
    36755114        /* Print return type if present */
    3676         if (d_left (dc) != NULL)
     5115        if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
     5116          d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
     5117                        d_left (dc));
     5118        else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
    36775119          {
    36785120            struct d_print_mod dpm;
     
    36865128            dpm.templates = dpi->templates;
    36875129
    3688             d_print_comp (dpi, d_left (dc));
     5130            d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
     5131                          d_left (dc));
    36895132
    36905133            dpi->modifiers = dpm.next;
     
    36955138            /* In standard prefix notation, there is a space between the
    36965139               return type and the function signature.  */
    3697             if ((dpi->options & DMGL_RET_POSTFIX) == 0)
     5140            if ((options & DMGL_RET_POSTFIX) == 0)
    36985141              d_append_char (dpi, ' ');
    36995142          }
    37005143
    3701         if ((dpi->options & DMGL_RET_POSTFIX) == 0)
    3702           d_print_function_type (dpi, dc, dpi->modifiers);
     5144        if ((options & DMGL_RET_POSTFIX) == 0)
     5145          d_print_function_type (dpi,
     5146                                 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
     5147                                 dc, dpi->modifiers);
    37035148
    37045149        return;
     
    37535198          }
    37545199
    3755         d_print_comp (dpi, d_right (dc));
     5200        d_print_comp (dpi, options, d_right (dc));
    37565201
    37575202        dpi->modifiers = hold_modifiers;
     
    37635208          {
    37645209            --i;
    3765             d_print_mod (dpi, adpm[i].mod);
     5210            d_print_mod (dpi, options, adpm[i].mod);
    37665211          }
    37675212
    3768         d_print_array_type (dpi, dc, dpi->modifiers);
     5213        d_print_array_type (dpi, options, dc, dpi->modifiers);
    37695214
    37705215        return;
     
    37725217
    37735218    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     5219    case DEMANGLE_COMPONENT_VECTOR_TYPE:
    37745220      {
    37755221        struct d_print_mod dpm;
     
    37815227        dpm.templates = dpi->templates;
    37825228
    3783         d_print_comp (dpi, d_right (dc));
     5229        d_print_comp (dpi, options, d_right (dc));
    37845230
    37855231        /* If the modifier didn't get printed by the type, print it
    37865232           now.  */
    37875233        if (! dpm.printed)
    3788           {
    3789             d_append_char (dpi, ' ');
    3790             d_print_comp (dpi, d_left (dc));
    3791             d_append_string (dpi, "::*");
    3792           }
     5234          d_print_mod (dpi, options, dc);
    37935235
    37945236        dpi->modifiers = dpm.next;
     
    38045246          != &cplus_demangle_builtin_types['i'-'a'])
    38055247        {
    3806           d_print_comp (dpi, dc->u.s_fixed.length);
     5248          d_print_comp (dpi, options, dc->u.s_fixed.length);
    38075249          d_append_char (dpi, ' ');
    38085250        }
     
    38165258    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
    38175259      if (d_left (dc) != NULL)
    3818         d_print_comp (dpi, d_left (dc));
     5260        d_print_comp (dpi, options, d_left (dc));
    38195261      if (d_right (dc) != NULL)
    38205262        {
    38215263          size_t len;
     5264          unsigned long int flush_count;
     5265          /* Make sure ", " isn't flushed by d_append_string, otherwise
     5266             dpi->len -= 2 wouldn't work.  */
     5267          if (dpi->len >= sizeof (dpi->buf) - 2)
     5268            d_print_flush (dpi);
    38225269          d_append_string (dpi, ", ");
    38235270          len = dpi->len;
    3824           d_print_comp (dpi, d_right (dc));
     5271          flush_count = dpi->flush_count;
     5272          d_print_comp (dpi, options, d_right (dc));
    38255273          /* If that didn't print anything (which can happen with empty
    38265274             template argument packs), remove the comma and space.  */
    3827           if (dpi->len == len)
     5275          if (dpi->flush_count == flush_count && dpi->len == len)
    38285276            dpi->len -= 2;
    38295277        }
    38305278      return;
    38315279
     5280    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
     5281      {
     5282        struct demangle_component *type = d_left (dc);
     5283        struct demangle_component *list = d_right (dc);
     5284
     5285        if (type)
     5286          d_print_comp (dpi, options, type);
     5287        d_append_char (dpi, '{');
     5288        d_print_comp (dpi, options, list);
     5289        d_append_char (dpi, '}');
     5290      }
     5291      return;
     5292
    38325293    case DEMANGLE_COMPONENT_OPERATOR:
    38335294      {
    3834         char c;
     5295        const struct demangle_operator_info *op = dc->u.s_operator.op;
     5296        int len = op->len;
    38355297
    38365298        d_append_string (dpi, "operator");
    3837         c = dc->u.s_operator.op->name[0];
    3838         if (IS_LOWER (c))
     5299        /* Add a space before new/delete.  */
     5300        if (IS_LOWER (op->name[0]))
    38395301          d_append_char (dpi, ' ');
    3840         d_append_buffer (dpi, dc->u.s_operator.op->name,
    3841                          dc->u.s_operator.op->len);
     5302        /* Omit a trailing space.  */
     5303        if (op->name[len-1] == ' ')
     5304          --len;
     5305        d_append_buffer (dpi, op->name, len);
    38425306        return;
    38435307      }
     
    38455309    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
    38465310      d_append_string (dpi, "operator ");
    3847       d_print_comp (dpi, dc->u.s_extended_operator.name);
    3848       return;
    3849 
    3850     case DEMANGLE_COMPONENT_CAST:
     5311      d_print_comp (dpi, options, dc->u.s_extended_operator.name);
     5312      return;
     5313
     5314    case DEMANGLE_COMPONENT_CONVERSION:
    38515315      d_append_string (dpi, "operator ");
    3852       d_print_cast (dpi, dc);
     5316      d_print_conversion (dpi, options, dc);
     5317      return;
     5318
     5319    case DEMANGLE_COMPONENT_NULLARY:
     5320      d_print_expr_op (dpi, options, d_left (dc));
    38535321      return;
    38545322
    38555323    case DEMANGLE_COMPONENT_UNARY:
    3856       if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
    3857         d_print_expr_op (dpi, d_left (dc));
    3858       else
    3859         {
    3860           d_append_char (dpi, '(');
    3861           d_print_cast (dpi, d_left (dc));
    3862           d_append_char (dpi, ')');
    3863         }
    3864       d_print_subexpr (dpi, d_right (dc));
     5324      {
     5325        struct demangle_component *op = d_left (dc);
     5326        struct demangle_component *operand = d_right (dc);
     5327        const char *code = NULL;
     5328
     5329        if (op->type == DEMANGLE_COMPONENT_OPERATOR)
     5330          {
     5331            code = op->u.s_operator.op->code;
     5332            if (!strcmp (code, "ad"))
     5333              {
     5334                /* Don't print the argument list for the address of a
     5335                   function.  */
     5336                if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
     5337                    && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
     5338                    && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
     5339                  operand = d_left (operand);
     5340              }
     5341            if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
     5342              {
     5343                /* This indicates a suffix operator.  */
     5344                operand = d_left (operand);
     5345                d_print_subexpr (dpi, options, operand);
     5346                d_print_expr_op (dpi, options, op);
     5347                return;
     5348              }
     5349          }
     5350
     5351        /* For sizeof..., just print the pack length.  */
     5352        if (code && !strcmp (code, "sZ"))
     5353          {
     5354            struct demangle_component *a = d_find_pack (dpi, operand);
     5355            int len = d_pack_length (a);
     5356            d_append_num (dpi, len);
     5357            return;
     5358          }
     5359        else if (code && !strcmp (code, "sP"))
     5360          {
     5361            int len = d_args_length (dpi, operand);
     5362            d_append_num (dpi, len);
     5363            return;
     5364          }
     5365
     5366        if (op->type != DEMANGLE_COMPONENT_CAST)
     5367          d_print_expr_op (dpi, options, op);
     5368        else
     5369          {
     5370            d_append_char (dpi, '(');
     5371            d_print_cast (dpi, options, op);
     5372            d_append_char (dpi, ')');
     5373          }
     5374        if (code && !strcmp (code, "gs"))
     5375          /* Avoid parens after '::'.  */
     5376          d_print_comp (dpi, options, operand);
     5377        else if (code && !strcmp (code, "st"))
     5378          /* Always print parens for sizeof (type).  */
     5379          {
     5380            d_append_char (dpi, '(');
     5381            d_print_comp (dpi, options, operand);
     5382            d_append_char (dpi, ')');
     5383          }
     5384        else
     5385          d_print_subexpr (dpi, options, operand);
     5386      }
    38655387      return;
    38665388
     
    38715393          return;
    38725394        }
     5395
     5396      if (op_is_new_cast (d_left (dc)))
     5397        {
     5398          d_print_expr_op (dpi, options, d_left (dc));
     5399          d_append_char (dpi, '<');
     5400          d_print_comp (dpi, options, d_left (d_right (dc)));
     5401          d_append_string (dpi, ">(");
     5402          d_print_comp (dpi, options, d_right (d_right (dc)));
     5403          d_append_char (dpi, ')');
     5404          return;
     5405        }
     5406
     5407      if (d_maybe_print_fold_expression (dpi, options, dc))
     5408        return;
    38735409
    38745410      /* We wrap an expression which uses the greater-than operator in
     
    38805416        d_append_char (dpi, '(');
    38815417
    3882       d_print_subexpr (dpi, d_left (d_right (dc)));
    3883       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
    3884         d_print_expr_op (dpi, d_left (dc));
    3885       d_print_subexpr (dpi, d_right (d_right (dc)));
     5418      if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
     5419          && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
     5420        {
     5421          /* Function call used in an expression should not have printed types
     5422             of the function arguments.  Values of the function arguments still
     5423             get printed below.  */
     5424
     5425          const struct demangle_component *func = d_left (d_right (dc));
     5426
     5427          if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
     5428            d_print_error (dpi);
     5429          d_print_subexpr (dpi, options, d_left (func));
     5430        }
     5431      else
     5432        d_print_subexpr (dpi, options, d_left (d_right (dc)));
     5433      if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
     5434        {
     5435          d_append_char (dpi, '[');
     5436          d_print_comp (dpi, options, d_right (d_right (dc)));
     5437          d_append_char (dpi, ']');
     5438        }
     5439      else
     5440        {
     5441          if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
     5442            d_print_expr_op (dpi, options, d_left (dc));
     5443          d_print_subexpr (dpi, options, d_right (d_right (dc)));
     5444        }
    38865445
    38875446      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
     
    39045463          return;
    39055464        }
    3906       d_print_subexpr (dpi, d_left (d_right (dc)));
    3907       d_print_expr_op (dpi, d_left (dc));
    3908       d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
    3909       d_append_string (dpi, " : ");
    3910       d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
     5465      if (d_maybe_print_fold_expression (dpi, options, dc))
     5466        return;
     5467      {
     5468        struct demangle_component *op = d_left (dc);
     5469        struct demangle_component *first = d_left (d_right (dc));
     5470        struct demangle_component *second = d_left (d_right (d_right (dc)));
     5471        struct demangle_component *third = d_right (d_right (d_right (dc)));
     5472
     5473        if (!strcmp (op->u.s_operator.op->code, "qu"))
     5474          {
     5475            d_print_subexpr (dpi, options, first);
     5476            d_print_expr_op (dpi, options, op);
     5477            d_print_subexpr (dpi, options, second);
     5478            d_append_string (dpi, " : ");
     5479            d_print_subexpr (dpi, options, third);
     5480          }
     5481        else
     5482          {
     5483            d_append_string (dpi, "new ");
     5484            if (d_left (first) != NULL)
     5485              {
     5486                d_print_subexpr (dpi, options, first);
     5487                d_append_char (dpi, ' ');
     5488              }
     5489            d_print_comp (dpi, options, second);
     5490            if (third)
     5491              d_print_subexpr (dpi, options, third);
     5492          }
     5493      }
    39115494      return;
    39125495
     
    39395522                    if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
    39405523                      d_append_char (dpi, '-');
    3941                     d_print_comp (dpi, d_right (dc));
     5524                    d_print_comp (dpi, options, d_right (dc));
    39425525                    switch (tp)
    39435526                      {
     
    39895572
    39905573        d_append_char (dpi, '(');
    3991         d_print_comp (dpi, d_left (dc));
     5574        d_print_comp (dpi, options, d_left (dc));
    39925575        d_append_char (dpi, ')');
    39935576        if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
     
    39955578        if (tp == D_PRINT_FLOAT)
    39965579          d_append_char (dpi, '[');
    3997         d_print_comp (dpi, d_right (dc));
     5580        d_print_comp (dpi, options, d_right (dc));
    39985581        if (tp == D_PRINT_FLOAT)
    39995582          d_append_char (dpi, ']');
     
    40015584      return;
    40025585
     5586    case DEMANGLE_COMPONENT_NUMBER:
     5587      d_append_num (dpi, dc->u.s_number.number);
     5588      return;
     5589
    40035590    case DEMANGLE_COMPONENT_JAVA_RESOURCE:
    40045591      d_append_string (dpi, "java resource ");
    4005       d_print_comp (dpi, d_left (dc));
     5592      d_print_comp (dpi, options, d_left (dc));
    40065593      return;
    40075594
    40085595    case DEMANGLE_COMPONENT_COMPOUND_NAME:
    4009       d_print_comp (dpi, d_left (dc));
    4010       d_print_comp (dpi, d_right (dc));
     5596      d_print_comp (dpi, options, d_left (dc));
     5597      d_print_comp (dpi, options, d_right (dc));
    40115598      return;
    40125599
     
    40175604    case DEMANGLE_COMPONENT_DECLTYPE:
    40185605      d_append_string (dpi, "decltype (");
    4019       d_print_comp (dpi, d_left (dc));
     5606      d_print_comp (dpi, options, d_left (dc));
    40205607      d_append_char (dpi, ')');
    40215608      return;
     
    40315618               in this expansion are function parameter packs; in that
    40325619               case, just print the pattern and "...".  */
    4033             d_print_subexpr (dpi, d_left (dc));
     5620            d_print_subexpr (dpi, options, d_left (dc));
    40345621            d_append_string (dpi, "...");
    40355622            return;
     
    40415628          {
    40425629            dpi->pack_index = i;
    4043             d_print_comp (dpi, dc);
     5630            d_print_comp (dpi, options, dc);
    40445631            if (i < len-1)
    40455632              d_append_string (dpi, ", ");
     
    40505637    case DEMANGLE_COMPONENT_FUNCTION_PARAM:
    40515638      {
    4052         char buf[25];
    4053         d_append_string (dpi, "parm#");
    4054         sprintf(buf,"%ld", dc->u.s_number.number);
    4055         d_append_string (dpi, buf);
    4056         return;
     5639        long num = dc->u.s_number.number;
     5640        if (num == 0)
     5641          d_append_string (dpi, "this");
     5642        else
     5643          {
     5644            d_append_string (dpi, "{parm#");
     5645            d_append_num (dpi, num);
     5646            d_append_char (dpi, '}');
     5647          }
    40575648      }
     5649      return;
    40585650
    40595651    case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
    40605652      d_append_string (dpi, "global constructors keyed to ");
    4061       d_print_comp (dpi, dc->u.s_binary.left);
     5653      d_print_comp (dpi, options, dc->u.s_binary.left);
    40625654      return;
    40635655
    40645656    case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
    40655657      d_append_string (dpi, "global destructors keyed to ");
    4066       d_print_comp (dpi, dc->u.s_binary.left);
     5658      d_print_comp (dpi, options, dc->u.s_binary.left);
     5659      return;
     5660
     5661    case DEMANGLE_COMPONENT_LAMBDA:
     5662      d_append_string (dpi, "{lambda(");
     5663      /* Generic lambda auto parms are mangled as the template type
     5664         parm they are.  */
     5665      dpi->is_lambda_arg++;
     5666      d_print_comp (dpi, options, dc->u.s_unary_num.sub);
     5667      dpi->is_lambda_arg--;
     5668      d_append_string (dpi, ")#");
     5669      d_append_num (dpi, dc->u.s_unary_num.num + 1);
     5670      d_append_char (dpi, '}');
     5671      return;
     5672
     5673    case DEMANGLE_COMPONENT_UNNAMED_TYPE:
     5674      d_append_string (dpi, "{unnamed type#");
     5675      d_append_num (dpi, dc->u.s_number.number + 1);
     5676      d_append_char (dpi, '}');
     5677      return;
     5678
     5679    case DEMANGLE_COMPONENT_CLONE:
     5680      d_print_comp (dpi, options, d_left (dc));
     5681      d_append_string (dpi, " [clone ");
     5682      d_print_comp (dpi, options, d_right (dc));
     5683      d_append_char (dpi, ']');
    40675684      return;
    40685685
     
    40715688      return;
    40725689    }
     5690}
     5691
     5692static void
     5693d_print_comp (struct d_print_info *dpi, int options,
     5694              struct demangle_component *dc)
     5695{
     5696  struct d_component_stack self;
     5697  if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
     5698    {
     5699      d_print_error (dpi);
     5700      return;
     5701    }
     5702
     5703  dc->d_printing++;
     5704  dpi->recursion++;
     5705
     5706  self.dc = dc;
     5707  self.parent = dpi->component_stack;
     5708  dpi->component_stack = &self;
     5709
     5710  d_print_comp_inner (dpi, options, dc);
     5711
     5712  dpi->component_stack = self.parent;
     5713  dc->d_printing--;
     5714  dpi->recursion--;
    40735715}
    40745716
     
    41295771
    41305772static void
    4131 d_print_mod_list (struct d_print_info *dpi,
     5773d_print_mod_list (struct d_print_info *dpi, int options,
    41325774                  struct d_print_mod *mods, int suffix)
    41335775{
     
    41395781  if (mods->printed
    41405782      || (! suffix
    4141           && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
    4142               || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
    4143               || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
    4144     {
    4145       d_print_mod_list (dpi, mods->next, suffix);
     5783          && (is_fnqual_component_type (mods->mod->type))))
     5784    {
     5785      d_print_mod_list (dpi, options, mods->next, suffix);
    41465786      return;
    41475787    }
     
    41545794  if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
    41555795    {
    4156       d_print_function_type (dpi, mods->mod, mods->next);
     5796      d_print_function_type (dpi, options, mods->mod, mods->next);
    41575797      dpi->templates = hold_dpt;
    41585798      return;
     
    41605800  else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
    41615801    {
    4162       d_print_array_type (dpi, mods->mod, mods->next);
     5802      d_print_array_type (dpi, options, mods->mod, mods->next);
    41635803      dpi->templates = hold_dpt;
    41645804      return;
     
    41765816      hold_modifiers = dpi->modifiers;
    41775817      dpi->modifiers = NULL;
    4178       d_print_comp (dpi, d_left (mods->mod));
     5818      d_print_comp (dpi, options, d_left (mods->mod));
    41795819      dpi->modifiers = hold_modifiers;
    41805820
    4181       if ((dpi->options & DMGL_JAVA) == 0)
     5821      if ((options & DMGL_JAVA) == 0)
    41825822        d_append_string (dpi, "::");
    41835823      else
     
    41855825
    41865826      dc = d_right (mods->mod);
    4187       while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
    4188              || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
    4189              || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
     5827
     5828      if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
     5829        {
     5830          d_append_string (dpi, "{default arg#");
     5831          d_append_num (dpi, dc->u.s_unary_num.num + 1);
     5832          d_append_string (dpi, "}::");
     5833          dc = dc->u.s_unary_num.sub;
     5834        }
     5835
     5836      while (is_fnqual_component_type (dc->type))
    41905837        dc = d_left (dc);
    41915838
    4192       d_print_comp (dpi, dc);
     5839      d_print_comp (dpi, options, dc);
    41935840
    41945841      dpi->templates = hold_dpt;
     
    41965843    }
    41975844
    4198   d_print_mod (dpi, mods->mod);
     5845  d_print_mod (dpi, options, mods->mod);
    41995846
    42005847  dpi->templates = hold_dpt;
    42015848
    4202   d_print_mod_list (dpi, mods->next, suffix);
     5849  d_print_mod_list (dpi, options, mods->next, suffix);
    42035850}
    42045851
     
    42065853
    42075854static void
    4208 d_print_mod (struct d_print_info *dpi,
    4209              const struct demangle_component *mod)
     5855d_print_mod (struct d_print_info *dpi, int options,
     5856             struct demangle_component *mod)
    42105857{
    42115858  switch (mod->type)
     
    42235870      d_append_string (dpi, " const");
    42245871      return;
     5872    case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
     5873      d_append_string (dpi, " transaction_safe");
     5874      return;
     5875    case DEMANGLE_COMPONENT_NOEXCEPT:
     5876      d_append_string (dpi, " noexcept");
     5877      if (d_right (mod))
     5878        {
     5879          d_append_char (dpi, '(');
     5880          d_print_comp (dpi, options, d_right (mod));
     5881          d_append_char (dpi, ')');
     5882        }
     5883      return;
     5884    case DEMANGLE_COMPONENT_THROW_SPEC:
     5885      d_append_string (dpi, " throw");
     5886      if (d_right (mod))
     5887        {
     5888          d_append_char (dpi, '(');
     5889          d_print_comp (dpi, options, d_right (mod));
     5890          d_append_char (dpi, ')');
     5891        }
     5892      return;
    42255893    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
    42265894      d_append_char (dpi, ' ');
    4227       d_print_comp (dpi, d_right (mod));
     5895      d_print_comp (dpi, options, d_right (mod));
    42285896      return;
    42295897    case DEMANGLE_COMPONENT_POINTER:
    42305898      /* There is no pointer symbol in Java.  */
    4231       if ((dpi->options & DMGL_JAVA) == 0)
     5899      if ((options & DMGL_JAVA) == 0)
    42325900        d_append_char (dpi, '*');
    42335901      return;
     5902    case DEMANGLE_COMPONENT_REFERENCE_THIS:
     5903      /* For the ref-qualifier, put a space before the &.  */
     5904      d_append_char (dpi, ' ');
     5905      /* FALLTHRU */
    42345906    case DEMANGLE_COMPONENT_REFERENCE:
    42355907      d_append_char (dpi, '&');
    42365908      return;
     5909    case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
     5910      d_append_char (dpi, ' ');
     5911      /* FALLTHRU */
    42375912    case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
    42385913      d_append_string (dpi, "&&");
     
    42475922      if (d_last_char (dpi) != '(')
    42485923        d_append_char (dpi, ' ');
    4249       d_print_comp (dpi, d_left (mod));
     5924      d_print_comp (dpi, options, d_left (mod));
    42505925      d_append_string (dpi, "::*");
    42515926      return;
    42525927    case DEMANGLE_COMPONENT_TYPED_NAME:
    4253       d_print_comp (dpi, d_left (mod));
    4254       return;
     5928      d_print_comp (dpi, options, d_left (mod));
     5929      return;
     5930    case DEMANGLE_COMPONENT_VECTOR_TYPE:
     5931      d_append_string (dpi, " __vector(");
     5932      d_print_comp (dpi, options, d_left (mod));
     5933      d_append_char (dpi, ')');
     5934      return;
     5935
    42555936    default:
    42565937      /* Otherwise, we have something that won't go back on the
    42575938         modifier stack, so we can just print it.  */
    4258       d_print_comp (dpi, mod);
     5939      d_print_comp (dpi, options, mod);
    42595940      return;
    42605941    }
     
    42645945
    42655946static void
    4266 d_print_function_type (struct d_print_info *dpi,
    4267                        const struct demangle_component *dc,
     5947d_print_function_type (struct d_print_info *dpi, int options,
     5948                       struct demangle_component *dc,
    42685949                       struct d_print_mod *mods)
    42695950{
    42705951  int need_paren;
    4271   int saw_mod;
    42725952  int need_space;
    42735953  struct d_print_mod *p;
     
    42755955
    42765956  need_paren = 0;
    4277   saw_mod = 0;
    42785957  need_space = 0;
    42795958  for (p = mods; p != NULL; p = p->next)
     
    42825961        break;
    42835962
    4284       saw_mod = 1;
    42855963      switch (p->mod->type)
    42865964        {
     
    43005978          need_paren = 1;
    43015979          break;
    4302         case DEMANGLE_COMPONENT_RESTRICT_THIS:
    4303         case DEMANGLE_COMPONENT_VOLATILE_THIS:
    4304         case DEMANGLE_COMPONENT_CONST_THIS:
     5980        FNQUAL_COMPONENT_CASE:
    43055981          break;
    43065982        default:
     
    43105986        break;
    43115987    }
    4312 
    4313   if (d_left (dc) != NULL && ! saw_mod)
    4314     need_paren = 1;
    43155988
    43165989  if (need_paren)
     
    43306003  dpi->modifiers = NULL;
    43316004
    4332   d_print_mod_list (dpi, mods, 0);
     6005  d_print_mod_list (dpi, options, mods, 0);
    43336006
    43346007  if (need_paren)
     
    43386011
    43396012  if (d_right (dc) != NULL)
    4340     d_print_comp (dpi, d_right (dc));
     6013    d_print_comp (dpi, options, d_right (dc));
    43416014
    43426015  d_append_char (dpi, ')');
    43436016
    4344   d_print_mod_list (dpi, mods, 1);
     6017  d_print_mod_list (dpi, options, mods, 1);
    43456018
    43466019  dpi->modifiers = hold_modifiers;
     
    43506023
    43516024static void
    4352 d_print_array_type (struct d_print_info *dpi,
    4353                     const struct demangle_component *dc,
     6025d_print_array_type (struct d_print_info *dpi, int options,
     6026                    struct demangle_component *dc,
    43546027                    struct d_print_mod *mods)
    43556028{
     
    43846057        d_append_string (dpi, " (");
    43856058
    4386       d_print_mod_list (dpi, mods, 0);
     6059      d_print_mod_list (dpi, options, mods, 0);
    43876060
    43886061      if (need_paren)
     
    43966069
    43976070  if (d_left (dc) != NULL)
    4398     d_print_comp (dpi, d_left (dc));
     6071    d_print_comp (dpi, options, d_left (dc));
    43996072
    44006073  d_append_char (dpi, ']');
     
    44046077
    44056078static void
    4406 d_print_expr_op (struct d_print_info *dpi,
    4407                  const struct demangle_component *dc)
     6079d_print_expr_op (struct d_print_info *dpi, int options,
     6080                 struct demangle_component *dc)
    44086081{
    44096082  if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
     
    44116084                     dc->u.s_operator.op->len);
    44126085  else
    4413     d_print_comp (dpi, dc);
     6086    d_print_comp (dpi, options, dc);
    44146087}
    44156088
     
    44176090
    44186091static void
    4419 d_print_cast (struct d_print_info *dpi,
    4420               const struct demangle_component *dc)
    4421 {
    4422   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
    4423     d_print_comp (dpi, d_left (dc));
    4424   else
    4425     {
    4426       struct d_print_mod *hold_dpm;
    4427       struct d_print_template dpt;
    4428 
    4429       /* It appears that for a templated cast operator, we need to put
    4430          the template parameters in scope for the operator name, but
    4431          not for the parameters.  The effect is that we need to handle
    4432          the template printing here.  */
    4433 
    4434       hold_dpm = dpi->modifiers;
    4435       dpi->modifiers = NULL;
    4436 
     6092d_print_cast (struct d_print_info *dpi, int options,
     6093              struct demangle_component *dc)
     6094{
     6095  d_print_comp (dpi, options, d_left (dc));
     6096}
     6097
     6098/* Print a conversion operator.  */
     6099
     6100static void
     6101d_print_conversion (struct d_print_info *dpi, int options,
     6102                    struct demangle_component *dc)
     6103{
     6104  struct d_print_template dpt;
     6105
     6106  /* For a conversion operator, we need the template parameters from
     6107     the enclosing template in scope for processing the type.  */
     6108  if (dpi->current_template != NULL)
     6109    {
    44376110      dpt.next = dpi->templates;
    44386111      dpi->templates = &dpt;
    4439       dpt.template_decl = d_left (dc);
    4440 
    4441       d_print_comp (dpi, d_left (d_left (dc)));
    4442 
    4443       dpi->templates = dpt.next;
     6112      dpt.template_decl = dpi->current_template;
     6113    }
     6114
     6115  if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
     6116    {
     6117      d_print_comp (dpi, options, d_left (dc));
     6118      if (dpi->current_template != NULL)
     6119        dpi->templates = dpt.next;
     6120    }
     6121  else
     6122    {
     6123      d_print_comp (dpi, options, d_left (d_left (dc)));
     6124
     6125      /* For a templated cast operator, we need to remove the template
     6126         parameters from scope after printing the operator name,
     6127         so we need to handle the template printing here.  */
     6128      if (dpi->current_template != NULL)
     6129        dpi->templates = dpt.next;
    44446130
    44456131      if (d_last_char (dpi) == '<')
    44466132        d_append_char (dpi, ' ');
    44476133      d_append_char (dpi, '<');
    4448       d_print_comp (dpi, d_right (d_left (dc)));
     6134      d_print_comp (dpi, options, d_right (d_left (dc)));
    44496135      /* Avoid generating two consecutive '>' characters, to avoid
    44506136         the C++ syntactic ambiguity.  */
     
    44526138        d_append_char (dpi, ' ');
    44536139      d_append_char (dpi, '>');
    4454 
    4455       dpi->modifiers = hold_dpm;
    44566140    }
    44576141}
     
    44816165  di->num_subs = len;
    44826166  di->next_sub = 0;
    4483   di->did_subs = 0;
    44846167
    44856168  di->last_name = NULL;
    44866169
    44876170  di->expansion = 0;
     6171  di->is_expression = 0;
     6172  di->is_conversion = 0;
    44886173}
    44896174
     
    45066191  type;
    45076192  struct d_info di;
    4508   struct demangle_component *dc = NULL;
     6193  struct demangle_component *dc;
    45096194  int status;
    45106195
     
    45526237                           ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
    45536238                           : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
    4554                           d_make_name (&di, d_str (&di), strlen (d_str (&di))),
     6239                          d_make_demangle_mangled_name (&di, d_str (&di)),
    45556240                          NULL);
    45566241        d_advance (&di, strlen (d_str (&di)));
    45576242        break;
     6243      default:
     6244        abort (); /* We have listed all the cases.  */
    45586245      }
    45596246
     
    46016288    }
    46026289
    4603   *palc = dgs.allocation_failure ? 1 : 0;
     6290  *palc = dgs.allocation_failure ? 1 : dgs.alc;
    46046291  return dgs.buf;
    46056292}
     
    48266513        switch (dc->type)
    48276514          {
     6515            /* These cannot appear on a constructor or destructor.  */
     6516          case DEMANGLE_COMPONENT_RESTRICT_THIS:
     6517          case DEMANGLE_COMPONENT_VOLATILE_THIS:
     6518          case DEMANGLE_COMPONENT_CONST_THIS:
     6519          case DEMANGLE_COMPONENT_REFERENCE_THIS:
     6520          case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
    48286521          default:
    48296522            dc = NULL;
     
    48316524          case DEMANGLE_COMPONENT_TYPED_NAME:
    48326525          case DEMANGLE_COMPONENT_TEMPLATE:
    4833           case DEMANGLE_COMPONENT_RESTRICT_THIS:
    4834           case DEMANGLE_COMPONENT_VOLATILE_THIS:
    4835           case DEMANGLE_COMPONENT_CONST_THIS:
    48366526            dc = d_left (dc);
    48376527            break;
  • rtemstoolkit/libiberty/cp-demangle.h

    r0ea1c27 r78bbe4c  
    11/* Internal demangler interface for g++ V3 ABI.
    2    Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
     2   Copyright (C) 2003-2017 Free Software Foundation, Inc.
    33   Written by Ian Lance Taylor <ian@wasabisystems.com>.
    44
     
    112112  /* The number of available entries in the subs array.  */
    113113  int num_subs;
    114   /* The number of substitutions which we actually made from the subs
    115      array, plus the number of template parameter references we
    116      saw.  */
    117   int did_subs;
    118114  /* The last name we saw, for constructors and destructors.  */
    119115  struct demangle_component *last_name;
     
    122118     substitutions and builtin types.  */
    123119  int expansion;
     120  /* Non-zero if we are parsing an expression.  */
     121  int is_expression;
     122  /* Non-zero if we are parsing the type operand of a conversion
     123     operator, but not when in an expression.  */
     124  int is_conversion;
    124125};
    125126
     
    130131   Everything else is safe.  */
    131132#define d_peek_char(di) (*((di)->n))
    132 #define d_peek_next_char(di) ((di)->n[1])
    133 #define d_advance(di, i) ((di)->n += (i))
     133#ifndef CHECK_DEMANGLER
     134#  define d_peek_next_char(di) ((di)->n[1])
     135#  define d_advance(di, i) ((di)->n += (i))
     136#endif
    134137#define d_check_char(di, c) (d_peek_char(di) == c ? ((di)->n++, 1) : 0)
    135138#define d_next_char(di) (d_peek_char(di) == '\0' ? '\0' : *((di)->n++))
    136139#define d_str(di) ((di)->n)
     140
     141#ifdef CHECK_DEMANGLER
     142static inline char
     143d_peek_next_char (const struct d_info *di)
     144{
     145  if (!di->n[0])
     146    abort ();
     147  return di->n[1];
     148}
     149
     150static inline void
     151d_advance (struct d_info *di, int i)
     152{
     153  if (i < 0)
     154    abort ();
     155  while (i--)
     156    {
     157      if (!di->n[0])
     158        abort ();
     159      di->n++;
     160    }
     161}
     162#endif
    137163
    138164/* Functions and arrays in cp-demangle.c which are referenced by
     
    148174#endif
    149175
    150 #define D_BUILTIN_TYPE_COUNT (32)
     176#define D_BUILTIN_TYPE_COUNT (33)
    151177
    152178CP_STATIC_IF_GLIBCPP_V3
  • rtemstoolkit/libiberty/cplus-dem.c

    r0ea1c27 r78bbe4c  
    11/* Demangler for GNU C++
    2    Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
    3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
     2   Copyright (C) 1989-2017 Free Software Foundation, Inc.
    43   Written by James Clark (jjc@jclark.uucp)
    54   Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
     
    5756#endif
    5857
     58#ifdef HAVE_LIMITS_H
     59#include <limits.h>
     60#endif
     61#ifndef INT_MAX
     62# define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */
     63#endif
     64
    5965#include <demangle.h>
    6066#undef CURRENT_DEMANGLING_STYLE
     
    6268
    6369#include "libiberty.h"
    64 
    65 static char *ada_demangle (const char *, int);
    6670
    6771#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
     
    140144  int nrepeats;         /* The number of times to repeat the previous
    141145                           argument.  */
     146  int *proctypevec;     /* Indices of currently processed remembered typevecs.  */
     147  int proctypevec_size;
     148  int nproctypes;
    142149};
    143150
     
    240247  tk_pointer,
    241248  tk_reference,
     249  tk_rvalue_reference,
    242250  tk_integral,
    243251  tk_bool,
     
    309317  ,
    310318  {
     319    DLANG_DEMANGLING_STYLE_STRING,
     320    dlang_demangling,
     321    "DLANG style demangling"
     322  }
     323  ,
     324  {
     325    RUST_DEMANGLING_STYLE_STRING,
     326    rust_demangling,
     327    "Rust style demangling"
     328  }
     329  ,
     330  {
    311331    NULL, unknown_demangling, NULL
    312332  }
     
    425445static void remember_type (struct work_stuff *, const char *, int);
    426446
     447static void push_processed_type (struct work_stuff *, int);
     448
     449static void pop_processed_type (struct work_stuff *);
     450
    427451static void remember_Btype (struct work_stuff *, const char *, int, int);
    428452
     
    479503recursively_demangle (struct work_stuff *, const char **, string *, int);
    480504
    481 static void grow_vect (char **, size_t *, size_t, int);
    482 
    483505/* Translate count to integer, consuming tokens in the process.
    484506   Conversion terminates on the first non-digit character.
     
    499521  while (ISDIGIT ((unsigned char)**type))
    500522    {
    501       count *= 10;
    502 
    503       /* Check for overflow.
    504          We assume that count is represented using two's-complement;
    505          no power of two is divisible by ten, so if an overflow occurs
    506          when multiplying by ten, the result will not be a multiple of
    507          ten.  */
    508       if ((count % 10) != 0)
     523      const int digit = **type - '0';
     524      /* Check for overflow.  */
     525      if (count > ((INT_MAX - digit) / 10))
    509526        {
    510527          while (ISDIGIT ((unsigned char) **type))
     
    513530        }
    514531
    515       count += **type - '0';
     532      count *= 10;
     533      count += digit;
    516534      (*type)++;
    517535    }
     
    858876
    859877  /* The V3 ABI demangling is implemented elsewhere.  */
    860   if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
     878  if (GNU_V3_DEMANGLING || RUST_DEMANGLING || AUTO_DEMANGLING)
    861879    {
    862880      ret = cplus_demangle_v3 (mangled, work->options);
    863       if (ret || GNU_V3_DEMANGLING)
     881      if (GNU_V3_DEMANGLING)
     882        return ret;
     883
     884      if (ret)
     885        {
     886          /* Rust symbols are GNU_V3 mangled plus some extra subtitutions.
     887             The subtitutions are always smaller, so do in place changes.  */
     888          if (rust_is_mangled (ret))
     889            rust_demangle_sym (ret);
     890          else if (RUST_DEMANGLING)
     891            {
     892              free (ret);
     893              ret = NULL;
     894            }
     895        }
     896
     897      if (ret || RUST_DEMANGLING)
    864898        return ret;
    865899    }
     
    873907
    874908  if (GNAT_DEMANGLING)
    875     return ada_demangle(mangled,options);
     909    return ada_demangle (mangled, options);
     910
     911  if (DLANG_DEMANGLING)
     912    {
     913      ret = dlang_demangle (mangled, options);
     914      if (ret)
     915        return ret;
     916    }
    876917
    877918  ret = internal_cplus_demangle (work, mangled);
     
    880921}
    881922
    882 
    883 /* Assuming *OLD_VECT points to an array of *SIZE objects of size
    884    ELEMENT_SIZE, grow it to contain at least MIN_SIZE objects,
    885    updating *OLD_VECT and *SIZE as necessary.  */
    886 
    887 static void
    888 grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
    889 {
    890   if (*size < min_size)
    891     {
    892       *size *= 2;
    893       if (*size < min_size)
    894         *size = min_size;
    895       *old_vect = XRESIZEVAR (char, *old_vect, *size * element_size);
    896     }
    897 }
    898 
    899 /* Demangle ada names:
    900    1. Discard final __{DIGIT}+ or ${DIGIT}+
    901    2. Convert other instances of embedded "__" to `.'.
    902    3. Discard leading _ada_.
    903    4. Remove everything after first ___ if it is followed by 'X'.
    904    5. Put symbols that should be suppressed in <...> brackets.
    905    The resulting string is valid until the next call of ada_demangle.  */
    906 
    907 static char *
     923char *
     924rust_demangle (const char *mangled, int options)
     925{
     926  /* Rust symbols are GNU_V3 mangled plus some extra subtitutions.  */
     927  char *ret = cplus_demangle_v3 (mangled, options);
     928
     929  /* The Rust subtitutions are always smaller, so do in place changes.  */
     930  if (ret != NULL)
     931    {
     932      if (rust_is_mangled (ret))
     933        rust_demangle_sym (ret);
     934      else
     935        {
     936          free (ret);
     937          ret = NULL;
     938        }
     939    }
     940
     941  return ret;
     942}
     943
     944/* Demangle ada names.  The encoding is documented in gcc/ada/exp_dbug.ads.  */
     945
     946char *
    908947ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
    909948{
    910   int i, j;
    911949  int len0;
    912950  const char* p;
     951  char *d;
    913952  char *demangled = NULL;
    914   int changed;
    915   size_t demangled_size = 0;
    916953 
    917   changed = 0;
    918 
     954  /* Discard leading _ada_, which is used for library level subprograms.  */
    919955  if (strncmp (mangled, "_ada_", 5) == 0)
    920     {
    921       mangled += 5;
    922       changed = 1;
    923     }
     956    mangled += 5;
     957
     958  /* All ada unit names are lower-case.  */
     959  if (!ISLOWER (mangled[0]))
     960    goto unknown;
     961
     962  /* Most of the demangling will trivially remove chars.  Operator names
     963     may add one char but because they are always preceeded by '__' which is
     964     replaced by '.', they eventually never expand the size.
     965     A few special names such as '___elabs' add a few chars (at most 7), but
     966     they occur only once.  */
     967  len0 = strlen (mangled) + 7 + 1;
     968  demangled = XNEWVEC (char, len0);
    924969 
    925   if (mangled[0] == '_' || mangled[0] == '<')
    926     goto Suppress;
    927  
    928   p = strstr (mangled, "___");
    929   if (p == NULL)
    930     len0 = strlen (mangled);
    931   else
    932     {
    933       if (p[3] == 'X')
    934         {
    935           len0 = p - mangled;
    936           changed = 1;
    937         }
     970  d = demangled;
     971  p = mangled;
     972  while (1)
     973    {
     974      /* An entity names is expected.  */
     975      if (ISLOWER (*p))
     976        {
     977          /* An identifier, which is always lower case.  */
     978          do
     979            *d++ = *p++;
     980          while (ISLOWER(*p) || ISDIGIT (*p)
     981                 || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
     982        }
     983      else if (p[0] == 'O')
     984        {
     985          /* An operator name.  */
     986          static const char * const operators[][2] =
     987            {{"Oabs", "abs"},  {"Oand", "and"},    {"Omod", "mod"},
     988             {"Onot", "not"},  {"Oor", "or"},      {"Orem", "rem"},
     989             {"Oxor", "xor"},  {"Oeq", "="},       {"One", "/="},
     990             {"Olt", "<"},     {"Ole", "<="},      {"Ogt", ">"},
     991             {"Oge", ">="},    {"Oadd", "+"},      {"Osubtract", "-"},
     992             {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
     993             {"Oexpon", "**"}, {NULL, NULL}};
     994          int k;
     995
     996          for (k = 0; operators[k][0] != NULL; k++)
     997            {
     998              size_t slen = strlen (operators[k][0]);
     999              if (strncmp (p, operators[k][0], slen) == 0)
     1000                {
     1001                  p += slen;
     1002                  slen = strlen (operators[k][1]);
     1003                  *d++ = '"';
     1004                  memcpy (d, operators[k][1], slen);
     1005                  d += slen;
     1006                  *d++ = '"';
     1007                  break;
     1008                }
     1009            }
     1010          /* Operator not found.  */
     1011          if (operators[k][0] == NULL)
     1012            goto unknown;
     1013        }
    9381014      else
    939         goto Suppress;
    940     }
    941  
    942   /* Make demangled big enough for possible expansion by operator name.  */
    943   grow_vect (&demangled,
    944              &demangled_size,  2 * len0 + 1,
    945              sizeof (char));
    946  
    947   if (ISDIGIT ((unsigned char) mangled[len0 - 1])) {
    948     for (i = len0 - 2; i >= 0 && ISDIGIT ((unsigned char) mangled[i]); i -= 1)
    949       ;
    950     if (i > 1 && mangled[i] == '_' && mangled[i - 1] == '_')
    951       {
    952         len0 = i - 1;
    953         changed = 1;
    954       }
    955     else if (mangled[i] == '$')
    956       {
    957         len0 = i;
    958         changed = 1;
    959       }
    960   }
    961  
    962   for (i = 0, j = 0; i < len0 && ! ISALPHA ((unsigned char)mangled[i]);
    963        i += 1, j += 1)
    964     demangled[j] = mangled[i];
    965  
    966   while (i < len0)
    967     {
    968       if (i < len0 - 2 && mangled[i] == '_' && mangled[i + 1] == '_')
    969         {
    970           demangled[j] = '.';
    971           changed = 1;
    972           i += 2; j += 1;
    973         }
     1015        {
     1016          /* Not a GNAT encoding.  */
     1017          goto unknown;
     1018        }
     1019
     1020      /* The name can be directly followed by some uppercase letters.  */
     1021      if (p[0] == 'T' && p[1] == 'K')
     1022        {
     1023          /* Task stuff.  */
     1024          if (p[2] == 'B' && p[3] == 0)
     1025            {
     1026              /* Subprogram for task body.  */
     1027              break;
     1028            }
     1029          else if (p[2] == '_' && p[3] == '_')
     1030            {
     1031              /* Inner declarations in a task.  */
     1032              p += 4;
     1033              *d++ = '.';
     1034              continue;
     1035            }
     1036          else
     1037            goto unknown;
     1038        }
     1039      if (p[0] == 'E' && p[1] == 0)
     1040        {
     1041          /* Exception name.  */
     1042          goto unknown;
     1043        }
     1044      if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
     1045        {
     1046          /* Protected type subprogram.  */
     1047          break;
     1048        }
     1049      if ((*p == 'N' || *p == 'S') && p[1] == 0)
     1050        {
     1051          /* Enumerated type name table.  */
     1052          goto unknown;
     1053        }
     1054      if (p[0] == 'X')
     1055        {
     1056          /* Body nested.  */
     1057          p++;
     1058          while (p[0] == 'n' || p[0] == 'b')
     1059            p++;
     1060        }
     1061      if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
     1062        {
     1063          /* Stream operations.  */
     1064          const char *name;
     1065          switch (p[1])
     1066            {
     1067            case 'R':
     1068              name = "'Read";
     1069              break;
     1070            case 'W':
     1071              name = "'Write";
     1072              break;
     1073            case 'I':
     1074              name = "'Input";
     1075              break;
     1076            case 'O':
     1077              name = "'Output";
     1078              break;
     1079            default:
     1080              goto unknown;
     1081            }
     1082          p += 2;
     1083          strcpy (d, name);
     1084          d += strlen (name);
     1085        }
     1086      else if (p[0] == 'D')
     1087        {
     1088          /* Controlled type operation.  */
     1089          const char *name;
     1090          switch (p[1])
     1091            {
     1092            case 'F':
     1093              name = ".Finalize";
     1094              break;
     1095            case 'A':
     1096              name = ".Adjust";
     1097              break;
     1098            default:
     1099              goto unknown;
     1100            }
     1101          strcpy (d, name);
     1102          d += strlen (name);
     1103          break;
     1104        }
     1105
     1106      if (p[0] == '_')
     1107        {
     1108          /* Separator.  */
     1109          if (p[1] == '_')
     1110            {
     1111              /* Standard separator.  Handled first.  */
     1112              p += 2;
     1113
     1114              if (ISDIGIT (*p))
     1115                {
     1116                  /* Overloading number.  */
     1117                  do
     1118                    p++;
     1119                  while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
     1120                  if (*p == 'X')
     1121                    {
     1122                      p++;
     1123                      while (p[0] == 'n' || p[0] == 'b')
     1124                        p++;
     1125                    }
     1126                }
     1127              else if (p[0] == '_' && p[1] != '_')
     1128                {
     1129                  /* Special names.  */
     1130                  static const char * const special[][2] = {
     1131                    { "_elabb", "'Elab_Body" },
     1132                    { "_elabs", "'Elab_Spec" },
     1133                    { "_size", "'Size" },
     1134                    { "_alignment", "'Alignment" },
     1135                    { "_assign", ".\":=\"" },
     1136                    { NULL, NULL }
     1137                  };
     1138                  int k;
     1139
     1140                  for (k = 0; special[k][0] != NULL; k++)
     1141                    {
     1142                      size_t slen = strlen (special[k][0]);
     1143                      if (strncmp (p, special[k][0], slen) == 0)
     1144                        {
     1145                          p += slen;
     1146                          slen = strlen (special[k][1]);
     1147                          memcpy (d, special[k][1], slen);
     1148                          d += slen;
     1149                          break;
     1150                        }
     1151                    }
     1152                  if (special[k][0] != NULL)
     1153                    break;
     1154                  else
     1155                    goto unknown;
     1156                }
     1157              else
     1158                {
     1159                  *d++ = '.';
     1160                  continue;
     1161                }
     1162            }
     1163          else if (p[1] == 'B' || p[1] == 'E')
     1164            {
     1165              /* Entry Body or barrier Evaluation.  */
     1166              p += 2;
     1167              while (ISDIGIT (*p))
     1168                p++;
     1169              if (p[0] == 's' && p[1] == 0)
     1170                break;
     1171              else
     1172                goto unknown;
     1173            }
     1174          else
     1175            goto unknown;
     1176        }
     1177
     1178      if (p[0] == '.' && ISDIGIT (p[1]))
     1179        {
     1180          /* Nested subprogram.  */
     1181          p += 2;
     1182          while (ISDIGIT (*p))
     1183            p++;
     1184        }
     1185      if (*p == 0)
     1186        {
     1187          /* End of mangled name.  */
     1188          break;
     1189        }
    9741190      else
    975         {
    976           demangled[j] = mangled[i];
    977           i += 1;  j += 1;
    978         }
    979     }
    980   demangled[j] = '\000';
    981  
    982   for (i = 0; demangled[i] != '\0'; i += 1)
    983     if (ISUPPER ((unsigned char)demangled[i]) || demangled[i] == ' ')
    984       goto Suppress;
    985 
    986   if (! changed)
    987     {
    988       free (demangled);
    989       return NULL;
    990     }
    991   else
    992     return demangled;
    993  
    994  Suppress:
    995   grow_vect (&demangled,
    996              &demangled_size,  strlen (mangled) + 3,
    997              sizeof (char));
     1191        goto unknown;
     1192    }
     1193  *d = 0;
     1194  return demangled;
     1195
     1196 unknown:
     1197  XDELETEVEC (demangled);
     1198  len0 = strlen (mangled);
     1199  demangled = XNEWVEC (char, len0 + 3);
    9981200
    9991201  if (mangled[0] == '<')
     
    10411243        {
    10421244          success = gnu_special (work, &mangled, &decl);
     1245          if (!success)
     1246            {
     1247              delete_work_stuff (work);
     1248              string_delete (&decl);
     1249            }
    10431250        }
    10441251      if (!success)
     
    10841291    {
    10851292      free ((char *) work -> btypevec);
     1293      work->btypevec = NULL;
     1294      work->bsize = 0;
    10861295    }
    10871296  if (work -> ktypevec != NULL)
    10881297    {
    10891298      free ((char *) work -> ktypevec);
     1299      work->ktypevec = NULL;
     1300      work->ksize = 0;
    10901301    }
    10911302}
     
    11381349    }
    11391350
     1351  if (from->proctypevec)
     1352    to->proctypevec =
     1353      XDUPVEC (int, from->proctypevec, from->proctypevec_size);
     1354
    11401355  if (from->ntmpl_args)
    11411356    to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
     
    11661381
    11671382  forget_types (work);
    1168   if (work -> typevec != NULL)
    1169     {
    1170       free ((char *) work -> typevec);
    1171       work -> typevec = NULL;
    1172       work -> typevec_size = 0;
     1383  if (work->typevec != NULL)
     1384    {
     1385      free ((char *) work->typevec);
     1386      work->typevec = NULL;
     1387      work->typevec_size = 0;
     1388    }
     1389  if (work->proctypevec != NULL)
     1390    {
     1391      free (work->proctypevec);
     1392      work->proctypevec = NULL;
     1393      work->proctypevec_size = 0;
    11731394    }
    11741395  if (work->tmpl_argvec)
     
    11771398
    11781399      for (i = 0; i < work->ntmpl_args; i++)
    1179         if (work->tmpl_argvec[i])
    1180           free ((char*) work->tmpl_argvec[i]);
     1400        free ((char*) work->tmpl_argvec[i]);
    11811401
    11821402      free ((char*) work->tmpl_argvec);
     
    14731693              if (!(work->constructor & 1))
    14741694                expect_return_type = 1;
    1475               (*mangled)++;
     1695              if (!**mangled)
     1696                success = 0;
     1697              else
     1698                (*mangled)++;
    14761699              break;
    14771700            }
    1478           else
    1479             /* fall through */
    1480             {;}
     1701          /* fall through */
    14811702
    14821703        default:
     
    18802101  else if (tk == tk_real)
    18812102    success = demangle_real_value (work, mangled, s);
    1882   else if (tk == tk_pointer || tk == tk_reference)
     2103  else if (tk == tk_pointer || tk == tk_reference
     2104           || tk == tk_rvalue_reference)
    18832105    {
    18842106      if (**mangled == 'Q')
     
    18892111        {
    18902112          int symbol_len  = consume_count (mangled);
    1891           if (symbol_len == -1)
     2113          if (symbol_len == -1
     2114              || symbol_len > (long) strlen (*mangled))
    18922115            return -1;
    18932116          if (symbol_len == 0)
     
    19522175          int idx;
    19532176          (*mangled)++;
     2177          if (**mangled == '\0')
     2178            return (0);
    19542179          (*mangled)++;
    19552180
     
    27963021  const char *p;
    27973022
    2798   if ((*mangled)[0] == '_'
     3023  if ((*mangled)[0] == '_' && (*mangled)[1] != '\0'
    27993024      && strchr (cplus_markers, (*mangled)[1]) != NULL
    28003025      && (*mangled)[2] == '_')
     
    28103035                && (*mangled)[4] == '_')
    28113036               || ((*mangled)[1] == 'v'
    2812                    && (*mangled)[2] == 't'
     3037                   && (*mangled)[2] == 't' && (*mangled)[3] != '\0'
    28133038                   && strchr (cplus_markers, (*mangled)[3]) != NULL)))
    28143039    {
     
    28463071                      break;
    28473072                    }
     3073                  else if (n == -1)
     3074                    {
     3075                      success = 0;
     3076                      break;
     3077                    }
    28483078                }
    28493079              else
     
    29403170      if (delta == -1)
    29413171        success = 0;
     3172      else if (**mangled != '_')
     3173        success = 0;
    29423174      else
    29433175        {
     
    33853617{
    33863618  int n;
     3619  int i;
     3620  int is_proctypevec;
    33873621  int done;
    33883622  int success;
     
    33973631  done = 0;
    33983632  success = 1;
     3633  is_proctypevec = 0;
    33993634  while (success && !done)
    34003635    {
     
    34193654          if (tk == tk_none)
    34203655            tk = tk_reference;
     3656          break;
     3657
     3658          /* An rvalue reference type */
     3659        case 'O':
     3660          (*mangled)++;
     3661          string_prepend (&decl, "&&");
     3662          if (tk == tk_none)
     3663            tk = tk_rvalue_reference;
    34213664          break;
    34223665
     
    34443687        case 'T':
    34453688          (*mangled)++;
    3446           if (!get_count (mangled, &n) || n >= work -> ntypes)
     3689          if (!get_count (mangled, &n) || n < 0 || n >= work -> ntypes)
    34473690            {
    34483691              success = 0;
    34493692            }
    34503693          else
    3451             {
    3452               remembered_type = work -> typevec[n];
     3694            for (i = 0; i < work->nproctypes; i++)
     3695              if (work -> proctypevec [i] == n)
     3696                success = 0;
     3697
     3698          if (success)
     3699            {   
     3700              is_proctypevec = 1;
     3701              push_processed_type (work, n);
     3702              remembered_type = work->typevec[n];
    34533703              mangled = &remembered_type;
    34543704            }
     
    34783728
    34793729        case 'M':
    3480         case 'O':
    34813730          {
    34823731            type_quals = TYPE_UNQUALIFIED;
     
    35233772                  }
    35243773                else
    3525                   break;
     3774                  {
     3775                    string_delete (&temp);
     3776                    break;
     3777                  }
    35263778              }
    35273779            else if (**mangled == 'Q')
     
    35553807                  }
    35563808
    3557                 if (*(*mangled)++ != 'F')
     3809                if (*(*mangled) != 'F')
    35583810                  {
    35593811                    success = 0;
    35603812                    break;
    35613813                  }
     3814                (*mangled)++;
    35623815              }
    35633816            if ((member && !demangle_nested_args (work, mangled, &decl))
     
    36193872    case 'B':
    36203873      (*mangled)++;
    3621       if (!get_count (mangled, &n) || n >= work -> numb)
     3874      if (!get_count (mangled, &n) || n < 0 || n >= work -> numb)
    36223875        success = 0;
    36233876      else
     
    36693922    string_delete (result);
    36703923  string_delete (&decl);
     3924
     3925  if (is_proctypevec)
     3926    pop_processed_type (work);
    36713927
    36723928  if (success)
     
    38134069          break;
    38144070        }
     4071      /* fall through */
    38154072    case 'I':
    38164073      (*mangled)++;
     
    39604217  literal_len = consume_count (mangled);
    39614218
    3962   if (literal_len <= 0)
     4219  if (literal_len <= 0
     4220      || literal_len > (long) strlen (*mangled))
    39634221    return 0;
    39644222
     
    40824340
    40834341static void
     4342push_processed_type (struct work_stuff *work, int typevec_index)
     4343{
     4344  if (work->nproctypes >= work->proctypevec_size)
     4345    {
     4346      if (!work->proctypevec_size)
     4347        {
     4348  &n