1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
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.
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
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.
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.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 http://www.codesourcery.com/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
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)
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
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
64 cplus_demangle_print_callback
65 and other functions defined in the file cp-demint.c.
67 This file also defines some other functions and variables which are
68 only to be used by the file cp-demint.c.
70 Preprocessor macros you can define while compiling this file:
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
76 int __gcclibcxx_demangle_callback (const char *,
78 (const char *, size_t, void *),
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
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. */
101 #if defined (_AIX) && !defined (__GNUC__)
123 # define alloca __builtin_alloca
125 extern char *alloca ();
126 # endif /* __GNUC__ */
128 #endif /* HAVE_ALLOCA_H */
134 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
137 #include "ansidecl.h"
138 #include "libiberty.h"
139 #include "demangle.h"
140 #include "cp-demangle.h"
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
148 #define CP_STATIC_IF_GLIBCPP_V3 static
150 #define cplus_demangle_fill_name d_fill_name
151 static int d_fill_name (struct demangle_component
*, const char *, int);
153 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
155 d_fill_extended_operator (struct demangle_component
*, int,
156 struct demangle_component
*);
158 #define cplus_demangle_fill_ctor d_fill_ctor
160 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
161 struct demangle_component
*);
163 #define cplus_demangle_fill_dtor d_fill_dtor
165 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
166 struct demangle_component
*);
168 #define cplus_demangle_mangled_name d_mangled_name
169 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
171 #define cplus_demangle_type d_type
172 static struct demangle_component
*d_type (struct d_info
*);
174 #define cplus_demangle_print d_print
175 static char *d_print (int, const struct demangle_component
*, int, size_t *);
177 #define cplus_demangle_print_callback d_print_callback
178 static int d_print_callback (int, const struct demangle_component
*,
179 demangle_callbackref
, void *);
181 #define cplus_demangle_init_info d_init_info
182 static void d_init_info (const char *, int, size_t, struct d_info
*);
184 #else /* ! defined(IN_GLIBCPP_V3) */
185 #define CP_STATIC_IF_GLIBCPP_V3
186 #endif /* ! defined(IN_GLIBCPP_V3) */
188 /* See if the compiler supports dynamic arrays. */
191 #define CP_DYNAMIC_ARRAYS
194 #ifdef __STDC_VERSION__
195 #if __STDC_VERSION__ >= 199901L
196 #define CP_DYNAMIC_ARRAYS
197 #endif /* __STDC__VERSION >= 199901L */
198 #endif /* defined (__STDC_VERSION__) */
199 #endif /* defined (__STDC__) */
200 #endif /* ! defined (__GNUC__) */
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
207 As of this writing this file has the following undefined references
208 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
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')
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)
221 /* Information we keep for the standard substitutions. */
223 struct d_standard_sub_info
225 /* The code for this substitution. */
227 /* The simple string it expands to. */
228 const char *simple_expansion
;
229 /* The length of the simple expansion. */
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. */
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
;
244 /* Accessors for subtrees of struct demangle_component. */
246 #define d_left(dc) ((dc)->u.s_binary.left)
247 #define d_right(dc) ((dc)->u.s_binary.right)
249 /* A list of templates. This is used while printing. */
251 struct d_print_template
253 /* Next template on the list. */
254 struct d_print_template
*next
;
256 const struct demangle_component
*template_decl
;
259 /* A list of type modifiers. This is used while printing. */
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
;
267 const struct demangle_component
*mod
;
268 /* Whether this modifier was printed. */
270 /* The list of templates which applies to this modifier. */
271 struct d_print_template
*templates
;
274 /* We use these structures to hold information during printing. */
276 struct d_growable_string
278 /* Buffer holding the result. */
280 /* Current length of data in buffer. */
282 /* Allocated size of buffer. */
284 /* Set to 1 if we had a memory allocation failure. */
285 int allocation_failure
;
288 /* Stack of components, innermost first, used to avoid loops. */
290 struct d_component_stack
292 /* This component. */
293 const struct demangle_component
*dc
;
294 /* This component's parent. */
295 const struct d_component_stack
*parent
;
298 /* A demangle component and some scope captured when it was first
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
;
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. */
314 struct d_info_checkpoint
323 enum { D_PRINT_BUFFER_LENGTH
= 256 };
326 /* Fixed-length allocated buffer for demangled data, flushed to the
327 callback with a NUL termination once full. */
328 char buf
[D_PRINT_BUFFER_LENGTH
];
329 /* Current length of data in buffer. */
331 /* The last character printed, saved individually so that it survives
334 /* Callback function to handle demangled buffer flush. */
335 demangle_callbackref callback
;
336 /* Opaque callback argument. */
338 /* The current list of templates, if any. */
339 struct d_print_template
*templates
;
340 /* The current list of modifiers (e.g., pointer, reference, etc.),
342 struct d_print_mod
*modifiers
;
343 /* Set to 1 if we saw a demangling error. */
344 int demangle_failure
;
345 /* Non-zero if we're printing a lambda argument. A template
346 parameter reference actually means 'auto'. */
348 /* The current index into any template argument packs we are using
349 for printing, or -1 to print the whole pack. */
351 /* Number of d_print_flush calls so far. */
352 unsigned long int flush_count
;
353 /* Stack of components, innermost first, used to avoid loops. */
354 const struct d_component_stack
*component_stack
;
355 /* Array of saved scopes for evaluating substitutions. */
356 struct d_saved_scope
*saved_scopes
;
357 /* Index of the next unused saved scope in the above array. */
358 int next_saved_scope
;
359 /* Number of saved scopes in the above array. */
360 int num_saved_scopes
;
361 /* Array of templates for saving into scopes. */
362 struct d_print_template
*copy_templates
;
363 /* Index of the next unused copy template in the above array. */
364 int next_copy_template
;
365 /* Number of copy templates in the above array. */
366 int num_copy_templates
;
367 /* The nearest enclosing template, if any. */
368 const struct demangle_component
*current_template
;
371 #ifdef CP_DEMANGLE_DEBUG
372 static void d_dump (struct demangle_component
*, int);
375 static struct demangle_component
*
376 d_make_empty (struct d_info
*);
378 static struct demangle_component
*
379 d_make_comp (struct d_info
*, enum demangle_component_type
,
380 struct demangle_component
*,
381 struct demangle_component
*);
383 static struct demangle_component
*
384 d_make_name (struct d_info
*, const char *, int);
386 static struct demangle_component
*
387 d_make_demangle_mangled_name (struct d_info
*, const char *);
389 static struct demangle_component
*
390 d_make_builtin_type (struct d_info
*,
391 const struct demangle_builtin_type_info
*);
393 static struct demangle_component
*
394 d_make_operator (struct d_info
*,
395 const struct demangle_operator_info
*);
397 static struct demangle_component
*
398 d_make_extended_operator (struct d_info
*, int,
399 struct demangle_component
*);
401 static struct demangle_component
*
402 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
403 struct demangle_component
*);
405 static struct demangle_component
*
406 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
407 struct demangle_component
*);
409 static struct demangle_component
*
410 d_make_template_param (struct d_info
*, int);
412 static struct demangle_component
*
413 d_make_sub (struct d_info
*, const char *, int);
416 has_return_type (struct demangle_component
*);
419 is_ctor_dtor_or_conversion (struct demangle_component
*);
421 static struct demangle_component
*d_encoding (struct d_info
*, int);
423 static struct demangle_component
*d_name (struct d_info
*);
425 static struct demangle_component
*d_nested_name (struct d_info
*);
427 static struct demangle_component
*d_prefix (struct d_info
*);
429 static struct demangle_component
*d_unqualified_name (struct d_info
*);
431 static struct demangle_component
*d_source_name (struct d_info
*);
433 static int d_number (struct d_info
*);
435 static struct demangle_component
*d_identifier (struct d_info
*, int);
437 static struct demangle_component
*d_operator_name (struct d_info
*);
439 static struct demangle_component
*d_special_name (struct d_info
*);
441 static struct demangle_component
*d_parmlist (struct d_info
*);
443 static int d_call_offset (struct d_info
*, int);
445 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
447 static struct demangle_component
**
448 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
450 static struct demangle_component
*
451 d_ref_qualifier (struct d_info
*, struct demangle_component
*);
453 static struct demangle_component
*
454 d_function_type (struct d_info
*);
456 static struct demangle_component
*
457 d_bare_function_type (struct d_info
*, int);
459 static struct demangle_component
*
460 d_class_enum_type (struct d_info
*);
462 static struct demangle_component
*d_array_type (struct d_info
*);
464 static struct demangle_component
*d_vector_type (struct d_info
*);
466 static struct demangle_component
*
467 d_pointer_to_member_type (struct d_info
*);
469 static struct demangle_component
*
470 d_template_param (struct d_info
*);
472 static struct demangle_component
*d_template_args (struct d_info
*);
473 static struct demangle_component
*d_template_args_1 (struct d_info
*);
475 static struct demangle_component
*
476 d_template_arg (struct d_info
*);
478 static struct demangle_component
*d_expression (struct d_info
*);
480 static struct demangle_component
*d_expr_primary (struct d_info
*);
482 static struct demangle_component
*d_local_name (struct d_info
*);
484 static int d_discriminator (struct d_info
*);
486 static struct demangle_component
*d_lambda (struct d_info
*);
488 static struct demangle_component
*d_unnamed_type (struct d_info
*);
490 static struct demangle_component
*
491 d_clone_suffix (struct d_info
*, struct demangle_component
*);
494 d_add_substitution (struct d_info
*, struct demangle_component
*);
496 static struct demangle_component
*d_substitution (struct d_info
*, int);
498 static void d_checkpoint (struct d_info
*, struct d_info_checkpoint
*);
500 static void d_backtrack (struct d_info
*, struct d_info_checkpoint
*);
502 static void d_growable_string_init (struct d_growable_string
*, size_t);
505 d_growable_string_resize (struct d_growable_string
*, size_t);
508 d_growable_string_append_buffer (struct d_growable_string
*,
509 const char *, size_t);
511 d_growable_string_callback_adapter (const char *, size_t, void *);
514 d_print_init (struct d_print_info
*, demangle_callbackref
, void *,
515 const struct demangle_component
*);
517 static inline void d_print_error (struct d_print_info
*);
519 static inline int d_print_saw_error (struct d_print_info
*);
521 static inline void d_print_flush (struct d_print_info
*);
523 static inline void d_append_char (struct d_print_info
*, char);
525 static inline void d_append_buffer (struct d_print_info
*,
526 const char *, size_t);
528 static inline void d_append_string (struct d_print_info
*, const char *);
530 static inline char d_last_char (struct d_print_info
*);
533 d_print_comp (struct d_print_info
*, int, const struct demangle_component
*);
536 d_print_java_identifier (struct d_print_info
*, const char *, int);
539 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
542 d_print_mod (struct d_print_info
*, int, const struct demangle_component
*);
545 d_print_function_type (struct d_print_info
*, int,
546 const struct demangle_component
*,
547 struct d_print_mod
*);
550 d_print_array_type (struct d_print_info
*, int,
551 const struct demangle_component
*,
552 struct d_print_mod
*);
555 d_print_expr_op (struct d_print_info
*, int, const struct demangle_component
*);
557 static void d_print_cast (struct d_print_info
*, int,
558 const struct demangle_component
*);
559 static void d_print_conversion (struct d_print_info
*, int,
560 const struct demangle_component
*);
562 static int d_demangle_callback (const char *, int,
563 demangle_callbackref
, void *);
564 static char *d_demangle (const char *, int, size_t *);
566 /* True iff TYPE is a demangling component representing a
567 function-type-qualifier. */
570 is_fnqual_component_type (enum demangle_component_type type
)
572 return (type
== DEMANGLE_COMPONENT_RESTRICT_THIS
573 || type
== DEMANGLE_COMPONENT_VOLATILE_THIS
574 || type
== DEMANGLE_COMPONENT_CONST_THIS
575 || type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
576 || type
== DEMANGLE_COMPONENT_TRANSACTION_SAFE
577 || type
== DEMANGLE_COMPONENT_NOEXCEPT
578 || type
== DEMANGLE_COMPONENT_THROW_SPEC
579 || type
== DEMANGLE_COMPONENT_REFERENCE_THIS
);
582 #define FNQUAL_COMPONENT_CASE \
583 case DEMANGLE_COMPONENT_RESTRICT_THIS: \
584 case DEMANGLE_COMPONENT_VOLATILE_THIS: \
585 case DEMANGLE_COMPONENT_CONST_THIS: \
586 case DEMANGLE_COMPONENT_REFERENCE_THIS: \
587 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
588 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
589 case DEMANGLE_COMPONENT_NOEXCEPT: \
590 case DEMANGLE_COMPONENT_THROW_SPEC
592 #ifdef CP_DEMANGLE_DEBUG
595 d_dump (struct demangle_component
*dc
, int indent
)
602 printf ("failed demangling\n");
606 for (i
= 0; i
< indent
; ++i
)
611 case DEMANGLE_COMPONENT_NAME
:
612 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
614 case DEMANGLE_COMPONENT_TAGGED_NAME
:
615 printf ("tagged name\n");
616 d_dump (dc
->u
.s_binary
.left
, indent
+ 2);
617 d_dump (dc
->u
.s_binary
.right
, indent
+ 2);
619 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
620 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
622 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
623 printf ("function parameter %ld\n", dc
->u
.s_number
.number
);
625 case DEMANGLE_COMPONENT_CTOR
:
626 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
627 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
629 case DEMANGLE_COMPONENT_DTOR
:
630 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
631 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
633 case DEMANGLE_COMPONENT_SUB_STD
:
634 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
636 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
637 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
639 case DEMANGLE_COMPONENT_OPERATOR
:
640 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
642 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
643 printf ("extended operator with %d args\n",
644 dc
->u
.s_extended_operator
.args
);
645 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
648 case DEMANGLE_COMPONENT_QUAL_NAME
:
649 printf ("qualified name\n");
651 case DEMANGLE_COMPONENT_LOCAL_NAME
:
652 printf ("local name\n");
654 case DEMANGLE_COMPONENT_TYPED_NAME
:
655 printf ("typed name\n");
657 case DEMANGLE_COMPONENT_TEMPLATE
:
658 printf ("template\n");
660 case DEMANGLE_COMPONENT_VTABLE
:
663 case DEMANGLE_COMPONENT_VTT
:
666 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
667 printf ("construction vtable\n");
669 case DEMANGLE_COMPONENT_TYPEINFO
:
670 printf ("typeinfo\n");
672 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
673 printf ("typeinfo name\n");
675 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
676 printf ("typeinfo function\n");
678 case DEMANGLE_COMPONENT_THUNK
:
681 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
682 printf ("virtual thunk\n");
684 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
685 printf ("covariant thunk\n");
687 case DEMANGLE_COMPONENT_JAVA_CLASS
:
688 printf ("java class\n");
690 case DEMANGLE_COMPONENT_GUARD
:
693 case DEMANGLE_COMPONENT_REFTEMP
:
694 printf ("reference temporary\n");
696 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
697 printf ("hidden alias\n");
699 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
700 printf ("transaction clone\n");
702 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
703 printf ("non-transaction clone\n");
705 case DEMANGLE_COMPONENT_RESTRICT
:
706 printf ("restrict\n");
708 case DEMANGLE_COMPONENT_VOLATILE
:
709 printf ("volatile\n");
711 case DEMANGLE_COMPONENT_CONST
:
714 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
715 printf ("restrict this\n");
717 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
718 printf ("volatile this\n");
720 case DEMANGLE_COMPONENT_CONST_THIS
:
721 printf ("const this\n");
723 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
724 printf ("reference this\n");
726 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
727 printf ("rvalue reference this\n");
729 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
730 printf ("transaction_safe this\n");
732 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
733 printf ("vendor type qualifier\n");
735 case DEMANGLE_COMPONENT_POINTER
:
736 printf ("pointer\n");
738 case DEMANGLE_COMPONENT_REFERENCE
:
739 printf ("reference\n");
741 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
742 printf ("rvalue reference\n");
744 case DEMANGLE_COMPONENT_COMPLEX
:
745 printf ("complex\n");
747 case DEMANGLE_COMPONENT_IMAGINARY
:
748 printf ("imaginary\n");
750 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
751 printf ("vendor type\n");
753 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
754 printf ("function type\n");
756 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
757 printf ("array type\n");
759 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
760 printf ("pointer to member type\n");
762 case DEMANGLE_COMPONENT_FIXED_TYPE
:
763 printf ("fixed-point type, accum? %d, sat? %d\n",
764 dc
->u
.s_fixed
.accum
, dc
->u
.s_fixed
.sat
);
765 d_dump (dc
->u
.s_fixed
.length
, indent
+ 2);
767 case DEMANGLE_COMPONENT_ARGLIST
:
768 printf ("argument list\n");
770 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
771 printf ("template argument list\n");
773 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
774 printf ("initializer list\n");
776 case DEMANGLE_COMPONENT_CAST
:
779 case DEMANGLE_COMPONENT_CONVERSION
:
780 printf ("conversion operator\n");
782 case DEMANGLE_COMPONENT_NULLARY
:
783 printf ("nullary operator\n");
785 case DEMANGLE_COMPONENT_UNARY
:
786 printf ("unary operator\n");
788 case DEMANGLE_COMPONENT_BINARY
:
789 printf ("binary operator\n");
791 case DEMANGLE_COMPONENT_BINARY_ARGS
:
792 printf ("binary operator arguments\n");
794 case DEMANGLE_COMPONENT_TRINARY
:
795 printf ("trinary operator\n");
797 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
798 printf ("trinary operator arguments 1\n");
800 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
801 printf ("trinary operator arguments 1\n");
803 case DEMANGLE_COMPONENT_LITERAL
:
804 printf ("literal\n");
806 case DEMANGLE_COMPONENT_LITERAL_NEG
:
807 printf ("negative literal\n");
809 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
810 printf ("java resource\n");
812 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
813 printf ("compound name\n");
815 case DEMANGLE_COMPONENT_CHARACTER
:
816 printf ("character '%c'\n", dc
->u
.s_character
.character
);
818 case DEMANGLE_COMPONENT_NUMBER
:
819 printf ("number %ld\n", dc
->u
.s_number
.number
);
821 case DEMANGLE_COMPONENT_DECLTYPE
:
822 printf ("decltype\n");
824 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
825 printf ("pack expansion\n");
827 case DEMANGLE_COMPONENT_TLS_INIT
:
828 printf ("tls init function\n");
830 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
831 printf ("tls wrapper function\n");
833 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
834 printf ("default argument %d\n", dc
->u
.s_unary_num
.num
);
835 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
837 case DEMANGLE_COMPONENT_LAMBDA
:
838 printf ("lambda %d\n", dc
->u
.s_unary_num
.num
);
839 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
843 d_dump (d_left (dc
), indent
+ 2);
844 d_dump (d_right (dc
), indent
+ 2);
847 #endif /* CP_DEMANGLE_DEBUG */
849 /* Fill in a DEMANGLE_COMPONENT_NAME. */
851 CP_STATIC_IF_GLIBCPP_V3
853 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
855 if (p
== NULL
|| s
== NULL
|| len
== 0)
857 p
->type
= DEMANGLE_COMPONENT_NAME
;
859 p
->u
.s_name
.len
= len
;
863 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
865 CP_STATIC_IF_GLIBCPP_V3
867 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
868 struct demangle_component
*name
)
870 if (p
== NULL
|| args
< 0 || name
== NULL
)
872 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
873 p
->u
.s_extended_operator
.args
= args
;
874 p
->u
.s_extended_operator
.name
= name
;
878 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
880 CP_STATIC_IF_GLIBCPP_V3
882 cplus_demangle_fill_ctor (struct demangle_component
*p
,
883 enum gnu_v3_ctor_kinds kind
,
884 struct demangle_component
*name
)
888 || (int) kind
< gnu_v3_complete_object_ctor
889 || (int) kind
> gnu_v3_object_ctor_group
)
891 p
->type
= DEMANGLE_COMPONENT_CTOR
;
892 p
->u
.s_ctor
.kind
= kind
;
893 p
->u
.s_ctor
.name
= name
;
897 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
899 CP_STATIC_IF_GLIBCPP_V3
901 cplus_demangle_fill_dtor (struct demangle_component
*p
,
902 enum gnu_v3_dtor_kinds kind
,
903 struct demangle_component
*name
)
907 || (int) kind
< gnu_v3_deleting_dtor
908 || (int) kind
> gnu_v3_object_dtor_group
)
910 p
->type
= DEMANGLE_COMPONENT_DTOR
;
911 p
->u
.s_dtor
.kind
= kind
;
912 p
->u
.s_dtor
.name
= name
;
916 /* Add a new component. */
918 static struct demangle_component
*
919 d_make_empty (struct d_info
*di
)
921 struct demangle_component
*p
;
923 if (di
->next_comp
>= di
->num_comps
)
925 p
= &di
->comps
[di
->next_comp
];
930 /* Add a new generic component. */
932 static struct demangle_component
*
933 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
934 struct demangle_component
*left
,
935 struct demangle_component
*right
)
937 struct demangle_component
*p
;
939 /* We check for errors here. A typical error would be a NULL return
940 from a subroutine. We catch those here, and return NULL
944 /* These types require two parameters. */
945 case DEMANGLE_COMPONENT_QUAL_NAME
:
946 case DEMANGLE_COMPONENT_LOCAL_NAME
:
947 case DEMANGLE_COMPONENT_TYPED_NAME
:
948 case DEMANGLE_COMPONENT_TAGGED_NAME
:
949 case DEMANGLE_COMPONENT_TEMPLATE
:
950 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
951 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
952 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
953 case DEMANGLE_COMPONENT_UNARY
:
954 case DEMANGLE_COMPONENT_BINARY
:
955 case DEMANGLE_COMPONENT_BINARY_ARGS
:
956 case DEMANGLE_COMPONENT_TRINARY
:
957 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
958 case DEMANGLE_COMPONENT_LITERAL
:
959 case DEMANGLE_COMPONENT_LITERAL_NEG
:
960 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
961 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
962 case DEMANGLE_COMPONENT_CLONE
:
963 if (left
== NULL
|| right
== NULL
)
967 /* These types only require one parameter. */
968 case DEMANGLE_COMPONENT_VTABLE
:
969 case DEMANGLE_COMPONENT_VTT
:
970 case DEMANGLE_COMPONENT_TYPEINFO
:
971 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
972 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
973 case DEMANGLE_COMPONENT_THUNK
:
974 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
975 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
976 case DEMANGLE_COMPONENT_JAVA_CLASS
:
977 case DEMANGLE_COMPONENT_GUARD
:
978 case DEMANGLE_COMPONENT_TLS_INIT
:
979 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
980 case DEMANGLE_COMPONENT_REFTEMP
:
981 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
982 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
983 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
984 case DEMANGLE_COMPONENT_POINTER
:
985 case DEMANGLE_COMPONENT_REFERENCE
:
986 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
987 case DEMANGLE_COMPONENT_COMPLEX
:
988 case DEMANGLE_COMPONENT_IMAGINARY
:
989 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
990 case DEMANGLE_COMPONENT_CAST
:
991 case DEMANGLE_COMPONENT_CONVERSION
:
992 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
993 case DEMANGLE_COMPONENT_DECLTYPE
:
994 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
995 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
996 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
997 case DEMANGLE_COMPONENT_NULLARY
:
998 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
1003 /* This needs a right parameter, but the left parameter can be
1005 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
1006 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
1011 /* These are allowed to have no parameters--in some cases they
1012 will be filled in later. */
1013 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
1014 case DEMANGLE_COMPONENT_RESTRICT
:
1015 case DEMANGLE_COMPONENT_VOLATILE
:
1016 case DEMANGLE_COMPONENT_CONST
:
1017 case DEMANGLE_COMPONENT_ARGLIST
:
1018 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
1019 FNQUAL_COMPONENT_CASE
:
1022 /* Other types should not be seen here. */
1027 p
= d_make_empty (di
);
1031 p
->u
.s_binary
.left
= left
;
1032 p
->u
.s_binary
.right
= right
;
1037 /* Add a new demangle mangled name component. */
1039 static struct demangle_component
*
1040 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
1042 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
1043 return d_make_name (di
, s
, strlen (s
));
1045 return d_encoding (di
, 0);
1048 /* Add a new name component. */
1050 static struct demangle_component
*
1051 d_make_name (struct d_info
*di
, const char *s
, int len
)
1053 struct demangle_component
*p
;
1055 p
= d_make_empty (di
);
1056 if (! cplus_demangle_fill_name (p
, s
, len
))
1061 /* Add a new builtin type component. */
1063 static struct demangle_component
*
1064 d_make_builtin_type (struct d_info
*di
,
1065 const struct demangle_builtin_type_info
*type
)
1067 struct demangle_component
*p
;
1071 p
= d_make_empty (di
);
1074 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
1075 p
->u
.s_builtin
.type
= type
;
1080 /* Add a new operator component. */
1082 static struct demangle_component
*
1083 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
1085 struct demangle_component
*p
;
1087 p
= d_make_empty (di
);
1090 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
1091 p
->u
.s_operator
.op
= op
;
1096 /* Add a new extended operator component. */
1098 static struct demangle_component
*
1099 d_make_extended_operator (struct d_info
*di
, int args
,
1100 struct demangle_component
*name
)
1102 struct demangle_component
*p
;
1104 p
= d_make_empty (di
);
1105 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
1110 static struct demangle_component
*
1111 d_make_default_arg (struct d_info
*di
, int num
,
1112 struct demangle_component
*sub
)
1114 struct demangle_component
*p
= d_make_empty (di
);
1117 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1118 p
->u
.s_unary_num
.num
= num
;
1119 p
->u
.s_unary_num
.sub
= sub
;
1124 /* Add a new constructor component. */
1126 static struct demangle_component
*
1127 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1128 struct demangle_component
*name
)
1130 struct demangle_component
*p
;
1132 p
= d_make_empty (di
);
1133 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1138 /* Add a new destructor component. */
1140 static struct demangle_component
*
1141 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1142 struct demangle_component
*name
)
1144 struct demangle_component
*p
;
1146 p
= d_make_empty (di
);
1147 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1152 /* Add a new template parameter. */
1154 static struct demangle_component
*
1155 d_make_template_param (struct d_info
*di
, int i
)
1157 struct demangle_component
*p
;
1159 p
= d_make_empty (di
);
1162 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1163 p
->u
.s_number
.number
= i
;
1168 /* Add a new function parameter. */
1170 static struct demangle_component
*
1171 d_make_function_param (struct d_info
*di
, int i
)
1173 struct demangle_component
*p
;
1175 p
= d_make_empty (di
);
1178 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1179 p
->u
.s_number
.number
= i
;
1184 /* Add a new standard substitution component. */
1186 static struct demangle_component
*
1187 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1189 struct demangle_component
*p
;
1191 p
= d_make_empty (di
);
1194 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1195 p
->u
.s_string
.string
= name
;
1196 p
->u
.s_string
.len
= len
;
1201 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1203 TOP_LEVEL is non-zero when called at the top level. */
1205 CP_STATIC_IF_GLIBCPP_V3
1206 struct demangle_component
*
1207 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1209 struct demangle_component
*p
;
1211 if (! d_check_char (di
, '_')
1212 /* Allow missing _ if not at toplevel to work around a
1213 bug in G++ abi-version=2 mangling; see the comment in
1214 write_template_arg. */
1217 if (! d_check_char (di
, 'Z'))
1219 p
= d_encoding (di
, top_level
);
1221 /* If at top level and parsing parameters, check for a clone
1223 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1224 while (d_peek_char (di
) == '.'
1225 && (IS_LOWER (d_peek_next_char (di
))
1226 || d_peek_next_char (di
) == '_'
1227 || IS_DIGIT (d_peek_next_char (di
))))
1228 p
= d_clone_suffix (di
, p
);
1233 /* Return whether a function should have a return type. The argument
1234 is the function name, which may be qualified in various ways. The
1235 rules are that template functions have return types with some
1236 exceptions, function types which are not part of a function name
1237 mangling have return types with some exceptions, and non-template
1238 function names do not have return types. The exceptions are that
1239 constructors, destructors, and conversion operators do not have
1243 has_return_type (struct demangle_component
*dc
)
1251 case DEMANGLE_COMPONENT_TEMPLATE
:
1252 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1253 FNQUAL_COMPONENT_CASE
:
1254 return has_return_type (d_left (dc
));
1258 /* Return whether a name is a constructor, a destructor, or a
1259 conversion operator. */
1262 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1270 case DEMANGLE_COMPONENT_QUAL_NAME
:
1271 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1272 return is_ctor_dtor_or_conversion (d_right (dc
));
1273 case DEMANGLE_COMPONENT_CTOR
:
1274 case DEMANGLE_COMPONENT_DTOR
:
1275 case DEMANGLE_COMPONENT_CONVERSION
:
1280 /* <encoding> ::= <(function) name> <bare-function-type>
1284 TOP_LEVEL is non-zero when called at the top level, in which case
1285 if DMGL_PARAMS is not set we do not demangle the function
1286 parameters. We only set this at the top level, because otherwise
1287 we would not correctly demangle names in local scopes. */
1289 static struct demangle_component
*
1290 d_encoding (struct d_info
*di
, int top_level
)
1292 char peek
= d_peek_char (di
);
1294 if (peek
== 'G' || peek
== 'T')
1295 return d_special_name (di
);
1298 struct demangle_component
*dc
;
1302 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1304 /* Strip off any initial CV-qualifiers, as they really apply
1305 to the `this' parameter, and they were not output by the
1306 v2 demangler without DMGL_PARAMS. */
1307 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1308 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1309 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
1310 || dc
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
1311 || dc
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
)
1314 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1315 there may be function-qualifiers on its right argument which
1316 really apply here; this happens when parsing a class
1317 which is local to a function. */
1318 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1320 struct demangle_component
*dcr
;
1323 while (is_fnqual_component_type (dcr
->type
))
1325 dc
->u
.s_binary
.right
= dcr
;
1331 peek
= d_peek_char (di
);
1332 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1334 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1335 d_bare_function_type (di
, has_return_type (dc
)));
1339 /* <tagged-name> ::= <name> B <source-name> */
1341 static struct demangle_component
*
1342 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1344 struct demangle_component
*hold_last_name
;
1347 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1348 hold_last_name
= di
->last_name
;
1350 while (peek
= d_peek_char (di
),
1353 struct demangle_component
*tag
;
1355 tag
= d_source_name (di
);
1356 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1359 di
->last_name
= hold_last_name
;
1364 /* <name> ::= <nested-name>
1366 ::= <unscoped-template-name> <template-args>
1369 <unscoped-name> ::= <unqualified-name>
1370 ::= St <unqualified-name>
1372 <unscoped-template-name> ::= <unscoped-name>
1376 static struct demangle_component
*
1377 d_name (struct d_info
*di
)
1379 char peek
= d_peek_char (di
);
1380 struct demangle_component
*dc
;
1385 return d_nested_name (di
);
1388 return d_local_name (di
);
1391 return d_unqualified_name (di
);
1397 if (d_peek_next_char (di
) != 't')
1399 dc
= d_substitution (di
, 0);
1405 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1406 d_make_name (di
, "std", 3),
1407 d_unqualified_name (di
));
1412 if (d_peek_char (di
) != 'I')
1414 /* The grammar does not permit this case to occur if we
1415 called d_substitution() above (i.e., subst == 1). We
1416 don't bother to check. */
1420 /* This is <template-args>, which means that we just saw
1421 <unscoped-template-name>, which is a substitution
1422 candidate if we didn't just get it from a
1426 if (! d_add_substitution (di
, dc
))
1429 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1430 d_template_args (di
));
1438 dc
= d_unqualified_name (di
);
1439 if (d_peek_char (di
) == 'I')
1441 /* This is <template-args>, which means that we just saw
1442 <unscoped-template-name>, which is a substitution
1444 if (! d_add_substitution (di
, dc
))
1446 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1447 d_template_args (di
));
1453 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1454 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1457 static struct demangle_component
*
1458 d_nested_name (struct d_info
*di
)
1460 struct demangle_component
*ret
;
1461 struct demangle_component
**pret
;
1462 struct demangle_component
*rqual
;
1464 if (! d_check_char (di
, 'N'))
1467 pret
= d_cv_qualifiers (di
, &ret
, 1);
1471 /* Parse the ref-qualifier now and then attach it
1472 once we have something to attach it to. */
1473 rqual
= d_ref_qualifier (di
, NULL
);
1475 *pret
= d_prefix (di
);
1481 d_left (rqual
) = ret
;
1485 if (! d_check_char (di
, 'E'))
1491 /* <prefix> ::= <prefix> <unqualified-name>
1492 ::= <template-prefix> <template-args>
1493 ::= <template-param>
1498 <template-prefix> ::= <prefix> <(template) unqualified-name>
1499 ::= <template-param>
1503 static struct demangle_component
*
1504 d_prefix (struct d_info
*di
)
1506 struct demangle_component
*ret
= NULL
;
1511 enum demangle_component_type comb_type
;
1512 struct demangle_component
*dc
;
1514 peek
= d_peek_char (di
);
1518 /* The older code accepts a <local-name> here, but I don't see
1519 that in the grammar. The older code does not accept a
1520 <template-param> here. */
1522 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1525 char peek2
= d_peek_next_char (di
);
1526 if (peek2
== 'T' || peek2
== 't')
1528 dc
= cplus_demangle_type (di
);
1530 /* Destructor name. */
1531 dc
= d_unqualified_name (di
);
1533 else if (IS_DIGIT (peek
)
1538 dc
= d_unqualified_name (di
);
1539 else if (peek
== 'S')
1540 dc
= d_substitution (di
, 1);
1541 else if (peek
== 'I')
1545 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1546 dc
= d_template_args (di
);
1548 else if (peek
== 'T')
1549 dc
= d_template_param (di
);
1550 else if (peek
== 'E')
1552 else if (peek
== 'M')
1554 /* Initializer scope for a lambda. We don't need to represent
1555 this; the normal code will just treat the variable as a type
1556 scope, which gives appropriate output. */
1568 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1570 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1572 if (! d_add_substitution (di
, ret
))
1578 /* <unqualified-name> ::= <operator-name>
1579 ::= <ctor-dtor-name>
1581 ::= <local-source-name>
1583 <local-source-name> ::= L <source-name> <discriminator>
1586 static struct demangle_component
*
1587 d_unqualified_name (struct d_info
*di
)
1589 struct demangle_component
*ret
;
1592 peek
= d_peek_char (di
);
1593 if (IS_DIGIT (peek
))
1594 ret
= d_source_name (di
);
1595 else if (IS_LOWER (peek
))
1597 ret
= d_operator_name (di
);
1598 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1600 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1601 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1602 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1603 d_source_name (di
));
1606 else if (peek
== 'C' || peek
== 'D')
1607 ret
= d_ctor_dtor_name (di
);
1608 else if (peek
== 'L')
1612 ret
= d_source_name (di
);
1615 if (! d_discriminator (di
))
1618 else if (peek
== 'U')
1620 switch (d_peek_next_char (di
))
1623 ret
= d_lambda (di
);
1626 ret
= d_unnamed_type (di
);
1635 if (d_peek_char (di
) == 'B')
1636 ret
= d_abi_tags (di
, ret
);
1640 /* <source-name> ::= <(positive length) number> <identifier> */
1642 static struct demangle_component
*
1643 d_source_name (struct d_info
*di
)
1646 struct demangle_component
*ret
;
1648 len
= d_number (di
);
1651 ret
= d_identifier (di
, len
);
1652 di
->last_name
= ret
;
1656 /* number ::= [n] <(non-negative decimal integer)> */
1659 d_number (struct d_info
*di
)
1666 peek
= d_peek_char (di
);
1671 peek
= d_peek_char (di
);
1677 if (! IS_DIGIT (peek
))
1683 ret
= ret
* 10 + peek
- '0';
1685 peek
= d_peek_char (di
);
1689 /* Like d_number, but returns a demangle_component. */
1691 static struct demangle_component
*
1692 d_number_component (struct d_info
*di
)
1694 struct demangle_component
*ret
= d_make_empty (di
);
1697 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1698 ret
->u
.s_number
.number
= d_number (di
);
1703 /* identifier ::= <(unqualified source code identifier)> */
1705 static struct demangle_component
*
1706 d_identifier (struct d_info
*di
, int len
)
1712 if (di
->send
- name
< len
)
1715 d_advance (di
, len
);
1717 /* A Java mangled name may have a trailing '$' if it is a C++
1718 keyword. This '$' is not included in the length count. We just
1720 if ((di
->options
& DMGL_JAVA
) != 0
1721 && d_peek_char (di
) == '$')
1724 /* Look for something which looks like a gcc encoding of an
1725 anonymous namespace, and replace it with a more user friendly
1727 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1728 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1729 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1733 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1734 if ((*s
== '.' || *s
== '_' || *s
== '$')
1737 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1738 return d_make_name (di
, "(anonymous namespace)",
1739 sizeof "(anonymous namespace)" - 1);
1743 return d_make_name (di
, name
, len
);
1746 /* operator_name ::= many different two character encodings.
1748 ::= v <digit> <source-name>
1750 This list is sorted for binary search. */
1752 #define NL(s) s, (sizeof s) - 1
1754 CP_STATIC_IF_GLIBCPP_V3
1755 const struct demangle_operator_info cplus_demangle_operators
[] =
1757 { "aN", NL ("&="), 2 },
1758 { "aS", NL ("="), 2 },
1759 { "aa", NL ("&&"), 2 },
1760 { "ad", NL ("&"), 1 },
1761 { "an", NL ("&"), 2 },
1762 { "at", NL ("alignof "), 1 },
1763 { "az", NL ("alignof "), 1 },
1764 { "cc", NL ("const_cast"), 2 },
1765 { "cl", NL ("()"), 2 },
1766 { "cm", NL (","), 2 },
1767 { "co", NL ("~"), 1 },
1768 { "dV", NL ("/="), 2 },
1769 { "da", NL ("delete[] "), 1 },
1770 { "dc", NL ("dynamic_cast"), 2 },
1771 { "de", NL ("*"), 1 },
1772 { "dl", NL ("delete "), 1 },
1773 { "ds", NL (".*"), 2 },
1774 { "dt", NL ("."), 2 },
1775 { "dv", NL ("/"), 2 },
1776 { "eO", NL ("^="), 2 },
1777 { "eo", NL ("^"), 2 },
1778 { "eq", NL ("=="), 2 },
1779 { "fL", NL ("..."), 3 },
1780 { "fR", NL ("..."), 3 },
1781 { "fl", NL ("..."), 2 },
1782 { "fr", NL ("..."), 2 },
1783 { "ge", NL (">="), 2 },
1784 { "gs", NL ("::"), 1 },
1785 { "gt", NL (">"), 2 },
1786 { "ix", NL ("[]"), 2 },
1787 { "lS", NL ("<<="), 2 },
1788 { "le", NL ("<="), 2 },
1789 { "li", NL ("operator\"\" "), 1 },
1790 { "ls", NL ("<<"), 2 },
1791 { "lt", NL ("<"), 2 },
1792 { "mI", NL ("-="), 2 },
1793 { "mL", NL ("*="), 2 },
1794 { "mi", NL ("-"), 2 },
1795 { "ml", NL ("*"), 2 },
1796 { "mm", NL ("--"), 1 },
1797 { "na", NL ("new[]"), 3 },
1798 { "ne", NL ("!="), 2 },
1799 { "ng", NL ("-"), 1 },
1800 { "nt", NL ("!"), 1 },
1801 { "nw", NL ("new"), 3 },
1802 { "oR", NL ("|="), 2 },
1803 { "oo", NL ("||"), 2 },
1804 { "or", NL ("|"), 2 },
1805 { "pL", NL ("+="), 2 },
1806 { "pl", NL ("+"), 2 },
1807 { "pm", NL ("->*"), 2 },
1808 { "pp", NL ("++"), 1 },
1809 { "ps", NL ("+"), 1 },
1810 { "pt", NL ("->"), 2 },
1811 { "qu", NL ("?"), 3 },
1812 { "rM", NL ("%="), 2 },
1813 { "rS", NL (">>="), 2 },
1814 { "rc", NL ("reinterpret_cast"), 2 },
1815 { "rm", NL ("%"), 2 },
1816 { "rs", NL (">>"), 2 },
1817 { "sP", NL ("sizeof..."), 1 },
1818 { "sZ", NL ("sizeof..."), 1 },
1819 { "sc", NL ("static_cast"), 2 },
1820 { "st", NL ("sizeof "), 1 },
1821 { "sz", NL ("sizeof "), 1 },
1822 { "tr", NL ("throw"), 0 },
1823 { "tw", NL ("throw "), 1 },
1824 { NULL
, NULL
, 0, 0 }
1827 static struct demangle_component
*
1828 d_operator_name (struct d_info
*di
)
1833 c1
= d_next_char (di
);
1834 c2
= d_next_char (di
);
1835 if (c1
== 'v' && IS_DIGIT (c2
))
1836 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1837 else if (c1
== 'c' && c2
== 'v')
1839 struct demangle_component
*type
;
1840 int was_conversion
= di
->is_conversion
;
1841 struct demangle_component
*res
;
1843 di
->is_conversion
= ! di
->is_expression
;
1844 type
= cplus_demangle_type (di
);
1845 if (di
->is_conversion
)
1846 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1848 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1849 di
->is_conversion
= was_conversion
;
1854 /* LOW is the inclusive lower bound. */
1856 /* HIGH is the exclusive upper bound. We subtract one to ignore
1857 the sentinel at the end of the array. */
1858 int high
= ((sizeof (cplus_demangle_operators
)
1859 / sizeof (cplus_demangle_operators
[0]))
1865 const struct demangle_operator_info
*p
;
1867 i
= low
+ (high
- low
) / 2;
1868 p
= cplus_demangle_operators
+ i
;
1870 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1871 return d_make_operator (di
, p
);
1873 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1883 static struct demangle_component
*
1884 d_make_character (struct d_info
*di
, int c
)
1886 struct demangle_component
*p
;
1887 p
= d_make_empty (di
);
1890 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1891 p
->u
.s_character
.character
= c
;
1896 static struct demangle_component
*
1897 d_java_resource (struct d_info
*di
)
1899 struct demangle_component
*p
= NULL
;
1900 struct demangle_component
*next
= NULL
;
1905 len
= d_number (di
);
1909 /* Eat the leading '_'. */
1910 if (d_next_char (di
) != '_')
1923 /* Each chunk is either a '$' escape... */
1941 next
= d_make_character (di
, c
);
1949 /* ... or a sequence of characters. */
1952 while (i
< len
&& str
[i
] && str
[i
] != '$')
1955 next
= d_make_name (di
, str
, i
);
1968 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
1974 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
1979 /* <special-name> ::= TV <type>
1983 ::= GV <(object) name>
1984 ::= T <call-offset> <(base) encoding>
1985 ::= Tc <call-offset> <call-offset> <(base) encoding>
1986 Also g++ extensions:
1987 ::= TC <type> <(offset) number> _ <(base) type>
1992 ::= Gr <resource name>
1997 static struct demangle_component
*
1998 d_special_name (struct d_info
*di
)
2000 di
->expansion
+= 20;
2001 if (d_check_char (di
, 'T'))
2003 switch (d_next_char (di
))
2007 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2008 cplus_demangle_type (di
), NULL
);
2010 di
->expansion
-= 10;
2011 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2012 cplus_demangle_type (di
), NULL
);
2014 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2015 cplus_demangle_type (di
), NULL
);
2017 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2018 cplus_demangle_type (di
), NULL
);
2021 if (! d_call_offset (di
, 'h'))
2023 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2024 d_encoding (di
, 0), NULL
);
2027 if (! d_call_offset (di
, 'v'))
2029 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2030 d_encoding (di
, 0), NULL
);
2033 if (! d_call_offset (di
, '\0'))
2035 if (! d_call_offset (di
, '\0'))
2037 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2038 d_encoding (di
, 0), NULL
);
2042 struct demangle_component
*derived_type
;
2044 struct demangle_component
*base_type
;
2046 derived_type
= cplus_demangle_type (di
);
2047 offset
= d_number (di
);
2050 if (! d_check_char (di
, '_'))
2052 base_type
= cplus_demangle_type (di
);
2053 /* We don't display the offset. FIXME: We should display
2054 it in verbose mode. */
2056 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2057 base_type
, derived_type
);
2061 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2062 cplus_demangle_type (di
), NULL
);
2064 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2065 cplus_demangle_type (di
), NULL
);
2068 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2072 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2079 else if (d_check_char (di
, 'G'))
2081 switch (d_next_char (di
))
2084 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
2088 struct demangle_component
*name
= d_name (di
);
2089 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2090 d_number_component (di
));
2094 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2095 d_encoding (di
, 0), NULL
);
2098 switch (d_next_char (di
))
2101 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2102 d_encoding (di
, 0), NULL
);
2104 /* ??? The proposal is that other letters (such as 'h') stand
2105 for different variants of transaction cloning, such as
2106 compiling directly for hardware transaction support. But
2107 they still should all be transactional clones of some sort
2108 so go ahead and call them that. */
2110 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2111 d_encoding (di
, 0), NULL
);
2115 return d_java_resource (di
);
2125 /* <call-offset> ::= h <nv-offset> _
2128 <nv-offset> ::= <(offset) number>
2130 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2132 The C parameter, if not '\0', is a character we just read which is
2133 the start of the <call-offset>.
2135 We don't display the offset information anywhere. FIXME: We should
2136 display it in verbose mode. */
2139 d_call_offset (struct d_info
*di
, int c
)
2142 c
= d_next_char (di
);
2149 if (! d_check_char (di
, '_'))
2156 if (! d_check_char (di
, '_'))
2162 /* <ctor-dtor-name> ::= C1
2170 static struct demangle_component
*
2171 d_ctor_dtor_name (struct d_info
*di
)
2173 if (di
->last_name
!= NULL
)
2175 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2176 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2177 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2178 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2180 switch (d_peek_char (di
))
2184 enum gnu_v3_ctor_kinds kind
;
2187 if (d_peek_next_char (di
) == 'I')
2193 switch (d_peek_next_char (di
))
2196 kind
= gnu_v3_complete_object_ctor
;
2199 kind
= gnu_v3_base_object_ctor
;
2202 kind
= gnu_v3_complete_object_allocating_ctor
;
2205 kind
= gnu_v3_unified_ctor
;
2208 kind
= gnu_v3_object_ctor_group
;
2217 cplus_demangle_type (di
);
2219 return d_make_ctor (di
, kind
, di
->last_name
);
2224 enum gnu_v3_dtor_kinds kind
;
2226 switch (d_peek_next_char (di
))
2229 kind
= gnu_v3_deleting_dtor
;
2232 kind
= gnu_v3_complete_object_dtor
;
2235 kind
= gnu_v3_base_object_dtor
;
2237 /* digit '3' is not used */
2239 kind
= gnu_v3_unified_dtor
;
2242 kind
= gnu_v3_object_dtor_group
;
2248 return d_make_dtor (di
, kind
, di
->last_name
);
2256 /* True iff we're looking at an order-insensitive type-qualifier, including
2257 function-type-qualifiers. */
2260 next_is_type_qual (struct d_info
*di
)
2262 char peek
= d_peek_char (di
);
2263 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2267 peek
= d_peek_next_char (di
);
2268 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2274 /* <type> ::= <builtin-type>
2276 ::= <class-enum-type>
2278 ::= <pointer-to-member-type>
2279 ::= <template-param>
2280 ::= <template-template-param> <template-args>
2282 ::= <CV-qualifiers> <type>
2285 ::= O <type> (C++0x)
2288 ::= U <source-name> <type>
2290 <builtin-type> ::= various one letter codes
2294 CP_STATIC_IF_GLIBCPP_V3
2295 const struct demangle_builtin_type_info
2296 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2298 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2299 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2300 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2301 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2302 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2303 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2304 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2305 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2306 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2307 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2308 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2309 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2310 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2311 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2312 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2314 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2315 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2316 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2317 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2318 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2319 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2320 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2321 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2322 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2323 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2324 D_PRINT_UNSIGNED_LONG_LONG
},
2325 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2326 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2327 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2328 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2329 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2330 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2331 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2332 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2336 CP_STATIC_IF_GLIBCPP_V3
2337 struct demangle_component
*
2338 cplus_demangle_type (struct d_info
*di
)
2341 struct demangle_component
*ret
;
2344 /* The ABI specifies that when CV-qualifiers are used, the base type
2345 is substitutable, and the fully qualified type is substitutable,
2346 but the base type with a strict subset of the CV-qualifiers is
2347 not substitutable. The natural recursive implementation of the
2348 CV-qualifiers would cause subsets to be substitutable, so instead
2349 we pull them all off now.
2351 FIXME: The ABI says that order-insensitive vendor qualifiers
2352 should be handled in the same way, but we have no way to tell
2353 which vendor qualifiers are order-insensitive and which are
2354 order-sensitive. So we just assume that they are all
2355 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2356 __vector, and it treats it as order-sensitive when mangling
2359 if (next_is_type_qual (di
))
2361 struct demangle_component
**pret
;
2363 pret
= d_cv_qualifiers (di
, &ret
, 0);
2366 if (d_peek_char (di
) == 'F')
2368 /* cv-qualifiers before a function type apply to 'this',
2369 so avoid adding the unqualified function type to
2370 the substitution list. */
2371 *pret
= d_function_type (di
);
2374 *pret
= cplus_demangle_type (di
);
2377 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2378 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2380 /* Move the ref-qualifier outside the cv-qualifiers so that
2381 they are printed in the right order. */
2382 struct demangle_component
*fn
= d_left (*pret
);
2383 d_left (*pret
) = ret
;
2387 if (! d_add_substitution (di
, ret
))
2394 peek
= d_peek_char (di
);
2397 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2398 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2399 case 'o': case 's': case 't':
2400 case 'v': case 'w': case 'x': case 'y': case 'z':
2401 ret
= d_make_builtin_type (di
,
2402 &cplus_demangle_builtin_types
[peek
- 'a']);
2403 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2410 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2411 d_source_name (di
), NULL
);
2415 ret
= d_function_type (di
);
2418 case '0': case '1': case '2': case '3': case '4':
2419 case '5': case '6': case '7': case '8': case '9':
2422 ret
= d_class_enum_type (di
);
2426 ret
= d_array_type (di
);
2430 ret
= d_pointer_to_member_type (di
);
2434 ret
= d_template_param (di
);
2435 if (d_peek_char (di
) == 'I')
2437 /* This may be <template-template-param> <template-args>.
2438 If this is the type for a conversion operator, we can
2439 have a <template-template-param> here only by following
2440 a derivation like this:
2443 -> <template-prefix> <template-args>
2444 -> <prefix> <template-unqualified-name> <template-args>
2445 -> <unqualified-name> <template-unqualified-name> <template-args>
2446 -> <source-name> <template-unqualified-name> <template-args>
2447 -> <source-name> <operator-name> <template-args>
2448 -> <source-name> cv <type> <template-args>
2449 -> <source-name> cv <template-template-param> <template-args> <template-args>
2451 where the <template-args> is followed by another.
2452 Otherwise, we must have a derivation like this:
2455 -> <template-prefix> <template-args>
2456 -> <prefix> <template-unqualified-name> <template-args>
2457 -> <unqualified-name> <template-unqualified-name> <template-args>
2458 -> <source-name> <template-unqualified-name> <template-args>
2459 -> <source-name> <operator-name> <template-args>
2460 -> <source-name> cv <type> <template-args>
2461 -> <source-name> cv <template-param> <template-args>
2463 where we need to leave the <template-args> to be processed
2464 by d_prefix (following the <template-prefix>).
2466 The <template-template-param> part is a substitution
2468 if (! di
->is_conversion
)
2470 if (! d_add_substitution (di
, ret
))
2472 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2473 d_template_args (di
));
2477 struct demangle_component
*args
;
2478 struct d_info_checkpoint checkpoint
;
2480 d_checkpoint (di
, &checkpoint
);
2481 args
= d_template_args (di
);
2482 if (d_peek_char (di
) == 'I')
2484 if (! d_add_substitution (di
, ret
))
2486 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2490 d_backtrack (di
, &checkpoint
);
2496 /* If this is a special substitution, then it is the start of
2497 <class-enum-type>. */
2501 peek_next
= d_peek_next_char (di
);
2502 if (IS_DIGIT (peek_next
)
2504 || IS_UPPER (peek_next
))
2506 ret
= d_substitution (di
, 0);
2507 /* The substituted name may have been a template name and
2508 may be followed by tepmlate args. */
2509 if (d_peek_char (di
) == 'I')
2510 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2511 d_template_args (di
));
2517 ret
= d_class_enum_type (di
);
2518 /* If the substitution was a complete type, then it is not
2519 a new substitution candidate. However, if the
2520 substitution was followed by template arguments, then
2521 the whole thing is a substitution candidate. */
2522 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2530 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2531 cplus_demangle_type (di
), NULL
);
2536 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2537 cplus_demangle_type (di
), NULL
);
2542 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2543 cplus_demangle_type (di
), NULL
);
2548 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2549 cplus_demangle_type (di
), NULL
);
2554 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2555 cplus_demangle_type (di
), NULL
);
2560 ret
= d_source_name (di
);
2561 if (d_peek_char (di
) == 'I')
2562 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2563 d_template_args (di
));
2564 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2565 cplus_demangle_type (di
), ret
);
2571 peek
= d_next_char (di
);
2576 /* decltype (expression) */
2577 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2578 d_expression (di
), NULL
);
2579 if (ret
&& d_next_char (di
) != 'E')
2585 /* Pack expansion. */
2586 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2587 cplus_demangle_type (di
), NULL
);
2593 ret
= d_make_name (di
, "auto", 4);
2596 /* decltype(auto) */
2597 ret
= d_make_name (di
, "decltype(auto)", 14);
2601 /* 32-bit decimal floating point */
2602 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2603 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2607 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2608 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2612 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2613 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2616 /* 16-bit half-precision FP */
2617 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2618 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2622 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2623 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2627 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2628 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2632 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2633 ret
= d_make_empty (di
);
2634 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2635 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2636 /* For demangling we don't care about the bits. */
2638 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2639 if (ret
->u
.s_fixed
.length
== NULL
)
2642 peek
= d_next_char (di
);
2643 ret
->u
.s_fixed
.sat
= (peek
== 's');
2647 ret
= d_vector_type (di
);
2652 /* decltype(nullptr) */
2653 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2654 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2668 if (! d_add_substitution (di
, ret
))
2675 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2677 static struct demangle_component
**
2678 d_cv_qualifiers (struct d_info
*di
,
2679 struct demangle_component
**pret
, int member_fn
)
2681 struct demangle_component
**pstart
;
2685 peek
= d_peek_char (di
);
2686 while (next_is_type_qual (di
))
2688 enum demangle_component_type t
;
2689 struct demangle_component
*right
= NULL
;
2695 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2696 : DEMANGLE_COMPONENT_RESTRICT
);
2697 di
->expansion
+= sizeof "restrict";
2699 else if (peek
== 'V')
2702 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2703 : DEMANGLE_COMPONENT_VOLATILE
);
2704 di
->expansion
+= sizeof "volatile";
2706 else if (peek
== 'K')
2709 ? DEMANGLE_COMPONENT_CONST_THIS
2710 : DEMANGLE_COMPONENT_CONST
);
2711 di
->expansion
+= sizeof "const";
2715 peek
= d_next_char (di
);
2718 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2719 di
->expansion
+= sizeof "transaction_safe";
2721 else if (peek
== 'o'
2724 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2725 di
->expansion
+= sizeof "noexcept";
2728 right
= d_expression (di
);
2731 if (! d_check_char (di
, 'E'))
2735 else if (peek
== 'w')
2737 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2738 di
->expansion
+= sizeof "throw";
2739 right
= d_parmlist (di
);
2742 if (! d_check_char (di
, 'E'))
2749 *pret
= d_make_comp (di
, t
, NULL
, right
);
2752 pret
= &d_left (*pret
);
2754 peek
= d_peek_char (di
);
2757 if (!member_fn
&& peek
== 'F')
2759 while (pstart
!= pret
)
2761 switch ((*pstart
)->type
)
2763 case DEMANGLE_COMPONENT_RESTRICT
:
2764 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2766 case DEMANGLE_COMPONENT_VOLATILE
:
2767 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2769 case DEMANGLE_COMPONENT_CONST
:
2770 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2775 pstart
= &d_left (*pstart
);
2782 /* <ref-qualifier> ::= R
2785 static struct demangle_component
*
2786 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2788 struct demangle_component
*ret
= sub
;
2791 peek
= d_peek_char (di
);
2792 if (peek
== 'R' || peek
== 'O')
2794 enum demangle_component_type t
;
2797 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2798 di
->expansion
+= sizeof "&";
2802 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2803 di
->expansion
+= sizeof "&&";
2807 ret
= d_make_comp (di
, t
, ret
, NULL
);
2813 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2815 static struct demangle_component
*
2816 d_function_type (struct d_info
*di
)
2818 struct demangle_component
*ret
;
2820 if (! d_check_char (di
, 'F'))
2822 if (d_peek_char (di
) == 'Y')
2824 /* Function has C linkage. We don't print this information.
2825 FIXME: We should print it in verbose mode. */
2828 ret
= d_bare_function_type (di
, 1);
2829 ret
= d_ref_qualifier (di
, ret
);
2831 if (! d_check_char (di
, 'E'))
2838 static struct demangle_component
*
2839 d_parmlist (struct d_info
*di
)
2841 struct demangle_component
*tl
;
2842 struct demangle_component
**ptl
;
2848 struct demangle_component
*type
;
2850 char peek
= d_peek_char (di
);
2851 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2853 if ((peek
== 'R' || peek
== 'O')
2854 && d_peek_next_char (di
) == 'E')
2855 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2857 type
= cplus_demangle_type (di
);
2860 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2863 ptl
= &d_right (*ptl
);
2866 /* There should be at least one parameter type besides the optional
2867 return type. A function which takes no arguments will have a
2868 single parameter type void. */
2872 /* If we have a single parameter type void, omit it. */
2873 if (d_right (tl
) == NULL
2874 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2875 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2877 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2884 /* <bare-function-type> ::= [J]<type>+ */
2886 static struct demangle_component
*
2887 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2889 struct demangle_component
*return_type
;
2890 struct demangle_component
*tl
;
2893 /* Detect special qualifier indicating that the first argument
2894 is the return type. */
2895 peek
= d_peek_char (di
);
2899 has_return_type
= 1;
2902 if (has_return_type
)
2904 return_type
= cplus_demangle_type (di
);
2905 if (return_type
== NULL
)
2911 tl
= d_parmlist (di
);
2915 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2919 /* <class-enum-type> ::= <name> */
2921 static struct demangle_component
*
2922 d_class_enum_type (struct d_info
*di
)
2927 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2928 ::= A [<(dimension) expression>] _ <(element) type>
2931 static struct demangle_component
*
2932 d_array_type (struct d_info
*di
)
2935 struct demangle_component
*dim
;
2937 if (! d_check_char (di
, 'A'))
2940 peek
= d_peek_char (di
);
2943 else if (IS_DIGIT (peek
))
2951 peek
= d_peek_char (di
);
2953 while (IS_DIGIT (peek
));
2954 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2960 dim
= d_expression (di
);
2965 if (! d_check_char (di
, '_'))
2968 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2969 cplus_demangle_type (di
));
2972 /* <vector-type> ::= Dv <number> _ <type>
2973 ::= Dv _ <expression> _ <type> */
2975 static struct demangle_component
*
2976 d_vector_type (struct d_info
*di
)
2979 struct demangle_component
*dim
;
2981 peek
= d_peek_char (di
);
2985 dim
= d_expression (di
);
2988 dim
= d_number_component (di
);
2993 if (! d_check_char (di
, '_'))
2996 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
2997 cplus_demangle_type (di
));
3000 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3002 static struct demangle_component
*
3003 d_pointer_to_member_type (struct d_info
*di
)
3005 struct demangle_component
*cl
;
3006 struct demangle_component
*mem
;
3008 if (! d_check_char (di
, 'M'))
3011 cl
= cplus_demangle_type (di
);
3015 /* The ABI says, "The type of a non-static member function is considered
3016 to be different, for the purposes of substitution, from the type of a
3017 namespace-scope or static member function whose type appears
3018 similar. The types of two non-static member functions are considered
3019 to be different, for the purposes of substitution, if the functions
3020 are members of different classes. In other words, for the purposes of
3021 substitution, the class of which the function is a member is
3022 considered part of the type of function."
3024 For a pointer to member function, this call to cplus_demangle_type
3025 will end up adding a (possibly qualified) non-member function type to
3026 the substitution table, which is not correct; however, the member
3027 function type will never be used in a substitution, so putting the
3028 wrong type in the substitution table is harmless. */
3030 mem
= cplus_demangle_type (di
);
3034 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3037 /* <non-negative number> _ */
3040 d_compact_number (struct d_info
*di
)
3043 if (d_peek_char (di
) == '_')
3045 else if (d_peek_char (di
) == 'n')
3048 num
= d_number (di
) + 1;
3050 if (num
< 0 || ! d_check_char (di
, '_'))
3055 /* <template-param> ::= T_
3056 ::= T <(parameter-2 non-negative) number> _
3059 static struct demangle_component
*
3060 d_template_param (struct d_info
*di
)
3064 if (! d_check_char (di
, 'T'))
3067 param
= d_compact_number (di
);
3073 return d_make_template_param (di
, param
);
3076 /* <template-args> ::= I <template-arg>+ E */
3078 static struct demangle_component
*
3079 d_template_args (struct d_info
*di
)
3081 if (d_peek_char (di
) != 'I'
3082 && d_peek_char (di
) != 'J')
3086 return d_template_args_1 (di
);
3089 /* <template-arg>* E */
3091 static struct demangle_component
*
3092 d_template_args_1 (struct d_info
*di
)
3094 struct demangle_component
*hold_last_name
;
3095 struct demangle_component
*al
;
3096 struct demangle_component
**pal
;
3098 /* Preserve the last name we saw--don't let the template arguments
3099 clobber it, as that would give us the wrong name for a subsequent
3100 constructor or destructor. */
3101 hold_last_name
= di
->last_name
;
3103 if (d_peek_char (di
) == 'E')
3105 /* An argument pack can be empty. */
3107 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3114 struct demangle_component
*a
;
3116 a
= d_template_arg (di
);
3120 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3123 pal
= &d_right (*pal
);
3125 if (d_peek_char (di
) == 'E')
3132 di
->last_name
= hold_last_name
;
3137 /* <template-arg> ::= <type>
3138 ::= X <expression> E
3142 static struct demangle_component
*
3143 d_template_arg (struct d_info
*di
)
3145 struct demangle_component
*ret
;
3147 switch (d_peek_char (di
))
3151 ret
= d_expression (di
);
3152 if (! d_check_char (di
, 'E'))
3157 return d_expr_primary (di
);
3161 /* An argument pack. */
3162 return d_template_args (di
);
3165 return cplus_demangle_type (di
);
3169 /* Parse a sequence of expressions until we hit the terminator
3172 static struct demangle_component
*
3173 d_exprlist (struct d_info
*di
, char terminator
)
3175 struct demangle_component
*list
= NULL
;
3176 struct demangle_component
**p
= &list
;
3178 if (d_peek_char (di
) == terminator
)
3181 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3186 struct demangle_component
*arg
= d_expression (di
);
3190 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3195 if (d_peek_char (di
) == terminator
)
3205 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3206 dynamic_cast, static_cast or reinterpret_cast. */
3209 op_is_new_cast (struct demangle_component
*op
)
3211 const char *code
= op
->u
.s_operator
.op
->code
;
3212 return (code
[1] == 'c'
3213 && (code
[0] == 's' || code
[0] == 'd'
3214 || code
[0] == 'c' || code
[0] == 'r'));
3217 /* <expression> ::= <(unary) operator-name> <expression>
3218 ::= <(binary) operator-name> <expression> <expression>
3219 ::= <(trinary) operator-name> <expression> <expression> <expression>
3220 ::= cl <expression>+ E
3222 ::= <template-param>
3223 ::= sr <type> <unqualified-name>
3224 ::= sr <type> <unqualified-name> <template-args>
3228 static inline struct demangle_component
*
3229 d_expression_1 (struct d_info
*di
)
3233 peek
= d_peek_char (di
);
3235 return d_expr_primary (di
);
3236 else if (peek
== 'T')
3237 return d_template_param (di
);
3238 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3240 struct demangle_component
*type
;
3241 struct demangle_component
*name
;
3244 type
= cplus_demangle_type (di
);
3245 name
= d_unqualified_name (di
);
3246 if (d_peek_char (di
) != 'I')
3247 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3249 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3250 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3251 d_template_args (di
)));
3253 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3256 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3257 d_expression_1 (di
), NULL
);
3259 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3261 /* Function parameter used in a late-specified return type. */
3264 if (d_peek_char (di
) == 'T')
3266 /* 'this' parameter. */
3272 index
= d_compact_number (di
);
3273 if (index
== INT_MAX
|| index
== -1)
3277 return d_make_function_param (di
, index
);
3279 else if (IS_DIGIT (peek
)
3280 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3282 /* We can get an unqualified name as an expression in the case of
3283 a dependent function call, i.e. decltype(f(t)). */
3284 struct demangle_component
*name
;
3287 /* operator-function-id, i.e. operator+(t). */
3290 name
= d_unqualified_name (di
);
3293 if (d_peek_char (di
) == 'I')
3294 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3295 d_template_args (di
));
3299 else if ((peek
== 'i' || peek
== 't')
3300 && d_peek_next_char (di
) == 'l')
3302 /* Brace-enclosed initializer list, untyped or typed. */
3303 struct demangle_component
*type
= NULL
;
3305 type
= cplus_demangle_type (di
);
3306 if (!d_peek_next_char (di
))
3309 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3310 type
, d_exprlist (di
, 'E'));
3314 struct demangle_component
*op
;
3315 const char *code
= NULL
;
3318 op
= d_operator_name (di
);
3322 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3324 code
= op
->u
.s_operator
.op
->code
;
3325 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3326 if (strcmp (code
, "st") == 0)
3327 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3328 cplus_demangle_type (di
));
3335 case DEMANGLE_COMPONENT_OPERATOR
:
3336 args
= op
->u
.s_operator
.op
->args
;
3338 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3339 args
= op
->u
.s_extended_operator
.args
;
3341 case DEMANGLE_COMPONENT_CAST
:
3349 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3353 struct demangle_component
*operand
;
3356 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3357 && code
[1] == code
[0])
3358 /* pp_ and mm_ are the prefix variants. */
3359 suffix
= !d_check_char (di
, '_');
3361 if (op
->type
== DEMANGLE_COMPONENT_CAST
3362 && d_check_char (di
, '_'))
3363 operand
= d_exprlist (di
, 'E');
3364 else if (code
&& !strcmp (code
, "sP"))
3365 operand
= d_template_args_1 (di
);
3367 operand
= d_expression_1 (di
);
3370 /* Indicate the suffix variant for d_print_comp. */
3371 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3373 DEMANGLE_COMPONENT_BINARY_ARGS
,
3376 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3381 struct demangle_component
*left
;
3382 struct demangle_component
*right
;
3386 if (op_is_new_cast (op
))
3387 left
= cplus_demangle_type (di
);
3388 else if (code
[0] == 'f')
3389 /* fold-expression. */
3390 left
= d_operator_name (di
);
3392 left
= d_expression_1 (di
);
3393 if (!strcmp (code
, "cl"))
3394 right
= d_exprlist (di
, 'E');
3395 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3397 right
= d_unqualified_name (di
);
3398 if (d_peek_char (di
) == 'I')
3399 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3400 right
, d_template_args (di
));
3403 right
= d_expression_1 (di
);
3405 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3407 DEMANGLE_COMPONENT_BINARY_ARGS
,
3412 struct demangle_component
*first
;
3413 struct demangle_component
*second
;
3414 struct demangle_component
*third
;
3418 else if (!strcmp (code
, "qu"))
3420 /* ?: expression. */
3421 first
= d_expression_1 (di
);
3422 second
= d_expression_1 (di
);
3423 third
= d_expression_1 (di
);
3427 else if (code
[0] == 'f')
3429 /* fold-expression. */
3430 first
= d_operator_name (di
);
3431 second
= d_expression_1 (di
);
3432 third
= d_expression_1 (di
);
3436 else if (code
[0] == 'n')
3438 /* new-expression. */
3439 if (code
[1] != 'w' && code
[1] != 'a')
3441 first
= d_exprlist (di
, '_');
3442 second
= cplus_demangle_type (di
);
3443 if (d_peek_char (di
) == 'E')
3448 else if (d_peek_char (di
) == 'p'
3449 && d_peek_next_char (di
) == 'i')
3451 /* Parenthesized initializer. */
3453 third
= d_exprlist (di
, 'E');
3455 else if (d_peek_char (di
) == 'i'
3456 && d_peek_next_char (di
) == 'l')
3457 /* initializer-list. */
3458 third
= d_expression_1 (di
);
3464 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3466 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3469 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3478 static struct demangle_component
*
3479 d_expression (struct d_info
*di
)
3481 struct demangle_component
*ret
;
3482 int was_expression
= di
->is_expression
;
3484 di
->is_expression
= 1;
3485 ret
= d_expression_1 (di
);
3486 di
->is_expression
= was_expression
;
3490 /* <expr-primary> ::= L <type> <(value) number> E
3491 ::= L <type> <(value) float> E
3492 ::= L <mangled-name> E
3495 static struct demangle_component
*
3496 d_expr_primary (struct d_info
*di
)
3498 struct demangle_component
*ret
;
3500 if (! d_check_char (di
, 'L'))
3502 if (d_peek_char (di
) == '_'
3503 /* Workaround for G++ bug; see comment in write_template_arg. */
3504 || d_peek_char (di
) == 'Z')
3505 ret
= cplus_demangle_mangled_name (di
, 0);
3508 struct demangle_component
*type
;
3509 enum demangle_component_type t
;
3512 type
= cplus_demangle_type (di
);
3516 /* If we have a type we know how to print, we aren't going to
3517 print the type name itself. */
3518 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3519 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3520 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3522 /* Rather than try to interpret the literal value, we just
3523 collect it as a string. Note that it's possible to have a
3524 floating point literal here. The ABI specifies that the
3525 format of such literals is machine independent. That's fine,
3526 but what's not fine is that versions of g++ up to 3.2 with
3527 -fabi-version=1 used upper case letters in the hex constant,
3528 and dumped out gcc's internal representation. That makes it
3529 hard to tell where the constant ends, and hard to dump the
3530 constant in any readable form anyhow. We don't attempt to
3531 handle these cases. */
3533 t
= DEMANGLE_COMPONENT_LITERAL
;
3534 if (d_peek_char (di
) == 'n')
3536 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3540 while (d_peek_char (di
) != 'E')
3542 if (d_peek_char (di
) == '\0')
3546 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3548 if (! d_check_char (di
, 'E'))
3553 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3554 ::= Z <(function) encoding> E s [<discriminator>]
3555 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3558 static struct demangle_component
*
3559 d_local_name (struct d_info
*di
)
3561 struct demangle_component
*function
;
3563 if (! d_check_char (di
, 'Z'))
3566 function
= d_encoding (di
, 0);
3568 if (! d_check_char (di
, 'E'))
3571 if (d_peek_char (di
) == 's')
3574 if (! d_discriminator (di
))
3576 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
3577 d_make_name (di
, "string literal",
3578 sizeof "string literal" - 1));
3582 struct demangle_component
*name
;
3585 if (d_peek_char (di
) == 'd')
3587 /* Default argument scope: d <number> _. */
3589 num
= d_compact_number (di
);
3598 /* Lambdas and unnamed types have internal discriminators. */
3599 case DEMANGLE_COMPONENT_LAMBDA
:
3600 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3603 if (! d_discriminator (di
))
3607 name
= d_make_default_arg (di
, num
, name
);
3608 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3612 /* <discriminator> ::= _ <(non-negative) number>
3614 We demangle the discriminator, but we don't print it out. FIXME:
3615 We should print it out in verbose mode. */
3618 d_discriminator (struct d_info
*di
)
3622 if (d_peek_char (di
) != '_')
3625 discrim
= d_number (di
);
3631 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3633 static struct demangle_component
*
3634 d_lambda (struct d_info
*di
)
3636 struct demangle_component
*tl
;
3637 struct demangle_component
*ret
;
3640 if (! d_check_char (di
, 'U'))
3642 if (! d_check_char (di
, 'l'))
3645 tl
= d_parmlist (di
);
3649 if (! d_check_char (di
, 'E'))
3652 num
= d_compact_number (di
);
3656 ret
= d_make_empty (di
);
3659 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3660 ret
->u
.s_unary_num
.sub
= tl
;
3661 ret
->u
.s_unary_num
.num
= num
;
3664 if (! d_add_substitution (di
, ret
))
3670 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3672 static struct demangle_component
*
3673 d_unnamed_type (struct d_info
*di
)
3675 struct demangle_component
*ret
;
3678 if (! d_check_char (di
, 'U'))
3680 if (! d_check_char (di
, 't'))
3683 num
= d_compact_number (di
);
3687 ret
= d_make_empty (di
);
3690 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3691 ret
->u
.s_number
.number
= num
;
3694 if (! d_add_substitution (di
, ret
))
3700 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3703 static struct demangle_component
*
3704 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3706 const char *suffix
= d_str (di
);
3707 const char *pend
= suffix
;
3708 struct demangle_component
*n
;
3710 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3713 while (IS_LOWER (*pend
) || *pend
== '_')
3716 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3719 while (IS_DIGIT (*pend
))
3722 d_advance (di
, pend
- suffix
);
3723 n
= d_make_name (di
, suffix
, pend
- suffix
);
3724 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3727 /* Add a new substitution. */
3730 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3734 if (di
->next_sub
>= di
->num_subs
)
3736 di
->subs
[di
->next_sub
] = dc
;
3741 /* <substitution> ::= S <seq-id> _
3751 If PREFIX is non-zero, then this type is being used as a prefix in
3752 a qualified name. In this case, for the standard substitutions, we
3753 need to check whether we are being used as a prefix for a
3754 constructor or destructor, and return a full template name.
3755 Otherwise we will get something like std::iostream::~iostream()
3756 which does not correspond particularly well to any function which
3757 actually appears in the source.
3760 static const struct d_standard_sub_info standard_subs
[] =
3765 { 'a', NL ("std::allocator"),
3766 NL ("std::allocator"),
3768 { 'b', NL ("std::basic_string"),
3769 NL ("std::basic_string"),
3770 NL ("basic_string") },
3771 { 's', NL ("std::string"),
3772 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3773 NL ("basic_string") },
3774 { 'i', NL ("std::istream"),
3775 NL ("std::basic_istream<char, std::char_traits<char> >"),
3776 NL ("basic_istream") },
3777 { 'o', NL ("std::ostream"),
3778 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3779 NL ("basic_ostream") },
3780 { 'd', NL ("std::iostream"),
3781 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3782 NL ("basic_iostream") }
3785 static struct demangle_component
*
3786 d_substitution (struct d_info
*di
, int prefix
)
3790 if (! d_check_char (di
, 'S'))
3793 c
= d_next_char (di
);
3794 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3803 unsigned int new_id
;
3806 new_id
= id
* 36 + c
- '0';
3807 else if (IS_UPPER (c
))
3808 new_id
= id
* 36 + c
- 'A' + 10;
3814 c
= d_next_char (di
);
3821 if (id
>= (unsigned int) di
->next_sub
)
3826 return di
->subs
[id
];
3831 const struct d_standard_sub_info
*p
;
3832 const struct d_standard_sub_info
*pend
;
3834 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3835 if (! verbose
&& prefix
)
3839 peek
= d_peek_char (di
);
3840 if (peek
== 'C' || peek
== 'D')
3844 pend
= (&standard_subs
[0]
3845 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3846 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3852 struct demangle_component
*dc
;
3854 if (p
->set_last_name
!= NULL
)
3855 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3856 p
->set_last_name_len
);
3859 s
= p
->full_expansion
;
3864 s
= p
->simple_expansion
;
3865 len
= p
->simple_len
;
3867 di
->expansion
+= len
;
3868 dc
= d_make_sub (di
, s
, len
);
3869 if (d_peek_char (di
) == 'B')
3871 /* If there are ABI tags on the abbreviation, it becomes
3872 a substitution candidate. */
3873 dc
= d_abi_tags (di
, dc
);
3874 d_add_substitution (di
, dc
);
3885 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3887 checkpoint
->n
= di
->n
;
3888 checkpoint
->next_comp
= di
->next_comp
;
3889 checkpoint
->next_sub
= di
->next_sub
;
3890 checkpoint
->did_subs
= di
->did_subs
;
3891 checkpoint
->expansion
= di
->expansion
;
3895 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3897 di
->n
= checkpoint
->n
;
3898 di
->next_comp
= checkpoint
->next_comp
;
3899 di
->next_sub
= checkpoint
->next_sub
;
3900 di
->did_subs
= checkpoint
->did_subs
;
3901 di
->expansion
= checkpoint
->expansion
;
3904 /* Initialize a growable string. */
3907 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3912 dgs
->allocation_failure
= 0;
3915 d_growable_string_resize (dgs
, estimate
);
3918 /* Grow a growable string to a given size. */
3921 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
3926 if (dgs
->allocation_failure
)
3929 /* Start allocation at two bytes to avoid any possibility of confusion
3930 with the special value of 1 used as a return in *palc to indicate
3931 allocation failures. */
3932 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
3933 while (newalc
< need
)
3936 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
3943 dgs
->allocation_failure
= 1;
3950 /* Append a buffer to a growable string. */
3953 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
3954 const char *s
, size_t l
)
3958 need
= dgs
->len
+ l
+ 1;
3959 if (need
> dgs
->alc
)
3960 d_growable_string_resize (dgs
, need
);
3962 if (dgs
->allocation_failure
)
3965 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
3966 dgs
->buf
[dgs
->len
+ l
] = '\0';
3970 /* Bridge growable strings to the callback mechanism. */
3973 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
3975 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
3977 d_growable_string_append_buffer (dgs
, s
, l
);
3980 /* Walk the tree, counting the number of templates encountered, and
3981 the number of times a scope might be saved. These counts will be
3982 used to allocate data structures for d_print_comp, so the logic
3983 here must mirror the logic d_print_comp will use. It is not
3984 important that the resulting numbers are exact, so long as they
3985 are larger than the actual numbers encountered. */
3988 d_count_templates_scopes (int *num_templates
, int *num_scopes
,
3989 const struct demangle_component
*dc
)
3996 case DEMANGLE_COMPONENT_NAME
:
3997 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3998 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
3999 case DEMANGLE_COMPONENT_SUB_STD
:
4000 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4001 case DEMANGLE_COMPONENT_OPERATOR
:
4002 case DEMANGLE_COMPONENT_CHARACTER
:
4003 case DEMANGLE_COMPONENT_NUMBER
:
4004 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4007 case DEMANGLE_COMPONENT_TEMPLATE
:
4009 goto recurse_left_right
;
4011 case DEMANGLE_COMPONENT_REFERENCE
:
4012 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4013 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4015 goto recurse_left_right
;
4017 case DEMANGLE_COMPONENT_QUAL_NAME
:
4018 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4019 case DEMANGLE_COMPONENT_TYPED_NAME
:
4020 case DEMANGLE_COMPONENT_VTABLE
:
4021 case DEMANGLE_COMPONENT_VTT
:
4022 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4023 case DEMANGLE_COMPONENT_TYPEINFO
:
4024 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4025 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4026 case DEMANGLE_COMPONENT_THUNK
:
4027 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4028 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4029 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4030 case DEMANGLE_COMPONENT_GUARD
:
4031 case DEMANGLE_COMPONENT_TLS_INIT
:
4032 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4033 case DEMANGLE_COMPONENT_REFTEMP
:
4034 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4035 case DEMANGLE_COMPONENT_RESTRICT
:
4036 case DEMANGLE_COMPONENT_VOLATILE
:
4037 case DEMANGLE_COMPONENT_CONST
:
4038 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4039 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4040 case DEMANGLE_COMPONENT_CONST_THIS
:
4041 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4042 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4043 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4044 case DEMANGLE_COMPONENT_NOEXCEPT
:
4045 case DEMANGLE_COMPONENT_THROW_SPEC
:
4046 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4047 case DEMANGLE_COMPONENT_POINTER
:
4048 case DEMANGLE_COMPONENT_COMPLEX
:
4049 case DEMANGLE_COMPONENT_IMAGINARY
:
4050 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4051 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4052 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4053 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4054 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4055 case DEMANGLE_COMPONENT_ARGLIST
:
4056 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4057 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4058 case DEMANGLE_COMPONENT_CAST
:
4059 case DEMANGLE_COMPONENT_CONVERSION
:
4060 case DEMANGLE_COMPONENT_NULLARY
:
4061 case DEMANGLE_COMPONENT_UNARY
:
4062 case DEMANGLE_COMPONENT_BINARY
:
4063 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4064 case DEMANGLE_COMPONENT_TRINARY
:
4065 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4066 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4067 case DEMANGLE_COMPONENT_LITERAL
:
4068 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4069 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4070 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4071 case DEMANGLE_COMPONENT_DECLTYPE
:
4072 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4073 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4074 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4075 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4076 case DEMANGLE_COMPONENT_CLONE
:
4078 d_count_templates_scopes (num_templates
, num_scopes
,
4080 d_count_templates_scopes (num_templates
, num_scopes
,
4084 case DEMANGLE_COMPONENT_CTOR
:
4085 d_count_templates_scopes (num_templates
, num_scopes
,
4089 case DEMANGLE_COMPONENT_DTOR
:
4090 d_count_templates_scopes (num_templates
, num_scopes
,
4094 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4095 d_count_templates_scopes (num_templates
, num_scopes
,
4096 dc
->u
.s_extended_operator
.name
);
4099 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4100 d_count_templates_scopes (num_templates
, num_scopes
,
4101 dc
->u
.s_fixed
.length
);
4104 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4105 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4106 d_count_templates_scopes (num_templates
, num_scopes
,
4110 case DEMANGLE_COMPONENT_LAMBDA
:
4111 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4112 d_count_templates_scopes (num_templates
, num_scopes
,
4113 dc
->u
.s_unary_num
.sub
);
4118 /* Initialize a print information structure. */
4121 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4122 void *opaque
, const struct demangle_component
*dc
)
4125 dpi
->last_char
= '\0';
4126 dpi
->templates
= NULL
;
4127 dpi
->modifiers
= NULL
;
4128 dpi
->pack_index
= 0;
4129 dpi
->flush_count
= 0;
4131 dpi
->callback
= callback
;
4132 dpi
->opaque
= opaque
;
4134 dpi
->demangle_failure
= 0;
4135 dpi
->is_lambda_arg
= 0;
4137 dpi
->component_stack
= NULL
;
4139 dpi
->saved_scopes
= NULL
;
4140 dpi
->next_saved_scope
= 0;
4141 dpi
->num_saved_scopes
= 0;
4143 dpi
->copy_templates
= NULL
;
4144 dpi
->next_copy_template
= 0;
4145 dpi
->num_copy_templates
= 0;
4147 d_count_templates_scopes (&dpi
->num_copy_templates
,
4148 &dpi
->num_saved_scopes
, dc
);
4149 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4151 dpi
->current_template
= NULL
;
4154 /* Indicate that an error occurred during printing, and test for error. */
4157 d_print_error (struct d_print_info
*dpi
)
4159 dpi
->demangle_failure
= 1;
4163 d_print_saw_error (struct d_print_info
*dpi
)
4165 return dpi
->demangle_failure
!= 0;
4168 /* Flush buffered characters to the callback. */
4171 d_print_flush (struct d_print_info
*dpi
)
4173 dpi
->buf
[dpi
->len
] = '\0';
4174 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4179 /* Append characters and buffers for printing. */
4182 d_append_char (struct d_print_info
*dpi
, char c
)
4184 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4185 d_print_flush (dpi
);
4187 dpi
->buf
[dpi
->len
++] = c
;
4192 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4196 for (i
= 0; i
< l
; i
++)
4197 d_append_char (dpi
, s
[i
]);
4201 d_append_string (struct d_print_info
*dpi
, const char *s
)
4203 d_append_buffer (dpi
, s
, strlen (s
));
4207 d_append_num (struct d_print_info
*dpi
, int l
)
4210 sprintf (buf
,"%d", l
);
4211 d_append_string (dpi
, buf
);
4215 d_last_char (struct d_print_info
*dpi
)
4217 return dpi
->last_char
;
4220 /* Turn components into a human readable string. OPTIONS is the
4221 options bits passed to the demangler. DC is the tree to print.
4222 CALLBACK is a function to call to flush demangled string segments
4223 as they fill the intermediate buffer, and OPAQUE is a generalized
4224 callback argument. On success, this returns 1. On failure,
4225 it returns 0, indicating a bad parse. It does not use heap
4226 memory to build an output string, so cannot encounter memory
4227 allocation failure. */
4229 CP_STATIC_IF_GLIBCPP_V3
4231 cplus_demangle_print_callback (int options
,
4232 const struct demangle_component
*dc
,
4233 demangle_callbackref callback
, void *opaque
)
4235 struct d_print_info dpi
;
4237 d_print_init (&dpi
, callback
, opaque
, dc
);
4240 #ifdef CP_DYNAMIC_ARRAYS
4241 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4242 and flagged as errors by Address Sanitizer. */
4243 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4244 ? dpi
.num_saved_scopes
: 1];
4245 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4246 ? dpi
.num_copy_templates
: 1];
4248 dpi
.saved_scopes
= scopes
;
4249 dpi
.copy_templates
= temps
;
4251 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4252 * sizeof (*dpi
.saved_scopes
));
4253 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4254 * sizeof (*dpi
.copy_templates
));
4257 d_print_comp (&dpi
, options
, dc
);
4260 d_print_flush (&dpi
);
4262 return ! d_print_saw_error (&dpi
);
4265 /* Turn components into a human readable string. OPTIONS is the
4266 options bits passed to the demangler. DC is the tree to print.
4267 ESTIMATE is a guess at the length of the result. This returns a
4268 string allocated by malloc, or NULL on error. On success, this
4269 sets *PALC to the size of the allocated buffer. On failure, this
4270 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4273 CP_STATIC_IF_GLIBCPP_V3
4275 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
4276 int estimate
, size_t *palc
)
4278 struct d_growable_string dgs
;
4280 d_growable_string_init (&dgs
, estimate
);
4282 if (! cplus_demangle_print_callback (options
, dc
,
4283 d_growable_string_callback_adapter
,
4291 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4295 /* Returns the I'th element of the template arglist ARGS, or NULL on
4296 failure. If I is negative, return the entire arglist. */
4298 static struct demangle_component
*
4299 d_index_template_argument (struct demangle_component
*args
, int i
)
4301 struct demangle_component
*a
;
4304 /* Print the whole argument pack. */
4311 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4317 if (i
!= 0 || a
== NULL
)
4323 /* Returns the template argument from the current context indicated by DC,
4324 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4326 static struct demangle_component
*
4327 d_lookup_template_argument (struct d_print_info
*dpi
,
4328 const struct demangle_component
*dc
)
4330 if (dpi
->templates
== NULL
)
4332 d_print_error (dpi
);
4336 return d_index_template_argument
4337 (d_right (dpi
->templates
->template_decl
),
4338 dc
->u
.s_number
.number
);
4341 /* Returns a template argument pack used in DC (any will do), or NULL. */
4343 static struct demangle_component
*
4344 d_find_pack (struct d_print_info
*dpi
,
4345 const struct demangle_component
*dc
)
4347 struct demangle_component
*a
;
4353 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4354 a
= d_lookup_template_argument (dpi
, dc
);
4355 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4359 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4362 case DEMANGLE_COMPONENT_LAMBDA
:
4363 case DEMANGLE_COMPONENT_NAME
:
4364 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4365 case DEMANGLE_COMPONENT_OPERATOR
:
4366 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4367 case DEMANGLE_COMPONENT_SUB_STD
:
4368 case DEMANGLE_COMPONENT_CHARACTER
:
4369 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4370 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4371 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4372 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4373 case DEMANGLE_COMPONENT_NUMBER
:
4376 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4377 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4378 case DEMANGLE_COMPONENT_CTOR
:
4379 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4380 case DEMANGLE_COMPONENT_DTOR
:
4381 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4384 a
= d_find_pack (dpi
, d_left (dc
));
4387 return d_find_pack (dpi
, d_right (dc
));
4391 /* Returns the length of the template argument pack DC. */
4394 d_pack_length (const struct demangle_component
*dc
)
4397 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4398 && d_left (dc
) != NULL
)
4406 /* Returns the number of template args in DC, expanding any pack expansions
4410 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4413 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4416 struct demangle_component
*elt
= d_left (dc
);
4419 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4421 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4422 count
+= d_pack_length (a
);
4430 /* DC is a component of a mangled expression. Print it, wrapped in parens
4434 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4435 const struct demangle_component
*dc
)
4438 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4439 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4440 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4441 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4444 d_append_char (dpi
, '(');
4445 d_print_comp (dpi
, options
, dc
);
4447 d_append_char (dpi
, ')');
4450 /* Save the current scope. */
4453 d_save_scope (struct d_print_info
*dpi
,
4454 const struct demangle_component
*container
)
4456 struct d_saved_scope
*scope
;
4457 struct d_print_template
*src
, **link
;
4459 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4461 d_print_error (dpi
);
4464 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4465 dpi
->next_saved_scope
++;
4467 scope
->container
= container
;
4468 link
= &scope
->templates
;
4470 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4472 struct d_print_template
*dst
;
4474 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4476 d_print_error (dpi
);
4479 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4480 dpi
->next_copy_template
++;
4482 dst
->template_decl
= src
->template_decl
;
4490 /* Attempt to locate a previously saved scope. Returns NULL if no
4491 corresponding saved scope was found. */
4493 static struct d_saved_scope
*
4494 d_get_saved_scope (struct d_print_info
*dpi
,
4495 const struct demangle_component
*container
)
4499 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4500 if (dpi
->saved_scopes
[i
].container
== container
)
4501 return &dpi
->saved_scopes
[i
];
4506 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4510 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4511 const struct demangle_component
*dc
)
4513 const struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4516 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4517 if (fold_code
[0] != 'f')
4521 operator_
= d_left (ops
);
4522 op1
= d_right (ops
);
4524 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4526 op2
= d_right (op1
);
4530 /* Print the whole pack. */
4531 save_idx
= dpi
->pack_index
;
4532 dpi
->pack_index
= -1;
4534 switch (fold_code
[1])
4536 /* Unary left fold, (... + X). */
4538 d_append_string (dpi
, "(...");
4539 d_print_expr_op (dpi
, options
, operator_
);
4540 d_print_subexpr (dpi
, options
, op1
);
4541 d_append_char (dpi
, ')');
4544 /* Unary right fold, (X + ...). */
4546 d_append_char (dpi
, '(');
4547 d_print_subexpr (dpi
, options
, op1
);
4548 d_print_expr_op (dpi
, options
, operator_
);
4549 d_append_string (dpi
, "...)");
4552 /* Binary left fold, (42 + ... + X). */
4554 /* Binary right fold, (X + ... + 42). */
4556 d_append_char (dpi
, '(');
4557 d_print_subexpr (dpi
, options
, op1
);
4558 d_print_expr_op (dpi
, options
, operator_
);
4559 d_append_string (dpi
, "...");
4560 d_print_expr_op (dpi
, options
, operator_
);
4561 d_print_subexpr (dpi
, options
, op2
);
4562 d_append_char (dpi
, ')');
4566 dpi
->pack_index
= save_idx
;
4570 /* Subroutine to handle components. */
4573 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4574 const struct demangle_component
*dc
)
4576 /* Magic variable to let reference smashing skip over the next modifier
4577 without needing to modify *dc. */
4578 const struct demangle_component
*mod_inner
= NULL
;
4580 /* Variable used to store the current templates while a previously
4581 captured scope is used. */
4582 struct d_print_template
*saved_templates
;
4584 /* Nonzero if templates have been stored in the above variable. */
4585 int need_template_restore
= 0;
4589 d_print_error (dpi
);
4592 if (d_print_saw_error (dpi
))
4597 case DEMANGLE_COMPONENT_NAME
:
4598 if ((options
& DMGL_JAVA
) == 0)
4599 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4601 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4604 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4605 d_print_comp (dpi
, options
, d_left (dc
));
4606 d_append_string (dpi
, "[abi:");
4607 d_print_comp (dpi
, options
, d_right (dc
));
4608 d_append_char (dpi
, ']');
4611 case DEMANGLE_COMPONENT_QUAL_NAME
:
4612 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4613 d_print_comp (dpi
, options
, d_left (dc
));
4614 if ((options
& DMGL_JAVA
) == 0)
4615 d_append_string (dpi
, "::");
4617 d_append_char (dpi
, '.');
4619 struct demangle_component
*local_name
= d_right (dc
);
4620 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4622 d_append_string (dpi
, "{default arg#");
4623 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4624 d_append_string (dpi
, "}::");
4625 local_name
= local_name
->u
.s_unary_num
.sub
;
4627 d_print_comp (dpi
, options
, local_name
);
4631 case DEMANGLE_COMPONENT_TYPED_NAME
:
4633 struct d_print_mod
*hold_modifiers
;
4634 struct demangle_component
*typed_name
;
4635 struct d_print_mod adpm
[4];
4637 struct d_print_template dpt
;
4639 /* Pass the name down to the type so that it can be printed in
4640 the right place for the type. We also have to pass down
4641 any CV-qualifiers, which apply to the this parameter. */
4642 hold_modifiers
= dpi
->modifiers
;
4645 typed_name
= d_left (dc
);
4646 while (typed_name
!= NULL
)
4648 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4650 d_print_error (dpi
);
4654 adpm
[i
].next
= dpi
->modifiers
;
4655 dpi
->modifiers
= &adpm
[i
];
4656 adpm
[i
].mod
= typed_name
;
4657 adpm
[i
].printed
= 0;
4658 adpm
[i
].templates
= dpi
->templates
;
4661 if (!is_fnqual_component_type (typed_name
->type
))
4664 typed_name
= d_left (typed_name
);
4667 if (typed_name
== NULL
)
4669 d_print_error (dpi
);
4673 /* If typed_name is a template, then it applies to the
4674 function type as well. */
4675 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4677 dpt
.next
= dpi
->templates
;
4678 dpi
->templates
= &dpt
;
4679 dpt
.template_decl
= typed_name
;
4682 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4683 there may be CV-qualifiers on its right argument which
4684 really apply here; this happens when parsing a class which
4685 is local to a function. */
4686 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4688 struct demangle_component
*local_name
;
4690 local_name
= d_right (typed_name
);
4691 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4692 local_name
= local_name
->u
.s_unary_num
.sub
;
4693 if (local_name
== NULL
)
4695 d_print_error (dpi
);
4698 while (is_fnqual_component_type (local_name
->type
))
4700 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4702 d_print_error (dpi
);
4706 adpm
[i
] = adpm
[i
- 1];
4707 adpm
[i
].next
= &adpm
[i
- 1];
4708 dpi
->modifiers
= &adpm
[i
];
4710 adpm
[i
- 1].mod
= local_name
;
4711 adpm
[i
- 1].printed
= 0;
4712 adpm
[i
- 1].templates
= dpi
->templates
;
4715 local_name
= d_left (local_name
);
4719 d_print_comp (dpi
, options
, d_right (dc
));
4721 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4722 dpi
->templates
= dpt
.next
;
4724 /* If the modifiers didn't get printed by the type, print them
4729 if (! adpm
[i
].printed
)
4731 d_append_char (dpi
, ' ');
4732 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4736 dpi
->modifiers
= hold_modifiers
;
4741 case DEMANGLE_COMPONENT_TEMPLATE
:
4743 struct d_print_mod
*hold_dpm
;
4744 struct demangle_component
*dcl
;
4745 const struct demangle_component
*hold_current
;
4747 /* This template may need to be referenced by a cast operator
4748 contained in its subtree. */
4749 hold_current
= dpi
->current_template
;
4750 dpi
->current_template
= dc
;
4752 /* Don't push modifiers into a template definition. Doing so
4753 could give the wrong definition for a template argument.
4754 Instead, treat the template essentially as a name. */
4756 hold_dpm
= dpi
->modifiers
;
4757 dpi
->modifiers
= NULL
;
4761 if ((options
& DMGL_JAVA
) != 0
4762 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4763 && dcl
->u
.s_name
.len
== 6
4764 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4766 /* Special-case Java arrays, so that JArray<TYPE> appears
4767 instead as TYPE[]. */
4769 d_print_comp (dpi
, options
, d_right (dc
));
4770 d_append_string (dpi
, "[]");
4774 d_print_comp (dpi
, options
, dcl
);
4775 if (d_last_char (dpi
) == '<')
4776 d_append_char (dpi
, ' ');
4777 d_append_char (dpi
, '<');
4778 d_print_comp (dpi
, options
, d_right (dc
));
4779 /* Avoid generating two consecutive '>' characters, to avoid
4780 the C++ syntactic ambiguity. */
4781 if (d_last_char (dpi
) == '>')
4782 d_append_char (dpi
, ' ');
4783 d_append_char (dpi
, '>');
4786 dpi
->modifiers
= hold_dpm
;
4787 dpi
->current_template
= hold_current
;
4792 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4793 if (dpi
->is_lambda_arg
)
4795 /* Show the template parm index, as that's how g++ displays
4796 these, and future proofs us against potential
4797 '[]<typename T> (T *a, T *b) {...}'. */
4798 d_append_buffer (dpi
, "auto:", 5);
4799 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4803 struct d_print_template
*hold_dpt
;
4804 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4806 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4807 a
= d_index_template_argument (a
, dpi
->pack_index
);
4811 d_print_error (dpi
);
4815 /* While processing this parameter, we need to pop the list
4816 of templates. This is because the template parameter may
4817 itself be a reference to a parameter of an outer
4820 hold_dpt
= dpi
->templates
;
4821 dpi
->templates
= hold_dpt
->next
;
4823 d_print_comp (dpi
, options
, a
);
4825 dpi
->templates
= hold_dpt
;
4829 case DEMANGLE_COMPONENT_CTOR
:
4830 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4833 case DEMANGLE_COMPONENT_DTOR
:
4834 d_append_char (dpi
, '~');
4835 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4838 case DEMANGLE_COMPONENT_VTABLE
:
4839 d_append_string (dpi
, "vtable for ");
4840 d_print_comp (dpi
, options
, d_left (dc
));
4843 case DEMANGLE_COMPONENT_VTT
:
4844 d_append_string (dpi
, "VTT for ");
4845 d_print_comp (dpi
, options
, d_left (dc
));
4848 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4849 d_append_string (dpi
, "construction vtable for ");
4850 d_print_comp (dpi
, options
, d_left (dc
));
4851 d_append_string (dpi
, "-in-");
4852 d_print_comp (dpi
, options
, d_right (dc
));
4855 case DEMANGLE_COMPONENT_TYPEINFO
:
4856 d_append_string (dpi
, "typeinfo for ");
4857 d_print_comp (dpi
, options
, d_left (dc
));
4860 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4861 d_append_string (dpi
, "typeinfo name for ");
4862 d_print_comp (dpi
, options
, d_left (dc
));
4865 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4866 d_append_string (dpi
, "typeinfo fn for ");
4867 d_print_comp (dpi
, options
, d_left (dc
));
4870 case DEMANGLE_COMPONENT_THUNK
:
4871 d_append_string (dpi
, "non-virtual thunk to ");
4872 d_print_comp (dpi
, options
, d_left (dc
));
4875 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4876 d_append_string (dpi
, "virtual thunk to ");
4877 d_print_comp (dpi
, options
, d_left (dc
));
4880 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4881 d_append_string (dpi
, "covariant return thunk to ");
4882 d_print_comp (dpi
, options
, d_left (dc
));
4885 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4886 d_append_string (dpi
, "java Class for ");
4887 d_print_comp (dpi
, options
, d_left (dc
));
4890 case DEMANGLE_COMPONENT_GUARD
:
4891 d_append_string (dpi
, "guard variable for ");
4892 d_print_comp (dpi
, options
, d_left (dc
));
4895 case DEMANGLE_COMPONENT_TLS_INIT
:
4896 d_append_string (dpi
, "TLS init function for ");
4897 d_print_comp (dpi
, options
, d_left (dc
));
4900 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4901 d_append_string (dpi
, "TLS wrapper function for ");
4902 d_print_comp (dpi
, options
, d_left (dc
));
4905 case DEMANGLE_COMPONENT_REFTEMP
:
4906 d_append_string (dpi
, "reference temporary #");
4907 d_print_comp (dpi
, options
, d_right (dc
));
4908 d_append_string (dpi
, " for ");
4909 d_print_comp (dpi
, options
, d_left (dc
));
4912 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4913 d_append_string (dpi
, "hidden alias for ");
4914 d_print_comp (dpi
, options
, d_left (dc
));
4917 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4918 d_append_string (dpi
, "transaction clone for ");
4919 d_print_comp (dpi
, options
, d_left (dc
));
4922 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4923 d_append_string (dpi
, "non-transaction clone for ");
4924 d_print_comp (dpi
, options
, d_left (dc
));
4927 case DEMANGLE_COMPONENT_SUB_STD
:
4928 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
4931 case DEMANGLE_COMPONENT_RESTRICT
:
4932 case DEMANGLE_COMPONENT_VOLATILE
:
4933 case DEMANGLE_COMPONENT_CONST
:
4935 struct d_print_mod
*pdpm
;
4937 /* When printing arrays, it's possible to have cases where the
4938 same CV-qualifier gets pushed on the stack multiple times.
4939 We only need to print it once. */
4941 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
4943 if (! pdpm
->printed
)
4945 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
4946 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
4947 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
4949 if (pdpm
->mod
->type
== dc
->type
)
4951 d_print_comp (dpi
, options
, d_left (dc
));
4959 case DEMANGLE_COMPONENT_REFERENCE
:
4960 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4962 /* Handle reference smashing: & + && = &. */
4963 const struct demangle_component
*sub
= d_left (dc
);
4964 if (!dpi
->is_lambda_arg
4965 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4967 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
4968 struct demangle_component
*a
;
4972 /* This is the first time SUB has been traversed.
4973 We need to capture the current templates so
4974 they can be restored if SUB is reentered as a
4976 d_save_scope (dpi
, sub
);
4977 if (d_print_saw_error (dpi
))
4982 const struct d_component_stack
*dcse
;
4983 int found_self_or_parent
= 0;
4985 /* This traversal is reentering SUB as a substition.
4986 If we are not beneath SUB or DC in the tree then we
4987 need to restore SUB's template stack temporarily. */
4988 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
4989 dcse
= dcse
->parent
)
4993 && dcse
!= dpi
->component_stack
))
4995 found_self_or_parent
= 1;
5000 if (!found_self_or_parent
)
5002 saved_templates
= dpi
->templates
;
5003 dpi
->templates
= scope
->templates
;
5004 need_template_restore
= 1;
5008 a
= d_lookup_template_argument (dpi
, sub
);
5009 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5010 a
= d_index_template_argument (a
, dpi
->pack_index
);
5014 if (need_template_restore
)
5015 dpi
->templates
= saved_templates
;
5017 d_print_error (dpi
);
5024 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5025 || sub
->type
== dc
->type
)
5027 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5028 mod_inner
= d_left (sub
);
5032 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5033 case DEMANGLE_COMPONENT_POINTER
:
5034 case DEMANGLE_COMPONENT_COMPLEX
:
5035 case DEMANGLE_COMPONENT_IMAGINARY
:
5036 FNQUAL_COMPONENT_CASE
:
5039 /* We keep a list of modifiers on the stack. */
5040 struct d_print_mod dpm
;
5042 dpm
.next
= dpi
->modifiers
;
5043 dpi
->modifiers
= &dpm
;
5046 dpm
.templates
= dpi
->templates
;
5049 mod_inner
= d_left (dc
);
5051 d_print_comp (dpi
, options
, mod_inner
);
5053 /* If the modifier didn't get printed by the type, print it
5056 d_print_mod (dpi
, options
, dc
);
5058 dpi
->modifiers
= dpm
.next
;
5060 if (need_template_restore
)
5061 dpi
->templates
= saved_templates
;
5066 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5067 if ((options
& DMGL_JAVA
) == 0)
5068 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5069 dc
->u
.s_builtin
.type
->len
);
5071 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5072 dc
->u
.s_builtin
.type
->java_len
);
5075 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5076 d_print_comp (dpi
, options
, d_left (dc
));
5079 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5081 if ((options
& DMGL_RET_POSTFIX
) != 0)
5082 d_print_function_type (dpi
,
5083 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5084 dc
, dpi
->modifiers
);
5086 /* Print return type if present */
5087 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5088 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5090 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5092 struct d_print_mod dpm
;
5094 /* We must pass this type down as a modifier in order to
5095 print it in the right location. */
5096 dpm
.next
= dpi
->modifiers
;
5097 dpi
->modifiers
= &dpm
;
5100 dpm
.templates
= dpi
->templates
;
5102 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5105 dpi
->modifiers
= dpm
.next
;
5110 /* In standard prefix notation, there is a space between the
5111 return type and the function signature. */
5112 if ((options
& DMGL_RET_POSTFIX
) == 0)
5113 d_append_char (dpi
, ' ');
5116 if ((options
& DMGL_RET_POSTFIX
) == 0)
5117 d_print_function_type (dpi
,
5118 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5119 dc
, dpi
->modifiers
);
5124 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5126 struct d_print_mod
*hold_modifiers
;
5127 struct d_print_mod adpm
[4];
5129 struct d_print_mod
*pdpm
;
5131 /* We must pass this type down as a modifier in order to print
5132 multi-dimensional arrays correctly. If the array itself is
5133 CV-qualified, we act as though the element type were
5134 CV-qualified. We do this by copying the modifiers down
5135 rather than fiddling pointers, so that we don't wind up
5136 with a d_print_mod higher on the stack pointing into our
5137 stack frame after we return. */
5139 hold_modifiers
= dpi
->modifiers
;
5141 adpm
[0].next
= hold_modifiers
;
5142 dpi
->modifiers
= &adpm
[0];
5144 adpm
[0].printed
= 0;
5145 adpm
[0].templates
= dpi
->templates
;
5148 pdpm
= hold_modifiers
;
5150 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5151 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5152 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5154 if (! pdpm
->printed
)
5156 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5158 d_print_error (dpi
);
5163 adpm
[i
].next
= dpi
->modifiers
;
5164 dpi
->modifiers
= &adpm
[i
];
5172 d_print_comp (dpi
, options
, d_right (dc
));
5174 dpi
->modifiers
= hold_modifiers
;
5176 if (adpm
[0].printed
)
5182 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5185 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5190 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5191 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5193 struct d_print_mod dpm
;
5195 dpm
.next
= dpi
->modifiers
;
5196 dpi
->modifiers
= &dpm
;
5199 dpm
.templates
= dpi
->templates
;
5201 d_print_comp (dpi
, options
, d_right (dc
));
5203 /* If the modifier didn't get printed by the type, print it
5206 d_print_mod (dpi
, options
, dc
);
5208 dpi
->modifiers
= dpm
.next
;
5213 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5214 if (dc
->u
.s_fixed
.sat
)
5215 d_append_string (dpi
, "_Sat ");
5216 /* Don't print "int _Accum". */
5217 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5218 != &cplus_demangle_builtin_types
['i'-'a'])
5220 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5221 d_append_char (dpi
, ' ');
5223 if (dc
->u
.s_fixed
.accum
)
5224 d_append_string (dpi
, "_Accum");
5226 d_append_string (dpi
, "_Fract");
5229 case DEMANGLE_COMPONENT_ARGLIST
:
5230 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5231 if (d_left (dc
) != NULL
)
5232 d_print_comp (dpi
, options
, d_left (dc
));
5233 if (d_right (dc
) != NULL
)
5236 unsigned long int flush_count
;
5237 /* Make sure ", " isn't flushed by d_append_string, otherwise
5238 dpi->len -= 2 wouldn't work. */
5239 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5240 d_print_flush (dpi
);
5241 d_append_string (dpi
, ", ");
5243 flush_count
= dpi
->flush_count
;
5244 d_print_comp (dpi
, options
, d_right (dc
));
5245 /* If that didn't print anything (which can happen with empty
5246 template argument packs), remove the comma and space. */
5247 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5252 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5254 struct demangle_component
*type
= d_left (dc
);
5255 struct demangle_component
*list
= d_right (dc
);
5258 d_print_comp (dpi
, options
, type
);
5259 d_append_char (dpi
, '{');
5260 d_print_comp (dpi
, options
, list
);
5261 d_append_char (dpi
, '}');
5265 case DEMANGLE_COMPONENT_OPERATOR
:
5267 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5270 d_append_string (dpi
, "operator");
5271 /* Add a space before new/delete. */
5272 if (IS_LOWER (op
->name
[0]))
5273 d_append_char (dpi
, ' ');
5274 /* Omit a trailing space. */
5275 if (op
->name
[len
-1] == ' ')
5277 d_append_buffer (dpi
, op
->name
, len
);
5281 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5282 d_append_string (dpi
, "operator ");
5283 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5286 case DEMANGLE_COMPONENT_CONVERSION
:
5287 d_append_string (dpi
, "operator ");
5288 d_print_conversion (dpi
, options
, dc
);
5291 case DEMANGLE_COMPONENT_NULLARY
:
5292 d_print_expr_op (dpi
, options
, d_left (dc
));
5295 case DEMANGLE_COMPONENT_UNARY
:
5297 struct demangle_component
*op
= d_left (dc
);
5298 struct demangle_component
*operand
= d_right (dc
);
5299 const char *code
= NULL
;
5301 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5303 code
= op
->u
.s_operator
.op
->code
;
5304 if (!strcmp (code
, "ad"))
5306 /* Don't print the argument list for the address of a
5308 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5309 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5310 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5311 operand
= d_left (operand
);
5313 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5315 /* This indicates a suffix operator. */
5316 operand
= d_left (operand
);
5317 d_print_subexpr (dpi
, options
, operand
);
5318 d_print_expr_op (dpi
, options
, op
);
5323 /* For sizeof..., just print the pack length. */
5324 if (code
&& !strcmp (code
, "sZ"))
5326 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5327 int len
= d_pack_length (a
);
5328 d_append_num (dpi
, len
);
5331 else if (code
&& !strcmp (code
, "sP"))
5333 int len
= d_args_length (dpi
, operand
);
5334 d_append_num (dpi
, len
);
5338 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5339 d_print_expr_op (dpi
, options
, op
);
5342 d_append_char (dpi
, '(');
5343 d_print_cast (dpi
, options
, op
);
5344 d_append_char (dpi
, ')');
5346 if (code
&& !strcmp (code
, "gs"))
5347 /* Avoid parens after '::'. */
5348 d_print_comp (dpi
, options
, operand
);
5349 else if (code
&& !strcmp (code
, "st"))
5350 /* Always print parens for sizeof (type). */
5352 d_append_char (dpi
, '(');
5353 d_print_comp (dpi
, options
, operand
);
5354 d_append_char (dpi
, ')');
5357 d_print_subexpr (dpi
, options
, operand
);
5361 case DEMANGLE_COMPONENT_BINARY
:
5362 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5364 d_print_error (dpi
);
5368 if (op_is_new_cast (d_left (dc
)))
5370 d_print_expr_op (dpi
, options
, d_left (dc
));
5371 d_append_char (dpi
, '<');
5372 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5373 d_append_string (dpi
, ">(");
5374 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5375 d_append_char (dpi
, ')');
5379 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5382 /* We wrap an expression which uses the greater-than operator in
5383 an extra layer of parens so that it does not get confused
5384 with the '>' which ends the template parameters. */
5385 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5386 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5387 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5388 d_append_char (dpi
, '(');
5390 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5391 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5393 /* Function call used in an expression should not have printed types
5394 of the function arguments. Values of the function arguments still
5395 get printed below. */
5397 const struct demangle_component
*func
= d_left (d_right (dc
));
5399 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5400 d_print_error (dpi
);
5401 d_print_subexpr (dpi
, options
, d_left (func
));
5404 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5405 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5407 d_append_char (dpi
, '[');
5408 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5409 d_append_char (dpi
, ']');
5413 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5414 d_print_expr_op (dpi
, options
, d_left (dc
));
5415 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5418 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5419 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5420 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5421 d_append_char (dpi
, ')');
5425 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5426 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5427 d_print_error (dpi
);
5430 case DEMANGLE_COMPONENT_TRINARY
:
5431 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5432 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5434 d_print_error (dpi
);
5437 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5440 struct demangle_component
*op
= d_left (dc
);
5441 struct demangle_component
*first
= d_left (d_right (dc
));
5442 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5443 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5445 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5447 d_print_subexpr (dpi
, options
, first
);
5448 d_print_expr_op (dpi
, options
, op
);
5449 d_print_subexpr (dpi
, options
, second
);
5450 d_append_string (dpi
, " : ");
5451 d_print_subexpr (dpi
, options
, third
);
5455 d_append_string (dpi
, "new ");
5456 if (d_left (first
) != NULL
)
5458 d_print_subexpr (dpi
, options
, first
);
5459 d_append_char (dpi
, ' ');
5461 d_print_comp (dpi
, options
, second
);
5463 d_print_subexpr (dpi
, options
, third
);
5468 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5469 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5470 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5471 d_print_error (dpi
);
5474 case DEMANGLE_COMPONENT_LITERAL
:
5475 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5477 enum d_builtin_type_print tp
;
5479 /* For some builtin types, produce simpler output. */
5480 tp
= D_PRINT_DEFAULT
;
5481 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5483 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5487 case D_PRINT_UNSIGNED
:
5489 case D_PRINT_UNSIGNED_LONG
:
5490 case D_PRINT_LONG_LONG
:
5491 case D_PRINT_UNSIGNED_LONG_LONG
:
5492 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5494 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5495 d_append_char (dpi
, '-');
5496 d_print_comp (dpi
, options
, d_right (dc
));
5501 case D_PRINT_UNSIGNED
:
5502 d_append_char (dpi
, 'u');
5505 d_append_char (dpi
, 'l');
5507 case D_PRINT_UNSIGNED_LONG
:
5508 d_append_string (dpi
, "ul");
5510 case D_PRINT_LONG_LONG
:
5511 d_append_string (dpi
, "ll");
5513 case D_PRINT_UNSIGNED_LONG_LONG
:
5514 d_append_string (dpi
, "ull");
5522 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5523 && d_right (dc
)->u
.s_name
.len
== 1
5524 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5526 switch (d_right (dc
)->u
.s_name
.s
[0])
5529 d_append_string (dpi
, "false");
5532 d_append_string (dpi
, "true");
5545 d_append_char (dpi
, '(');
5546 d_print_comp (dpi
, options
, d_left (dc
));
5547 d_append_char (dpi
, ')');
5548 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5549 d_append_char (dpi
, '-');
5550 if (tp
== D_PRINT_FLOAT
)
5551 d_append_char (dpi
, '[');
5552 d_print_comp (dpi
, options
, d_right (dc
));
5553 if (tp
== D_PRINT_FLOAT
)
5554 d_append_char (dpi
, ']');
5558 case DEMANGLE_COMPONENT_NUMBER
:
5559 d_append_num (dpi
, dc
->u
.s_number
.number
);
5562 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5563 d_append_string (dpi
, "java resource ");
5564 d_print_comp (dpi
, options
, d_left (dc
));
5567 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5568 d_print_comp (dpi
, options
, d_left (dc
));
5569 d_print_comp (dpi
, options
, d_right (dc
));
5572 case DEMANGLE_COMPONENT_CHARACTER
:
5573 d_append_char (dpi
, dc
->u
.s_character
.character
);
5576 case DEMANGLE_COMPONENT_DECLTYPE
:
5577 d_append_string (dpi
, "decltype (");
5578 d_print_comp (dpi
, options
, d_left (dc
));
5579 d_append_char (dpi
, ')');
5582 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5586 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5589 /* d_find_pack won't find anything if the only packs involved
5590 in this expansion are function parameter packs; in that
5591 case, just print the pattern and "...". */
5592 d_print_subexpr (dpi
, options
, d_left (dc
));
5593 d_append_string (dpi
, "...");
5597 len
= d_pack_length (a
);
5599 for (i
= 0; i
< len
; ++i
)
5601 dpi
->pack_index
= i
;
5602 d_print_comp (dpi
, options
, dc
);
5604 d_append_string (dpi
, ", ");
5609 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5611 long num
= dc
->u
.s_number
.number
;
5613 d_append_string (dpi
, "this");
5616 d_append_string (dpi
, "{parm#");
5617 d_append_num (dpi
, num
);
5618 d_append_char (dpi
, '}');
5623 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5624 d_append_string (dpi
, "global constructors keyed to ");
5625 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5628 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5629 d_append_string (dpi
, "global destructors keyed to ");
5630 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5633 case DEMANGLE_COMPONENT_LAMBDA
:
5634 d_append_string (dpi
, "{lambda(");
5635 /* Generic lambda auto parms are mangled as the template type
5637 dpi
->is_lambda_arg
++;
5638 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5639 dpi
->is_lambda_arg
--;
5640 d_append_string (dpi
, ")#");
5641 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5642 d_append_char (dpi
, '}');
5645 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5646 d_append_string (dpi
, "{unnamed type#");
5647 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5648 d_append_char (dpi
, '}');
5651 case DEMANGLE_COMPONENT_CLONE
:
5652 d_print_comp (dpi
, options
, d_left (dc
));
5653 d_append_string (dpi
, " [clone ");
5654 d_print_comp (dpi
, options
, d_right (dc
));
5655 d_append_char (dpi
, ']');
5659 d_print_error (dpi
);
5665 d_print_comp (struct d_print_info
*dpi
, int options
,
5666 const struct demangle_component
*dc
)
5668 struct d_component_stack self
;
5671 self
.parent
= dpi
->component_stack
;
5672 dpi
->component_stack
= &self
;
5674 d_print_comp_inner (dpi
, options
, dc
);
5676 dpi
->component_stack
= self
.parent
;
5679 /* Print a Java dentifier. For Java we try to handle encoded extended
5680 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5681 so we don't it for C++. Characters are encoded as
5685 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5691 for (p
= name
; p
< end
; ++p
)
5702 for (q
= p
+ 3; q
< end
; ++q
)
5708 else if (*q
>= 'A' && *q
<= 'F')
5709 dig
= *q
- 'A' + 10;
5710 else if (*q
>= 'a' && *q
<= 'f')
5711 dig
= *q
- 'a' + 10;
5717 /* If the Unicode character is larger than 256, we don't try
5718 to deal with it here. FIXME. */
5719 if (q
< end
&& *q
== '_' && c
< 256)
5721 d_append_char (dpi
, c
);
5727 d_append_char (dpi
, *p
);
5731 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5732 qualifiers on this after printing a function. */
5735 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5736 struct d_print_mod
*mods
, int suffix
)
5738 struct d_print_template
*hold_dpt
;
5740 if (mods
== NULL
|| d_print_saw_error (dpi
))
5745 && (is_fnqual_component_type (mods
->mod
->type
))))
5747 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5753 hold_dpt
= dpi
->templates
;
5754 dpi
->templates
= mods
->templates
;
5756 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5758 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5759 dpi
->templates
= hold_dpt
;
5762 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5764 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5765 dpi
->templates
= hold_dpt
;
5768 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5770 struct d_print_mod
*hold_modifiers
;
5771 struct demangle_component
*dc
;
5773 /* When this is on the modifier stack, we have pulled any
5774 qualifiers off the right argument already. Otherwise, we
5775 print it as usual, but don't let the left argument see any
5778 hold_modifiers
= dpi
->modifiers
;
5779 dpi
->modifiers
= NULL
;
5780 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5781 dpi
->modifiers
= hold_modifiers
;
5783 if ((options
& DMGL_JAVA
) == 0)
5784 d_append_string (dpi
, "::");
5786 d_append_char (dpi
, '.');
5788 dc
= d_right (mods
->mod
);
5790 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5792 d_append_string (dpi
, "{default arg#");
5793 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5794 d_append_string (dpi
, "}::");
5795 dc
= dc
->u
.s_unary_num
.sub
;
5798 while (is_fnqual_component_type (dc
->type
))
5801 d_print_comp (dpi
, options
, dc
);
5803 dpi
->templates
= hold_dpt
;
5807 d_print_mod (dpi
, options
, mods
->mod
);
5809 dpi
->templates
= hold_dpt
;
5811 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5814 /* Print a modifier. */
5817 d_print_mod (struct d_print_info
*dpi
, int options
,
5818 const struct demangle_component
*mod
)
5822 case DEMANGLE_COMPONENT_RESTRICT
:
5823 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5824 d_append_string (dpi
, " restrict");
5826 case DEMANGLE_COMPONENT_VOLATILE
:
5827 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5828 d_append_string (dpi
, " volatile");
5830 case DEMANGLE_COMPONENT_CONST
:
5831 case DEMANGLE_COMPONENT_CONST_THIS
:
5832 d_append_string (dpi
, " const");
5834 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5835 d_append_string (dpi
, " transaction_safe");
5837 case DEMANGLE_COMPONENT_NOEXCEPT
:
5838 d_append_string (dpi
, " noexcept");
5841 d_append_char (dpi
, '(');
5842 d_print_comp (dpi
, options
, d_right (mod
));
5843 d_append_char (dpi
, ')');
5846 case DEMANGLE_COMPONENT_THROW_SPEC
:
5847 d_append_string (dpi
, " throw");
5850 d_append_char (dpi
, '(');
5851 d_print_comp (dpi
, options
, d_right (mod
));
5852 d_append_char (dpi
, ')');
5855 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5856 d_append_char (dpi
, ' ');
5857 d_print_comp (dpi
, options
, d_right (mod
));
5859 case DEMANGLE_COMPONENT_POINTER
:
5860 /* There is no pointer symbol in Java. */
5861 if ((options
& DMGL_JAVA
) == 0)
5862 d_append_char (dpi
, '*');
5864 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5865 /* For the ref-qualifier, put a space before the &. */
5866 d_append_char (dpi
, ' ');
5868 case DEMANGLE_COMPONENT_REFERENCE
:
5869 d_append_char (dpi
, '&');
5871 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5872 d_append_char (dpi
, ' ');
5874 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5875 d_append_string (dpi
, "&&");
5877 case DEMANGLE_COMPONENT_COMPLEX
:
5878 d_append_string (dpi
, "complex ");
5880 case DEMANGLE_COMPONENT_IMAGINARY
:
5881 d_append_string (dpi
, "imaginary ");
5883 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5884 if (d_last_char (dpi
) != '(')
5885 d_append_char (dpi
, ' ');
5886 d_print_comp (dpi
, options
, d_left (mod
));
5887 d_append_string (dpi
, "::*");
5889 case DEMANGLE_COMPONENT_TYPED_NAME
:
5890 d_print_comp (dpi
, options
, d_left (mod
));
5892 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5893 d_append_string (dpi
, " __vector(");
5894 d_print_comp (dpi
, options
, d_left (mod
));
5895 d_append_char (dpi
, ')');
5899 /* Otherwise, we have something that won't go back on the
5900 modifier stack, so we can just print it. */
5901 d_print_comp (dpi
, options
, mod
);
5906 /* Print a function type, except for the return type. */
5909 d_print_function_type (struct d_print_info
*dpi
, int options
,
5910 const struct demangle_component
*dc
,
5911 struct d_print_mod
*mods
)
5915 struct d_print_mod
*p
;
5916 struct d_print_mod
*hold_modifiers
;
5920 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5925 switch (p
->mod
->type
)
5927 case DEMANGLE_COMPONENT_POINTER
:
5928 case DEMANGLE_COMPONENT_REFERENCE
:
5929 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5932 case DEMANGLE_COMPONENT_RESTRICT
:
5933 case DEMANGLE_COMPONENT_VOLATILE
:
5934 case DEMANGLE_COMPONENT_CONST
:
5935 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5936 case DEMANGLE_COMPONENT_COMPLEX
:
5937 case DEMANGLE_COMPONENT_IMAGINARY
:
5938 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5942 FNQUAL_COMPONENT_CASE
:
5955 if (d_last_char (dpi
) != '('
5956 && d_last_char (dpi
) != '*')
5959 if (need_space
&& d_last_char (dpi
) != ' ')
5960 d_append_char (dpi
, ' ');
5961 d_append_char (dpi
, '(');
5964 hold_modifiers
= dpi
->modifiers
;
5965 dpi
->modifiers
= NULL
;
5967 d_print_mod_list (dpi
, options
, mods
, 0);
5970 d_append_char (dpi
, ')');
5972 d_append_char (dpi
, '(');
5974 if (d_right (dc
) != NULL
)
5975 d_print_comp (dpi
, options
, d_right (dc
));
5977 d_append_char (dpi
, ')');
5979 d_print_mod_list (dpi
, options
, mods
, 1);
5981 dpi
->modifiers
= hold_modifiers
;
5984 /* Print an array type, except for the element type. */
5987 d_print_array_type (struct d_print_info
*dpi
, int options
,
5988 const struct demangle_component
*dc
,
5989 struct d_print_mod
*mods
)
5997 struct d_print_mod
*p
;
6000 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6004 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6019 d_append_string (dpi
, " (");
6021 d_print_mod_list (dpi
, options
, mods
, 0);
6024 d_append_char (dpi
, ')');
6028 d_append_char (dpi
, ' ');
6030 d_append_char (dpi
, '[');
6032 if (d_left (dc
) != NULL
)
6033 d_print_comp (dpi
, options
, d_left (dc
));
6035 d_append_char (dpi
, ']');
6038 /* Print an operator in an expression. */
6041 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6042 const struct demangle_component
*dc
)
6044 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6045 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6046 dc
->u
.s_operator
.op
->len
);
6048 d_print_comp (dpi
, options
, dc
);
6054 d_print_cast (struct d_print_info
*dpi
, int options
,
6055 const struct demangle_component
*dc
)
6057 d_print_comp (dpi
, options
, d_left (dc
));
6060 /* Print a conversion operator. */
6063 d_print_conversion (struct d_print_info
*dpi
, int options
,
6064 const struct demangle_component
*dc
)
6066 struct d_print_template dpt
;
6068 /* For a conversion operator, we need the template parameters from
6069 the enclosing template in scope for processing the type. */
6070 if (dpi
->current_template
!= NULL
)
6072 dpt
.next
= dpi
->templates
;
6073 dpi
->templates
= &dpt
;
6074 dpt
.template_decl
= dpi
->current_template
;
6077 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6079 d_print_comp (dpi
, options
, d_left (dc
));
6080 if (dpi
->current_template
!= NULL
)
6081 dpi
->templates
= dpt
.next
;
6085 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6087 /* For a templated cast operator, we need to remove the template
6088 parameters from scope after printing the operator name,
6089 so we need to handle the template printing here. */
6090 if (dpi
->current_template
!= NULL
)
6091 dpi
->templates
= dpt
.next
;
6093 if (d_last_char (dpi
) == '<')
6094 d_append_char (dpi
, ' ');
6095 d_append_char (dpi
, '<');
6096 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6097 /* Avoid generating two consecutive '>' characters, to avoid
6098 the C++ syntactic ambiguity. */
6099 if (d_last_char (dpi
) == '>')
6100 d_append_char (dpi
, ' ');
6101 d_append_char (dpi
, '>');
6105 /* Initialize the information structure we use to pass around
6108 CP_STATIC_IF_GLIBCPP_V3
6110 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6114 di
->send
= mangled
+ len
;
6115 di
->options
= options
;
6119 /* We can not need more components than twice the number of chars in
6120 the mangled string. Most components correspond directly to
6121 chars, but the ARGLIST types are exceptions. */
6122 di
->num_comps
= 2 * len
;
6125 /* Similarly, we can not need more substitutions than there are
6126 chars in the mangled string. */
6131 di
->last_name
= NULL
;
6134 di
->is_expression
= 0;
6135 di
->is_conversion
= 0;
6138 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6139 mangled name, return strings in repeated callback giving the demangled
6140 name. OPTIONS is the usual libiberty demangler options. On success,
6141 this returns 1. On failure, returns 0. */
6144 d_demangle_callback (const char *mangled
, int options
,
6145 demangle_callbackref callback
, void *opaque
)
6156 struct demangle_component
*dc
;
6159 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6161 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6162 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6163 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6164 && mangled
[10] == '_')
6165 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6168 if ((options
& DMGL_TYPES
) == 0)
6173 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6176 #ifdef CP_DYNAMIC_ARRAYS
6177 __extension__
struct demangle_component comps
[di
.num_comps
];
6178 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6183 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6184 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6190 dc
= cplus_demangle_type (&di
);
6193 dc
= cplus_demangle_mangled_name (&di
, 1);
6195 case DCT_GLOBAL_CTORS
:
6196 case DCT_GLOBAL_DTORS
:
6197 d_advance (&di
, 11);
6198 dc
= d_make_comp (&di
,
6199 (type
== DCT_GLOBAL_CTORS
6200 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6201 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6202 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6204 d_advance (&di
, strlen (d_str (&di
)));
6207 abort (); /* We have listed all the cases. */
6210 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6211 mangled string, then we didn't successfully demangle it. If
6212 DMGL_PARAMS is not set, we didn't look at the trailing
6214 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6217 #ifdef CP_DEMANGLE_DEBUG
6221 status
= (dc
!= NULL
)
6222 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6229 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6230 name, return a buffer allocated with malloc holding the demangled
6231 name. OPTIONS is the usual libiberty demangler options. On
6232 success, this sets *PALC to the allocated size of the returned
6233 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6234 a memory allocation failure, and returns NULL. */
6237 d_demangle (const char *mangled
, int options
, size_t *palc
)
6239 struct d_growable_string dgs
;
6242 d_growable_string_init (&dgs
, 0);
6244 status
= d_demangle_callback (mangled
, options
,
6245 d_growable_string_callback_adapter
, &dgs
);
6253 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6257 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6259 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6261 /* ia64 ABI-mandated entry point in the C++ runtime library for
6262 performing demangling. MANGLED_NAME is a NUL-terminated character
6263 string containing the name to be demangled.
6265 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6266 *LENGTH bytes, into which the demangled name is stored. If
6267 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6268 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6269 is placed in a region of memory allocated with malloc.
6271 If LENGTH is non-NULL, the length of the buffer containing the
6272 demangled name, is placed in *LENGTH.
6274 The return value is a pointer to the start of the NUL-terminated
6275 demangled name, or NULL if the demangling fails. The caller is
6276 responsible for deallocating this memory using free.
6278 *STATUS is set to one of the following values:
6279 0: The demangling operation succeeded.
6280 -1: A memory allocation failure occurred.
6281 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6282 -3: One of the arguments is invalid.
6284 The demangling is performed using the C++ ABI mangling rules, with
6288 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6289 size_t *length
, int *status
)
6294 if (mangled_name
== NULL
)
6301 if (output_buffer
!= NULL
&& length
== NULL
)
6308 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6310 if (demangled
== NULL
)
6322 if (output_buffer
== NULL
)
6329 if (strlen (demangled
) < *length
)
6331 strcpy (output_buffer
, demangled
);
6333 demangled
= output_buffer
;
6337 free (output_buffer
);
6348 extern int __gcclibcxx_demangle_callback (const char *,
6350 (const char *, size_t, void *),
6353 /* Alternative, allocationless entry point in the C++ runtime library
6354 for performing demangling. MANGLED_NAME is a NUL-terminated character
6355 string containing the name to be demangled.
6357 CALLBACK is a callback function, called with demangled string
6358 segments as demangling progresses; it is called at least once,
6359 but may be called more than once. OPAQUE is a generalized pointer
6360 used as a callback argument.
6362 The return code is one of the following values, equivalent to
6363 the STATUS values of __cxa_demangle() (excluding -1, since this
6364 function performs no memory allocations):
6365 0: The demangling operation succeeded.
6366 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6367 -3: One of the arguments is invalid.
6369 The demangling is performed using the C++ ABI mangling rules, with
6373 __gcclibcxx_demangle_callback (const char *mangled_name
,
6374 void (*callback
) (const char *, size_t, void *),
6379 if (mangled_name
== NULL
|| callback
== NULL
)
6382 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6390 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6392 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6393 mangled name, return a buffer allocated with malloc holding the
6394 demangled name. Otherwise, return NULL. */
6397 cplus_demangle_v3 (const char *mangled
, int options
)
6401 return d_demangle (mangled
, options
, &alc
);
6405 cplus_demangle_v3_callback (const char *mangled
, int options
,
6406 demangle_callbackref callback
, void *opaque
)
6408 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6411 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6412 conventions, but the output formatting is a little different.
6413 This instructs the C++ demangler not to emit pointer characters ("*"), to
6414 use Java's namespace separator symbol ("." instead of "::"), and to output
6415 JArray<TYPE> as TYPE[]. */
6418 java_demangle_v3 (const char *mangled
)
6422 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6426 java_demangle_v3_callback (const char *mangled
,
6427 demangle_callbackref callback
, void *opaque
)
6429 return d_demangle_callback (mangled
,
6430 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6434 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6436 #ifndef IN_GLIBCPP_V3
6438 /* Demangle a string in order to find out whether it is a constructor
6439 or destructor. Return non-zero on success. Set *CTOR_KIND and
6440 *DTOR_KIND appropriately. */
6443 is_ctor_or_dtor (const char *mangled
,
6444 enum gnu_v3_ctor_kinds
*ctor_kind
,
6445 enum gnu_v3_dtor_kinds
*dtor_kind
)
6448 struct demangle_component
*dc
;
6451 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6452 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6454 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6457 #ifdef CP_DYNAMIC_ARRAYS
6458 __extension__
struct demangle_component comps
[di
.num_comps
];
6459 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6464 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6465 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6468 dc
= cplus_demangle_mangled_name (&di
, 1);
6470 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6471 to demangle the entire string. */
6478 /* These cannot appear on a constructor or destructor. */
6479 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6480 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6481 case DEMANGLE_COMPONENT_CONST_THIS
:
6482 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6483 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6487 case DEMANGLE_COMPONENT_TYPED_NAME
:
6488 case DEMANGLE_COMPONENT_TEMPLATE
:
6491 case DEMANGLE_COMPONENT_QUAL_NAME
:
6492 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6495 case DEMANGLE_COMPONENT_CTOR
:
6496 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6500 case DEMANGLE_COMPONENT_DTOR
:
6501 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6512 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6513 name. A non-zero return indicates the type of constructor. */
6515 enum gnu_v3_ctor_kinds
6516 is_gnu_v3_mangled_ctor (const char *name
)
6518 enum gnu_v3_ctor_kinds ctor_kind
;
6519 enum gnu_v3_dtor_kinds dtor_kind
;
6521 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6522 return (enum gnu_v3_ctor_kinds
) 0;
6527 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6528 name. A non-zero return indicates the type of destructor. */
6530 enum gnu_v3_dtor_kinds
6531 is_gnu_v3_mangled_dtor (const char *name
)
6533 enum gnu_v3_ctor_kinds ctor_kind
;
6534 enum gnu_v3_dtor_kinds dtor_kind
;
6536 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6537 return (enum gnu_v3_dtor_kinds
) 0;
6541 #endif /* IN_GLIBCPP_V3 */
6543 #ifdef STANDALONE_DEMANGLER
6546 #include "dyn-string.h"
6548 static void print_usage (FILE* fp
, int exit_value
);
6550 #define IS_ALPHA(CHAR) \
6551 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6552 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6554 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6555 #define is_mangled_char(CHAR) \
6556 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6557 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6559 /* The name of this program, as invoked. */
6560 const char* program_name
;
6562 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6565 print_usage (FILE* fp
, int exit_value
)
6567 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6568 fprintf (fp
, "Options:\n");
6569 fprintf (fp
, " -h,--help Display this message.\n");
6570 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6571 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6572 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6577 /* Option specification for getopt_long. */
6578 static const struct option long_options
[] =
6580 { "help", no_argument
, NULL
, 'h' },
6581 { "no-params", no_argument
, NULL
, 'p' },
6582 { "verbose", no_argument
, NULL
, 'v' },
6583 { NULL
, no_argument
, NULL
, 0 },
6586 /* Main entry for a demangling filter executable. It will demangle
6587 its command line arguments, if any. If none are provided, it will
6588 filter stdin to stdout, replacing any recognized mangled C++ names
6589 with their demangled equivalents. */
6592 main (int argc
, char *argv
[])
6596 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6598 /* Use the program name of this program, as invoked. */
6599 program_name
= argv
[0];
6601 /* Parse options. */
6604 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6607 case '?': /* Unrecognized option. */
6608 print_usage (stderr
, 1);
6612 print_usage (stdout
, 0);
6616 options
&= ~ DMGL_PARAMS
;
6620 options
|= DMGL_VERBOSE
;
6624 while (opt_char
!= -1);
6627 /* No command line arguments were provided. Filter stdin. */
6629 dyn_string_t mangled
= dyn_string_new (3);
6632 /* Read all of input. */
6633 while (!feof (stdin
))
6637 /* Pile characters into mangled until we hit one that can't
6638 occur in a mangled name. */
6640 while (!feof (stdin
) && is_mangled_char (c
))
6642 dyn_string_append_char (mangled
, c
);
6648 if (dyn_string_length (mangled
) > 0)
6650 #ifdef IN_GLIBCPP_V3
6651 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6653 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6663 /* It might not have been a mangled name. Print the
6665 fputs (dyn_string_buf (mangled
), stdout
);
6668 dyn_string_clear (mangled
);
6671 /* If we haven't hit EOF yet, we've read one character that
6672 can't occur in a mangled name, so print it out. */
6677 dyn_string_delete (mangled
);
6680 /* Demangle command line arguments. */
6682 /* Loop over command line arguments. */
6683 for (i
= optind
; i
< argc
; ++i
)
6686 #ifdef IN_GLIBCPP_V3
6690 /* Attempt to demangle. */
6691 #ifdef IN_GLIBCPP_V3
6692 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6694 s
= cplus_demangle_v3 (argv
[i
], options
);
6697 /* If it worked, print the demangled name. */
6705 #ifdef IN_GLIBCPP_V3
6706 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6708 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6717 #endif /* STANDALONE_DEMANGLER */