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