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