libiberty/cp-demangle.c

   1 /* Demangler for g++ V3 ABI.
   2    Copyright (C) 2003-2019 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@wasabisystems.com>.
   4
   5    This file is part of the libiberty library, which is part of GCC.
   6
   7    This file is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    In addition to the permissions in the GNU General Public License, the
  13    Free Software Foundation gives you unlimited permission to link the
  14    compiled version of this file into combinations with other programs,
  15    and to distribute those combinations without any restriction coming
  16    from the use of this file.  (The General Public License restrictions
  17    do apply in other respects; for example, they cover modification of
  18    the file, and distribution when not linked into a combined
  19    executable.)
  20
  21    This program is distributed in the hope that it will be useful,
  22    but WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24    GNU General Public License for more details.
  25
  26    You should have received a copy of the GNU General Public License
  27    along with this program; if not, write to the Free Software
  28    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  29 */
  30
  31 /* This code implements a demangler for the g++ V3 ABI.  The ABI is
  32    described on this web page:
  33        https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
  34
  35    This code was written while looking at the demangler written by
  36    Alex Samuel <samuel@codesourcery.com>.
  37
  38    This code first pulls the mangled name apart into a list of
  39    components, and then walks the list generating the demangled
  40    name.
  41
  42    This file will normally define the following functions, q.v.:
  43       char *cplus_demangle_v3(const char *mangled, int options)
  44       char *java_demangle_v3(const char *mangled)
  45       int cplus_demangle_v3_callback(const char *mangled, int options,
  46                                      demangle_callbackref callback)
  47       int java_demangle_v3_callback(const char *mangled,
  48                                     demangle_callbackref callback)
  49       enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
  50       enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
  51
  52    Also, the interface to the component list is public, and defined in
  53    demangle.h.  The interface consists of these types, which are
  54    defined in demangle.h:
  55       enum demangle_component_type
  56       struct demangle_component
  57       demangle_callbackref
  58    and these functions defined in this file:
  59       cplus_demangle_fill_name
  60       cplus_demangle_fill_extended_operator
  61       cplus_demangle_fill_ctor
  62       cplus_demangle_fill_dtor
  63       cplus_demangle_print
  64       cplus_demangle_print_callback
  65    and other functions defined in the file cp-demint.c.
  66
  67    This file also defines some other functions and variables which are
  68    only to be used by the file cp-demint.c.
  69
  70    Preprocessor macros you can define while compiling this file:
  71
  72    IN_LIBGCC2
  73       If defined, this file defines the following functions, q.v.:
  74          char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
  75                                int *status)
  76          int __gcclibcxx_demangle_callback (const char *,
  77                                             void (*)
  78                                               (const char *, size_t, void *),
  79                                             void *)
  80       instead of cplus_demangle_v3[_callback]() and
  81       java_demangle_v3[_callback]().
  82
  83    IN_GLIBCPP_V3
  84       If defined, this file defines only __cxa_demangle() and
  85       __gcclibcxx_demangle_callback(), and no other publically visible
  86       functions or variables.
  87
  88    STANDALONE_DEMANGLER
  89       If defined, this file defines a main() function which demangles
  90       any arguments, or, if none, demangles stdin.
  91
  92    CP_DEMANGLE_DEBUG
  93       If defined, turns on debugging mode, which prints information on
  94       stdout about the mangled string.  This is not generally useful.
  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.  */
 100
 101 #if defined (_AIX) && !defined (__GNUC__)
 102  #pragma alloca
 103 #endif
 104
 105 #ifdef HAVE_CONFIG_H
 106 #include "config.h"
 107 #endif
 108
 109 #include <stdio.h>
 110
 111 #ifdef HAVE_STDLIB_H
 112 #include <stdlib.h>
 113 #endif
 114 #ifdef HAVE_STRING_H
 115 #include <string.h>
 116 #endif
 117
 118 #ifdef HAVE_ALLOCA_H
 119 # include <alloca.h>
 120 #else
 121 # ifndef alloca
 122 #  ifdef __GNUC__
 123 #   define alloca __builtin_alloca
 124 #  else
 125 extern char *alloca ();
 126 #  endif /* __GNUC__ */
 127 # endif /* alloca */
 128 #endif /* HAVE_ALLOCA_H */
 129
 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
 137 #include "ansidecl.h"
 138 #include "libiberty.h"
 139 #include "demangle.h"
 140 #include "cp-demangle.h"
 141
 142 /* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
 143    also rename them via #define to avoid compiler errors when the
 144    static definition conflicts with the extern declaration in a header
 145    file.  */
 146 #ifdef IN_GLIBCPP_V3
 147
 148 #define CP_STATIC_IF_GLIBCPP_V3 static
 149
 150 #define cplus_demangle_fill_name d_fill_name
 151 static int d_fill_name (struct demangle_component *, const char *, int);
 152
 153 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
 154 static int
 155 d_fill_extended_operator (struct demangle_component *, int,
 156                           struct demangle_component *);
 157
 158 #define cplus_demangle_fill_ctor d_fill_ctor
 159 static int
 160 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
 161              struct demangle_component *);
 162
 163 #define cplus_demangle_fill_dtor d_fill_dtor
 164 static int
 165 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
 166              struct demangle_component *);
 167
 168 #define cplus_demangle_mangled_name d_mangled_name
 169 static struct demangle_component *d_mangled_name (struct d_info *, int);
 170
 171 #define cplus_demangle_type d_type
 172 static struct demangle_component *d_type (struct d_info *);
 173
 174 #define cplus_demangle_print d_print
 175 static char *d_print (int, struct demangle_component *, int, size_t *);
 176
 177 #define cplus_demangle_print_callback d_print_callback
 178 static int d_print_callback (int, struct demangle_component *,
 179                              demangle_callbackref, void *);
 180
 181 #define cplus_demangle_init_info d_init_info
 182 static void d_init_info (const char *, int, size_t, struct d_info *);
 183
 184 #else /* ! defined(IN_GLIBCPP_V3) */
 185 #define CP_STATIC_IF_GLIBCPP_V3
 186 #endif /* ! defined(IN_GLIBCPP_V3) */
 187
 188 /* See if the compiler supports dynamic arrays.  */
 189
 190 #ifdef __GNUC__
 191 #define CP_DYNAMIC_ARRAYS
 192 #else
 193 #ifdef __STDC__
 194 #ifdef __STDC_VERSION__
 195 #if __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__
 196 #define CP_DYNAMIC_ARRAYS
 197 #endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */
 198 #endif /* defined (__STDC_VERSION__) */
 199 #endif /* defined (__STDC__) */
 200 #endif /* ! defined (__GNUC__) */
 201
 202 /* We avoid pulling in the ctype tables, to prevent pulling in
 203    additional unresolved symbols when this code is used in a library.
 204    FIXME: Is this really a valid reason?  This comes from the original
 205    V3 demangler code.
 206
 207    As of this writing this file has the following undefined references
 208    when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
 209    strcat, strlen.  */
 210
 211 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
 212 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
 213 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
 214
 215 /* The prefix prepended by GCC to an identifier represnting the
 216    anonymous namespace.  */
 217 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
 218 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
 219   (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
 220
 221 /* Information we keep for the standard substitutions.  */
 222
 223 struct d_standard_sub_info
 224 {
 225   /* The code for this substitution.  */
 226   char code;
 227   /* The simple string it expands to.  */
 228   const char *simple_expansion;
 229   /* The length of the simple expansion.  */
 230   int simple_len;
 231   /* The results of a full, verbose, expansion.  This is used when
 232      qualifying a constructor/destructor, or when in verbose mode.  */
 233   const char *full_expansion;
 234   /* The length of the full expansion.  */
 235   int full_len;
 236   /* What to set the last_name field of d_info to; NULL if we should
 237      not set it.  This is only relevant when qualifying a
 238      constructor/destructor.  */
 239   const char *set_last_name;
 240   /* The length of set_last_name.  */
 241   int set_last_name_len;
 242 };
 243
 244 /* Accessors for subtrees of struct demangle_component.  */
 245
 246 #define d_left(dc) ((dc)->u.s_binary.left)
 247 #define d_right(dc) ((dc)->u.s_binary.right)
 248
 249 /* A list of templates.  This is used while printing.  */
 250
 251 struct d_print_template
 252 {
 253   /* Next template on the list.  */
 254   struct d_print_template *next;
 255   /* This template.  */
 256   const struct demangle_component *template_decl;
 257 };
 258
 259 /* A list of type modifiers.  This is used while printing.  */
 260
 261 struct d_print_mod
 262 {
 263   /* Next modifier on the list.  These are in the reverse of the order
 264      in which they appeared in the mangled string.  */
 265   struct d_print_mod *next;
 266   /* The modifier.  */
 267   struct demangle_component *mod;
 268   /* Whether this modifier was printed.  */
 269   int printed;
 270   /* The list of templates which applies to this modifier.  */
 271   struct d_print_template *templates;
 272 };
 273
 274 /* We use these structures to hold information during printing.  */
 275
 276 struct d_growable_string
 277 {
 278   /* Buffer holding the result.  */
 279   char *buf;
 280   /* Current length of data in buffer.  */
 281   size_t len;
 282   /* Allocated size of buffer.  */
 283   size_t alc;
 284   /* Set to 1 if we had a memory allocation failure.  */
 285   int allocation_failure;
 286 };
 287
 288 /* Stack of components, innermost first, used to avoid loops.  */
 289
 290 struct 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
 301 struct 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
 314 struct 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
 325 enum { D_PRINT_BUFFER_LENGTH = 256 };
 326 struct d_print_info
 327 {
 328   /* Fixed-length allocated buffer for demangled data, flushed to the
 329      callback with a NUL termination once full.  */
 330   char buf[D_PRINT_BUFFER_LENGTH];
 331   /* Current length of data in buffer.  */
 332   size_t len;
 333   /* The last character printed, saved individually so that it survives
 334      any buffer flush.  */
 335   char last_char;
 336   /* Callback function to handle demangled buffer flush.  */
 337   demangle_callbackref callback;
 338   /* Opaque callback argument.  */
 339   void *opaque;
 340   /* The current list of templates, if any.  */
 341   struct d_print_template *templates;
 342   /* The current list of modifiers (e.g., pointer, reference, etc.),
 343      if any.  */
 344   struct d_print_mod *modifiers;
 345   /* Set to 1 if we saw a demangling error.  */
 346   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;
 353   /* The current index into any template argument packs we are using
 354      for printing, or -1 to print the whole pack.  */
 355   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;
 374 };
 375
 376 #ifdef CP_DEMANGLE_DEBUG
 377 static void d_dump (struct demangle_component *, int);
 378 #endif
 379
 380 static struct demangle_component *
 381 d_make_empty (struct d_info *);
 382
 383 static struct demangle_component *
 384 d_make_comp (struct d_info *, enum demangle_component_type,
 385              struct demangle_component *,
 386              struct demangle_component *);
 387
 388 static struct demangle_component *
 389 d_make_name (struct d_info *, const char *, int);
 390
 391 static struct demangle_component *
 392 d_make_demangle_mangled_name (struct d_info *, const char *);
 393
 394 static struct demangle_component *
 395 d_make_builtin_type (struct d_info *,
 396                      const struct demangle_builtin_type_info *);
 397
 398 static struct demangle_component *
 399 d_make_operator (struct d_info *,
 400                  const struct demangle_operator_info *);
 401
 402 static struct demangle_component *
 403 d_make_extended_operator (struct d_info *, int,
 404                           struct demangle_component *);
 405
 406 static struct demangle_component *
 407 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
 408              struct demangle_component *);
 409
 410 static struct demangle_component *
 411 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
 412              struct demangle_component *);
 413
 414 static struct demangle_component *
 415 d_make_template_param (struct d_info *, int);
 416
 417 static struct demangle_component *
 418 d_make_sub (struct d_info *, const char *, int);
 419
 420 static int
 421 has_return_type (struct demangle_component *);
 422
 423 static int
 424 is_ctor_dtor_or_conversion (struct demangle_component *);
 425
 426 static struct demangle_component *d_encoding (struct d_info *, int);
 427
 428 static struct demangle_component *d_name (struct d_info *);
 429
 430 static struct demangle_component *d_nested_name (struct d_info *);
 431
 432 static struct demangle_component *d_prefix (struct d_info *);
 433
 434 static struct demangle_component *d_unqualified_name (struct d_info *);
 435
 436 static struct demangle_component *d_source_name (struct d_info *);
 437
 438 static int d_number (struct d_info *);
 439
 440 static struct demangle_component *d_identifier (struct d_info *, int);
 441
 442 static struct demangle_component *d_operator_name (struct d_info *);
 443
 444 static struct demangle_component *d_special_name (struct d_info *);
 445
 446 static struct demangle_component *d_parmlist (struct d_info *);
 447
 448 static int d_call_offset (struct d_info *, int);
 449
 450 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
 451
 452 static struct demangle_component **
 453 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
 454
 455 static struct demangle_component *
 456 d_ref_qualifier (struct d_info *, struct demangle_component *);
 457
 458 static struct demangle_component *
 459 d_function_type (struct d_info *);
 460
 461 static struct demangle_component *
 462 d_bare_function_type (struct d_info *, int);
 463
 464 static struct demangle_component *
 465 d_class_enum_type (struct d_info *);
 466
 467 static struct demangle_component *d_array_type (struct d_info *);
 468
 469 static struct demangle_component *d_vector_type (struct d_info *);
 470
 471 static struct demangle_component *
 472 d_pointer_to_member_type (struct d_info *);
 473
 474 static struct demangle_component *
 475 d_template_param (struct d_info *);
 476
 477 static struct demangle_component *d_template_args (struct d_info *);
 478 static struct demangle_component *d_template_args_1 (struct d_info *);
 479
 480 static struct demangle_component *
 481 d_template_arg (struct d_info *);
 482
 483 static struct demangle_component *d_expression (struct d_info *);
 484
 485 static struct demangle_component *d_expr_primary (struct d_info *);
 486
 487 static struct demangle_component *d_local_name (struct d_info *);
 488
 489 static int d_discriminator (struct d_info *);
 490
 491 static struct demangle_component *d_lambda (struct d_info *);
 492
 493 static struct demangle_component *d_unnamed_type (struct d_info *);
 494
 495 static struct demangle_component *
 496 d_clone_suffix (struct d_info *, struct demangle_component *);
 497
 498 static int
 499 d_add_substitution (struct d_info *, struct demangle_component *);
 500
 501 static struct demangle_component *d_substitution (struct d_info *, int);
 502
 503 static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
 504
 505 static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
 506
 507 static void d_growable_string_init (struct d_growable_string *, size_t);
 508
 509 static inline void
 510 d_growable_string_resize (struct d_growable_string *, size_t);
 511
 512 static inline void
 513 d_growable_string_append_buffer (struct d_growable_string *,
 514                                  const char *, size_t);
 515 static void
 516 d_growable_string_callback_adapter (const char *, size_t, void *);
 517
 518 static void
 519 d_print_init (struct d_print_info *, demangle_callbackref, void *,
 520               const struct demangle_component *);
 521
 522 static inline void d_print_error (struct d_print_info *);
 523
 524 static inline int d_print_saw_error (struct d_print_info *);
 525
 526 static inline void d_print_flush (struct d_print_info *);
 527
 528 static inline void d_append_char (struct d_print_info *, char);
 529
 530 static inline void d_append_buffer (struct d_print_info *,
 531                                     const char *, size_t);
 532
 533 static inline void d_append_string (struct d_print_info *, const char *);
 534
 535 static inline char d_last_char (struct d_print_info *);
 536
 537 static void
 538 d_print_comp (struct d_print_info *, int, struct demangle_component *);
 539
 540 static void
 541 d_print_java_identifier (struct d_print_info *, const char *, int);
 542
 543 static void
 544 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
 545
 546 static void
 547 d_print_mod (struct d_print_info *, int, struct demangle_component *);
 548
 549 static void
 550 d_print_function_type (struct d_print_info *, int,
 551                        struct demangle_component *,
 552                        struct d_print_mod *);
 553
 554 static void
 555 d_print_array_type (struct d_print_info *, int,
 556                     struct demangle_component *,
 557                     struct d_print_mod *);
 558
 559 static void
 560 d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
 561
 562 static void d_print_cast (struct d_print_info *, int,
 563                           struct demangle_component *);
 564 static void d_print_conversion (struct d_print_info *, int,
 565                                 struct demangle_component *);
 566
 567 static int d_demangle_callback (const char *, int,
 568                                 demangle_callbackref, void *);
 569 static char *d_demangle (const char *, int, size_t *);
 570
 571 #define FNQUAL_COMPONENT_CASE                           \
 572     case DEMANGLE_COMPONENT_RESTRICT_THIS:              \
 573     case DEMANGLE_COMPONENT_VOLATILE_THIS:              \
 574     case DEMANGLE_COMPONENT_CONST_THIS:                 \
 575     case DEMANGLE_COMPONENT_REFERENCE_THIS:             \
 576     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:      \
 577     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:           \
 578     case DEMANGLE_COMPONENT_NOEXCEPT:                   \
 579     case DEMANGLE_COMPONENT_THROW_SPEC
 580
 581 /* True iff TYPE is a demangling component representing a
 582    function-type-qualifier.  */
 583
 584 static int
 585 is_fnqual_component_type (enum demangle_component_type type)
 586 {
 587   switch (type)
 588     {
 589     FNQUAL_COMPONENT_CASE:
 590       return 1;
 591     default:
 592       break;
 593     }
 594   return 0;
 595 }
 596
 597
 598 #ifdef CP_DEMANGLE_DEBUG
 599
 600 static void
 601 d_dump (struct demangle_component *dc, int indent)
 602 {
 603   int i;
 604
 605   if (dc == NULL)
 606     {
 607       if (indent == 0)
 608         printf ("failed demangling\n");
 609       return;
 610     }
 611
 612   for (i = 0; i < indent; ++i)
 613     putchar (' ');
 614
 615   switch (dc->type)
 616     {
 617     case DEMANGLE_COMPONENT_NAME:
 618       printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
 619       return;
 620     case DEMANGLE_COMPONENT_TAGGED_NAME:
 621       printf ("tagged name\n");
 622       d_dump (dc->u.s_binary.left, indent + 2);
 623       d_dump (dc->u.s_binary.right, indent + 2);
 624       return;
 625     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
 626       printf ("template parameter %ld\n", dc->u.s_number.number);
 627       return;
 628     case DEMANGLE_COMPONENT_TPARM_OBJ:
 629       printf ("template parameter object\n");
 630       break;
 631     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
 632       printf ("function parameter %ld\n", dc->u.s_number.number);
 633       return;
 634     case DEMANGLE_COMPONENT_CTOR:
 635       printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
 636       d_dump (dc->u.s_ctor.name, indent + 2);
 637       return;
 638     case DEMANGLE_COMPONENT_DTOR:
 639       printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
 640       d_dump (dc->u.s_dtor.name, indent + 2);
 641       return;
 642     case DEMANGLE_COMPONENT_SUB_STD:
 643       printf ("standard substitution %s\n", dc->u.s_string.string);
 644       return;
 645     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
 646       printf ("builtin type %s\n", dc->u.s_builtin.type->name);
 647       return;
 648     case DEMANGLE_COMPONENT_OPERATOR:
 649       printf ("operator %s\n", dc->u.s_operator.op->name);
 650       return;
 651     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 652       printf ("extended operator with %d args\n",
 653               dc->u.s_extended_operator.args);
 654       d_dump (dc->u.s_extended_operator.name, indent + 2);
 655       return;
 656
 657     case DEMANGLE_COMPONENT_QUAL_NAME:
 658       printf ("qualified name\n");
 659       break;
 660     case DEMANGLE_COMPONENT_LOCAL_NAME:
 661       printf ("local name\n");
 662       break;
 663     case DEMANGLE_COMPONENT_TYPED_NAME:
 664       printf ("typed name\n");
 665       break;
 666     case DEMANGLE_COMPONENT_TEMPLATE:
 667       printf ("template\n");
 668       break;
 669     case DEMANGLE_COMPONENT_VTABLE:
 670       printf ("vtable\n");
 671       break;
 672     case DEMANGLE_COMPONENT_VTT:
 673       printf ("VTT\n");
 674       break;
 675     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 676       printf ("construction vtable\n");
 677       break;
 678     case DEMANGLE_COMPONENT_TYPEINFO:
 679       printf ("typeinfo\n");
 680       break;
 681     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 682       printf ("typeinfo name\n");
 683       break;
 684     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 685       printf ("typeinfo function\n");
 686       break;
 687     case DEMANGLE_COMPONENT_THUNK:
 688       printf ("thunk\n");
 689       break;
 690     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 691       printf ("virtual thunk\n");
 692       break;
 693     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 694       printf ("covariant thunk\n");
 695       break;
 696     case DEMANGLE_COMPONENT_JAVA_CLASS:
 697       printf ("java class\n");
 698       break;
 699     case DEMANGLE_COMPONENT_GUARD:
 700       printf ("guard\n");
 701       break;
 702     case DEMANGLE_COMPONENT_REFTEMP:
 703       printf ("reference temporary\n");
 704       break;
 705     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 706       printf ("hidden alias\n");
 707       break;
 708     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
 709       printf ("transaction clone\n");
 710       break;
 711     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
 712       printf ("non-transaction clone\n");
 713       break;
 714     case DEMANGLE_COMPONENT_RESTRICT:
 715       printf ("restrict\n");
 716       break;
 717     case DEMANGLE_COMPONENT_VOLATILE:
 718       printf ("volatile\n");
 719       break;
 720     case DEMANGLE_COMPONENT_CONST:
 721       printf ("const\n");
 722       break;
 723     case DEMANGLE_COMPONENT_RESTRICT_THIS:
 724       printf ("restrict this\n");
 725       break;
 726     case DEMANGLE_COMPONENT_VOLATILE_THIS:
 727       printf ("volatile this\n");
 728       break;
 729     case DEMANGLE_COMPONENT_CONST_THIS:
 730       printf ("const this\n");
 731       break;
 732     case DEMANGLE_COMPONENT_REFERENCE_THIS:
 733       printf ("reference this\n");
 734       break;
 735     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
 736       printf ("rvalue reference this\n");
 737       break;
 738     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
 739       printf ("transaction_safe this\n");
 740       break;
 741     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 742       printf ("vendor type qualifier\n");
 743       break;
 744     case DEMANGLE_COMPONENT_POINTER:
 745       printf ("pointer\n");
 746       break;
 747     case DEMANGLE_COMPONENT_REFERENCE:
 748       printf ("reference\n");
 749       break;
 750     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 751       printf ("rvalue reference\n");
 752       break;
 753     case DEMANGLE_COMPONENT_COMPLEX:
 754       printf ("complex\n");
 755       break;
 756     case DEMANGLE_COMPONENT_IMAGINARY:
 757       printf ("imaginary\n");
 758       break;
 759     case DEMANGLE_COMPONENT_VENDOR_TYPE:
 760       printf ("vendor type\n");
 761       break;
 762     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 763       printf ("function type\n");
 764       break;
 765     case DEMANGLE_COMPONENT_ARRAY_TYPE:
 766       printf ("array type\n");
 767       break;
 768     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 769       printf ("pointer to member type\n");
 770       break;
 771     case DEMANGLE_COMPONENT_FIXED_TYPE:
 772       printf ("fixed-point type, accum? %d, sat? %d\n",
 773               dc->u.s_fixed.accum, dc->u.s_fixed.sat);
 774       d_dump (dc->u.s_fixed.length, indent + 2);
 775       break;
 776     case DEMANGLE_COMPONENT_ARGLIST:
 777       printf ("argument list\n");
 778       break;
 779     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 780       printf ("template argument list\n");
 781       break;
 782     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
 783       printf ("initializer list\n");
 784       break;
 785     case DEMANGLE_COMPONENT_CAST:
 786       printf ("cast\n");
 787       break;
 788     case DEMANGLE_COMPONENT_CONVERSION:
 789       printf ("conversion operator\n");
 790       break;
 791     case DEMANGLE_COMPONENT_NULLARY:
 792       printf ("nullary operator\n");
 793       break;
 794     case DEMANGLE_COMPONENT_UNARY:
 795       printf ("unary operator\n");
 796       break;
 797     case DEMANGLE_COMPONENT_BINARY:
 798       printf ("binary operator\n");
 799       break;
 800     case DEMANGLE_COMPONENT_BINARY_ARGS:
 801       printf ("binary operator arguments\n");
 802       break;
 803     case DEMANGLE_COMPONENT_TRINARY:
 804       printf ("trinary operator\n");
 805       break;
 806     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 807       printf ("trinary operator arguments 1\n");
 808       break;
 809     case DEMANGLE_COMPONENT_TRINARY_ARG2:
 810       printf ("trinary operator arguments 1\n");
 811       break;
 812     case DEMANGLE_COMPONENT_LITERAL:
 813       printf ("literal\n");
 814       break;
 815     case DEMANGLE_COMPONENT_LITERAL_NEG:
 816       printf ("negative literal\n");
 817       break;
 818     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
 819       printf ("java resource\n");
 820       break;
 821     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 822       printf ("compound name\n");
 823       break;
 824     case DEMANGLE_COMPONENT_CHARACTER:
 825       printf ("character '%c'\n",  dc->u.s_character.character);
 826       return;
 827     case DEMANGLE_COMPONENT_NUMBER:
 828       printf ("number %ld\n", dc->u.s_number.number);
 829       return;
 830     case DEMANGLE_COMPONENT_DECLTYPE:
 831       printf ("decltype\n");
 832       break;
 833     case DEMANGLE_COMPONENT_PACK_EXPANSION:
 834       printf ("pack expansion\n");
 835       break;
 836     case DEMANGLE_COMPONENT_TLS_INIT:
 837       printf ("tls init function\n");
 838       break;
 839     case DEMANGLE_COMPONENT_TLS_WRAPPER:
 840       printf ("tls wrapper function\n");
 841       break;
 842     case DEMANGLE_COMPONENT_DEFAULT_ARG:
 843       printf ("default argument %d\n", dc->u.s_unary_num.num);
 844       d_dump (dc->u.s_unary_num.sub, indent+2);
 845       return;
 846     case DEMANGLE_COMPONENT_LAMBDA:
 847       printf ("lambda %d\n", dc->u.s_unary_num.num);
 848       d_dump (dc->u.s_unary_num.sub, indent+2);
 849       return;
 850     }
 851
 852   d_dump (d_left (dc), indent + 2);
 853   d_dump (d_right (dc), indent + 2);
 854 }
 855
 856 #endif /* CP_DEMANGLE_DEBUG */
 857
 858 /* Fill in a DEMANGLE_COMPONENT_NAME.  */
 859
 860 CP_STATIC_IF_GLIBCPP_V3
 861 int
 862 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
 863 {
 864   if (p == NULL || s == NULL || len <= 0)
 865     return 0;
 866   p->d_printing = 0;
 867   p->type = DEMANGLE_COMPONENT_NAME;
 868   p->u.s_name.s = s;
 869   p->u.s_name.len = len;
 870   return 1;
 871 }
 872
 873 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
 874
 875 CP_STATIC_IF_GLIBCPP_V3
 876 int
 877 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
 878                                        struct demangle_component *name)
 879 {
 880   if (p == NULL || args < 0 || name == NULL)
 881     return 0;
 882   p->d_printing = 0;
 883   p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
 884   p->u.s_extended_operator.args = args;
 885   p->u.s_extended_operator.name = name;
 886   return 1;
 887 }
 888
 889 /* Fill in a DEMANGLE_COMPONENT_CTOR.  */
 890
 891 CP_STATIC_IF_GLIBCPP_V3
 892 int
 893 cplus_demangle_fill_ctor (struct demangle_component *p,
 894                           enum gnu_v3_ctor_kinds kind,
 895                           struct demangle_component *name)
 896 {
 897   if (p == NULL
 898       || name == NULL
 899       || (int) kind < gnu_v3_complete_object_ctor
 900       || (int) kind > gnu_v3_object_ctor_group)
 901     return 0;
 902   p->d_printing = 0;
 903   p->type = DEMANGLE_COMPONENT_CTOR;
 904   p->u.s_ctor.kind = kind;
 905   p->u.s_ctor.name = name;
 906   return 1;
 907 }
 908
 909 /* Fill in a DEMANGLE_COMPONENT_DTOR.  */
 910
 911 CP_STATIC_IF_GLIBCPP_V3
 912 int
 913 cplus_demangle_fill_dtor (struct demangle_component *p,
 914                           enum gnu_v3_dtor_kinds kind,
 915                           struct demangle_component *name)
 916 {
 917   if (p == NULL
 918       || name == NULL
 919       || (int) kind < gnu_v3_deleting_dtor
 920       || (int) kind > gnu_v3_object_dtor_group)
 921     return 0;
 922   p->d_printing = 0;
 923   p->type = DEMANGLE_COMPONENT_DTOR;
 924   p->u.s_dtor.kind = kind;
 925   p->u.s_dtor.name = name;
 926   return 1;
 927 }
 928
 929 /* Add a new component.  */
 930
 931 static struct demangle_component *
 932 d_make_empty (struct d_info *di)
 933 {
 934   struct demangle_component *p;
 935
 936   if (di->next_comp >= di->num_comps)
 937     return NULL;
 938   p = &di->comps[di->next_comp];
 939   p->d_printing = 0;
 940   ++di->next_comp;
 941   return p;
 942 }
 943
 944 /* Add a new generic component.  */
 945
 946 static struct demangle_component *
 947 d_make_comp (struct d_info *di, enum demangle_component_type type,
 948              struct demangle_component *left,
 949              struct demangle_component *right)
 950 {
 951   struct demangle_component *p;
 952
 953   /* We check for errors here.  A typical error would be a NULL return
 954      from a subroutine.  We catch those here, and return NULL
 955      upward.  */
 956   switch (type)
 957     {
 958       /* These types require two parameters.  */
 959     case DEMANGLE_COMPONENT_QUAL_NAME:
 960     case DEMANGLE_COMPONENT_LOCAL_NAME:
 961     case DEMANGLE_COMPONENT_TYPED_NAME:
 962     case DEMANGLE_COMPONENT_TAGGED_NAME:
 963     case DEMANGLE_COMPONENT_TEMPLATE:
 964     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
 965     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 966     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 967     case DEMANGLE_COMPONENT_UNARY:
 968     case DEMANGLE_COMPONENT_BINARY:
 969     case DEMANGLE_COMPONENT_BINARY_ARGS:
 970     case DEMANGLE_COMPONENT_TRINARY:
 971     case DEMANGLE_COMPONENT_TRINARY_ARG1:
 972     case DEMANGLE_COMPONENT_LITERAL:
 973     case DEMANGLE_COMPONENT_LITERAL_NEG:
 974     case DEMANGLE_COMPONENT_COMPOUND_NAME:
 975     case DEMANGLE_COMPONENT_VECTOR_TYPE:
 976     case DEMANGLE_COMPONENT_CLONE:
 977       if (left == NULL || right == NULL)
 978         return NULL;
 979       break;
 980
 981       /* These types only require one parameter.  */
 982     case DEMANGLE_COMPONENT_VTABLE:
 983     case DEMANGLE_COMPONENT_VTT:
 984     case DEMANGLE_COMPONENT_TYPEINFO:
 985     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
 986     case DEMANGLE_COMPONENT_TYPEINFO_FN:
 987     case DEMANGLE_COMPONENT_THUNK:
 988     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
 989     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
 990     case DEMANGLE_COMPONENT_JAVA_CLASS:
 991     case DEMANGLE_COMPONENT_GUARD:
 992     case DEMANGLE_COMPONENT_TLS_INIT:
 993     case DEMANGLE_COMPONENT_TLS_WRAPPER:
 994     case DEMANGLE_COMPONENT_REFTEMP:
 995     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
 996     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
 997     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
 998     case DEMANGLE_COMPONENT_POINTER:
 999     case DEMANGLE_COMPONENT_REFERENCE:
1000     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
1001     case DEMANGLE_COMPONENT_COMPLEX:
1002     case DEMANGLE_COMPONENT_IMAGINARY:
1003     case DEMANGLE_COMPONENT_VENDOR_TYPE:
1004     case DEMANGLE_COMPONENT_CAST:
1005     case DEMANGLE_COMPONENT_CONVERSION:
1006     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
1007     case DEMANGLE_COMPONENT_DECLTYPE:
1008     case DEMANGLE_COMPONENT_PACK_EXPANSION:
1009     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
1010     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
1011     case DEMANGLE_COMPONENT_NULLARY:
1012     case DEMANGLE_COMPONENT_TRINARY_ARG2:
1013     case DEMANGLE_COMPONENT_TPARM_OBJ:
1014       if (left == NULL)
1015         return NULL;
1016       break;
1017
1018       /* This needs a right parameter, but the left parameter can be
1019          empty.  */
1020     case DEMANGLE_COMPONENT_ARRAY_TYPE:
1021     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
1022       if (right == NULL)
1023         return NULL;
1024       break;
1025
1026       /* These are allowed to have no parameters--in some cases they
1027          will be filled in later.  */
1028     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
1029     case DEMANGLE_COMPONENT_RESTRICT:
1030     case DEMANGLE_COMPONENT_VOLATILE:
1031     case DEMANGLE_COMPONENT_CONST:
1032     case DEMANGLE_COMPONENT_ARGLIST:
1033     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
1034     FNQUAL_COMPONENT_CASE:
1035       break;
1036
1037       /* Other types should not be seen here.  */
1038     default:
1039       return NULL;
1040     }
1041
1042   p = d_make_empty (di);
1043   if (p != NULL)
1044     {
1045       p->type = type;
1046       p->u.s_binary.left = left;
1047       p->u.s_binary.right = right;
1048     }
1049   return p;
1050 }
1051
1052 /* Add a new demangle mangled name component.  */
1053
1054 static struct demangle_component *
1055 d_make_demangle_mangled_name (struct d_info *di, const char *s)
1056 {
1057   if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
1058     return d_make_name (di, s, strlen (s));
1059   d_advance (di, 2);
1060   return d_encoding (di, 0);
1061 }
1062
1063 /* Add a new name component.  */
1064
1065 static struct demangle_component *
1066 d_make_name (struct d_info *di, const char *s, int len)
1067 {
1068   struct demangle_component *p;
1069
1070   p = d_make_empty (di);
1071   if (! cplus_demangle_fill_name (p, s, len))
1072     return NULL;
1073   return p;
1074 }
1075
1076 /* Add a new builtin type component.  */
1077
1078 static struct demangle_component *
1079 d_make_builtin_type (struct d_info *di,
1080                      const struct demangle_builtin_type_info *type)
1081 {
1082   struct demangle_component *p;
1083
1084   if (type == NULL)
1085     return NULL;
1086   p = d_make_empty (di);
1087   if (p != NULL)
1088     {
1089       p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
1090       p->u.s_builtin.type = type;
1091     }
1092   return p;
1093 }
1094
1095 /* Add a new operator component.  */
1096
1097 static struct demangle_component *
1098 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1099 {
1100   struct demangle_component *p;
1101
1102   p = d_make_empty (di);
1103   if (p != NULL)
1104     {
1105       p->type = DEMANGLE_COMPONENT_OPERATOR;
1106       p->u.s_operator.op = op;
1107     }
1108   return p;
1109 }
1110
1111 /* Add a new extended operator component.  */
1112
1113 static struct demangle_component *
1114 d_make_extended_operator (struct d_info *di, int args,
1115                           struct demangle_component *name)
1116 {
1117   struct demangle_component *p;
1118
1119   p = d_make_empty (di);
1120   if (! cplus_demangle_fill_extended_operator (p, args, name))
1121     return NULL;
1122   return p;
1123 }
1124
1125 static struct demangle_component *
1126 d_make_default_arg (struct d_info *di, int num,
1127                     struct demangle_component *sub)
1128 {
1129   struct demangle_component *p = d_make_empty (di);
1130   if (p)
1131     {
1132       p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
1133       p->u.s_unary_num.num = num;
1134       p->u.s_unary_num.sub = sub;
1135     }
1136   return p;
1137 }
1138
1139 /* Add a new constructor component.  */
1140
1141 static struct demangle_component *
1142 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1143              struct demangle_component *name)
1144 {
1145   struct demangle_component *p;
1146
1147   p = d_make_empty (di);
1148   if (! cplus_demangle_fill_ctor (p, kind, name))
1149     return NULL;
1150   return p;
1151 }
1152
1153 /* Add a new destructor component.  */
1154
1155 static struct demangle_component *
1156 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1157              struct demangle_component *name)
1158 {
1159   struct demangle_component *p;
1160
1161   p = d_make_empty (di);
1162   if (! cplus_demangle_fill_dtor (p, kind, name))
1163     return NULL;
1164   return p;
1165 }
1166
1167 /* Add a new template parameter.  */
1168
1169 static struct demangle_component *
1170 d_make_template_param (struct d_info *di, int i)
1171 {
1172   struct demangle_component *p;
1173
1174   p = d_make_empty (di);
1175   if (p != NULL)
1176     {
1177       p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1178       p->u.s_number.number = i;
1179     }
1180   return p;
1181 }
1182
1183 /* Add a new function parameter.  */
1184
1185 static struct demangle_component *
1186 d_make_function_param (struct d_info *di, int i)
1187 {
1188   struct demangle_component *p;
1189
1190   p = d_make_empty (di);
1191   if (p != NULL)
1192     {
1193       p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1194       p->u.s_number.number = i;
1195     }
1196   return p;
1197 }
1198
1199 /* Add a new standard substitution component.  */
1200
1201 static struct demangle_component *
1202 d_make_sub (struct d_info *di, const char *name, int len)
1203 {
1204   struct demangle_component *p;
1205
1206   p = d_make_empty (di);
1207   if (p != NULL)
1208     {
1209       p->type = DEMANGLE_COMPONENT_SUB_STD;
1210       p->u.s_string.string = name;
1211       p->u.s_string.len = len;
1212     }
1213   return p;
1214 }
1215
1216 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1217
1218    TOP_LEVEL is non-zero when called at the top level.  */
1219
1220 CP_STATIC_IF_GLIBCPP_V3
1221 struct demangle_component *
1222 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1223 {
1224   struct demangle_component *p;
1225
1226   if (! d_check_char (di, '_')
1227       /* Allow missing _ if not at toplevel to work around a
1228          bug in G++ abi-version=2 mangling; see the comment in
1229          write_template_arg.  */
1230       && top_level)
1231     return NULL;
1232   if (! d_check_char (di, 'Z'))
1233     return NULL;
1234   p = d_encoding (di, top_level);
1235
1236   /* If at top level and parsing parameters, check for a clone
1237      suffix.  */
1238   if (top_level && (di->options & DMGL_PARAMS) != 0)
1239     while (d_peek_char (di) == '.'
1240            && (IS_LOWER (d_peek_next_char (di))
1241                || d_peek_next_char (di) == '_'
1242                || IS_DIGIT (d_peek_next_char (di))))
1243       p = d_clone_suffix (di, p);
1244
1245   return p;
1246 }
1247
1248 /* Return whether a function should have a return type.  The argument
1249    is the function name, which may be qualified in various ways.  The
1250    rules are that template functions have return types with some
1251    exceptions, function types which are not part of a function name
1252    mangling have return types with some exceptions, and non-template
1253    function names do not have return types.  The exceptions are that
1254    constructors, destructors, and conversion operators do not have
1255    return types.  */
1256
1257 static int
1258 has_return_type (struct demangle_component *dc)
1259 {
1260   if (dc == NULL)
1261     return 0;
1262   switch (dc->type)
1263     {
1264     default:
1265       return 0;
1266     case DEMANGLE_COMPONENT_LOCAL_NAME:
1267       return has_return_type (d_right (dc));
1268     case DEMANGLE_COMPONENT_TEMPLATE:
1269       return ! is_ctor_dtor_or_conversion (d_left (dc));
1270     FNQUAL_COMPONENT_CASE:
1271       return has_return_type (d_left (dc));
1272     }
1273 }
1274
1275 /* Return whether a name is a constructor, a destructor, or a
1276    conversion operator.  */
1277
1278 static int
1279 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1280 {
1281   if (dc == NULL)
1282     return 0;
1283   switch (dc->type)
1284     {
1285     default:
1286       return 0;
1287     case DEMANGLE_COMPONENT_QUAL_NAME:
1288     case DEMANGLE_COMPONENT_LOCAL_NAME:
1289       return is_ctor_dtor_or_conversion (d_right (dc));
1290     case DEMANGLE_COMPONENT_CTOR:
1291     case DEMANGLE_COMPONENT_DTOR:
1292     case DEMANGLE_COMPONENT_CONVERSION:
1293       return 1;
1294     }
1295 }
1296
1297 /* <encoding> ::= <(function) name> <bare-function-type>
1298               ::= <(data) name>
1299               ::= <special-name>
1300
1301    TOP_LEVEL is non-zero when called at the top level, in which case
1302    if DMGL_PARAMS is not set we do not demangle the function
1303    parameters.  We only set this at the top level, because otherwise
1304    we would not correctly demangle names in local scopes.  */
1305
1306 static struct demangle_component *
1307 d_encoding (struct d_info *di, int top_level)
1308 {
1309   char peek = d_peek_char (di);
1310   struct demangle_component *dc;
1311
1312   if (peek == 'G' || peek == 'T')
1313     dc = d_special_name (di);
1314   else
1315     {
1316       dc = d_name (di);
1317
1318       if (!dc)
1319         /* Failed already.  */;
1320       else if (top_level && (di->options & DMGL_PARAMS) == 0)
1321         {
1322           /* Strip off any initial CV-qualifiers, as they really apply
1323              to the `this' parameter, and they were not output by the
1324              v2 demangler without DMGL_PARAMS.  */
1325           while (is_fnqual_component_type (dc->type))
1326             dc = d_left (dc);
1327
1328           /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1329              there may be function-qualifiers on its right argument which
1330              really apply here; this happens when parsing a class
1331              which is local to a function.  */
1332           if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1333             {
1334               while (d_right (dc) != NULL
1335                      && is_fnqual_component_type (d_right (dc)->type))
1336                 d_right (dc) = d_left (d_right (dc));
1337
1338               if (d_right (dc) == NULL)
1339                 dc = NULL;
1340             }
1341         }
1342       else
1343         {
1344           peek = d_peek_char (di);
1345           if (peek != '\0' && peek != 'E')
1346             {
1347               struct demangle_component *ftype;
1348
1349               ftype = d_bare_function_type (di, has_return_type (dc));
1350               if (ftype)
1351                 {
1352                   /* If this is a non-top-level local-name, clear the
1353                      return type, so it doesn't confuse the user by
1354                      being confused with the return type of whaever
1355                      this is nested within.  */
1356                   if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME
1357                       && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
1358                     d_left (ftype) = NULL;
1359
1360                   dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
1361                                     dc, ftype);
1362                 }
1363               else
1364                 dc = NULL;
1365             }
1366         }
1367     }
1368
1369   return dc;
1370 }
1371
1372 /* <tagged-name> ::= <name> B <source-name> */
1373
1374 static struct demangle_component *
1375 d_abi_tags (struct d_info *di, struct demangle_component *dc)
1376 {
1377   struct demangle_component *hold_last_name;
1378   char peek;
1379
1380   /* Preserve the last name, so the ABI tag doesn't clobber it.  */
1381   hold_last_name = di->last_name;
1382
1383   while (peek = d_peek_char (di),
1384          peek == 'B')
1385     {
1386       struct demangle_component *tag;
1387       d_advance (di, 1);
1388       tag = d_source_name (di);
1389       dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1390     }
1391
1392   di->last_name = hold_last_name;
1393
1394   return dc;
1395 }
1396
1397 /* <name> ::= <nested-name>
1398           ::= <unscoped-name>
1399           ::= <unscoped-template-name> <template-args>
1400           ::= <local-name>
1401
1402    <unscoped-name> ::= <unqualified-name>
1403                    ::= St <unqualified-name>
1404
1405    <unscoped-template-name> ::= <unscoped-name>
1406                             ::= <substitution>
1407 */
1408
1409 static struct demangle_component *
1410 d_name (struct d_info *di)
1411 {
1412   char peek = d_peek_char (di);
1413   struct demangle_component *dc;
1414
1415   switch (peek)
1416     {
1417     case 'N':
1418       return d_nested_name (di);
1419
1420     case 'Z':
1421       return d_local_name (di);
1422
1423     case 'U':
1424       return d_unqualified_name (di);
1425
1426     case 'S':
1427       {
1428         int subst;
1429
1430         if (d_peek_next_char (di) != 't')
1431           {
1432             dc = d_substitution (di, 0);
1433             subst = 1;
1434           }
1435         else
1436           {
1437             d_advance (di, 2);
1438             dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1439                               d_make_name (di, "std", 3),
1440                               d_unqualified_name (di));
1441             di->expansion += 3;
1442             subst = 0;
1443           }
1444
1445         if (d_peek_char (di) != 'I')
1446           {
1447             /* The grammar does not permit this case to occur if we
1448                called d_substitution() above (i.e., subst == 1).  We
1449                don't bother to check.  */
1450           }
1451         else
1452           {
1453             /* This is <template-args>, which means that we just saw
1454                <unscoped-template-name>, which is a substitution
1455                candidate if we didn't just get it from a
1456                substitution.  */
1457             if (! subst)
1458               {
1459                 if (! d_add_substitution (di, dc))
1460                   return NULL;
1461               }
1462             dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1463                               d_template_args (di));
1464           }
1465
1466         return dc;
1467       }
1468
1469     case 'L':
1470     default:
1471       dc = d_unqualified_name (di);
1472       if (d_peek_char (di) == 'I')
1473         {
1474           /* This is <template-args>, which means that we just saw
1475              <unscoped-template-name>, which is a substitution
1476              candidate.  */
1477           if (! d_add_substitution (di, dc))
1478             return NULL;
1479           dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1480                             d_template_args (di));
1481         }
1482       return dc;
1483     }
1484 }
1485
1486 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1487                  ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1488 */
1489
1490 static struct demangle_component *
1491 d_nested_name (struct d_info *di)
1492 {
1493   struct demangle_component *ret;
1494   struct demangle_component **pret;
1495   struct demangle_component *rqual;
1496
1497   if (! d_check_char (di, 'N'))
1498     return NULL;
1499
1500   pret = d_cv_qualifiers (di, &ret, 1);
1501   if (pret == NULL)
1502     return NULL;
1503
1504   /* Parse the ref-qualifier now and then attach it
1505      once we have something to attach it to.  */
1506   rqual = d_ref_qualifier (di, NULL);
1507
1508   *pret = d_prefix (di);
1509   if (*pret == NULL)
1510     return NULL;
1511
1512   if (rqual)
1513     {
1514       d_left (rqual) = ret;
1515       ret = rqual;
1516     }
1517
1518   if (! d_check_char (di, 'E'))
1519     return NULL;
1520
1521   return ret;
1522 }
1523
1524 /* <prefix> ::= <prefix> <unqualified-name>
1525             ::= <template-prefix> <template-args>
1526             ::= <template-param>
1527             ::= <decltype>
1528             ::=
1529             ::= <substitution>
1530
1531    <template-prefix> ::= <prefix> <(template) unqualified-name>
1532                      ::= <template-param>
1533                      ::= <substitution>
1534 */
1535
1536 static struct demangle_component *
1537 d_prefix (struct d_info *di)
1538 {
1539   struct demangle_component *ret = NULL;
1540
1541   while (1)
1542     {
1543       char peek;
1544       enum demangle_component_type comb_type;
1545       struct demangle_component *dc;
1546
1547       peek = d_peek_char (di);
1548       if (peek == '\0')
1549         return NULL;
1550
1551       /* The older code accepts a <local-name> here, but I don't see
1552          that in the grammar.  The older code does not accept a
1553          <template-param> here.  */
1554
1555       comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1556       if (peek == 'D')
1557         {
1558           char peek2 = d_peek_next_char (di);
1559           if (peek2 == 'T' || peek2 == 't')
1560             /* Decltype.  */
1561             dc = cplus_demangle_type (di);
1562           else
1563             /* Destructor name.  */
1564             dc = d_unqualified_name (di);
1565         }
1566       else if (IS_DIGIT (peek)
1567           || IS_LOWER (peek)
1568           || peek == 'C'
1569           || peek == 'U'
1570           || peek == 'L')
1571         dc = d_unqualified_name (di);
1572       else if (peek == 'S')
1573         dc = d_substitution (di, 1);
1574       else if (peek == 'I')
1575         {
1576           if (ret == NULL)
1577             return NULL;
1578           comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1579           dc = d_template_args (di);
1580         }
1581       else if (peek == 'T')
1582         dc = d_template_param (di);
1583       else if (peek == 'E')
1584         return ret;
1585       else if (peek == 'M')
1586         {
1587           /* Initializer scope for a lambda.  We don't need to represent
1588              this; the normal code will just treat the variable as a type
1589              scope, which gives appropriate output.  */
1590           if (ret == NULL)
1591             return NULL;
1592           d_advance (di, 1);
1593           continue;
1594         }
1595       else
1596         return NULL;
1597
1598       if (ret == NULL)
1599         ret = dc;
1600       else
1601         ret = d_make_comp (di, comb_type, ret, dc);
1602
1603       if (peek != 'S' && d_peek_char (di) != 'E')
1604         {
1605           if (! d_add_substitution (di, ret))
1606             return NULL;
1607         }
1608     }
1609 }
1610
1611 /* <unqualified-name> ::= <operator-name>
1612                       ::= <ctor-dtor-name>
1613                       ::= <source-name>
1614                       ::= <local-source-name>
1615
1616     <local-source-name> ::= L <source-name> <discriminator>
1617 */
1618
1619 static struct demangle_component *
1620 d_unqualified_name (struct d_info *di)
1621 {
1622   struct demangle_component *ret;
1623   char peek;
1624
1625   peek = d_peek_char (di);
1626   if (IS_DIGIT (peek))
1627     ret = d_source_name (di);
1628   else if (IS_LOWER (peek))
1629     {
1630       if (peek == 'o' && d_peek_next_char (di) == 'n')
1631         d_advance (di, 2);
1632       ret = d_operator_name (di);
1633       if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1634         {
1635           di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1636           if (!strcmp (ret->u.s_operator.op->code, "li"))
1637             ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1638                                d_source_name (di));
1639         }
1640     }
1641   else if (peek == 'C' || peek == 'D')
1642     ret = d_ctor_dtor_name (di);
1643   else if (peek == 'L')
1644     {
1645       d_advance (di, 1);
1646
1647       ret = d_source_name (di);
1648       if (ret == NULL)
1649         return NULL;
1650       if (! d_discriminator (di))
1651         return NULL;
1652     }
1653   else if (peek == 'U')
1654     {
1655       switch (d_peek_next_char (di))
1656         {
1657         case 'l':
1658           ret = d_lambda (di);
1659           break;
1660         case 't':
1661           ret = d_unnamed_type (di);
1662           break;
1663         default:
1664           return NULL;
1665         }
1666     }
1667   else
1668     return NULL;
1669
1670   if (d_peek_char (di) == 'B')
1671     ret = d_abi_tags (di, ret);
1672   return ret;
1673 }
1674
1675 /* <source-name> ::= <(positive length) number> <identifier>  */
1676
1677 static struct demangle_component *
1678 d_source_name (struct d_info *di)
1679 {
1680   int len;
1681   struct demangle_component *ret;
1682
1683   len = d_number (di);
1684   if (len <= 0)
1685     return NULL;
1686   ret = d_identifier (di, len);
1687   di->last_name = ret;
1688   return ret;
1689 }
1690
1691 /* number ::= [n] <(non-negative decimal integer)>  */
1692
1693 static int
1694 d_number (struct d_info *di)
1695 {
1696   int negative;
1697   char peek;
1698   int ret;
1699
1700   negative = 0;
1701   peek = d_peek_char (di);
1702   if (peek == 'n')
1703     {
1704       negative = 1;
1705       d_advance (di, 1);
1706       peek = d_peek_char (di);
1707     }
1708
1709   ret = 0;
1710   while (1)
1711     {
1712       if (! IS_DIGIT (peek))
1713         {
1714           if (negative)
1715             ret = - ret;
1716           return ret;
1717         }
1718       if (ret > ((INT_MAX - (peek - '0')) / 10))
1719         return -1;
1720       ret = ret * 10 + peek - '0';
1721       d_advance (di, 1);
1722       peek = d_peek_char (di);
1723     }
1724 }
1725
1726 /* Like d_number, but returns a demangle_component.  */
1727
1728 static struct demangle_component *
1729 d_number_component (struct d_info *di)
1730 {
1731   struct demangle_component *ret = d_make_empty (di);
1732   if (ret)
1733     {
1734       ret->type = DEMANGLE_COMPONENT_NUMBER;
1735       ret->u.s_number.number = d_number (di);
1736     }
1737   return ret;
1738 }
1739
1740 /* identifier ::= <(unqualified source code identifier)>  */
1741
1742 static struct demangle_component *
1743 d_identifier (struct d_info *di, int len)
1744 {
1745   const char *name;
1746
1747   name = d_str (di);
1748
1749   if (di->send - name < len)
1750     return NULL;
1751
1752   d_advance (di, len);
1753
1754   /* A Java mangled name may have a trailing '$' if it is a C++
1755      keyword.  This '$' is not included in the length count.  We just
1756      ignore the '$'.  */
1757   if ((di->options & DMGL_JAVA) != 0
1758       && d_peek_char (di) == '$')
1759     d_advance (di, 1);
1760
1761   /* Look for something which looks like a gcc encoding of an
1762      anonymous namespace, and replace it with a more user friendly
1763      name.  */
1764   if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1765       && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1766                  ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1767     {
1768       const char *s;
1769
1770       s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1771       if ((*s == '.' || *s == '_' || *s == '$')
1772           && s[1] == 'N')
1773         {
1774           di->expansion -= len - sizeof "(anonymous namespace)";
1775           return d_make_name (di, "(anonymous namespace)",
1776                               sizeof "(anonymous namespace)" - 1);
1777         }
1778     }
1779
1780   return d_make_name (di, name, len);
1781 }
1782
1783 /* operator_name ::= many different two character encodings.
1784                  ::= cv <type>
1785                  ::= v <digit> <source-name>
1786
1787    This list is sorted for binary search.  */
1788
1789 #define NL(s) s, (sizeof s) - 1
1790
1791 CP_STATIC_IF_GLIBCPP_V3
1792 const struct demangle_operator_info cplus_demangle_operators[] =
1793 {
1794   { "aN", NL ("&="),        2 },
1795   { "aS", NL ("="),         2 },
1796   { "aa", NL ("&&"),        2 },
1797   { "ad", NL ("&"),         1 },
1798   { "an", NL ("&"),         2 },
1799   { "at", NL ("alignof "),   1 },
1800   { "az", NL ("alignof "),   1 },
1801   { "cc", NL ("const_cast"), 2 },
1802   { "cl", NL ("()"),        2 },
1803   { "cm", NL (","),         2 },
1804   { "co", NL ("~"),         1 },
1805   { "dV", NL ("/="),        2 },
1806   { "da", NL ("delete[] "), 1 },
1807   { "dc", NL ("dynamic_cast"), 2 },
1808   { "de", NL ("*"),         1 },
1809   { "dl", NL ("delete "),   1 },
1810   { "ds", NL (".*"),        2 },
1811   { "dt", NL ("."),         2 },
1812   { "dv", NL ("/"),         2 },
1813   { "eO", NL ("^="),        2 },
1814   { "eo", NL ("^"),         2 },
1815   { "eq", NL ("=="),        2 },
1816   { "fL", NL ("..."),       3 },
1817   { "fR", NL ("..."),       3 },
1818   { "fl", NL ("..."),       2 },
1819   { "fr", NL ("..."),       2 },
1820   { "ge", NL (">="),        2 },
1821   { "gs", NL ("::"),        1 },
1822   { "gt", NL (">"),         2 },
1823   { "ix", NL ("[]"),        2 },
1824   { "lS", NL ("<<="),       2 },
1825   { "le", NL ("<="),        2 },
1826   { "li", NL ("operator\"\" "), 1 },
1827   { "ls", NL ("<<"),        2 },
1828   { "lt", NL ("<"),         2 },
1829   { "mI", NL ("-="),        2 },
1830   { "mL", NL ("*="),        2 },
1831   { "mi", NL ("-"),         2 },
1832   { "ml", NL ("*"),         2 },
1833   { "mm", NL ("--"),        1 },
1834   { "na", NL ("new[]"),     3 },
1835   { "ne", NL ("!="),        2 },
1836   { "ng", NL ("-"),         1 },
1837   { "nt", NL ("!"),         1 },
1838   { "nw", NL ("new"),       3 },
1839   { "oR", NL ("|="),        2 },
1840   { "oo", NL ("||"),        2 },
1841   { "or", NL ("|"),         2 },
1842   { "pL", NL ("+="),        2 },
1843   { "pl", NL ("+"),         2 },
1844   { "pm", NL ("->*"),       2 },
1845   { "pp", NL ("++"),        1 },
1846   { "ps", NL ("+"),         1 },
1847   { "pt", NL ("->"),        2 },
1848   { "qu", NL ("?"),         3 },
1849   { "rM", NL ("%="),        2 },
1850   { "rS", NL (">>="),       2 },
1851   { "rc", NL ("reinterpret_cast"), 2 },
1852   { "rm", NL ("%"),         2 },
1853   { "rs", NL (">>"),        2 },
1854   { "sP", NL ("sizeof..."), 1 },
1855   { "sZ", NL ("sizeof..."), 1 },
1856   { "sc", NL ("static_cast"), 2 },
1857   { "st", NL ("sizeof "),   1 },
1858   { "sz", NL ("sizeof "),   1 },
1859   { "tr", NL ("throw"),     0 },
1860   { "tw", NL ("throw "),    1 },
1861   { NULL, NULL, 0,          0 }
1862 };
1863
1864 static struct demangle_component *
1865 d_operator_name (struct d_info *di)
1866 {
1867   char c1;
1868   char c2;
1869
1870   c1 = d_next_char (di);
1871   c2 = d_next_char (di);
1872   if (c1 == 'v' && IS_DIGIT (c2))
1873     return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1874   else if (c1 == 'c' && c2 == 'v')
1875     {
1876       struct demangle_component *type;
1877       int was_conversion = di->is_conversion;
1878       struct demangle_component *res;
1879
1880       di->is_conversion = ! di->is_expression;
1881       type = cplus_demangle_type (di);
1882       if (di->is_conversion)
1883         res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
1884       else
1885         res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
1886       di->is_conversion = was_conversion;
1887       return res;
1888     }
1889   else
1890     {
1891       /* LOW is the inclusive lower bound.  */
1892       int low = 0;
1893       /* HIGH is the exclusive upper bound.  We subtract one to ignore
1894          the sentinel at the end of the array.  */
1895       int high = ((sizeof (cplus_demangle_operators)
1896                    / sizeof (cplus_demangle_operators[0]))
1897                   - 1);
1898
1899       while (1)
1900         {
1901           int i;
1902           const struct demangle_operator_info *p;
1903
1904           i = low + (high - low) / 2;
1905           p = cplus_demangle_operators + i;
1906
1907           if (c1 == p->code[0] && c2 == p->code[1])
1908             return d_make_operator (di, p);
1909
1910           if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1911             high = i;
1912           else
1913             low = i + 1;
1914           if (low == high)
1915             return NULL;
1916         }
1917     }
1918 }
1919
1920 static struct demangle_component *
1921 d_make_character (struct d_info *di, int c)
1922 {
1923   struct demangle_component *p;
1924   p = d_make_empty (di);
1925   if (p != NULL)
1926     {
1927       p->type = DEMANGLE_COMPONENT_CHARACTER;
1928       p->u.s_character.character = c;
1929     }
1930   return p;
1931 }
1932
1933 static struct demangle_component *
1934 d_java_resource (struct d_info *di)
1935 {
1936   struct demangle_component *p = NULL;
1937   struct demangle_component *next = NULL;
1938   int len, i;
1939   char c;
1940   const char *str;
1941
1942   len = d_number (di);
1943   if (len <= 1)
1944     return NULL;
1945
1946   /* Eat the leading '_'.  */
1947   if (d_next_char (di) != '_')
1948     return NULL;
1949   len--;
1950
1951   str = d_str (di);
1952   i = 0;
1953
1954   while (len > 0)
1955     {
1956       c = str[i];
1957       if (!c)
1958         return NULL;
1959
1960       /* Each chunk is either a '$' escape...  */
1961       if (c == '$')
1962         {
1963           i++;
1964           switch (str[i++])
1965             {
1966             case 'S':
1967               c = '/';
1968               break;
1969             case '_':
1970               c = '.';
1971               break;
1972             case '$':
1973               c = '$';
1974               break;
1975             default:
1976               return NULL;
1977             }
1978           next = d_make_character (di, c);
1979           d_advance (di, i);
1980           str = d_str (di);
1981           len -= i;
1982           i = 0;
1983           if (next == NULL)
1984             return NULL;
1985         }
1986       /* ... or a sequence of characters.  */
1987       else
1988         {
1989           while (i < len && str[i] && str[i] != '$')
1990             i++;
1991
1992           next = d_make_name (di, str, i);
1993           d_advance (di, i);
1994           str = d_str (di);
1995           len -= i;
1996           i = 0;
1997           if (next == NULL)
1998             return NULL;
1999         }
2000
2001       if (p == NULL)
2002         p = next;
2003       else
2004         {
2005           p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
2006           if (p == NULL)
2007             return NULL;
2008         }
2009     }
2010
2011   p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
2012
2013   return p;
2014 }
2015
2016 /* <special-name> ::= TV <type>
2017                   ::= TT <type>
2018                   ::= TI <type>
2019                   ::= TS <type>
2020                   ::= TA <template-arg>
2021                   ::= GV <(object) name>
2022                   ::= T <call-offset> <(base) encoding>
2023                   ::= Tc <call-offset> <call-offset> <(base) encoding>
2024    Also g++ extensions:
2025                   ::= TC <type> <(offset) number> _ <(base) type>
2026                   ::= TF <type>
2027                   ::= TJ <type>
2028                   ::= GR <name>
2029                   ::= GA <encoding>
2030                   ::= Gr <resource name>
2031                   ::= GTt <encoding>
2032                   ::= GTn <encoding>
2033 */
2034
2035 static struct demangle_component *
2036 d_special_name (struct d_info *di)
2037 {
2038   di->expansion += 20;
2039   if (d_check_char (di, 'T'))
2040     {
2041       switch (d_next_char (di))
2042         {
2043         case 'V':
2044           di->expansion -= 5;
2045           return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
2046                               cplus_demangle_type (di), NULL);
2047         case 'T':
2048           di->expansion -= 10;
2049           return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
2050                               cplus_demangle_type (di), NULL);
2051         case 'I':
2052           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
2053                               cplus_demangle_type (di), NULL);
2054         case 'S':
2055           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
2056                               cplus_demangle_type (di), NULL);
2057
2058         case 'h':
2059           if (! d_call_offset (di, 'h'))
2060             return NULL;
2061           return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
2062                               d_encoding (di, 0), NULL);
2063
2064         case 'v':
2065           if (! d_call_offset (di, 'v'))
2066             return NULL;
2067           return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
2068                               d_encoding (di, 0), NULL);
2069
2070         case 'c':
2071           if (! d_call_offset (di, '\0'))
2072             return NULL;
2073           if (! d_call_offset (di, '\0'))
2074             return NULL;
2075           return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
2076                               d_encoding (di, 0), NULL);
2077
2078         case 'C':
2079           {
2080             struct demangle_component *derived_type;
2081             int offset;
2082             struct demangle_component *base_type;
2083
2084             derived_type = cplus_demangle_type (di);
2085             offset = d_number (di);
2086             if (offset < 0)
2087               return NULL;
2088             if (! d_check_char (di, '_'))
2089               return NULL;
2090             base_type = cplus_demangle_type (di);
2091             /* We don't display the offset.  FIXME: We should display
2092                it in verbose mode.  */
2093             di->expansion += 5;
2094             return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
2095                                 base_type, derived_type);
2096           }
2097
2098         case 'F':
2099           return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2100                               cplus_demangle_type (di), NULL);
2101         case 'J':
2102           return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2103                               cplus_demangle_type (di), NULL);
2104
2105         case 'H':
2106           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2107                               d_name (di), NULL);
2108
2109         case 'W':
2110           return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2111                               d_name (di), NULL);
2112
2113         case 'A':
2114           return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
2115                               d_template_arg (di), NULL);
2116
2117         default:
2118           return NULL;
2119         }
2120     }
2121   else if (d_check_char (di, 'G'))
2122     {
2123       switch (d_next_char (di))
2124         {
2125         case 'V':
2126           return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
2127                               d_name (di), NULL);
2128
2129         case 'R':
2130           {
2131             struct demangle_component *name = d_name (di);
2132             return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2133                                 d_number_component (di));
2134           }
2135
2136         case 'A':
2137           return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2138                               d_encoding (di, 0), NULL);
2139
2140         case 'T':
2141           switch (d_next_char (di))
2142             {
2143             case 'n':
2144               return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2145                                   d_encoding (di, 0), NULL);
2146             default:
2147               /* ??? The proposal is that other letters (such as 'h') stand
2148                  for different variants of transaction cloning, such as
2149                  compiling directly for hardware transaction support.  But
2150                  they still should all be transactional clones of some sort
2151                  so go ahead and call them that.  */
2152             case 't':
2153               return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
2154                                   d_encoding (di, 0), NULL);
2155             }
2156
2157         case 'r':
2158           return d_java_resource (di);
2159
2160         default:
2161           return NULL;
2162         }
2163     }
2164   else
2165     return NULL;
2166 }
2167
2168 /* <call-offset> ::= h <nv-offset> _
2169                  ::= v <v-offset> _
2170
2171    <nv-offset> ::= <(offset) number>
2172
2173    <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2174
2175    The C parameter, if not '\0', is a character we just read which is
2176    the start of the <call-offset>.
2177
2178    We don't display the offset information anywhere.  FIXME: We should
2179    display it in verbose mode.  */
2180
2181 static int
2182 d_call_offset (struct d_info *di, int c)
2183 {
2184   if (c == '\0')
2185     c = d_next_char (di);
2186
2187   if (c == 'h')
2188     d_number (di);
2189   else if (c == 'v')
2190     {
2191       d_number (di);
2192       if (! d_check_char (di, '_'))
2193         return 0;
2194       d_number (di);
2195     }
2196   else
2197     return 0;
2198
2199   if (! d_check_char (di, '_'))
2200     return 0;
2201
2202   return 1;
2203 }
2204
2205 /* <ctor-dtor-name> ::= C1
2206                     ::= C2
2207                     ::= C3
2208                     ::= D0
2209                     ::= D1
2210                     ::= D2
2211 */
2212
2213 static struct demangle_component *
2214 d_ctor_dtor_name (struct d_info *di)
2215 {
2216   if (di->last_name != NULL)
2217     {
2218       if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2219         di->expansion += di->last_name->u.s_name.len;
2220       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2221         di->expansion += di->last_name->u.s_string.len;
2222     }
2223   switch (d_peek_char (di))
2224     {
2225     case 'C':
2226       {
2227         enum gnu_v3_ctor_kinds kind;
2228         int inheriting = 0;
2229
2230         if (d_peek_next_char (di) == 'I')
2231           {
2232             inheriting = 1;
2233             d_advance (di, 1);
2234           }
2235
2236         switch (d_peek_next_char (di))
2237           {
2238           case '1':
2239             kind = gnu_v3_complete_object_ctor;
2240             break;
2241           case '2':
2242             kind = gnu_v3_base_object_ctor;
2243             break;
2244           case '3':
2245             kind = gnu_v3_complete_object_allocating_ctor;
2246             break;
2247           case '4':
2248             kind = gnu_v3_unified_ctor;
2249             break;
2250           case '5':
2251             kind = gnu_v3_object_ctor_group;
2252             break;
2253           default:
2254             return NULL;
2255           }
2256
2257         d_advance (di, 2);
2258
2259         if (inheriting)
2260           cplus_demangle_type (di);
2261
2262         return d_make_ctor (di, kind, di->last_name);
2263       }
2264
2265     case 'D':
2266       {
2267         enum gnu_v3_dtor_kinds kind;
2268
2269         switch (d_peek_next_char (di))
2270           {
2271           case '0':
2272             kind = gnu_v3_deleting_dtor;
2273             break;
2274           case '1':
2275             kind = gnu_v3_complete_object_dtor;
2276             break;
2277           case '2':
2278             kind = gnu_v3_base_object_dtor;
2279             break;
2280           /*  digit '3' is not used */
2281           case '4':
2282             kind = gnu_v3_unified_dtor;
2283             break;
2284           case '5':
2285             kind = gnu_v3_object_dtor_group;
2286             break;
2287           default:
2288             return NULL;
2289           }
2290         d_advance (di, 2);
2291         return d_make_dtor (di, kind, di->last_name);
2292       }
2293
2294     default:
2295       return NULL;
2296     }
2297 }
2298
2299 /* True iff we're looking at an order-insensitive type-qualifier, including
2300    function-type-qualifiers.  */
2301
2302 static int
2303 next_is_type_qual (struct d_info *di)
2304 {
2305   char peek = d_peek_char (di);
2306   if (peek == 'r' || peek == 'V' || peek == 'K')
2307     return 1;
2308   if (peek == 'D')
2309     {
2310       peek = d_peek_next_char (di);
2311       if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
2312         return 1;
2313     }
2314   return 0;
2315 }
2316
2317 /* <type> ::= <builtin-type>
2318           ::= <function-type>
2319           ::= <class-enum-type>
2320           ::= <array-type>
2321           ::= <pointer-to-member-type>
2322           ::= <template-param>
2323           ::= <template-template-param> <template-args>
2324           ::= <substitution>
2325           ::= <CV-qualifiers> <type>
2326           ::= P <type>
2327           ::= R <type>
2328           ::= O <type> (C++0x)
2329           ::= C <type>
2330           ::= G <type>
2331           ::= U <source-name> <type>
2332
2333    <builtin-type> ::= various one letter codes
2334                   ::= u <source-name>
2335 */
2336
2337 CP_STATIC_IF_GLIBCPP_V3
2338 const struct demangle_builtin_type_info
2339 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2340 {
2341   /* a */ { NL ("signed char"), NL ("signed char"),     D_PRINT_DEFAULT },
2342   /* b */ { NL ("bool"),        NL ("boolean"),         D_PRINT_BOOL },
2343   /* c */ { NL ("char"),        NL ("byte"),            D_PRINT_DEFAULT },
2344   /* d */ { NL ("double"),      NL ("double"),          D_PRINT_FLOAT },
2345   /* e */ { NL ("long double"), NL ("long double"),     D_PRINT_FLOAT },
2346   /* f */ { NL ("float"),       NL ("float"),           D_PRINT_FLOAT },
2347   /* g */ { NL ("__float128"),  NL ("__float128"),      D_PRINT_FLOAT },
2348   /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2349   /* i */ { NL ("int"),         NL ("int"),             D_PRINT_INT },
2350   /* j */ { NL ("unsigned int"), NL ("unsigned"),       D_PRINT_UNSIGNED },
2351   /* k */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2352   /* l */ { NL ("long"),        NL ("long"),            D_PRINT_LONG },
2353   /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2354   /* n */ { NL ("__int128"),    NL ("__int128"),        D_PRINT_DEFAULT },
2355   /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2356             D_PRINT_DEFAULT },
2357   /* p */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2358   /* q */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2359   /* r */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2360   /* s */ { NL ("short"),       NL ("short"),           D_PRINT_DEFAULT },
2361   /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2362   /* u */ { NULL, 0,            NULL, 0,                D_PRINT_DEFAULT },
2363   /* v */ { NL ("void"),        NL ("void"),            D_PRINT_VOID },
2364   /* w */ { NL ("wchar_t"),     NL ("char"),            D_PRINT_DEFAULT },
2365   /* x */ { NL ("long long"),   NL ("long"),            D_PRINT_LONG_LONG },
2366   /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2367             D_PRINT_UNSIGNED_LONG_LONG },
2368   /* z */ { NL ("..."),         NL ("..."),             D_PRINT_DEFAULT },
2369   /* 26 */ { NL ("decimal32"),  NL ("decimal32"),       D_PRINT_DEFAULT },
2370   /* 27 */ { NL ("decimal64"),  NL ("decimal64"),       D_PRINT_DEFAULT },
2371   /* 28 */ { NL ("decimal128"), NL ("decimal128"),      D_PRINT_DEFAULT },
2372   /* 29 */ { NL ("half"),       NL ("half"),            D_PRINT_FLOAT },
2373   /* 30 */ { NL ("char8_t"),    NL ("char8_t"),         D_PRINT_DEFAULT },
2374   /* 31 */ { NL ("char16_t"),   NL ("char16_t"),        D_PRINT_DEFAULT },
2375   /* 32 */ { NL ("char32_t"),   NL ("char32_t"),        D_PRINT_DEFAULT },
2376   /* 33 */ { NL ("decltype(nullptr)"),  NL ("decltype(nullptr)"),
2377              D_PRINT_DEFAULT },
2378 };
2379
2380 CP_STATIC_IF_GLIBCPP_V3
2381 struct demangle_component *
2382 cplus_demangle_type (struct d_info *di)
2383 {
2384   char peek;
2385   struct demangle_component *ret;
2386   int can_subst;
2387
2388   /* The ABI specifies that when CV-qualifiers are used, the base type
2389      is substitutable, and the fully qualified type is substitutable,
2390      but the base type with a strict subset of the CV-qualifiers is
2391      not substitutable.  The natural recursive implementation of the
2392      CV-qualifiers would cause subsets to be substitutable, so instead
2393      we pull them all off now.
2394
2395      FIXME: The ABI says that order-insensitive vendor qualifiers
2396      should be handled in the same way, but we have no way to tell
2397      which vendor qualifiers are order-insensitive and which are
2398      order-sensitive.  So we just assume that they are all
2399      order-sensitive.  g++ 3.4 supports only one vendor qualifier,
2400      __vector, and it treats it as order-sensitive when mangling
2401      names.  */
2402
2403   if (next_is_type_qual (di))
2404     {
2405       struct demangle_component **pret;
2406
2407       pret = d_cv_qualifiers (di, &ret, 0);
2408       if (pret == NULL)
2409         return NULL;
2410       if (d_peek_char (di) == 'F')
2411         {
2412           /* cv-qualifiers before a function type apply to 'this',
2413              so avoid adding the unqualified function type to
2414              the substitution list.  */
2415           *pret = d_function_type (di);
2416         }
2417       else
2418         *pret = cplus_demangle_type (di);
2419       if (!*pret)
2420         return NULL;
2421       if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2422           || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2423         {
2424           /* Move the ref-qualifier outside the cv-qualifiers so that
2425              they are printed in the right order.  */
2426           struct demangle_component *fn = d_left (*pret);
2427           d_left (*pret) = ret;
2428           ret = *pret;
2429           *pret = fn;
2430         }
2431       if (! d_add_substitution (di, ret))
2432         return NULL;
2433       return ret;
2434     }
2435
2436   can_subst = 1;
2437
2438   peek = d_peek_char (di);
2439   switch (peek)
2440     {
2441     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2442     case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
2443     case 'o':                               case 's': case 't':
2444     case 'v': case 'w': case 'x': case 'y': case 'z':
2445       ret = d_make_builtin_type (di,
2446                                  &cplus_demangle_builtin_types[peek - 'a']);
2447       di->expansion += ret->u.s_builtin.type->len;
2448       can_subst = 0;
2449       d_advance (di, 1);
2450       break;
2451
2452     case 'u':
2453       d_advance (di, 1);
2454       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2455                          d_source_name (di), NULL);
2456       break;
2457
2458     case 'F':
2459       ret = d_function_type (di);
2460       break;
2461
2462     case '0': case '1': case '2': case '3': case '4':
2463     case '5': case '6': case '7': case '8': case '9':
2464     case 'N':
2465     case 'Z':
2466       ret = d_class_enum_type (di);
2467       break;
2468
2469     case 'A':
2470       ret = d_array_type (di);
2471       break;
2472
2473     case 'M':
2474       ret = d_pointer_to_member_type (di);
2475       break;
2476
2477     case 'T':
2478       ret = d_template_param (di);
2479       if (d_peek_char (di) == 'I')
2480         {
2481           /* This may be <template-template-param> <template-args>.
2482              If this is the type for a conversion operator, we can
2483              have a <template-template-param> here only by following
2484              a derivation like this:
2485
2486              <nested-name>
2487              -> <template-prefix> <template-args>
2488              -> <prefix> <template-unqualified-name> <template-args>
2489              -> <unqualified-name> <template-unqualified-name> <template-args>
2490              -> <source-name> <template-unqualified-name> <template-args>
2491              -> <source-name> <operator-name> <template-args>
2492              -> <source-name> cv <type> <template-args>
2493              -> <source-name> cv <template-template-param> <template-args> <template-args>
2494
2495              where the <template-args> is followed by another.
2496              Otherwise, we must have a derivation like this:
2497
2498              <nested-name>
2499              -> <template-prefix> <template-args>
2500              -> <prefix> <template-unqualified-name> <template-args>
2501              -> <unqualified-name> <template-unqualified-name> <template-args>
2502              -> <source-name> <template-unqualified-name> <template-args>
2503              -> <source-name> <operator-name> <template-args>
2504              -> <source-name> cv <type> <template-args>
2505              -> <source-name> cv <template-param> <template-args>
2506
2507              where we need to leave the <template-args> to be processed
2508              by d_prefix (following the <template-prefix>).
2509
2510              The <template-template-param> part is a substitution
2511              candidate.  */
2512           if (! di->is_conversion)
2513             {
2514               if (! d_add_substitution (di, ret))
2515                 return NULL;
2516               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2517                                  d_template_args (di));
2518             }
2519           else
2520             {
2521               struct demangle_component *args;
2522               struct d_info_checkpoint checkpoint;
2523
2524               d_checkpoint (di, &checkpoint);
2525               args = d_template_args (di);
2526               if (d_peek_char (di) == 'I')
2527                 {
2528                   if (! d_add_substitution (di, ret))
2529                     return NULL;
2530                   ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2531                                      args);
2532                 }
2533               else
2534                 d_backtrack (di, &checkpoint);
2535             }
2536         }
2537       break;
2538
2539     case 'S':
2540       /* If this is a special substitution, then it is the start of
2541          <class-enum-type>.  */
2542       {
2543         char peek_next;
2544
2545         peek_next = d_peek_next_char (di);
2546         if (IS_DIGIT (peek_next)
2547             || peek_next == '_'
2548             || IS_UPPER (peek_next))
2549           {
2550             ret = d_substitution (di, 0);
2551             /* The substituted name may have been a template name and
2552                may be followed by tepmlate args.  */
2553             if (d_peek_char (di) == 'I')
2554               ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2555                                  d_template_args (di));
2556             else
2557               can_subst = 0;
2558           }
2559         else
2560           {
2561             ret = d_class_enum_type (di);
2562             /* If the substitution was a complete type, then it is not
2563                a new substitution candidate.  However, if the
2564                substitution was followed by template arguments, then
2565                the whole thing is a substitution candidate.  */
2566             if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2567               can_subst = 0;
2568           }
2569       }
2570       break;
2571
2572     case 'O':
2573       d_advance (di, 1);
2574       ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2575                          cplus_demangle_type (di), NULL);
2576       break;
2577
2578     case 'P':
2579       d_advance (di, 1);
2580       ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2581                          cplus_demangle_type (di), NULL);
2582       break;
2583
2584     case 'R':
2585       d_advance (di, 1);
2586       ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2587                          cplus_demangle_type (di), NULL);
2588       break;
2589
2590     case 'C':
2591       d_advance (di, 1);
2592       ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2593                          cplus_demangle_type (di), NULL);
2594       break;
2595
2596     case 'G':
2597       d_advance (di, 1);
2598       ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2599                          cplus_demangle_type (di), NULL);
2600       break;
2601
2602     case 'U':
2603       d_advance (di, 1);
2604       ret = d_source_name (di);
2605       if (d_peek_char (di) == 'I')
2606         ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2607                            d_template_args (di));
2608       ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2609                          cplus_demangle_type (di), ret);
2610       break;
2611
2612     case 'D':
2613       can_subst = 0;
2614       d_advance (di, 1);
2615       peek = d_next_char (di);
2616       switch (peek)
2617         {
2618         case 'T':
2619         case 't':
2620           /* decltype (expression) */
2621           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2622                              d_expression (di), NULL);
2623           if (ret && d_next_char (di) != 'E')
2624             ret = NULL;
2625           can_subst = 1;
2626           break;
2627
2628         case 'p':
2629           /* Pack expansion.  */
2630           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2631                              cplus_demangle_type (di), NULL);
2632           can_subst = 1;
2633           break;
2634
2635         case 'a':
2636           /* auto */
2637           ret = d_make_name (di, "auto", 4);
2638           break;
2639         case 'c':
2640           /* decltype(auto) */
2641           ret = d_make_name (di, "decltype(auto)", 14);
2642           break;
2643
2644         case 'f':
2645           /* 32-bit decimal floating point */
2646           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2647           di->expansion += ret->u.s_builtin.type->len;
2648           break;
2649         case 'd':
2650           /* 64-bit DFP */
2651           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2652           di->expansion += ret->u.s_builtin.type->len;
2653           break;
2654         case 'e':
2655           /* 128-bit DFP */
2656           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2657           di->expansion += ret->u.s_builtin.type->len;
2658           break;
2659         case 'h':
2660           /* 16-bit half-precision FP */
2661           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2662           di->expansion += ret->u.s_builtin.type->len;
2663           break;
2664         case 'u':
2665           /* char8_t */
2666           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2667           di->expansion += ret->u.s_builtin.type->len;
2668           break;
2669         case 's':
2670           /* char16_t */
2671           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2672           di->expansion += ret->u.s_builtin.type->len;
2673           break;
2674         case 'i':
2675           /* char32_t */
2676           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2677           di->expansion += ret->u.s_builtin.type->len;
2678           break;
2679
2680         case 'F':
2681           /* Fixed point types. DF<int bits><length><fract bits><sat>  */
2682           ret = d_make_empty (di);
2683           ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2684           if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2685             /* For demangling we don't care about the bits.  */
2686             d_number (di);
2687           ret->u.s_fixed.length = cplus_demangle_type (di);
2688           if (ret->u.s_fixed.length == NULL)
2689             return NULL;
2690           d_number (di);
2691           peek = d_next_char (di);
2692           ret->u.s_fixed.sat = (peek == 's');
2693           break;
2694
2695         case 'v':
2696           ret = d_vector_type (di);
2697           can_subst = 1;
2698           break;
2699
2700         case 'n':
2701           /* decltype(nullptr) */
2702           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
2703           di->expansion += ret->u.s_builtin.type->len;
2704           break;
2705
2706         default:
2707           return NULL;
2708         }
2709       break;
2710
2711     default:
2712       return NULL;
2713     }
2714
2715   if (can_subst)
2716     {
2717       if (! d_add_substitution (di, ret))
2718         return NULL;
2719     }
2720
2721   return ret;
2722 }
2723
2724 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2725
2726 static struct demangle_component **
2727 d_cv_qualifiers (struct d_info *di,
2728                  struct demangle_component **pret, int member_fn)
2729 {
2730   struct demangle_component **pstart;
2731   char peek;
2732
2733   pstart = pret;
2734   peek = d_peek_char (di);
2735   while (next_is_type_qual (di))
2736     {
2737       enum demangle_component_type t;
2738       struct demangle_component *right = NULL;
2739
2740       d_advance (di, 1);
2741       if (peek == 'r')
2742         {
2743           t = (member_fn
2744                ? DEMANGLE_COMPONENT_RESTRICT_THIS
2745                : DEMANGLE_COMPONENT_RESTRICT);
2746           di->expansion += sizeof "restrict";
2747         }
2748       else if (peek == 'V')
2749         {
2750           t = (member_fn
2751                ? DEMANGLE_COMPONENT_VOLATILE_THIS
2752                : DEMANGLE_COMPONENT_VOLATILE);
2753           di->expansion += sizeof "volatile";
2754         }
2755       else if (peek == 'K')
2756         {
2757           t = (member_fn
2758                ? DEMANGLE_COMPONENT_CONST_THIS
2759                : DEMANGLE_COMPONENT_CONST);
2760           di->expansion += sizeof "const";
2761         }
2762       else
2763         {
2764           peek = d_next_char (di);
2765           if (peek == 'x')
2766             {
2767               t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
2768               di->expansion += sizeof "transaction_safe";
2769             }
2770           else if (peek == 'o'
2771                    || peek == 'O')
2772             {
2773               t = DEMANGLE_COMPONENT_NOEXCEPT;
2774               di->expansion += sizeof "noexcept";
2775               if (peek == 'O')
2776                 {
2777                   right = d_expression (di);
2778                   if (right == NULL)
2779                     return NULL;
2780                   if (! d_check_char (di, 'E'))
2781                     return NULL;
2782                 }
2783             }
2784           else if (peek == 'w')
2785             {
2786               t = DEMANGLE_COMPONENT_THROW_SPEC;
2787               di->expansion += sizeof "throw";
2788               right = d_parmlist (di);
2789               if (right == NULL)
2790                 return NULL;
2791               if (! d_check_char (di, 'E'))
2792                 return NULL;
2793             }
2794           else
2795             return NULL;
2796         }
2797
2798       *pret = d_make_comp (di, t, NULL, right);
2799       if (*pret == NULL)
2800         return NULL;
2801       pret = &d_left (*pret);
2802
2803       peek = d_peek_char (di);
2804     }
2805
2806   if (!member_fn && peek == 'F')
2807     {
2808       while (pstart != pret)
2809         {
2810           switch ((*pstart)->type)
2811             {
2812             case DEMANGLE_COMPONENT_RESTRICT:
2813               (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2814               break;
2815             case DEMANGLE_COMPONENT_VOLATILE:
2816               (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2817               break;
2818             case DEMANGLE_COMPONENT_CONST:
2819               (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2820               break;
2821             default:
2822               break;
2823             }
2824           pstart = &d_left (*pstart);
2825         }
2826     }
2827
2828   return pret;
2829 }
2830
2831 /* <ref-qualifier> ::= R
2832                    ::= O */
2833
2834 static struct demangle_component *
2835 d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2836 {
2837   struct demangle_component *ret = sub;
2838   char peek;
2839
2840   peek = d_peek_char (di);
2841   if (peek == 'R' || peek == 'O')
2842     {
2843       enum demangle_component_type t;
2844       if (peek == 'R')
2845         {
2846           t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2847           di->expansion += sizeof "&";
2848         }
2849       else
2850         {
2851           t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2852           di->expansion += sizeof "&&";
2853         }
2854       d_advance (di, 1);
2855
2856       ret = d_make_comp (di, t, ret, NULL);
2857     }
2858
2859   return ret;
2860 }
2861
2862 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E  */
2863
2864 static struct demangle_component *
2865 d_function_type (struct d_info *di)
2866 {
2867   struct demangle_component *ret = NULL;
2868
2869   if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2870     {
2871       if (di->recursion_level > DEMANGLE_RECURSION_LIMIT)
2872         /* FIXME: There ought to be a way to report
2873            that the recursion limit has been reached.  */
2874         return NULL;
2875
2876       di->recursion_level ++;
2877     }
2878
2879   if (d_check_char (di, 'F'))
2880     {
2881       if (d_peek_char (di) == 'Y')
2882         {
2883           /* Function has C linkage.  We don't print this information.
2884              FIXME: We should print it in verbose mode.  */
2885           d_advance (di, 1);
2886         }
2887       ret = d_bare_function_type (di, 1);
2888       ret = d_ref_qualifier (di, ret);
2889
2890       if (! d_check_char (di, 'E'))
2891         ret = NULL;
2892     }
2893
2894   if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2895     di->recursion_level --;
2896   return ret;
2897 }
2898
2899 /* <type>+ */
2900
2901 static struct demangle_component *
2902 d_parmlist (struct d_info *di)
2903 {
2904   struct demangle_component *tl;
2905   struct demangle_component **ptl;
2906
2907   tl = NULL;
2908   ptl = &tl;
2909   while (1)
2910     {
2911       struct demangle_component *type;
2912
2913       char peek = d_peek_char (di);
2914       if (peek == '\0' || peek == 'E' || peek == '.')
2915         break;
2916       if ((peek == 'R' || peek == 'O')
2917           && d_peek_next_char (di) == 'E')
2918         /* Function ref-qualifier, not a ref prefix for a parameter type.  */
2919         break;
2920       type = cplus_demangle_type (di);
2921       if (type == NULL)
2922         return NULL;
2923       *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2924       if (*ptl == NULL)
2925         return NULL;
2926       ptl = &d_right (*ptl);
2927     }
2928
2929   /* There should be at least one parameter type besides the optional
2930      return type.  A function which takes no arguments will have a
2931      single parameter type void.  */
2932   if (tl == NULL)
2933     return NULL;
2934
2935   /* If we have a single parameter type void, omit it.  */
2936   if (d_right (tl) == NULL
2937       && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2938       && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2939     {
2940       di->expansion -= d_left (tl)->u.s_builtin.type->len;
2941       d_left (tl) = NULL;
2942     }
2943
2944   return tl;
2945 }
2946
2947 /* <bare-function-type> ::= [J]<type>+  */
2948
2949 static struct demangle_component *
2950 d_bare_function_type (struct d_info *di, int has_return_type)
2951 {
2952   struct demangle_component *return_type;
2953   struct demangle_component *tl;
2954   char peek;
2955
2956   /* Detect special qualifier indicating that the first argument
2957      is the return type.  */
2958   peek = d_peek_char (di);
2959   if (peek == 'J')
2960     {
2961       d_advance (di, 1);
2962       has_return_type = 1;
2963     }
2964
2965   if (has_return_type)
2966     {
2967       return_type = cplus_demangle_type (di);
2968       if (return_type == NULL)
2969         return NULL;
2970     }
2971   else
2972     return_type = NULL;
2973
2974   tl = d_parmlist (di);
2975   if (tl == NULL)
2976     return NULL;
2977
2978   return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2979                       return_type, tl);
2980 }
2981
2982 /* <class-enum-type> ::= <name>  */
2983
2984 static struct demangle_component *
2985 d_class_enum_type (struct d_info *di)
2986 {
2987   return d_name (di);
2988 }
2989
2990 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2991                 ::= A [<(dimension) expression>] _ <(element) type>
2992 */
2993
2994 static struct demangle_component *
2995 d_array_type (struct d_info *di)
2996 {
2997   char peek;
2998   struct demangle_component *dim;
2999
3000   if (! d_check_char (di, 'A'))
3001     return NULL;
3002
3003   peek = d_peek_char (di);
3004   if (peek == '_')
3005     dim = NULL;
3006   else if (IS_DIGIT (peek))
3007     {
3008       const char *s;
3009
3010       s = d_str (di);
3011       do
3012         {
3013           d_advance (di, 1);
3014           peek = d_peek_char (di);
3015         }
3016       while (IS_DIGIT (peek));
3017       dim = d_make_name (di, s, d_str (di) - s);
3018       if (dim == NULL)
3019         return NULL;
3020     }
3021   else
3022     {
3023       dim = d_expression (di);
3024       if (dim == NULL)
3025         return NULL;
3026     }
3027
3028   if (! d_check_char (di, '_'))
3029     return NULL;
3030
3031   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
3032                       cplus_demangle_type (di));
3033 }
3034
3035 /* <vector-type> ::= Dv <number> _ <type>
3036                  ::= Dv _ <expression> _ <type> */
3037
3038 static struct demangle_component *
3039 d_vector_type (struct d_info *di)
3040 {
3041   char peek;
3042   struct demangle_component *dim;
3043
3044   peek = d_peek_char (di);
3045   if (peek == '_')
3046     {
3047       d_advance (di, 1);
3048       dim = d_expression (di);
3049     }
3050   else
3051     dim = d_number_component (di);
3052
3053   if (dim == NULL)
3054     return NULL;
3055
3056   if (! d_check_char (di, '_'))
3057     return NULL;
3058
3059   return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
3060                       cplus_demangle_type (di));
3061 }
3062
3063 /* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
3064
3065 static struct demangle_component *
3066 d_pointer_to_member_type (struct d_info *di)
3067 {
3068   struct demangle_component *cl;
3069   struct demangle_component *mem;
3070
3071   if (! d_check_char (di, 'M'))
3072     return NULL;
3073
3074   cl = cplus_demangle_type (di);
3075   if (cl == NULL)
3076     return NULL;
3077
3078   /* The ABI says, "The type of a non-static member function is considered
3079      to be different, for the purposes of substitution, from the type of a
3080      namespace-scope or static member function whose type appears
3081      similar. The types of two non-static member functions are considered
3082      to be different, for the purposes of substitution, if the functions
3083      are members of different classes. In other words, for the purposes of
3084      substitution, the class of which the function is a member is
3085      considered part of the type of function."
3086
3087      For a pointer to member function, this call to cplus_demangle_type
3088      will end up adding a (possibly qualified) non-member function type to
3089      the substitution table, which is not correct; however, the member
3090      function type will never be used in a substitution, so putting the
3091      wrong type in the substitution table is harmless.  */
3092
3093   mem = cplus_demangle_type (di);
3094   if (mem == NULL)
3095     return NULL;
3096
3097   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
3098 }
3099
3100 /* <non-negative number> _ */
3101
3102 static int
3103 d_compact_number (struct d_info *di)
3104 {
3105   int num;
3106   if (d_peek_char (di) == '_')
3107     num = 0;
3108   else if (d_peek_char (di) == 'n')
3109     return -1;
3110   else
3111     num = d_number (di) + 1;
3112
3113   if (num < 0 || ! d_check_char (di, '_'))
3114     return -1;
3115   return num;
3116 }
3117
3118 /* <template-param> ::= T_
3119                     ::= T <(parameter-2 non-negative) number> _
3120 */
3121
3122 static struct demangle_component *
3123 d_template_param (struct d_info *di)
3124 {
3125   int param;
3126
3127   if (! d_check_char (di, 'T'))
3128     return NULL;
3129
3130   param = d_compact_number (di);
3131   if (param < 0)
3132     return NULL;
3133
3134   return d_make_template_param (di, param);
3135 }
3136
3137 /* <template-args> ::= I <template-arg>+ E  */
3138
3139 static struct demangle_component *
3140 d_template_args (struct d_info *di)
3141 {
3142   if (d_peek_char (di) != 'I'
3143       && d_peek_char (di) != 'J')
3144     return NULL;
3145   d_advance (di, 1);
3146
3147   return d_template_args_1 (di);
3148 }
3149
3150 /* <template-arg>* E  */
3151
3152 static struct demangle_component *
3153 d_template_args_1 (struct d_info *di)
3154 {
3155   struct demangle_component *hold_last_name;
3156   struct demangle_component *al;
3157   struct demangle_component **pal;
3158
3159   /* Preserve the last name we saw--don't let the template arguments
3160      clobber it, as that would give us the wrong name for a subsequent
3161      constructor or destructor.  */
3162   hold_last_name = di->last_name;
3163
3164   if (d_peek_char (di) == 'E')
3165     {
3166       /* An argument pack can be empty.  */
3167       d_advance (di, 1);
3168       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
3169     }
3170
3171   al = NULL;
3172   pal = &al;
3173   while (1)
3174     {
3175       struct demangle_component *a;
3176
3177       a = d_template_arg (di);
3178       if (a == NULL)
3179         return NULL;
3180
3181       *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
3182       if (*pal == NULL)
3183         return NULL;
3184       pal = &d_right (*pal);
3185
3186       if (d_peek_char (di) == 'E')
3187         {
3188           d_advance (di, 1);
3189           break;
3190         }
3191     }
3192
3193   di->last_name = hold_last_name;
3194
3195   return al;
3196 }
3197
3198 /* <template-arg> ::= <type>
3199                   ::= X <expression> E
3200                   ::= <expr-primary>
3201 */
3202
3203 static struct demangle_component *
3204 d_template_arg (struct d_info *di)
3205 {
3206   struct demangle_component *ret;
3207
3208   switch (d_peek_char (di))
3209     {
3210     case 'X':
3211       d_advance (di, 1);
3212       ret = d_expression (di);
3213       if (! d_check_char (di, 'E'))
3214         return NULL;
3215       return ret;
3216
3217     case 'L':
3218       return d_expr_primary (di);
3219
3220     case 'I':
3221     case 'J':
3222       /* An argument pack.  */
3223       return d_template_args (di);
3224
3225     default:
3226       return cplus_demangle_type (di);
3227     }
3228 }
3229
3230 /* Parse a sequence of expressions until we hit the terminator
3231    character.  */
3232
3233 static struct demangle_component *
3234 d_exprlist (struct d_info *di, char terminator)
3235 {
3236   struct demangle_component *list = NULL;
3237   struct demangle_component **p = &list;
3238
3239   if (d_peek_char (di) == terminator)
3240     {
3241       d_advance (di, 1);
3242       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3243     }
3244
3245   while (1)
3246     {
3247       struct demangle_component *arg = d_expression (di);
3248       if (arg == NULL)
3249         return NULL;
3250
3251       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3252       if (*p == NULL)
3253         return NULL;
3254       p = &d_right (*p);
3255
3256       if (d_peek_char (di) == terminator)
3257         {
3258           d_advance (di, 1);
3259           break;
3260         }
3261     }
3262
3263   return list;
3264 }
3265
3266 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3267    dynamic_cast, static_cast or reinterpret_cast.  */
3268
3269 static int
3270 op_is_new_cast (struct demangle_component *op)
3271 {
3272   const char *code = op->u.s_operator.op->code;
3273   return (code[1] == 'c'
3274           && (code[0] == 's' || code[0] == 'd'
3275               || code[0] == 'c' || code[0] == 'r'));
3276 }
3277
3278 /* <expression> ::= <(unary) operator-name> <expression>
3279                 ::= <(binary) operator-name> <expression> <expression>
3280                 ::= <(trinary) operator-name> <expression> <expression> <expression>
3281                 ::= cl <expression>+ E
3282                 ::= st <type>
3283                 ::= <template-param>
3284                 ::= sr <type> <unqualified-name>
3285                 ::= sr <type> <unqualified-name> <template-args>
3286                 ::= <expr-primary>
3287 */
3288
3289 static inline struct demangle_component *
3290 d_expression_1 (struct d_info *di)
3291 {
3292   char peek;
3293
3294   peek = d_peek_char (di);
3295   if (peek == 'L')
3296     return d_expr_primary (di);
3297   else if (peek == 'T')
3298     return d_template_param (di);
3299   else if (peek == 's' && d_peek_next_char (di) == 'r')
3300     {
3301       struct demangle_component *type;
3302       struct demangle_component *name;
3303
3304       d_advance (di, 2);
3305       type = cplus_demangle_type (di);
3306       name = d_unqualified_name (di);
3307       if (d_peek_char (di) != 'I')
3308         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
3309       else
3310         return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
3311                             d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3312                                          d_template_args (di)));
3313     }
3314   else if (peek == 's' && d_peek_next_char (di) == 'p')
3315     {
3316       d_advance (di, 2);
3317       return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
3318                           d_expression_1 (di), NULL);
3319     }
3320   else if (peek == 'f' && d_peek_next_char (di) == 'p')
3321     {
3322       /* Function parameter used in a late-specified return type.  */
3323       int index;
3324       d_advance (di, 2);
3325       if (d_peek_char (di) == 'T')
3326         {
3327           /* 'this' parameter.  */
3328           d_advance (di, 1);
3329           index = 0;
3330         }
3331       else
3332         {
3333           index = d_compact_number (di);
3334           if (index == INT_MAX || index == -1)
3335             return NULL;
3336           index++;
3337         }
3338       return d_make_function_param (di, index);
3339     }
3340   else if (IS_DIGIT (peek)
3341            || (peek == 'o' && d_peek_next_char (di) == 'n'))
3342     {
3343       /* We can get an unqualified name as an expression in the case of
3344          a dependent function call, i.e. decltype(f(t)).  */
3345       struct demangle_component *name;
3346
3347       if (peek == 'o')
3348         /* operator-function-id, i.e. operator+(t).  */
3349         d_advance (di, 2);
3350
3351       name = d_unqualified_name (di);
3352       if (name == NULL)
3353         return NULL;
3354       if (d_peek_char (di) == 'I')
3355         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3356                             d_template_args (di));
3357       else
3358         return name;
3359     }
3360   else if ((peek == 'i' || peek == 't')
3361            && d_peek_next_char (di) == 'l')
3362     {
3363       /* Brace-enclosed initializer list, untyped or typed.  */
3364       struct demangle_component *type = NULL;
3365       d_advance (di, 2);
3366       if (peek == 't')
3367         type = cplus_demangle_type (di);
3368       if (!d_peek_char (di) || !d_peek_next_char (di))
3369         return NULL;
3370       return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3371                           type, d_exprlist (di, 'E'));
3372     }
3373   else
3374     {
3375       struct demangle_component *op;
3376       const char *code = NULL;
3377       int args;
3378
3379       op = d_operator_name (di);
3380       if (op == NULL)
3381         return NULL;
3382
3383       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
3384         {
3385           code = op->u.s_operator.op->code;
3386           di->expansion += op->u.s_operator.op->len - 2;
3387           if (strcmp (code, "st") == 0)
3388             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3389                                 cplus_demangle_type (di));
3390         }
3391
3392       switch (op->type)
3393         {
3394         default:
3395           return NULL;
3396         case DEMANGLE_COMPONENT_OPERATOR:
3397           args = op->u.s_operator.op->args;
3398           break;
3399         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3400           args = op->u.s_extended_operator.args;
3401           break;
3402         case DEMANGLE_COMPONENT_CAST:
3403           args = 1;
3404           break;
3405         }
3406
3407       switch (args)
3408         {
3409         case 0:
3410           return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3411
3412         case 1:
3413           {
3414             struct demangle_component *operand;
3415             int suffix = 0;
3416
3417             if (code && (code[0] == 'p' || code[0] == 'm')
3418                 && code[1] == code[0])
3419               /* pp_ and mm_ are the prefix variants.  */
3420               suffix = !d_check_char (di, '_');
3421
3422             if (op->type == DEMANGLE_COMPONENT_CAST
3423                 && d_check_char (di, '_'))
3424               operand = d_exprlist (di, 'E');
3425             else if (code && !strcmp (code, "sP"))
3426               operand = d_template_args_1 (di);
3427             else
3428               operand = d_expression_1 (di);
3429
3430             if (suffix)
3431               /* Indicate the suffix variant for d_print_comp.  */
3432               operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
3433                                      operand, operand);
3434
3435             return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
3436           }
3437         case 2:
3438           {
3439             struct demangle_component *left;
3440             struct demangle_component *right;
3441
3442             if (code == NULL)
3443               return NULL;
3444             if (op_is_new_cast (op))
3445               left = cplus_demangle_type (di);
3446             else if (code[0] == 'f')
3447               /* fold-expression.  */
3448               left = d_operator_name (di);
3449             else
3450               left = d_expression_1 (di);
3451             if (!strcmp (code, "cl"))
3452               right = d_exprlist (di, 'E');
3453             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3454               {
3455                 right = d_unqualified_name (di);
3456                 if (d_peek_char (di) == 'I')
3457                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3458                                        right, d_template_args (di));
3459               }
3460             else
3461               right = d_expression_1 (di);
3462
3463             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3464                                 d_make_comp (di,
3465                                              DEMANGLE_COMPONENT_BINARY_ARGS,
3466                                              left, right));
3467           }
3468         case 3:
3469           {
3470             struct demangle_component *first;
3471             struct demangle_component *second;
3472             struct demangle_component *third;
3473
3474             if (code == NULL)
3475               return NULL;
3476             else if (!strcmp (code, "qu"))
3477               {
3478                 /* ?: expression.  */
3479                 first = d_expression_1 (di);
3480                 second = d_expression_1 (di);
3481                 third = d_expression_1 (di);
3482                 if (third == NULL)
3483                   return NULL;
3484               }
3485             else if (code[0] == 'f')
3486               {
3487                 /* fold-expression.  */
3488                 first = d_operator_name (di);
3489                 second = d_expression_1 (di);
3490                 third = d_expression_1 (di);
3491                 if (third == NULL)
3492                   return NULL;
3493               }
3494             else if (code[0] == 'n')
3495               {
3496                 /* new-expression.  */
3497                 if (code[1] != 'w' && code[1] != 'a')
3498                   return NULL;
3499                 first = d_exprlist (di, '_');
3500                 second = cplus_demangle_type (di);
3501                 if (d_peek_char (di) == 'E')
3502                   {
3503                     d_advance (di, 1);
3504                     third = NULL;
3505                   }
3506                 else if (d_peek_char (di) == 'p'
3507                          && d_peek_next_char (di) == 'i')
3508                   {
3509                     /* Parenthesized initializer.  */
3510                     d_advance (di, 2);
3511                     third = d_exprlist (di, 'E');
3512                   }
3513                 else if (d_peek_char (di) == 'i'
3514                          && d_peek_next_char (di) == 'l')
3515                   /* initializer-list.  */
3516                   third = d_expression_1 (di);
3517                 else
3518                   return NULL;
3519               }
3520             else
3521               return NULL;
3522             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3523                                 d_make_comp (di,
3524                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
3525                                              first,
3526                                              d_make_comp (di,
3527                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
3528                                                           second, third)));
3529           }
3530         default:
3531           return NULL;
3532         }
3533     }
3534 }
3535
3536 static struct demangle_component *
3537 d_expression (struct d_info *di)
3538 {
3539   struct demangle_component *ret;
3540   int was_expression = di->is_expression;
3541
3542   di->is_expression = 1;
3543   ret = d_expression_1 (di);
3544   di->is_expression = was_expression;
3545   return ret;
3546 }
3547
3548 /* <expr-primary> ::= L <type> <(value) number> E
3549                   ::= L <type> <(value) float> E
3550                   ::= L <mangled-name> E
3551 */
3552
3553 static struct demangle_component *
3554 d_expr_primary (struct d_info *di)
3555 {
3556   struct demangle_component *ret;
3557
3558   if (! d_check_char (di, 'L'))
3559     return NULL;
3560   if (d_peek_char (di) == '_'
3561       /* Workaround for G++ bug; see comment in write_template_arg.  */
3562       || d_peek_char (di) == 'Z')
3563     ret = cplus_demangle_mangled_name (di, 0);
3564   else
3565     {
3566       struct demangle_component *type;
3567       enum demangle_component_type t;
3568       const char *s;
3569
3570       type = cplus_demangle_type (di);
3571       if (type == NULL)
3572         return NULL;
3573
3574       /* If we have a type we know how to print, we aren't going to
3575          print the type name itself.  */
3576       if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3577           && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3578         di->expansion -= type->u.s_builtin.type->len;
3579
3580       /* Rather than try to interpret the literal value, we just
3581          collect it as a string.  Note that it's possible to have a
3582          floating point literal here.  The ABI specifies that the
3583          format of such literals is machine independent.  That's fine,
3584          but what's not fine is that versions of g++ up to 3.2 with
3585          -fabi-version=1 used upper case letters in the hex constant,
3586          and dumped out gcc's internal representation.  That makes it
3587          hard to tell where the constant ends, and hard to dump the
3588          constant in any readable form anyhow.  We don't attempt to
3589          handle these cases.  */
3590
3591       t = DEMANGLE_COMPONENT_LITERAL;
3592       if (d_peek_char (di) == 'n')
3593         {
3594           t = DEMANGLE_COMPONENT_LITERAL_NEG;
3595           d_advance (di, 1);
3596         }
3597       s = d_str (di);
3598       while (d_peek_char (di) != 'E')
3599         {
3600           if (d_peek_char (di) == '\0')
3601             return NULL;
3602           d_advance (di, 1);
3603         }
3604       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3605     }
3606   if (! d_check_char (di, 'E'))
3607     return NULL;
3608   return ret;
3609 }
3610
3611 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3612                 ::= Z <(function) encoding> E s [<discriminator>]
3613                 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3614 */
3615
3616 static struct demangle_component *
3617 d_local_name (struct d_info *di)
3618 {
3619   struct demangle_component *function;
3620   struct demangle_component *name;
3621
3622   if (! d_check_char (di, 'Z'))
3623     return NULL;
3624
3625   function = d_encoding (di, 0);
3626   if (!function)
3627     return NULL;
3628
3629   if (! d_check_char (di, 'E'))
3630     return NULL;
3631
3632   if (d_peek_char (di) == 's')
3633     {
3634       d_advance (di, 1);
3635       if (! d_discriminator (di))
3636         return NULL;
3637       name = d_make_name (di, "string literal", sizeof "string literal" - 1);
3638     }
3639   else
3640     {
3641       int num = -1;
3642
3643       if (d_peek_char (di) == 'd')
3644         {
3645           /* Default argument scope: d <number> _.  */
3646           d_advance (di, 1);
3647           num = d_compact_number (di);
3648           if (num < 0)
3649             return NULL;
3650         }
3651
3652       name = d_name (di);
3653
3654       if (name
3655           /* Lambdas and unnamed types have internal discriminators
3656              and are not functions.  */
3657           && name->type != DEMANGLE_COMPONENT_LAMBDA
3658           && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
3659         {
3660           /* Read and ignore an optional discriminator.  */
3661           if (! d_discriminator (di))
3662             return NULL;
3663         }
3664
3665       if (num >= 0)
3666         name = d_make_default_arg (di, num, name);
3667     }
3668
3669   /* Elide the return type of the containing function so as to not
3670      confuse the user thinking it is the return type of whatever local
3671      function we might be containing.  */
3672   if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
3673       && d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3674     d_left (d_right (function)) = NULL;
3675
3676   return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3677 }
3678
3679 /* <discriminator> ::= _ <number>    # when number < 10
3680                    ::= __ <number> _ # when number >= 10
3681
3682    <discriminator> ::= _ <number>    # when number >=10
3683    is also accepted to support gcc versions that wrongly mangled that way.
3684
3685    We demangle the discriminator, but we don't print it out.  FIXME:
3686    We should print it out in verbose mode.  */
3687
3688 static int
3689 d_discriminator (struct d_info *di)
3690 {
3691   int discrim, num_underscores = 1;
3692
3693   if (d_peek_char (di) != '_')
3694     return 1;
3695   d_advance (di, 1);
3696   if (d_peek_char (di) == '_')
3697     {
3698       ++num_underscores;
3699       d_advance (di, 1);
3700     }
3701
3702   discrim = d_number (di);
3703   if (discrim < 0)
3704     return 0;
3705   if (num_underscores > 1 && discrim >= 10)
3706     {
3707       if (d_peek_char (di) == '_')
3708         d_advance (di, 1);
3709       else
3710         return 0;
3711     }
3712
3713   return 1;
3714 }
3715
3716 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3717
3718 static struct demangle_component *
3719 d_lambda (struct d_info *di)
3720 {
3721   struct demangle_component *tl;
3722   struct demangle_component *ret;
3723   int num;
3724
3725   if (! d_check_char (di, 'U'))
3726     return NULL;
3727   if (! d_check_char (di, 'l'))
3728     return NULL;
3729
3730   tl = d_parmlist (di);
3731   if (tl == NULL)
3732     return NULL;
3733
3734   if (! d_check_char (di, 'E'))
3735     return NULL;
3736
3737   num = d_compact_number (di);
3738   if (num < 0)
3739     return NULL;
3740
3741   ret = d_make_empty (di);
3742   if (ret)
3743     {
3744       ret->type = DEMANGLE_COMPONENT_LAMBDA;
3745       ret->u.s_unary_num.sub = tl;
3746       ret->u.s_unary_num.num = num;
3747     }
3748
3749   if (! d_add_substitution (di, ret))
3750     return NULL;
3751
3752   return ret;
3753 }
3754
3755 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3756
3757 static struct demangle_component *
3758 d_unnamed_type (struct d_info *di)
3759 {
3760   struct demangle_component *ret;
3761   int num;
3762
3763   if (! d_check_char (di, 'U'))
3764     return NULL;
3765   if (! d_check_char (di, 't'))
3766     return NULL;
3767
3768   num = d_compact_number (di);
3769   if (num < 0)
3770     return NULL;
3771
3772   ret = d_make_empty (di);
3773   if (ret)
3774     {
3775       ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3776       ret->u.s_number.number = num;
3777     }
3778
3779   if (! d_add_substitution (di, ret))
3780     return NULL;
3781
3782   return ret;
3783 }
3784
3785 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3786 */
3787
3788 static struct demangle_component *
3789 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3790 {
3791   const char *suffix = d_str (di);
3792   const char *pend = suffix;
3793   struct demangle_component *n;
3794
3795   if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3796     {
3797       pend += 2;
3798       while (IS_LOWER (*pend) || *pend == '_')
3799         ++pend;
3800     }
3801   while (*pend == '.' && IS_DIGIT (pend[1]))
3802     {
3803       pend += 2;
3804       while (IS_DIGIT (*pend))
3805         ++pend;
3806     }
3807   d_advance (di, pend - suffix);
3808   n = d_make_name (di, suffix, pend - suffix);
3809   return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3810 }
3811
3812 /* Add a new substitution.  */
3813
3814 static int
3815 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3816 {
3817   if (dc == NULL)
3818     return 0;
3819   if (di->next_sub >= di->num_subs)
3820     return 0;
3821   di->subs[di->next_sub] = dc;
3822   ++di->next_sub;
3823   return 1;
3824 }
3825
3826 /* <substitution> ::= S <seq-id> _
3827                   ::= S_
3828                   ::= St
3829                   ::= Sa
3830                   ::= Sb
3831                   ::= Ss
3832                   ::= Si
3833                   ::= So
3834                   ::= Sd
3835
3836    If PREFIX is non-zero, then this type is being used as a prefix in
3837    a qualified name.  In this case, for the standard substitutions, we
3838    need to check whether we are being used as a prefix for a
3839    constructor or destructor, and return a full template name.
3840    Otherwise we will get something like std::iostream::~iostream()
3841    which does not correspond particularly well to any function which
3842    actually appears in the source.
3843 */
3844
3845 static const struct d_standard_sub_info standard_subs[] =
3846 {
3847   { 't', NL ("std"),
3848     NL ("std"),
3849     NULL, 0 },
3850   { 'a', NL ("std::allocator"),
3851     NL ("std::allocator"),
3852     NL ("allocator") },
3853   { 'b', NL ("std::basic_string"),
3854     NL ("std::basic_string"),
3855     NL ("basic_string") },
3856   { 's', NL ("std::string"),
3857     NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3858     NL ("basic_string") },
3859   { 'i', NL ("std::istream"),
3860     NL ("std::basic_istream<char, std::char_traits<char> >"),
3861     NL ("basic_istream") },
3862   { 'o', NL ("std::ostream"),
3863     NL ("std::basic_ostream<char, std::char_traits<char> >"),
3864     NL ("basic_ostream") },
3865   { 'd', NL ("std::iostream"),
3866     NL ("std::basic_iostream<char, std::char_traits<char> >"),
3867     NL ("basic_iostream") }
3868 };
3869
3870 static struct demangle_component *
3871 d_substitution (struct d_info *di, int prefix)
3872 {
3873   char c;
3874
3875   if (! d_check_char (di, 'S'))
3876     return NULL;
3877
3878   c = d_next_char (di);
3879   if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3880     {
3881       unsigned int id;
3882
3883       id = 0;
3884       if (c != '_')
3885         {
3886           do
3887             {
3888               unsigned int new_id;
3889
3890               if (IS_DIGIT (c))
3891                 new_id = id * 36 + c - '0';
3892               else if (IS_UPPER (c))
3893                 new_id = id * 36 + c - 'A' + 10;
3894               else
3895                 return NULL;
3896               if (new_id < id)
3897                 return NULL;
3898               id = new_id;
3899               c = d_next_char (di);
3900             }
3901           while (c != '_');
3902
3903           ++id;
3904         }
3905
3906       if (id >= (unsigned int) di->next_sub)
3907         return NULL;
3908
3909       return di->subs[id];
3910     }
3911   else
3912     {
3913       int verbose;
3914       const struct d_standard_sub_info *p;
3915       const struct d_standard_sub_info *pend;
3916
3917       verbose = (di->options & DMGL_VERBOSE) != 0;
3918       if (! verbose && prefix)
3919         {
3920           char peek;
3921
3922           peek = d_peek_char (di);
3923           if (peek == 'C' || peek == 'D')
3924             verbose = 1;
3925         }
3926
3927       pend = (&standard_subs[0]
3928               + sizeof standard_subs / sizeof standard_subs[0]);
3929       for (p = &standard_subs[0]; p < pend; ++p)
3930         {
3931           if (c == p->code)
3932             {
3933               const char *s;
3934               int len;
3935               struct demangle_component *dc;
3936
3937               if (p->set_last_name != NULL)
3938                 di->last_name = d_make_sub (di, p->set_last_name,
3939                                             p->set_last_name_len);
3940               if (verbose)
3941                 {
3942                   s = p->full_expansion;
3943                   len = p->full_len;
3944                 }
3945               else
3946                 {
3947                   s = p->simple_expansion;
3948                   len = p->simple_len;
3949                 }
3950               di->expansion += len;
3951               dc = d_make_sub (di, s, len);
3952               if (d_peek_char (di) == 'B')
3953                 {
3954                   /* If there are ABI tags on the abbreviation, it becomes
3955                      a substitution candidate.  */
3956                   dc = d_abi_tags (di, dc);
3957                   if (! d_add_substitution (di, dc))
3958                     return NULL;
3959                 }
3960               return dc;
3961             }
3962         }
3963
3964       return NULL;
3965     }
3966 }
3967
3968 static void
3969 d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
3970 {
3971   checkpoint->n = di->n;
3972   checkpoint->next_comp = di->next_comp;
3973   checkpoint->next_sub = di->next_sub;
3974   checkpoint->expansion = di->expansion;
3975 }
3976
3977 static void
3978 d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
3979 {
3980   di->n = checkpoint->n;
3981   di->next_comp = checkpoint->next_comp;
3982   di->next_sub = checkpoint->next_sub;
3983   di->expansion = checkpoint->expansion;
3984 }
3985
3986 /* Initialize a growable string.  */
3987
3988 static void
3989 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3990 {
3991   dgs->buf = NULL;
3992   dgs->len = 0;
3993   dgs->alc = 0;
3994   dgs->allocation_failure = 0;
3995
3996   if (estimate > 0)
3997     d_growable_string_resize (dgs, estimate);
3998 }
3999
4000 /* Grow a growable string to a given size.  */
4001
4002 static inline void
4003 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
4004 {
4005   size_t newalc;
4006   char *newbuf;
4007
4008   if (dgs->allocation_failure)
4009     return;
4010
4011   /* Start allocation at two bytes to avoid any possibility of confusion
4012      with the special value of 1 used as a return in *palc to indicate
4013      allocation failures.  */
4014   newalc = dgs->alc > 0 ? dgs->alc : 2;
4015   while (newalc < need)
4016     newalc <<= 1;
4017
4018   newbuf = (char *) realloc (dgs->buf, newalc);
4019   if (newbuf == NULL)
4020     {
4021       free (dgs->buf);
4022       dgs->buf = NULL;
4023       dgs->len = 0;
4024       dgs->alc = 0;
4025       dgs->allocation_failure = 1;
4026       return;
4027     }
4028   dgs->buf = newbuf;
4029   dgs->alc = newalc;
4030 }
4031
4032 /* Append a buffer to a growable string.  */
4033
4034 static inline void
4035 d_growable_string_append_buffer (struct d_growable_string *dgs,
4036                                  const char *s, size_t l)
4037 {
4038   size_t need;
4039
4040   need = dgs->len + l + 1;
4041   if (need > dgs->alc)
4042     d_growable_string_resize (dgs, need);
4043
4044   if (dgs->allocation_failure)
4045     return;
4046
4047   memcpy (dgs->buf + dgs->len, s, l);
4048   dgs->buf[dgs->len + l] = '\0';
4049   dgs->len += l;
4050 }
4051
4052 /* Bridge growable strings to the callback mechanism.  */
4053
4054 static void
4055 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
4056 {
4057   struct d_growable_string *dgs = (struct d_growable_string*) opaque;
4058
4059   d_growable_string_append_buffer (dgs, s, l);
4060 }
4061
4062 /* Walk the tree, counting the number of templates encountered, and
4063    the number of times a scope might be saved.  These counts will be
4064    used to allocate data structures for d_print_comp, so the logic
4065    here must mirror the logic d_print_comp will use.  It is not
4066    important that the resulting numbers are exact, so long as they
4067    are larger than the actual numbers encountered.  */
4068
4069 static void
4070 d_count_templates_scopes (struct d_print_info *dpi,
4071                           const struct demangle_component *dc)
4072 {
4073   if (dc == NULL)
4074     return;
4075
4076   switch (dc->type)
4077     {
4078     case DEMANGLE_COMPONENT_NAME:
4079     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4080     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4081     case DEMANGLE_COMPONENT_SUB_STD:
4082     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4083     case DEMANGLE_COMPONENT_OPERATOR:
4084     case DEMANGLE_COMPONENT_CHARACTER:
4085     case DEMANGLE_COMPONENT_NUMBER:
4086     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4087       break;
4088
4089     case DEMANGLE_COMPONENT_TEMPLATE:
4090       dpi->num_copy_templates++;
4091       goto recurse_left_right;
4092
4093     case DEMANGLE_COMPONENT_REFERENCE:
4094     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4095       if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4096         dpi->num_saved_scopes++;
4097       goto recurse_left_right;
4098
4099     case DEMANGLE_COMPONENT_QUAL_NAME:
4100     case DEMANGLE_COMPONENT_LOCAL_NAME:
4101     case DEMANGLE_COMPONENT_TYPED_NAME:
4102     case DEMANGLE_COMPONENT_VTABLE:
4103     case DEMANGLE_COMPONENT_VTT:
4104     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4105     case DEMANGLE_COMPONENT_TYPEINFO:
4106     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4107     case DEMANGLE_COMPONENT_TYPEINFO_FN:
4108     case DEMANGLE_COMPONENT_THUNK:
4109     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4110     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4111     case DEMANGLE_COMPONENT_JAVA_CLASS:
4112     case DEMANGLE_COMPONENT_GUARD:
4113     case DEMANGLE_COMPONENT_TLS_INIT:
4114     case DEMANGLE_COMPONENT_TLS_WRAPPER:
4115     case DEMANGLE_COMPONENT_REFTEMP:
4116     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4117     case DEMANGLE_COMPONENT_RESTRICT:
4118     case DEMANGLE_COMPONENT_VOLATILE:
4119     case DEMANGLE_COMPONENT_CONST:
4120     case DEMANGLE_COMPONENT_RESTRICT_THIS:
4121     case DEMANGLE_COMPONENT_VOLATILE_THIS:
4122     case DEMANGLE_COMPONENT_CONST_THIS:
4123     case DEMANGLE_COMPONENT_REFERENCE_THIS:
4124     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
4125     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
4126     case DEMANGLE_COMPONENT_NOEXCEPT:
4127     case DEMANGLE_COMPONENT_THROW_SPEC:
4128     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4129     case DEMANGLE_COMPONENT_POINTER:
4130     case DEMANGLE_COMPONENT_COMPLEX:
4131     case DEMANGLE_COMPONENT_IMAGINARY:
4132     case DEMANGLE_COMPONENT_VENDOR_TYPE:
4133     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4134     case DEMANGLE_COMPONENT_ARRAY_TYPE:
4135     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4136     case DEMANGLE_COMPONENT_VECTOR_TYPE:
4137     case DEMANGLE_COMPONENT_ARGLIST:
4138     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4139     case DEMANGLE_COMPONENT_TPARM_OBJ:
4140     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4141     case DEMANGLE_COMPONENT_CAST:
4142     case DEMANGLE_COMPONENT_CONVERSION:
4143     case DEMANGLE_COMPONENT_NULLARY:
4144     case DEMANGLE_COMPONENT_UNARY:
4145     case DEMANGLE_COMPONENT_BINARY:
4146     case DEMANGLE_COMPONENT_BINARY_ARGS:
4147     case DEMANGLE_COMPONENT_TRINARY:
4148     case DEMANGLE_COMPONENT_TRINARY_ARG1:
4149     case DEMANGLE_COMPONENT_TRINARY_ARG2:
4150     case DEMANGLE_COMPONENT_LITERAL:
4151     case DEMANGLE_COMPONENT_LITERAL_NEG:
4152     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4153     case DEMANGLE_COMPONENT_COMPOUND_NAME:
4154     case DEMANGLE_COMPONENT_DECLTYPE:
4155     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4156     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4157     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4158     case DEMANGLE_COMPONENT_TAGGED_NAME:
4159     case DEMANGLE_COMPONENT_CLONE:
4160     recurse_left_right:
4161       /* PR 89394 - Check for too much recursion.  */
4162       if (dpi->recursion > DEMANGLE_RECURSION_LIMIT)
4163         /* FIXME: There ought to be a way to report to the
4164            user that the recursion limit has been reached.  */
4165         return;
4166
4167       ++ dpi->recursion;
4168       d_count_templates_scopes (dpi, d_left (dc));
4169       d_count_templates_scopes (dpi, d_right (dc));
4170       -- dpi->recursion;
4171       break;
4172
4173     case DEMANGLE_COMPONENT_CTOR:
4174       d_count_templates_scopes (dpi, dc->u.s_ctor.name);
4175       break;
4176
4177     case DEMANGLE_COMPONENT_DTOR:
4178       d_count_templates_scopes (dpi, dc->u.s_dtor.name);
4179       break;
4180
4181     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4182       d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
4183       break;
4184
4185     case DEMANGLE_COMPONENT_FIXED_TYPE:
4186       d_count_templates_scopes (dpi, dc->u.s_fixed.length);
4187       break;
4188
4189     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4190     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4191       d_count_templates_scopes (dpi, d_left (dc));
4192       break;
4193
4194     case DEMANGLE_COMPONENT_LAMBDA:
4195     case DEMANGLE_COMPONENT_DEFAULT_ARG:
4196       d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
4197       break;
4198     }
4199 }
4200
4201 /* Initialize a print information structure.  */
4202
4203 static void
4204 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
4205               void *opaque, const struct demangle_component *dc)
4206 {
4207   dpi->len = 0;
4208   dpi->last_char = '\0';
4209   dpi->templates = NULL;
4210   dpi->modifiers = NULL;
4211   dpi->pack_index = 0;
4212   dpi->flush_count = 0;
4213
4214   dpi->callback = callback;
4215   dpi->opaque = opaque;
4216
4217   dpi->demangle_failure = 0;
4218   dpi->recursion = 0;
4219   dpi->is_lambda_arg = 0;
4220
4221   dpi->component_stack = NULL;
4222
4223   dpi->saved_scopes = NULL;
4224   dpi->next_saved_scope = 0;
4225   dpi->num_saved_scopes = 0;
4226
4227   dpi->copy_templates = NULL;
4228   dpi->next_copy_template = 0;
4229   dpi->num_copy_templates = 0;
4230
4231   d_count_templates_scopes (dpi, dc);
4232   /* If we did not reach the recursion limit, then reset the
4233      current recursion value back to 0, so that we can print
4234      the templates.  */
4235   if (dpi->recursion < DEMANGLE_RECURSION_LIMIT)
4236     dpi->recursion = 0;
4237   dpi->num_copy_templates *= dpi->num_saved_scopes;
4238
4239   dpi->current_template = NULL;
4240 }
4241
4242 /* Indicate that an error occurred during printing, and test for error.  */
4243
4244 static inline void
4245 d_print_error (struct d_print_info *dpi)
4246 {
4247   dpi->demangle_failure = 1;
4248 }
4249
4250 static inline int
4251 d_print_saw_error (struct d_print_info *dpi)
4252 {
4253   return dpi->demangle_failure != 0;
4254 }
4255
4256 /* Flush buffered characters to the callback.  */
4257
4258 static inline void
4259 d_print_flush (struct d_print_info *dpi)
4260 {
4261   dpi->buf[dpi->len] = '\0';
4262   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4263   dpi->len = 0;
4264   dpi->flush_count++;
4265 }
4266
4267 /* Append characters and buffers for printing.  */
4268
4269 static inline void
4270 d_append_char (struct d_print_info *dpi, char c)
4271 {
4272   if (dpi->len == sizeof (dpi->buf) - 1)
4273     d_print_flush (dpi);
4274
4275   dpi->buf[dpi->len++] = c;
4276   dpi->last_char = c;
4277 }
4278
4279 static inline void
4280 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4281 {
4282   size_t i;
4283
4284   for (i = 0; i < l; i++)
4285     d_append_char (dpi, s[i]);
4286 }
4287
4288 static inline void
4289 d_append_string (struct d_print_info *dpi, const char *s)
4290 {
4291   d_append_buffer (dpi, s, strlen (s));
4292 }
4293
4294 static inline void
4295 d_append_num (struct d_print_info *dpi, int l)
4296 {
4297   char buf[25];
4298   sprintf (buf,"%d", l);
4299   d_append_string (dpi, buf);
4300 }
4301
4302 static inline char
4303 d_last_char (struct d_print_info *dpi)
4304 {
4305   return dpi->last_char;
4306 }
4307
4308 /* Turn components into a human readable string.  OPTIONS is the
4309    options bits passed to the demangler.  DC is the tree to print.
4310    CALLBACK is a function to call to flush demangled string segments
4311    as they fill the intermediate buffer, and OPAQUE is a generalized
4312    callback argument.  On success, this returns 1.  On failure,
4313    it returns 0, indicating a bad parse.  It does not use heap
4314    memory to build an output string, so cannot encounter memory
4315    allocation failure.  */
4316
4317 CP_STATIC_IF_GLIBCPP_V3
4318 int
4319 cplus_demangle_print_callback (int options,
4320                                struct demangle_component *dc,
4321                                demangle_callbackref callback, void *opaque)
4322 {
4323   struct d_print_info dpi;
4324
4325   d_print_init (&dpi, callback, opaque, dc);
4326
4327   {
4328 #ifdef CP_DYNAMIC_ARRAYS
4329     /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4330        and flagged as errors by Address Sanitizer.  */
4331     __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
4332                                               ? dpi.num_saved_scopes : 1];
4333     __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
4334                                                 ? dpi.num_copy_templates : 1];
4335
4336     dpi.saved_scopes = scopes;
4337     dpi.copy_templates = temps;
4338 #else
4339     dpi.saved_scopes = alloca (dpi.num_saved_scopes
4340                                * sizeof (*dpi.saved_scopes));
4341     dpi.copy_templates = alloca (dpi.num_copy_templates
4342                                  * sizeof (*dpi.copy_templates));
4343 #endif
4344
4345     d_print_comp (&dpi, options, dc);
4346   }
4347
4348   d_print_flush (&dpi);
4349
4350   return ! d_print_saw_error (&dpi);
4351 }
4352
4353 /* Turn components into a human readable string.  OPTIONS is the
4354    options bits passed to the demangler.  DC is the tree to print.
4355    ESTIMATE is a guess at the length of the result.  This returns a
4356    string allocated by malloc, or NULL on error.  On success, this
4357    sets *PALC to the size of the allocated buffer.  On failure, this
4358    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4359    failure.  */
4360
4361 CP_STATIC_IF_GLIBCPP_V3
4362 char *
4363 cplus_demangle_print (int options, struct demangle_component *dc,
4364                       int estimate, size_t *palc)
4365 {
4366   struct d_growable_string dgs;
4367
4368   d_growable_string_init (&dgs, estimate);
4369
4370   if (! cplus_demangle_print_callback (options, dc,
4371                                        d_growable_string_callback_adapter,
4372                                        &dgs))
4373     {
4374       free (dgs.buf);
4375       *palc = 0;
4376       return NULL;
4377     }
4378
4379   *palc = dgs.allocation_failure ? 1 : dgs.alc;
4380   return dgs.buf;
4381 }
4382
4383 /* Returns the I'th element of the template arglist ARGS, or NULL on
4384    failure.  If I is negative, return the entire arglist.  */
4385
4386 static struct demangle_component *
4387 d_index_template_argument (struct demangle_component *args, int i)
4388 {
4389   struct demangle_component *a;
4390
4391   if (i < 0)
4392     /* Print the whole argument pack.  */
4393     return args;
4394
4395   for (a = args;
4396        a != NULL;
4397        a = d_right (a))
4398     {
4399       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4400         return NULL;
4401       if (i <= 0)
4402         break;
4403       --i;
4404     }
4405   if (i != 0 || a == NULL)
4406     return NULL;
4407
4408   return d_left (a);
4409 }
4410
4411 /* Returns the template argument from the current context indicated by DC,
4412    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
4413
4414 static struct demangle_component *
4415 d_lookup_template_argument (struct d_print_info *dpi,
4416                             const struct demangle_component *dc)
4417 {
4418   if (dpi->templates == NULL)
4419     {
4420       d_print_error (dpi);
4421       return NULL;
4422     }
4423
4424   return d_index_template_argument
4425     (d_right (dpi->templates->template_decl),
4426      dc->u.s_number.number);
4427 }
4428
4429 /* Returns a template argument pack used in DC (any will do), or NULL.  */
4430
4431 static struct demangle_component *
4432 d_find_pack (struct d_print_info *dpi,
4433              const struct demangle_component *dc)
4434 {
4435   struct demangle_component *a;
4436   if (dc == NULL)
4437     return NULL;
4438
4439   switch (dc->type)
4440     {
4441     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4442       a = d_lookup_template_argument (dpi, dc);
4443       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4444         return a;
4445       return NULL;
4446
4447     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4448       return NULL;
4449
4450     case DEMANGLE_COMPONENT_LAMBDA:
4451     case DEMANGLE_COMPONENT_NAME:
4452     case DEMANGLE_COMPONENT_TAGGED_NAME:
4453     case DEMANGLE_COMPONENT_OPERATOR:
4454     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4455     case DEMANGLE_COMPONENT_SUB_STD:
4456     case DEMANGLE_COMPONENT_CHARACTER:
4457     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4458     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4459     case DEMANGLE_COMPONENT_FIXED_TYPE:
4460     case DEMANGLE_COMPONENT_DEFAULT_ARG:
4461     case DEMANGLE_COMPONENT_NUMBER:
4462       return NULL;
4463
4464     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4465       return d_find_pack (dpi, dc->u.s_extended_operator.name);
4466     case DEMANGLE_COMPONENT_CTOR:
4467       return d_find_pack (dpi, dc->u.s_ctor.name);
4468     case DEMANGLE_COMPONENT_DTOR:
4469       return d_find_pack (dpi, dc->u.s_dtor.name);
4470
4471     default:
4472       a = d_find_pack (dpi, d_left (dc));
4473       if (a)
4474         return a;
4475       return d_find_pack (dpi, d_right (dc));
4476     }
4477 }
4478
4479 /* Returns the length of the template argument pack DC.  */
4480
4481 static int
4482 d_pack_length (const struct demangle_component *dc)
4483 {
4484   int count = 0;
4485   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4486          && d_left (dc) != NULL)
4487     {
4488       ++count;
4489       dc = d_right (dc);
4490     }
4491   return count;
4492 }
4493
4494 /* Returns the number of template args in DC, expanding any pack expansions
4495    found there.  */
4496
4497 static int
4498 d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4499 {
4500   int count = 0;
4501   for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
4502        dc = d_right (dc))
4503     {
4504       struct demangle_component *elt = d_left (dc);
4505       if (elt == NULL)
4506         break;
4507       if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4508         {
4509           struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4510           count += d_pack_length (a);
4511         }
4512       else
4513         ++count;
4514     }
4515   return count;
4516 }
4517
4518 /* DC is a component of a mangled expression.  Print it, wrapped in parens
4519    if needed.  */
4520
4521 static void
4522 d_print_subexpr (struct d_print_info *dpi, int options,
4523                  struct demangle_component *dc)
4524 {
4525   int simple = 0;
4526   if (dc->type == DEMANGLE_COMPONENT_NAME
4527       || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4528       || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
4529       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
4530     simple = 1;
4531   if (!simple)
4532     d_append_char (dpi, '(');
4533   d_print_comp (dpi, options, dc);
4534   if (!simple)
4535     d_append_char (dpi, ')');
4536 }
4537
4538 /* Save the current scope.  */
4539
4540 static void
4541 d_save_scope (struct d_print_info *dpi,
4542               const struct demangle_component *container)
4543 {
4544   struct d_saved_scope *scope;
4545   struct d_print_template *src, **link;
4546
4547   if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4548     {
4549       d_print_error (dpi);
4550       return;
4551     }
4552   scope = &dpi->saved_scopes[dpi->next_saved_scope];
4553   dpi->next_saved_scope++;
4554
4555   scope->container = container;
4556   link = &scope->templates;
4557
4558   for (src = dpi->templates; src != NULL; src = src->next)
4559     {
4560       struct d_print_template *dst;
4561
4562       if (dpi->next_copy_template >= dpi->num_copy_templates)
4563         {
4564           d_print_error (dpi);
4565           return;
4566         }
4567       dst = &dpi->copy_templates[dpi->next_copy_template];
4568       dpi->next_copy_template++;
4569
4570       dst->template_decl = src->template_decl;
4571       *link = dst;
4572       link = &dst->next;
4573     }
4574
4575   *link = NULL;
4576 }
4577
4578 /* Attempt to locate a previously saved scope.  Returns NULL if no
4579    corresponding saved scope was found.  */
4580
4581 static struct d_saved_scope *
4582 d_get_saved_scope (struct d_print_info *dpi,
4583                    const struct demangle_component *container)
4584 {
4585   int i;
4586
4587   for (i = 0; i < dpi->next_saved_scope; i++)
4588     if (dpi->saved_scopes[i].container == container)
4589       return &dpi->saved_scopes[i];
4590
4591   return NULL;
4592 }
4593
4594 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4595    return false.  */
4596
4597 static int
4598 d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
4599                                struct demangle_component *dc)
4600 {
4601   struct demangle_component *ops, *operator_, *op1, *op2;
4602   int save_idx;
4603
4604   const char *fold_code = d_left (dc)->u.s_operator.op->code;
4605   if (fold_code[0] != 'f')
4606     return 0;
4607
4608   ops = d_right (dc);
4609   operator_ = d_left (ops);
4610   op1 = d_right (ops);
4611   op2 = 0;
4612   if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4613     {
4614       op2 = d_right (op1);
4615       op1 = d_left (op1);
4616     }
4617
4618   /* Print the whole pack.  */
4619   save_idx = dpi->pack_index;
4620   dpi->pack_index = -1;
4621
4622   switch (fold_code[1])
4623     {
4624       /* Unary left fold, (... + X).  */
4625     case 'l':
4626       d_append_string (dpi, "(...");
4627       d_print_expr_op (dpi, options, operator_);
4628       d_print_subexpr (dpi, options, op1);
4629       d_append_char (dpi, ')');
4630       break;
4631
4632       /* Unary right fold, (X + ...).  */
4633     case 'r':
4634       d_append_char (dpi, '(');
4635       d_print_subexpr (dpi, options, op1);
4636       d_print_expr_op (dpi, options, operator_);
4637       d_append_string (dpi, "...)");
4638       break;
4639
4640       /* Binary left fold, (42 + ... + X).  */
4641     case 'L':
4642       /* Binary right fold, (X + ... + 42).  */
4643     case 'R':
4644       d_append_char (dpi, '(');
4645       d_print_subexpr (dpi, options, op1);
4646       d_print_expr_op (dpi, options, operator_);
4647       d_append_string (dpi, "...");
4648       d_print_expr_op (dpi, options, operator_);
4649       d_print_subexpr (dpi, options, op2);
4650       d_append_char (dpi, ')');
4651       break;
4652     }
4653
4654   dpi->pack_index = save_idx;
4655   return 1;
4656 }
4657
4658 /* Subroutine to handle components.  */
4659
4660 static void
4661 d_print_comp_inner (struct d_print_info *dpi, int options,
4662                     struct demangle_component *dc)
4663 {
4664   /* Magic variable to let reference smashing skip over the next modifier
4665      without needing to modify *dc.  */
4666   struct demangle_component *mod_inner = NULL;
4667
4668   /* Variable used to store the current templates while a previously
4669      captured scope is used.  */
4670   struct d_print_template *saved_templates;
4671
4672   /* Nonzero if templates have been stored in the above variable.  */
4673   int need_template_restore = 0;
4674
4675   if (dc == NULL)
4676     {
4677       d_print_error (dpi);
4678       return;
4679     }
4680   if (d_print_saw_error (dpi))
4681     return;
4682
4683   switch (dc->type)
4684     {
4685     case DEMANGLE_COMPONENT_NAME:
4686       if ((options & DMGL_JAVA) == 0)
4687         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4688       else
4689         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
4690       return;
4691
4692     case DEMANGLE_COMPONENT_TAGGED_NAME:
4693       d_print_comp (dpi, options, d_left (dc));
4694       d_append_string (dpi, "[abi:");
4695       d_print_comp (dpi, options, d_right (dc));
4696       d_append_char (dpi, ']');
4697       return;
4698
4699     case DEMANGLE_COMPONENT_QUAL_NAME:
4700     case DEMANGLE_COMPONENT_LOCAL_NAME:
4701       d_print_comp (dpi, options, d_left (dc));
4702       if ((options & DMGL_JAVA) == 0)
4703         d_append_string (dpi, "::");
4704       else
4705         d_append_char (dpi, '.');
4706       {
4707         struct demangle_component *local_name = d_right (dc);
4708         if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4709           {
4710             d_append_string (dpi, "{default arg#");
4711             d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4712             d_append_string (dpi, "}::");
4713             local_name = local_name->u.s_unary_num.sub;
4714           }
4715         d_print_comp (dpi, options, local_name);
4716       }
4717       return;
4718
4719     case DEMANGLE_COMPONENT_TYPED_NAME:
4720       {
4721         struct d_print_mod *hold_modifiers;
4722         struct demangle_component *typed_name;
4723         struct d_print_mod adpm[4];
4724         unsigned int i;
4725         struct d_print_template dpt;
4726
4727         /* Pass the name down to the type so that it can be printed in
4728            the right place for the type.  We also have to pass down
4729            any CV-qualifiers, which apply to the this parameter.  */
4730         hold_modifiers = dpi->modifiers;
4731         dpi->modifiers = 0;
4732         i = 0;
4733         typed_name = d_left (dc);
4734         while (typed_name != NULL)
4735           {
4736             if (i >= sizeof adpm / sizeof adpm[0])
4737               {
4738                 d_print_error (dpi);
4739                 return;
4740               }
4741
4742             adpm[i].next = dpi->modifiers;
4743             dpi->modifiers = &adpm[i];
4744             adpm[i].mod = typed_name;
4745             adpm[i].printed = 0;
4746             adpm[i].templates = dpi->templates;
4747             ++i;
4748
4749             if (!is_fnqual_component_type (typed_name->type))
4750               break;
4751
4752             typed_name = d_left (typed_name);
4753           }
4754
4755         if (typed_name == NULL)
4756           {
4757             d_print_error (dpi);
4758             return;
4759           }
4760
4761         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4762            there may be CV-qualifiers on its right argument which
4763            really apply here; this happens when parsing a class that
4764            is local to a function.  */
4765         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4766           {
4767             typed_name = d_right (typed_name);
4768             if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4769               typed_name = typed_name->u.s_unary_num.sub;
4770             while (typed_name != NULL
4771                    && is_fnqual_component_type (typed_name->type))
4772               {
4773                 if (i >= sizeof adpm / sizeof adpm[0])
4774                   {
4775                     d_print_error (dpi);
4776                     return;
4777                   }
4778
4779                 adpm[i] = adpm[i - 1];
4780                 adpm[i].next = &adpm[i - 1];
4781                 dpi->modifiers = &adpm[i];
4782
4783                 adpm[i - 1].mod = typed_name;
4784                 adpm[i - 1].printed = 0;
4785                 adpm[i - 1].templates = dpi->templates;
4786                 ++i;
4787
4788                 typed_name = d_left (typed_name);
4789               }
4790             if (typed_name == NULL)
4791               {
4792                 d_print_error (dpi);
4793                 return;
4794               }
4795           }
4796
4797         /* If typed_name is a template, then it applies to the
4798            function type as well.  */
4799         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4800           {
4801             dpt.next = dpi->templates;
4802             dpi->templates = &dpt;
4803             dpt.template_decl = typed_name;
4804           }
4805
4806         d_print_comp (dpi, options, d_right (dc));
4807
4808         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4809           dpi->templates = dpt.next;
4810
4811         /* If the modifiers didn't get printed by the type, print them
4812            now.  */
4813         while (i > 0)
4814           {
4815             --i;
4816             if (! adpm[i].printed)
4817               {
4818                 d_append_char (dpi, ' ');
4819                 d_print_mod (dpi, options, adpm[i].mod);
4820               }
4821           }
4822
4823         dpi->modifiers = hold_modifiers;
4824
4825         return;
4826       }
4827
4828     case DEMANGLE_COMPONENT_TEMPLATE:
4829       {
4830         struct d_print_mod *hold_dpm;
4831         struct demangle_component *dcl;
4832         const struct demangle_component *hold_current;
4833
4834         /* This template may need to be referenced by a cast operator
4835            contained in its subtree.  */
4836         hold_current = dpi->current_template;
4837         dpi->current_template = dc;
4838
4839         /* Don't push modifiers into a template definition.  Doing so
4840            could give the wrong definition for a template argument.
4841            Instead, treat the template essentially as a name.  */
4842
4843         hold_dpm = dpi->modifiers;
4844         dpi->modifiers = NULL;
4845
4846         dcl = d_left (dc);
4847
4848         if ((options & DMGL_JAVA) != 0
4849             && dcl->type == DEMANGLE_COMPONENT_NAME
4850             && dcl->u.s_name.len == 6
4851             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4852           {
4853             /* Special-case Java arrays, so that JArray<TYPE> appears
4854                instead as TYPE[].  */
4855
4856             d_print_comp (dpi, options, d_right (dc));
4857             d_append_string (dpi, "[]");
4858           }
4859         else
4860           {
4861             d_print_comp (dpi, options, dcl);
4862             if (d_last_char (dpi) == '<')
4863               d_append_char (dpi, ' ');
4864             d_append_char (dpi, '<');
4865             d_print_comp (dpi, options, d_right (dc));
4866             /* Avoid generating two consecutive '>' characters, to avoid
4867                the C++ syntactic ambiguity.  */
4868             if (d_last_char (dpi) == '>')
4869               d_append_char (dpi, ' ');
4870             d_append_char (dpi, '>');
4871           }
4872
4873         dpi->modifiers = hold_dpm;
4874         dpi->current_template = hold_current;
4875
4876         return;
4877       }
4878
4879     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4880       if (dpi->is_lambda_arg)
4881         {
4882           /* Show the template parm index, as that's how g++ displays
4883              these, and future proofs us against potential
4884              '[]<typename T> (T *a, T *b) {...}'.  */
4885           d_append_buffer (dpi, "auto:", 5);
4886           d_append_num (dpi, dc->u.s_number.number + 1);
4887         }
4888       else
4889         {
4890           struct d_print_template *hold_dpt;
4891           struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4892
4893           if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4894             a = d_index_template_argument (a, dpi->pack_index);
4895
4896           if (a == NULL)
4897             {
4898               d_print_error (dpi);
4899               return;
4900             }
4901
4902           /* While processing this parameter, we need to pop the list
4903              of templates.  This is because the template parameter may
4904              itself be a reference to a parameter of an outer
4905              template.  */
4906
4907           hold_dpt = dpi->templates;
4908           dpi->templates = hold_dpt->next;
4909
4910           d_print_comp (dpi, options, a);
4911
4912           dpi->templates = hold_dpt;
4913         }
4914       return;
4915
4916     case DEMANGLE_COMPONENT_TPARM_OBJ:
4917       d_append_string (dpi, "template parameter object for ");
4918       d_print_comp (dpi, options, d_left (dc));
4919       return;
4920
4921     case DEMANGLE_COMPONENT_CTOR:
4922       d_print_comp (dpi, options, dc->u.s_ctor.name);
4923       return;
4924
4925     case DEMANGLE_COMPONENT_DTOR:
4926       d_append_char (dpi, '~');
4927       d_print_comp (dpi, options, dc->u.s_dtor.name);
4928       return;
4929
4930     case DEMANGLE_COMPONENT_VTABLE:
4931       d_append_string (dpi, "vtable for ");
4932       d_print_comp (dpi, options, d_left (dc));
4933       return;
4934
4935     case DEMANGLE_COMPONENT_VTT:
4936       d_append_string (dpi, "VTT for ");
4937       d_print_comp (dpi, options, d_left (dc));
4938       return;
4939
4940     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4941       d_append_string (dpi, "construction vtable for ");
4942       d_print_comp (dpi, options, d_left (dc));
4943       d_append_string (dpi, "-in-");
4944       d_print_comp (dpi, options, d_right (dc));
4945       return;
4946
4947     case DEMANGLE_COMPONENT_TYPEINFO:
4948       d_append_string (dpi, "typeinfo for ");
4949       d_print_comp (dpi, options, d_left (dc));
4950       return;
4951
4952     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4953       d_append_string (dpi, "typeinfo name for ");
4954       d_print_comp (dpi, options, d_left (dc));
4955       return;
4956
4957     case DEMANGLE_COMPONENT_TYPEINFO_FN:
4958       d_append_string (dpi, "typeinfo fn for ");
4959       d_print_comp (dpi, options, d_left (dc));
4960       return;
4961
4962     case DEMANGLE_COMPONENT_THUNK:
4963       d_append_string (dpi, "non-virtual thunk to ");
4964       d_print_comp (dpi, options, d_left (dc));
4965       return;
4966
4967     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4968       d_append_string (dpi, "virtual thunk to ");
4969       d_print_comp (dpi, options, d_left (dc));
4970       return;
4971
4972     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4973       d_append_string (dpi, "covariant return thunk to ");
4974       d_print_comp (dpi, options, d_left (dc));
4975       return;
4976
4977     case DEMANGLE_COMPONENT_JAVA_CLASS:
4978       d_append_string (dpi, "java Class for ");
4979       d_print_comp (dpi, options, d_left (dc));
4980       return;
4981
4982     case DEMANGLE_COMPONENT_GUARD:
4983       d_append_string (dpi, "guard variable for ");
4984       d_print_comp (dpi, options, d_left (dc));
4985       return;
4986
4987     case DEMANGLE_COMPONENT_TLS_INIT:
4988       d_append_string (dpi, "TLS init function for ");
4989       d_print_comp (dpi, options, d_left (dc));
4990       return;
4991
4992     case DEMANGLE_COMPONENT_TLS_WRAPPER:
4993       d_append_string (dpi, "TLS wrapper function for ");
4994       d_print_comp (dpi, options, d_left (dc));
4995       return;
4996
4997     case DEMANGLE_COMPONENT_REFTEMP:
4998       d_append_string (dpi, "reference temporary #");
4999       d_print_comp (dpi, options, d_right (dc));
5000       d_append_string (dpi, " for ");
5001       d_print_comp (dpi, options, d_left (dc));
5002       return;
5003
5004     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
5005       d_append_string (dpi, "hidden alias for ");
5006       d_print_comp (dpi, options, d_left (dc));
5007       return;
5008
5009     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
5010       d_append_string (dpi, "transaction clone for ");
5011       d_print_comp (dpi, options, d_left (dc));
5012       return;
5013
5014     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
5015       d_append_string (dpi, "non-transaction clone for ");
5016       d_print_comp (dpi, options, d_left (dc));
5017       return;
5018
5019     case DEMANGLE_COMPONENT_SUB_STD:
5020       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
5021       return;
5022
5023     case DEMANGLE_COMPONENT_RESTRICT:
5024     case DEMANGLE_COMPONENT_VOLATILE:
5025     case DEMANGLE_COMPONENT_CONST:
5026       {
5027         struct d_print_mod *pdpm;
5028
5029         /* When printing arrays, it's possible to have cases where the
5030            same CV-qualifier gets pushed on the stack multiple times.
5031            We only need to print it once.  */
5032
5033         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
5034           {
5035             if (! pdpm->printed)
5036               {
5037                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
5038                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
5039                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
5040                   break;
5041                 if (pdpm->mod->type == dc->type)
5042                   {
5043                     d_print_comp (dpi, options, d_left (dc));
5044                     return;
5045                   }
5046               }
5047           }
5048       }
5049       goto modifier;
5050
5051     case DEMANGLE_COMPONENT_REFERENCE:
5052     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5053       {
5054         /* Handle reference smashing: & + && = &.  */
5055         struct demangle_component *sub = d_left (dc);
5056         if (!dpi->is_lambda_arg
5057             && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
5058           {
5059             struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
5060             struct demangle_component *a;
5061
5062             if (scope == NULL)
5063               {
5064                 /* This is the first time SUB has been traversed.
5065                    We need to capture the current templates so
5066                    they can be restored if SUB is reentered as a
5067                    substitution.  */
5068                 d_save_scope (dpi, sub);
5069                 if (d_print_saw_error (dpi))
5070                   return;
5071               }
5072             else
5073               {
5074                 const struct d_component_stack *dcse;
5075                 int found_self_or_parent = 0;
5076
5077                 /* This traversal is reentering SUB as a substition.
5078                    If we are not beneath SUB or DC in the tree then we
5079                    need to restore SUB's template stack temporarily.  */
5080                 for (dcse = dpi->component_stack; dcse != NULL;
5081                      dcse = dcse->parent)
5082                   {
5083                     if (dcse->dc == sub
5084                         || (dcse->dc == dc
5085                             && dcse != dpi->component_stack))
5086                       {
5087                         found_self_or_parent = 1;
5088                         break;
5089                       }
5090                   }
5091
5092                 if (!found_self_or_parent)
5093                   {
5094                     saved_templates = dpi->templates;
5095                     dpi->templates = scope->templates;
5096                     need_template_restore = 1;
5097                   }
5098               }
5099
5100             a = d_lookup_template_argument (dpi, sub);
5101             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5102               a = d_index_template_argument (a, dpi->pack_index);
5103
5104             if (a == NULL)
5105               {
5106                 if (need_template_restore)
5107                   dpi->templates = saved_templates;
5108
5109                 d_print_error (dpi);
5110                 return;
5111               }
5112
5113             sub = a;
5114           }
5115
5116         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
5117             || sub->type == dc->type)
5118           dc = sub;
5119         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
5120           mod_inner = d_left (sub);
5121       }
5122       /* Fall through.  */
5123
5124     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5125     case DEMANGLE_COMPONENT_POINTER:
5126     case DEMANGLE_COMPONENT_COMPLEX:
5127     case DEMANGLE_COMPONENT_IMAGINARY:
5128     FNQUAL_COMPONENT_CASE:
5129     modifier:
5130       {
5131         /* We keep a list of modifiers on the stack.  */
5132         struct d_print_mod dpm;
5133
5134         dpm.next = dpi->modifiers;
5135         dpi->modifiers = &dpm;
5136         dpm.mod = dc;
5137         dpm.printed = 0;
5138         dpm.templates = dpi->templates;
5139
5140         if (!mod_inner)
5141           mod_inner = d_left (dc);
5142
5143         d_print_comp (dpi, options, mod_inner);
5144
5145         /* If the modifier didn't get printed by the type, print it
5146            now.  */
5147         if (! dpm.printed)
5148           d_print_mod (dpi, options, dc);
5149
5150         dpi->modifiers = dpm.next;
5151
5152         if (need_template_restore)
5153           dpi->templates = saved_templates;
5154
5155         return;
5156       }
5157
5158     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5159       if ((options & DMGL_JAVA) == 0)
5160         d_append_buffer (dpi, dc->u.s_builtin.type->name,
5161                          dc->u.s_builtin.type->len);
5162       else
5163         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5164                          dc->u.s_builtin.type->java_len);
5165       return;
5166
5167     case DEMANGLE_COMPONENT_VENDOR_TYPE:
5168       d_print_comp (dpi, options, d_left (dc));
5169       return;
5170
5171     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5172       {
5173         if ((options & DMGL_RET_POSTFIX) != 0)
5174           d_print_function_type (dpi,
5175                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5176                                  dc, dpi->modifiers);
5177
5178         /* Print return type if present */
5179         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5180           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5181                         d_left (dc));
5182         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
5183           {
5184             struct d_print_mod dpm;
5185
5186             /* We must pass this type down as a modifier in order to
5187                print it in the right location.  */
5188             dpm.next = dpi->modifiers;
5189             dpi->modifiers = &dpm;
5190             dpm.mod = dc;
5191             dpm.printed = 0;
5192             dpm.templates = dpi->templates;
5193
5194             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5195                           d_left (dc));
5196
5197             dpi->modifiers = dpm.next;
5198
5199             if (dpm.printed)
5200               return;
5201
5202             /* In standard prefix notation, there is a space between the
5203                return type and the function signature.  */
5204             if ((options & DMGL_RET_POSTFIX) == 0)
5205               d_append_char (dpi, ' ');
5206           }
5207
5208         if ((options & DMGL_RET_POSTFIX) == 0)
5209           d_print_function_type (dpi,
5210                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5211                                  dc, dpi->modifiers);
5212
5213         return;
5214       }
5215
5216     case DEMANGLE_COMPONENT_ARRAY_TYPE:
5217       {
5218         struct d_print_mod *hold_modifiers;
5219         struct d_print_mod adpm[4];
5220         unsigned int i;
5221         struct d_print_mod *pdpm;
5222
5223         /* We must pass this type down as a modifier in order to print
5224            multi-dimensional arrays correctly.  If the array itself is
5225            CV-qualified, we act as though the element type were
5226            CV-qualified.  We do this by copying the modifiers down
5227            rather than fiddling pointers, so that we don't wind up
5228            with a d_print_mod higher on the stack pointing into our
5229            stack frame after we return.  */
5230
5231         hold_modifiers = dpi->modifiers;
5232
5233         adpm[0].next = hold_modifiers;
5234         dpi->modifiers = &adpm[0];
5235         adpm[0].mod = dc;
5236         adpm[0].printed = 0;
5237         adpm[0].templates = dpi->templates;
5238
5239         i = 1;
5240         pdpm = hold_modifiers;
5241         while (pdpm != NULL
5242                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
5243                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
5244                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
5245           {
5246             if (! pdpm->printed)
5247               {
5248                 if (i >= sizeof adpm / sizeof adpm[0])
5249                   {
5250                     d_print_error (dpi);
5251                     return;
5252                   }
5253
5254                 adpm[i] = *pdpm;
5255                 adpm[i].next = dpi->modifiers;
5256                 dpi->modifiers = &adpm[i];
5257                 pdpm->printed = 1;
5258                 ++i;
5259               }
5260
5261             pdpm = pdpm->next;
5262           }
5263
5264         d_print_comp (dpi, options, d_right (dc));
5265
5266         dpi->modifiers = hold_modifiers;
5267
5268         if (adpm[0].printed)
5269           return;
5270
5271         while (i > 1)
5272           {
5273             --i;
5274             d_print_mod (dpi, options, adpm[i].mod);
5275           }
5276
5277         d_print_array_type (dpi, options, dc, dpi->modifiers);
5278
5279         return;
5280       }
5281
5282     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5283     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5284       {
5285         struct d_print_mod dpm;
5286
5287         dpm.next = dpi->modifiers;
5288         dpi->modifiers = &dpm;
5289         dpm.mod = dc;
5290         dpm.printed = 0;
5291         dpm.templates = dpi->templates;
5292
5293         d_print_comp (dpi, options, d_right (dc));
5294
5295         /* If the modifier didn't get printed by the type, print it
5296            now.  */
5297         if (! dpm.printed)
5298           d_print_mod (dpi, options, dc);
5299
5300         dpi->modifiers = dpm.next;
5301
5302         return;
5303       }
5304
5305     case DEMANGLE_COMPONENT_FIXED_TYPE:
5306       if (dc->u.s_fixed.sat)
5307         d_append_string (dpi, "_Sat ");
5308       /* Don't print "int _Accum".  */
5309       if (dc->u.s_fixed.length->u.s_builtin.type
5310           != &cplus_demangle_builtin_types['i'-'a'])
5311         {
5312           d_print_comp (dpi, options, dc->u.s_fixed.length);
5313           d_append_char (dpi, ' ');
5314         }
5315       if (dc->u.s_fixed.accum)
5316         d_append_string (dpi, "_Accum");
5317       else
5318         d_append_string (dpi, "_Fract");
5319       return;
5320
5321     case DEMANGLE_COMPONENT_ARGLIST:
5322     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
5323       if (d_left (dc) != NULL)
5324         d_print_comp (dpi, options, d_left (dc));
5325       if (d_right (dc) != NULL)
5326         {
5327           size_t len;
5328           unsigned long int flush_count;
5329           /* Make sure ", " isn't flushed by d_append_string, otherwise
5330              dpi->len -= 2 wouldn't work.  */
5331           if (dpi->len >= sizeof (dpi->buf) - 2)
5332             d_print_flush (dpi);
5333           d_append_string (dpi, ", ");
5334           len = dpi->len;
5335           flush_count = dpi->flush_count;
5336           d_print_comp (dpi, options, d_right (dc));
5337           /* If that didn't print anything (which can happen with empty
5338              template argument packs), remove the comma and space.  */
5339           if (dpi->flush_count == flush_count && dpi->len == len)
5340             dpi->len -= 2;
5341         }
5342       return;
5343
5344     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5345       {
5346         struct demangle_component *type = d_left (dc);
5347         struct demangle_component *list = d_right (dc);
5348
5349         if (type)
5350           d_print_comp (dpi, options, type);
5351         d_append_char (dpi, '{');
5352         d_print_comp (dpi, options, list);
5353         d_append_char (dpi, '}');
5354       }
5355       return;
5356
5357     case DEMANGLE_COMPONENT_OPERATOR:
5358       {
5359         const struct demangle_operator_info *op = dc->u.s_operator.op;
5360         int len = op->len;
5361
5362         d_append_string (dpi, "operator");
5363         /* Add a space before new/delete.  */
5364         if (IS_LOWER (op->name[0]))
5365           d_append_char (dpi, ' ');
5366         /* Omit a trailing space.  */
5367         if (op->name[len-1] == ' ')
5368           --len;
5369         d_append_buffer (dpi, op->name, len);
5370         return;
5371       }
5372
5373     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
5374       d_append_string (dpi, "operator ");
5375       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
5376       return;
5377
5378     case DEMANGLE_COMPONENT_CONVERSION:
5379       d_append_string (dpi, "operator ");
5380       d_print_conversion (dpi, options, dc);
5381       return;
5382
5383     case DEMANGLE_COMPONENT_NULLARY:
5384       d_print_expr_op (dpi, options, d_left (dc));
5385       return;
5386
5387     case DEMANGLE_COMPONENT_UNARY:
5388       {
5389         struct demangle_component *op = d_left (dc);
5390         struct demangle_component *operand = d_right (dc);
5391         const char *code = NULL;
5392
5393         if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5394           {
5395             code = op->u.s_operator.op->code;
5396             if (!strcmp (code, "ad"))
5397               {
5398                 /* Don't print the argument list for the address of a
5399                    function.  */
5400                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5401                     && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5402                     && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5403                   operand = d_left (operand);
5404               }
5405             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5406               {
5407                 /* This indicates a suffix operator.  */
5408                 operand = d_left (operand);
5409                 d_print_subexpr (dpi, options, operand);
5410                 d_print_expr_op (dpi, options, op);
5411                 return;
5412               }
5413           }
5414
5415         /* For sizeof..., just print the pack length.  */
5416         if (code && !strcmp (code, "sZ"))
5417           {
5418             struct demangle_component *a = d_find_pack (dpi, operand);
5419             int len = d_pack_length (a);
5420             d_append_num (dpi, len);
5421             return;
5422           }
5423         else if (code && !strcmp (code, "sP"))
5424           {
5425             int len = d_args_length (dpi, operand);
5426             d_append_num (dpi, len);
5427             return;
5428           }
5429
5430         if (op->type != DEMANGLE_COMPONENT_CAST)
5431           d_print_expr_op (dpi, options, op);
5432         else
5433           {
5434             d_append_char (dpi, '(');
5435             d_print_cast (dpi, options, op);
5436             d_append_char (dpi, ')');
5437           }
5438         if (code && !strcmp (code, "gs"))
5439           /* Avoid parens after '::'.  */
5440           d_print_comp (dpi, options, operand);
5441         else if (code && !strcmp (code, "st"))
5442           /* Always print parens for sizeof (type).  */
5443           {
5444             d_append_char (dpi, '(');
5445             d_print_comp (dpi, options, operand);
5446             d_append_char (dpi, ')');
5447           }
5448         else
5449           d_print_subexpr (dpi, options, operand);
5450       }
5451       return;
5452
5453     case DEMANGLE_COMPONENT_BINARY:
5454       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
5455         {
5456           d_print_error (dpi);
5457           return;
5458         }
5459
5460       if (op_is_new_cast (d_left (dc)))
5461         {
5462           d_print_expr_op (dpi, options, d_left (dc));
5463           d_append_char (dpi, '<');
5464           d_print_comp (dpi, options, d_left (d_right (dc)));
5465           d_append_string (dpi, ">(");
5466           d_print_comp (dpi, options, d_right (d_right (dc)));
5467           d_append_char (dpi, ')');
5468           return;
5469         }
5470
5471       if (d_maybe_print_fold_expression (dpi, options, dc))
5472         return;
5473
5474       /* We wrap an expression which uses the greater-than operator in
5475          an extra layer of parens so that it does not get confused
5476          with the '>' which ends the template parameters.  */
5477       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5478           && d_left (dc)->u.s_operator.op->len == 1
5479           && d_left (dc)->u.s_operator.op->name[0] == '>')
5480         d_append_char (dpi, '(');
5481
5482       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5483           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5484         {
5485           /* Function call used in an expression should not have printed types
5486              of the function arguments.  Values of the function arguments still
5487              get printed below.  */
5488
5489           const struct demangle_component *func = d_left (d_right (dc));
5490
5491           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5492             d_print_error (dpi);
5493           d_print_subexpr (dpi, options, d_left (func));
5494         }
5495       else
5496         d_print_subexpr (dpi, options, d_left (d_right (dc)));
5497       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5498         {
5499           d_append_char (dpi, '[');
5500           d_print_comp (dpi, options, d_right (d_right (dc)));
5501           d_append_char (dpi, ']');
5502         }
5503       else
5504         {
5505           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
5506             d_print_expr_op (dpi, options, d_left (dc));
5507           d_print_subexpr (dpi, options, d_right (d_right (dc)));
5508         }
5509
5510       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5511           && d_left (dc)->u.s_operator.op->len == 1
5512           && d_left (dc)->u.s_operator.op->name[0] == '>')
5513         d_append_char (dpi, ')');
5514
5515       return;
5516
5517     case DEMANGLE_COMPONENT_BINARY_ARGS:
5518       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
5519       d_print_error (dpi);
5520       return;
5521
5522     case DEMANGLE_COMPONENT_TRINARY:
5523       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5524           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
5525         {
5526           d_print_error (dpi);
5527           return;
5528         }
5529       if (d_maybe_print_fold_expression (dpi, options, dc))
5530         return;
5531       {
5532         struct demangle_component *op = d_left (dc);
5533         struct demangle_component *first = d_left (d_right (dc));
5534         struct demangle_component *second = d_left (d_right (d_right (dc)));
5535         struct demangle_component *third = d_right (d_right (d_right (dc)));
5536
5537         if (!strcmp (op->u.s_operator.op->code, "qu"))
5538           {
5539             d_print_subexpr (dpi, options, first);
5540             d_print_expr_op (dpi, options, op);
5541             d_print_subexpr (dpi, options, second);
5542             d_append_string (dpi, " : ");
5543             d_print_subexpr (dpi, options, third);
5544           }
5545         else
5546           {
5547             d_append_string (dpi, "new ");
5548             if (d_left (first) != NULL)
5549               {
5550                 d_print_subexpr (dpi, options, first);
5551                 d_append_char (dpi, ' ');
5552               }
5553             d_print_comp (dpi, options, second);
5554             if (third)
5555               d_print_subexpr (dpi, options, third);
5556           }
5557       }
5558       return;
5559
5560     case DEMANGLE_COMPONENT_TRINARY_ARG1:
5561     case DEMANGLE_COMPONENT_TRINARY_ARG2:
5562       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
5563       d_print_error (dpi);
5564       return;
5565
5566     case DEMANGLE_COMPONENT_LITERAL:
5567     case DEMANGLE_COMPONENT_LITERAL_NEG:
5568       {
5569         enum d_builtin_type_print tp;
5570
5571         /* For some builtin types, produce simpler output.  */
5572         tp = D_PRINT_DEFAULT;
5573         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5574           {
5575             tp = d_left (dc)->u.s_builtin.type->print;
5576             switch (tp)
5577               {
5578               case D_PRINT_INT:
5579               case D_PRINT_UNSIGNED:
5580               case D_PRINT_LONG:
5581               case D_PRINT_UNSIGNED_LONG:
5582               case D_PRINT_LONG_LONG:
5583               case D_PRINT_UNSIGNED_LONG_LONG:
5584                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5585                   {
5586                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5587                       d_append_char (dpi, '-');
5588                     d_print_comp (dpi, options, d_right (dc));
5589                     switch (tp)
5590                       {
5591                       default:
5592                         break;
5593                       case D_PRINT_UNSIGNED:
5594                         d_append_char (dpi, 'u');
5595                         break;
5596                       case D_PRINT_LONG:
5597                         d_append_char (dpi, 'l');
5598                         break;
5599                       case D_PRINT_UNSIGNED_LONG:
5600                         d_append_string (dpi, "ul");
5601                         break;
5602                       case D_PRINT_LONG_LONG:
5603                         d_append_string (dpi, "ll");
5604                         break;
5605                       case D_PRINT_UNSIGNED_LONG_LONG:
5606                         d_append_string (dpi, "ull");
5607                         break;
5608                       }
5609                     return;
5610                   }
5611                 break;
5612
5613               case D_PRINT_BOOL:
5614                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5615                     && d_right (dc)->u.s_name.len == 1
5616                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
5617                   {
5618                     switch (d_right (dc)->u.s_name.s[0])
5619                       {
5620                       case '0':
5621                         d_append_string (dpi, "false");
5622                         return;
5623                       case '1':
5624                         d_append_string (dpi, "true");
5625                         return;
5626                       default:
5627                         break;
5628                       }
5629                   }
5630                 break;
5631
5632               default:
5633                 break;
5634               }
5635           }
5636
5637         d_append_char (dpi, '(');
5638         d_print_comp (dpi, options, d_left (dc));
5639         d_append_char (dpi, ')');
5640         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5641           d_append_char (dpi, '-');
5642         if (tp == D_PRINT_FLOAT)
5643           d_append_char (dpi, '[');
5644         d_print_comp (dpi, options, d_right (dc));
5645         if (tp == D_PRINT_FLOAT)
5646           d_append_char (dpi, ']');
5647       }
5648       return;
5649
5650     case DEMANGLE_COMPONENT_NUMBER:
5651       d_append_num (dpi, dc->u.s_number.number);
5652       return;
5653
5654     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5655       d_append_string (dpi, "java resource ");
5656       d_print_comp (dpi, options, d_left (dc));
5657       return;
5658
5659     case DEMANGLE_COMPONENT_COMPOUND_NAME:
5660       d_print_comp (dpi, options, d_left (dc));
5661       d_print_comp (dpi, options, d_right (dc));
5662       return;
5663
5664     case DEMANGLE_COMPONENT_CHARACTER:
5665       d_append_char (dpi, dc->u.s_character.character);
5666       return;
5667
5668     case DEMANGLE_COMPONENT_DECLTYPE:
5669       d_append_string (dpi, "decltype (");
5670       d_print_comp (dpi, options, d_left (dc));
5671       d_append_char (dpi, ')');
5672       return;
5673
5674     case DEMANGLE_COMPONENT_PACK_EXPANSION:
5675       {
5676         int len;
5677         int i;
5678         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5679         if (a == NULL)
5680           {
5681             /* d_find_pack won't find anything if the only packs involved
5682                in this expansion are function parameter packs; in that
5683                case, just print the pattern and "...".  */
5684             d_print_subexpr (dpi, options, d_left (dc));
5685             d_append_string (dpi, "...");
5686             return;
5687           }
5688
5689         len = d_pack_length (a);
5690         dc = d_left (dc);
5691         for (i = 0; i < len; ++i)
5692           {
5693             dpi->pack_index = i;
5694             d_print_comp (dpi, options, dc);
5695             if (i < len-1)
5696               d_append_string (dpi, ", ");
5697           }
5698       }
5699       return;
5700
5701     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
5702       {
5703         long num = dc->u.s_number.number;
5704         if (num == 0)
5705           d_append_string (dpi, "this");
5706         else
5707           {
5708             d_append_string (dpi, "{parm#");
5709             d_append_num (dpi, num);
5710             d_append_char (dpi, '}');
5711           }
5712       }
5713       return;
5714
5715     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5716       d_append_string (dpi, "global constructors keyed to ");
5717       d_print_comp (dpi, options, dc->u.s_binary.left);
5718       return;
5719
5720     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5721       d_append_string (dpi, "global destructors keyed to ");
5722       d_print_comp (dpi, options, dc->u.s_binary.left);
5723       return;
5724
5725     case DEMANGLE_COMPONENT_LAMBDA:
5726       d_append_string (dpi, "{lambda(");
5727       /* Generic lambda auto parms are mangled as the template type
5728          parm they are.  */
5729       dpi->is_lambda_arg++;
5730       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
5731       dpi->is_lambda_arg--;
5732       d_append_string (dpi, ")#");
5733       d_append_num (dpi, dc->u.s_unary_num.num + 1);
5734       d_append_char (dpi, '}');
5735       return;
5736
5737     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5738       d_append_string (dpi, "{unnamed type#");
5739       d_append_num (dpi, dc->u.s_number.number + 1);
5740       d_append_char (dpi, '}');
5741       return;
5742
5743     case DEMANGLE_COMPONENT_CLONE:
5744       d_print_comp (dpi, options, d_left (dc));
5745       d_append_string (dpi, " [clone ");
5746       d_print_comp (dpi, options, d_right (dc));
5747       d_append_char (dpi, ']');
5748       return;
5749
5750     default:
5751       d_print_error (dpi);
5752       return;
5753     }
5754 }
5755
5756 static void
5757 d_print_comp (struct d_print_info *dpi, int options,
5758               struct demangle_component *dc)
5759 {
5760   struct d_component_stack self;
5761   if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
5762     {
5763       d_print_error (dpi);
5764       return;
5765     }
5766
5767   dc->d_printing++;
5768   dpi->recursion++;
5769
5770   self.dc = dc;
5771   self.parent = dpi->component_stack;
5772   dpi->component_stack = &self;
5773
5774   d_print_comp_inner (dpi, options, dc);
5775
5776   dpi->component_stack = self.parent;
5777   dc->d_printing--;
5778   dpi->recursion--;
5779 }
5780
5781 /* Print a Java dentifier.  For Java we try to handle encoded extended
5782    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
5783    so we don't it for C++.  Characters are encoded as
5784    __U<hex-char>+_.  */
5785
5786 static void
5787 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5788 {
5789   const char *p;
5790   const char *end;
5791
5792   end = name + len;
5793   for (p = name; p < end; ++p)
5794     {
5795       if (end - p > 3
5796           && p[0] == '_'
5797           && p[1] == '_'
5798           && p[2] == 'U')
5799         {
5800           unsigned long c;
5801           const char *q;
5802
5803           c = 0;
5804           for (q = p + 3; q < end; ++q)
5805             {
5806               int dig;
5807
5808               if (IS_DIGIT (*q))
5809                 dig = *q - '0';
5810               else if (*q >= 'A' && *q <= 'F')
5811                 dig = *q - 'A' + 10;
5812               else if (*q >= 'a' && *q <= 'f')
5813                 dig = *q - 'a' + 10;
5814               else
5815                 break;
5816
5817               c = c * 16 + dig;
5818             }
5819           /* If the Unicode character is larger than 256, we don't try
5820              to deal with it here.  FIXME.  */
5821           if (q < end && *q == '_' && c < 256)
5822             {
5823               d_append_char (dpi, c);
5824               p = q;
5825               continue;
5826             }
5827         }
5828
5829       d_append_char (dpi, *p);
5830     }
5831 }
5832
5833 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
5834    qualifiers on this after printing a function.  */
5835
5836 static void
5837 d_print_mod_list (struct d_print_info *dpi, int options,
5838                   struct d_print_mod *mods, int suffix)
5839 {
5840   struct d_print_template *hold_dpt;
5841
5842   if (mods == NULL || d_print_saw_error (dpi))
5843     return;
5844
5845   if (mods->printed
5846       || (! suffix
5847           && (is_fnqual_component_type (mods->mod->type))))
5848     {
5849       d_print_mod_list (dpi, options, mods->next, suffix);
5850       return;
5851     }
5852
5853   mods->printed = 1;
5854
5855   hold_dpt = dpi->templates;
5856   dpi->templates = mods->templates;
5857
5858   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5859     {
5860       d_print_function_type (dpi, options, mods->mod, mods->next);
5861       dpi->templates = hold_dpt;
5862       return;
5863     }
5864   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5865     {
5866       d_print_array_type (dpi, options, mods->mod, mods->next);
5867       dpi->templates = hold_dpt;
5868       return;
5869     }
5870   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
5871     {
5872       struct d_print_mod *hold_modifiers;
5873       struct demangle_component *dc;
5874
5875       /* When this is on the modifier stack, we have pulled any
5876          qualifiers off the right argument already.  Otherwise, we
5877          print it as usual, but don't let the left argument see any
5878          modifiers.  */
5879
5880       hold_modifiers = dpi->modifiers;
5881       dpi->modifiers = NULL;
5882       d_print_comp (dpi, options, d_left (mods->mod));
5883       dpi->modifiers = hold_modifiers;
5884
5885       if ((options & DMGL_JAVA) == 0)
5886         d_append_string (dpi, "::");
5887       else
5888         d_append_char (dpi, '.');
5889
5890       dc = d_right (mods->mod);
5891
5892       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5893         {
5894           d_append_string (dpi, "{default arg#");
5895           d_append_num (dpi, dc->u.s_unary_num.num + 1);
5896           d_append_string (dpi, "}::");
5897           dc = dc->u.s_unary_num.sub;
5898         }
5899
5900       while (is_fnqual_component_type (dc->type))
5901         dc = d_left (dc);
5902
5903       d_print_comp (dpi, options, dc);
5904
5905       dpi->templates = hold_dpt;
5906       return;
5907     }
5908
5909   d_print_mod (dpi, options, mods->mod);
5910
5911   dpi->templates = hold_dpt;
5912
5913   d_print_mod_list (dpi, options, mods->next, suffix);
5914 }
5915
5916 /* Print a modifier.  */
5917
5918 static void
5919 d_print_mod (struct d_print_info *dpi, int options,
5920              struct demangle_component *mod)
5921 {
5922   switch (mod->type)
5923     {
5924     case DEMANGLE_COMPONENT_RESTRICT:
5925     case DEMANGLE_COMPONENT_RESTRICT_THIS:
5926       d_append_string (dpi, " restrict");
5927       return;
5928     case DEMANGLE_COMPONENT_VOLATILE:
5929     case DEMANGLE_COMPONENT_VOLATILE_THIS:
5930       d_append_string (dpi, " volatile");
5931       return;
5932     case DEMANGLE_COMPONENT_CONST:
5933     case DEMANGLE_COMPONENT_CONST_THIS:
5934       d_append_string (dpi, " const");
5935       return;
5936     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
5937       d_append_string (dpi, " transaction_safe");
5938       return;
5939     case DEMANGLE_COMPONENT_NOEXCEPT:
5940       d_append_string (dpi, " noexcept");
5941       if (d_right (mod))
5942         {
5943           d_append_char (dpi, '(');
5944           d_print_comp (dpi, options, d_right (mod));
5945           d_append_char (dpi, ')');
5946         }
5947       return;
5948     case DEMANGLE_COMPONENT_THROW_SPEC:
5949       d_append_string (dpi, " throw");
5950       if (d_right (mod))
5951         {
5952           d_append_char (dpi, '(');
5953           d_print_comp (dpi, options, d_right (mod));
5954           d_append_char (dpi, ')');
5955         }
5956       return;
5957     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5958       d_append_char (dpi, ' ');
5959       d_print_comp (dpi, options, d_right (mod));
5960       return;
5961     case DEMANGLE_COMPONENT_POINTER:
5962       /* There is no pointer symbol in Java.  */
5963       if ((options & DMGL_JAVA) == 0)
5964         d_append_char (dpi, '*');
5965       return;
5966     case DEMANGLE_COMPONENT_REFERENCE_THIS:
5967       /* For the ref-qualifier, put a space before the &.  */
5968       d_append_char (dpi, ' ');
5969       /* FALLTHRU */
5970     case DEMANGLE_COMPONENT_REFERENCE:
5971       d_append_char (dpi, '&');
5972       return;
5973     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5974       d_append_char (dpi, ' ');
5975       /* FALLTHRU */
5976     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5977       d_append_string (dpi, "&&");
5978       return;
5979     case DEMANGLE_COMPONENT_COMPLEX:
5980       d_append_string (dpi, "complex ");
5981       return;
5982     case DEMANGLE_COMPONENT_IMAGINARY:
5983       d_append_string (dpi, "imaginary ");
5984       return;
5985     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5986       if (d_last_char (dpi) != '(')
5987         d_append_char (dpi, ' ');
5988       d_print_comp (dpi, options, d_left (mod));
5989       d_append_string (dpi, "::*");
5990       return;
5991     case DEMANGLE_COMPONENT_TYPED_NAME:
5992       d_print_comp (dpi, options, d_left (mod));
5993       return;
5994     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5995       d_append_string (dpi, " __vector(");
5996       d_print_comp (dpi, options, d_left (mod));
5997       d_append_char (dpi, ')');
5998       return;
5999
6000     default:
6001       /* Otherwise, we have something that won't go back on the
6002          modifier stack, so we can just print it.  */
6003       d_print_comp (dpi, options, mod);
6004       return;
6005     }
6006 }
6007
6008 /* Print a function type, except for the return type.  */
6009
6010 static void
6011 d_print_function_type (struct d_print_info *dpi, int options,
6012                        struct demangle_component *dc,
6013                        struct d_print_mod *mods)
6014 {
6015   int need_paren;
6016   int need_space;
6017   struct d_print_mod *p;
6018   struct d_print_mod *hold_modifiers;
6019
6020   need_paren = 0;
6021   need_space = 0;
6022   for (p = mods; p != NULL; p = p->next)
6023     {
6024       if (p->printed)
6025         break;
6026
6027       switch (p->mod->type)
6028         {
6029         case DEMANGLE_COMPONENT_POINTER:
6030         case DEMANGLE_COMPONENT_REFERENCE:
6031         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6032           need_paren = 1;
6033           break;
6034         case DEMANGLE_COMPONENT_RESTRICT:
6035         case DEMANGLE_COMPONENT_VOLATILE:
6036         case DEMANGLE_COMPONENT_CONST:
6037         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
6038         case DEMANGLE_COMPONENT_COMPLEX:
6039         case DEMANGLE_COMPONENT_IMAGINARY:
6040         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
6041           need_space = 1;
6042           need_paren = 1;
6043           break;
6044         FNQUAL_COMPONENT_CASE:
6045           break;
6046         default:
6047           break;
6048         }
6049       if (need_paren)
6050         break;
6051     }
6052
6053   if (need_paren)
6054     {
6055       if (! need_space)
6056         {
6057           if (d_last_char (dpi) != '('
6058               && d_last_char (dpi) != '*')
6059             need_space = 1;
6060         }
6061       if (need_space && d_last_char (dpi) != ' ')
6062         d_append_char (dpi, ' ');
6063       d_append_char (dpi, '(');
6064     }
6065
6066   hold_modifiers = dpi->modifiers;
6067   dpi->modifiers = NULL;
6068
6069   d_print_mod_list (dpi, options, mods, 0);
6070
6071   if (need_paren)
6072     d_append_char (dpi, ')');
6073
6074   d_append_char (dpi, '(');
6075
6076   if (d_right (dc) != NULL)
6077     d_print_comp (dpi, options, d_right (dc));
6078
6079   d_append_char (dpi, ')');
6080
6081   d_print_mod_list (dpi, options, mods, 1);
6082
6083   dpi->modifiers = hold_modifiers;
6084 }
6085
6086 /* Print an array type, except for the element type.  */
6087
6088 static void
6089 d_print_array_type (struct d_print_info *dpi, int options,
6090                     struct demangle_component *dc,
6091                     struct d_print_mod *mods)
6092 {
6093   int need_space;
6094
6095   need_space = 1;
6096   if (mods != NULL)
6097     {
6098       int need_paren;
6099       struct d_print_mod *p;
6100
6101       need_paren = 0;
6102       for (p = mods; p != NULL; p = p->next)
6103         {
6104           if (! p->printed)
6105             {
6106               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6107                 {
6108                   need_space = 0;
6109                   break;
6110                 }
6111               else
6112                 {
6113                   need_paren = 1;
6114                   need_space = 1;
6115                   break;
6116                 }
6117             }
6118         }
6119
6120       if (need_paren)
6121         d_append_string (dpi, " (");
6122
6123       d_print_mod_list (dpi, options, mods, 0);
6124
6125       if (need_paren)
6126         d_append_char (dpi, ')');
6127     }
6128
6129   if (need_space)
6130     d_append_char (dpi, ' ');
6131
6132   d_append_char (dpi, '[');
6133
6134   if (d_left (dc) != NULL)
6135     d_print_comp (dpi, options, d_left (dc));
6136
6137   d_append_char (dpi, ']');
6138 }
6139
6140 /* Print an operator in an expression.  */
6141
6142 static void
6143 d_print_expr_op (struct d_print_info *dpi, int options,
6144                  struct demangle_component *dc)
6145 {
6146   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
6147     d_append_buffer (dpi, dc->u.s_operator.op->name,
6148                      dc->u.s_operator.op->len);
6149   else
6150     d_print_comp (dpi, options, dc);
6151 }
6152
6153 /* Print a cast.  */
6154
6155 static void
6156 d_print_cast (struct d_print_info *dpi, int options,
6157               struct demangle_component *dc)
6158 {
6159   d_print_comp (dpi, options, d_left (dc));
6160 }
6161
6162 /* Print a conversion operator.  */
6163
6164 static void
6165 d_print_conversion (struct d_print_info *dpi, int options,
6166                     struct demangle_component *dc)
6167 {
6168   struct d_print_template dpt;
6169
6170   /* For a conversion operator, we need the template parameters from
6171      the enclosing template in scope for processing the type.  */
6172   if (dpi->current_template != NULL)
6173     {
6174       dpt.next = dpi->templates;
6175       dpi->templates = &dpt;
6176       dpt.template_decl = dpi->current_template;
6177     }
6178
6179   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6180     {
6181       d_print_comp (dpi, options, d_left (dc));
6182       if (dpi->current_template != NULL)
6183         dpi->templates = dpt.next;
6184     }
6185   else
6186     {
6187       d_print_comp (dpi, options, d_left (d_left (dc)));
6188
6189       /* For a templated cast operator, we need to remove the template
6190          parameters from scope after printing the operator name,
6191          so we need to handle the template printing here.  */
6192       if (dpi->current_template != NULL)
6193         dpi->templates = dpt.next;
6194
6195       if (d_last_char (dpi) == '<')
6196         d_append_char (dpi, ' ');
6197       d_append_char (dpi, '<');
6198       d_print_comp (dpi, options, d_right (d_left (dc)));
6199       /* Avoid generating two consecutive '>' characters, to avoid
6200          the C++ syntactic ambiguity.  */
6201       if (d_last_char (dpi) == '>')
6202         d_append_char (dpi, ' ');
6203       d_append_char (dpi, '>');
6204     }
6205 }
6206
6207 /* Initialize the information structure we use to pass around
6208    information.  */
6209
6210 CP_STATIC_IF_GLIBCPP_V3
6211 void
6212 cplus_demangle_init_info (const char *mangled, int options, size_t len,
6213                           struct d_info *di)
6214 {
6215   di->s = mangled;
6216   di->send = mangled + len;
6217   di->options = options;
6218
6219   di->n = mangled;
6220
6221   /* We cannot need more components than twice the number of chars in
6222      the mangled string.  Most components correspond directly to
6223      chars, but the ARGLIST types are exceptions.  */
6224   di->num_comps = 2 * len;
6225   di->next_comp = 0;
6226
6227   /* Similarly, we cannot need more substitutions than there are
6228      chars in the mangled string.  */
6229   di->num_subs = len;
6230   di->next_sub = 0;
6231
6232   di->last_name = NULL;
6233
6234   di->expansion = 0;
6235   di->is_expression = 0;
6236   di->is_conversion = 0;
6237   di->recursion_level = 0;
6238 }
6239
6240 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
6241    mangled name, return strings in repeated callback giving the demangled
6242    name.  OPTIONS is the usual libiberty demangler options.  On success,
6243    this returns 1.  On failure, returns 0.  */
6244
6245 static int
6246 d_demangle_callback (const char *mangled, int options,
6247                      demangle_callbackref callback, void *opaque)
6248 {
6249   enum
6250     {
6251       DCT_TYPE,
6252       DCT_MANGLED,
6253       DCT_GLOBAL_CTORS,
6254       DCT_GLOBAL_DTORS
6255     }
6256   type;
6257   struct d_info di;
6258   struct demangle_component *dc;
6259   int status;
6260
6261   if (mangled[0] == '_' && mangled[1] == 'Z')
6262     type = DCT_MANGLED;
6263   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6264            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6265            && (mangled[9] == 'D' || mangled[9] == 'I')
6266            && mangled[10] == '_')
6267     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
6268   else
6269     {
6270       if ((options & DMGL_TYPES) == 0)
6271         return 0;
6272       type = DCT_TYPE;
6273     }
6274
6275   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
6276
6277   /* PR 87675 - Check for a mangled string that is so long
6278      that we do not have enough stack space to demangle it.  */
6279   if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
6280       /* This check is a bit arbitrary, since what we really want to do is to
6281          compare the sizes of the di.comps and di.subs arrays against the
6282          amount of stack space remaining.  But there is no portable way to do
6283          this, so instead we use the recursion limit as a guide to the maximum
6284          size of the arrays.  */
6285       && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
6286     {
6287       /* FIXME: We need a way to indicate that a stack limit has been reached.  */
6288       return 0;
6289     }
6290
6291   {
6292 #ifdef CP_DYNAMIC_ARRAYS
6293     __extension__ struct demangle_component comps[di.num_comps];
6294     __extension__ struct demangle_component *subs[di.num_subs];
6295
6296     di.comps = comps;
6297     di.subs = subs;
6298 #else
6299     di.comps = alloca (di.num_comps * sizeof (*di.comps));
6300     di.subs = alloca (di.num_subs * sizeof (*di.subs));
6301 #endif
6302
6303     switch (type)
6304       {
6305       case DCT_TYPE:
6306         dc = cplus_demangle_type (&di);
6307         break;
6308       case DCT_MANGLED:
6309         dc = cplus_demangle_mangled_name (&di, 1);
6310         break;
6311       case DCT_GLOBAL_CTORS:
6312       case DCT_GLOBAL_DTORS:
6313         d_advance (&di, 11);
6314         dc = d_make_comp (&di,
6315                           (type == DCT_GLOBAL_CTORS
6316                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6317                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
6318                           d_make_demangle_mangled_name (&di, d_str (&di)),
6319                           NULL);
6320         d_advance (&di, strlen (d_str (&di)));
6321         break;
6322       default:
6323         abort (); /* We have listed all the cases.  */
6324       }
6325
6326     /* If DMGL_PARAMS is set, then if we didn't consume the entire
6327        mangled string, then we didn't successfully demangle it.  If
6328        DMGL_PARAMS is not set, we didn't look at the trailing
6329        parameters.  */
6330     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6331       dc = NULL;
6332
6333 #ifdef CP_DEMANGLE_DEBUG
6334     d_dump (dc, 0);
6335 #endif
6336
6337     status = (dc != NULL)
6338              ? cplus_demangle_print_callback (options, dc, callback, opaque)
6339              : 0;
6340   }
6341
6342   return status;
6343 }
6344
6345 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
6346    name, return a buffer allocated with malloc holding the demangled
6347    name.  OPTIONS is the usual libiberty demangler options.  On
6348    success, this sets *PALC to the allocated size of the returned
6349    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
6350    a memory allocation failure, and returns NULL.  */
6351
6352 static char *
6353 d_demangle (const char *mangled, int options, size_t *palc)
6354 {
6355   struct d_growable_string dgs;
6356   int status;
6357
6358   d_growable_string_init (&dgs, 0);
6359
6360   status = d_demangle_callback (mangled, options,
6361                                 d_growable_string_callback_adapter, &dgs);
6362   if (status == 0)
6363     {
6364       free (dgs.buf);
6365       *palc = 0;
6366       return NULL;
6367     }
6368
6369   *palc = dgs.allocation_failure ? 1 : dgs.alc;
6370   return dgs.buf;
6371 }
6372
6373 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6374
6375 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6376
6377 /* ia64 ABI-mandated entry point in the C++ runtime library for
6378    performing demangling.  MANGLED_NAME is a NUL-terminated character
6379    string containing the name to be demangled.
6380
6381    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6382    *LENGTH bytes, into which the demangled name is stored.  If
6383    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6384    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6385    is placed in a region of memory allocated with malloc.
6386
6387    If LENGTH is non-NULL, the length of the buffer containing the
6388    demangled name, is placed in *LENGTH.
6389
6390    The return value is a pointer to the start of the NUL-terminated
6391    demangled name, or NULL if the demangling fails.  The caller is
6392    responsible for deallocating this memory using free.
6393
6394    *STATUS is set to one of the following values:
6395       0: The demangling operation succeeded.
6396      -1: A memory allocation failure occurred.
6397      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6398      -3: One of the arguments is invalid.
6399
6400    The demangling is performed using the C++ ABI mangling rules, with
6401    GNU extensions.  */
6402
6403 char *
6404 __cxa_demangle (const char *mangled_name, char *output_buffer,
6405                 size_t *length, int *status)
6406 {
6407   char *demangled;
6408   size_t alc;
6409
6410   if (mangled_name == NULL)
6411     {
6412       if (status != NULL)
6413         *status = -3;
6414       return NULL;
6415     }
6416
6417   if (output_buffer != NULL && length == NULL)
6418     {
6419       if (status != NULL)
6420         *status = -3;
6421       return NULL;
6422     }
6423
6424   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
6425
6426   if (demangled == NULL)
6427     {
6428       if (status != NULL)
6429         {
6430           if (alc == 1)
6431             *status = -1;
6432           else
6433             *status = -2;
6434         }
6435       return NULL;
6436     }
6437
6438   if (output_buffer == NULL)
6439     {
6440       if (length != NULL)
6441         *length = alc;
6442     }
6443   else
6444     {
6445       if (strlen (demangled) < *length)
6446         {
6447           strcpy (output_buffer, demangled);
6448           free (demangled);
6449           demangled = output_buffer;
6450         }
6451       else
6452         {
6453           free (output_buffer);
6454           *length = alc;
6455         }
6456     }
6457
6458   if (status != NULL)
6459     *status = 0;
6460
6461   return demangled;
6462 }
6463
6464 extern int __gcclibcxx_demangle_callback (const char *,
6465                                           void (*)
6466                                             (const char *, size_t, void *),
6467                                           void *);
6468
6469 /* Alternative, allocationless entry point in the C++ runtime library
6470    for performing demangling.  MANGLED_NAME is a NUL-terminated character
6471    string containing the name to be demangled.
6472
6473    CALLBACK is a callback function, called with demangled string
6474    segments as demangling progresses; it is called at least once,
6475    but may be called more than once.  OPAQUE is a generalized pointer
6476    used as a callback argument.
6477
6478    The return code is one of the following values, equivalent to
6479    the STATUS values of __cxa_demangle() (excluding -1, since this
6480    function performs no memory allocations):
6481       0: The demangling operation succeeded.
6482      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6483      -3: One of the arguments is invalid.
6484
6485    The demangling is performed using the C++ ABI mangling rules, with
6486    GNU extensions.  */
6487
6488 int
6489 __gcclibcxx_demangle_callback (const char *mangled_name,
6490                                void (*callback) (const char *, size_t, void *),
6491                                void *opaque)
6492 {
6493   int status;
6494
6495   if (mangled_name == NULL || callback == NULL)
6496     return -3;
6497
6498   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6499                                 callback, opaque);
6500   if (status == 0)
6501     return -2;
6502
6503   return 0;
6504 }
6505
6506 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6507
6508 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
6509    mangled name, return a buffer allocated with malloc holding the
6510    demangled name.  Otherwise, return NULL.  */
6511
6512 char *
6513 cplus_demangle_v3 (const char *mangled, int options)
6514 {
6515   size_t alc;
6516
6517   return d_demangle (mangled, options, &alc);
6518 }
6519
6520 int
6521 cplus_demangle_v3_callback (const char *mangled, int options,
6522                             demangle_callbackref callback, void *opaque)
6523 {
6524   return d_demangle_callback (mangled, options, callback, opaque);
6525 }
6526
6527 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
6528    conventions, but the output formatting is a little different.
6529    This instructs the C++ demangler not to emit pointer characters ("*"), to
6530    use Java's namespace separator symbol ("." instead of "::"), and to output
6531    JArray<TYPE> as TYPE[].  */
6532
6533 char *
6534 java_demangle_v3 (const char *mangled)
6535 {
6536   size_t alc;
6537
6538   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6539 }
6540
6541 int
6542 java_demangle_v3_callback (const char *mangled,
6543                            demangle_callbackref callback, void *opaque)
6544 {
6545   return d_demangle_callback (mangled,
6546                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6547                               callback, opaque);
6548 }
6549
6550 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6551
6552 #ifndef IN_GLIBCPP_V3
6553
6554 /* Demangle a string in order to find out whether it is a constructor
6555    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
6556    *DTOR_KIND appropriately.  */
6557
6558 static int
6559 is_ctor_or_dtor (const char *mangled,
6560                  enum gnu_v3_ctor_kinds *ctor_kind,
6561                  enum gnu_v3_dtor_kinds *dtor_kind)
6562 {
6563   struct d_info di;
6564   struct demangle_component *dc;
6565   int ret;
6566
6567   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6568   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6569
6570   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
6571
6572   {
6573 #ifdef CP_DYNAMIC_ARRAYS
6574     __extension__ struct demangle_component comps[di.num_comps];
6575     __extension__ struct demangle_component *subs[di.num_subs];
6576
6577     di.comps = comps;
6578     di.subs = subs;
6579 #else
6580     di.comps = alloca (di.num_comps * sizeof (*di.comps));
6581     di.subs = alloca (di.num_subs * sizeof (*di.subs));
6582 #endif
6583
6584     dc = cplus_demangle_mangled_name (&di, 1);
6585
6586     /* Note that because we did not pass DMGL_PARAMS, we don't expect
6587        to demangle the entire string.  */
6588
6589     ret = 0;
6590     while (dc != NULL)
6591       {
6592         switch (dc->type)
6593           {
6594             /* These cannot appear on a constructor or destructor.  */
6595           case DEMANGLE_COMPONENT_RESTRICT_THIS:
6596           case DEMANGLE_COMPONENT_VOLATILE_THIS:
6597           case DEMANGLE_COMPONENT_CONST_THIS:
6598           case DEMANGLE_COMPONENT_REFERENCE_THIS:
6599           case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6600           default:
6601             dc = NULL;
6602             break;
6603           case DEMANGLE_COMPONENT_TYPED_NAME:
6604           case DEMANGLE_COMPONENT_TEMPLATE:
6605             dc = d_left (dc);
6606             break;
6607           case DEMANGLE_COMPONENT_QUAL_NAME:
6608           case DEMANGLE_COMPONENT_LOCAL_NAME:
6609             dc = d_right (dc);
6610             break;
6611           case DEMANGLE_COMPONENT_CTOR:
6612             *ctor_kind = dc->u.s_ctor.kind;
6613             ret = 1;
6614             dc = NULL;
6615             break;
6616           case DEMANGLE_COMPONENT_DTOR:
6617             *dtor_kind = dc->u.s_dtor.kind;
6618             ret = 1;
6619             dc = NULL;
6620             break;
6621           }
6622       }
6623   }
6624
6625   return ret;
6626 }
6627
6628 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6629    name.  A non-zero return indicates the type of constructor.  */
6630
6631 enum gnu_v3_ctor_kinds
6632 is_gnu_v3_mangled_ctor (const char *name)
6633 {
6634   enum gnu_v3_ctor_kinds ctor_kind;
6635   enum gnu_v3_dtor_kinds dtor_kind;
6636
6637   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6638     return (enum gnu_v3_ctor_kinds) 0;
6639   return ctor_kind;
6640 }
6641
6642
6643 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6644    name.  A non-zero return indicates the type of destructor.  */
6645
6646 enum gnu_v3_dtor_kinds
6647 is_gnu_v3_mangled_dtor (const char *name)
6648 {
6649   enum gnu_v3_ctor_kinds ctor_kind;
6650   enum gnu_v3_dtor_kinds dtor_kind;
6651
6652   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6653     return (enum gnu_v3_dtor_kinds) 0;
6654   return dtor_kind;
6655 }
6656
6657 #endif /* IN_GLIBCPP_V3 */
6658
6659 #ifdef STANDALONE_DEMANGLER
6660
6661 #include "getopt.h"
6662 #include "dyn-string.h"
6663
6664 static void print_usage (FILE* fp, int exit_value);
6665
6666 #define IS_ALPHA(CHAR)                                                  \
6667   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
6668    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6669
6670 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
6671 #define is_mangled_char(CHAR)                                           \
6672   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
6673    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6674
6675 /* The name of this program, as invoked.  */
6676 const char* program_name;
6677
6678 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
6679
6680 static void
6681 print_usage (FILE* fp, int exit_value)
6682 {
6683   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
6684   fprintf (fp, "Options:\n");
6685   fprintf (fp, "  -h,--help       Display this message.\n");
6686   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
6687   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
6688   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
6689
6690   exit (exit_value);
6691 }
6692
6693 /* Option specification for getopt_long.  */
6694 static const struct option long_options[] =
6695 {
6696   { "help",      no_argument, NULL, 'h' },
6697   { "no-params", no_argument, NULL, 'p' },
6698   { "verbose",   no_argument, NULL, 'v' },
6699   { NULL,        no_argument, NULL, 0   },
6700 };
6701
6702 /* Main entry for a demangling filter executable.  It will demangle
6703    its command line arguments, if any.  If none are provided, it will
6704    filter stdin to stdout, replacing any recognized mangled C++ names
6705    with their demangled equivalents.  */
6706
6707 int
6708 main (int argc, char *argv[])
6709 {
6710   int i;
6711   int opt_char;
6712   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
6713
6714   /* Use the program name of this program, as invoked.  */
6715   program_name = argv[0];
6716
6717   /* Parse options.  */
6718   do
6719     {
6720       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
6721       switch (opt_char)
6722         {
6723         case '?':  /* Unrecognized option.  */
6724           print_usage (stderr, 1);
6725           break;
6726
6727         case 'h':
6728           print_usage (stdout, 0);
6729           break;
6730
6731         case 'p':
6732           options &= ~ DMGL_PARAMS;
6733           break;
6734
6735         case 'v':
6736           options |= DMGL_VERBOSE;
6737           break;
6738         }
6739     }
6740   while (opt_char != -1);
6741
6742   if (optind == argc)
6743     /* No command line arguments were provided.  Filter stdin.  */
6744     {
6745       dyn_string_t mangled = dyn_string_new (3);
6746       char *s;
6747
6748       /* Read all of input.  */
6749       while (!feof (stdin))
6750         {
6751           char c;
6752
6753           /* Pile characters into mangled until we hit one that can't
6754              occur in a mangled name.  */
6755           c = getchar ();
6756           while (!feof (stdin) && is_mangled_char (c))
6757             {
6758               dyn_string_append_char (mangled, c);
6759               if (feof (stdin))
6760                 break;
6761               c = getchar ();
6762             }
6763
6764           if (dyn_string_length (mangled) > 0)
6765             {
6766 #ifdef IN_GLIBCPP_V3
6767               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6768 #else
6769               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
6770 #endif
6771
6772               if (s != NULL)
6773                 {
6774                   fputs (s, stdout);
6775                   free (s);
6776                 }
6777               else
6778                 {
6779                   /* It might not have been a mangled name.  Print the
6780                      original text.  */
6781                   fputs (dyn_string_buf (mangled), stdout);
6782                 }
6783
6784               dyn_string_clear (mangled);
6785             }
6786
6787           /* If we haven't hit EOF yet, we've read one character that
6788              can't occur in a mangled name, so print it out.  */
6789           if (!feof (stdin))
6790             putchar (c);
6791         }
6792
6793       dyn_string_delete (mangled);
6794     }
6795   else
6796     /* Demangle command line arguments.  */
6797     {
6798       /* Loop over command line arguments.  */
6799       for (i = optind; i < argc; ++i)
6800         {
6801           char *s;
6802 #ifdef IN_GLIBCPP_V3
6803           int status;
6804 #endif
6805
6806           /* Attempt to demangle.  */
6807 #ifdef IN_GLIBCPP_V3
6808           s = __cxa_demangle (argv[i], NULL, NULL, &status);
6809 #else
6810           s = cplus_demangle_v3 (argv[i], options);
6811 #endif
6812
6813           /* If it worked, print the demangled name.  */
6814           if (s != NULL)
6815             {
6816               printf ("%s\n", s);
6817               free (s);
6818             }
6819           else
6820             {
6821 #ifdef IN_GLIBCPP_V3
6822               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6823 #else
6824               fprintf (stderr, "Failed: %s\n", argv[i]);
6825 #endif
6826             }
6827         }
6828     }
6829
6830   return 0;
6831 }
6832
6833 #endif /* STANDALONE_DEMANGLER */