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