1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2021 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 https://itanium-cxx-abi.github.io/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, struct demangle_component
*, int, size_t *);
177 #define cplus_demangle_print_callback d_print_callback
178 static int d_print_callback (int, 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 && !__STDC_NO_VLA__
196 #define CP_DYNAMIC_ARRAYS
197 #endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */
198 #endif /* defined (__STDC_VERSION__) */
199 #endif /* defined (__STDC__) */
200 #endif /* ! defined (__GNUC__) */
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 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
322 /* Maximum number of times d_print_comp may be called recursively. */
323 #define MAX_RECURSION_COUNT 1024
325 enum { D_PRINT_BUFFER_LENGTH
= 256 };
328 /* Fixed-length allocated buffer for demangled data, flushed to the
329 callback with a NUL termination once full. */
330 char buf
[D_PRINT_BUFFER_LENGTH
];
331 /* Current length of data in buffer. */
333 /* The last character printed, saved individually so that it survives
336 /* Callback function to handle demangled buffer flush. */
337 demangle_callbackref callback
;
338 /* Opaque callback argument. */
340 /* The current list of templates, if any. */
341 struct d_print_template
*templates
;
342 /* The current list of modifiers (e.g., pointer, reference, etc.),
344 struct d_print_mod
*modifiers
;
345 /* Set to 1 if we saw a demangling error. */
346 int demangle_failure
;
347 /* Number of times d_print_comp was recursively called. Should not
348 be bigger than MAX_RECURSION_COUNT. */
350 /* Non-zero if we're printing a lambda argument. A template
351 parameter reference actually means 'auto'. */
353 /* The current index into any template argument packs we are using
354 for printing, or -1 to print the whole pack. */
356 /* Number of d_print_flush calls so far. */
357 unsigned long int flush_count
;
358 /* Stack of components, innermost first, used to avoid loops. */
359 const struct d_component_stack
*component_stack
;
360 /* Array of saved scopes for evaluating substitutions. */
361 struct d_saved_scope
*saved_scopes
;
362 /* Index of the next unused saved scope in the above array. */
363 int next_saved_scope
;
364 /* Number of saved scopes in the above array. */
365 int num_saved_scopes
;
366 /* Array of templates for saving into scopes. */
367 struct d_print_template
*copy_templates
;
368 /* Index of the next unused copy template in the above array. */
369 int next_copy_template
;
370 /* Number of copy templates in the above array. */
371 int num_copy_templates
;
372 /* The nearest enclosing template, if any. */
373 const struct demangle_component
*current_template
;
376 #ifdef CP_DEMANGLE_DEBUG
377 static void d_dump (struct demangle_component
*, int);
380 static struct demangle_component
*
381 d_make_empty (struct d_info
*);
383 static struct demangle_component
*
384 d_make_comp (struct d_info
*, enum demangle_component_type
,
385 struct demangle_component
*,
386 struct demangle_component
*);
388 static struct demangle_component
*
389 d_make_name (struct d_info
*, const char *, int);
391 static struct demangle_component
*
392 d_make_demangle_mangled_name (struct d_info
*, const char *);
394 static struct demangle_component
*
395 d_make_builtin_type (struct d_info
*,
396 const struct demangle_builtin_type_info
*);
398 static struct demangle_component
*
399 d_make_operator (struct d_info
*,
400 const struct demangle_operator_info
*);
402 static struct demangle_component
*
403 d_make_extended_operator (struct d_info
*, int,
404 struct demangle_component
*);
406 static struct demangle_component
*
407 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
408 struct demangle_component
*);
410 static struct demangle_component
*
411 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
412 struct demangle_component
*);
414 static struct demangle_component
*
415 d_make_template_param (struct d_info
*, int);
417 static struct demangle_component
*
418 d_make_sub (struct d_info
*, const char *, int);
421 has_return_type (struct demangle_component
*);
424 is_ctor_dtor_or_conversion (struct demangle_component
*);
426 static struct demangle_component
*d_encoding (struct d_info
*, int);
428 static struct demangle_component
*d_name (struct d_info
*);
430 static struct demangle_component
*d_nested_name (struct d_info
*);
432 static struct demangle_component
*d_prefix (struct d_info
*, int);
434 static struct demangle_component
*d_unqualified_name (struct d_info
*);
436 static struct demangle_component
*d_source_name (struct d_info
*);
438 static int d_number (struct d_info
*);
440 static struct demangle_component
*d_identifier (struct d_info
*, int);
442 static struct demangle_component
*d_operator_name (struct d_info
*);
444 static struct demangle_component
*d_special_name (struct d_info
*);
446 static struct demangle_component
*d_parmlist (struct d_info
*);
448 static int d_call_offset (struct d_info
*, int);
450 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
452 static struct demangle_component
**
453 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
455 static struct demangle_component
*
456 d_ref_qualifier (struct d_info
*, struct demangle_component
*);
458 static struct demangle_component
*
459 d_function_type (struct d_info
*);
461 static struct demangle_component
*
462 d_bare_function_type (struct d_info
*, int);
464 static struct demangle_component
*
465 d_class_enum_type (struct d_info
*);
467 static struct demangle_component
*d_array_type (struct d_info
*);
469 static struct demangle_component
*d_vector_type (struct d_info
*);
471 static struct demangle_component
*
472 d_pointer_to_member_type (struct d_info
*);
474 static struct demangle_component
*
475 d_template_param (struct d_info
*);
477 static struct demangle_component
*d_template_args (struct d_info
*);
478 static struct demangle_component
*d_template_args_1 (struct d_info
*);
480 static struct demangle_component
*
481 d_template_arg (struct d_info
*);
483 static struct demangle_component
*d_expression (struct d_info
*);
485 static struct demangle_component
*d_expr_primary (struct d_info
*);
487 static struct demangle_component
*d_local_name (struct d_info
*);
489 static int d_discriminator (struct d_info
*);
491 static struct demangle_component
*d_lambda (struct d_info
*);
493 static struct demangle_component
*d_unnamed_type (struct d_info
*);
495 static struct demangle_component
*
496 d_clone_suffix (struct d_info
*, struct demangle_component
*);
499 d_add_substitution (struct d_info
*, struct demangle_component
*);
501 static struct demangle_component
*d_substitution (struct d_info
*, int);
503 static void d_checkpoint (struct d_info
*, struct d_info_checkpoint
*);
505 static void d_backtrack (struct d_info
*, struct d_info_checkpoint
*);
507 static void d_growable_string_init (struct d_growable_string
*, size_t);
510 d_growable_string_resize (struct d_growable_string
*, size_t);
513 d_growable_string_append_buffer (struct d_growable_string
*,
514 const char *, size_t);
516 d_growable_string_callback_adapter (const char *, size_t, void *);
519 d_print_init (struct d_print_info
*, demangle_callbackref
, void *,
520 struct demangle_component
*);
522 static inline void d_print_error (struct d_print_info
*);
524 static inline int d_print_saw_error (struct d_print_info
*);
526 static inline void d_print_flush (struct d_print_info
*);
528 static inline void d_append_char (struct d_print_info
*, char);
530 static inline void d_append_buffer (struct d_print_info
*,
531 const char *, size_t);
533 static inline void d_append_string (struct d_print_info
*, const char *);
535 static inline char d_last_char (struct d_print_info
*);
538 d_print_comp (struct d_print_info
*, int, struct demangle_component
*);
541 d_print_java_identifier (struct d_print_info
*, const char *, int);
544 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
547 d_print_mod (struct d_print_info
*, int, struct demangle_component
*);
550 d_print_function_type (struct d_print_info
*, int,
551 struct demangle_component
*,
552 struct d_print_mod
*);
555 d_print_array_type (struct d_print_info
*, int,
556 struct demangle_component
*,
557 struct d_print_mod
*);
560 d_print_expr_op (struct d_print_info
*, int, struct demangle_component
*);
562 static void d_print_cast (struct d_print_info
*, int,
563 struct demangle_component
*);
564 static void d_print_conversion (struct d_print_info
*, int,
565 struct demangle_component
*);
567 static int d_demangle_callback (const char *, int,
568 demangle_callbackref
, void *);
569 static char *d_demangle (const char *, int, size_t *);
571 #define FNQUAL_COMPONENT_CASE \
572 case DEMANGLE_COMPONENT_RESTRICT_THIS: \
573 case DEMANGLE_COMPONENT_VOLATILE_THIS: \
574 case DEMANGLE_COMPONENT_CONST_THIS: \
575 case DEMANGLE_COMPONENT_REFERENCE_THIS: \
576 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
577 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
578 case DEMANGLE_COMPONENT_NOEXCEPT: \
579 case DEMANGLE_COMPONENT_THROW_SPEC
581 /* True iff TYPE is a demangling component representing a
582 function-type-qualifier. */
585 is_fnqual_component_type (enum demangle_component_type type
)
589 FNQUAL_COMPONENT_CASE
:
598 #ifdef CP_DEMANGLE_DEBUG
601 d_dump (struct demangle_component
*dc
, int indent
)
608 printf ("failed demangling\n");
612 for (i
= 0; i
< indent
; ++i
)
617 case DEMANGLE_COMPONENT_NAME
:
618 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
620 case DEMANGLE_COMPONENT_TAGGED_NAME
:
621 printf ("tagged name\n");
622 d_dump (dc
->u
.s_binary
.left
, indent
+ 2);
623 d_dump (dc
->u
.s_binary
.right
, indent
+ 2);
625 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
626 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
628 case DEMANGLE_COMPONENT_TPARM_OBJ
:
629 printf ("template parameter object\n");
631 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
632 printf ("function parameter %ld\n", dc
->u
.s_number
.number
);
634 case DEMANGLE_COMPONENT_CTOR
:
635 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
636 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
638 case DEMANGLE_COMPONENT_DTOR
:
639 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
640 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
642 case DEMANGLE_COMPONENT_SUB_STD
:
643 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
645 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
646 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
648 case DEMANGLE_COMPONENT_OPERATOR
:
649 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
651 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
652 printf ("extended operator with %d args\n",
653 dc
->u
.s_extended_operator
.args
);
654 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
657 case DEMANGLE_COMPONENT_QUAL_NAME
:
658 printf ("qualified name\n");
660 case DEMANGLE_COMPONENT_LOCAL_NAME
:
661 printf ("local name\n");
663 case DEMANGLE_COMPONENT_TYPED_NAME
:
664 printf ("typed name\n");
666 case DEMANGLE_COMPONENT_TEMPLATE
:
667 printf ("template\n");
669 case DEMANGLE_COMPONENT_VTABLE
:
672 case DEMANGLE_COMPONENT_VTT
:
675 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
676 printf ("construction vtable\n");
678 case DEMANGLE_COMPONENT_TYPEINFO
:
679 printf ("typeinfo\n");
681 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
682 printf ("typeinfo name\n");
684 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
685 printf ("typeinfo function\n");
687 case DEMANGLE_COMPONENT_THUNK
:
690 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
691 printf ("virtual thunk\n");
693 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
694 printf ("covariant thunk\n");
696 case DEMANGLE_COMPONENT_JAVA_CLASS
:
697 printf ("java class\n");
699 case DEMANGLE_COMPONENT_GUARD
:
702 case DEMANGLE_COMPONENT_REFTEMP
:
703 printf ("reference temporary\n");
705 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
706 printf ("hidden alias\n");
708 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
709 printf ("transaction clone\n");
711 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
712 printf ("non-transaction clone\n");
714 case DEMANGLE_COMPONENT_RESTRICT
:
715 printf ("restrict\n");
717 case DEMANGLE_COMPONENT_VOLATILE
:
718 printf ("volatile\n");
720 case DEMANGLE_COMPONENT_CONST
:
723 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
724 printf ("restrict this\n");
726 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
727 printf ("volatile this\n");
729 case DEMANGLE_COMPONENT_CONST_THIS
:
730 printf ("const this\n");
732 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
733 printf ("reference this\n");
735 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
736 printf ("rvalue reference this\n");
738 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
739 printf ("transaction_safe this\n");
741 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
742 printf ("vendor type qualifier\n");
744 case DEMANGLE_COMPONENT_POINTER
:
745 printf ("pointer\n");
747 case DEMANGLE_COMPONENT_REFERENCE
:
748 printf ("reference\n");
750 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
751 printf ("rvalue reference\n");
753 case DEMANGLE_COMPONENT_COMPLEX
:
754 printf ("complex\n");
756 case DEMANGLE_COMPONENT_IMAGINARY
:
757 printf ("imaginary\n");
759 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
760 printf ("vendor type\n");
762 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
763 printf ("function type\n");
765 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
766 printf ("array type\n");
768 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
769 printf ("pointer to member type\n");
771 case DEMANGLE_COMPONENT_FIXED_TYPE
:
772 printf ("fixed-point type, accum? %d, sat? %d\n",
773 dc
->u
.s_fixed
.accum
, dc
->u
.s_fixed
.sat
);
774 d_dump (dc
->u
.s_fixed
.length
, indent
+ 2);
776 case DEMANGLE_COMPONENT_ARGLIST
:
777 printf ("argument list\n");
779 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
780 printf ("template argument list\n");
782 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
783 printf ("initializer list\n");
785 case DEMANGLE_COMPONENT_CAST
:
788 case DEMANGLE_COMPONENT_CONVERSION
:
789 printf ("conversion operator\n");
791 case DEMANGLE_COMPONENT_NULLARY
:
792 printf ("nullary operator\n");
794 case DEMANGLE_COMPONENT_UNARY
:
795 printf ("unary operator\n");
797 case DEMANGLE_COMPONENT_BINARY
:
798 printf ("binary operator\n");
800 case DEMANGLE_COMPONENT_BINARY_ARGS
:
801 printf ("binary operator arguments\n");
803 case DEMANGLE_COMPONENT_TRINARY
:
804 printf ("trinary operator\n");
806 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
807 printf ("trinary operator arguments 1\n");
809 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
810 printf ("trinary operator arguments 1\n");
812 case DEMANGLE_COMPONENT_LITERAL
:
813 printf ("literal\n");
815 case DEMANGLE_COMPONENT_LITERAL_NEG
:
816 printf ("negative literal\n");
818 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
819 printf ("java resource\n");
821 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
822 printf ("compound name\n");
824 case DEMANGLE_COMPONENT_CHARACTER
:
825 printf ("character '%c'\n", dc
->u
.s_character
.character
);
827 case DEMANGLE_COMPONENT_NUMBER
:
828 printf ("number %ld\n", dc
->u
.s_number
.number
);
830 case DEMANGLE_COMPONENT_DECLTYPE
:
831 printf ("decltype\n");
833 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
834 printf ("pack expansion\n");
836 case DEMANGLE_COMPONENT_TLS_INIT
:
837 printf ("tls init function\n");
839 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
840 printf ("tls wrapper function\n");
842 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
843 printf ("default argument %d\n", dc
->u
.s_unary_num
.num
);
844 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
846 case DEMANGLE_COMPONENT_LAMBDA
:
847 printf ("lambda %d\n", dc
->u
.s_unary_num
.num
);
848 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
852 d_dump (d_left (dc
), indent
+ 2);
853 d_dump (d_right (dc
), indent
+ 2);
856 #endif /* CP_DEMANGLE_DEBUG */
858 /* Fill in a DEMANGLE_COMPONENT_NAME. */
860 CP_STATIC_IF_GLIBCPP_V3
862 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
864 if (p
== NULL
|| s
== NULL
|| len
<= 0)
868 p
->type
= DEMANGLE_COMPONENT_NAME
;
870 p
->u
.s_name
.len
= len
;
874 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
876 CP_STATIC_IF_GLIBCPP_V3
878 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
879 struct demangle_component
*name
)
881 if (p
== NULL
|| args
< 0 || name
== NULL
)
885 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
886 p
->u
.s_extended_operator
.args
= args
;
887 p
->u
.s_extended_operator
.name
= name
;
891 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
893 CP_STATIC_IF_GLIBCPP_V3
895 cplus_demangle_fill_ctor (struct demangle_component
*p
,
896 enum gnu_v3_ctor_kinds kind
,
897 struct demangle_component
*name
)
901 || (int) kind
< gnu_v3_complete_object_ctor
902 || (int) kind
> gnu_v3_object_ctor_group
)
906 p
->type
= DEMANGLE_COMPONENT_CTOR
;
907 p
->u
.s_ctor
.kind
= kind
;
908 p
->u
.s_ctor
.name
= name
;
912 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
914 CP_STATIC_IF_GLIBCPP_V3
916 cplus_demangle_fill_dtor (struct demangle_component
*p
,
917 enum gnu_v3_dtor_kinds kind
,
918 struct demangle_component
*name
)
922 || (int) kind
< gnu_v3_deleting_dtor
923 || (int) kind
> gnu_v3_object_dtor_group
)
927 p
->type
= DEMANGLE_COMPONENT_DTOR
;
928 p
->u
.s_dtor
.kind
= kind
;
929 p
->u
.s_dtor
.name
= name
;
933 /* Add a new component. */
935 static struct demangle_component
*
936 d_make_empty (struct d_info
*di
)
938 struct demangle_component
*p
;
940 if (di
->next_comp
>= di
->num_comps
)
942 p
= &di
->comps
[di
->next_comp
];
949 /* Add a new generic component. */
951 static struct demangle_component
*
952 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
953 struct demangle_component
*left
,
954 struct demangle_component
*right
)
956 struct demangle_component
*p
;
958 /* We check for errors here. A typical error would be a NULL return
959 from a subroutine. We catch those here, and return NULL
963 /* These types require two parameters. */
964 case DEMANGLE_COMPONENT_QUAL_NAME
:
965 case DEMANGLE_COMPONENT_LOCAL_NAME
:
966 case DEMANGLE_COMPONENT_TYPED_NAME
:
967 case DEMANGLE_COMPONENT_TAGGED_NAME
:
968 case DEMANGLE_COMPONENT_TEMPLATE
:
969 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
970 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
971 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
972 case DEMANGLE_COMPONENT_UNARY
:
973 case DEMANGLE_COMPONENT_BINARY
:
974 case DEMANGLE_COMPONENT_BINARY_ARGS
:
975 case DEMANGLE_COMPONENT_TRINARY
:
976 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
977 case DEMANGLE_COMPONENT_LITERAL
:
978 case DEMANGLE_COMPONENT_LITERAL_NEG
:
979 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
980 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
981 case DEMANGLE_COMPONENT_CLONE
:
982 if (left
== NULL
|| right
== NULL
)
986 /* These types only require one parameter. */
987 case DEMANGLE_COMPONENT_VTABLE
:
988 case DEMANGLE_COMPONENT_VTT
:
989 case DEMANGLE_COMPONENT_TYPEINFO
:
990 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
991 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
992 case DEMANGLE_COMPONENT_THUNK
:
993 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
994 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
995 case DEMANGLE_COMPONENT_JAVA_CLASS
:
996 case DEMANGLE_COMPONENT_GUARD
:
997 case DEMANGLE_COMPONENT_TLS_INIT
:
998 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
999 case DEMANGLE_COMPONENT_REFTEMP
:
1000 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
1001 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
1002 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
1003 case DEMANGLE_COMPONENT_POINTER
:
1004 case DEMANGLE_COMPONENT_REFERENCE
:
1005 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
1006 case DEMANGLE_COMPONENT_COMPLEX
:
1007 case DEMANGLE_COMPONENT_IMAGINARY
:
1008 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
1009 case DEMANGLE_COMPONENT_CAST
:
1010 case DEMANGLE_COMPONENT_CONVERSION
:
1011 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
1012 case DEMANGLE_COMPONENT_DECLTYPE
:
1013 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
1014 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
1015 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
1016 case DEMANGLE_COMPONENT_NULLARY
:
1017 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
1018 case DEMANGLE_COMPONENT_TPARM_OBJ
:
1023 /* This needs a right parameter, but the left parameter can be
1025 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
1026 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
1031 /* These are allowed to have no parameters--in some cases they
1032 will be filled in later. */
1033 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
1034 case DEMANGLE_COMPONENT_RESTRICT
:
1035 case DEMANGLE_COMPONENT_VOLATILE
:
1036 case DEMANGLE_COMPONENT_CONST
:
1037 case DEMANGLE_COMPONENT_ARGLIST
:
1038 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
1039 FNQUAL_COMPONENT_CASE
:
1042 /* Other types should not be seen here. */
1047 p
= d_make_empty (di
);
1051 p
->u
.s_binary
.left
= left
;
1052 p
->u
.s_binary
.right
= right
;
1057 /* Add a new demangle mangled name component. */
1059 static struct demangle_component
*
1060 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
1062 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
1063 return d_make_name (di
, s
, strlen (s
));
1065 return d_encoding (di
, 0);
1068 /* Add a new name component. */
1070 static struct demangle_component
*
1071 d_make_name (struct d_info
*di
, const char *s
, int len
)
1073 struct demangle_component
*p
;
1075 p
= d_make_empty (di
);
1076 if (! cplus_demangle_fill_name (p
, s
, len
))
1081 /* Add a new builtin type component. */
1083 static struct demangle_component
*
1084 d_make_builtin_type (struct d_info
*di
,
1085 const struct demangle_builtin_type_info
*type
)
1087 struct demangle_component
*p
;
1091 p
= d_make_empty (di
);
1094 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
1095 p
->u
.s_builtin
.type
= type
;
1100 /* Add a new operator component. */
1102 static struct demangle_component
*
1103 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
1105 struct demangle_component
*p
;
1107 p
= d_make_empty (di
);
1110 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
1111 p
->u
.s_operator
.op
= op
;
1116 /* Add a new extended operator component. */
1118 static struct demangle_component
*
1119 d_make_extended_operator (struct d_info
*di
, int args
,
1120 struct demangle_component
*name
)
1122 struct demangle_component
*p
;
1124 p
= d_make_empty (di
);
1125 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
1130 static struct demangle_component
*
1131 d_make_default_arg (struct d_info
*di
, int num
,
1132 struct demangle_component
*sub
)
1134 struct demangle_component
*p
= d_make_empty (di
);
1137 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1138 p
->u
.s_unary_num
.num
= num
;
1139 p
->u
.s_unary_num
.sub
= sub
;
1144 /* Add a new constructor component. */
1146 static struct demangle_component
*
1147 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1148 struct demangle_component
*name
)
1150 struct demangle_component
*p
;
1152 p
= d_make_empty (di
);
1153 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1158 /* Add a new destructor component. */
1160 static struct demangle_component
*
1161 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1162 struct demangle_component
*name
)
1164 struct demangle_component
*p
;
1166 p
= d_make_empty (di
);
1167 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1172 /* Add a new template parameter. */
1174 static struct demangle_component
*
1175 d_make_template_param (struct d_info
*di
, int i
)
1177 struct demangle_component
*p
;
1179 p
= d_make_empty (di
);
1182 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1183 p
->u
.s_number
.number
= i
;
1188 /* Add a new function parameter. */
1190 static struct demangle_component
*
1191 d_make_function_param (struct d_info
*di
, int i
)
1193 struct demangle_component
*p
;
1195 p
= d_make_empty (di
);
1198 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1199 p
->u
.s_number
.number
= i
;
1204 /* Add a new standard substitution component. */
1206 static struct demangle_component
*
1207 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1209 struct demangle_component
*p
;
1211 p
= d_make_empty (di
);
1214 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1215 p
->u
.s_string
.string
= name
;
1216 p
->u
.s_string
.len
= len
;
1221 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1223 TOP_LEVEL is non-zero when called at the top level. */
1225 CP_STATIC_IF_GLIBCPP_V3
1226 struct demangle_component
*
1227 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1229 struct demangle_component
*p
;
1231 if (! d_check_char (di
, '_')
1232 /* Allow missing _ if not at toplevel to work around a
1233 bug in G++ abi-version=2 mangling; see the comment in
1234 write_template_arg. */
1237 if (! d_check_char (di
, 'Z'))
1239 p
= d_encoding (di
, top_level
);
1241 /* If at top level and parsing parameters, check for a clone
1243 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1244 while (d_peek_char (di
) == '.'
1245 && (IS_LOWER (d_peek_next_char (di
))
1246 || d_peek_next_char (di
) == '_'
1247 || IS_DIGIT (d_peek_next_char (di
))))
1248 p
= d_clone_suffix (di
, p
);
1253 /* Return whether a function should have a return type. The argument
1254 is the function name, which may be qualified in various ways. The
1255 rules are that template functions have return types with some
1256 exceptions, function types which are not part of a function name
1257 mangling have return types with some exceptions, and non-template
1258 function names do not have return types. The exceptions are that
1259 constructors, destructors, and conversion operators do not have
1263 has_return_type (struct demangle_component
*dc
)
1271 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1272 return has_return_type (d_right (dc
));
1273 case DEMANGLE_COMPONENT_TEMPLATE
:
1274 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1275 FNQUAL_COMPONENT_CASE
:
1276 return has_return_type (d_left (dc
));
1280 /* Return whether a name is a constructor, a destructor, or a
1281 conversion operator. */
1284 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1292 case DEMANGLE_COMPONENT_QUAL_NAME
:
1293 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1294 return is_ctor_dtor_or_conversion (d_right (dc
));
1295 case DEMANGLE_COMPONENT_CTOR
:
1296 case DEMANGLE_COMPONENT_DTOR
:
1297 case DEMANGLE_COMPONENT_CONVERSION
:
1302 /* <encoding> ::= <(function) name> <bare-function-type>
1306 TOP_LEVEL is non-zero when called at the top level, in which case
1307 if DMGL_PARAMS is not set we do not demangle the function
1308 parameters. We only set this at the top level, because otherwise
1309 we would not correctly demangle names in local scopes. */
1311 static struct demangle_component
*
1312 d_encoding (struct d_info
*di
, int top_level
)
1314 char peek
= d_peek_char (di
);
1315 struct demangle_component
*dc
;
1317 if (peek
== 'G' || peek
== 'T')
1318 dc
= d_special_name (di
);
1324 /* Failed already. */;
1325 else if (top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1327 /* Strip off any initial CV-qualifiers, as they really apply
1328 to the `this' parameter, and they were not output by the
1329 v2 demangler without DMGL_PARAMS. */
1330 while (is_fnqual_component_type (dc
->type
))
1333 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1334 there may be function-qualifiers on its right argument which
1335 really apply here; this happens when parsing a class
1336 which is local to a function. */
1337 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1339 while (d_right (dc
) != NULL
1340 && is_fnqual_component_type (d_right (dc
)->type
))
1341 d_right (dc
) = d_left (d_right (dc
));
1343 if (d_right (dc
) == NULL
)
1349 peek
= d_peek_char (di
);
1350 if (peek
!= '\0' && peek
!= 'E')
1352 struct demangle_component
*ftype
;
1354 ftype
= d_bare_function_type (di
, has_return_type (dc
));
1357 /* If this is a non-top-level local-name, clear the
1358 return type, so it doesn't confuse the user by
1359 being confused with the return type of whaever
1360 this is nested within. */
1361 if (!top_level
&& dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
1362 && ftype
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
1363 d_left (ftype
) = NULL
;
1365 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
,
1377 /* <tagged-name> ::= <name> B <source-name> */
1379 static struct demangle_component
*
1380 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1382 struct demangle_component
*hold_last_name
;
1385 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1386 hold_last_name
= di
->last_name
;
1388 while (peek
= d_peek_char (di
),
1391 struct demangle_component
*tag
;
1393 tag
= d_source_name (di
);
1394 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1397 di
->last_name
= hold_last_name
;
1402 /* <name> ::= <nested-name>
1404 ::= <unscoped-template-name> <template-args>
1407 <unscoped-name> ::= <unqualified-name>
1408 ::= St <unqualified-name>
1410 <unscoped-template-name> ::= <unscoped-name>
1414 static struct demangle_component
*
1415 d_name (struct d_info
*di
)
1417 char peek
= d_peek_char (di
);
1418 struct demangle_component
*dc
;
1423 return d_nested_name (di
);
1426 return d_local_name (di
);
1429 return d_unqualified_name (di
);
1435 if (d_peek_next_char (di
) != 't')
1437 dc
= d_substitution (di
, 0);
1443 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1444 d_make_name (di
, "std", 3),
1445 d_unqualified_name (di
));
1450 if (d_peek_char (di
) != 'I')
1452 /* The grammar does not permit this case to occur if we
1453 called d_substitution() above (i.e., subst == 1). We
1454 don't bother to check. */
1458 /* This is <template-args>, which means that we just saw
1459 <unscoped-template-name>, which is a substitution
1460 candidate if we didn't just get it from a
1464 if (! d_add_substitution (di
, dc
))
1467 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1468 d_template_args (di
));
1476 dc
= d_unqualified_name (di
);
1477 if (d_peek_char (di
) == 'I')
1479 /* This is <template-args>, which means that we just saw
1480 <unscoped-template-name>, which is a substitution
1482 if (! d_add_substitution (di
, dc
))
1484 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1485 d_template_args (di
));
1491 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1492 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1495 static struct demangle_component
*
1496 d_nested_name (struct d_info
*di
)
1498 struct demangle_component
*ret
;
1499 struct demangle_component
**pret
;
1500 struct demangle_component
*rqual
;
1502 if (! d_check_char (di
, 'N'))
1505 pret
= d_cv_qualifiers (di
, &ret
, 1);
1509 /* Parse the ref-qualifier now and then attach it
1510 once we have something to attach it to. */
1511 rqual
= d_ref_qualifier (di
, NULL
);
1513 *pret
= d_prefix (di
, 1);
1519 d_left (rqual
) = ret
;
1523 if (! d_check_char (di
, 'E'))
1529 /* <prefix> ::= <prefix> <unqualified-name>
1530 ::= <template-prefix> <template-args>
1531 ::= <template-param>
1536 <template-prefix> ::= <prefix> <(template) unqualified-name>
1537 ::= <template-param>
1540 SUBST is true if we should add substitutions (as normal), false
1541 if not (in an unresolved-name). */
1543 static struct demangle_component
*
1544 d_prefix (struct d_info
*di
, int subst
)
1546 struct demangle_component
*ret
= NULL
;
1551 enum demangle_component_type comb_type
;
1552 struct demangle_component
*dc
;
1554 peek
= d_peek_char (di
);
1558 /* The older code accepts a <local-name> here, but I don't see
1559 that in the grammar. The older code does not accept a
1560 <template-param> here. */
1562 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1565 char peek2
= d_peek_next_char (di
);
1566 if (peek2
== 'T' || peek2
== 't')
1568 dc
= cplus_demangle_type (di
);
1570 /* Destructor name. */
1571 dc
= d_unqualified_name (di
);
1573 else if (IS_DIGIT (peek
)
1578 dc
= d_unqualified_name (di
);
1579 else if (peek
== 'S')
1580 dc
= d_substitution (di
, 1);
1581 else if (peek
== 'I')
1585 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1586 dc
= d_template_args (di
);
1588 else if (peek
== 'T')
1589 dc
= d_template_param (di
);
1590 else if (peek
== 'E')
1592 else if (peek
== 'M')
1594 /* Initializer scope for a lambda. We don't need to represent
1595 this; the normal code will just treat the variable as a type
1596 scope, which gives appropriate output. */
1608 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1610 if (peek
!= 'S' && d_peek_char (di
) != 'E' && subst
)
1612 if (! d_add_substitution (di
, ret
))
1618 /* <unqualified-name> ::= <operator-name>
1619 ::= <ctor-dtor-name>
1621 ::= <local-source-name>
1623 <local-source-name> ::= L <source-name> <discriminator>
1626 static struct demangle_component
*
1627 d_unqualified_name (struct d_info
*di
)
1629 struct demangle_component
*ret
;
1632 peek
= d_peek_char (di
);
1633 if (IS_DIGIT (peek
))
1634 ret
= d_source_name (di
);
1635 else if (IS_LOWER (peek
))
1637 int was_expr
= di
->is_expression
;
1638 if (peek
== 'o' && d_peek_next_char (di
) == 'n')
1641 /* Treat cv as naming a conversion operator. */
1642 di
->is_expression
= 0;
1644 ret
= d_operator_name (di
);
1645 di
->is_expression
= was_expr
;
1646 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1648 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1649 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1650 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1651 d_source_name (di
));
1654 else if (peek
== 'C' || peek
== 'D')
1655 ret
= d_ctor_dtor_name (di
);
1656 else if (peek
== 'L')
1660 ret
= d_source_name (di
);
1663 if (! d_discriminator (di
))
1666 else if (peek
== 'U')
1668 switch (d_peek_next_char (di
))
1671 ret
= d_lambda (di
);
1674 ret
= d_unnamed_type (di
);
1683 if (d_peek_char (di
) == 'B')
1684 ret
= d_abi_tags (di
, ret
);
1688 /* <source-name> ::= <(positive length) number> <identifier> */
1690 static struct demangle_component
*
1691 d_source_name (struct d_info
*di
)
1694 struct demangle_component
*ret
;
1696 len
= d_number (di
);
1699 ret
= d_identifier (di
, len
);
1700 di
->last_name
= ret
;
1704 /* number ::= [n] <(non-negative decimal integer)> */
1707 d_number (struct d_info
*di
)
1714 peek
= d_peek_char (di
);
1719 peek
= d_peek_char (di
);
1725 if (! IS_DIGIT (peek
))
1731 if (ret
> ((INT_MAX
- (peek
- '0')) / 10))
1733 ret
= ret
* 10 + (peek
- '0');
1735 peek
= d_peek_char (di
);
1739 /* Like d_number, but returns a demangle_component. */
1741 static struct demangle_component
*
1742 d_number_component (struct d_info
*di
)
1744 struct demangle_component
*ret
= d_make_empty (di
);
1747 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1748 ret
->u
.s_number
.number
= d_number (di
);
1753 /* identifier ::= <(unqualified source code identifier)> */
1755 static struct demangle_component
*
1756 d_identifier (struct d_info
*di
, int len
)
1762 if (di
->send
- name
< len
)
1765 d_advance (di
, len
);
1767 /* A Java mangled name may have a trailing '$' if it is a C++
1768 keyword. This '$' is not included in the length count. We just
1770 if ((di
->options
& DMGL_JAVA
) != 0
1771 && d_peek_char (di
) == '$')
1774 /* Look for something which looks like a gcc encoding of an
1775 anonymous namespace, and replace it with a more user friendly
1777 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1778 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1779 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1783 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1784 if ((*s
== '.' || *s
== '_' || *s
== '$')
1787 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1788 return d_make_name (di
, "(anonymous namespace)",
1789 sizeof "(anonymous namespace)" - 1);
1793 return d_make_name (di
, name
, len
);
1796 /* operator_name ::= many different two character encodings.
1798 ::= v <digit> <source-name>
1800 This list is sorted for binary search. */
1802 #define NL(s) s, (sizeof s) - 1
1804 CP_STATIC_IF_GLIBCPP_V3
1805 const struct demangle_operator_info cplus_demangle_operators
[] =
1807 { "aN", NL ("&="), 2 },
1808 { "aS", NL ("="), 2 },
1809 { "aa", NL ("&&"), 2 },
1810 { "ad", NL ("&"), 1 },
1811 { "an", NL ("&"), 2 },
1812 { "at", NL ("alignof "), 1 },
1813 { "aw", NL ("co_await "), 1 },
1814 { "az", NL ("alignof "), 1 },
1815 { "cc", NL ("const_cast"), 2 },
1816 { "cl", NL ("()"), 2 },
1817 { "cm", NL (","), 2 },
1818 { "co", NL ("~"), 1 },
1819 { "dV", NL ("/="), 2 },
1820 { "dX", NL ("[...]="), 3 }, /* [expr...expr] = expr */
1821 { "da", NL ("delete[] "), 1 },
1822 { "dc", NL ("dynamic_cast"), 2 },
1823 { "de", NL ("*"), 1 },
1824 { "di", NL ("="), 2 }, /* .name = expr */
1825 { "dl", NL ("delete "), 1 },
1826 { "ds", NL (".*"), 2 },
1827 { "dt", NL ("."), 2 },
1828 { "dv", NL ("/"), 2 },
1829 { "dx", NL ("]="), 2 }, /* [expr] = expr */
1830 { "eO", NL ("^="), 2 },
1831 { "eo", NL ("^"), 2 },
1832 { "eq", NL ("=="), 2 },
1833 { "fL", NL ("..."), 3 },
1834 { "fR", NL ("..."), 3 },
1835 { "fl", NL ("..."), 2 },
1836 { "fr", NL ("..."), 2 },
1837 { "ge", NL (">="), 2 },
1838 { "gs", NL ("::"), 1 },
1839 { "gt", NL (">"), 2 },
1840 { "ix", NL ("[]"), 2 },
1841 { "lS", NL ("<<="), 2 },
1842 { "le", NL ("<="), 2 },
1843 { "li", NL ("operator\"\" "), 1 },
1844 { "ls", NL ("<<"), 2 },
1845 { "lt", NL ("<"), 2 },
1846 { "mI", NL ("-="), 2 },
1847 { "mL", NL ("*="), 2 },
1848 { "mi", NL ("-"), 2 },
1849 { "ml", NL ("*"), 2 },
1850 { "mm", NL ("--"), 1 },
1851 { "na", NL ("new[]"), 3 },
1852 { "ne", NL ("!="), 2 },
1853 { "ng", NL ("-"), 1 },
1854 { "nt", NL ("!"), 1 },
1855 { "nw", NL ("new"), 3 },
1856 { "oR", NL ("|="), 2 },
1857 { "oo", NL ("||"), 2 },
1858 { "or", NL ("|"), 2 },
1859 { "pL", NL ("+="), 2 },
1860 { "pl", NL ("+"), 2 },
1861 { "pm", NL ("->*"), 2 },
1862 { "pp", NL ("++"), 1 },
1863 { "ps", NL ("+"), 1 },
1864 { "pt", NL ("->"), 2 },
1865 { "qu", NL ("?"), 3 },
1866 { "rM", NL ("%="), 2 },
1867 { "rS", NL (">>="), 2 },
1868 { "rc", NL ("reinterpret_cast"), 2 },
1869 { "rm", NL ("%"), 2 },
1870 { "rs", NL (">>"), 2 },
1871 { "sP", NL ("sizeof..."), 1 },
1872 { "sZ", NL ("sizeof..."), 1 },
1873 { "sc", NL ("static_cast"), 2 },
1874 { "ss", NL ("<=>"), 2 },
1875 { "st", NL ("sizeof "), 1 },
1876 { "sz", NL ("sizeof "), 1 },
1877 { "tr", NL ("throw"), 0 },
1878 { "tw", NL ("throw "), 1 },
1879 { NULL
, NULL
, 0, 0 }
1882 static struct demangle_component
*
1883 d_operator_name (struct d_info
*di
)
1888 c1
= d_next_char (di
);
1889 c2
= d_next_char (di
);
1890 if (c1
== 'v' && IS_DIGIT (c2
))
1891 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1892 else if (c1
== 'c' && c2
== 'v')
1894 struct demangle_component
*type
;
1895 int was_conversion
= di
->is_conversion
;
1896 struct demangle_component
*res
;
1898 di
->is_conversion
= ! di
->is_expression
;
1899 type
= cplus_demangle_type (di
);
1900 if (di
->is_conversion
)
1901 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1903 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1904 di
->is_conversion
= was_conversion
;
1909 /* LOW is the inclusive lower bound. */
1911 /* HIGH is the exclusive upper bound. We subtract one to ignore
1912 the sentinel at the end of the array. */
1913 int high
= ((sizeof (cplus_demangle_operators
)
1914 / sizeof (cplus_demangle_operators
[0]))
1920 const struct demangle_operator_info
*p
;
1922 i
= low
+ (high
- low
) / 2;
1923 p
= cplus_demangle_operators
+ i
;
1925 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1926 return d_make_operator (di
, p
);
1928 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1938 static struct demangle_component
*
1939 d_make_character (struct d_info
*di
, int c
)
1941 struct demangle_component
*p
;
1942 p
= d_make_empty (di
);
1945 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1946 p
->u
.s_character
.character
= c
;
1951 static struct demangle_component
*
1952 d_java_resource (struct d_info
*di
)
1954 struct demangle_component
*p
= NULL
;
1955 struct demangle_component
*next
= NULL
;
1960 len
= d_number (di
);
1964 /* Eat the leading '_'. */
1965 if (d_next_char (di
) != '_')
1978 /* Each chunk is either a '$' escape... */
1996 next
= d_make_character (di
, c
);
2004 /* ... or a sequence of characters. */
2007 while (i
< len
&& str
[i
] && str
[i
] != '$')
2010 next
= d_make_name (di
, str
, i
);
2023 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
2029 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
2034 /* <special-name> ::= TV <type>
2038 ::= TA <template-arg>
2039 ::= GV <(object) name>
2040 ::= T <call-offset> <(base) encoding>
2041 ::= Tc <call-offset> <call-offset> <(base) encoding>
2042 Also g++ extensions:
2043 ::= TC <type> <(offset) number> _ <(base) type>
2048 ::= Gr <resource name>
2053 static struct demangle_component
*
2054 d_special_name (struct d_info
*di
)
2056 di
->expansion
+= 20;
2057 if (d_check_char (di
, 'T'))
2059 switch (d_next_char (di
))
2063 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2064 cplus_demangle_type (di
), NULL
);
2066 di
->expansion
-= 10;
2067 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2068 cplus_demangle_type (di
), NULL
);
2070 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2071 cplus_demangle_type (di
), NULL
);
2073 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2074 cplus_demangle_type (di
), NULL
);
2077 if (! d_call_offset (di
, 'h'))
2079 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2080 d_encoding (di
, 0), NULL
);
2083 if (! d_call_offset (di
, 'v'))
2085 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2086 d_encoding (di
, 0), NULL
);
2089 if (! d_call_offset (di
, '\0'))
2091 if (! d_call_offset (di
, '\0'))
2093 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2094 d_encoding (di
, 0), NULL
);
2098 struct demangle_component
*derived_type
;
2100 struct demangle_component
*base_type
;
2102 derived_type
= cplus_demangle_type (di
);
2103 offset
= d_number (di
);
2106 if (! d_check_char (di
, '_'))
2108 base_type
= cplus_demangle_type (di
);
2109 /* We don't display the offset. FIXME: We should display
2110 it in verbose mode. */
2112 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2113 base_type
, derived_type
);
2117 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2118 cplus_demangle_type (di
), NULL
);
2120 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2121 cplus_demangle_type (di
), NULL
);
2124 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2128 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2132 return d_make_comp (di
, DEMANGLE_COMPONENT_TPARM_OBJ
,
2133 d_template_arg (di
), NULL
);
2139 else if (d_check_char (di
, 'G'))
2141 switch (d_next_char (di
))
2144 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
,
2149 struct demangle_component
*name
= d_name (di
);
2150 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2151 d_number_component (di
));
2155 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2156 d_encoding (di
, 0), NULL
);
2159 switch (d_next_char (di
))
2162 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2163 d_encoding (di
, 0), NULL
);
2165 /* ??? The proposal is that other letters (such as 'h') stand
2166 for different variants of transaction cloning, such as
2167 compiling directly for hardware transaction support. But
2168 they still should all be transactional clones of some sort
2169 so go ahead and call them that. */
2171 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2172 d_encoding (di
, 0), NULL
);
2176 return d_java_resource (di
);
2186 /* <call-offset> ::= h <nv-offset> _
2189 <nv-offset> ::= <(offset) number>
2191 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2193 The C parameter, if not '\0', is a character we just read which is
2194 the start of the <call-offset>.
2196 We don't display the offset information anywhere. FIXME: We should
2197 display it in verbose mode. */
2200 d_call_offset (struct d_info
*di
, int c
)
2203 c
= d_next_char (di
);
2210 if (! d_check_char (di
, '_'))
2217 if (! d_check_char (di
, '_'))
2223 /* <ctor-dtor-name> ::= C1
2231 static struct demangle_component
*
2232 d_ctor_dtor_name (struct d_info
*di
)
2234 if (di
->last_name
!= NULL
)
2236 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2237 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2238 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2239 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2241 switch (d_peek_char (di
))
2245 enum gnu_v3_ctor_kinds kind
;
2248 if (d_peek_next_char (di
) == 'I')
2254 switch (d_peek_next_char (di
))
2257 kind
= gnu_v3_complete_object_ctor
;
2260 kind
= gnu_v3_base_object_ctor
;
2263 kind
= gnu_v3_complete_object_allocating_ctor
;
2266 kind
= gnu_v3_unified_ctor
;
2269 kind
= gnu_v3_object_ctor_group
;
2278 cplus_demangle_type (di
);
2280 return d_make_ctor (di
, kind
, di
->last_name
);
2285 enum gnu_v3_dtor_kinds kind
;
2287 switch (d_peek_next_char (di
))
2290 kind
= gnu_v3_deleting_dtor
;
2293 kind
= gnu_v3_complete_object_dtor
;
2296 kind
= gnu_v3_base_object_dtor
;
2298 /* digit '3' is not used */
2300 kind
= gnu_v3_unified_dtor
;
2303 kind
= gnu_v3_object_dtor_group
;
2309 return d_make_dtor (di
, kind
, di
->last_name
);
2317 /* True iff we're looking at an order-insensitive type-qualifier, including
2318 function-type-qualifiers. */
2321 next_is_type_qual (struct d_info
*di
)
2323 char peek
= d_peek_char (di
);
2324 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2328 peek
= d_peek_next_char (di
);
2329 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2335 /* <type> ::= <builtin-type>
2337 ::= <class-enum-type>
2339 ::= <pointer-to-member-type>
2340 ::= <template-param>
2341 ::= <template-template-param> <template-args>
2343 ::= <CV-qualifiers> <type>
2346 ::= O <type> (C++0x)
2349 ::= U <source-name> <type>
2351 <builtin-type> ::= various one letter codes
2355 CP_STATIC_IF_GLIBCPP_V3
2356 const struct demangle_builtin_type_info
2357 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2359 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2360 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2361 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2362 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2363 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2364 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2365 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2366 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2367 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2368 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2369 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2370 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2371 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2372 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2373 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2375 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2376 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2377 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2378 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2379 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2380 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2381 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2382 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2383 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2384 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2385 D_PRINT_UNSIGNED_LONG_LONG
},
2386 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2387 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2388 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2389 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2390 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2391 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT
},
2392 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2393 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2394 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2398 CP_STATIC_IF_GLIBCPP_V3
2399 struct demangle_component
*
2400 cplus_demangle_type (struct d_info
*di
)
2403 struct demangle_component
*ret
;
2406 /* The ABI specifies that when CV-qualifiers are used, the base type
2407 is substitutable, and the fully qualified type is substitutable,
2408 but the base type with a strict subset of the CV-qualifiers is
2409 not substitutable. The natural recursive implementation of the
2410 CV-qualifiers would cause subsets to be substitutable, so instead
2411 we pull them all off now.
2413 FIXME: The ABI says that order-insensitive vendor qualifiers
2414 should be handled in the same way, but we have no way to tell
2415 which vendor qualifiers are order-insensitive and which are
2416 order-sensitive. So we just assume that they are all
2417 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2418 __vector, and it treats it as order-sensitive when mangling
2421 if (next_is_type_qual (di
))
2423 struct demangle_component
**pret
;
2425 pret
= d_cv_qualifiers (di
, &ret
, 0);
2428 if (d_peek_char (di
) == 'F')
2430 /* cv-qualifiers before a function type apply to 'this',
2431 so avoid adding the unqualified function type to
2432 the substitution list. */
2433 *pret
= d_function_type (di
);
2436 *pret
= cplus_demangle_type (di
);
2439 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2440 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2442 /* Move the ref-qualifier outside the cv-qualifiers so that
2443 they are printed in the right order. */
2444 struct demangle_component
*fn
= d_left (*pret
);
2445 d_left (*pret
) = ret
;
2449 if (! d_add_substitution (di
, ret
))
2456 peek
= d_peek_char (di
);
2459 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2460 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2461 case 'o': case 's': case 't':
2462 case 'v': case 'w': case 'x': case 'y': case 'z':
2463 ret
= d_make_builtin_type (di
,
2464 &cplus_demangle_builtin_types
[peek
- 'a']);
2465 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2472 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2473 d_source_name (di
), NULL
);
2477 ret
= d_function_type (di
);
2480 case '0': case '1': case '2': case '3': case '4':
2481 case '5': case '6': case '7': case '8': case '9':
2484 ret
= d_class_enum_type (di
);
2488 ret
= d_array_type (di
);
2492 ret
= d_pointer_to_member_type (di
);
2496 ret
= d_template_param (di
);
2497 if (d_peek_char (di
) == 'I')
2499 /* This may be <template-template-param> <template-args>.
2500 If this is the type for a conversion operator, we can
2501 have a <template-template-param> here only by following
2502 a derivation like this:
2505 -> <template-prefix> <template-args>
2506 -> <prefix> <template-unqualified-name> <template-args>
2507 -> <unqualified-name> <template-unqualified-name> <template-args>
2508 -> <source-name> <template-unqualified-name> <template-args>
2509 -> <source-name> <operator-name> <template-args>
2510 -> <source-name> cv <type> <template-args>
2511 -> <source-name> cv <template-template-param> <template-args> <template-args>
2513 where the <template-args> is followed by another.
2514 Otherwise, we must have a derivation like this:
2517 -> <template-prefix> <template-args>
2518 -> <prefix> <template-unqualified-name> <template-args>
2519 -> <unqualified-name> <template-unqualified-name> <template-args>
2520 -> <source-name> <template-unqualified-name> <template-args>
2521 -> <source-name> <operator-name> <template-args>
2522 -> <source-name> cv <type> <template-args>
2523 -> <source-name> cv <template-param> <template-args>
2525 where we need to leave the <template-args> to be processed
2526 by d_prefix (following the <template-prefix>).
2528 The <template-template-param> part is a substitution
2530 if (! di
->is_conversion
)
2532 if (! d_add_substitution (di
, ret
))
2534 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2535 d_template_args (di
));
2539 struct demangle_component
*args
;
2540 struct d_info_checkpoint checkpoint
;
2542 d_checkpoint (di
, &checkpoint
);
2543 args
= d_template_args (di
);
2544 if (d_peek_char (di
) == 'I')
2546 if (! d_add_substitution (di
, ret
))
2548 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2552 d_backtrack (di
, &checkpoint
);
2558 /* If this is a special substitution, then it is the start of
2559 <class-enum-type>. */
2563 peek_next
= d_peek_next_char (di
);
2564 if (IS_DIGIT (peek_next
)
2566 || IS_UPPER (peek_next
))
2568 ret
= d_substitution (di
, 0);
2569 /* The substituted name may have been a template name and
2570 may be followed by tepmlate args. */
2571 if (d_peek_char (di
) == 'I')
2572 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2573 d_template_args (di
));
2579 ret
= d_class_enum_type (di
);
2580 /* If the substitution was a complete type, then it is not
2581 a new substitution candidate. However, if the
2582 substitution was followed by template arguments, then
2583 the whole thing is a substitution candidate. */
2584 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2592 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2593 cplus_demangle_type (di
), NULL
);
2598 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2599 cplus_demangle_type (di
), NULL
);
2604 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2605 cplus_demangle_type (di
), NULL
);
2610 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2611 cplus_demangle_type (di
), NULL
);
2616 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2617 cplus_demangle_type (di
), NULL
);
2622 ret
= d_source_name (di
);
2623 if (d_peek_char (di
) == 'I')
2624 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2625 d_template_args (di
));
2626 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2627 cplus_demangle_type (di
), ret
);
2633 peek
= d_next_char (di
);
2638 /* decltype (expression) */
2639 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2640 d_expression (di
), NULL
);
2641 if (ret
&& d_next_char (di
) != 'E')
2647 /* Pack expansion. */
2648 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2649 cplus_demangle_type (di
), NULL
);
2655 ret
= d_make_name (di
, "auto", 4);
2658 /* decltype(auto) */
2659 ret
= d_make_name (di
, "decltype(auto)", 14);
2663 /* 32-bit decimal floating point */
2664 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2665 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2669 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2670 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2674 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2675 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2678 /* 16-bit half-precision FP */
2679 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2680 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2684 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2685 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2689 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2690 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2694 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2695 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2699 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2700 ret
= d_make_empty (di
);
2701 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2702 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2703 /* For demangling we don't care about the bits. */
2705 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2706 if (ret
->u
.s_fixed
.length
== NULL
)
2709 peek
= d_next_char (di
);
2710 ret
->u
.s_fixed
.sat
= (peek
== 's');
2714 ret
= d_vector_type (di
);
2719 /* decltype(nullptr) */
2720 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[33]);
2721 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2735 if (! d_add_substitution (di
, ret
))
2742 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2744 static struct demangle_component
**
2745 d_cv_qualifiers (struct d_info
*di
,
2746 struct demangle_component
**pret
, int member_fn
)
2748 struct demangle_component
**pstart
;
2752 peek
= d_peek_char (di
);
2753 while (next_is_type_qual (di
))
2755 enum demangle_component_type t
;
2756 struct demangle_component
*right
= NULL
;
2762 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2763 : DEMANGLE_COMPONENT_RESTRICT
);
2764 di
->expansion
+= sizeof "restrict";
2766 else if (peek
== 'V')
2769 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2770 : DEMANGLE_COMPONENT_VOLATILE
);
2771 di
->expansion
+= sizeof "volatile";
2773 else if (peek
== 'K')
2776 ? DEMANGLE_COMPONENT_CONST_THIS
2777 : DEMANGLE_COMPONENT_CONST
);
2778 di
->expansion
+= sizeof "const";
2782 peek
= d_next_char (di
);
2785 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2786 di
->expansion
+= sizeof "transaction_safe";
2788 else if (peek
== 'o'
2791 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2792 di
->expansion
+= sizeof "noexcept";
2795 right
= d_expression (di
);
2798 if (! d_check_char (di
, 'E'))
2802 else if (peek
== 'w')
2804 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2805 di
->expansion
+= sizeof "throw";
2806 right
= d_parmlist (di
);
2809 if (! d_check_char (di
, 'E'))
2816 *pret
= d_make_comp (di
, t
, NULL
, right
);
2819 pret
= &d_left (*pret
);
2821 peek
= d_peek_char (di
);
2824 if (!member_fn
&& peek
== 'F')
2826 while (pstart
!= pret
)
2828 switch ((*pstart
)->type
)
2830 case DEMANGLE_COMPONENT_RESTRICT
:
2831 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2833 case DEMANGLE_COMPONENT_VOLATILE
:
2834 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2836 case DEMANGLE_COMPONENT_CONST
:
2837 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2842 pstart
= &d_left (*pstart
);
2849 /* <ref-qualifier> ::= R
2852 static struct demangle_component
*
2853 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2855 struct demangle_component
*ret
= sub
;
2858 peek
= d_peek_char (di
);
2859 if (peek
== 'R' || peek
== 'O')
2861 enum demangle_component_type t
;
2864 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2865 di
->expansion
+= sizeof "&";
2869 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2870 di
->expansion
+= sizeof "&&";
2874 ret
= d_make_comp (di
, t
, ret
, NULL
);
2880 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2882 static struct demangle_component
*
2883 d_function_type (struct d_info
*di
)
2885 struct demangle_component
*ret
= NULL
;
2887 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2889 if (di
->recursion_level
> DEMANGLE_RECURSION_LIMIT
)
2890 /* FIXME: There ought to be a way to report
2891 that the recursion limit has been reached. */
2894 di
->recursion_level
++;
2897 if (d_check_char (di
, 'F'))
2899 if (d_peek_char (di
) == 'Y')
2901 /* Function has C linkage. We don't print this information.
2902 FIXME: We should print it in verbose mode. */
2905 ret
= d_bare_function_type (di
, 1);
2906 ret
= d_ref_qualifier (di
, ret
);
2908 if (! d_check_char (di
, 'E'))
2912 if ((di
->options
& DMGL_NO_RECURSE_LIMIT
) == 0)
2913 di
->recursion_level
--;
2919 static struct demangle_component
*
2920 d_parmlist (struct d_info
*di
)
2922 struct demangle_component
*tl
;
2923 struct demangle_component
**ptl
;
2929 struct demangle_component
*type
;
2931 char peek
= d_peek_char (di
);
2932 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2934 if ((peek
== 'R' || peek
== 'O')
2935 && d_peek_next_char (di
) == 'E')
2936 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2938 type
= cplus_demangle_type (di
);
2941 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2944 ptl
= &d_right (*ptl
);
2947 /* There should be at least one parameter type besides the optional
2948 return type. A function which takes no arguments will have a
2949 single parameter type void. */
2953 /* If we have a single parameter type void, omit it. */
2954 if (d_right (tl
) == NULL
2955 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2956 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2958 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2965 /* <bare-function-type> ::= [J]<type>+ */
2967 static struct demangle_component
*
2968 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2970 struct demangle_component
*return_type
;
2971 struct demangle_component
*tl
;
2974 /* Detect special qualifier indicating that the first argument
2975 is the return type. */
2976 peek
= d_peek_char (di
);
2980 has_return_type
= 1;
2983 if (has_return_type
)
2985 return_type
= cplus_demangle_type (di
);
2986 if (return_type
== NULL
)
2992 tl
= d_parmlist (di
);
2996 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
3000 /* <class-enum-type> ::= <name> */
3002 static struct demangle_component
*
3003 d_class_enum_type (struct d_info
*di
)
3008 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
3009 ::= A [<(dimension) expression>] _ <(element) type>
3012 static struct demangle_component
*
3013 d_array_type (struct d_info
*di
)
3016 struct demangle_component
*dim
;
3018 if (! d_check_char (di
, 'A'))
3021 peek
= d_peek_char (di
);
3024 else if (IS_DIGIT (peek
))
3032 peek
= d_peek_char (di
);
3034 while (IS_DIGIT (peek
));
3035 dim
= d_make_name (di
, s
, d_str (di
) - s
);
3041 dim
= d_expression (di
);
3046 if (! d_check_char (di
, '_'))
3049 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
3050 cplus_demangle_type (di
));
3053 /* <vector-type> ::= Dv <number> _ <type>
3054 ::= Dv _ <expression> _ <type> */
3056 static struct demangle_component
*
3057 d_vector_type (struct d_info
*di
)
3060 struct demangle_component
*dim
;
3062 peek
= d_peek_char (di
);
3066 dim
= d_expression (di
);
3069 dim
= d_number_component (di
);
3074 if (! d_check_char (di
, '_'))
3077 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
3078 cplus_demangle_type (di
));
3081 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3083 static struct demangle_component
*
3084 d_pointer_to_member_type (struct d_info
*di
)
3086 struct demangle_component
*cl
;
3087 struct demangle_component
*mem
;
3089 if (! d_check_char (di
, 'M'))
3092 cl
= cplus_demangle_type (di
);
3096 /* The ABI says, "The type of a non-static member function is considered
3097 to be different, for the purposes of substitution, from the type of a
3098 namespace-scope or static member function whose type appears
3099 similar. The types of two non-static member functions are considered
3100 to be different, for the purposes of substitution, if the functions
3101 are members of different classes. In other words, for the purposes of
3102 substitution, the class of which the function is a member is
3103 considered part of the type of function."
3105 For a pointer to member function, this call to cplus_demangle_type
3106 will end up adding a (possibly qualified) non-member function type to
3107 the substitution table, which is not correct; however, the member
3108 function type will never be used in a substitution, so putting the
3109 wrong type in the substitution table is harmless. */
3111 mem
= cplus_demangle_type (di
);
3115 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3118 /* <non-negative number> _ */
3121 d_compact_number (struct d_info
*di
)
3124 if (d_peek_char (di
) == '_')
3126 else if (d_peek_char (di
) == 'n')
3129 num
= d_number (di
) + 1;
3131 if (num
< 0 || ! d_check_char (di
, '_'))
3136 /* <template-param> ::= T_
3137 ::= T <(parameter-2 non-negative) number> _
3140 static struct demangle_component
*
3141 d_template_param (struct d_info
*di
)
3145 if (! d_check_char (di
, 'T'))
3148 param
= d_compact_number (di
);
3152 return d_make_template_param (di
, param
);
3155 /* <template-args> ::= I <template-arg>+ E */
3157 static struct demangle_component
*
3158 d_template_args (struct d_info
*di
)
3160 if (d_peek_char (di
) != 'I'
3161 && d_peek_char (di
) != 'J')
3165 return d_template_args_1 (di
);
3168 /* <template-arg>* E */
3170 static struct demangle_component
*
3171 d_template_args_1 (struct d_info
*di
)
3173 struct demangle_component
*hold_last_name
;
3174 struct demangle_component
*al
;
3175 struct demangle_component
**pal
;
3177 /* Preserve the last name we saw--don't let the template arguments
3178 clobber it, as that would give us the wrong name for a subsequent
3179 constructor or destructor. */
3180 hold_last_name
= di
->last_name
;
3182 if (d_peek_char (di
) == 'E')
3184 /* An argument pack can be empty. */
3186 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3193 struct demangle_component
*a
;
3195 a
= d_template_arg (di
);
3199 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3202 pal
= &d_right (*pal
);
3204 if (d_peek_char (di
) == 'E')
3211 di
->last_name
= hold_last_name
;
3216 /* <template-arg> ::= <type>
3217 ::= X <expression> E
3221 static struct demangle_component
*
3222 d_template_arg (struct d_info
*di
)
3224 struct demangle_component
*ret
;
3226 switch (d_peek_char (di
))
3230 ret
= d_expression (di
);
3231 if (! d_check_char (di
, 'E'))
3236 return d_expr_primary (di
);
3240 /* An argument pack. */
3241 return d_template_args (di
);
3244 return cplus_demangle_type (di
);
3248 /* Parse a sequence of expressions until we hit the terminator
3251 static struct demangle_component
*
3252 d_exprlist (struct d_info
*di
, char terminator
)
3254 struct demangle_component
*list
= NULL
;
3255 struct demangle_component
**p
= &list
;
3257 if (d_peek_char (di
) == terminator
)
3260 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3265 struct demangle_component
*arg
= d_expression (di
);
3269 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3274 if (d_peek_char (di
) == terminator
)
3284 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3285 dynamic_cast, static_cast or reinterpret_cast. */
3288 op_is_new_cast (struct demangle_component
*op
)
3290 const char *code
= op
->u
.s_operator
.op
->code
;
3291 return (code
[1] == 'c'
3292 && (code
[0] == 's' || code
[0] == 'd'
3293 || code
[0] == 'c' || code
[0] == 'r'));
3296 /* <unresolved-name> ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
3297 ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
3298 # T::N::x /decltype(p)::N::x
3299 ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
3300 # A::x, N::y, A<T>::z; "gs" means leading "::"
3301 ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
3303 "gs" is handled elsewhere, as a unary operator. */
3305 static struct demangle_component
*
3306 d_unresolved_name (struct d_info
*di
)
3308 struct demangle_component
*type
;
3309 struct demangle_component
*name
;
3312 /* Consume the "sr". */
3315 peek
= d_peek_char (di
);
3316 if (di
->unresolved_name_state
3323 /* The third production is ambiguous with the old unresolved-name syntax
3324 of <type> <base-unresolved-name>; in the old mangling, A::x was mangled
3325 as sr1A1x, now sr1AE1x. So we first try to demangle using the new
3326 mangling, then with the old if that fails. */
3327 di
->unresolved_name_state
= -1;
3328 type
= d_prefix (di
, 0);
3329 if (d_peek_char (di
) == 'E')
3333 type
= cplus_demangle_type (di
);
3334 name
= d_unqualified_name (di
);
3335 if (d_peek_char (di
) == 'I')
3336 name
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3337 d_template_args (di
));
3338 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3341 /* <expression> ::= <(unary) operator-name> <expression>
3342 ::= <(binary) operator-name> <expression> <expression>
3343 ::= <(trinary) operator-name> <expression> <expression> <expression>
3344 ::= cl <expression>+ E
3346 ::= <template-param>
3347 ::= <unresolved-name>
3350 <braced-expression> ::= <expression>
3351 ::= di <field source-name> <braced-expression> # .name = expr
3352 ::= dx <index expression> <braced-expression> # [expr] = expr
3353 ::= dX <range begin expression> <range end expression> <braced-expression>
3354 # [expr ... expr] = expr
3357 static struct demangle_component
*
3358 d_expression_1 (struct d_info
*di
)
3362 peek
= d_peek_char (di
);
3364 return d_expr_primary (di
);
3365 else if (peek
== 'T')
3366 return d_template_param (di
);
3367 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3368 return d_unresolved_name (di
);
3369 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3372 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3373 d_expression_1 (di
), NULL
);
3375 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3377 /* Function parameter used in a late-specified return type. */
3380 if (d_peek_char (di
) == 'T')
3382 /* 'this' parameter. */
3388 index
= d_compact_number (di
);
3389 if (index
== INT_MAX
|| index
== -1)
3393 return d_make_function_param (di
, index
);
3395 else if (IS_DIGIT (peek
)
3396 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3398 /* We can get an unqualified name as an expression in the case of
3399 a dependent function call, i.e. decltype(f(t)). */
3400 struct demangle_component
*name
;
3403 /* operator-function-id, i.e. operator+(t). */
3406 name
= d_unqualified_name (di
);
3409 if (d_peek_char (di
) == 'I')
3410 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3411 d_template_args (di
));
3415 else if ((peek
== 'i' || peek
== 't')
3416 && d_peek_next_char (di
) == 'l')
3418 /* Brace-enclosed initializer list, untyped or typed. */
3419 struct demangle_component
*type
= NULL
;
3422 type
= cplus_demangle_type (di
);
3423 if (!d_peek_char (di
) || !d_peek_next_char (di
))
3425 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3426 type
, d_exprlist (di
, 'E'));
3430 struct demangle_component
*op
;
3431 const char *code
= NULL
;
3434 op
= d_operator_name (di
);
3438 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3440 code
= op
->u
.s_operator
.op
->code
;
3441 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3442 if (strcmp (code
, "st") == 0)
3443 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3444 cplus_demangle_type (di
));
3451 case DEMANGLE_COMPONENT_OPERATOR
:
3452 args
= op
->u
.s_operator
.op
->args
;
3454 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3455 args
= op
->u
.s_extended_operator
.args
;
3457 case DEMANGLE_COMPONENT_CAST
:
3465 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3469 struct demangle_component
*operand
;
3472 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3473 && code
[1] == code
[0])
3474 /* pp_ and mm_ are the prefix variants. */
3475 suffix
= !d_check_char (di
, '_');
3477 if (op
->type
== DEMANGLE_COMPONENT_CAST
3478 && d_check_char (di
, '_'))
3479 operand
= d_exprlist (di
, 'E');
3480 else if (code
&& !strcmp (code
, "sP"))
3481 operand
= d_template_args_1 (di
);
3483 operand
= d_expression_1 (di
);
3486 /* Indicate the suffix variant for d_print_comp. */
3487 operand
= d_make_comp (di
, DEMANGLE_COMPONENT_BINARY_ARGS
,
3490 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
, operand
);
3494 struct demangle_component
*left
;
3495 struct demangle_component
*right
;
3499 if (op_is_new_cast (op
))
3500 left
= cplus_demangle_type (di
);
3501 else if (code
[0] == 'f')
3502 /* fold-expression. */
3503 left
= d_operator_name (di
);
3504 else if (!strcmp (code
, "di"))
3505 left
= d_unqualified_name (di
);
3507 left
= d_expression_1 (di
);
3508 if (!strcmp (code
, "cl"))
3509 right
= d_exprlist (di
, 'E');
3510 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3512 peek
= d_peek_char (di
);
3513 /* These codes start a qualified name. */
3514 if ((peek
== 'g' && d_peek_next_char (di
) == 's')
3515 || (peek
== 's' && d_peek_next_char (di
) == 'r'))
3516 right
= d_expression_1 (di
);
3519 /* Otherwise it's an unqualified name. We use
3520 d_unqualified_name rather than d_expression_1 here for
3521 old mangled names that didn't add 'on' before operator
3523 right
= d_unqualified_name (di
);
3524 if (d_peek_char (di
) == 'I')
3525 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3526 right
, d_template_args (di
));
3530 right
= d_expression_1 (di
);
3532 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3534 DEMANGLE_COMPONENT_BINARY_ARGS
,
3539 struct demangle_component
*first
;
3540 struct demangle_component
*second
;
3541 struct demangle_component
*third
;
3545 else if (!strcmp (code
, "qu")
3546 || !strcmp (code
, "dX"))
3548 /* ?: expression. */
3549 first
= d_expression_1 (di
);
3550 second
= d_expression_1 (di
);
3551 third
= d_expression_1 (di
);
3555 else if (code
[0] == 'f')
3557 /* fold-expression. */
3558 first
= d_operator_name (di
);
3559 second
= d_expression_1 (di
);
3560 third
= d_expression_1 (di
);
3564 else if (code
[0] == 'n')
3566 /* new-expression. */
3567 if (code
[1] != 'w' && code
[1] != 'a')
3569 first
= d_exprlist (di
, '_');
3570 second
= cplus_demangle_type (di
);
3571 if (d_peek_char (di
) == 'E')
3576 else if (d_peek_char (di
) == 'p'
3577 && d_peek_next_char (di
) == 'i')
3579 /* Parenthesized initializer. */
3581 third
= d_exprlist (di
, 'E');
3583 else if (d_peek_char (di
) == 'i'
3584 && d_peek_next_char (di
) == 'l')
3585 /* initializer-list. */
3586 third
= d_expression_1 (di
);
3592 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3594 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3597 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3606 static struct demangle_component
*
3607 d_expression (struct d_info
*di
)
3609 struct demangle_component
*ret
;
3610 int was_expression
= di
->is_expression
;
3612 di
->is_expression
= 1;
3613 ret
= d_expression_1 (di
);
3614 di
->is_expression
= was_expression
;
3618 /* <expr-primary> ::= L <type> <(value) number> E
3619 ::= L <type> <(value) float> E
3620 ::= L <mangled-name> E
3623 static struct demangle_component
*
3624 d_expr_primary (struct d_info
*di
)
3626 struct demangle_component
*ret
;
3628 if (! d_check_char (di
, 'L'))
3630 if (d_peek_char (di
) == '_'
3631 /* Workaround for G++ bug; see comment in write_template_arg. */
3632 || d_peek_char (di
) == 'Z')
3633 ret
= cplus_demangle_mangled_name (di
, 0);
3636 struct demangle_component
*type
;
3637 enum demangle_component_type t
;
3640 type
= cplus_demangle_type (di
);
3644 /* If we have a type we know how to print, we aren't going to
3645 print the type name itself. */
3646 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3647 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3648 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3650 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3651 && strcmp (type
->u
.s_builtin
.type
->name
,
3652 cplus_demangle_builtin_types
[33].name
) == 0)
3654 if (d_peek_char (di
) == 'E')
3661 /* Rather than try to interpret the literal value, we just
3662 collect it as a string. Note that it's possible to have a
3663 floating point literal here. The ABI specifies that the
3664 format of such literals is machine independent. That's fine,
3665 but what's not fine is that versions of g++ up to 3.2 with
3666 -fabi-version=1 used upper case letters in the hex constant,
3667 and dumped out gcc's internal representation. That makes it
3668 hard to tell where the constant ends, and hard to dump the
3669 constant in any readable form anyhow. We don't attempt to
3670 handle these cases. */
3672 t
= DEMANGLE_COMPONENT_LITERAL
;
3673 if (d_peek_char (di
) == 'n')
3675 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3679 while (d_peek_char (di
) != 'E')
3681 if (d_peek_char (di
) == '\0')
3685 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3687 if (! d_check_char (di
, 'E'))
3692 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3693 ::= Z <(function) encoding> E s [<discriminator>]
3694 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3697 static struct demangle_component
*
3698 d_local_name (struct d_info
*di
)
3700 struct demangle_component
*function
;
3701 struct demangle_component
*name
;
3703 if (! d_check_char (di
, 'Z'))
3706 function
= d_encoding (di
, 0);
3710 if (! d_check_char (di
, 'E'))
3713 if (d_peek_char (di
) == 's')
3716 if (! d_discriminator (di
))
3718 name
= d_make_name (di
, "string literal", sizeof "string literal" - 1);
3724 if (d_peek_char (di
) == 'd')
3726 /* Default argument scope: d <number> _. */
3728 num
= d_compact_number (di
);
3736 /* Lambdas and unnamed types have internal discriminators
3737 and are not functions. */
3738 && name
->type
!= DEMANGLE_COMPONENT_LAMBDA
3739 && name
->type
!= DEMANGLE_COMPONENT_UNNAMED_TYPE
)
3741 /* Read and ignore an optional discriminator. */
3742 if (! d_discriminator (di
))
3747 name
= d_make_default_arg (di
, num
, name
);
3750 /* Elide the return type of the containing function so as to not
3751 confuse the user thinking it is the return type of whatever local
3752 function we might be containing. */
3753 if (function
->type
== DEMANGLE_COMPONENT_TYPED_NAME
3754 && d_right (function
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3755 d_left (d_right (function
)) = NULL
;
3757 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3760 /* <discriminator> ::= _ <number> # when number < 10
3761 ::= __ <number> _ # when number >= 10
3763 <discriminator> ::= _ <number> # when number >=10
3764 is also accepted to support gcc versions that wrongly mangled that way.
3766 We demangle the discriminator, but we don't print it out. FIXME:
3767 We should print it out in verbose mode. */
3770 d_discriminator (struct d_info
*di
)
3772 int discrim
, num_underscores
= 1;
3774 if (d_peek_char (di
) != '_')
3777 if (d_peek_char (di
) == '_')
3783 discrim
= d_number (di
);
3786 if (num_underscores
> 1 && discrim
>= 10)
3788 if (d_peek_char (di
) == '_')
3797 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3799 static struct demangle_component
*
3800 d_lambda (struct d_info
*di
)
3802 struct demangle_component
*tl
;
3803 struct demangle_component
*ret
;
3806 if (! d_check_char (di
, 'U'))
3808 if (! d_check_char (di
, 'l'))
3811 tl
= d_parmlist (di
);
3815 if (! d_check_char (di
, 'E'))
3818 num
= d_compact_number (di
);
3822 ret
= d_make_empty (di
);
3825 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3826 ret
->u
.s_unary_num
.sub
= tl
;
3827 ret
->u
.s_unary_num
.num
= num
;
3833 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3835 static struct demangle_component
*
3836 d_unnamed_type (struct d_info
*di
)
3838 struct demangle_component
*ret
;
3841 if (! d_check_char (di
, 'U'))
3843 if (! d_check_char (di
, 't'))
3846 num
= d_compact_number (di
);
3850 ret
= d_make_empty (di
);
3853 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3854 ret
->u
.s_number
.number
= num
;
3857 if (! d_add_substitution (di
, ret
))
3863 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3866 static struct demangle_component
*
3867 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3869 const char *suffix
= d_str (di
);
3870 const char *pend
= suffix
;
3871 struct demangle_component
*n
;
3873 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3876 while (IS_LOWER (*pend
) || *pend
== '_')
3879 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3882 while (IS_DIGIT (*pend
))
3885 d_advance (di
, pend
- suffix
);
3886 n
= d_make_name (di
, suffix
, pend
- suffix
);
3887 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3890 /* Add a new substitution. */
3893 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3897 if (di
->next_sub
>= di
->num_subs
)
3899 di
->subs
[di
->next_sub
] = dc
;
3904 /* <substitution> ::= S <seq-id> _
3914 If PREFIX is non-zero, then this type is being used as a prefix in
3915 a qualified name. In this case, for the standard substitutions, we
3916 need to check whether we are being used as a prefix for a
3917 constructor or destructor, and return a full template name.
3918 Otherwise we will get something like std::iostream::~iostream()
3919 which does not correspond particularly well to any function which
3920 actually appears in the source.
3923 static const struct d_standard_sub_info standard_subs
[] =
3928 { 'a', NL ("std::allocator"),
3929 NL ("std::allocator"),
3931 { 'b', NL ("std::basic_string"),
3932 NL ("std::basic_string"),
3933 NL ("basic_string") },
3934 { 's', NL ("std::string"),
3935 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3936 NL ("basic_string") },
3937 { 'i', NL ("std::istream"),
3938 NL ("std::basic_istream<char, std::char_traits<char> >"),
3939 NL ("basic_istream") },
3940 { 'o', NL ("std::ostream"),
3941 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3942 NL ("basic_ostream") },
3943 { 'd', NL ("std::iostream"),
3944 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3945 NL ("basic_iostream") }
3948 static struct demangle_component
*
3949 d_substitution (struct d_info
*di
, int prefix
)
3953 if (! d_check_char (di
, 'S'))
3956 c
= d_next_char (di
);
3957 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3966 unsigned int new_id
;
3969 new_id
= id
* 36 + c
- '0';
3970 else if (IS_UPPER (c
))
3971 new_id
= id
* 36 + c
- 'A' + 10;
3977 c
= d_next_char (di
);
3984 if (id
>= (unsigned int) di
->next_sub
)
3987 return di
->subs
[id
];
3992 const struct d_standard_sub_info
*p
;
3993 const struct d_standard_sub_info
*pend
;
3995 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3996 if (! verbose
&& prefix
)
4000 peek
= d_peek_char (di
);
4001 if (peek
== 'C' || peek
== 'D')
4005 pend
= (&standard_subs
[0]
4006 + sizeof standard_subs
/ sizeof standard_subs
[0]);
4007 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
4013 struct demangle_component
*dc
;
4015 if (p
->set_last_name
!= NULL
)
4016 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
4017 p
->set_last_name_len
);
4020 s
= p
->full_expansion
;
4025 s
= p
->simple_expansion
;
4026 len
= p
->simple_len
;
4028 di
->expansion
+= len
;
4029 dc
= d_make_sub (di
, s
, len
);
4030 if (d_peek_char (di
) == 'B')
4032 /* If there are ABI tags on the abbreviation, it becomes
4033 a substitution candidate. */
4034 dc
= d_abi_tags (di
, dc
);
4035 if (! d_add_substitution (di
, dc
))
4047 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
4049 checkpoint
->n
= di
->n
;
4050 checkpoint
->next_comp
= di
->next_comp
;
4051 checkpoint
->next_sub
= di
->next_sub
;
4052 checkpoint
->expansion
= di
->expansion
;
4056 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
4058 di
->n
= checkpoint
->n
;
4059 di
->next_comp
= checkpoint
->next_comp
;
4060 di
->next_sub
= checkpoint
->next_sub
;
4061 di
->expansion
= checkpoint
->expansion
;
4064 /* Initialize a growable string. */
4067 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
4072 dgs
->allocation_failure
= 0;
4075 d_growable_string_resize (dgs
, estimate
);
4078 /* Grow a growable string to a given size. */
4081 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
4086 if (dgs
->allocation_failure
)
4089 /* Start allocation at two bytes to avoid any possibility of confusion
4090 with the special value of 1 used as a return in *palc to indicate
4091 allocation failures. */
4092 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
4093 while (newalc
< need
)
4096 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
4103 dgs
->allocation_failure
= 1;
4110 /* Append a buffer to a growable string. */
4113 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
4114 const char *s
, size_t l
)
4118 need
= dgs
->len
+ l
+ 1;
4119 if (need
> dgs
->alc
)
4120 d_growable_string_resize (dgs
, need
);
4122 if (dgs
->allocation_failure
)
4125 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
4126 dgs
->buf
[dgs
->len
+ l
] = '\0';
4130 /* Bridge growable strings to the callback mechanism. */
4133 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
4135 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
4137 d_growable_string_append_buffer (dgs
, s
, l
);
4140 /* Walk the tree, counting the number of templates encountered, and
4141 the number of times a scope might be saved. These counts will be
4142 used to allocate data structures for d_print_comp, so the logic
4143 here must mirror the logic d_print_comp will use. It is not
4144 important that the resulting numbers are exact, so long as they
4145 are larger than the actual numbers encountered. */
4148 d_count_templates_scopes (struct d_print_info
*dpi
,
4149 struct demangle_component
*dc
)
4151 if (dc
== NULL
|| dc
->d_counting
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
4158 case DEMANGLE_COMPONENT_NAME
:
4159 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4160 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4161 case DEMANGLE_COMPONENT_SUB_STD
:
4162 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4163 case DEMANGLE_COMPONENT_OPERATOR
:
4164 case DEMANGLE_COMPONENT_CHARACTER
:
4165 case DEMANGLE_COMPONENT_NUMBER
:
4166 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4169 case DEMANGLE_COMPONENT_TEMPLATE
:
4170 dpi
->num_copy_templates
++;
4171 goto recurse_left_right
;
4173 case DEMANGLE_COMPONENT_REFERENCE
:
4174 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4175 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4176 dpi
->num_saved_scopes
++;
4177 goto recurse_left_right
;
4179 case DEMANGLE_COMPONENT_QUAL_NAME
:
4180 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4181 case DEMANGLE_COMPONENT_TYPED_NAME
:
4182 case DEMANGLE_COMPONENT_VTABLE
:
4183 case DEMANGLE_COMPONENT_VTT
:
4184 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4185 case DEMANGLE_COMPONENT_TYPEINFO
:
4186 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4187 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4188 case DEMANGLE_COMPONENT_THUNK
:
4189 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4190 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4191 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4192 case DEMANGLE_COMPONENT_GUARD
:
4193 case DEMANGLE_COMPONENT_TLS_INIT
:
4194 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4195 case DEMANGLE_COMPONENT_REFTEMP
:
4196 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4197 case DEMANGLE_COMPONENT_RESTRICT
:
4198 case DEMANGLE_COMPONENT_VOLATILE
:
4199 case DEMANGLE_COMPONENT_CONST
:
4200 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4201 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4202 case DEMANGLE_COMPONENT_CONST_THIS
:
4203 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4204 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4205 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4206 case DEMANGLE_COMPONENT_NOEXCEPT
:
4207 case DEMANGLE_COMPONENT_THROW_SPEC
:
4208 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4209 case DEMANGLE_COMPONENT_POINTER
:
4210 case DEMANGLE_COMPONENT_COMPLEX
:
4211 case DEMANGLE_COMPONENT_IMAGINARY
:
4212 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4213 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4214 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4215 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4216 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4217 case DEMANGLE_COMPONENT_ARGLIST
:
4218 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4219 case DEMANGLE_COMPONENT_TPARM_OBJ
:
4220 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4221 case DEMANGLE_COMPONENT_CAST
:
4222 case DEMANGLE_COMPONENT_CONVERSION
:
4223 case DEMANGLE_COMPONENT_NULLARY
:
4224 case DEMANGLE_COMPONENT_UNARY
:
4225 case DEMANGLE_COMPONENT_BINARY
:
4226 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4227 case DEMANGLE_COMPONENT_TRINARY
:
4228 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4229 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4230 case DEMANGLE_COMPONENT_LITERAL
:
4231 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4232 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4233 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4234 case DEMANGLE_COMPONENT_DECLTYPE
:
4235 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4236 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4237 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4238 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4239 case DEMANGLE_COMPONENT_CLONE
:
4241 /* PR 89394 - Check for too much recursion. */
4242 if (dpi
->recursion
> DEMANGLE_RECURSION_LIMIT
)
4243 /* FIXME: There ought to be a way to report to the
4244 user that the recursion limit has been reached. */
4248 d_count_templates_scopes (dpi
, d_left (dc
));
4249 d_count_templates_scopes (dpi
, d_right (dc
));
4253 case DEMANGLE_COMPONENT_CTOR
:
4254 d_count_templates_scopes (dpi
, dc
->u
.s_ctor
.name
);
4257 case DEMANGLE_COMPONENT_DTOR
:
4258 d_count_templates_scopes (dpi
, dc
->u
.s_dtor
.name
);
4261 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4262 d_count_templates_scopes (dpi
, dc
->u
.s_extended_operator
.name
);
4265 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4266 d_count_templates_scopes (dpi
, dc
->u
.s_fixed
.length
);
4269 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4270 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4271 d_count_templates_scopes (dpi
, d_left (dc
));
4274 case DEMANGLE_COMPONENT_LAMBDA
:
4275 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4276 d_count_templates_scopes (dpi
, dc
->u
.s_unary_num
.sub
);
4281 /* Initialize a print information structure. */
4284 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4285 void *opaque
, struct demangle_component
*dc
)
4288 dpi
->last_char
= '\0';
4289 dpi
->templates
= NULL
;
4290 dpi
->modifiers
= NULL
;
4291 dpi
->pack_index
= 0;
4292 dpi
->flush_count
= 0;
4294 dpi
->callback
= callback
;
4295 dpi
->opaque
= opaque
;
4297 dpi
->demangle_failure
= 0;
4299 dpi
->is_lambda_arg
= 0;
4301 dpi
->component_stack
= NULL
;
4303 dpi
->saved_scopes
= NULL
;
4304 dpi
->next_saved_scope
= 0;
4305 dpi
->num_saved_scopes
= 0;
4307 dpi
->copy_templates
= NULL
;
4308 dpi
->next_copy_template
= 0;
4309 dpi
->num_copy_templates
= 0;
4311 d_count_templates_scopes (dpi
, dc
);
4312 /* If we did not reach the recursion limit, then reset the
4313 current recursion value back to 0, so that we can print
4315 if (dpi
->recursion
< DEMANGLE_RECURSION_LIMIT
)
4317 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4319 dpi
->current_template
= NULL
;
4322 /* Indicate that an error occurred during printing, and test for error. */
4325 d_print_error (struct d_print_info
*dpi
)
4327 dpi
->demangle_failure
= 1;
4331 d_print_saw_error (struct d_print_info
*dpi
)
4333 return dpi
->demangle_failure
!= 0;
4336 /* Flush buffered characters to the callback. */
4339 d_print_flush (struct d_print_info
*dpi
)
4341 dpi
->buf
[dpi
->len
] = '\0';
4342 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4347 /* Append characters and buffers for printing. */
4350 d_append_char (struct d_print_info
*dpi
, char c
)
4352 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4353 d_print_flush (dpi
);
4355 dpi
->buf
[dpi
->len
++] = c
;
4360 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4364 for (i
= 0; i
< l
; i
++)
4365 d_append_char (dpi
, s
[i
]);
4369 d_append_string (struct d_print_info
*dpi
, const char *s
)
4371 d_append_buffer (dpi
, s
, strlen (s
));
4375 d_append_num (struct d_print_info
*dpi
, int l
)
4378 sprintf (buf
,"%d", l
);
4379 d_append_string (dpi
, buf
);
4383 d_last_char (struct d_print_info
*dpi
)
4385 return dpi
->last_char
;
4388 /* Turn components into a human readable string. OPTIONS is the
4389 options bits passed to the demangler. DC is the tree to print.
4390 CALLBACK is a function to call to flush demangled string segments
4391 as they fill the intermediate buffer, and OPAQUE is a generalized
4392 callback argument. On success, this returns 1. On failure,
4393 it returns 0, indicating a bad parse. It does not use heap
4394 memory to build an output string, so cannot encounter memory
4395 allocation failure. */
4397 CP_STATIC_IF_GLIBCPP_V3
4399 cplus_demangle_print_callback (int options
,
4400 struct demangle_component
*dc
,
4401 demangle_callbackref callback
, void *opaque
)
4403 struct d_print_info dpi
;
4405 d_print_init (&dpi
, callback
, opaque
, dc
);
4408 #ifdef CP_DYNAMIC_ARRAYS
4409 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4410 and flagged as errors by Address Sanitizer. */
4411 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4412 ? dpi
.num_saved_scopes
: 1];
4413 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4414 ? dpi
.num_copy_templates
: 1];
4416 dpi
.saved_scopes
= scopes
;
4417 dpi
.copy_templates
= temps
;
4419 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4420 * sizeof (*dpi
.saved_scopes
));
4421 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4422 * sizeof (*dpi
.copy_templates
));
4425 d_print_comp (&dpi
, options
, dc
);
4428 d_print_flush (&dpi
);
4430 return ! d_print_saw_error (&dpi
);
4433 /* Turn components into a human readable string. OPTIONS is the
4434 options bits passed to the demangler. DC is the tree to print.
4435 ESTIMATE is a guess at the length of the result. This returns a
4436 string allocated by malloc, or NULL on error. On success, this
4437 sets *PALC to the size of the allocated buffer. On failure, this
4438 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4441 CP_STATIC_IF_GLIBCPP_V3
4443 cplus_demangle_print (int options
, struct demangle_component
*dc
,
4444 int estimate
, size_t *palc
)
4446 struct d_growable_string dgs
;
4448 d_growable_string_init (&dgs
, estimate
);
4450 if (! cplus_demangle_print_callback (options
, dc
,
4451 d_growable_string_callback_adapter
,
4459 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4463 /* Returns the I'th element of the template arglist ARGS, or NULL on
4464 failure. If I is negative, return the entire arglist. */
4466 static struct demangle_component
*
4467 d_index_template_argument (struct demangle_component
*args
, int i
)
4469 struct demangle_component
*a
;
4472 /* Print the whole argument pack. */
4479 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4485 if (i
!= 0 || a
== NULL
)
4491 /* Returns the template argument from the current context indicated by DC,
4492 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4494 static struct demangle_component
*
4495 d_lookup_template_argument (struct d_print_info
*dpi
,
4496 const struct demangle_component
*dc
)
4498 if (dpi
->templates
== NULL
)
4500 d_print_error (dpi
);
4504 return d_index_template_argument
4505 (d_right (dpi
->templates
->template_decl
),
4506 dc
->u
.s_number
.number
);
4509 /* Returns a template argument pack used in DC (any will do), or NULL. */
4511 static struct demangle_component
*
4512 d_find_pack (struct d_print_info
*dpi
,
4513 const struct demangle_component
*dc
)
4515 struct demangle_component
*a
;
4521 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4522 a
= d_lookup_template_argument (dpi
, dc
);
4523 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4527 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4530 case DEMANGLE_COMPONENT_LAMBDA
:
4531 case DEMANGLE_COMPONENT_NAME
:
4532 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4533 case DEMANGLE_COMPONENT_OPERATOR
:
4534 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4535 case DEMANGLE_COMPONENT_SUB_STD
:
4536 case DEMANGLE_COMPONENT_CHARACTER
:
4537 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4538 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4539 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4540 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4541 case DEMANGLE_COMPONENT_NUMBER
:
4544 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4545 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4546 case DEMANGLE_COMPONENT_CTOR
:
4547 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4548 case DEMANGLE_COMPONENT_DTOR
:
4549 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4552 a
= d_find_pack (dpi
, d_left (dc
));
4555 return d_find_pack (dpi
, d_right (dc
));
4559 /* Returns the length of the template argument pack DC. */
4562 d_pack_length (const struct demangle_component
*dc
)
4565 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4566 && d_left (dc
) != NULL
)
4574 /* Returns the number of template args in DC, expanding any pack expansions
4578 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4581 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4584 struct demangle_component
*elt
= d_left (dc
);
4587 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4589 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4590 count
+= d_pack_length (a
);
4598 /* DC is a component of a mangled expression. Print it, wrapped in parens
4602 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4603 struct demangle_component
*dc
)
4606 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4607 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4608 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4609 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4612 d_append_char (dpi
, '(');
4613 d_print_comp (dpi
, options
, dc
);
4615 d_append_char (dpi
, ')');
4618 /* Save the current scope. */
4621 d_save_scope (struct d_print_info
*dpi
,
4622 const struct demangle_component
*container
)
4624 struct d_saved_scope
*scope
;
4625 struct d_print_template
*src
, **link
;
4627 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4629 d_print_error (dpi
);
4632 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4633 dpi
->next_saved_scope
++;
4635 scope
->container
= container
;
4636 link
= &scope
->templates
;
4638 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4640 struct d_print_template
*dst
;
4642 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4644 d_print_error (dpi
);
4647 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4648 dpi
->next_copy_template
++;
4650 dst
->template_decl
= src
->template_decl
;
4658 /* Attempt to locate a previously saved scope. Returns NULL if no
4659 corresponding saved scope was found. */
4661 static struct d_saved_scope
*
4662 d_get_saved_scope (struct d_print_info
*dpi
,
4663 const struct demangle_component
*container
)
4667 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4668 if (dpi
->saved_scopes
[i
].container
== container
)
4669 return &dpi
->saved_scopes
[i
];
4674 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4678 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4679 struct demangle_component
*dc
)
4681 struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4684 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4685 if (fold_code
[0] != 'f')
4689 operator_
= d_left (ops
);
4690 op1
= d_right (ops
);
4692 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4694 op2
= d_right (op1
);
4698 /* Print the whole pack. */
4699 save_idx
= dpi
->pack_index
;
4700 dpi
->pack_index
= -1;
4702 switch (fold_code
[1])
4704 /* Unary left fold, (... + X). */
4706 d_append_string (dpi
, "(...");
4707 d_print_expr_op (dpi
, options
, operator_
);
4708 d_print_subexpr (dpi
, options
, op1
);
4709 d_append_char (dpi
, ')');
4712 /* Unary right fold, (X + ...). */
4714 d_append_char (dpi
, '(');
4715 d_print_subexpr (dpi
, options
, op1
);
4716 d_print_expr_op (dpi
, options
, operator_
);
4717 d_append_string (dpi
, "...)");
4720 /* Binary left fold, (42 + ... + X). */
4722 /* Binary right fold, (X + ... + 42). */
4724 d_append_char (dpi
, '(');
4725 d_print_subexpr (dpi
, options
, op1
);
4726 d_print_expr_op (dpi
, options
, operator_
);
4727 d_append_string (dpi
, "...");
4728 d_print_expr_op (dpi
, options
, operator_
);
4729 d_print_subexpr (dpi
, options
, op2
);
4730 d_append_char (dpi
, ')');
4734 dpi
->pack_index
= save_idx
;
4738 /* True iff DC represents a C99-style designated initializer. */
4741 is_designated_init (struct demangle_component
*dc
)
4743 if (dc
->type
!= DEMANGLE_COMPONENT_BINARY
4744 && dc
->type
!= DEMANGLE_COMPONENT_TRINARY
)
4747 struct demangle_component
*op
= d_left (dc
);
4748 const char *code
= op
->u
.s_operator
.op
->code
;
4749 return (code
[0] == 'd'
4750 && (code
[1] == 'i' || code
[1] == 'x' || code
[1] == 'X'));
4753 /* If DC represents a C99-style designated initializer, print it and return
4754 true; otherwise, return false. */
4757 d_maybe_print_designated_init (struct d_print_info
*dpi
, int options
,
4758 struct demangle_component
*dc
)
4760 if (!is_designated_init (dc
))
4763 const char *code
= d_left (dc
)->u
.s_operator
.op
->code
;
4765 struct demangle_component
*operands
= d_right (dc
);
4766 struct demangle_component
*op1
= d_left (operands
);
4767 struct demangle_component
*op2
= d_right (operands
);
4770 d_append_char (dpi
, '.');
4772 d_append_char (dpi
, '[');
4774 d_print_comp (dpi
, options
, op1
);
4777 d_append_string (dpi
, " ... ");
4778 d_print_comp (dpi
, options
, d_left (op2
));
4779 op2
= d_right (op2
);
4782 d_append_char (dpi
, ']');
4783 if (is_designated_init (op2
))
4785 /* Don't put '=' or '(' between chained designators. */
4786 d_print_comp (dpi
, options
, op2
);
4790 d_append_char (dpi
, '=');
4791 d_print_subexpr (dpi
, options
, op2
);
4796 /* Subroutine to handle components. */
4799 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4800 struct demangle_component
*dc
)
4802 /* Magic variable to let reference smashing skip over the next modifier
4803 without needing to modify *dc. */
4804 struct demangle_component
*mod_inner
= NULL
;
4806 /* Variable used to store the current templates while a previously
4807 captured scope is used. */
4808 struct d_print_template
*saved_templates
;
4810 /* Nonzero if templates have been stored in the above variable. */
4811 int need_template_restore
= 0;
4815 d_print_error (dpi
);
4818 if (d_print_saw_error (dpi
))
4823 case DEMANGLE_COMPONENT_NAME
:
4824 if ((options
& DMGL_JAVA
) == 0)
4825 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4827 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4830 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4831 d_print_comp (dpi
, options
, d_left (dc
));
4832 d_append_string (dpi
, "[abi:");
4833 d_print_comp (dpi
, options
, d_right (dc
));
4834 d_append_char (dpi
, ']');
4837 case DEMANGLE_COMPONENT_QUAL_NAME
:
4838 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4839 d_print_comp (dpi
, options
, d_left (dc
));
4840 if ((options
& DMGL_JAVA
) == 0)
4841 d_append_string (dpi
, "::");
4843 d_append_char (dpi
, '.');
4845 struct demangle_component
*local_name
= d_right (dc
);
4846 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4848 d_append_string (dpi
, "{default arg#");
4849 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4850 d_append_string (dpi
, "}::");
4851 local_name
= local_name
->u
.s_unary_num
.sub
;
4853 d_print_comp (dpi
, options
, local_name
);
4857 case DEMANGLE_COMPONENT_TYPED_NAME
:
4859 struct d_print_mod
*hold_modifiers
;
4860 struct demangle_component
*typed_name
;
4861 struct d_print_mod adpm
[4];
4863 struct d_print_template dpt
;
4865 /* Pass the name down to the type so that it can be printed in
4866 the right place for the type. We also have to pass down
4867 any CV-qualifiers, which apply to the this parameter. */
4868 hold_modifiers
= dpi
->modifiers
;
4871 typed_name
= d_left (dc
);
4872 while (typed_name
!= NULL
)
4874 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4876 d_print_error (dpi
);
4880 adpm
[i
].next
= dpi
->modifiers
;
4881 dpi
->modifiers
= &adpm
[i
];
4882 adpm
[i
].mod
= typed_name
;
4883 adpm
[i
].printed
= 0;
4884 adpm
[i
].templates
= dpi
->templates
;
4887 if (!is_fnqual_component_type (typed_name
->type
))
4890 typed_name
= d_left (typed_name
);
4893 if (typed_name
== NULL
)
4895 d_print_error (dpi
);
4899 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4900 there may be CV-qualifiers on its right argument which
4901 really apply here; this happens when parsing a class that
4902 is local to a function. */
4903 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4905 typed_name
= d_right (typed_name
);
4906 if (typed_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4907 typed_name
= typed_name
->u
.s_unary_num
.sub
;
4908 while (typed_name
!= NULL
4909 && is_fnqual_component_type (typed_name
->type
))
4911 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4913 d_print_error (dpi
);
4917 adpm
[i
] = adpm
[i
- 1];
4918 adpm
[i
].next
= &adpm
[i
- 1];
4919 dpi
->modifiers
= &adpm
[i
];
4921 adpm
[i
- 1].mod
= typed_name
;
4922 adpm
[i
- 1].printed
= 0;
4923 adpm
[i
- 1].templates
= dpi
->templates
;
4926 typed_name
= d_left (typed_name
);
4928 if (typed_name
== NULL
)
4930 d_print_error (dpi
);
4935 /* If typed_name is a template, then it applies to the
4936 function type as well. */
4937 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4939 dpt
.next
= dpi
->templates
;
4940 dpi
->templates
= &dpt
;
4941 dpt
.template_decl
= typed_name
;
4944 d_print_comp (dpi
, options
, d_right (dc
));
4946 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4947 dpi
->templates
= dpt
.next
;
4949 /* If the modifiers didn't get printed by the type, print them
4954 if (! adpm
[i
].printed
)
4956 d_append_char (dpi
, ' ');
4957 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4961 dpi
->modifiers
= hold_modifiers
;
4966 case DEMANGLE_COMPONENT_TEMPLATE
:
4968 struct d_print_mod
*hold_dpm
;
4969 struct demangle_component
*dcl
;
4970 const struct demangle_component
*hold_current
;
4972 /* This template may need to be referenced by a cast operator
4973 contained in its subtree. */
4974 hold_current
= dpi
->current_template
;
4975 dpi
->current_template
= dc
;
4977 /* Don't push modifiers into a template definition. Doing so
4978 could give the wrong definition for a template argument.
4979 Instead, treat the template essentially as a name. */
4981 hold_dpm
= dpi
->modifiers
;
4982 dpi
->modifiers
= NULL
;
4986 if ((options
& DMGL_JAVA
) != 0
4987 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4988 && dcl
->u
.s_name
.len
== 6
4989 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4991 /* Special-case Java arrays, so that JArray<TYPE> appears
4992 instead as TYPE[]. */
4994 d_print_comp (dpi
, options
, d_right (dc
));
4995 d_append_string (dpi
, "[]");
4999 d_print_comp (dpi
, options
, dcl
);
5000 if (d_last_char (dpi
) == '<')
5001 d_append_char (dpi
, ' ');
5002 d_append_char (dpi
, '<');
5003 d_print_comp (dpi
, options
, d_right (dc
));
5004 /* Avoid generating two consecutive '>' characters, to avoid
5005 the C++ syntactic ambiguity. */
5006 if (d_last_char (dpi
) == '>')
5007 d_append_char (dpi
, ' ');
5008 d_append_char (dpi
, '>');
5011 dpi
->modifiers
= hold_dpm
;
5012 dpi
->current_template
= hold_current
;
5017 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
5018 if (dpi
->is_lambda_arg
)
5020 /* Show the template parm index, as that's how g++ displays
5021 these, and future proofs us against potential
5022 '[]<typename T> (T *a, T *b) {...}'. */
5023 d_append_buffer (dpi
, "auto:", 5);
5024 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5028 struct d_print_template
*hold_dpt
;
5029 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
5031 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5032 a
= d_index_template_argument (a
, dpi
->pack_index
);
5036 d_print_error (dpi
);
5040 /* While processing this parameter, we need to pop the list
5041 of templates. This is because the template parameter may
5042 itself be a reference to a parameter of an outer
5045 hold_dpt
= dpi
->templates
;
5046 dpi
->templates
= hold_dpt
->next
;
5048 d_print_comp (dpi
, options
, a
);
5050 dpi
->templates
= hold_dpt
;
5054 case DEMANGLE_COMPONENT_TPARM_OBJ
:
5055 d_append_string (dpi
, "template parameter object for ");
5056 d_print_comp (dpi
, options
, d_left (dc
));
5059 case DEMANGLE_COMPONENT_CTOR
:
5060 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
5063 case DEMANGLE_COMPONENT_DTOR
:
5064 d_append_char (dpi
, '~');
5065 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
5068 case DEMANGLE_COMPONENT_VTABLE
:
5069 d_append_string (dpi
, "vtable for ");
5070 d_print_comp (dpi
, options
, d_left (dc
));
5073 case DEMANGLE_COMPONENT_VTT
:
5074 d_append_string (dpi
, "VTT for ");
5075 d_print_comp (dpi
, options
, d_left (dc
));
5078 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
5079 d_append_string (dpi
, "construction vtable for ");
5080 d_print_comp (dpi
, options
, d_left (dc
));
5081 d_append_string (dpi
, "-in-");
5082 d_print_comp (dpi
, options
, d_right (dc
));
5085 case DEMANGLE_COMPONENT_TYPEINFO
:
5086 d_append_string (dpi
, "typeinfo for ");
5087 d_print_comp (dpi
, options
, d_left (dc
));
5090 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
5091 d_append_string (dpi
, "typeinfo name for ");
5092 d_print_comp (dpi
, options
, d_left (dc
));
5095 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
5096 d_append_string (dpi
, "typeinfo fn for ");
5097 d_print_comp (dpi
, options
, d_left (dc
));
5100 case DEMANGLE_COMPONENT_THUNK
:
5101 d_append_string (dpi
, "non-virtual thunk to ");
5102 d_print_comp (dpi
, options
, d_left (dc
));
5105 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
5106 d_append_string (dpi
, "virtual thunk to ");
5107 d_print_comp (dpi
, options
, d_left (dc
));
5110 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
5111 d_append_string (dpi
, "covariant return thunk to ");
5112 d_print_comp (dpi
, options
, d_left (dc
));
5115 case DEMANGLE_COMPONENT_JAVA_CLASS
:
5116 d_append_string (dpi
, "java Class for ");
5117 d_print_comp (dpi
, options
, d_left (dc
));
5120 case DEMANGLE_COMPONENT_GUARD
:
5121 d_append_string (dpi
, "guard variable for ");
5122 d_print_comp (dpi
, options
, d_left (dc
));
5125 case DEMANGLE_COMPONENT_TLS_INIT
:
5126 d_append_string (dpi
, "TLS init function for ");
5127 d_print_comp (dpi
, options
, d_left (dc
));
5130 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
5131 d_append_string (dpi
, "TLS wrapper function for ");
5132 d_print_comp (dpi
, options
, d_left (dc
));
5135 case DEMANGLE_COMPONENT_REFTEMP
:
5136 d_append_string (dpi
, "reference temporary #");
5137 d_print_comp (dpi
, options
, d_right (dc
));
5138 d_append_string (dpi
, " for ");
5139 d_print_comp (dpi
, options
, d_left (dc
));
5142 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
5143 d_append_string (dpi
, "hidden alias for ");
5144 d_print_comp (dpi
, options
, d_left (dc
));
5147 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
5148 d_append_string (dpi
, "transaction clone for ");
5149 d_print_comp (dpi
, options
, d_left (dc
));
5152 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
5153 d_append_string (dpi
, "non-transaction clone for ");
5154 d_print_comp (dpi
, options
, d_left (dc
));
5157 case DEMANGLE_COMPONENT_SUB_STD
:
5158 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
5161 case DEMANGLE_COMPONENT_RESTRICT
:
5162 case DEMANGLE_COMPONENT_VOLATILE
:
5163 case DEMANGLE_COMPONENT_CONST
:
5165 struct d_print_mod
*pdpm
;
5167 /* When printing arrays, it's possible to have cases where the
5168 same CV-qualifier gets pushed on the stack multiple times.
5169 We only need to print it once. */
5171 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
5173 if (! pdpm
->printed
)
5175 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
5176 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
5177 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
5179 if (pdpm
->mod
->type
== dc
->type
)
5181 d_print_comp (dpi
, options
, d_left (dc
));
5189 case DEMANGLE_COMPONENT_REFERENCE
:
5190 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5192 /* Handle reference smashing: & + && = &. */
5193 struct demangle_component
*sub
= d_left (dc
);
5194 if (!dpi
->is_lambda_arg
5195 && sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
5197 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
5198 struct demangle_component
*a
;
5202 /* This is the first time SUB has been traversed.
5203 We need to capture the current templates so
5204 they can be restored if SUB is reentered as a
5206 d_save_scope (dpi
, sub
);
5207 if (d_print_saw_error (dpi
))
5212 const struct d_component_stack
*dcse
;
5213 int found_self_or_parent
= 0;
5215 /* This traversal is reentering SUB as a substition.
5216 If we are not beneath SUB or DC in the tree then we
5217 need to restore SUB's template stack temporarily. */
5218 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
5219 dcse
= dcse
->parent
)
5223 && dcse
!= dpi
->component_stack
))
5225 found_self_or_parent
= 1;
5230 if (!found_self_or_parent
)
5232 saved_templates
= dpi
->templates
;
5233 dpi
->templates
= scope
->templates
;
5234 need_template_restore
= 1;
5238 a
= d_lookup_template_argument (dpi
, sub
);
5239 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
5240 a
= d_index_template_argument (a
, dpi
->pack_index
);
5244 if (need_template_restore
)
5245 dpi
->templates
= saved_templates
;
5247 d_print_error (dpi
);
5254 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5255 || sub
->type
== dc
->type
)
5257 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5258 mod_inner
= d_left (sub
);
5262 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5263 case DEMANGLE_COMPONENT_POINTER
:
5264 case DEMANGLE_COMPONENT_COMPLEX
:
5265 case DEMANGLE_COMPONENT_IMAGINARY
:
5266 FNQUAL_COMPONENT_CASE
:
5269 /* We keep a list of modifiers on the stack. */
5270 struct d_print_mod dpm
;
5272 dpm
.next
= dpi
->modifiers
;
5273 dpi
->modifiers
= &dpm
;
5276 dpm
.templates
= dpi
->templates
;
5279 mod_inner
= d_left (dc
);
5281 d_print_comp (dpi
, options
, mod_inner
);
5283 /* If the modifier didn't get printed by the type, print it
5286 d_print_mod (dpi
, options
, dc
);
5288 dpi
->modifiers
= dpm
.next
;
5290 if (need_template_restore
)
5291 dpi
->templates
= saved_templates
;
5296 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5297 if ((options
& DMGL_JAVA
) == 0)
5298 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5299 dc
->u
.s_builtin
.type
->len
);
5301 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5302 dc
->u
.s_builtin
.type
->java_len
);
5305 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5306 d_print_comp (dpi
, options
, d_left (dc
));
5309 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5311 if ((options
& DMGL_RET_POSTFIX
) != 0)
5312 d_print_function_type (dpi
,
5313 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5314 dc
, dpi
->modifiers
);
5316 /* Print return type if present */
5317 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5318 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5320 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5322 struct d_print_mod dpm
;
5324 /* We must pass this type down as a modifier in order to
5325 print it in the right location. */
5326 dpm
.next
= dpi
->modifiers
;
5327 dpi
->modifiers
= &dpm
;
5330 dpm
.templates
= dpi
->templates
;
5332 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5335 dpi
->modifiers
= dpm
.next
;
5340 /* In standard prefix notation, there is a space between the
5341 return type and the function signature. */
5342 if ((options
& DMGL_RET_POSTFIX
) == 0)
5343 d_append_char (dpi
, ' ');
5346 if ((options
& DMGL_RET_POSTFIX
) == 0)
5347 d_print_function_type (dpi
,
5348 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5349 dc
, dpi
->modifiers
);
5354 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5356 struct d_print_mod
*hold_modifiers
;
5357 struct d_print_mod adpm
[4];
5359 struct d_print_mod
*pdpm
;
5361 /* We must pass this type down as a modifier in order to print
5362 multi-dimensional arrays correctly. If the array itself is
5363 CV-qualified, we act as though the element type were
5364 CV-qualified. We do this by copying the modifiers down
5365 rather than fiddling pointers, so that we don't wind up
5366 with a d_print_mod higher on the stack pointing into our
5367 stack frame after we return. */
5369 hold_modifiers
= dpi
->modifiers
;
5371 adpm
[0].next
= hold_modifiers
;
5372 dpi
->modifiers
= &adpm
[0];
5374 adpm
[0].printed
= 0;
5375 adpm
[0].templates
= dpi
->templates
;
5378 pdpm
= hold_modifiers
;
5380 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5381 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5382 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5384 if (! pdpm
->printed
)
5386 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5388 d_print_error (dpi
);
5393 adpm
[i
].next
= dpi
->modifiers
;
5394 dpi
->modifiers
= &adpm
[i
];
5402 d_print_comp (dpi
, options
, d_right (dc
));
5404 dpi
->modifiers
= hold_modifiers
;
5406 if (adpm
[0].printed
)
5412 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5415 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5420 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5421 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5423 struct d_print_mod dpm
;
5425 dpm
.next
= dpi
->modifiers
;
5426 dpi
->modifiers
= &dpm
;
5429 dpm
.templates
= dpi
->templates
;
5431 d_print_comp (dpi
, options
, d_right (dc
));
5433 /* If the modifier didn't get printed by the type, print it
5436 d_print_mod (dpi
, options
, dc
);
5438 dpi
->modifiers
= dpm
.next
;
5443 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5444 if (dc
->u
.s_fixed
.sat
)
5445 d_append_string (dpi
, "_Sat ");
5446 /* Don't print "int _Accum". */
5447 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5448 != &cplus_demangle_builtin_types
['i'-'a'])
5450 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5451 d_append_char (dpi
, ' ');
5453 if (dc
->u
.s_fixed
.accum
)
5454 d_append_string (dpi
, "_Accum");
5456 d_append_string (dpi
, "_Fract");
5459 case DEMANGLE_COMPONENT_ARGLIST
:
5460 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5461 if (d_left (dc
) != NULL
)
5462 d_print_comp (dpi
, options
, d_left (dc
));
5463 if (d_right (dc
) != NULL
)
5466 unsigned long int flush_count
;
5467 /* Make sure ", " isn't flushed by d_append_string, otherwise
5468 dpi->len -= 2 wouldn't work. */
5469 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5470 d_print_flush (dpi
);
5471 d_append_string (dpi
, ", ");
5473 flush_count
= dpi
->flush_count
;
5474 d_print_comp (dpi
, options
, d_right (dc
));
5475 /* If that didn't print anything (which can happen with empty
5476 template argument packs), remove the comma and space. */
5477 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5482 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5484 struct demangle_component
*type
= d_left (dc
);
5485 struct demangle_component
*list
= d_right (dc
);
5488 d_print_comp (dpi
, options
, type
);
5489 d_append_char (dpi
, '{');
5490 d_print_comp (dpi
, options
, list
);
5491 d_append_char (dpi
, '}');
5495 case DEMANGLE_COMPONENT_OPERATOR
:
5497 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5500 d_append_string (dpi
, "operator");
5501 /* Add a space before new/delete. */
5502 if (IS_LOWER (op
->name
[0]))
5503 d_append_char (dpi
, ' ');
5504 /* Omit a trailing space. */
5505 if (op
->name
[len
-1] == ' ')
5507 d_append_buffer (dpi
, op
->name
, len
);
5511 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5513 struct demangle_component
*name
= dc
->u
.s_extended_operator
.name
;
5514 if (name
->type
== DEMANGLE_COMPONENT_NAME
5515 && !strncmp (name
->u
.s_name
.s
, "__alignof__", name
->u
.s_name
.len
))
5516 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5519 d_append_string (dpi
, "operator ");
5520 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5525 case DEMANGLE_COMPONENT_CONVERSION
:
5526 d_append_string (dpi
, "operator ");
5527 d_print_conversion (dpi
, options
, dc
);
5530 case DEMANGLE_COMPONENT_NULLARY
:
5531 d_print_expr_op (dpi
, options
, d_left (dc
));
5534 case DEMANGLE_COMPONENT_UNARY
:
5536 struct demangle_component
*op
= d_left (dc
);
5537 struct demangle_component
*operand
= d_right (dc
);
5538 const char *code
= NULL
;
5540 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5542 code
= op
->u
.s_operator
.op
->code
;
5543 if (!strcmp (code
, "ad"))
5545 /* Don't print the argument list for the address of a
5547 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5548 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5549 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5550 operand
= d_left (operand
);
5552 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5554 /* This indicates a suffix operator. */
5555 operand
= d_left (operand
);
5556 d_print_subexpr (dpi
, options
, operand
);
5557 d_print_expr_op (dpi
, options
, op
);
5562 /* For sizeof..., just print the pack length. */
5563 if (code
&& !strcmp (code
, "sZ"))
5565 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5566 int len
= d_pack_length (a
);
5567 d_append_num (dpi
, len
);
5570 else if (code
&& !strcmp (code
, "sP"))
5572 int len
= d_args_length (dpi
, operand
);
5573 d_append_num (dpi
, len
);
5577 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5578 d_print_expr_op (dpi
, options
, op
);
5581 d_append_char (dpi
, '(');
5582 d_print_cast (dpi
, options
, op
);
5583 d_append_char (dpi
, ')');
5585 if (code
&& !strcmp (code
, "gs"))
5586 /* Avoid parens after '::'. */
5587 d_print_comp (dpi
, options
, operand
);
5588 else if ((code
&& !strcmp (code
, "st"))
5589 || (op
->type
== DEMANGLE_COMPONENT_EXTENDED_OPERATOR
5590 && (op
->u
.s_extended_operator
.name
->type
5591 == DEMANGLE_COMPONENT_NAME
)
5592 && !strncmp (op
->u
.s_extended_operator
.name
->u
.s_name
.s
,
5594 op
->u
.s_extended_operator
.name
->u
.s_name
.len
)))
5595 /* Always print parens for sizeof (type) and __alignof__. */
5597 d_append_char (dpi
, '(');
5598 d_print_comp (dpi
, options
, operand
);
5599 d_append_char (dpi
, ')');
5602 d_print_subexpr (dpi
, options
, operand
);
5606 case DEMANGLE_COMPONENT_BINARY
:
5607 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5609 d_print_error (dpi
);
5613 if (op_is_new_cast (d_left (dc
)))
5615 d_print_expr_op (dpi
, options
, d_left (dc
));
5616 d_append_char (dpi
, '<');
5617 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5618 d_append_string (dpi
, ">(");
5619 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5620 d_append_char (dpi
, ')');
5624 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5627 if (d_maybe_print_designated_init (dpi
, options
, dc
))
5630 /* We wrap an expression which uses the greater-than operator in
5631 an extra layer of parens so that it does not get confused
5632 with the '>' which ends the template parameters. */
5633 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5634 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5635 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5636 d_append_char (dpi
, '(');
5638 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5639 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5641 /* Function call used in an expression should not have printed types
5642 of the function arguments. Values of the function arguments still
5643 get printed below. */
5645 const struct demangle_component
*func
= d_left (d_right (dc
));
5647 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5648 d_print_error (dpi
);
5649 d_print_subexpr (dpi
, options
, d_left (func
));
5652 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5653 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5655 d_append_char (dpi
, '[');
5656 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5657 d_append_char (dpi
, ']');
5661 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5662 d_print_expr_op (dpi
, options
, d_left (dc
));
5663 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5666 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5667 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5668 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5669 d_append_char (dpi
, ')');
5673 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5674 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5675 d_print_error (dpi
);
5678 case DEMANGLE_COMPONENT_TRINARY
:
5679 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5680 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5682 d_print_error (dpi
);
5685 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5687 if (d_maybe_print_designated_init (dpi
, options
, dc
))
5690 struct demangle_component
*op
= d_left (dc
);
5691 struct demangle_component
*first
= d_left (d_right (dc
));
5692 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5693 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5695 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5697 d_print_subexpr (dpi
, options
, first
);
5698 d_print_expr_op (dpi
, options
, op
);
5699 d_print_subexpr (dpi
, options
, second
);
5700 d_append_string (dpi
, " : ");
5701 d_print_subexpr (dpi
, options
, third
);
5705 d_append_string (dpi
, "new ");
5706 if (d_left (first
) != NULL
)
5708 d_print_subexpr (dpi
, options
, first
);
5709 d_append_char (dpi
, ' ');
5711 d_print_comp (dpi
, options
, second
);
5713 d_print_subexpr (dpi
, options
, third
);
5718 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5719 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5720 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5721 d_print_error (dpi
);
5724 case DEMANGLE_COMPONENT_LITERAL
:
5725 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5727 enum d_builtin_type_print tp
;
5729 /* For some builtin types, produce simpler output. */
5730 tp
= D_PRINT_DEFAULT
;
5731 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5733 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5737 case D_PRINT_UNSIGNED
:
5739 case D_PRINT_UNSIGNED_LONG
:
5740 case D_PRINT_LONG_LONG
:
5741 case D_PRINT_UNSIGNED_LONG_LONG
:
5742 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5744 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5745 d_append_char (dpi
, '-');
5746 d_print_comp (dpi
, options
, d_right (dc
));
5751 case D_PRINT_UNSIGNED
:
5752 d_append_char (dpi
, 'u');
5755 d_append_char (dpi
, 'l');
5757 case D_PRINT_UNSIGNED_LONG
:
5758 d_append_string (dpi
, "ul");
5760 case D_PRINT_LONG_LONG
:
5761 d_append_string (dpi
, "ll");
5763 case D_PRINT_UNSIGNED_LONG_LONG
:
5764 d_append_string (dpi
, "ull");
5772 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5773 && d_right (dc
)->u
.s_name
.len
== 1
5774 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5776 switch (d_right (dc
)->u
.s_name
.s
[0])
5779 d_append_string (dpi
, "false");
5782 d_append_string (dpi
, "true");
5795 d_append_char (dpi
, '(');
5796 d_print_comp (dpi
, options
, d_left (dc
));
5797 d_append_char (dpi
, ')');
5798 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5799 d_append_char (dpi
, '-');
5800 if (tp
== D_PRINT_FLOAT
)
5801 d_append_char (dpi
, '[');
5802 d_print_comp (dpi
, options
, d_right (dc
));
5803 if (tp
== D_PRINT_FLOAT
)
5804 d_append_char (dpi
, ']');
5808 case DEMANGLE_COMPONENT_NUMBER
:
5809 d_append_num (dpi
, dc
->u
.s_number
.number
);
5812 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5813 d_append_string (dpi
, "java resource ");
5814 d_print_comp (dpi
, options
, d_left (dc
));
5817 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5818 d_print_comp (dpi
, options
, d_left (dc
));
5819 d_print_comp (dpi
, options
, d_right (dc
));
5822 case DEMANGLE_COMPONENT_CHARACTER
:
5823 d_append_char (dpi
, dc
->u
.s_character
.character
);
5826 case DEMANGLE_COMPONENT_DECLTYPE
:
5827 d_append_string (dpi
, "decltype (");
5828 d_print_comp (dpi
, options
, d_left (dc
));
5829 d_append_char (dpi
, ')');
5832 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5836 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5839 /* d_find_pack won't find anything if the only packs involved
5840 in this expansion are function parameter packs; in that
5841 case, just print the pattern and "...". */
5842 d_print_subexpr (dpi
, options
, d_left (dc
));
5843 d_append_string (dpi
, "...");
5847 len
= d_pack_length (a
);
5849 for (i
= 0; i
< len
; ++i
)
5851 dpi
->pack_index
= i
;
5852 d_print_comp (dpi
, options
, dc
);
5854 d_append_string (dpi
, ", ");
5859 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5861 long num
= dc
->u
.s_number
.number
;
5863 d_append_string (dpi
, "this");
5866 d_append_string (dpi
, "{parm#");
5867 d_append_num (dpi
, num
);
5868 d_append_char (dpi
, '}');
5873 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5874 d_append_string (dpi
, "global constructors keyed to ");
5875 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5878 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5879 d_append_string (dpi
, "global destructors keyed to ");
5880 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5883 case DEMANGLE_COMPONENT_LAMBDA
:
5884 d_append_string (dpi
, "{lambda(");
5885 /* Generic lambda auto parms are mangled as the template type
5887 dpi
->is_lambda_arg
++;
5888 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5889 dpi
->is_lambda_arg
--;
5890 d_append_string (dpi
, ")#");
5891 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5892 d_append_char (dpi
, '}');
5895 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5896 d_append_string (dpi
, "{unnamed type#");
5897 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5898 d_append_char (dpi
, '}');
5901 case DEMANGLE_COMPONENT_CLONE
:
5902 d_print_comp (dpi
, options
, d_left (dc
));
5903 d_append_string (dpi
, " [clone ");
5904 d_print_comp (dpi
, options
, d_right (dc
));
5905 d_append_char (dpi
, ']');
5909 d_print_error (dpi
);
5915 d_print_comp (struct d_print_info
*dpi
, int options
,
5916 struct demangle_component
*dc
)
5918 struct d_component_stack self
;
5919 if (dc
== NULL
|| dc
->d_printing
> 1 || dpi
->recursion
> MAX_RECURSION_COUNT
)
5921 d_print_error (dpi
);
5929 self
.parent
= dpi
->component_stack
;
5930 dpi
->component_stack
= &self
;
5932 d_print_comp_inner (dpi
, options
, dc
);
5934 dpi
->component_stack
= self
.parent
;
5939 /* Print a Java dentifier. For Java we try to handle encoded extended
5940 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5941 so we don't it for C++. Characters are encoded as
5945 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5951 for (p
= name
; p
< end
; ++p
)
5962 for (q
= p
+ 3; q
< end
; ++q
)
5968 else if (*q
>= 'A' && *q
<= 'F')
5969 dig
= *q
- 'A' + 10;
5970 else if (*q
>= 'a' && *q
<= 'f')
5971 dig
= *q
- 'a' + 10;
5977 /* If the Unicode character is larger than 256, we don't try
5978 to deal with it here. FIXME. */
5979 if (q
< end
&& *q
== '_' && c
< 256)
5981 d_append_char (dpi
, c
);
5987 d_append_char (dpi
, *p
);
5991 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5992 qualifiers on this after printing a function. */
5995 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5996 struct d_print_mod
*mods
, int suffix
)
5998 struct d_print_template
*hold_dpt
;
6000 if (mods
== NULL
|| d_print_saw_error (dpi
))
6005 && (is_fnqual_component_type (mods
->mod
->type
))))
6007 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
6013 hold_dpt
= dpi
->templates
;
6014 dpi
->templates
= mods
->templates
;
6016 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
6018 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
6019 dpi
->templates
= hold_dpt
;
6022 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6024 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
6025 dpi
->templates
= hold_dpt
;
6028 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
6030 struct d_print_mod
*hold_modifiers
;
6031 struct demangle_component
*dc
;
6033 /* When this is on the modifier stack, we have pulled any
6034 qualifiers off the right argument already. Otherwise, we
6035 print it as usual, but don't let the left argument see any
6038 hold_modifiers
= dpi
->modifiers
;
6039 dpi
->modifiers
= NULL
;
6040 d_print_comp (dpi
, options
, d_left (mods
->mod
));
6041 dpi
->modifiers
= hold_modifiers
;
6043 if ((options
& DMGL_JAVA
) == 0)
6044 d_append_string (dpi
, "::");
6046 d_append_char (dpi
, '.');
6048 dc
= d_right (mods
->mod
);
6050 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
6052 d_append_string (dpi
, "{default arg#");
6053 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
6054 d_append_string (dpi
, "}::");
6055 dc
= dc
->u
.s_unary_num
.sub
;
6058 while (is_fnqual_component_type (dc
->type
))
6061 d_print_comp (dpi
, options
, dc
);
6063 dpi
->templates
= hold_dpt
;
6067 d_print_mod (dpi
, options
, mods
->mod
);
6069 dpi
->templates
= hold_dpt
;
6071 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
6074 /* Print a modifier. */
6077 d_print_mod (struct d_print_info
*dpi
, int options
,
6078 struct demangle_component
*mod
)
6082 case DEMANGLE_COMPONENT_RESTRICT
:
6083 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6084 d_append_string (dpi
, " restrict");
6086 case DEMANGLE_COMPONENT_VOLATILE
:
6087 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6088 d_append_string (dpi
, " volatile");
6090 case DEMANGLE_COMPONENT_CONST
:
6091 case DEMANGLE_COMPONENT_CONST_THIS
:
6092 d_append_string (dpi
, " const");
6094 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
6095 d_append_string (dpi
, " transaction_safe");
6097 case DEMANGLE_COMPONENT_NOEXCEPT
:
6098 d_append_string (dpi
, " noexcept");
6101 d_append_char (dpi
, '(');
6102 d_print_comp (dpi
, options
, d_right (mod
));
6103 d_append_char (dpi
, ')');
6106 case DEMANGLE_COMPONENT_THROW_SPEC
:
6107 d_append_string (dpi
, " throw");
6110 d_append_char (dpi
, '(');
6111 d_print_comp (dpi
, options
, d_right (mod
));
6112 d_append_char (dpi
, ')');
6115 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6116 d_append_char (dpi
, ' ');
6117 d_print_comp (dpi
, options
, d_right (mod
));
6119 case DEMANGLE_COMPONENT_POINTER
:
6120 /* There is no pointer symbol in Java. */
6121 if ((options
& DMGL_JAVA
) == 0)
6122 d_append_char (dpi
, '*');
6124 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6125 /* For the ref-qualifier, put a space before the &. */
6126 d_append_char (dpi
, ' ');
6128 case DEMANGLE_COMPONENT_REFERENCE
:
6129 d_append_char (dpi
, '&');
6131 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6132 d_append_char (dpi
, ' ');
6134 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6135 d_append_string (dpi
, "&&");
6137 case DEMANGLE_COMPONENT_COMPLEX
:
6138 d_append_string (dpi
, " _Complex");
6140 case DEMANGLE_COMPONENT_IMAGINARY
:
6141 d_append_string (dpi
, " _Imaginary");
6143 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6144 if (d_last_char (dpi
) != '(')
6145 d_append_char (dpi
, ' ');
6146 d_print_comp (dpi
, options
, d_left (mod
));
6147 d_append_string (dpi
, "::*");
6149 case DEMANGLE_COMPONENT_TYPED_NAME
:
6150 d_print_comp (dpi
, options
, d_left (mod
));
6152 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
6153 d_append_string (dpi
, " __vector(");
6154 d_print_comp (dpi
, options
, d_left (mod
));
6155 d_append_char (dpi
, ')');
6159 /* Otherwise, we have something that won't go back on the
6160 modifier stack, so we can just print it. */
6161 d_print_comp (dpi
, options
, mod
);
6166 /* Print a function type, except for the return type. */
6169 d_print_function_type (struct d_print_info
*dpi
, int options
,
6170 struct demangle_component
*dc
,
6171 struct d_print_mod
*mods
)
6175 struct d_print_mod
*p
;
6176 struct d_print_mod
*hold_modifiers
;
6180 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6185 switch (p
->mod
->type
)
6187 case DEMANGLE_COMPONENT_POINTER
:
6188 case DEMANGLE_COMPONENT_REFERENCE
:
6189 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
6192 case DEMANGLE_COMPONENT_RESTRICT
:
6193 case DEMANGLE_COMPONENT_VOLATILE
:
6194 case DEMANGLE_COMPONENT_CONST
:
6195 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
6196 case DEMANGLE_COMPONENT_COMPLEX
:
6197 case DEMANGLE_COMPONENT_IMAGINARY
:
6198 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
6202 FNQUAL_COMPONENT_CASE
:
6215 if (d_last_char (dpi
) != '('
6216 && d_last_char (dpi
) != '*')
6219 if (need_space
&& d_last_char (dpi
) != ' ')
6220 d_append_char (dpi
, ' ');
6221 d_append_char (dpi
, '(');
6224 hold_modifiers
= dpi
->modifiers
;
6225 dpi
->modifiers
= NULL
;
6227 d_print_mod_list (dpi
, options
, mods
, 0);
6230 d_append_char (dpi
, ')');
6232 d_append_char (dpi
, '(');
6234 if (d_right (dc
) != NULL
)
6235 d_print_comp (dpi
, options
, d_right (dc
));
6237 d_append_char (dpi
, ')');
6239 d_print_mod_list (dpi
, options
, mods
, 1);
6241 dpi
->modifiers
= hold_modifiers
;
6244 /* Print an array type, except for the element type. */
6247 d_print_array_type (struct d_print_info
*dpi
, int options
,
6248 struct demangle_component
*dc
,
6249 struct d_print_mod
*mods
)
6257 struct d_print_mod
*p
;
6260 for (p
= mods
; p
!= NULL
; p
= p
->next
)
6264 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
6279 d_append_string (dpi
, " (");
6281 d_print_mod_list (dpi
, options
, mods
, 0);
6284 d_append_char (dpi
, ')');
6288 d_append_char (dpi
, ' ');
6290 d_append_char (dpi
, '[');
6292 if (d_left (dc
) != NULL
)
6293 d_print_comp (dpi
, options
, d_left (dc
));
6295 d_append_char (dpi
, ']');
6298 /* Print an operator in an expression. */
6301 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6302 struct demangle_component
*dc
)
6304 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6305 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6306 dc
->u
.s_operator
.op
->len
);
6308 d_print_comp (dpi
, options
, dc
);
6314 d_print_cast (struct d_print_info
*dpi
, int options
,
6315 struct demangle_component
*dc
)
6317 d_print_comp (dpi
, options
, d_left (dc
));
6320 /* Print a conversion operator. */
6323 d_print_conversion (struct d_print_info
*dpi
, int options
,
6324 struct demangle_component
*dc
)
6326 struct d_print_template dpt
;
6328 /* For a conversion operator, we need the template parameters from
6329 the enclosing template in scope for processing the type. */
6330 if (dpi
->current_template
!= NULL
)
6332 dpt
.next
= dpi
->templates
;
6333 dpi
->templates
= &dpt
;
6334 dpt
.template_decl
= dpi
->current_template
;
6337 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6339 d_print_comp (dpi
, options
, d_left (dc
));
6340 if (dpi
->current_template
!= NULL
)
6341 dpi
->templates
= dpt
.next
;
6345 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6347 /* For a templated cast operator, we need to remove the template
6348 parameters from scope after printing the operator name,
6349 so we need to handle the template printing here. */
6350 if (dpi
->current_template
!= NULL
)
6351 dpi
->templates
= dpt
.next
;
6353 if (d_last_char (dpi
) == '<')
6354 d_append_char (dpi
, ' ');
6355 d_append_char (dpi
, '<');
6356 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6357 /* Avoid generating two consecutive '>' characters, to avoid
6358 the C++ syntactic ambiguity. */
6359 if (d_last_char (dpi
) == '>')
6360 d_append_char (dpi
, ' ');
6361 d_append_char (dpi
, '>');
6365 /* Initialize the information structure we use to pass around
6368 CP_STATIC_IF_GLIBCPP_V3
6370 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6374 di
->send
= mangled
+ len
;
6375 di
->options
= options
;
6379 /* We cannot need more components than twice the number of chars in
6380 the mangled string. Most components correspond directly to
6381 chars, but the ARGLIST types are exceptions. */
6382 di
->num_comps
= 2 * len
;
6385 /* Similarly, we cannot need more substitutions than there are
6386 chars in the mangled string. */
6390 di
->last_name
= NULL
;
6393 di
->is_expression
= 0;
6394 di
->is_conversion
= 0;
6395 di
->recursion_level
= 0;
6398 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6399 mangled name, return strings in repeated callback giving the demangled
6400 name. OPTIONS is the usual libiberty demangler options. On success,
6401 this returns 1. On failure, returns 0. */
6404 d_demangle_callback (const char *mangled
, int options
,
6405 demangle_callbackref callback
, void *opaque
)
6416 struct demangle_component
*dc
;
6419 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6421 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6422 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6423 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6424 && mangled
[10] == '_')
6425 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6428 if ((options
& DMGL_TYPES
) == 0)
6433 di
.unresolved_name_state
= 1;
6436 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6438 /* PR 87675 - Check for a mangled string that is so long
6439 that we do not have enough stack space to demangle it. */
6440 if (((options
& DMGL_NO_RECURSE_LIMIT
) == 0)
6441 /* This check is a bit arbitrary, since what we really want to do is to
6442 compare the sizes of the di.comps and di.subs arrays against the
6443 amount of stack space remaining. But there is no portable way to do
6444 this, so instead we use the recursion limit as a guide to the maximum
6445 size of the arrays. */
6446 && (unsigned long) di
.num_comps
> DEMANGLE_RECURSION_LIMIT
)
6448 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6453 #ifdef CP_DYNAMIC_ARRAYS
6454 __extension__
struct demangle_component comps
[di
.num_comps
];
6455 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6460 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6461 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6467 dc
= cplus_demangle_type (&di
);
6470 dc
= cplus_demangle_mangled_name (&di
, 1);
6472 case DCT_GLOBAL_CTORS
:
6473 case DCT_GLOBAL_DTORS
:
6474 d_advance (&di
, 11);
6475 dc
= d_make_comp (&di
,
6476 (type
== DCT_GLOBAL_CTORS
6477 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6478 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6479 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6481 d_advance (&di
, strlen (d_str (&di
)));
6484 abort (); /* We have listed all the cases. */
6487 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6488 mangled string, then we didn't successfully demangle it. If
6489 DMGL_PARAMS is not set, we didn't look at the trailing
6491 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6494 /* See discussion in d_unresolved_name. */
6495 if (dc
== NULL
&& di
.unresolved_name_state
== -1)
6497 di
.unresolved_name_state
= 0;
6501 #ifdef CP_DEMANGLE_DEBUG
6505 status
= (dc
!= NULL
)
6506 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6513 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6514 name, return a buffer allocated with malloc holding the demangled
6515 name. OPTIONS is the usual libiberty demangler options. On
6516 success, this sets *PALC to the allocated size of the returned
6517 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6518 a memory allocation failure, and returns NULL. */
6521 d_demangle (const char *mangled
, int options
, size_t *palc
)
6523 struct d_growable_string dgs
;
6526 d_growable_string_init (&dgs
, 0);
6528 status
= d_demangle_callback (mangled
, options
,
6529 d_growable_string_callback_adapter
, &dgs
);
6537 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6541 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6543 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6545 /* ia64 ABI-mandated entry point in the C++ runtime library for
6546 performing demangling. MANGLED_NAME is a NUL-terminated character
6547 string containing the name to be demangled.
6549 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6550 *LENGTH bytes, into which the demangled name is stored. If
6551 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6552 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6553 is placed in a region of memory allocated with malloc.
6555 If LENGTH is non-NULL, the length of the buffer containing the
6556 demangled name, is placed in *LENGTH.
6558 The return value is a pointer to the start of the NUL-terminated
6559 demangled name, or NULL if the demangling fails. The caller is
6560 responsible for deallocating this memory using free.
6562 *STATUS is set to one of the following values:
6563 0: The demangling operation succeeded.
6564 -1: A memory allocation failure occurred.
6565 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6566 -3: One of the arguments is invalid.
6568 The demangling is performed using the C++ ABI mangling rules, with
6572 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6573 size_t *length
, int *status
)
6578 if (mangled_name
== NULL
)
6585 if (output_buffer
!= NULL
&& length
== NULL
)
6592 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6594 if (demangled
== NULL
)
6606 if (output_buffer
== NULL
)
6613 if (strlen (demangled
) < *length
)
6615 strcpy (output_buffer
, demangled
);
6617 demangled
= output_buffer
;
6621 free (output_buffer
);
6632 extern int __gcclibcxx_demangle_callback (const char *,
6634 (const char *, size_t, void *),
6637 /* Alternative, allocationless entry point in the C++ runtime library
6638 for performing demangling. MANGLED_NAME is a NUL-terminated character
6639 string containing the name to be demangled.
6641 CALLBACK is a callback function, called with demangled string
6642 segments as demangling progresses; it is called at least once,
6643 but may be called more than once. OPAQUE is a generalized pointer
6644 used as a callback argument.
6646 The return code is one of the following values, equivalent to
6647 the STATUS values of __cxa_demangle() (excluding -1, since this
6648 function performs no memory allocations):
6649 0: The demangling operation succeeded.
6650 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6651 -3: One of the arguments is invalid.
6653 The demangling is performed using the C++ ABI mangling rules, with
6657 __gcclibcxx_demangle_callback (const char *mangled_name
,
6658 void (*callback
) (const char *, size_t, void *),
6663 if (mangled_name
== NULL
|| callback
== NULL
)
6666 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6674 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6676 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6677 mangled name, return a buffer allocated with malloc holding the
6678 demangled name. Otherwise, return NULL. */
6681 cplus_demangle_v3 (const char *mangled
, int options
)
6685 return d_demangle (mangled
, options
, &alc
);
6689 cplus_demangle_v3_callback (const char *mangled
, int options
,
6690 demangle_callbackref callback
, void *opaque
)
6692 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6695 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6696 conventions, but the output formatting is a little different.
6697 This instructs the C++ demangler not to emit pointer characters ("*"), to
6698 use Java's namespace separator symbol ("." instead of "::"), and to output
6699 JArray<TYPE> as TYPE[]. */
6702 java_demangle_v3 (const char *mangled
)
6706 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6710 java_demangle_v3_callback (const char *mangled
,
6711 demangle_callbackref callback
, void *opaque
)
6713 return d_demangle_callback (mangled
,
6714 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6718 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6720 #ifndef IN_GLIBCPP_V3
6722 /* Demangle a string in order to find out whether it is a constructor
6723 or destructor. Return non-zero on success. Set *CTOR_KIND and
6724 *DTOR_KIND appropriately. */
6727 is_ctor_or_dtor (const char *mangled
,
6728 enum gnu_v3_ctor_kinds
*ctor_kind
,
6729 enum gnu_v3_dtor_kinds
*dtor_kind
)
6732 struct demangle_component
*dc
;
6735 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6736 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6738 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6741 #ifdef CP_DYNAMIC_ARRAYS
6742 __extension__
struct demangle_component comps
[di
.num_comps
];
6743 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6748 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6749 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6752 dc
= cplus_demangle_mangled_name (&di
, 1);
6754 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6755 to demangle the entire string. */
6762 /* These cannot appear on a constructor or destructor. */
6763 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6764 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6765 case DEMANGLE_COMPONENT_CONST_THIS
:
6766 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6767 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6771 case DEMANGLE_COMPONENT_TYPED_NAME
:
6772 case DEMANGLE_COMPONENT_TEMPLATE
:
6775 case DEMANGLE_COMPONENT_QUAL_NAME
:
6776 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6779 case DEMANGLE_COMPONENT_CTOR
:
6780 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6784 case DEMANGLE_COMPONENT_DTOR
:
6785 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6796 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6797 name. A non-zero return indicates the type of constructor. */
6799 enum gnu_v3_ctor_kinds
6800 is_gnu_v3_mangled_ctor (const char *name
)
6802 enum gnu_v3_ctor_kinds ctor_kind
;
6803 enum gnu_v3_dtor_kinds dtor_kind
;
6805 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6806 return (enum gnu_v3_ctor_kinds
) 0;
6811 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6812 name. A non-zero return indicates the type of destructor. */
6814 enum gnu_v3_dtor_kinds
6815 is_gnu_v3_mangled_dtor (const char *name
)
6817 enum gnu_v3_ctor_kinds ctor_kind
;
6818 enum gnu_v3_dtor_kinds dtor_kind
;
6820 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6821 return (enum gnu_v3_dtor_kinds
) 0;
6825 #endif /* IN_GLIBCPP_V3 */
6827 #ifdef STANDALONE_DEMANGLER
6830 #include "dyn-string.h"
6832 static void print_usage (FILE* fp
, int exit_value
);
6834 #define IS_ALPHA(CHAR) \
6835 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6836 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6838 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6839 #define is_mangled_char(CHAR) \
6840 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6841 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6843 /* The name of this program, as invoked. */
6844 const char* program_name
;
6846 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6849 print_usage (FILE* fp
, int exit_value
)
6851 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6852 fprintf (fp
, "Options:\n");
6853 fprintf (fp
, " -h,--help Display this message.\n");
6854 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6855 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6856 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6861 /* Option specification for getopt_long. */
6862 static const struct option long_options
[] =
6864 { "help", no_argument
, NULL
, 'h' },
6865 { "no-params", no_argument
, NULL
, 'p' },
6866 { "verbose", no_argument
, NULL
, 'v' },
6867 { NULL
, no_argument
, NULL
, 0 },
6870 /* Main entry for a demangling filter executable. It will demangle
6871 its command line arguments, if any. If none are provided, it will
6872 filter stdin to stdout, replacing any recognized mangled C++ names
6873 with their demangled equivalents. */
6876 main (int argc
, char *argv
[])
6880 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6882 /* Use the program name of this program, as invoked. */
6883 program_name
= argv
[0];
6885 /* Parse options. */
6888 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6891 case '?': /* Unrecognized option. */
6892 print_usage (stderr
, 1);
6896 print_usage (stdout
, 0);
6900 options
&= ~ DMGL_PARAMS
;
6904 options
|= DMGL_VERBOSE
;
6908 while (opt_char
!= -1);
6911 /* No command line arguments were provided. Filter stdin. */
6913 dyn_string_t mangled
= dyn_string_new (3);
6916 /* Read all of input. */
6917 while (!feof (stdin
))
6921 /* Pile characters into mangled until we hit one that can't
6922 occur in a mangled name. */
6924 while (!feof (stdin
) && is_mangled_char (c
))
6926 dyn_string_append_char (mangled
, c
);
6932 if (dyn_string_length (mangled
) > 0)
6934 #ifdef IN_GLIBCPP_V3
6935 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6937 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6947 /* It might not have been a mangled name. Print the
6949 fputs (dyn_string_buf (mangled
), stdout
);
6952 dyn_string_clear (mangled
);
6955 /* If we haven't hit EOF yet, we've read one character that
6956 can't occur in a mangled name, so print it out. */
6961 dyn_string_delete (mangled
);
6964 /* Demangle command line arguments. */
6966 /* Loop over command line arguments. */
6967 for (i
= optind
; i
< argc
; ++i
)
6970 #ifdef IN_GLIBCPP_V3
6974 /* Attempt to demangle. */
6975 #ifdef IN_GLIBCPP_V3
6976 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6978 s
= cplus_demangle_v3 (argv
[i
], options
);
6981 /* If it worked, print the demangled name. */
6989 #ifdef IN_GLIBCPP_V3
6990 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6992 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
7001 #endif /* STANDALONE_DEMANGLER */