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