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