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