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 (int *num_templates, int *num_scopes,
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       (*num_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         (*num_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       d_count_templates_scopes (num_templates, num_scopes,
4156                                 d_left (dc));
4157       d_count_templates_scopes (num_templates, num_scopes,
4158                                 d_right (dc));
4159       break;
4160
4161     case DEMANGLE_COMPONENT_CTOR:
4162       d_count_templates_scopes (num_templates, num_scopes,
4163                                 dc->u.s_ctor.name);
4164       break;
4165
4166     case DEMANGLE_COMPONENT_DTOR:
4167       d_count_templates_scopes (num_templates, num_scopes,
4168                                 dc->u.s_dtor.name);
4169       break;
4170
4171     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4172       d_count_templates_scopes (num_templates, num_scopes,
4173                                 dc->u.s_extended_operator.name);
4174       break;
4175
4176     case DEMANGLE_COMPONENT_FIXED_TYPE:
4177       d_count_templates_scopes (num_templates, num_scopes,
4178                                 dc->u.s_fixed.length);
4179       break;
4180
4181     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4182     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4183       d_count_templates_scopes (num_templates, num_scopes,
4184                                 d_left (dc));
4185       break;
4186
4187     case DEMANGLE_COMPONENT_LAMBDA:
4188     case DEMANGLE_COMPONENT_DEFAULT_ARG:
4189       d_count_templates_scopes (num_templates, num_scopes,
4190                                 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->num_copy_templates,
4226                             &dpi->num_saved_scopes, dc);
4227   dpi->num_copy_templates *= dpi->num_saved_scopes;
4228
4229   dpi->current_template = NULL;
4230 }
4231
4232 /* Indicate that an error occurred during printing, and test for error.  */
4233
4234 static inline void
4235 d_print_error (struct d_print_info *dpi)
4236 {
4237   dpi->demangle_failure = 1;
4238 }
4239
4240 static inline int
4241 d_print_saw_error (struct d_print_info *dpi)
4242 {
4243   return dpi->demangle_failure != 0;
4244 }
4245
4246 /* Flush buffered characters to the callback.  */
4247
4248 static inline void
4249 d_print_flush (struct d_print_info *dpi)
4250 {
4251   dpi->buf[dpi->len] = '\0';
4252   dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4253   dpi->len = 0;
4254   dpi->flush_count++;
4255 }
4256
4257 /* Append characters and buffers for printing.  */
4258
4259 static inline void
4260 d_append_char (struct d_print_info *dpi, char c)
4261 {
4262   if (dpi->len == sizeof (dpi->buf) - 1)
4263     d_print_flush (dpi);
4264
4265   dpi->buf[dpi->len++] = c;
4266   dpi->last_char = c;
4267 }
4268
4269 static inline void
4270 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4271 {
4272   size_t i;
4273
4274   for (i = 0; i < l; i++)
4275     d_append_char (dpi, s[i]);
4276 }
4277
4278 static inline void
4279 d_append_string (struct d_print_info *dpi, const char *s)
4280 {
4281   d_append_buffer (dpi, s, strlen (s));
4282 }
4283
4284 static inline void
4285 d_append_num (struct d_print_info *dpi, int l)
4286 {
4287   char buf[25];
4288   sprintf (buf,"%d", l);
4289   d_append_string (dpi, buf);
4290 }
4291
4292 static inline char
4293 d_last_char (struct d_print_info *dpi)
4294 {
4295   return dpi->last_char;
4296 }
4297
4298 /* Turn components into a human readable string.  OPTIONS is the
4299    options bits passed to the demangler.  DC is the tree to print.
4300    CALLBACK is a function to call to flush demangled string segments
4301    as they fill the intermediate buffer, and OPAQUE is a generalized
4302    callback argument.  On success, this returns 1.  On failure,
4303    it returns 0, indicating a bad parse.  It does not use heap
4304    memory to build an output string, so cannot encounter memory
4305    allocation failure.  */
4306
4307 CP_STATIC_IF_GLIBCPP_V3
4308 int
4309 cplus_demangle_print_callback (int options,
4310                                struct demangle_component *dc,
4311                                demangle_callbackref callback, void *opaque)
4312 {
4313   struct d_print_info dpi;
4314
4315   d_print_init (&dpi, callback, opaque, dc);
4316
4317   {
4318 #ifdef CP_DYNAMIC_ARRAYS
4319     /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4320        and flagged as errors by Address Sanitizer.  */
4321     __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
4322                                               ? dpi.num_saved_scopes : 1];
4323     __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
4324                                                 ? dpi.num_copy_templates : 1];
4325
4326     dpi.saved_scopes = scopes;
4327     dpi.copy_templates = temps;
4328 #else
4329     dpi.saved_scopes = alloca (dpi.num_saved_scopes
4330                                * sizeof (*dpi.saved_scopes));
4331     dpi.copy_templates = alloca (dpi.num_copy_templates
4332                                  * sizeof (*dpi.copy_templates));
4333 #endif
4334
4335     d_print_comp (&dpi, options, dc);
4336   }
4337
4338   d_print_flush (&dpi);
4339
4340   return ! d_print_saw_error (&dpi);
4341 }
4342
4343 /* Turn components into a human readable string.  OPTIONS is the
4344    options bits passed to the demangler.  DC is the tree to print.
4345    ESTIMATE is a guess at the length of the result.  This returns a
4346    string allocated by malloc, or NULL on error.  On success, this
4347    sets *PALC to the size of the allocated buffer.  On failure, this
4348    sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4349    failure.  */
4350
4351 CP_STATIC_IF_GLIBCPP_V3
4352 char *
4353 cplus_demangle_print (int options, struct demangle_component *dc,
4354                       int estimate, size_t *palc)
4355 {
4356   struct d_growable_string dgs;
4357
4358   d_growable_string_init (&dgs, estimate);
4359
4360   if (! cplus_demangle_print_callback (options, dc,
4361                                        d_growable_string_callback_adapter,
4362                                        &dgs))
4363     {
4364       free (dgs.buf);
4365       *palc = 0;
4366       return NULL;
4367     }
4368
4369   *palc = dgs.allocation_failure ? 1 : dgs.alc;
4370   return dgs.buf;
4371 }
4372
4373 /* Returns the I'th element of the template arglist ARGS, or NULL on
4374    failure.  If I is negative, return the entire arglist.  */
4375
4376 static struct demangle_component *
4377 d_index_template_argument (struct demangle_component *args, int i)
4378 {
4379   struct demangle_component *a;
4380
4381   if (i < 0)
4382     /* Print the whole argument pack.  */
4383     return args;
4384
4385   for (a = args;
4386        a != NULL;
4387        a = d_right (a))
4388     {
4389       if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4390         return NULL;
4391       if (i <= 0)
4392         break;
4393       --i;
4394     }
4395   if (i != 0 || a == NULL)
4396     return NULL;
4397
4398   return d_left (a);
4399 }
4400
4401 /* Returns the template argument from the current context indicated by DC,
4402    which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL.  */
4403
4404 static struct demangle_component *
4405 d_lookup_template_argument (struct d_print_info *dpi,
4406                             const struct demangle_component *dc)
4407 {
4408   if (dpi->templates == NULL)
4409     {
4410       d_print_error (dpi);
4411       return NULL;
4412     }
4413
4414   return d_index_template_argument
4415     (d_right (dpi->templates->template_decl),
4416      dc->u.s_number.number);
4417 }
4418
4419 /* Returns a template argument pack used in DC (any will do), or NULL.  */
4420
4421 static struct demangle_component *
4422 d_find_pack (struct d_print_info *dpi,
4423              const struct demangle_component *dc)
4424 {
4425   struct demangle_component *a;
4426   if (dc == NULL)
4427     return NULL;
4428
4429   switch (dc->type)
4430     {
4431     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4432       a = d_lookup_template_argument (dpi, dc);
4433       if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4434         return a;
4435       return NULL;
4436
4437     case DEMANGLE_COMPONENT_PACK_EXPANSION:
4438       return NULL;
4439
4440     case DEMANGLE_COMPONENT_LAMBDA:
4441     case DEMANGLE_COMPONENT_NAME:
4442     case DEMANGLE_COMPONENT_TAGGED_NAME:
4443     case DEMANGLE_COMPONENT_OPERATOR:
4444     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4445     case DEMANGLE_COMPONENT_SUB_STD:
4446     case DEMANGLE_COMPONENT_CHARACTER:
4447     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4448     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4449     case DEMANGLE_COMPONENT_FIXED_TYPE:
4450     case DEMANGLE_COMPONENT_DEFAULT_ARG:
4451     case DEMANGLE_COMPONENT_NUMBER:
4452       return NULL;
4453
4454     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4455       return d_find_pack (dpi, dc->u.s_extended_operator.name);
4456     case DEMANGLE_COMPONENT_CTOR:
4457       return d_find_pack (dpi, dc->u.s_ctor.name);
4458     case DEMANGLE_COMPONENT_DTOR:
4459       return d_find_pack (dpi, dc->u.s_dtor.name);
4460
4461     default:
4462       a = d_find_pack (dpi, d_left (dc));
4463       if (a)
4464         return a;
4465       return d_find_pack (dpi, d_right (dc));
4466     }
4467 }
4468
4469 /* Returns the length of the template argument pack DC.  */
4470
4471 static int
4472 d_pack_length (const struct demangle_component *dc)
4473 {
4474   int count = 0;
4475   while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4476          && d_left (dc) != NULL)
4477     {
4478       ++count;
4479       dc = d_right (dc);
4480     }
4481   return count;
4482 }
4483
4484 /* Returns the number of template args in DC, expanding any pack expansions
4485    found there.  */
4486
4487 static int
4488 d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4489 {
4490   int count = 0;
4491   for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
4492        dc = d_right (dc))
4493     {
4494       struct demangle_component *elt = d_left (dc);
4495       if (elt == NULL)
4496         break;
4497       if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4498         {
4499           struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4500           count += d_pack_length (a);
4501         }
4502       else
4503         ++count;
4504     }
4505   return count;
4506 }
4507
4508 /* DC is a component of a mangled expression.  Print it, wrapped in parens
4509    if needed.  */
4510
4511 static void
4512 d_print_subexpr (struct d_print_info *dpi, int options,
4513                  struct demangle_component *dc)
4514 {
4515   int simple = 0;
4516   if (dc->type == DEMANGLE_COMPONENT_NAME
4517       || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4518       || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
4519       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
4520     simple = 1;
4521   if (!simple)
4522     d_append_char (dpi, '(');
4523   d_print_comp (dpi, options, dc);
4524   if (!simple)
4525     d_append_char (dpi, ')');
4526 }
4527
4528 /* Save the current scope.  */
4529
4530 static void
4531 d_save_scope (struct d_print_info *dpi,
4532               const struct demangle_component *container)
4533 {
4534   struct d_saved_scope *scope;
4535   struct d_print_template *src, **link;
4536
4537   if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4538     {
4539       d_print_error (dpi);
4540       return;
4541     }
4542   scope = &dpi->saved_scopes[dpi->next_saved_scope];
4543   dpi->next_saved_scope++;
4544
4545   scope->container = container;
4546   link = &scope->templates;
4547
4548   for (src = dpi->templates; src != NULL; src = src->next)
4549     {
4550       struct d_print_template *dst;
4551
4552       if (dpi->next_copy_template >= dpi->num_copy_templates)
4553         {
4554           d_print_error (dpi);
4555           return;
4556         }
4557       dst = &dpi->copy_templates[dpi->next_copy_template];
4558       dpi->next_copy_template++;
4559
4560       dst->template_decl = src->template_decl;
4561       *link = dst;
4562       link = &dst->next;
4563     }
4564
4565   *link = NULL;
4566 }
4567
4568 /* Attempt to locate a previously saved scope.  Returns NULL if no
4569    corresponding saved scope was found.  */
4570
4571 static struct d_saved_scope *
4572 d_get_saved_scope (struct d_print_info *dpi,
4573                    const struct demangle_component *container)
4574 {
4575   int i;
4576
4577   for (i = 0; i < dpi->next_saved_scope; i++)
4578     if (dpi->saved_scopes[i].container == container)
4579       return &dpi->saved_scopes[i];
4580
4581   return NULL;
4582 }
4583
4584 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4585    return false.  */
4586
4587 static int
4588 d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
4589                                struct demangle_component *dc)
4590 {
4591   struct demangle_component *ops, *operator_, *op1, *op2;
4592   int save_idx;
4593
4594   const char *fold_code = d_left (dc)->u.s_operator.op->code;
4595   if (fold_code[0] != 'f')
4596     return 0;
4597
4598   ops = d_right (dc);
4599   operator_ = d_left (ops);
4600   op1 = d_right (ops);
4601   op2 = 0;
4602   if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4603     {
4604       op2 = d_right (op1);
4605       op1 = d_left (op1);
4606     }
4607
4608   /* Print the whole pack.  */
4609   save_idx = dpi->pack_index;
4610   dpi->pack_index = -1;
4611
4612   switch (fold_code[1])
4613     {
4614       /* Unary left fold, (... + X).  */
4615     case 'l':
4616       d_append_string (dpi, "(...");
4617       d_print_expr_op (dpi, options, operator_);
4618       d_print_subexpr (dpi, options, op1);
4619       d_append_char (dpi, ')');
4620       break;
4621
4622       /* Unary right fold, (X + ...).  */
4623     case 'r':
4624       d_append_char (dpi, '(');
4625       d_print_subexpr (dpi, options, op1);
4626       d_print_expr_op (dpi, options, operator_);
4627       d_append_string (dpi, "...)");
4628       break;
4629
4630       /* Binary left fold, (42 + ... + X).  */
4631     case 'L':
4632       /* Binary right fold, (X + ... + 42).  */
4633     case 'R':
4634       d_append_char (dpi, '(');
4635       d_print_subexpr (dpi, options, op1);
4636       d_print_expr_op (dpi, options, operator_);
4637       d_append_string (dpi, "...");
4638       d_print_expr_op (dpi, options, operator_);
4639       d_print_subexpr (dpi, options, op2);
4640       d_append_char (dpi, ')');
4641       break;
4642     }
4643
4644   dpi->pack_index = save_idx;
4645   return 1;
4646 }
4647
4648 /* Subroutine to handle components.  */
4649
4650 static void
4651 d_print_comp_inner (struct d_print_info *dpi, int options,
4652                     struct demangle_component *dc)
4653 {
4654   /* Magic variable to let reference smashing skip over the next modifier
4655      without needing to modify *dc.  */
4656   struct demangle_component *mod_inner = NULL;
4657
4658   /* Variable used to store the current templates while a previously
4659      captured scope is used.  */
4660   struct d_print_template *saved_templates;
4661
4662   /* Nonzero if templates have been stored in the above variable.  */
4663   int need_template_restore = 0;
4664
4665   if (dc == NULL)
4666     {
4667       d_print_error (dpi);
4668       return;
4669     }
4670   if (d_print_saw_error (dpi))
4671     return;
4672
4673   switch (dc->type)
4674     {
4675     case DEMANGLE_COMPONENT_NAME:
4676       if ((options & DMGL_JAVA) == 0)
4677         d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4678       else
4679         d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
4680       return;
4681
4682     case DEMANGLE_COMPONENT_TAGGED_NAME:
4683       d_print_comp (dpi, options, d_left (dc));
4684       d_append_string (dpi, "[abi:");
4685       d_print_comp (dpi, options, d_right (dc));
4686       d_append_char (dpi, ']');
4687       return;
4688
4689     case DEMANGLE_COMPONENT_QUAL_NAME:
4690     case DEMANGLE_COMPONENT_LOCAL_NAME:
4691       d_print_comp (dpi, options, d_left (dc));
4692       if ((options & DMGL_JAVA) == 0)
4693         d_append_string (dpi, "::");
4694       else
4695         d_append_char (dpi, '.');
4696       {
4697         struct demangle_component *local_name = d_right (dc);
4698         if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4699           {
4700             d_append_string (dpi, "{default arg#");
4701             d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4702             d_append_string (dpi, "}::");
4703             local_name = local_name->u.s_unary_num.sub;
4704           }
4705         d_print_comp (dpi, options, local_name);
4706       }
4707       return;
4708
4709     case DEMANGLE_COMPONENT_TYPED_NAME:
4710       {
4711         struct d_print_mod *hold_modifiers;
4712         struct demangle_component *typed_name;
4713         struct d_print_mod adpm[4];
4714         unsigned int i;
4715         struct d_print_template dpt;
4716
4717         /* Pass the name down to the type so that it can be printed in
4718            the right place for the type.  We also have to pass down
4719            any CV-qualifiers, which apply to the this parameter.  */
4720         hold_modifiers = dpi->modifiers;
4721         dpi->modifiers = 0;
4722         i = 0;
4723         typed_name = d_left (dc);
4724         while (typed_name != NULL)
4725           {
4726             if (i >= sizeof adpm / sizeof adpm[0])
4727               {
4728                 d_print_error (dpi);
4729                 return;
4730               }
4731
4732             adpm[i].next = dpi->modifiers;
4733             dpi->modifiers = &adpm[i];
4734             adpm[i].mod = typed_name;
4735             adpm[i].printed = 0;
4736             adpm[i].templates = dpi->templates;
4737             ++i;
4738
4739             if (!is_fnqual_component_type (typed_name->type))
4740               break;
4741
4742             typed_name = d_left (typed_name);
4743           }
4744
4745         if (typed_name == NULL)
4746           {
4747             d_print_error (dpi);
4748             return;
4749           }
4750
4751         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4752            there may be CV-qualifiers on its right argument which
4753            really apply here; this happens when parsing a class that
4754            is local to a function.  */
4755         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4756           {
4757             typed_name = d_right (typed_name);
4758             if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4759               typed_name = typed_name->u.s_unary_num.sub;
4760             if (typed_name == NULL)
4761               {
4762                 d_print_error (dpi);
4763                 return;
4764               }
4765             while (is_fnqual_component_type (typed_name->type))
4766               {
4767                 if (i >= sizeof adpm / sizeof adpm[0])
4768                   {
4769                     d_print_error (dpi);
4770                     return;
4771                   }
4772
4773                 adpm[i] = adpm[i - 1];
4774                 adpm[i].next = &adpm[i - 1];
4775                 dpi->modifiers = &adpm[i];
4776
4777                 adpm[i - 1].mod = typed_name;
4778                 adpm[i - 1].printed = 0;
4779                 adpm[i - 1].templates = dpi->templates;
4780                 ++i;
4781
4782                 typed_name = d_left (typed_name);
4783               }
4784           }
4785
4786         /* If typed_name is a template, then it applies to the
4787            function type as well.  */
4788         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4789           {
4790             dpt.next = dpi->templates;
4791             dpi->templates = &dpt;
4792             dpt.template_decl = typed_name;
4793           }
4794
4795         d_print_comp (dpi, options, d_right (dc));
4796
4797         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4798           dpi->templates = dpt.next;
4799
4800         /* If the modifiers didn't get printed by the type, print them
4801            now.  */
4802         while (i > 0)
4803           {
4804             --i;
4805             if (! adpm[i].printed)
4806               {
4807                 d_append_char (dpi, ' ');
4808                 d_print_mod (dpi, options, adpm[i].mod);
4809               }
4810           }
4811
4812         dpi->modifiers = hold_modifiers;
4813
4814         return;
4815       }
4816
4817     case DEMANGLE_COMPONENT_TEMPLATE:
4818       {
4819         struct d_print_mod *hold_dpm;
4820         struct demangle_component *dcl;
4821         const struct demangle_component *hold_current;
4822
4823         /* This template may need to be referenced by a cast operator
4824            contained in its subtree.  */
4825         hold_current = dpi->current_template;
4826         dpi->current_template = dc;
4827
4828         /* Don't push modifiers into a template definition.  Doing so
4829            could give the wrong definition for a template argument.
4830            Instead, treat the template essentially as a name.  */
4831
4832         hold_dpm = dpi->modifiers;
4833         dpi->modifiers = NULL;
4834
4835         dcl = d_left (dc);
4836
4837         if ((options & DMGL_JAVA) != 0
4838             && dcl->type == DEMANGLE_COMPONENT_NAME
4839             && dcl->u.s_name.len == 6
4840             && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4841           {
4842             /* Special-case Java arrays, so that JArray<TYPE> appears
4843                instead as TYPE[].  */
4844
4845             d_print_comp (dpi, options, d_right (dc));
4846             d_append_string (dpi, "[]");
4847           }
4848         else
4849           {
4850             d_print_comp (dpi, options, dcl);
4851             if (d_last_char (dpi) == '<')
4852               d_append_char (dpi, ' ');
4853             d_append_char (dpi, '<');
4854             d_print_comp (dpi, options, d_right (dc));
4855             /* Avoid generating two consecutive '>' characters, to avoid
4856                the C++ syntactic ambiguity.  */
4857             if (d_last_char (dpi) == '>')
4858               d_append_char (dpi, ' ');
4859             d_append_char (dpi, '>');
4860           }
4861
4862         dpi->modifiers = hold_dpm;
4863         dpi->current_template = hold_current;
4864
4865         return;
4866       }
4867
4868     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4869       if (dpi->is_lambda_arg)
4870         {
4871           /* Show the template parm index, as that's how g++ displays
4872              these, and future proofs us against potential
4873              '[]<typename T> (T *a, T *b) {...}'.  */
4874           d_append_buffer (dpi, "auto:", 5);
4875           d_append_num (dpi, dc->u.s_number.number + 1);
4876         }
4877       else
4878         {
4879           struct d_print_template *hold_dpt;
4880           struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4881
4882           if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4883             a = d_index_template_argument (a, dpi->pack_index);
4884
4885           if (a == NULL)
4886             {
4887               d_print_error (dpi);
4888               return;
4889             }
4890
4891           /* While processing this parameter, we need to pop the list
4892              of templates.  This is because the template parameter may
4893              itself be a reference to a parameter of an outer
4894              template.  */
4895
4896           hold_dpt = dpi->templates;
4897           dpi->templates = hold_dpt->next;
4898
4899           d_print_comp (dpi, options, a);
4900
4901           dpi->templates = hold_dpt;
4902         }
4903       return;
4904
4905     case DEMANGLE_COMPONENT_TPARM_OBJ:
4906       d_append_string (dpi, "template parameter object for ");
4907       d_print_comp (dpi, options, d_left (dc));
4908       return;
4909
4910     case DEMANGLE_COMPONENT_CTOR:
4911       d_print_comp (dpi, options, dc->u.s_ctor.name);
4912       return;
4913
4914     case DEMANGLE_COMPONENT_DTOR:
4915       d_append_char (dpi, '~');
4916       d_print_comp (dpi, options, dc->u.s_dtor.name);
4917       return;
4918
4919     case DEMANGLE_COMPONENT_VTABLE:
4920       d_append_string (dpi, "vtable for ");
4921       d_print_comp (dpi, options, d_left (dc));
4922       return;
4923
4924     case DEMANGLE_COMPONENT_VTT:
4925       d_append_string (dpi, "VTT for ");
4926       d_print_comp (dpi, options, d_left (dc));
4927       return;
4928
4929     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4930       d_append_string (dpi, "construction vtable for ");
4931       d_print_comp (dpi, options, d_left (dc));
4932       d_append_string (dpi, "-in-");
4933       d_print_comp (dpi, options, d_right (dc));
4934       return;
4935
4936     case DEMANGLE_COMPONENT_TYPEINFO:
4937       d_append_string (dpi, "typeinfo for ");
4938       d_print_comp (dpi, options, d_left (dc));
4939       return;
4940
4941     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4942       d_append_string (dpi, "typeinfo name for ");
4943       d_print_comp (dpi, options, d_left (dc));
4944       return;
4945
4946     case DEMANGLE_COMPONENT_TYPEINFO_FN:
4947       d_append_string (dpi, "typeinfo fn for ");
4948       d_print_comp (dpi, options, d_left (dc));
4949       return;
4950
4951     case DEMANGLE_COMPONENT_THUNK:
4952       d_append_string (dpi, "non-virtual thunk to ");
4953       d_print_comp (dpi, options, d_left (dc));
4954       return;
4955
4956     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4957       d_append_string (dpi, "virtual thunk to ");
4958       d_print_comp (dpi, options, d_left (dc));
4959       return;
4960
4961     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4962       d_append_string (dpi, "covariant return thunk to ");
4963       d_print_comp (dpi, options, d_left (dc));
4964       return;
4965
4966     case DEMANGLE_COMPONENT_JAVA_CLASS:
4967       d_append_string (dpi, "java Class for ");
4968       d_print_comp (dpi, options, d_left (dc));
4969       return;
4970
4971     case DEMANGLE_COMPONENT_GUARD:
4972       d_append_string (dpi, "guard variable for ");
4973       d_print_comp (dpi, options, d_left (dc));
4974       return;
4975
4976     case DEMANGLE_COMPONENT_TLS_INIT:
4977       d_append_string (dpi, "TLS init function for ");
4978       d_print_comp (dpi, options, d_left (dc));
4979       return;
4980
4981     case DEMANGLE_COMPONENT_TLS_WRAPPER:
4982       d_append_string (dpi, "TLS wrapper function for ");
4983       d_print_comp (dpi, options, d_left (dc));
4984       return;
4985
4986     case DEMANGLE_COMPONENT_REFTEMP:
4987       d_append_string (dpi, "reference temporary #");
4988       d_print_comp (dpi, options, d_right (dc));
4989       d_append_string (dpi, " for ");
4990       d_print_comp (dpi, options, d_left (dc));
4991       return;
4992
4993     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4994       d_append_string (dpi, "hidden alias for ");
4995       d_print_comp (dpi, options, d_left (dc));
4996       return;
4997
4998     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4999       d_append_string (dpi, "transaction clone for ");
5000       d_print_comp (dpi, options, d_left (dc));
5001       return;
5002
5003     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
5004       d_append_string (dpi, "non-transaction clone for ");
5005       d_print_comp (dpi, options, d_left (dc));
5006       return;
5007
5008     case DEMANGLE_COMPONENT_SUB_STD:
5009       d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
5010       return;
5011
5012     case DEMANGLE_COMPONENT_RESTRICT:
5013     case DEMANGLE_COMPONENT_VOLATILE:
5014     case DEMANGLE_COMPONENT_CONST:
5015       {
5016         struct d_print_mod *pdpm;
5017
5018         /* When printing arrays, it's possible to have cases where the
5019            same CV-qualifier gets pushed on the stack multiple times.
5020            We only need to print it once.  */
5021
5022         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
5023           {
5024             if (! pdpm->printed)
5025               {
5026                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
5027                     && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
5028                     && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
5029                   break;
5030                 if (pdpm->mod->type == dc->type)
5031                   {
5032                     d_print_comp (dpi, options, d_left (dc));
5033                     return;
5034                   }
5035               }
5036           }
5037       }
5038       goto modifier;
5039
5040     case DEMANGLE_COMPONENT_REFERENCE:
5041     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5042       {
5043         /* Handle reference smashing: & + && = &.  */
5044         struct demangle_component *sub = d_left (dc);
5045         if (!dpi->is_lambda_arg
5046             && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
5047           {
5048             struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
5049             struct demangle_component *a;
5050
5051             if (scope == NULL)
5052               {
5053                 /* This is the first time SUB has been traversed.
5054                    We need to capture the current templates so
5055                    they can be restored if SUB is reentered as a
5056                    substitution.  */
5057                 d_save_scope (dpi, sub);
5058                 if (d_print_saw_error (dpi))
5059                   return;
5060               }
5061             else
5062               {
5063                 const struct d_component_stack *dcse;
5064                 int found_self_or_parent = 0;
5065
5066                 /* This traversal is reentering SUB as a substition.
5067                    If we are not beneath SUB or DC in the tree then we
5068                    need to restore SUB's template stack temporarily.  */
5069                 for (dcse = dpi->component_stack; dcse != NULL;
5070                      dcse = dcse->parent)
5071                   {
5072                     if (dcse->dc == sub
5073                         || (dcse->dc == dc
5074                             && dcse != dpi->component_stack))
5075                       {
5076                         found_self_or_parent = 1;
5077                         break;
5078                       }
5079                   }
5080
5081                 if (!found_self_or_parent)
5082                   {
5083                     saved_templates = dpi->templates;
5084                     dpi->templates = scope->templates;
5085                     need_template_restore = 1;
5086                   }
5087               }
5088
5089             a = d_lookup_template_argument (dpi, sub);
5090             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5091               a = d_index_template_argument (a, dpi->pack_index);
5092
5093             if (a == NULL)
5094               {
5095                 if (need_template_restore)
5096                   dpi->templates = saved_templates;
5097
5098                 d_print_error (dpi);
5099                 return;
5100               }
5101
5102             sub = a;
5103           }
5104
5105         if (sub->type == DEMANGLE_COMPONENT_REFERENCE
5106             || sub->type == dc->type)
5107           dc = sub;
5108         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
5109           mod_inner = d_left (sub);
5110       }
5111       /* Fall through.  */
5112
5113     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5114     case DEMANGLE_COMPONENT_POINTER:
5115     case DEMANGLE_COMPONENT_COMPLEX:
5116     case DEMANGLE_COMPONENT_IMAGINARY:
5117     FNQUAL_COMPONENT_CASE:
5118     modifier:
5119       {
5120         /* We keep a list of modifiers on the stack.  */
5121         struct d_print_mod dpm;
5122
5123         dpm.next = dpi->modifiers;
5124         dpi->modifiers = &dpm;
5125         dpm.mod = dc;
5126         dpm.printed = 0;
5127         dpm.templates = dpi->templates;
5128
5129         if (!mod_inner)
5130           mod_inner = d_left (dc);
5131
5132         d_print_comp (dpi, options, mod_inner);
5133
5134         /* If the modifier didn't get printed by the type, print it
5135            now.  */
5136         if (! dpm.printed)
5137           d_print_mod (dpi, options, dc);
5138
5139         dpi->modifiers = dpm.next;
5140
5141         if (need_template_restore)
5142           dpi->templates = saved_templates;
5143
5144         return;
5145       }
5146
5147     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5148       if ((options & DMGL_JAVA) == 0)
5149         d_append_buffer (dpi, dc->u.s_builtin.type->name,
5150                          dc->u.s_builtin.type->len);
5151       else
5152         d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5153                          dc->u.s_builtin.type->java_len);
5154       return;
5155
5156     case DEMANGLE_COMPONENT_VENDOR_TYPE:
5157       d_print_comp (dpi, options, d_left (dc));
5158       return;
5159
5160     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5161       {
5162         if ((options & DMGL_RET_POSTFIX) != 0)
5163           d_print_function_type (dpi,
5164                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5165                                  dc, dpi->modifiers);
5166
5167         /* Print return type if present */
5168         if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5169           d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5170                         d_left (dc));
5171         else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
5172           {
5173             struct d_print_mod dpm;
5174
5175             /* We must pass this type down as a modifier in order to
5176                print it in the right location.  */
5177             dpm.next = dpi->modifiers;
5178             dpi->modifiers = &dpm;
5179             dpm.mod = dc;
5180             dpm.printed = 0;
5181             dpm.templates = dpi->templates;
5182
5183             d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5184                           d_left (dc));
5185
5186             dpi->modifiers = dpm.next;
5187
5188             if (dpm.printed)
5189               return;
5190
5191             /* In standard prefix notation, there is a space between the
5192                return type and the function signature.  */
5193             if ((options & DMGL_RET_POSTFIX) == 0)
5194               d_append_char (dpi, ' ');
5195           }
5196
5197         if ((options & DMGL_RET_POSTFIX) == 0)
5198           d_print_function_type (dpi,
5199                                  options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5200                                  dc, dpi->modifiers);
5201
5202         return;
5203       }
5204
5205     case DEMANGLE_COMPONENT_ARRAY_TYPE:
5206       {
5207         struct d_print_mod *hold_modifiers;
5208         struct d_print_mod adpm[4];
5209         unsigned int i;
5210         struct d_print_mod *pdpm;
5211
5212         /* We must pass this type down as a modifier in order to print
5213            multi-dimensional arrays correctly.  If the array itself is
5214            CV-qualified, we act as though the element type were
5215            CV-qualified.  We do this by copying the modifiers down
5216            rather than fiddling pointers, so that we don't wind up
5217            with a d_print_mod higher on the stack pointing into our
5218            stack frame after we return.  */
5219
5220         hold_modifiers = dpi->modifiers;
5221
5222         adpm[0].next = hold_modifiers;
5223         dpi->modifiers = &adpm[0];
5224         adpm[0].mod = dc;
5225         adpm[0].printed = 0;
5226         adpm[0].templates = dpi->templates;
5227
5228         i = 1;
5229         pdpm = hold_modifiers;
5230         while (pdpm != NULL
5231                && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
5232                    || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
5233                    || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
5234           {
5235             if (! pdpm->printed)
5236               {
5237                 if (i >= sizeof adpm / sizeof adpm[0])
5238                   {
5239                     d_print_error (dpi);
5240                     return;
5241                   }
5242
5243                 adpm[i] = *pdpm;
5244                 adpm[i].next = dpi->modifiers;
5245                 dpi->modifiers = &adpm[i];
5246                 pdpm->printed = 1;
5247                 ++i;
5248               }
5249
5250             pdpm = pdpm->next;
5251           }
5252
5253         d_print_comp (dpi, options, d_right (dc));
5254
5255         dpi->modifiers = hold_modifiers;
5256
5257         if (adpm[0].printed)
5258           return;
5259
5260         while (i > 1)
5261           {
5262             --i;
5263             d_print_mod (dpi, options, adpm[i].mod);
5264           }
5265
5266         d_print_array_type (dpi, options, dc, dpi->modifiers);
5267
5268         return;
5269       }
5270
5271     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5272     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5273       {
5274         struct d_print_mod dpm;
5275
5276         dpm.next = dpi->modifiers;
5277         dpi->modifiers = &dpm;
5278         dpm.mod = dc;
5279         dpm.printed = 0;
5280         dpm.templates = dpi->templates;
5281
5282         d_print_comp (dpi, options, d_right (dc));
5283
5284         /* If the modifier didn't get printed by the type, print it
5285            now.  */
5286         if (! dpm.printed)
5287           d_print_mod (dpi, options, dc);
5288
5289         dpi->modifiers = dpm.next;
5290
5291         return;
5292       }
5293
5294     case DEMANGLE_COMPONENT_FIXED_TYPE:
5295       if (dc->u.s_fixed.sat)
5296         d_append_string (dpi, "_Sat ");
5297       /* Don't print "int _Accum".  */
5298       if (dc->u.s_fixed.length->u.s_builtin.type
5299           != &cplus_demangle_builtin_types['i'-'a'])
5300         {
5301           d_print_comp (dpi, options, dc->u.s_fixed.length);
5302           d_append_char (dpi, ' ');
5303         }
5304       if (dc->u.s_fixed.accum)
5305         d_append_string (dpi, "_Accum");
5306       else
5307         d_append_string (dpi, "_Fract");
5308       return;
5309
5310     case DEMANGLE_COMPONENT_ARGLIST:
5311     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
5312       if (d_left (dc) != NULL)
5313         d_print_comp (dpi, options, d_left (dc));
5314       if (d_right (dc) != NULL)
5315         {
5316           size_t len;
5317           unsigned long int flush_count;
5318           /* Make sure ", " isn't flushed by d_append_string, otherwise
5319              dpi->len -= 2 wouldn't work.  */
5320           if (dpi->len >= sizeof (dpi->buf) - 2)
5321             d_print_flush (dpi);
5322           d_append_string (dpi, ", ");
5323           len = dpi->len;
5324           flush_count = dpi->flush_count;
5325           d_print_comp (dpi, options, d_right (dc));
5326           /* If that didn't print anything (which can happen with empty
5327              template argument packs), remove the comma and space.  */
5328           if (dpi->flush_count == flush_count && dpi->len == len)
5329             dpi->len -= 2;
5330         }
5331       return;
5332
5333     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5334       {
5335         struct demangle_component *type = d_left (dc);
5336         struct demangle_component *list = d_right (dc);
5337
5338         if (type)
5339           d_print_comp (dpi, options, type);
5340         d_append_char (dpi, '{');
5341         d_print_comp (dpi, options, list);
5342         d_append_char (dpi, '}');
5343       }
5344       return;
5345
5346     case DEMANGLE_COMPONENT_OPERATOR:
5347       {
5348         const struct demangle_operator_info *op = dc->u.s_operator.op;
5349         int len = op->len;
5350
5351         d_append_string (dpi, "operator");
5352         /* Add a space before new/delete.  */
5353         if (IS_LOWER (op->name[0]))
5354           d_append_char (dpi, ' ');
5355         /* Omit a trailing space.  */
5356         if (op->name[len-1] == ' ')
5357           --len;
5358         d_append_buffer (dpi, op->name, len);
5359         return;
5360       }
5361
5362     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
5363       d_append_string (dpi, "operator ");
5364       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
5365       return;
5366
5367     case DEMANGLE_COMPONENT_CONVERSION:
5368       d_append_string (dpi, "operator ");
5369       d_print_conversion (dpi, options, dc);
5370       return;
5371
5372     case DEMANGLE_COMPONENT_NULLARY:
5373       d_print_expr_op (dpi, options, d_left (dc));
5374       return;
5375
5376     case DEMANGLE_COMPONENT_UNARY:
5377       {
5378         struct demangle_component *op = d_left (dc);
5379         struct demangle_component *operand = d_right (dc);
5380         const char *code = NULL;
5381
5382         if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5383           {
5384             code = op->u.s_operator.op->code;
5385             if (!strcmp (code, "ad"))
5386               {
5387                 /* Don't print the argument list for the address of a
5388                    function.  */
5389                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5390                     && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5391                     && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5392                   operand = d_left (operand);
5393               }
5394             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5395               {
5396                 /* This indicates a suffix operator.  */
5397                 operand = d_left (operand);
5398                 d_print_subexpr (dpi, options, operand);
5399                 d_print_expr_op (dpi, options, op);
5400                 return;
5401               }
5402           }
5403
5404         /* For sizeof..., just print the pack length.  */
5405         if (code && !strcmp (code, "sZ"))
5406           {
5407             struct demangle_component *a = d_find_pack (dpi, operand);
5408             int len = d_pack_length (a);
5409             d_append_num (dpi, len);
5410             return;
5411           }
5412         else if (code && !strcmp (code, "sP"))
5413           {
5414             int len = d_args_length (dpi, operand);
5415             d_append_num (dpi, len);
5416             return;
5417           }
5418
5419         if (op->type != DEMANGLE_COMPONENT_CAST)
5420           d_print_expr_op (dpi, options, op);
5421         else
5422           {
5423             d_append_char (dpi, '(');
5424             d_print_cast (dpi, options, op);
5425             d_append_char (dpi, ')');
5426           }
5427         if (code && !strcmp (code, "gs"))
5428           /* Avoid parens after '::'.  */
5429           d_print_comp (dpi, options, operand);
5430         else if (code && !strcmp (code, "st"))
5431           /* Always print parens for sizeof (type).  */
5432           {
5433             d_append_char (dpi, '(');
5434             d_print_comp (dpi, options, operand);
5435             d_append_char (dpi, ')');
5436           }
5437         else
5438           d_print_subexpr (dpi, options, operand);
5439       }
5440       return;
5441
5442     case DEMANGLE_COMPONENT_BINARY:
5443       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
5444         {
5445           d_print_error (dpi);
5446           return;
5447         }
5448
5449       if (op_is_new_cast (d_left (dc)))
5450         {
5451           d_print_expr_op (dpi, options, d_left (dc));
5452           d_append_char (dpi, '<');
5453           d_print_comp (dpi, options, d_left (d_right (dc)));
5454           d_append_string (dpi, ">(");
5455           d_print_comp (dpi, options, d_right (d_right (dc)));
5456           d_append_char (dpi, ')');
5457           return;
5458         }
5459
5460       if (d_maybe_print_fold_expression (dpi, options, dc))
5461         return;
5462
5463       /* We wrap an expression which uses the greater-than operator in
5464          an extra layer of parens so that it does not get confused
5465          with the '>' which ends the template parameters.  */
5466       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5467           && d_left (dc)->u.s_operator.op->len == 1
5468           && d_left (dc)->u.s_operator.op->name[0] == '>')
5469         d_append_char (dpi, '(');
5470
5471       if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5472           && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5473         {
5474           /* Function call used in an expression should not have printed types
5475              of the function arguments.  Values of the function arguments still
5476              get printed below.  */
5477
5478           const struct demangle_component *func = d_left (d_right (dc));
5479
5480           if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5481             d_print_error (dpi);
5482           d_print_subexpr (dpi, options, d_left (func));
5483         }
5484       else
5485         d_print_subexpr (dpi, options, d_left (d_right (dc)));
5486       if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5487         {
5488           d_append_char (dpi, '[');
5489           d_print_comp (dpi, options, d_right (d_right (dc)));
5490           d_append_char (dpi, ']');
5491         }
5492       else
5493         {
5494           if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
5495             d_print_expr_op (dpi, options, d_left (dc));
5496           d_print_subexpr (dpi, options, d_right (d_right (dc)));
5497         }
5498
5499       if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5500           && d_left (dc)->u.s_operator.op->len == 1
5501           && d_left (dc)->u.s_operator.op->name[0] == '>')
5502         d_append_char (dpi, ')');
5503
5504       return;
5505
5506     case DEMANGLE_COMPONENT_BINARY_ARGS:
5507       /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
5508       d_print_error (dpi);
5509       return;
5510
5511     case DEMANGLE_COMPONENT_TRINARY:
5512       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5513           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
5514         {
5515           d_print_error (dpi);
5516           return;
5517         }
5518       if (d_maybe_print_fold_expression (dpi, options, dc))
5519         return;
5520       {
5521         struct demangle_component *op = d_left (dc);
5522         struct demangle_component *first = d_left (d_right (dc));
5523         struct demangle_component *second = d_left (d_right (d_right (dc)));
5524         struct demangle_component *third = d_right (d_right (d_right (dc)));
5525
5526         if (!strcmp (op->u.s_operator.op->code, "qu"))
5527           {
5528             d_print_subexpr (dpi, options, first);
5529             d_print_expr_op (dpi, options, op);
5530             d_print_subexpr (dpi, options, second);
5531             d_append_string (dpi, " : ");
5532             d_print_subexpr (dpi, options, third);
5533           }
5534         else
5535           {
5536             d_append_string (dpi, "new ");
5537             if (d_left (first) != NULL)
5538               {
5539                 d_print_subexpr (dpi, options, first);
5540                 d_append_char (dpi, ' ');
5541               }
5542             d_print_comp (dpi, options, second);
5543             if (third)
5544               d_print_subexpr (dpi, options, third);
5545           }
5546       }
5547       return;
5548
5549     case DEMANGLE_COMPONENT_TRINARY_ARG1:
5550     case DEMANGLE_COMPONENT_TRINARY_ARG2:
5551       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
5552       d_print_error (dpi);
5553       return;
5554
5555     case DEMANGLE_COMPONENT_LITERAL:
5556     case DEMANGLE_COMPONENT_LITERAL_NEG:
5557       {
5558         enum d_builtin_type_print tp;
5559
5560         /* For some builtin types, produce simpler output.  */
5561         tp = D_PRINT_DEFAULT;
5562         if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5563           {
5564             tp = d_left (dc)->u.s_builtin.type->print;
5565             switch (tp)
5566               {
5567               case D_PRINT_INT:
5568               case D_PRINT_UNSIGNED:
5569               case D_PRINT_LONG:
5570               case D_PRINT_UNSIGNED_LONG:
5571               case D_PRINT_LONG_LONG:
5572               case D_PRINT_UNSIGNED_LONG_LONG:
5573                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5574                   {
5575                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5576                       d_append_char (dpi, '-');
5577                     d_print_comp (dpi, options, d_right (dc));
5578                     switch (tp)
5579                       {
5580                       default:
5581                         break;
5582                       case D_PRINT_UNSIGNED:
5583                         d_append_char (dpi, 'u');
5584                         break;
5585                       case D_PRINT_LONG:
5586                         d_append_char (dpi, 'l');
5587                         break;
5588                       case D_PRINT_UNSIGNED_LONG:
5589                         d_append_string (dpi, "ul");
5590                         break;
5591                       case D_PRINT_LONG_LONG:
5592                         d_append_string (dpi, "ll");
5593                         break;
5594                       case D_PRINT_UNSIGNED_LONG_LONG:
5595                         d_append_string (dpi, "ull");
5596                         break;
5597                       }
5598                     return;
5599                   }
5600                 break;
5601
5602               case D_PRINT_BOOL:
5603                 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5604                     && d_right (dc)->u.s_name.len == 1
5605                     && dc->type == DEMANGLE_COMPONENT_LITERAL)
5606                   {
5607                     switch (d_right (dc)->u.s_name.s[0])
5608                       {
5609                       case '0':
5610                         d_append_string (dpi, "false");
5611                         return;
5612                       case '1':
5613                         d_append_string (dpi, "true");
5614                         return;
5615                       default:
5616                         break;
5617                       }
5618                   }
5619                 break;
5620
5621               default:
5622                 break;
5623               }
5624           }
5625
5626         d_append_char (dpi, '(');
5627         d_print_comp (dpi, options, d_left (dc));
5628         d_append_char (dpi, ')');
5629         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5630           d_append_char (dpi, '-');
5631         if (tp == D_PRINT_FLOAT)
5632           d_append_char (dpi, '[');
5633         d_print_comp (dpi, options, d_right (dc));
5634         if (tp == D_PRINT_FLOAT)
5635           d_append_char (dpi, ']');
5636       }
5637       return;
5638
5639     case DEMANGLE_COMPONENT_NUMBER:
5640       d_append_num (dpi, dc->u.s_number.number);
5641       return;
5642
5643     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5644       d_append_string (dpi, "java resource ");
5645       d_print_comp (dpi, options, d_left (dc));
5646       return;
5647
5648     case DEMANGLE_COMPONENT_COMPOUND_NAME:
5649       d_print_comp (dpi, options, d_left (dc));
5650       d_print_comp (dpi, options, d_right (dc));
5651       return;
5652
5653     case DEMANGLE_COMPONENT_CHARACTER:
5654       d_append_char (dpi, dc->u.s_character.character);
5655       return;
5656
5657     case DEMANGLE_COMPONENT_DECLTYPE:
5658       d_append_string (dpi, "decltype (");
5659       d_print_comp (dpi, options, d_left (dc));
5660       d_append_char (dpi, ')');
5661       return;
5662
5663     case DEMANGLE_COMPONENT_PACK_EXPANSION:
5664       {
5665         int len;
5666         int i;
5667         struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5668         if (a == NULL)
5669           {
5670             /* d_find_pack won't find anything if the only packs involved
5671                in this expansion are function parameter packs; in that
5672                case, just print the pattern and "...".  */
5673             d_print_subexpr (dpi, options, d_left (dc));
5674             d_append_string (dpi, "...");
5675             return;
5676           }
5677
5678         len = d_pack_length (a);
5679         dc = d_left (dc);
5680         for (i = 0; i < len; ++i)
5681           {
5682             dpi->pack_index = i;
5683             d_print_comp (dpi, options, dc);
5684             if (i < len-1)
5685               d_append_string (dpi, ", ");
5686           }
5687       }
5688       return;
5689
5690     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
5691       {
5692         long num = dc->u.s_number.number;
5693         if (num == 0)
5694           d_append_string (dpi, "this");
5695         else
5696           {
5697             d_append_string (dpi, "{parm#");
5698             d_append_num (dpi, num);
5699             d_append_char (dpi, '}');
5700           }
5701       }
5702       return;
5703
5704     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5705       d_append_string (dpi, "global constructors keyed to ");
5706       d_print_comp (dpi, options, dc->u.s_binary.left);
5707       return;
5708
5709     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5710       d_append_string (dpi, "global destructors keyed to ");
5711       d_print_comp (dpi, options, dc->u.s_binary.left);
5712       return;
5713
5714     case DEMANGLE_COMPONENT_LAMBDA:
5715       d_append_string (dpi, "{lambda(");
5716       /* Generic lambda auto parms are mangled as the template type
5717          parm they are.  */
5718       dpi->is_lambda_arg++;
5719       d_print_comp (dpi, options, dc->u.s_unary_num.sub);
5720       dpi->is_lambda_arg--;
5721       d_append_string (dpi, ")#");
5722       d_append_num (dpi, dc->u.s_unary_num.num + 1);
5723       d_append_char (dpi, '}');
5724       return;
5725
5726     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5727       d_append_string (dpi, "{unnamed type#");
5728       d_append_num (dpi, dc->u.s_number.number + 1);
5729       d_append_char (dpi, '}');
5730       return;
5731
5732     case DEMANGLE_COMPONENT_CLONE:
5733       d_print_comp (dpi, options, d_left (dc));
5734       d_append_string (dpi, " [clone ");
5735       d_print_comp (dpi, options, d_right (dc));
5736       d_append_char (dpi, ']');
5737       return;
5738
5739     default:
5740       d_print_error (dpi);
5741       return;
5742     }
5743 }
5744
5745 static void
5746 d_print_comp (struct d_print_info *dpi, int options,
5747               struct demangle_component *dc)
5748 {
5749   struct d_component_stack self;
5750   if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
5751     {
5752       d_print_error (dpi);
5753       return;
5754     }
5755
5756   dc->d_printing++;
5757   dpi->recursion++;
5758
5759   self.dc = dc;
5760   self.parent = dpi->component_stack;
5761   dpi->component_stack = &self;
5762
5763   d_print_comp_inner (dpi, options, dc);
5764
5765   dpi->component_stack = self.parent;
5766   dc->d_printing--;
5767   dpi->recursion--;
5768 }
5769
5770 /* Print a Java dentifier.  For Java we try to handle encoded extended
5771    Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
5772    so we don't it for C++.  Characters are encoded as
5773    __U<hex-char>+_.  */
5774
5775 static void
5776 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5777 {
5778   const char *p;
5779   const char *end;
5780
5781   end = name + len;
5782   for (p = name; p < end; ++p)
5783     {
5784       if (end - p > 3
5785           && p[0] == '_'
5786           && p[1] == '_'
5787           && p[2] == 'U')
5788         {
5789           unsigned long c;
5790           const char *q;
5791
5792           c = 0;
5793           for (q = p + 3; q < end; ++q)
5794             {
5795               int dig;
5796
5797               if (IS_DIGIT (*q))
5798                 dig = *q - '0';
5799               else if (*q >= 'A' && *q <= 'F')
5800                 dig = *q - 'A' + 10;
5801               else if (*q >= 'a' && *q <= 'f')
5802                 dig = *q - 'a' + 10;
5803               else
5804                 break;
5805
5806               c = c * 16 + dig;
5807             }
5808           /* If the Unicode character is larger than 256, we don't try
5809              to deal with it here.  FIXME.  */
5810           if (q < end && *q == '_' && c < 256)
5811             {
5812               d_append_char (dpi, c);
5813               p = q;
5814               continue;
5815             }
5816         }
5817
5818       d_append_char (dpi, *p);
5819     }
5820 }
5821
5822 /* Print a list of modifiers.  SUFFIX is 1 if we are printing
5823    qualifiers on this after printing a function.  */
5824
5825 static void
5826 d_print_mod_list (struct d_print_info *dpi, int options,
5827                   struct d_print_mod *mods, int suffix)
5828 {
5829   struct d_print_template *hold_dpt;
5830
5831   if (mods == NULL || d_print_saw_error (dpi))
5832     return;
5833
5834   if (mods->printed
5835       || (! suffix
5836           && (is_fnqual_component_type (mods->mod->type))))
5837     {
5838       d_print_mod_list (dpi, options, mods->next, suffix);
5839       return;
5840     }
5841
5842   mods->printed = 1;
5843
5844   hold_dpt = dpi->templates;
5845   dpi->templates = mods->templates;
5846
5847   if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5848     {
5849       d_print_function_type (dpi, options, mods->mod, mods->next);
5850       dpi->templates = hold_dpt;
5851       return;
5852     }
5853   else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5854     {
5855       d_print_array_type (dpi, options, mods->mod, mods->next);
5856       dpi->templates = hold_dpt;
5857       return;
5858     }
5859   else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
5860     {
5861       struct d_print_mod *hold_modifiers;
5862       struct demangle_component *dc;
5863
5864       /* When this is on the modifier stack, we have pulled any
5865          qualifiers off the right argument already.  Otherwise, we
5866          print it as usual, but don't let the left argument see any
5867          modifiers.  */
5868
5869       hold_modifiers = dpi->modifiers;
5870       dpi->modifiers = NULL;
5871       d_print_comp (dpi, options, d_left (mods->mod));
5872       dpi->modifiers = hold_modifiers;
5873
5874       if ((options & DMGL_JAVA) == 0)
5875         d_append_string (dpi, "::");
5876       else
5877         d_append_char (dpi, '.');
5878
5879       dc = d_right (mods->mod);
5880
5881       if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5882         {
5883           d_append_string (dpi, "{default arg#");
5884           d_append_num (dpi, dc->u.s_unary_num.num + 1);
5885           d_append_string (dpi, "}::");
5886           dc = dc->u.s_unary_num.sub;
5887         }
5888
5889       while (is_fnqual_component_type (dc->type))
5890         dc = d_left (dc);
5891
5892       d_print_comp (dpi, options, dc);
5893
5894       dpi->templates = hold_dpt;
5895       return;
5896     }
5897
5898   d_print_mod (dpi, options, mods->mod);
5899
5900   dpi->templates = hold_dpt;
5901
5902   d_print_mod_list (dpi, options, mods->next, suffix);
5903 }
5904
5905 /* Print a modifier.  */
5906
5907 static void
5908 d_print_mod (struct d_print_info *dpi, int options,
5909              struct demangle_component *mod)
5910 {
5911   switch (mod->type)
5912     {
5913     case DEMANGLE_COMPONENT_RESTRICT:
5914     case DEMANGLE_COMPONENT_RESTRICT_THIS:
5915       d_append_string (dpi, " restrict");
5916       return;
5917     case DEMANGLE_COMPONENT_VOLATILE:
5918     case DEMANGLE_COMPONENT_VOLATILE_THIS:
5919       d_append_string (dpi, " volatile");
5920       return;
5921     case DEMANGLE_COMPONENT_CONST:
5922     case DEMANGLE_COMPONENT_CONST_THIS:
5923       d_append_string (dpi, " const");
5924       return;
5925     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
5926       d_append_string (dpi, " transaction_safe");
5927       return;
5928     case DEMANGLE_COMPONENT_NOEXCEPT:
5929       d_append_string (dpi, " noexcept");
5930       if (d_right (mod))
5931         {
5932           d_append_char (dpi, '(');
5933           d_print_comp (dpi, options, d_right (mod));
5934           d_append_char (dpi, ')');
5935         }
5936       return;
5937     case DEMANGLE_COMPONENT_THROW_SPEC:
5938       d_append_string (dpi, " throw");
5939       if (d_right (mod))
5940         {
5941           d_append_char (dpi, '(');
5942           d_print_comp (dpi, options, d_right (mod));
5943           d_append_char (dpi, ')');
5944         }
5945       return;
5946     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5947       d_append_char (dpi, ' ');
5948       d_print_comp (dpi, options, d_right (mod));
5949       return;
5950     case DEMANGLE_COMPONENT_POINTER:
5951       /* There is no pointer symbol in Java.  */
5952       if ((options & DMGL_JAVA) == 0)
5953         d_append_char (dpi, '*');
5954       return;
5955     case DEMANGLE_COMPONENT_REFERENCE_THIS:
5956       /* For the ref-qualifier, put a space before the &.  */
5957       d_append_char (dpi, ' ');
5958       /* FALLTHRU */
5959     case DEMANGLE_COMPONENT_REFERENCE:
5960       d_append_char (dpi, '&');
5961       return;
5962     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5963       d_append_char (dpi, ' ');
5964       /* FALLTHRU */
5965     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5966       d_append_string (dpi, "&&");
5967       return;
5968     case DEMANGLE_COMPONENT_COMPLEX:
5969       d_append_string (dpi, "complex ");
5970       return;
5971     case DEMANGLE_COMPONENT_IMAGINARY:
5972       d_append_string (dpi, "imaginary ");
5973       return;
5974     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5975       if (d_last_char (dpi) != '(')
5976         d_append_char (dpi, ' ');
5977       d_print_comp (dpi, options, d_left (mod));
5978       d_append_string (dpi, "::*");
5979       return;
5980     case DEMANGLE_COMPONENT_TYPED_NAME:
5981       d_print_comp (dpi, options, d_left (mod));
5982       return;
5983     case DEMANGLE_COMPONENT_VECTOR_TYPE:
5984       d_append_string (dpi, " __vector(");
5985       d_print_comp (dpi, options, d_left (mod));
5986       d_append_char (dpi, ')');
5987       return;
5988
5989     default:
5990       /* Otherwise, we have something that won't go back on the
5991          modifier stack, so we can just print it.  */
5992       d_print_comp (dpi, options, mod);
5993       return;
5994     }
5995 }
5996
5997 /* Print a function type, except for the return type.  */
5998
5999 static void
6000 d_print_function_type (struct d_print_info *dpi, int options,
6001                        struct demangle_component *dc,
6002                        struct d_print_mod *mods)
6003 {
6004   int need_paren;
6005   int need_space;
6006   struct d_print_mod *p;
6007   struct d_print_mod *hold_modifiers;
6008
6009   need_paren = 0;
6010   need_space = 0;
6011   for (p = mods; p != NULL; p = p->next)
6012     {
6013       if (p->printed)
6014         break;
6015
6016       switch (p->mod->type)
6017         {
6018         case DEMANGLE_COMPONENT_POINTER:
6019         case DEMANGLE_COMPONENT_REFERENCE:
6020         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6021           need_paren = 1;
6022           break;
6023         case DEMANGLE_COMPONENT_RESTRICT:
6024         case DEMANGLE_COMPONENT_VOLATILE:
6025         case DEMANGLE_COMPONENT_CONST:
6026         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
6027         case DEMANGLE_COMPONENT_COMPLEX:
6028         case DEMANGLE_COMPONENT_IMAGINARY:
6029         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
6030           need_space = 1;
6031           need_paren = 1;
6032           break;
6033         FNQUAL_COMPONENT_CASE:
6034           break;
6035         default:
6036           break;
6037         }
6038       if (need_paren)
6039         break;
6040     }
6041
6042   if (need_paren)
6043     {
6044       if (! need_space)
6045         {
6046           if (d_last_char (dpi) != '('
6047               && d_last_char (dpi) != '*')
6048             need_space = 1;
6049         }
6050       if (need_space && d_last_char (dpi) != ' ')
6051         d_append_char (dpi, ' ');
6052       d_append_char (dpi, '(');
6053     }
6054
6055   hold_modifiers = dpi->modifiers;
6056   dpi->modifiers = NULL;
6057
6058   d_print_mod_list (dpi, options, mods, 0);
6059
6060   if (need_paren)
6061     d_append_char (dpi, ')');
6062
6063   d_append_char (dpi, '(');
6064
6065   if (d_right (dc) != NULL)
6066     d_print_comp (dpi, options, d_right (dc));
6067
6068   d_append_char (dpi, ')');
6069
6070   d_print_mod_list (dpi, options, mods, 1);
6071
6072   dpi->modifiers = hold_modifiers;
6073 }
6074
6075 /* Print an array type, except for the element type.  */
6076
6077 static void
6078 d_print_array_type (struct d_print_info *dpi, int options,
6079                     struct demangle_component *dc,
6080                     struct d_print_mod *mods)
6081 {
6082   int need_space;
6083
6084   need_space = 1;
6085   if (mods != NULL)
6086     {
6087       int need_paren;
6088       struct d_print_mod *p;
6089
6090       need_paren = 0;
6091       for (p = mods; p != NULL; p = p->next)
6092         {
6093           if (! p->printed)
6094             {
6095               if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6096                 {
6097                   need_space = 0;
6098                   break;
6099                 }
6100               else
6101                 {
6102                   need_paren = 1;
6103                   need_space = 1;
6104                   break;
6105                 }
6106             }
6107         }
6108
6109       if (need_paren)
6110         d_append_string (dpi, " (");
6111
6112       d_print_mod_list (dpi, options, mods, 0);
6113
6114       if (need_paren)
6115         d_append_char (dpi, ')');
6116     }
6117
6118   if (need_space)
6119     d_append_char (dpi, ' ');
6120
6121   d_append_char (dpi, '[');
6122
6123   if (d_left (dc) != NULL)
6124     d_print_comp (dpi, options, d_left (dc));
6125
6126   d_append_char (dpi, ']');
6127 }
6128
6129 /* Print an operator in an expression.  */
6130
6131 static void
6132 d_print_expr_op (struct d_print_info *dpi, int options,
6133                  struct demangle_component *dc)
6134 {
6135   if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
6136     d_append_buffer (dpi, dc->u.s_operator.op->name,
6137                      dc->u.s_operator.op->len);
6138   else
6139     d_print_comp (dpi, options, dc);
6140 }
6141
6142 /* Print a cast.  */
6143
6144 static void
6145 d_print_cast (struct d_print_info *dpi, int options,
6146               struct demangle_component *dc)
6147 {
6148   d_print_comp (dpi, options, d_left (dc));
6149 }
6150
6151 /* Print a conversion operator.  */
6152
6153 static void
6154 d_print_conversion (struct d_print_info *dpi, int options,
6155                     struct demangle_component *dc)
6156 {
6157   struct d_print_template dpt;
6158
6159   /* For a conversion operator, we need the template parameters from
6160      the enclosing template in scope for processing the type.  */
6161   if (dpi->current_template != NULL)
6162     {
6163       dpt.next = dpi->templates;
6164       dpi->templates = &dpt;
6165       dpt.template_decl = dpi->current_template;
6166     }
6167
6168   if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6169     {
6170       d_print_comp (dpi, options, d_left (dc));
6171       if (dpi->current_template != NULL)
6172         dpi->templates = dpt.next;
6173     }
6174   else
6175     {
6176       d_print_comp (dpi, options, d_left (d_left (dc)));
6177
6178       /* For a templated cast operator, we need to remove the template
6179          parameters from scope after printing the operator name,
6180          so we need to handle the template printing here.  */
6181       if (dpi->current_template != NULL)
6182         dpi->templates = dpt.next;
6183
6184       if (d_last_char (dpi) == '<')
6185         d_append_char (dpi, ' ');
6186       d_append_char (dpi, '<');
6187       d_print_comp (dpi, options, d_right (d_left (dc)));
6188       /* Avoid generating two consecutive '>' characters, to avoid
6189          the C++ syntactic ambiguity.  */
6190       if (d_last_char (dpi) == '>')
6191         d_append_char (dpi, ' ');
6192       d_append_char (dpi, '>');
6193     }
6194 }
6195
6196 /* Initialize the information structure we use to pass around
6197    information.  */
6198
6199 CP_STATIC_IF_GLIBCPP_V3
6200 void
6201 cplus_demangle_init_info (const char *mangled, int options, size_t len,
6202                           struct d_info *di)
6203 {
6204   di->s = mangled;
6205   di->send = mangled + len;
6206   di->options = options;
6207
6208   di->n = mangled;
6209
6210   /* We cannot need more components than twice the number of chars in
6211      the mangled string.  Most components correspond directly to
6212      chars, but the ARGLIST types are exceptions.  */
6213   di->num_comps = 2 * len;
6214   di->next_comp = 0;
6215
6216   /* Similarly, we cannot need more substitutions than there are
6217      chars in the mangled string.  */
6218   di->num_subs = len;
6219   di->next_sub = 0;
6220
6221   di->last_name = NULL;
6222
6223   di->expansion = 0;
6224   di->is_expression = 0;
6225   di->is_conversion = 0;
6226   di->recursion_level = 0;
6227 }
6228
6229 /* Internal implementation for the demangler.  If MANGLED is a g++ v3 ABI
6230    mangled name, return strings in repeated callback giving the demangled
6231    name.  OPTIONS is the usual libiberty demangler options.  On success,
6232    this returns 1.  On failure, returns 0.  */
6233
6234 static int
6235 d_demangle_callback (const char *mangled, int options,
6236                      demangle_callbackref callback, void *opaque)
6237 {
6238   enum
6239     {
6240       DCT_TYPE,
6241       DCT_MANGLED,
6242       DCT_GLOBAL_CTORS,
6243       DCT_GLOBAL_DTORS
6244     }
6245   type;
6246   struct d_info di;
6247   struct demangle_component *dc;
6248   int status;
6249
6250   if (mangled[0] == '_' && mangled[1] == 'Z')
6251     type = DCT_MANGLED;
6252   else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6253            && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6254            && (mangled[9] == 'D' || mangled[9] == 'I')
6255            && mangled[10] == '_')
6256     type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
6257   else
6258     {
6259       if ((options & DMGL_TYPES) == 0)
6260         return 0;
6261       type = DCT_TYPE;
6262     }
6263
6264   cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
6265
6266   /* PR 87675 - Check for a mangled string that is so long
6267      that we do not have enough stack space to demangle it.  */
6268   if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
6269       /* This check is a bit arbitrary, since what we really want to do is to
6270          compare the sizes of the di.comps and di.subs arrays against the
6271          amount of stack space remaining.  But there is no portable way to do
6272          this, so instead we use the recursion limit as a guide to the maximum
6273          size of the arrays.  */
6274       && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
6275     {
6276       /* FIXME: We need a way to indicate that a stack limit has been reached.  */
6277       return 0;
6278     }
6279
6280   {
6281 #ifdef CP_DYNAMIC_ARRAYS
6282     __extension__ struct demangle_component comps[di.num_comps];
6283     __extension__ struct demangle_component *subs[di.num_subs];
6284
6285     di.comps = comps;
6286     di.subs = subs;
6287 #else
6288     di.comps = alloca (di.num_comps * sizeof (*di.comps));
6289     di.subs = alloca (di.num_subs * sizeof (*di.subs));
6290 #endif
6291
6292     switch (type)
6293       {
6294       case DCT_TYPE:
6295         dc = cplus_demangle_type (&di);
6296         break;
6297       case DCT_MANGLED:
6298         dc = cplus_demangle_mangled_name (&di, 1);
6299         break;
6300       case DCT_GLOBAL_CTORS:
6301       case DCT_GLOBAL_DTORS:
6302         d_advance (&di, 11);
6303         dc = d_make_comp (&di,
6304                           (type == DCT_GLOBAL_CTORS
6305                            ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6306                            : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
6307                           d_make_demangle_mangled_name (&di, d_str (&di)),
6308                           NULL);
6309         d_advance (&di, strlen (d_str (&di)));
6310         break;
6311       default:
6312         abort (); /* We have listed all the cases.  */
6313       }
6314
6315     /* If DMGL_PARAMS is set, then if we didn't consume the entire
6316        mangled string, then we didn't successfully demangle it.  If
6317        DMGL_PARAMS is not set, we didn't look at the trailing
6318        parameters.  */
6319     if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6320       dc = NULL;
6321
6322 #ifdef CP_DEMANGLE_DEBUG
6323     d_dump (dc, 0);
6324 #endif
6325
6326     status = (dc != NULL)
6327              ? cplus_demangle_print_callback (options, dc, callback, opaque)
6328              : 0;
6329   }
6330
6331   return status;
6332 }
6333
6334 /* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
6335    name, return a buffer allocated with malloc holding the demangled
6336    name.  OPTIONS is the usual libiberty demangler options.  On
6337    success, this sets *PALC to the allocated size of the returned
6338    buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
6339    a memory allocation failure, and returns NULL.  */
6340
6341 static char *
6342 d_demangle (const char *mangled, int options, size_t *palc)
6343 {
6344   struct d_growable_string dgs;
6345   int status;
6346
6347   d_growable_string_init (&dgs, 0);
6348
6349   status = d_demangle_callback (mangled, options,
6350                                 d_growable_string_callback_adapter, &dgs);
6351   if (status == 0)
6352     {
6353       free (dgs.buf);
6354       *palc = 0;
6355       return NULL;
6356     }
6357
6358   *palc = dgs.allocation_failure ? 1 : dgs.alc;
6359   return dgs.buf;
6360 }
6361
6362 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6363
6364 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6365
6366 /* ia64 ABI-mandated entry point in the C++ runtime library for
6367    performing demangling.  MANGLED_NAME is a NUL-terminated character
6368    string containing the name to be demangled.
6369
6370    OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6371    *LENGTH bytes, into which the demangled name is stored.  If
6372    OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6373    OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6374    is placed in a region of memory allocated with malloc.
6375
6376    If LENGTH is non-NULL, the length of the buffer containing the
6377    demangled name, is placed in *LENGTH.
6378
6379    The return value is a pointer to the start of the NUL-terminated
6380    demangled name, or NULL if the demangling fails.  The caller is
6381    responsible for deallocating this memory using free.
6382
6383    *STATUS is set to one of the following values:
6384       0: The demangling operation succeeded.
6385      -1: A memory allocation failure occurred.
6386      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6387      -3: One of the arguments is invalid.
6388
6389    The demangling is performed using the C++ ABI mangling rules, with
6390    GNU extensions.  */
6391
6392 char *
6393 __cxa_demangle (const char *mangled_name, char *output_buffer,
6394                 size_t *length, int *status)
6395 {
6396   char *demangled;
6397   size_t alc;
6398
6399   if (mangled_name == NULL)
6400     {
6401       if (status != NULL)
6402         *status = -3;
6403       return NULL;
6404     }
6405
6406   if (output_buffer != NULL && length == NULL)
6407     {
6408       if (status != NULL)
6409         *status = -3;
6410       return NULL;
6411     }
6412
6413   demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
6414
6415   if (demangled == NULL)
6416     {
6417       if (status != NULL)
6418         {
6419           if (alc == 1)
6420             *status = -1;
6421           else
6422             *status = -2;
6423         }
6424       return NULL;
6425     }
6426
6427   if (output_buffer == NULL)
6428     {
6429       if (length != NULL)
6430         *length = alc;
6431     }
6432   else
6433     {
6434       if (strlen (demangled) < *length)
6435         {
6436           strcpy (output_buffer, demangled);
6437           free (demangled);
6438           demangled = output_buffer;
6439         }
6440       else
6441         {
6442           free (output_buffer);
6443           *length = alc;
6444         }
6445     }
6446
6447   if (status != NULL)
6448     *status = 0;
6449
6450   return demangled;
6451 }
6452
6453 extern int __gcclibcxx_demangle_callback (const char *,
6454                                           void (*)
6455                                             (const char *, size_t, void *),
6456                                           void *);
6457
6458 /* Alternative, allocationless entry point in the C++ runtime library
6459    for performing demangling.  MANGLED_NAME is a NUL-terminated character
6460    string containing the name to be demangled.
6461
6462    CALLBACK is a callback function, called with demangled string
6463    segments as demangling progresses; it is called at least once,
6464    but may be called more than once.  OPAQUE is a generalized pointer
6465    used as a callback argument.
6466
6467    The return code is one of the following values, equivalent to
6468    the STATUS values of __cxa_demangle() (excluding -1, since this
6469    function performs no memory allocations):
6470       0: The demangling operation succeeded.
6471      -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6472      -3: One of the arguments is invalid.
6473
6474    The demangling is performed using the C++ ABI mangling rules, with
6475    GNU extensions.  */
6476
6477 int
6478 __gcclibcxx_demangle_callback (const char *mangled_name,
6479                                void (*callback) (const char *, size_t, void *),
6480                                void *opaque)
6481 {
6482   int status;
6483
6484   if (mangled_name == NULL || callback == NULL)
6485     return -3;
6486
6487   status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6488                                 callback, opaque);
6489   if (status == 0)
6490     return -2;
6491
6492   return 0;
6493 }
6494
6495 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6496
6497 /* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
6498    mangled name, return a buffer allocated with malloc holding the
6499    demangled name.  Otherwise, return NULL.  */
6500
6501 char *
6502 cplus_demangle_v3 (const char *mangled, int options)
6503 {
6504   size_t alc;
6505
6506   return d_demangle (mangled, options, &alc);
6507 }
6508
6509 int
6510 cplus_demangle_v3_callback (const char *mangled, int options,
6511                             demangle_callbackref callback, void *opaque)
6512 {
6513   return d_demangle_callback (mangled, options, callback, opaque);
6514 }
6515
6516 /* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
6517    conventions, but the output formatting is a little different.
6518    This instructs the C++ demangler not to emit pointer characters ("*"), to
6519    use Java's namespace separator symbol ("." instead of "::"), and to output
6520    JArray<TYPE> as TYPE[].  */
6521
6522 char *
6523 java_demangle_v3 (const char *mangled)
6524 {
6525   size_t alc;
6526
6527   return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6528 }
6529
6530 int
6531 java_demangle_v3_callback (const char *mangled,
6532                            demangle_callbackref callback, void *opaque)
6533 {
6534   return d_demangle_callback (mangled,
6535                               DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6536                               callback, opaque);
6537 }
6538
6539 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6540
6541 #ifndef IN_GLIBCPP_V3
6542
6543 /* Demangle a string in order to find out whether it is a constructor
6544    or destructor.  Return non-zero on success.  Set *CTOR_KIND and
6545    *DTOR_KIND appropriately.  */
6546
6547 static int
6548 is_ctor_or_dtor (const char *mangled,
6549                  enum gnu_v3_ctor_kinds *ctor_kind,
6550                  enum gnu_v3_dtor_kinds *dtor_kind)
6551 {
6552   struct d_info di;
6553   struct demangle_component *dc;
6554   int ret;
6555
6556   *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6557   *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6558
6559   cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
6560
6561   {
6562 #ifdef CP_DYNAMIC_ARRAYS
6563     __extension__ struct demangle_component comps[di.num_comps];
6564     __extension__ struct demangle_component *subs[di.num_subs];
6565
6566     di.comps = comps;
6567     di.subs = subs;
6568 #else
6569     di.comps = alloca (di.num_comps * sizeof (*di.comps));
6570     di.subs = alloca (di.num_subs * sizeof (*di.subs));
6571 #endif
6572
6573     dc = cplus_demangle_mangled_name (&di, 1);
6574
6575     /* Note that because we did not pass DMGL_PARAMS, we don't expect
6576        to demangle the entire string.  */
6577
6578     ret = 0;
6579     while (dc != NULL)
6580       {
6581         switch (dc->type)
6582           {
6583             /* These cannot appear on a constructor or destructor.  */
6584           case DEMANGLE_COMPONENT_RESTRICT_THIS:
6585           case DEMANGLE_COMPONENT_VOLATILE_THIS:
6586           case DEMANGLE_COMPONENT_CONST_THIS:
6587           case DEMANGLE_COMPONENT_REFERENCE_THIS:
6588           case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6589           default:
6590             dc = NULL;
6591             break;
6592           case DEMANGLE_COMPONENT_TYPED_NAME:
6593           case DEMANGLE_COMPONENT_TEMPLATE:
6594             dc = d_left (dc);
6595             break;
6596           case DEMANGLE_COMPONENT_QUAL_NAME:
6597           case DEMANGLE_COMPONENT_LOCAL_NAME:
6598             dc = d_right (dc);
6599             break;
6600           case DEMANGLE_COMPONENT_CTOR:
6601             *ctor_kind = dc->u.s_ctor.kind;
6602             ret = 1;
6603             dc = NULL;
6604             break;
6605           case DEMANGLE_COMPONENT_DTOR:
6606             *dtor_kind = dc->u.s_dtor.kind;
6607             ret = 1;
6608             dc = NULL;
6609             break;
6610           }
6611       }
6612   }
6613
6614   return ret;
6615 }
6616
6617 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6618    name.  A non-zero return indicates the type of constructor.  */
6619
6620 enum gnu_v3_ctor_kinds
6621 is_gnu_v3_mangled_ctor (const char *name)
6622 {
6623   enum gnu_v3_ctor_kinds ctor_kind;
6624   enum gnu_v3_dtor_kinds dtor_kind;
6625
6626   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6627     return (enum gnu_v3_ctor_kinds) 0;
6628   return ctor_kind;
6629 }
6630
6631
6632 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6633    name.  A non-zero return indicates the type of destructor.  */
6634
6635 enum gnu_v3_dtor_kinds
6636 is_gnu_v3_mangled_dtor (const char *name)
6637 {
6638   enum gnu_v3_ctor_kinds ctor_kind;
6639   enum gnu_v3_dtor_kinds dtor_kind;
6640
6641   if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6642     return (enum gnu_v3_dtor_kinds) 0;
6643   return dtor_kind;
6644 }
6645
6646 #endif /* IN_GLIBCPP_V3 */
6647
6648 #ifdef STANDALONE_DEMANGLER
6649
6650 #include "getopt.h"
6651 #include "dyn-string.h"
6652
6653 static void print_usage (FILE* fp, int exit_value);
6654
6655 #define IS_ALPHA(CHAR)                                                  \
6656   (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
6657    || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6658
6659 /* Non-zero if CHAR is a character than can occur in a mangled name.  */
6660 #define is_mangled_char(CHAR)                                           \
6661   (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
6662    || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6663
6664 /* The name of this program, as invoked.  */
6665 const char* program_name;
6666
6667 /* Prints usage summary to FP and then exits with EXIT_VALUE.  */
6668
6669 static void
6670 print_usage (FILE* fp, int exit_value)
6671 {
6672   fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
6673   fprintf (fp, "Options:\n");
6674   fprintf (fp, "  -h,--help       Display this message.\n");
6675   fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
6676   fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
6677   fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
6678
6679   exit (exit_value);
6680 }
6681
6682 /* Option specification for getopt_long.  */
6683 static const struct option long_options[] =
6684 {
6685   { "help",      no_argument, NULL, 'h' },
6686   { "no-params", no_argument, NULL, 'p' },
6687   { "verbose",   no_argument, NULL, 'v' },
6688   { NULL,        no_argument, NULL, 0   },
6689 };
6690
6691 /* Main entry for a demangling filter executable.  It will demangle
6692    its command line arguments, if any.  If none are provided, it will
6693    filter stdin to stdout, replacing any recognized mangled C++ names
6694    with their demangled equivalents.  */
6695
6696 int
6697 main (int argc, char *argv[])
6698 {
6699   int i;
6700   int opt_char;
6701   int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
6702
6703   /* Use the program name of this program, as invoked.  */
6704   program_name = argv[0];
6705
6706   /* Parse options.  */
6707   do
6708     {
6709       opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
6710       switch (opt_char)
6711         {
6712         case '?':  /* Unrecognized option.  */
6713           print_usage (stderr, 1);
6714           break;
6715
6716         case 'h':
6717           print_usage (stdout, 0);
6718           break;
6719
6720         case 'p':
6721           options &= ~ DMGL_PARAMS;
6722           break;
6723
6724         case 'v':
6725           options |= DMGL_VERBOSE;
6726           break;
6727         }
6728     }
6729   while (opt_char != -1);
6730
6731   if (optind == argc)
6732     /* No command line arguments were provided.  Filter stdin.  */
6733     {
6734       dyn_string_t mangled = dyn_string_new (3);
6735       char *s;
6736
6737       /* Read all of input.  */
6738       while (!feof (stdin))
6739         {
6740           char c;
6741
6742           /* Pile characters into mangled until we hit one that can't
6743              occur in a mangled name.  */
6744           c = getchar ();
6745           while (!feof (stdin) && is_mangled_char (c))
6746             {
6747               dyn_string_append_char (mangled, c);
6748               if (feof (stdin))
6749                 break;
6750               c = getchar ();
6751             }
6752
6753           if (dyn_string_length (mangled) > 0)
6754             {
6755 #ifdef IN_GLIBCPP_V3
6756               s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6757 #else
6758               s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
6759 #endif
6760
6761               if (s != NULL)
6762                 {
6763                   fputs (s, stdout);
6764                   free (s);
6765                 }
6766               else
6767                 {
6768                   /* It might not have been a mangled name.  Print the
6769                      original text.  */
6770                   fputs (dyn_string_buf (mangled), stdout);
6771                 }
6772
6773               dyn_string_clear (mangled);
6774             }
6775
6776           /* If we haven't hit EOF yet, we've read one character that
6777              can't occur in a mangled name, so print it out.  */
6778           if (!feof (stdin))
6779             putchar (c);
6780         }
6781
6782       dyn_string_delete (mangled);
6783     }
6784   else
6785     /* Demangle command line arguments.  */
6786     {
6787       /* Loop over command line arguments.  */
6788       for (i = optind; i < argc; ++i)
6789         {
6790           char *s;
6791 #ifdef IN_GLIBCPP_V3
6792           int status;
6793 #endif
6794
6795           /* Attempt to demangle.  */
6796 #ifdef IN_GLIBCPP_V3
6797           s = __cxa_demangle (argv[i], NULL, NULL, &status);
6798 #else
6799           s = cplus_demangle_v3 (argv[i], options);
6800 #endif
6801
6802           /* If it worked, print the demangled name.  */
6803           if (s != NULL)
6804             {
6805               printf ("%s\n", s);
6806               free (s);
6807             }
6808           else
6809             {
6810 #ifdef IN_GLIBCPP_V3
6811               fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6812 #else
6813               fprintf (stderr, "Failed: %s\n", argv[i]);
6814 #endif
6815             }
6816         }
6817     }
6818
6819   return 0;
6820 }
6821
6822 #endif /* STANDALONE_DEMANGLER */