1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2014
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@wasabisystems.com>.
6 This file is part of the libiberty library, which is part of GCC.
8 This file is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file. (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combined
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
32 /* This code implements a demangler for the g++ V3 ABI. The ABI is
33 described on this web page:
34 http://www.codesourcery.com/cxx-abi/abi.html#mangling
36 This code was written while looking at the demangler written by
37 Alex Samuel <samuel@codesourcery.com>.
39 This code first pulls the mangled name apart into a list of
40 components, and then walks the list generating the demangled
43 This file will normally define the following functions, q.v.:
44 char *cplus_demangle_v3(const char *mangled, int options)
45 char *java_demangle_v3(const char *mangled)
46 int cplus_demangle_v3_callback(const char *mangled, int options,
47 demangle_callbackref callback)
48 int java_demangle_v3_callback(const char *mangled,
49 demangle_callbackref callback)
50 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
51 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
53 Also, the interface to the component list is public, and defined in
54 demangle.h. The interface consists of these types, which are
55 defined in demangle.h:
56 enum demangle_component_type
57 struct demangle_component
59 and these functions defined in this file:
60 cplus_demangle_fill_name
61 cplus_demangle_fill_extended_operator
62 cplus_demangle_fill_ctor
63 cplus_demangle_fill_dtor
65 cplus_demangle_print_callback
66 and other functions defined in the file cp-demint.c.
68 This file also defines some other functions and variables which are
69 only to be used by the file cp-demint.c.
71 Preprocessor macros you can define while compiling this file:
74 If defined, this file defines the following functions, q.v.:
75 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
77 int __gcclibcxx_demangle_callback (const char *,
79 (const char *, size_t, void *),
81 instead of cplus_demangle_v3[_callback]() and
82 java_demangle_v3[_callback]().
85 If defined, this file defines only __cxa_demangle() and
86 __gcclibcxx_demangle_callback(), and no other publically visible
87 functions or variables.
90 If defined, this file defines a main() function which demangles
91 any arguments, or, if none, demangles stdin.
94 If defined, turns on debugging mode, which prints information on
95 stdout about the mangled string. This is not generally useful.
98 If defined, additional sanity checks will be performed. It will
99 cause some slowdown, but will allow to catch out-of-bound access
100 errors earlier. This macro is intended for testing and debugging. */
102 #if defined (_AIX) && !defined (__GNUC__)
124 # define alloca __builtin_alloca
126 extern char *alloca ();
127 # endif /* __GNUC__ */
129 #endif /* HAVE_ALLOCA_H */
135 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
138 #include "ansidecl.h"
139 #include "libiberty.h"
140 #include "demangle.h"
141 #include "cp-demangle.h"
143 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
144 also rename them via #define to avoid compiler errors when the
145 static definition conflicts with the extern declaration in a header
149 #define CP_STATIC_IF_GLIBCPP_V3 static
151 #define cplus_demangle_fill_name d_fill_name
152 static int d_fill_name (struct demangle_component
*, const char *, int);
154 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
156 d_fill_extended_operator (struct demangle_component
*, int,
157 struct demangle_component
*);
159 #define cplus_demangle_fill_ctor d_fill_ctor
161 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
162 struct demangle_component
*);
164 #define cplus_demangle_fill_dtor d_fill_dtor
166 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
167 struct demangle_component
*);
169 #define cplus_demangle_mangled_name d_mangled_name
170 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
172 #define cplus_demangle_type d_type
173 static struct demangle_component
*d_type (struct d_info
*);
175 #define cplus_demangle_print d_print
176 static char *d_print (int, const struct demangle_component
*, int, size_t *);
178 #define cplus_demangle_print_callback d_print_callback
179 static int d_print_callback (int, const struct demangle_component
*,
180 demangle_callbackref
, void *);
182 #define cplus_demangle_init_info d_init_info
183 static void d_init_info (const char *, int, size_t, struct d_info
*);
185 #else /* ! defined(IN_GLIBCPP_V3) */
186 #define CP_STATIC_IF_GLIBCPP_V3
187 #endif /* ! defined(IN_GLIBCPP_V3) */
189 /* See if the compiler supports dynamic arrays. */
192 #define CP_DYNAMIC_ARRAYS
195 #ifdef __STDC_VERSION__
196 #if __STDC_VERSION__ >= 199901L
197 #define CP_DYNAMIC_ARRAYS
198 #endif /* __STDC__VERSION >= 199901L */
199 #endif /* defined (__STDC_VERSION__) */
200 #endif /* defined (__STDC__) */
201 #endif /* ! defined (__GNUC__) */
203 /* We avoid pulling in the ctype tables, to prevent pulling in
204 additional unresolved symbols when this code is used in a library.
205 FIXME: Is this really a valid reason? This comes from the original
208 As of this writing this file has the following undefined references
209 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
212 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
213 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
214 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
216 /* The prefix prepended by GCC to an identifier represnting the
217 anonymous namespace. */
218 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
219 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
220 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
222 /* Information we keep for the standard substitutions. */
224 struct d_standard_sub_info
226 /* The code for this substitution. */
228 /* The simple string it expands to. */
229 const char *simple_expansion
;
230 /* The length of the simple expansion. */
232 /* The results of a full, verbose, expansion. This is used when
233 qualifying a constructor/destructor, or when in verbose mode. */
234 const char *full_expansion
;
235 /* The length of the full expansion. */
237 /* What to set the last_name field of d_info to; NULL if we should
238 not set it. This is only relevant when qualifying a
239 constructor/destructor. */
240 const char *set_last_name
;
241 /* The length of set_last_name. */
242 int set_last_name_len
;
245 /* Accessors for subtrees of struct demangle_component. */
247 #define d_left(dc) ((dc)->u.s_binary.left)
248 #define d_right(dc) ((dc)->u.s_binary.right)
250 /* A list of templates. This is used while printing. */
252 struct d_print_template
254 /* Next template on the list. */
255 struct d_print_template
*next
;
257 const struct demangle_component
*template_decl
;
260 /* A list of type modifiers. This is used while printing. */
264 /* Next modifier on the list. These are in the reverse of the order
265 in which they appeared in the mangled string. */
266 struct d_print_mod
*next
;
268 const struct demangle_component
*mod
;
269 /* Whether this modifier was printed. */
271 /* The list of templates which applies to this modifier. */
272 struct d_print_template
*templates
;
275 /* We use these structures to hold information during printing. */
277 struct d_growable_string
279 /* Buffer holding the result. */
281 /* Current length of data in buffer. */
283 /* Allocated size of buffer. */
285 /* Set to 1 if we had a memory allocation failure. */
286 int allocation_failure
;
289 /* Stack of components, innermost first, used to avoid loops. */
291 struct d_component_stack
293 /* This component. */
294 const struct demangle_component
*dc
;
295 /* This component's parent. */
296 const struct d_component_stack
*parent
;
299 /* A demangle component and some scope captured when it was first
304 /* The component whose scope this is. */
305 const struct demangle_component
*container
;
306 /* The list of templates, if any, that was current when this
307 scope was captured. */
308 struct d_print_template
*templates
;
311 /* Checkpoint structure to allow backtracking. This holds copies
312 of the fields of struct d_info that need to be restored
313 if a trial parse needs to be backtracked over. */
315 struct d_info_checkpoint
324 enum { D_PRINT_BUFFER_LENGTH
= 256 };
327 /* Fixed-length allocated buffer for demangled data, flushed to the
328 callback with a NUL termination once full. */
329 char buf
[D_PRINT_BUFFER_LENGTH
];
330 /* Current length of data in buffer. */
332 /* The last character printed, saved individually so that it survives
335 /* Callback function to handle demangled buffer flush. */
336 demangle_callbackref callback
;
337 /* Opaque callback argument. */
339 /* The current list of templates, if any. */
340 struct d_print_template
*templates
;
341 /* The current list of modifiers (e.g., pointer, reference, etc.),
343 struct d_print_mod
*modifiers
;
344 /* Set to 1 if we saw a demangling error. */
345 int demangle_failure
;
346 /* The current index into any template argument packs we are using
347 for printing, or -1 to print the whole pack. */
349 /* Number of d_print_flush calls so far. */
350 unsigned long int flush_count
;
351 /* Stack of components, innermost first, used to avoid loops. */
352 const struct d_component_stack
*component_stack
;
353 /* Array of saved scopes for evaluating substitutions. */
354 struct d_saved_scope
*saved_scopes
;
355 /* Index of the next unused saved scope in the above array. */
356 int next_saved_scope
;
357 /* Number of saved scopes in the above array. */
358 int num_saved_scopes
;
359 /* Array of templates for saving into scopes. */
360 struct d_print_template
*copy_templates
;
361 /* Index of the next unused copy template in the above array. */
362 int next_copy_template
;
363 /* Number of copy templates in the above array. */
364 int num_copy_templates
;
365 /* The nearest enclosing template, if any. */
366 const struct demangle_component
*current_template
;
369 #ifdef CP_DEMANGLE_DEBUG
370 static void d_dump (struct demangle_component
*, int);
373 static struct demangle_component
*
374 d_make_empty (struct d_info
*);
376 static struct demangle_component
*
377 d_make_comp (struct d_info
*, enum demangle_component_type
,
378 struct demangle_component
*,
379 struct demangle_component
*);
381 static struct demangle_component
*
382 d_make_name (struct d_info
*, const char *, int);
384 static struct demangle_component
*
385 d_make_demangle_mangled_name (struct d_info
*, const char *);
387 static struct demangle_component
*
388 d_make_builtin_type (struct d_info
*,
389 const struct demangle_builtin_type_info
*);
391 static struct demangle_component
*
392 d_make_operator (struct d_info
*,
393 const struct demangle_operator_info
*);
395 static struct demangle_component
*
396 d_make_extended_operator (struct d_info
*, int,
397 struct demangle_component
*);
399 static struct demangle_component
*
400 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
401 struct demangle_component
*);
403 static struct demangle_component
*
404 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
405 struct demangle_component
*);
407 static struct demangle_component
*
408 d_make_template_param (struct d_info
*, int);
410 static struct demangle_component
*
411 d_make_sub (struct d_info
*, const char *, int);
414 has_return_type (struct demangle_component
*);
417 is_ctor_dtor_or_conversion (struct demangle_component
*);
419 static struct demangle_component
*d_encoding (struct d_info
*, int);
421 static struct demangle_component
*d_name (struct d_info
*);
423 static struct demangle_component
*d_nested_name (struct d_info
*);
425 static struct demangle_component
*d_prefix (struct d_info
*);
427 static struct demangle_component
*d_unqualified_name (struct d_info
*);
429 static struct demangle_component
*d_source_name (struct d_info
*);
431 static int d_number (struct d_info
*);
433 static struct demangle_component
*d_identifier (struct d_info
*, int);
435 static struct demangle_component
*d_operator_name (struct d_info
*);
437 static struct demangle_component
*d_special_name (struct d_info
*);
439 static struct demangle_component
*d_parmlist (struct d_info
*);
441 static int d_call_offset (struct d_info
*, int);
443 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
445 static struct demangle_component
**
446 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
448 static struct demangle_component
*
449 d_ref_qualifier (struct d_info
*, struct demangle_component
*);
451 static struct demangle_component
*
452 d_function_type (struct d_info
*);
454 static struct demangle_component
*
455 d_bare_function_type (struct d_info
*, int);
457 static struct demangle_component
*
458 d_class_enum_type (struct d_info
*);
460 static struct demangle_component
*d_array_type (struct d_info
*);
462 static struct demangle_component
*d_vector_type (struct d_info
*);
464 static struct demangle_component
*
465 d_pointer_to_member_type (struct d_info
*);
467 static struct demangle_component
*
468 d_template_param (struct d_info
*);
470 static struct demangle_component
*d_template_args (struct d_info
*);
471 static struct demangle_component
*d_template_args_1 (struct d_info
*);
473 static struct demangle_component
*
474 d_template_arg (struct d_info
*);
476 static struct demangle_component
*d_expression (struct d_info
*);
478 static struct demangle_component
*d_expr_primary (struct d_info
*);
480 static struct demangle_component
*d_local_name (struct d_info
*);
482 static int d_discriminator (struct d_info
*);
484 static struct demangle_component
*d_lambda (struct d_info
*);
486 static struct demangle_component
*d_unnamed_type (struct d_info
*);
488 static struct demangle_component
*
489 d_clone_suffix (struct d_info
*, struct demangle_component
*);
492 d_add_substitution (struct d_info
*, struct demangle_component
*);
494 static struct demangle_component
*d_substitution (struct d_info
*, int);
496 static void d_checkpoint (struct d_info
*, struct d_info_checkpoint
*);
498 static void d_backtrack (struct d_info
*, struct d_info_checkpoint
*);
500 static void d_growable_string_init (struct d_growable_string
*, size_t);
503 d_growable_string_resize (struct d_growable_string
*, size_t);
506 d_growable_string_append_buffer (struct d_growable_string
*,
507 const char *, size_t);
509 d_growable_string_callback_adapter (const char *, size_t, void *);
512 d_print_init (struct d_print_info
*, demangle_callbackref
, void *,
513 const struct demangle_component
*);
515 static inline void d_print_error (struct d_print_info
*);
517 static inline int d_print_saw_error (struct d_print_info
*);
519 static inline void d_print_flush (struct d_print_info
*);
521 static inline void d_append_char (struct d_print_info
*, char);
523 static inline void d_append_buffer (struct d_print_info
*,
524 const char *, size_t);
526 static inline void d_append_string (struct d_print_info
*, const char *);
528 static inline char d_last_char (struct d_print_info
*);
531 d_print_comp (struct d_print_info
*, int, const struct demangle_component
*);
534 d_print_java_identifier (struct d_print_info
*, const char *, int);
537 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
540 d_print_mod (struct d_print_info
*, int, const struct demangle_component
*);
543 d_print_function_type (struct d_print_info
*, int,
544 const struct demangle_component
*,
545 struct d_print_mod
*);
548 d_print_array_type (struct d_print_info
*, int,
549 const struct demangle_component
*,
550 struct d_print_mod
*);
553 d_print_expr_op (struct d_print_info
*, int, const struct demangle_component
*);
555 static void d_print_cast (struct d_print_info
*, int,
556 const struct demangle_component
*);
557 static void d_print_conversion (struct d_print_info
*, int,
558 const struct demangle_component
*);
560 static int d_demangle_callback (const char *, int,
561 demangle_callbackref
, void *);
562 static char *d_demangle (const char *, int, size_t *);
564 /* True iff TYPE is a demangling component representing a
565 function-type-qualifier. */
568 is_fnqual_component_type (enum demangle_component_type type
)
570 return (type
== DEMANGLE_COMPONENT_RESTRICT_THIS
571 || type
== DEMANGLE_COMPONENT_VOLATILE_THIS
572 || type
== DEMANGLE_COMPONENT_CONST_THIS
573 || type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
574 || type
== DEMANGLE_COMPONENT_TRANSACTION_SAFE
575 || type
== DEMANGLE_COMPONENT_NOEXCEPT
576 || type
== DEMANGLE_COMPONENT_THROW_SPEC
577 || type
== DEMANGLE_COMPONENT_REFERENCE_THIS
);
580 #define FNQUAL_COMPONENT_CASE \
581 case DEMANGLE_COMPONENT_RESTRICT_THIS: \
582 case DEMANGLE_COMPONENT_VOLATILE_THIS: \
583 case DEMANGLE_COMPONENT_CONST_THIS: \
584 case DEMANGLE_COMPONENT_REFERENCE_THIS: \
585 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
586 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
587 case DEMANGLE_COMPONENT_NOEXCEPT: \
588 case DEMANGLE_COMPONENT_THROW_SPEC
590 #ifdef CP_DEMANGLE_DEBUG
593 d_dump (struct demangle_component
*dc
, int indent
)
600 printf ("failed demangling\n");
604 for (i
= 0; i
< indent
; ++i
)
609 case DEMANGLE_COMPONENT_NAME
:
610 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
612 case DEMANGLE_COMPONENT_TAGGED_NAME
:
613 printf ("tagged name\n");
614 d_dump (dc
->u
.s_binary
.left
, indent
+ 2);
615 d_dump (dc
->u
.s_binary
.right
, indent
+ 2);
617 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
618 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
620 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
621 printf ("function parameter %ld\n", dc
->u
.s_number
.number
);
623 case DEMANGLE_COMPONENT_CTOR
:
624 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
625 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
627 case DEMANGLE_COMPONENT_DTOR
:
628 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
629 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
631 case DEMANGLE_COMPONENT_SUB_STD
:
632 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
634 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
635 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
637 case DEMANGLE_COMPONENT_OPERATOR
:
638 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
640 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
641 printf ("extended operator with %d args\n",
642 dc
->u
.s_extended_operator
.args
);
643 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
646 case DEMANGLE_COMPONENT_QUAL_NAME
:
647 printf ("qualified name\n");
649 case DEMANGLE_COMPONENT_LOCAL_NAME
:
650 printf ("local name\n");
652 case DEMANGLE_COMPONENT_TYPED_NAME
:
653 printf ("typed name\n");
655 case DEMANGLE_COMPONENT_TEMPLATE
:
656 printf ("template\n");
658 case DEMANGLE_COMPONENT_VTABLE
:
661 case DEMANGLE_COMPONENT_VTT
:
664 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
665 printf ("construction vtable\n");
667 case DEMANGLE_COMPONENT_TYPEINFO
:
668 printf ("typeinfo\n");
670 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
671 printf ("typeinfo name\n");
673 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
674 printf ("typeinfo function\n");
676 case DEMANGLE_COMPONENT_THUNK
:
679 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
680 printf ("virtual thunk\n");
682 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
683 printf ("covariant thunk\n");
685 case DEMANGLE_COMPONENT_JAVA_CLASS
:
686 printf ("java class\n");
688 case DEMANGLE_COMPONENT_GUARD
:
691 case DEMANGLE_COMPONENT_REFTEMP
:
692 printf ("reference temporary\n");
694 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
695 printf ("hidden alias\n");
697 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
698 printf ("transaction clone\n");
700 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
701 printf ("non-transaction clone\n");
703 case DEMANGLE_COMPONENT_RESTRICT
:
704 printf ("restrict\n");
706 case DEMANGLE_COMPONENT_VOLATILE
:
707 printf ("volatile\n");
709 case DEMANGLE_COMPONENT_CONST
:
712 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
713 printf ("restrict this\n");
715 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
716 printf ("volatile this\n");
718 case DEMANGLE_COMPONENT_CONST_THIS
:
719 printf ("const this\n");
721 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
722 printf ("reference this\n");
724 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
725 printf ("rvalue reference this\n");
727 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
728 printf ("transaction_safe this\n");
730 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
731 printf ("vendor type qualifier\n");
733 case DEMANGLE_COMPONENT_POINTER
:
734 printf ("pointer\n");
736 case DEMANGLE_COMPONENT_REFERENCE
:
737 printf ("reference\n");
739 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
740 printf ("rvalue reference\n");
742 case DEMANGLE_COMPONENT_COMPLEX
:
743 printf ("complex\n");
745 case DEMANGLE_COMPONENT_IMAGINARY
:
746 printf ("imaginary\n");
748 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
749 printf ("vendor type\n");
751 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
752 printf ("function type\n");
754 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
755 printf ("array type\n");
757 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
758 printf ("pointer to member type\n");
760 case DEMANGLE_COMPONENT_FIXED_TYPE
:
761 printf ("fixed-point type, accum? %d, sat? %d\n",
762 dc
->u
.s_fixed
.accum
, dc
->u
.s_fixed
.sat
);
763 d_dump (dc
->u
.s_fixed
.length
, indent
+ 2);
765 case DEMANGLE_COMPONENT_ARGLIST
:
766 printf ("argument list\n");
768 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
769 printf ("template argument list\n");
771 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
772 printf ("initializer list\n");
774 case DEMANGLE_COMPONENT_CAST
:
777 case DEMANGLE_COMPONENT_CONVERSION
:
778 printf ("conversion operator\n");
780 case DEMANGLE_COMPONENT_NULLARY
:
781 printf ("nullary operator\n");
783 case DEMANGLE_COMPONENT_UNARY
:
784 printf ("unary operator\n");
786 case DEMANGLE_COMPONENT_BINARY
:
787 printf ("binary operator\n");
789 case DEMANGLE_COMPONENT_BINARY_ARGS
:
790 printf ("binary operator arguments\n");
792 case DEMANGLE_COMPONENT_TRINARY
:
793 printf ("trinary operator\n");
795 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
796 printf ("trinary operator arguments 1\n");
798 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
799 printf ("trinary operator arguments 1\n");
801 case DEMANGLE_COMPONENT_LITERAL
:
802 printf ("literal\n");
804 case DEMANGLE_COMPONENT_LITERAL_NEG
:
805 printf ("negative literal\n");
807 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
808 printf ("java resource\n");
810 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
811 printf ("compound name\n");
813 case DEMANGLE_COMPONENT_CHARACTER
:
814 printf ("character '%c'\n", dc
->u
.s_character
.character
);
816 case DEMANGLE_COMPONENT_NUMBER
:
817 printf ("number %ld\n", dc
->u
.s_number
.number
);
819 case DEMANGLE_COMPONENT_DECLTYPE
:
820 printf ("decltype\n");
822 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
823 printf ("pack expansion\n");
825 case DEMANGLE_COMPONENT_TLS_INIT
:
826 printf ("tls init function\n");
828 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
829 printf ("tls wrapper function\n");
831 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
832 printf ("default argument %d\n", dc
->u
.s_unary_num
.num
);
833 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
835 case DEMANGLE_COMPONENT_LAMBDA
:
836 printf ("lambda %d\n", dc
->u
.s_unary_num
.num
);
837 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
841 d_dump (d_left (dc
), indent
+ 2);
842 d_dump (d_right (dc
), indent
+ 2);
845 #endif /* CP_DEMANGLE_DEBUG */
847 /* Fill in a DEMANGLE_COMPONENT_NAME. */
849 CP_STATIC_IF_GLIBCPP_V3
851 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
853 if (p
== NULL
|| s
== NULL
|| len
== 0)
855 p
->type
= DEMANGLE_COMPONENT_NAME
;
857 p
->u
.s_name
.len
= len
;
861 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
863 CP_STATIC_IF_GLIBCPP_V3
865 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
866 struct demangle_component
*name
)
868 if (p
== NULL
|| args
< 0 || name
== NULL
)
870 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
871 p
->u
.s_extended_operator
.args
= args
;
872 p
->u
.s_extended_operator
.name
= name
;
876 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
878 CP_STATIC_IF_GLIBCPP_V3
880 cplus_demangle_fill_ctor (struct demangle_component
*p
,
881 enum gnu_v3_ctor_kinds kind
,
882 struct demangle_component
*name
)
886 || (int) kind
< gnu_v3_complete_object_ctor
887 || (int) kind
> gnu_v3_object_ctor_group
)
889 p
->type
= DEMANGLE_COMPONENT_CTOR
;
890 p
->u
.s_ctor
.kind
= kind
;
891 p
->u
.s_ctor
.name
= name
;
895 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
897 CP_STATIC_IF_GLIBCPP_V3
899 cplus_demangle_fill_dtor (struct demangle_component
*p
,
900 enum gnu_v3_dtor_kinds kind
,
901 struct demangle_component
*name
)
905 || (int) kind
< gnu_v3_deleting_dtor
906 || (int) kind
> gnu_v3_object_dtor_group
)
908 p
->type
= DEMANGLE_COMPONENT_DTOR
;
909 p
->u
.s_dtor
.kind
= kind
;
910 p
->u
.s_dtor
.name
= name
;
914 /* Add a new component. */
916 static struct demangle_component
*
917 d_make_empty (struct d_info
*di
)
919 struct demangle_component
*p
;
921 if (di
->next_comp
>= di
->num_comps
)
923 p
= &di
->comps
[di
->next_comp
];
928 /* Add a new generic component. */
930 static struct demangle_component
*
931 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
932 struct demangle_component
*left
,
933 struct demangle_component
*right
)
935 struct demangle_component
*p
;
937 /* We check for errors here. A typical error would be a NULL return
938 from a subroutine. We catch those here, and return NULL
942 /* These types require two parameters. */
943 case DEMANGLE_COMPONENT_QUAL_NAME
:
944 case DEMANGLE_COMPONENT_LOCAL_NAME
:
945 case DEMANGLE_COMPONENT_TYPED_NAME
:
946 case DEMANGLE_COMPONENT_TAGGED_NAME
:
947 case DEMANGLE_COMPONENT_TEMPLATE
:
948 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
949 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
950 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
951 case DEMANGLE_COMPONENT_UNARY
:
952 case DEMANGLE_COMPONENT_BINARY
:
953 case DEMANGLE_COMPONENT_BINARY_ARGS
:
954 case DEMANGLE_COMPONENT_TRINARY
:
955 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
956 case DEMANGLE_COMPONENT_LITERAL
:
957 case DEMANGLE_COMPONENT_LITERAL_NEG
:
958 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
959 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
960 case DEMANGLE_COMPONENT_CLONE
:
961 if (left
== NULL
|| right
== NULL
)
965 /* These types only require one parameter. */
966 case DEMANGLE_COMPONENT_VTABLE
:
967 case DEMANGLE_COMPONENT_VTT
:
968 case DEMANGLE_COMPONENT_TYPEINFO
:
969 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
970 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
971 case DEMANGLE_COMPONENT_THUNK
:
972 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
973 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
974 case DEMANGLE_COMPONENT_JAVA_CLASS
:
975 case DEMANGLE_COMPONENT_GUARD
:
976 case DEMANGLE_COMPONENT_TLS_INIT
:
977 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
978 case DEMANGLE_COMPONENT_REFTEMP
:
979 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
980 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
981 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
982 case DEMANGLE_COMPONENT_POINTER
:
983 case DEMANGLE_COMPONENT_REFERENCE
:
984 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
985 case DEMANGLE_COMPONENT_COMPLEX
:
986 case DEMANGLE_COMPONENT_IMAGINARY
:
987 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
988 case DEMANGLE_COMPONENT_CAST
:
989 case DEMANGLE_COMPONENT_CONVERSION
:
990 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
991 case DEMANGLE_COMPONENT_DECLTYPE
:
992 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
993 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
994 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
995 case DEMANGLE_COMPONENT_NULLARY
:
996 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
1001 /* This needs a right parameter, but the left parameter can be
1003 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
1004 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
1009 /* These are allowed to have no parameters--in some cases they
1010 will be filled in later. */
1011 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
1012 case DEMANGLE_COMPONENT_RESTRICT
:
1013 case DEMANGLE_COMPONENT_VOLATILE
:
1014 case DEMANGLE_COMPONENT_CONST
:
1015 case DEMANGLE_COMPONENT_ARGLIST
:
1016 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
1017 FNQUAL_COMPONENT_CASE
:
1020 /* Other types should not be seen here. */
1025 p
= d_make_empty (di
);
1029 p
->u
.s_binary
.left
= left
;
1030 p
->u
.s_binary
.right
= right
;
1035 /* Add a new demangle mangled name component. */
1037 static struct demangle_component
*
1038 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
1040 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
1041 return d_make_name (di
, s
, strlen (s
));
1043 return d_encoding (di
, 0);
1046 /* Add a new name component. */
1048 static struct demangle_component
*
1049 d_make_name (struct d_info
*di
, const char *s
, int len
)
1051 struct demangle_component
*p
;
1053 p
= d_make_empty (di
);
1054 if (! cplus_demangle_fill_name (p
, s
, len
))
1059 /* Add a new builtin type component. */
1061 static struct demangle_component
*
1062 d_make_builtin_type (struct d_info
*di
,
1063 const struct demangle_builtin_type_info
*type
)
1065 struct demangle_component
*p
;
1069 p
= d_make_empty (di
);
1072 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
1073 p
->u
.s_builtin
.type
= type
;
1078 /* Add a new operator component. */
1080 static struct demangle_component
*
1081 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
1083 struct demangle_component
*p
;
1085 p
= d_make_empty (di
);
1088 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
1089 p
->u
.s_operator
.op
= op
;
1094 /* Add a new extended operator component. */
1096 static struct demangle_component
*
1097 d_make_extended_operator (struct d_info
*di
, int args
,
1098 struct demangle_component
*name
)
1100 struct demangle_component
*p
;
1102 p
= d_make_empty (di
);
1103 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
1108 static struct demangle_component
*
1109 d_make_default_arg (struct d_info
*di
, int num
,
1110 struct demangle_component
*sub
)
1112 struct demangle_component
*p
= d_make_empty (di
);
1115 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1116 p
->u
.s_unary_num
.num
= num
;
1117 p
->u
.s_unary_num
.sub
= sub
;
1122 /* Add a new constructor component. */
1124 static struct demangle_component
*
1125 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1126 struct demangle_component
*name
)
1128 struct demangle_component
*p
;
1130 p
= d_make_empty (di
);
1131 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1136 /* Add a new destructor component. */
1138 static struct demangle_component
*
1139 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1140 struct demangle_component
*name
)
1142 struct demangle_component
*p
;
1144 p
= d_make_empty (di
);
1145 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1150 /* Add a new template parameter. */
1152 static struct demangle_component
*
1153 d_make_template_param (struct d_info
*di
, int i
)
1155 struct demangle_component
*p
;
1157 p
= d_make_empty (di
);
1160 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1161 p
->u
.s_number
.number
= i
;
1166 /* Add a new function parameter. */
1168 static struct demangle_component
*
1169 d_make_function_param (struct d_info
*di
, int i
)
1171 struct demangle_component
*p
;
1173 p
= d_make_empty (di
);
1176 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1177 p
->u
.s_number
.number
= i
;
1182 /* Add a new standard substitution component. */
1184 static struct demangle_component
*
1185 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1187 struct demangle_component
*p
;
1189 p
= d_make_empty (di
);
1192 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1193 p
->u
.s_string
.string
= name
;
1194 p
->u
.s_string
.len
= len
;
1199 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1201 TOP_LEVEL is non-zero when called at the top level. */
1203 CP_STATIC_IF_GLIBCPP_V3
1204 struct demangle_component
*
1205 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1207 struct demangle_component
*p
;
1209 if (! d_check_char (di
, '_')
1210 /* Allow missing _ if not at toplevel to work around a
1211 bug in G++ abi-version=2 mangling; see the comment in
1212 write_template_arg. */
1215 if (! d_check_char (di
, 'Z'))
1217 p
= d_encoding (di
, top_level
);
1219 /* If at top level and parsing parameters, check for a clone
1221 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1222 while (d_peek_char (di
) == '.'
1223 && (IS_LOWER (d_peek_next_char (di
))
1224 || d_peek_next_char (di
) == '_'
1225 || IS_DIGIT (d_peek_next_char (di
))))
1226 p
= d_clone_suffix (di
, p
);
1231 /* Return whether a function should have a return type. The argument
1232 is the function name, which may be qualified in various ways. The
1233 rules are that template functions have return types with some
1234 exceptions, function types which are not part of a function name
1235 mangling have return types with some exceptions, and non-template
1236 function names do not have return types. The exceptions are that
1237 constructors, destructors, and conversion operators do not have
1241 has_return_type (struct demangle_component
*dc
)
1249 case DEMANGLE_COMPONENT_TEMPLATE
:
1250 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1251 FNQUAL_COMPONENT_CASE
:
1252 return has_return_type (d_left (dc
));
1256 /* Return whether a name is a constructor, a destructor, or a
1257 conversion operator. */
1260 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1268 case DEMANGLE_COMPONENT_QUAL_NAME
:
1269 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1270 return is_ctor_dtor_or_conversion (d_right (dc
));
1271 case DEMANGLE_COMPONENT_CTOR
:
1272 case DEMANGLE_COMPONENT_DTOR
:
1273 case DEMANGLE_COMPONENT_CONVERSION
:
1278 /* <encoding> ::= <(function) name> <bare-function-type>
1282 TOP_LEVEL is non-zero when called at the top level, in which case
1283 if DMGL_PARAMS is not set we do not demangle the function
1284 parameters. We only set this at the top level, because otherwise
1285 we would not correctly demangle names in local scopes. */
1287 static struct demangle_component
*
1288 d_encoding (struct d_info
*di
, int top_level
)
1290 char peek
= d_peek_char (di
);
1292 if (peek
== 'G' || peek
== 'T')
1293 return d_special_name (di
);
1296 struct demangle_component
*dc
;
1300 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1302 /* Strip off any initial CV-qualifiers, as they really apply
1303 to the `this' parameter, and they were not output by the
1304 v2 demangler without DMGL_PARAMS. */
1305 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1306 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1307 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
1308 || dc
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
1309 || dc
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
)
1312 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1313 there may be function-qualifiers on its right argument which
1314 really apply here; this happens when parsing a class
1315 which is local to a function. */
1316 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1318 struct demangle_component
*dcr
;
1321 while (is_fnqual_component_type (dcr
->type
))
1323 dc
->u
.s_binary
.right
= dcr
;
1329 peek
= d_peek_char (di
);
1330 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1332 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1333 d_bare_function_type (di
, has_return_type (dc
)));
1337 /* <tagged-name> ::= <name> B <source-name> */
1339 static struct demangle_component
*
1340 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1342 struct demangle_component
*hold_last_name
;
1345 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1346 hold_last_name
= di
->last_name
;
1348 while (peek
= d_peek_char (di
),
1351 struct demangle_component
*tag
;
1353 tag
= d_source_name (di
);
1354 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1357 di
->last_name
= hold_last_name
;
1362 /* <name> ::= <nested-name>
1364 ::= <unscoped-template-name> <template-args>
1367 <unscoped-name> ::= <unqualified-name>
1368 ::= St <unqualified-name>
1370 <unscoped-template-name> ::= <unscoped-name>
1374 static struct demangle_component
*
1375 d_name (struct d_info
*di
)
1377 char peek
= d_peek_char (di
);
1378 struct demangle_component
*dc
;
1383 return d_nested_name (di
);
1386 return d_local_name (di
);
1389 return d_unqualified_name (di
);
1395 if (d_peek_next_char (di
) != 't')
1397 dc
= d_substitution (di
, 0);
1403 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1404 d_make_name (di
, "std", 3),
1405 d_unqualified_name (di
));
1410 if (d_peek_char (di
) != 'I')
1412 /* The grammar does not permit this case to occur if we
1413 called d_substitution() above (i.e., subst == 1). We
1414 don't bother to check. */
1418 /* This is <template-args>, which means that we just saw
1419 <unscoped-template-name>, which is a substitution
1420 candidate if we didn't just get it from a
1424 if (! d_add_substitution (di
, dc
))
1427 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1428 d_template_args (di
));
1436 dc
= d_unqualified_name (di
);
1437 if (d_peek_char (di
) == 'I')
1439 /* This is <template-args>, which means that we just saw
1440 <unscoped-template-name>, which is a substitution
1442 if (! d_add_substitution (di
, dc
))
1444 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1445 d_template_args (di
));
1451 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1452 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1455 static struct demangle_component
*
1456 d_nested_name (struct d_info
*di
)
1458 struct demangle_component
*ret
;
1459 struct demangle_component
**pret
;
1460 struct demangle_component
*rqual
;
1462 if (! d_check_char (di
, 'N'))
1465 pret
= d_cv_qualifiers (di
, &ret
, 1);
1469 /* Parse the ref-qualifier now and then attach it
1470 once we have something to attach it to. */
1471 rqual
= d_ref_qualifier (di
, NULL
);
1473 *pret
= d_prefix (di
);
1479 d_left (rqual
) = ret
;
1483 if (! d_check_char (di
, 'E'))
1489 /* <prefix> ::= <prefix> <unqualified-name>
1490 ::= <template-prefix> <template-args>
1491 ::= <template-param>
1496 <template-prefix> ::= <prefix> <(template) unqualified-name>
1497 ::= <template-param>
1501 static struct demangle_component
*
1502 d_prefix (struct d_info
*di
)
1504 struct demangle_component
*ret
= NULL
;
1509 enum demangle_component_type comb_type
;
1510 struct demangle_component
*dc
;
1512 peek
= d_peek_char (di
);
1516 /* The older code accepts a <local-name> here, but I don't see
1517 that in the grammar. The older code does not accept a
1518 <template-param> here. */
1520 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1523 char peek2
= d_peek_next_char (di
);
1524 if (peek2
== 'T' || peek2
== 't')
1526 dc
= cplus_demangle_type (di
);
1528 /* Destructor name. */
1529 dc
= d_unqualified_name (di
);
1531 else if (IS_DIGIT (peek
)
1536 dc
= d_unqualified_name (di
);
1537 else if (peek
== 'S')
1538 dc
= d_substitution (di
, 1);
1539 else if (peek
== 'I')
1543 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1544 dc
= d_template_args (di
);
1546 else if (peek
== 'T')
1547 dc
= d_template_param (di
);
1548 else if (peek
== 'E')
1550 else if (peek
== 'M')
1552 /* Initializer scope for a lambda. We don't need to represent
1553 this; the normal code will just treat the variable as a type
1554 scope, which gives appropriate output. */
1566 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1568 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1570 if (! d_add_substitution (di
, ret
))
1576 /* <unqualified-name> ::= <operator-name>
1577 ::= <ctor-dtor-name>
1579 ::= <local-source-name>
1581 <local-source-name> ::= L <source-name> <discriminator>
1584 static struct demangle_component
*
1585 d_unqualified_name (struct d_info
*di
)
1587 struct demangle_component
*ret
;
1590 peek
= d_peek_char (di
);
1591 if (IS_DIGIT (peek
))
1592 ret
= d_source_name (di
);
1593 else if (IS_LOWER (peek
))
1595 ret
= d_operator_name (di
);
1596 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1598 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1599 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1600 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1601 d_source_name (di
));
1604 else if (peek
== 'C' || peek
== 'D')
1605 ret
= d_ctor_dtor_name (di
);
1606 else if (peek
== 'L')
1610 ret
= d_source_name (di
);
1613 if (! d_discriminator (di
))
1616 else if (peek
== 'U')
1618 switch (d_peek_next_char (di
))
1621 ret
= d_lambda (di
);
1624 ret
= d_unnamed_type (di
);
1633 if (d_peek_char (di
) == 'B')
1634 ret
= d_abi_tags (di
, ret
);
1638 /* <source-name> ::= <(positive length) number> <identifier> */
1640 static struct demangle_component
*
1641 d_source_name (struct d_info
*di
)
1644 struct demangle_component
*ret
;
1646 len
= d_number (di
);
1649 ret
= d_identifier (di
, len
);
1650 di
->last_name
= ret
;
1654 /* number ::= [n] <(non-negative decimal integer)> */
1657 d_number (struct d_info
*di
)
1664 peek
= d_peek_char (di
);
1669 peek
= d_peek_char (di
);
1675 if (! IS_DIGIT (peek
))
1681 ret
= ret
* 10 + peek
- '0';
1683 peek
= d_peek_char (di
);
1687 /* Like d_number, but returns a demangle_component. */
1689 static struct demangle_component
*
1690 d_number_component (struct d_info
*di
)
1692 struct demangle_component
*ret
= d_make_empty (di
);
1695 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1696 ret
->u
.s_number
.number
= d_number (di
);
1701 /* identifier ::= <(unqualified source code identifier)> */
1703 static struct demangle_component
*
1704 d_identifier (struct d_info
*di
, int len
)
1710 if (di
->send
- name
< len
)
1713 d_advance (di
, len
);
1715 /* A Java mangled name may have a trailing '$' if it is a C++
1716 keyword. This '$' is not included in the length count. We just
1718 if ((di
->options
& DMGL_JAVA
) != 0
1719 && d_peek_char (di
) == '$')
1722 /* Look for something which looks like a gcc encoding of an
1723 anonymous namespace, and replace it with a more user friendly
1725 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1726 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1727 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1731 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1732 if ((*s
== '.' || *s
== '_' || *s
== '$')
1735 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1736 return d_make_name (di
, "(anonymous namespace)",
1737 sizeof "(anonymous namespace)" - 1);
1741 return d_make_name (di
, name
, len
);
1744 /* operator_name ::= many different two character encodings.
1746 ::= v <digit> <source-name>
1748 This list is sorted for binary search. */
1750 #define NL(s) s, (sizeof s) - 1
1752 CP_STATIC_IF_GLIBCPP_V3
1753 const struct demangle_operator_info cplus_demangle_operators
[] =
1755 { "aN", NL ("&="), 2 },
1756 { "aS", NL ("="), 2 },
1757 { "aa", NL ("&&"), 2 },
1758 { "ad", NL ("&"), 1 },
1759 { "an", NL ("&"), 2 },
1760 { "at", NL ("alignof "), 1 },
1761 { "az", NL ("alignof "), 1 },
1762 { "cc", NL ("const_cast"), 2 },
1763 { "cl", NL ("()"), 2 },
1764 { "cm", NL (","), 2 },
1765 { "co", NL ("~"), 1 },
1766 { "dV", NL ("/="), 2 },
1767 { "da", NL ("delete[] "), 1 },
1768 { "dc", NL ("dynamic_cast"), 2 },
1769 { "de", NL ("*"), 1 },
1770 { "dl", NL ("delete "), 1 },
1771 { "ds", NL (".*"), 2 },
1772 { "dt", NL ("."), 2 },
1773 { "dv", NL ("/"), 2 },
1774 { "eO", NL ("^="), 2 },
1775 { "eo", NL ("^"), 2 },
1776 { "eq", NL ("=="), 2 },
1777 { "fL", NL ("..."), 3 },
1778 { "fR", NL ("..."), 3 },
1779 { "fl", NL ("..."), 2 },
1780 { "fr", NL ("..."), 2 },
1781 { "ge", NL (">="), 2 },
1782 { "gs", NL ("::"), 1 },
1783 { "gt", NL (">"), 2 },
1784 { "ix", NL ("[]"), 2 },
1785 { "lS", NL ("<<="), 2 },
1786 { "le", NL ("<="), 2 },
1787 { "li", NL ("operator\"\" "), 1 },
1788 { "ls", NL ("<<"), 2 },
1789 { "lt", NL ("<"), 2 },
1790 { "mI", NL ("-="), 2 },
1791 { "mL", NL ("*="), 2 },
1792 { "mi", NL ("-"), 2 },
1793 { "ml", NL ("*"), 2 },
1794 { "mm", NL ("--"), 1 },
1795 { "na", NL ("new[]"), 3 },
1796 { "ne", NL ("!="), 2 },
1797 { "ng", NL ("-"), 1 },
1798 { "nt", NL ("!"), 1 },
1799 { "nw", NL ("new"), 3 },
1800 { "oR", NL ("|="), 2 },
1801 { "oo", NL ("||"), 2 },
1802 { "or", NL ("|"), 2 },
1803 { "pL", NL ("+="), 2 },
1804 { "pl", NL ("+"), 2 },
1805 { "pm", NL ("->*"), 2 },
1806 { "pp", NL ("++"), 1 },
1807 { "ps", NL ("+"), 1 },
1808 { "pt", NL ("->"), 2 },
1809 { "qu", NL ("?"), 3 },
1810 { "rM", NL ("%="), 2 },
1811 { "rS", NL (">>="), 2 },
1812 { "rc", NL ("reinterpret_cast"), 2 },
1813 { "rm", NL ("%"), 2 },
1814 { "rs", NL (">>"), 2 },
1815 { "sP", NL ("sizeof..."), 1 },
1816 { "sZ", NL ("sizeof..."), 1 },
1817 { "sc", NL ("static_cast"), 2 },
1818 { "st", NL ("sizeof "), 1 },
1819 { "sz", NL ("sizeof "), 1 },
1820 { "tr", NL ("throw"), 0 },
1821 { "tw", NL ("throw "), 1 },
1822 { NULL
, NULL
, 0, 0 }
1825 static struct demangle_component
*
1826 d_operator_name (struct d_info
*di
)
1831 c1
= d_next_char (di
);
1832 c2
= d_next_char (di
);
1833 if (c1
== 'v' && IS_DIGIT (c2
))
1834 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1835 else if (c1
== 'c' && c2
== 'v')
1837 struct demangle_component
*type
;
1838 int was_conversion
= di
->is_conversion
;
1839 struct demangle_component
*res
;
1841 di
->is_conversion
= ! di
->is_expression
;
1842 type
= cplus_demangle_type (di
);
1843 if (di
->is_conversion
)
1844 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CONVERSION
, type
, NULL
);
1846 res
= d_make_comp (di
, DEMANGLE_COMPONENT_CAST
, type
, NULL
);
1847 di
->is_conversion
= was_conversion
;
1852 /* LOW is the inclusive lower bound. */
1854 /* HIGH is the exclusive upper bound. We subtract one to ignore
1855 the sentinel at the end of the array. */
1856 int high
= ((sizeof (cplus_demangle_operators
)
1857 / sizeof (cplus_demangle_operators
[0]))
1863 const struct demangle_operator_info
*p
;
1865 i
= low
+ (high
- low
) / 2;
1866 p
= cplus_demangle_operators
+ i
;
1868 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1869 return d_make_operator (di
, p
);
1871 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1881 static struct demangle_component
*
1882 d_make_character (struct d_info
*di
, int c
)
1884 struct demangle_component
*p
;
1885 p
= d_make_empty (di
);
1888 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1889 p
->u
.s_character
.character
= c
;
1894 static struct demangle_component
*
1895 d_java_resource (struct d_info
*di
)
1897 struct demangle_component
*p
= NULL
;
1898 struct demangle_component
*next
= NULL
;
1903 len
= d_number (di
);
1907 /* Eat the leading '_'. */
1908 if (d_next_char (di
) != '_')
1921 /* Each chunk is either a '$' escape... */
1939 next
= d_make_character (di
, c
);
1947 /* ... or a sequence of characters. */
1950 while (i
< len
&& str
[i
] && str
[i
] != '$')
1953 next
= d_make_name (di
, str
, i
);
1966 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
1972 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
1977 /* <special-name> ::= TV <type>
1981 ::= GV <(object) name>
1982 ::= T <call-offset> <(base) encoding>
1983 ::= Tc <call-offset> <call-offset> <(base) encoding>
1984 Also g++ extensions:
1985 ::= TC <type> <(offset) number> _ <(base) type>
1990 ::= Gr <resource name>
1995 static struct demangle_component
*
1996 d_special_name (struct d_info
*di
)
1998 di
->expansion
+= 20;
1999 if (d_check_char (di
, 'T'))
2001 switch (d_next_char (di
))
2005 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
2006 cplus_demangle_type (di
), NULL
);
2008 di
->expansion
-= 10;
2009 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
2010 cplus_demangle_type (di
), NULL
);
2012 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
2013 cplus_demangle_type (di
), NULL
);
2015 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
2016 cplus_demangle_type (di
), NULL
);
2019 if (! d_call_offset (di
, 'h'))
2021 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
2022 d_encoding (di
, 0), NULL
);
2025 if (! d_call_offset (di
, 'v'))
2027 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
2028 d_encoding (di
, 0), NULL
);
2031 if (! d_call_offset (di
, '\0'))
2033 if (! d_call_offset (di
, '\0'))
2035 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
2036 d_encoding (di
, 0), NULL
);
2040 struct demangle_component
*derived_type
;
2042 struct demangle_component
*base_type
;
2044 derived_type
= cplus_demangle_type (di
);
2045 offset
= d_number (di
);
2048 if (! d_check_char (di
, '_'))
2050 base_type
= cplus_demangle_type (di
);
2051 /* We don't display the offset. FIXME: We should display
2052 it in verbose mode. */
2054 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
2055 base_type
, derived_type
);
2059 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
2060 cplus_demangle_type (di
), NULL
);
2062 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
2063 cplus_demangle_type (di
), NULL
);
2066 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
2070 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
2077 else if (d_check_char (di
, 'G'))
2079 switch (d_next_char (di
))
2082 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
2086 struct demangle_component
*name
= d_name (di
);
2087 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
2088 d_number_component (di
));
2092 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
2093 d_encoding (di
, 0), NULL
);
2096 switch (d_next_char (di
))
2099 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
2100 d_encoding (di
, 0), NULL
);
2102 /* ??? The proposal is that other letters (such as 'h') stand
2103 for different variants of transaction cloning, such as
2104 compiling directly for hardware transaction support. But
2105 they still should all be transactional clones of some sort
2106 so go ahead and call them that. */
2108 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
2109 d_encoding (di
, 0), NULL
);
2113 return d_java_resource (di
);
2123 /* <call-offset> ::= h <nv-offset> _
2126 <nv-offset> ::= <(offset) number>
2128 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2130 The C parameter, if not '\0', is a character we just read which is
2131 the start of the <call-offset>.
2133 We don't display the offset information anywhere. FIXME: We should
2134 display it in verbose mode. */
2137 d_call_offset (struct d_info
*di
, int c
)
2140 c
= d_next_char (di
);
2147 if (! d_check_char (di
, '_'))
2154 if (! d_check_char (di
, '_'))
2160 /* <ctor-dtor-name> ::= C1
2168 static struct demangle_component
*
2169 d_ctor_dtor_name (struct d_info
*di
)
2171 if (di
->last_name
!= NULL
)
2173 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2174 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2175 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2176 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2178 switch (d_peek_char (di
))
2182 enum gnu_v3_ctor_kinds kind
;
2185 if (d_peek_next_char (di
) == 'I')
2191 switch (d_peek_next_char (di
))
2194 kind
= gnu_v3_complete_object_ctor
;
2197 kind
= gnu_v3_base_object_ctor
;
2200 kind
= gnu_v3_complete_object_allocating_ctor
;
2203 kind
= gnu_v3_unified_ctor
;
2206 kind
= gnu_v3_object_ctor_group
;
2215 cplus_demangle_type (di
);
2217 return d_make_ctor (di
, kind
, di
->last_name
);
2222 enum gnu_v3_dtor_kinds kind
;
2224 switch (d_peek_next_char (di
))
2227 kind
= gnu_v3_deleting_dtor
;
2230 kind
= gnu_v3_complete_object_dtor
;
2233 kind
= gnu_v3_base_object_dtor
;
2235 /* digit '3' is not used */
2237 kind
= gnu_v3_unified_dtor
;
2240 kind
= gnu_v3_object_dtor_group
;
2246 return d_make_dtor (di
, kind
, di
->last_name
);
2254 /* True iff we're looking at an order-insensitive type-qualifier, including
2255 function-type-qualifiers. */
2258 next_is_type_qual (struct d_info
*di
)
2260 char peek
= d_peek_char (di
);
2261 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2265 peek
= d_peek_next_char (di
);
2266 if (peek
== 'x' || peek
== 'o' || peek
== 'O' || peek
== 'w')
2272 /* <type> ::= <builtin-type>
2274 ::= <class-enum-type>
2276 ::= <pointer-to-member-type>
2277 ::= <template-param>
2278 ::= <template-template-param> <template-args>
2280 ::= <CV-qualifiers> <type>
2283 ::= O <type> (C++0x)
2286 ::= U <source-name> <type>
2288 <builtin-type> ::= various one letter codes
2292 CP_STATIC_IF_GLIBCPP_V3
2293 const struct demangle_builtin_type_info
2294 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2296 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2297 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2298 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2299 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2300 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2301 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2302 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2303 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2304 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2305 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2306 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2307 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2308 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2309 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2310 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2312 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2313 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2314 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2315 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2316 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2317 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2318 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2319 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2320 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2321 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2322 D_PRINT_UNSIGNED_LONG_LONG
},
2323 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2324 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2325 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2326 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2327 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2328 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2329 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2330 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2334 CP_STATIC_IF_GLIBCPP_V3
2335 struct demangle_component
*
2336 cplus_demangle_type (struct d_info
*di
)
2339 struct demangle_component
*ret
;
2342 /* The ABI specifies that when CV-qualifiers are used, the base type
2343 is substitutable, and the fully qualified type is substitutable,
2344 but the base type with a strict subset of the CV-qualifiers is
2345 not substitutable. The natural recursive implementation of the
2346 CV-qualifiers would cause subsets to be substitutable, so instead
2347 we pull them all off now.
2349 FIXME: The ABI says that order-insensitive vendor qualifiers
2350 should be handled in the same way, but we have no way to tell
2351 which vendor qualifiers are order-insensitive and which are
2352 order-sensitive. So we just assume that they are all
2353 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2354 __vector, and it treats it as order-sensitive when mangling
2357 if (next_is_type_qual (di
))
2359 struct demangle_component
**pret
;
2361 pret
= d_cv_qualifiers (di
, &ret
, 0);
2364 if (d_peek_char (di
) == 'F')
2366 /* cv-qualifiers before a function type apply to 'this',
2367 so avoid adding the unqualified function type to
2368 the substitution list. */
2369 *pret
= d_function_type (di
);
2372 *pret
= cplus_demangle_type (di
);
2375 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2376 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2378 /* Move the ref-qualifier outside the cv-qualifiers so that
2379 they are printed in the right order. */
2380 struct demangle_component
*fn
= d_left (*pret
);
2381 d_left (*pret
) = ret
;
2385 if (! d_add_substitution (di
, ret
))
2392 peek
= d_peek_char (di
);
2395 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2396 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2397 case 'o': case 's': case 't':
2398 case 'v': case 'w': case 'x': case 'y': case 'z':
2399 ret
= d_make_builtin_type (di
,
2400 &cplus_demangle_builtin_types
[peek
- 'a']);
2401 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2408 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2409 d_source_name (di
), NULL
);
2413 ret
= d_function_type (di
);
2416 case '0': case '1': case '2': case '3': case '4':
2417 case '5': case '6': case '7': case '8': case '9':
2420 ret
= d_class_enum_type (di
);
2424 ret
= d_array_type (di
);
2428 ret
= d_pointer_to_member_type (di
);
2432 ret
= d_template_param (di
);
2433 if (d_peek_char (di
) == 'I')
2435 /* This may be <template-template-param> <template-args>.
2436 If this is the type for a conversion operator, we can
2437 have a <template-template-param> here only by following
2438 a derivation like this:
2441 -> <template-prefix> <template-args>
2442 -> <prefix> <template-unqualified-name> <template-args>
2443 -> <unqualified-name> <template-unqualified-name> <template-args>
2444 -> <source-name> <template-unqualified-name> <template-args>
2445 -> <source-name> <operator-name> <template-args>
2446 -> <source-name> cv <type> <template-args>
2447 -> <source-name> cv <template-template-param> <template-args> <template-args>
2449 where the <template-args> is followed by another.
2450 Otherwise, we must have a derivation like this:
2453 -> <template-prefix> <template-args>
2454 -> <prefix> <template-unqualified-name> <template-args>
2455 -> <unqualified-name> <template-unqualified-name> <template-args>
2456 -> <source-name> <template-unqualified-name> <template-args>
2457 -> <source-name> <operator-name> <template-args>
2458 -> <source-name> cv <type> <template-args>
2459 -> <source-name> cv <template-param> <template-args>
2461 where we need to leave the <template-args> to be processed
2462 by d_prefix (following the <template-prefix>).
2464 The <template-template-param> part is a substitution
2466 if (! di
->is_conversion
)
2468 if (! d_add_substitution (di
, ret
))
2470 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2471 d_template_args (di
));
2475 struct demangle_component
*args
;
2476 struct d_info_checkpoint checkpoint
;
2478 d_checkpoint (di
, &checkpoint
);
2479 args
= d_template_args (di
);
2480 if (d_peek_char (di
) == 'I')
2482 if (! d_add_substitution (di
, ret
))
2484 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2488 d_backtrack (di
, &checkpoint
);
2494 /* If this is a special substitution, then it is the start of
2495 <class-enum-type>. */
2499 peek_next
= d_peek_next_char (di
);
2500 if (IS_DIGIT (peek_next
)
2502 || IS_UPPER (peek_next
))
2504 ret
= d_substitution (di
, 0);
2505 /* The substituted name may have been a template name and
2506 may be followed by tepmlate args. */
2507 if (d_peek_char (di
) == 'I')
2508 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2509 d_template_args (di
));
2515 ret
= d_class_enum_type (di
);
2516 /* If the substitution was a complete type, then it is not
2517 a new substitution candidate. However, if the
2518 substitution was followed by template arguments, then
2519 the whole thing is a substitution candidate. */
2520 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2528 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2529 cplus_demangle_type (di
), NULL
);
2534 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2535 cplus_demangle_type (di
), NULL
);
2540 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2541 cplus_demangle_type (di
), NULL
);
2546 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2547 cplus_demangle_type (di
), NULL
);
2552 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2553 cplus_demangle_type (di
), NULL
);
2558 ret
= d_source_name (di
);
2559 if (d_peek_char (di
) == 'I')
2560 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2561 d_template_args (di
));
2562 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2563 cplus_demangle_type (di
), ret
);
2569 peek
= d_next_char (di
);
2574 /* decltype (expression) */
2575 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2576 d_expression (di
), NULL
);
2577 if (ret
&& d_next_char (di
) != 'E')
2583 /* Pack expansion. */
2584 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2585 cplus_demangle_type (di
), NULL
);
2591 ret
= d_make_name (di
, "auto", 4);
2595 /* 32-bit decimal floating point */
2596 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2597 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2601 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2602 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2606 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2607 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2610 /* 16-bit half-precision FP */
2611 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2612 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2616 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2617 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2621 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2622 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2626 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2627 ret
= d_make_empty (di
);
2628 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2629 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2630 /* For demangling we don't care about the bits. */
2632 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2633 if (ret
->u
.s_fixed
.length
== NULL
)
2636 peek
= d_next_char (di
);
2637 ret
->u
.s_fixed
.sat
= (peek
== 's');
2641 ret
= d_vector_type (di
);
2646 /* decltype(nullptr) */
2647 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2648 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2662 if (! d_add_substitution (di
, ret
))
2669 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2671 static struct demangle_component
**
2672 d_cv_qualifiers (struct d_info
*di
,
2673 struct demangle_component
**pret
, int member_fn
)
2675 struct demangle_component
**pstart
;
2679 peek
= d_peek_char (di
);
2680 while (next_is_type_qual (di
))
2682 enum demangle_component_type t
;
2683 struct demangle_component
*right
= NULL
;
2689 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2690 : DEMANGLE_COMPONENT_RESTRICT
);
2691 di
->expansion
+= sizeof "restrict";
2693 else if (peek
== 'V')
2696 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2697 : DEMANGLE_COMPONENT_VOLATILE
);
2698 di
->expansion
+= sizeof "volatile";
2700 else if (peek
== 'K')
2703 ? DEMANGLE_COMPONENT_CONST_THIS
2704 : DEMANGLE_COMPONENT_CONST
);
2705 di
->expansion
+= sizeof "const";
2709 peek
= d_next_char (di
);
2712 t
= DEMANGLE_COMPONENT_TRANSACTION_SAFE
;
2713 di
->expansion
+= sizeof "transaction_safe";
2715 else if (peek
== 'o'
2718 t
= DEMANGLE_COMPONENT_NOEXCEPT
;
2719 di
->expansion
+= sizeof "noexcept";
2722 right
= d_expression (di
);
2725 if (! d_check_char (di
, 'E'))
2729 else if (peek
== 'w')
2731 t
= DEMANGLE_COMPONENT_THROW_SPEC
;
2732 di
->expansion
+= sizeof "throw";
2733 right
= d_parmlist (di
);
2736 if (! d_check_char (di
, 'E'))
2743 *pret
= d_make_comp (di
, t
, NULL
, right
);
2746 pret
= &d_left (*pret
);
2748 peek
= d_peek_char (di
);
2751 if (!member_fn
&& peek
== 'F')
2753 while (pstart
!= pret
)
2755 switch ((*pstart
)->type
)
2757 case DEMANGLE_COMPONENT_RESTRICT
:
2758 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2760 case DEMANGLE_COMPONENT_VOLATILE
:
2761 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2763 case DEMANGLE_COMPONENT_CONST
:
2764 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2769 pstart
= &d_left (*pstart
);
2776 /* <ref-qualifier> ::= R
2779 static struct demangle_component
*
2780 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2782 struct demangle_component
*ret
= sub
;
2785 peek
= d_peek_char (di
);
2786 if (peek
== 'R' || peek
== 'O')
2788 enum demangle_component_type t
;
2791 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2792 di
->expansion
+= sizeof "&";
2796 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2797 di
->expansion
+= sizeof "&&";
2801 ret
= d_make_comp (di
, t
, ret
, NULL
);
2807 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2809 static struct demangle_component
*
2810 d_function_type (struct d_info
*di
)
2812 struct demangle_component
*ret
;
2814 if (! d_check_char (di
, 'F'))
2816 if (d_peek_char (di
) == 'Y')
2818 /* Function has C linkage. We don't print this information.
2819 FIXME: We should print it in verbose mode. */
2822 ret
= d_bare_function_type (di
, 1);
2823 ret
= d_ref_qualifier (di
, ret
);
2825 if (! d_check_char (di
, 'E'))
2832 static struct demangle_component
*
2833 d_parmlist (struct d_info
*di
)
2835 struct demangle_component
*tl
;
2836 struct demangle_component
**ptl
;
2842 struct demangle_component
*type
;
2844 char peek
= d_peek_char (di
);
2845 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2847 if ((peek
== 'R' || peek
== 'O')
2848 && d_peek_next_char (di
) == 'E')
2849 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2851 type
= cplus_demangle_type (di
);
2854 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2857 ptl
= &d_right (*ptl
);
2860 /* There should be at least one parameter type besides the optional
2861 return type. A function which takes no arguments will have a
2862 single parameter type void. */
2866 /* If we have a single parameter type void, omit it. */
2867 if (d_right (tl
) == NULL
2868 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2869 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2871 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2878 /* <bare-function-type> ::= [J]<type>+ */
2880 static struct demangle_component
*
2881 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2883 struct demangle_component
*return_type
;
2884 struct demangle_component
*tl
;
2887 /* Detect special qualifier indicating that the first argument
2888 is the return type. */
2889 peek
= d_peek_char (di
);
2893 has_return_type
= 1;
2896 if (has_return_type
)
2898 return_type
= cplus_demangle_type (di
);
2899 if (return_type
== NULL
)
2905 tl
= d_parmlist (di
);
2909 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2913 /* <class-enum-type> ::= <name> */
2915 static struct demangle_component
*
2916 d_class_enum_type (struct d_info
*di
)
2921 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2922 ::= A [<(dimension) expression>] _ <(element) type>
2925 static struct demangle_component
*
2926 d_array_type (struct d_info
*di
)
2929 struct demangle_component
*dim
;
2931 if (! d_check_char (di
, 'A'))
2934 peek
= d_peek_char (di
);
2937 else if (IS_DIGIT (peek
))
2945 peek
= d_peek_char (di
);
2947 while (IS_DIGIT (peek
));
2948 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2954 dim
= d_expression (di
);
2959 if (! d_check_char (di
, '_'))
2962 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2963 cplus_demangle_type (di
));
2966 /* <vector-type> ::= Dv <number> _ <type>
2967 ::= Dv _ <expression> _ <type> */
2969 static struct demangle_component
*
2970 d_vector_type (struct d_info
*di
)
2973 struct demangle_component
*dim
;
2975 peek
= d_peek_char (di
);
2979 dim
= d_expression (di
);
2982 dim
= d_number_component (di
);
2987 if (! d_check_char (di
, '_'))
2990 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
2991 cplus_demangle_type (di
));
2994 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2996 static struct demangle_component
*
2997 d_pointer_to_member_type (struct d_info
*di
)
2999 struct demangle_component
*cl
;
3000 struct demangle_component
*mem
;
3002 if (! d_check_char (di
, 'M'))
3005 cl
= cplus_demangle_type (di
);
3009 /* The ABI says, "The type of a non-static member function is considered
3010 to be different, for the purposes of substitution, from the type of a
3011 namespace-scope or static member function whose type appears
3012 similar. The types of two non-static member functions are considered
3013 to be different, for the purposes of substitution, if the functions
3014 are members of different classes. In other words, for the purposes of
3015 substitution, the class of which the function is a member is
3016 considered part of the type of function."
3018 For a pointer to member function, this call to cplus_demangle_type
3019 will end up adding a (possibly qualified) non-member function type to
3020 the substitution table, which is not correct; however, the member
3021 function type will never be used in a substitution, so putting the
3022 wrong type in the substitution table is harmless. */
3024 mem
= cplus_demangle_type (di
);
3028 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
3031 /* <non-negative number> _ */
3034 d_compact_number (struct d_info
*di
)
3037 if (d_peek_char (di
) == '_')
3039 else if (d_peek_char (di
) == 'n')
3042 num
= d_number (di
) + 1;
3044 if (num
< 0 || ! d_check_char (di
, '_'))
3049 /* <template-param> ::= T_
3050 ::= T <(parameter-2 non-negative) number> _
3053 static struct demangle_component
*
3054 d_template_param (struct d_info
*di
)
3058 if (! d_check_char (di
, 'T'))
3061 param
= d_compact_number (di
);
3067 return d_make_template_param (di
, param
);
3070 /* <template-args> ::= I <template-arg>+ E */
3072 static struct demangle_component
*
3073 d_template_args (struct d_info
*di
)
3075 if (d_peek_char (di
) != 'I'
3076 && d_peek_char (di
) != 'J')
3080 return d_template_args_1 (di
);
3083 /* <template-arg>* E */
3085 static struct demangle_component
*
3086 d_template_args_1 (struct d_info
*di
)
3088 struct demangle_component
*hold_last_name
;
3089 struct demangle_component
*al
;
3090 struct demangle_component
**pal
;
3092 /* Preserve the last name we saw--don't let the template arguments
3093 clobber it, as that would give us the wrong name for a subsequent
3094 constructor or destructor. */
3095 hold_last_name
= di
->last_name
;
3097 if (d_peek_char (di
) == 'E')
3099 /* An argument pack can be empty. */
3101 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
3108 struct demangle_component
*a
;
3110 a
= d_template_arg (di
);
3114 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
3117 pal
= &d_right (*pal
);
3119 if (d_peek_char (di
) == 'E')
3126 di
->last_name
= hold_last_name
;
3131 /* <template-arg> ::= <type>
3132 ::= X <expression> E
3136 static struct demangle_component
*
3137 d_template_arg (struct d_info
*di
)
3139 struct demangle_component
*ret
;
3141 switch (d_peek_char (di
))
3145 ret
= d_expression (di
);
3146 if (! d_check_char (di
, 'E'))
3151 return d_expr_primary (di
);
3155 /* An argument pack. */
3156 return d_template_args (di
);
3159 return cplus_demangle_type (di
);
3163 /* Parse a sequence of expressions until we hit the terminator
3166 static struct demangle_component
*
3167 d_exprlist (struct d_info
*di
, char terminator
)
3169 struct demangle_component
*list
= NULL
;
3170 struct demangle_component
**p
= &list
;
3172 if (d_peek_char (di
) == terminator
)
3175 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
3180 struct demangle_component
*arg
= d_expression (di
);
3184 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
3189 if (d_peek_char (di
) == terminator
)
3199 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3200 dynamic_cast, static_cast or reinterpret_cast. */
3203 op_is_new_cast (struct demangle_component
*op
)
3205 const char *code
= op
->u
.s_operator
.op
->code
;
3206 return (code
[1] == 'c'
3207 && (code
[0] == 's' || code
[0] == 'd'
3208 || code
[0] == 'c' || code
[0] == 'r'));
3211 /* <expression> ::= <(unary) operator-name> <expression>
3212 ::= <(binary) operator-name> <expression> <expression>
3213 ::= <(trinary) operator-name> <expression> <expression> <expression>
3214 ::= cl <expression>+ E
3216 ::= <template-param>
3217 ::= sr <type> <unqualified-name>
3218 ::= sr <type> <unqualified-name> <template-args>
3222 static inline struct demangle_component
*
3223 d_expression_1 (struct d_info
*di
)
3227 peek
= d_peek_char (di
);
3229 return d_expr_primary (di
);
3230 else if (peek
== 'T')
3231 return d_template_param (di
);
3232 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
3234 struct demangle_component
*type
;
3235 struct demangle_component
*name
;
3238 type
= cplus_demangle_type (di
);
3239 name
= d_unqualified_name (di
);
3240 if (d_peek_char (di
) != 'I')
3241 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
3243 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
3244 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3245 d_template_args (di
)));
3247 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3250 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3251 d_expression_1 (di
), NULL
);
3253 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3255 /* Function parameter used in a late-specified return type. */
3258 if (d_peek_char (di
) == 'T')
3260 /* 'this' parameter. */
3266 index
= d_compact_number (di
);
3267 if (index
== INT_MAX
|| index
== -1)
3271 return d_make_function_param (di
, index
);
3273 else if (IS_DIGIT (peek
)
3274 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3276 /* We can get an unqualified name as an expression in the case of
3277 a dependent function call, i.e. decltype(f(t)). */
3278 struct demangle_component
*name
;
3281 /* operator-function-id, i.e. operator+(t). */
3284 name
= d_unqualified_name (di
);
3287 if (d_peek_char (di
) == 'I')
3288 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3289 d_template_args (di
));
3293 else if ((peek
== 'i' || peek
== 't')
3294 && d_peek_next_char (di
) == 'l')
3296 /* Brace-enclosed initializer list, untyped or typed. */
3297 struct demangle_component
*type
= NULL
;
3299 type
= cplus_demangle_type (di
);
3300 if (!d_peek_next_char (di
))
3303 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3304 type
, d_exprlist (di
, 'E'));
3308 struct demangle_component
*op
;
3309 const char *code
= NULL
;
3312 op
= d_operator_name (di
);
3316 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3318 code
= op
->u
.s_operator
.op
->code
;
3319 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3320 if (strcmp (code
, "st") == 0)
3321 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3322 cplus_demangle_type (di
));
3329 case DEMANGLE_COMPONENT_OPERATOR
:
3330 args
= op
->u
.s_operator
.op
->args
;
3332 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3333 args
= op
->u
.s_extended_operator
.args
;
3335 case DEMANGLE_COMPONENT_CAST
:
3343 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3347 struct demangle_component
*operand
;
3350 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3351 && code
[1] == code
[0])
3352 /* pp_ and mm_ are the prefix variants. */
3353 suffix
= !d_check_char (di
, '_');
3355 if (op
->type
== DEMANGLE_COMPONENT_CAST
3356 && d_check_char (di
, '_'))
3357 operand
= d_exprlist (di
, 'E');
3358 else if (code
&& !strcmp (code
, "sP"))
3359 operand
= d_template_args_1 (di
);
3361 operand
= d_expression_1 (di
);
3364 /* Indicate the suffix variant for d_print_comp. */
3365 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3367 DEMANGLE_COMPONENT_BINARY_ARGS
,
3370 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3375 struct demangle_component
*left
;
3376 struct demangle_component
*right
;
3380 if (op_is_new_cast (op
))
3381 left
= cplus_demangle_type (di
);
3382 else if (code
[0] == 'f')
3383 /* fold-expression. */
3384 left
= d_operator_name (di
);
3386 left
= d_expression_1 (di
);
3387 if (!strcmp (code
, "cl"))
3388 right
= d_exprlist (di
, 'E');
3389 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3391 right
= d_unqualified_name (di
);
3392 if (d_peek_char (di
) == 'I')
3393 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3394 right
, d_template_args (di
));
3397 right
= d_expression_1 (di
);
3399 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3401 DEMANGLE_COMPONENT_BINARY_ARGS
,
3406 struct demangle_component
*first
;
3407 struct demangle_component
*second
;
3408 struct demangle_component
*third
;
3412 else if (!strcmp (code
, "qu"))
3414 /* ?: expression. */
3415 first
= d_expression_1 (di
);
3416 second
= d_expression_1 (di
);
3417 third
= d_expression_1 (di
);
3419 else if (code
[0] == 'f')
3421 /* fold-expression. */
3422 first
= d_operator_name (di
);
3423 second
= d_expression_1 (di
);
3424 third
= d_expression_1 (di
);
3426 else if (code
[0] == 'n')
3428 /* new-expression. */
3429 if (code
[1] != 'w' && code
[1] != 'a')
3431 first
= d_exprlist (di
, '_');
3432 second
= cplus_demangle_type (di
);
3433 if (d_peek_char (di
) == 'E')
3438 else if (d_peek_char (di
) == 'p'
3439 && d_peek_next_char (di
) == 'i')
3441 /* Parenthesized initializer. */
3443 third
= d_exprlist (di
, 'E');
3445 else if (d_peek_char (di
) == 'i'
3446 && d_peek_next_char (di
) == 'l')
3447 /* initializer-list. */
3448 third
= d_expression_1 (di
);
3454 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3456 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3459 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3468 static struct demangle_component
*
3469 d_expression (struct d_info
*di
)
3471 struct demangle_component
*ret
;
3472 int was_expression
= di
->is_expression
;
3474 di
->is_expression
= 1;
3475 ret
= d_expression_1 (di
);
3476 di
->is_expression
= was_expression
;
3480 /* <expr-primary> ::= L <type> <(value) number> E
3481 ::= L <type> <(value) float> E
3482 ::= L <mangled-name> E
3485 static struct demangle_component
*
3486 d_expr_primary (struct d_info
*di
)
3488 struct demangle_component
*ret
;
3490 if (! d_check_char (di
, 'L'))
3492 if (d_peek_char (di
) == '_'
3493 /* Workaround for G++ bug; see comment in write_template_arg. */
3494 || d_peek_char (di
) == 'Z')
3495 ret
= cplus_demangle_mangled_name (di
, 0);
3498 struct demangle_component
*type
;
3499 enum demangle_component_type t
;
3502 type
= cplus_demangle_type (di
);
3506 /* If we have a type we know how to print, we aren't going to
3507 print the type name itself. */
3508 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3509 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3510 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3512 /* Rather than try to interpret the literal value, we just
3513 collect it as a string. Note that it's possible to have a
3514 floating point literal here. The ABI specifies that the
3515 format of such literals is machine independent. That's fine,
3516 but what's not fine is that versions of g++ up to 3.2 with
3517 -fabi-version=1 used upper case letters in the hex constant,
3518 and dumped out gcc's internal representation. That makes it
3519 hard to tell where the constant ends, and hard to dump the
3520 constant in any readable form anyhow. We don't attempt to
3521 handle these cases. */
3523 t
= DEMANGLE_COMPONENT_LITERAL
;
3524 if (d_peek_char (di
) == 'n')
3526 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3530 while (d_peek_char (di
) != 'E')
3532 if (d_peek_char (di
) == '\0')
3536 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3538 if (! d_check_char (di
, 'E'))
3543 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3544 ::= Z <(function) encoding> E s [<discriminator>]
3545 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3548 static struct demangle_component
*
3549 d_local_name (struct d_info
*di
)
3551 struct demangle_component
*function
;
3553 if (! d_check_char (di
, 'Z'))
3556 function
= d_encoding (di
, 0);
3558 if (! d_check_char (di
, 'E'))
3561 if (d_peek_char (di
) == 's')
3564 if (! d_discriminator (di
))
3566 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
3567 d_make_name (di
, "string literal",
3568 sizeof "string literal" - 1));
3572 struct demangle_component
*name
;
3575 if (d_peek_char (di
) == 'd')
3577 /* Default argument scope: d <number> _. */
3579 num
= d_compact_number (di
);
3588 /* Lambdas and unnamed types have internal discriminators. */
3589 case DEMANGLE_COMPONENT_LAMBDA
:
3590 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3593 if (! d_discriminator (di
))
3597 name
= d_make_default_arg (di
, num
, name
);
3598 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3602 /* <discriminator> ::= _ <(non-negative) number>
3604 We demangle the discriminator, but we don't print it out. FIXME:
3605 We should print it out in verbose mode. */
3608 d_discriminator (struct d_info
*di
)
3612 if (d_peek_char (di
) != '_')
3615 discrim
= d_number (di
);
3621 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3623 static struct demangle_component
*
3624 d_lambda (struct d_info
*di
)
3626 struct demangle_component
*tl
;
3627 struct demangle_component
*ret
;
3630 if (! d_check_char (di
, 'U'))
3632 if (! d_check_char (di
, 'l'))
3635 tl
= d_parmlist (di
);
3639 if (! d_check_char (di
, 'E'))
3642 num
= d_compact_number (di
);
3646 ret
= d_make_empty (di
);
3649 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3650 ret
->u
.s_unary_num
.sub
= tl
;
3651 ret
->u
.s_unary_num
.num
= num
;
3654 if (! d_add_substitution (di
, ret
))
3660 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3662 static struct demangle_component
*
3663 d_unnamed_type (struct d_info
*di
)
3665 struct demangle_component
*ret
;
3668 if (! d_check_char (di
, 'U'))
3670 if (! d_check_char (di
, 't'))
3673 num
= d_compact_number (di
);
3677 ret
= d_make_empty (di
);
3680 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3681 ret
->u
.s_number
.number
= num
;
3684 if (! d_add_substitution (di
, ret
))
3690 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3693 static struct demangle_component
*
3694 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3696 const char *suffix
= d_str (di
);
3697 const char *pend
= suffix
;
3698 struct demangle_component
*n
;
3700 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3703 while (IS_LOWER (*pend
) || *pend
== '_')
3706 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3709 while (IS_DIGIT (*pend
))
3712 d_advance (di
, pend
- suffix
);
3713 n
= d_make_name (di
, suffix
, pend
- suffix
);
3714 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3717 /* Add a new substitution. */
3720 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3724 if (di
->next_sub
>= di
->num_subs
)
3726 di
->subs
[di
->next_sub
] = dc
;
3731 /* <substitution> ::= S <seq-id> _
3741 If PREFIX is non-zero, then this type is being used as a prefix in
3742 a qualified name. In this case, for the standard substitutions, we
3743 need to check whether we are being used as a prefix for a
3744 constructor or destructor, and return a full template name.
3745 Otherwise we will get something like std::iostream::~iostream()
3746 which does not correspond particularly well to any function which
3747 actually appears in the source.
3750 static const struct d_standard_sub_info standard_subs
[] =
3755 { 'a', NL ("std::allocator"),
3756 NL ("std::allocator"),
3758 { 'b', NL ("std::basic_string"),
3759 NL ("std::basic_string"),
3760 NL ("basic_string") },
3761 { 's', NL ("std::string"),
3762 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3763 NL ("basic_string") },
3764 { 'i', NL ("std::istream"),
3765 NL ("std::basic_istream<char, std::char_traits<char> >"),
3766 NL ("basic_istream") },
3767 { 'o', NL ("std::ostream"),
3768 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3769 NL ("basic_ostream") },
3770 { 'd', NL ("std::iostream"),
3771 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3772 NL ("basic_iostream") }
3775 static struct demangle_component
*
3776 d_substitution (struct d_info
*di
, int prefix
)
3780 if (! d_check_char (di
, 'S'))
3783 c
= d_next_char (di
);
3784 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3793 unsigned int new_id
;
3796 new_id
= id
* 36 + c
- '0';
3797 else if (IS_UPPER (c
))
3798 new_id
= id
* 36 + c
- 'A' + 10;
3804 c
= d_next_char (di
);
3811 if (id
>= (unsigned int) di
->next_sub
)
3816 return di
->subs
[id
];
3821 const struct d_standard_sub_info
*p
;
3822 const struct d_standard_sub_info
*pend
;
3824 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3825 if (! verbose
&& prefix
)
3829 peek
= d_peek_char (di
);
3830 if (peek
== 'C' || peek
== 'D')
3834 pend
= (&standard_subs
[0]
3835 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3836 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3842 struct demangle_component
*dc
;
3844 if (p
->set_last_name
!= NULL
)
3845 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3846 p
->set_last_name_len
);
3849 s
= p
->full_expansion
;
3854 s
= p
->simple_expansion
;
3855 len
= p
->simple_len
;
3857 di
->expansion
+= len
;
3858 dc
= d_make_sub (di
, s
, len
);
3859 if (d_peek_char (di
) == 'B')
3861 /* If there are ABI tags on the abbreviation, it becomes
3862 a substitution candidate. */
3863 dc
= d_abi_tags (di
, dc
);
3864 d_add_substitution (di
, dc
);
3875 d_checkpoint (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3877 checkpoint
->n
= di
->n
;
3878 checkpoint
->next_comp
= di
->next_comp
;
3879 checkpoint
->next_sub
= di
->next_sub
;
3880 checkpoint
->did_subs
= di
->did_subs
;
3881 checkpoint
->expansion
= di
->expansion
;
3885 d_backtrack (struct d_info
*di
, struct d_info_checkpoint
*checkpoint
)
3887 di
->n
= checkpoint
->n
;
3888 di
->next_comp
= checkpoint
->next_comp
;
3889 di
->next_sub
= checkpoint
->next_sub
;
3890 di
->did_subs
= checkpoint
->did_subs
;
3891 di
->expansion
= checkpoint
->expansion
;
3894 /* Initialize a growable string. */
3897 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3902 dgs
->allocation_failure
= 0;
3905 d_growable_string_resize (dgs
, estimate
);
3908 /* Grow a growable string to a given size. */
3911 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
3916 if (dgs
->allocation_failure
)
3919 /* Start allocation at two bytes to avoid any possibility of confusion
3920 with the special value of 1 used as a return in *palc to indicate
3921 allocation failures. */
3922 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
3923 while (newalc
< need
)
3926 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
3933 dgs
->allocation_failure
= 1;
3940 /* Append a buffer to a growable string. */
3943 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
3944 const char *s
, size_t l
)
3948 need
= dgs
->len
+ l
+ 1;
3949 if (need
> dgs
->alc
)
3950 d_growable_string_resize (dgs
, need
);
3952 if (dgs
->allocation_failure
)
3955 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
3956 dgs
->buf
[dgs
->len
+ l
] = '\0';
3960 /* Bridge growable strings to the callback mechanism. */
3963 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
3965 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
3967 d_growable_string_append_buffer (dgs
, s
, l
);
3970 /* Walk the tree, counting the number of templates encountered, and
3971 the number of times a scope might be saved. These counts will be
3972 used to allocate data structures for d_print_comp, so the logic
3973 here must mirror the logic d_print_comp will use. It is not
3974 important that the resulting numbers are exact, so long as they
3975 are larger than the actual numbers encountered. */
3978 d_count_templates_scopes (int *num_templates
, int *num_scopes
,
3979 const struct demangle_component
*dc
)
3986 case DEMANGLE_COMPONENT_NAME
:
3987 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3988 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
3989 case DEMANGLE_COMPONENT_SUB_STD
:
3990 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3991 case DEMANGLE_COMPONENT_OPERATOR
:
3992 case DEMANGLE_COMPONENT_CHARACTER
:
3993 case DEMANGLE_COMPONENT_NUMBER
:
3994 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3997 case DEMANGLE_COMPONENT_TEMPLATE
:
3999 goto recurse_left_right
;
4001 case DEMANGLE_COMPONENT_REFERENCE
:
4002 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4003 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4005 goto recurse_left_right
;
4007 case DEMANGLE_COMPONENT_QUAL_NAME
:
4008 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4009 case DEMANGLE_COMPONENT_TYPED_NAME
:
4010 case DEMANGLE_COMPONENT_VTABLE
:
4011 case DEMANGLE_COMPONENT_VTT
:
4012 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4013 case DEMANGLE_COMPONENT_TYPEINFO
:
4014 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4015 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4016 case DEMANGLE_COMPONENT_THUNK
:
4017 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4018 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4019 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4020 case DEMANGLE_COMPONENT_GUARD
:
4021 case DEMANGLE_COMPONENT_TLS_INIT
:
4022 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4023 case DEMANGLE_COMPONENT_REFTEMP
:
4024 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4025 case DEMANGLE_COMPONENT_RESTRICT
:
4026 case DEMANGLE_COMPONENT_VOLATILE
:
4027 case DEMANGLE_COMPONENT_CONST
:
4028 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4029 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4030 case DEMANGLE_COMPONENT_CONST_THIS
:
4031 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4032 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4033 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
4034 case DEMANGLE_COMPONENT_NOEXCEPT
:
4035 case DEMANGLE_COMPONENT_THROW_SPEC
:
4036 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4037 case DEMANGLE_COMPONENT_POINTER
:
4038 case DEMANGLE_COMPONENT_COMPLEX
:
4039 case DEMANGLE_COMPONENT_IMAGINARY
:
4040 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4041 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4042 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4043 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4044 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4045 case DEMANGLE_COMPONENT_ARGLIST
:
4046 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4047 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4048 case DEMANGLE_COMPONENT_CAST
:
4049 case DEMANGLE_COMPONENT_CONVERSION
:
4050 case DEMANGLE_COMPONENT_NULLARY
:
4051 case DEMANGLE_COMPONENT_UNARY
:
4052 case DEMANGLE_COMPONENT_BINARY
:
4053 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4054 case DEMANGLE_COMPONENT_TRINARY
:
4055 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4056 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4057 case DEMANGLE_COMPONENT_LITERAL
:
4058 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4059 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4060 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4061 case DEMANGLE_COMPONENT_DECLTYPE
:
4062 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4063 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4064 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4065 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4066 case DEMANGLE_COMPONENT_CLONE
:
4068 d_count_templates_scopes (num_templates
, num_scopes
,
4070 d_count_templates_scopes (num_templates
, num_scopes
,
4074 case DEMANGLE_COMPONENT_CTOR
:
4075 d_count_templates_scopes (num_templates
, num_scopes
,
4079 case DEMANGLE_COMPONENT_DTOR
:
4080 d_count_templates_scopes (num_templates
, num_scopes
,
4084 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4085 d_count_templates_scopes (num_templates
, num_scopes
,
4086 dc
->u
.s_extended_operator
.name
);
4089 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4090 d_count_templates_scopes (num_templates
, num_scopes
,
4091 dc
->u
.s_fixed
.length
);
4094 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4095 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4096 d_count_templates_scopes (num_templates
, num_scopes
,
4100 case DEMANGLE_COMPONENT_LAMBDA
:
4101 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4102 d_count_templates_scopes (num_templates
, num_scopes
,
4103 dc
->u
.s_unary_num
.sub
);
4108 /* Initialize a print information structure. */
4111 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
4112 void *opaque
, const struct demangle_component
*dc
)
4115 dpi
->last_char
= '\0';
4116 dpi
->templates
= NULL
;
4117 dpi
->modifiers
= NULL
;
4118 dpi
->pack_index
= 0;
4119 dpi
->flush_count
= 0;
4121 dpi
->callback
= callback
;
4122 dpi
->opaque
= opaque
;
4124 dpi
->demangle_failure
= 0;
4126 dpi
->component_stack
= NULL
;
4128 dpi
->saved_scopes
= NULL
;
4129 dpi
->next_saved_scope
= 0;
4130 dpi
->num_saved_scopes
= 0;
4132 dpi
->copy_templates
= NULL
;
4133 dpi
->next_copy_template
= 0;
4134 dpi
->num_copy_templates
= 0;
4136 d_count_templates_scopes (&dpi
->num_copy_templates
,
4137 &dpi
->num_saved_scopes
, dc
);
4138 dpi
->num_copy_templates
*= dpi
->num_saved_scopes
;
4140 dpi
->current_template
= NULL
;
4143 /* Indicate that an error occurred during printing, and test for error. */
4146 d_print_error (struct d_print_info
*dpi
)
4148 dpi
->demangle_failure
= 1;
4152 d_print_saw_error (struct d_print_info
*dpi
)
4154 return dpi
->demangle_failure
!= 0;
4157 /* Flush buffered characters to the callback. */
4160 d_print_flush (struct d_print_info
*dpi
)
4162 dpi
->buf
[dpi
->len
] = '\0';
4163 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
4168 /* Append characters and buffers for printing. */
4171 d_append_char (struct d_print_info
*dpi
, char c
)
4173 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
4174 d_print_flush (dpi
);
4176 dpi
->buf
[dpi
->len
++] = c
;
4181 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
4185 for (i
= 0; i
< l
; i
++)
4186 d_append_char (dpi
, s
[i
]);
4190 d_append_string (struct d_print_info
*dpi
, const char *s
)
4192 d_append_buffer (dpi
, s
, strlen (s
));
4196 d_append_num (struct d_print_info
*dpi
, int l
)
4199 sprintf (buf
,"%d", l
);
4200 d_append_string (dpi
, buf
);
4204 d_last_char (struct d_print_info
*dpi
)
4206 return dpi
->last_char
;
4209 /* Turn components into a human readable string. OPTIONS is the
4210 options bits passed to the demangler. DC is the tree to print.
4211 CALLBACK is a function to call to flush demangled string segments
4212 as they fill the intermediate buffer, and OPAQUE is a generalized
4213 callback argument. On success, this returns 1. On failure,
4214 it returns 0, indicating a bad parse. It does not use heap
4215 memory to build an output string, so cannot encounter memory
4216 allocation failure. */
4218 CP_STATIC_IF_GLIBCPP_V3
4220 cplus_demangle_print_callback (int options
,
4221 const struct demangle_component
*dc
,
4222 demangle_callbackref callback
, void *opaque
)
4224 struct d_print_info dpi
;
4226 d_print_init (&dpi
, callback
, opaque
, dc
);
4229 #ifdef CP_DYNAMIC_ARRAYS
4230 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4231 and flagged as errors by Address Sanitizer. */
4232 __extension__
struct d_saved_scope scopes
[(dpi
.num_saved_scopes
> 0)
4233 ? dpi
.num_saved_scopes
: 1];
4234 __extension__
struct d_print_template temps
[(dpi
.num_copy_templates
> 0)
4235 ? dpi
.num_copy_templates
: 1];
4237 dpi
.saved_scopes
= scopes
;
4238 dpi
.copy_templates
= temps
;
4240 dpi
.saved_scopes
= alloca (dpi
.num_saved_scopes
4241 * sizeof (*dpi
.saved_scopes
));
4242 dpi
.copy_templates
= alloca (dpi
.num_copy_templates
4243 * sizeof (*dpi
.copy_templates
));
4246 d_print_comp (&dpi
, options
, dc
);
4249 d_print_flush (&dpi
);
4251 return ! d_print_saw_error (&dpi
);
4254 /* Turn components into a human readable string. OPTIONS is the
4255 options bits passed to the demangler. DC is the tree to print.
4256 ESTIMATE is a guess at the length of the result. This returns a
4257 string allocated by malloc, or NULL on error. On success, this
4258 sets *PALC to the size of the allocated buffer. On failure, this
4259 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4262 CP_STATIC_IF_GLIBCPP_V3
4264 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
4265 int estimate
, size_t *palc
)
4267 struct d_growable_string dgs
;
4269 d_growable_string_init (&dgs
, estimate
);
4271 if (! cplus_demangle_print_callback (options
, dc
,
4272 d_growable_string_callback_adapter
,
4280 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
4284 /* Returns the I'th element of the template arglist ARGS, or NULL on
4285 failure. If I is negative, return the entire arglist. */
4287 static struct demangle_component
*
4288 d_index_template_argument (struct demangle_component
*args
, int i
)
4290 struct demangle_component
*a
;
4293 /* Print the whole argument pack. */
4300 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4306 if (i
!= 0 || a
== NULL
)
4312 /* Returns the template argument from the current context indicated by DC,
4313 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4315 static struct demangle_component
*
4316 d_lookup_template_argument (struct d_print_info
*dpi
,
4317 const struct demangle_component
*dc
)
4319 if (dpi
->templates
== NULL
)
4321 d_print_error (dpi
);
4325 return d_index_template_argument
4326 (d_right (dpi
->templates
->template_decl
),
4327 dc
->u
.s_number
.number
);
4330 /* Returns a template argument pack used in DC (any will do), or NULL. */
4332 static struct demangle_component
*
4333 d_find_pack (struct d_print_info
*dpi
,
4334 const struct demangle_component
*dc
)
4336 struct demangle_component
*a
;
4342 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4343 a
= d_lookup_template_argument (dpi
, dc
);
4344 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4348 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4351 case DEMANGLE_COMPONENT_LAMBDA
:
4352 case DEMANGLE_COMPONENT_NAME
:
4353 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4354 case DEMANGLE_COMPONENT_OPERATOR
:
4355 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4356 case DEMANGLE_COMPONENT_SUB_STD
:
4357 case DEMANGLE_COMPONENT_CHARACTER
:
4358 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4359 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4360 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4361 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
4362 case DEMANGLE_COMPONENT_NUMBER
:
4365 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4366 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
4367 case DEMANGLE_COMPONENT_CTOR
:
4368 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
4369 case DEMANGLE_COMPONENT_DTOR
:
4370 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
4373 a
= d_find_pack (dpi
, d_left (dc
));
4376 return d_find_pack (dpi
, d_right (dc
));
4380 /* Returns the length of the template argument pack DC. */
4383 d_pack_length (const struct demangle_component
*dc
)
4386 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4387 && d_left (dc
) != NULL
)
4395 /* Returns the number of template args in DC, expanding any pack expansions
4399 d_args_length (struct d_print_info
*dpi
, const struct demangle_component
*dc
)
4402 for (; dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
;
4405 struct demangle_component
*elt
= d_left (dc
);
4408 if (elt
->type
== DEMANGLE_COMPONENT_PACK_EXPANSION
)
4410 struct demangle_component
*a
= d_find_pack (dpi
, d_left (elt
));
4411 count
+= d_pack_length (a
);
4419 /* DC is a component of a mangled expression. Print it, wrapped in parens
4423 d_print_subexpr (struct d_print_info
*dpi
, int options
,
4424 const struct demangle_component
*dc
)
4427 if (dc
->type
== DEMANGLE_COMPONENT_NAME
4428 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
4429 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
4430 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
4433 d_append_char (dpi
, '(');
4434 d_print_comp (dpi
, options
, dc
);
4436 d_append_char (dpi
, ')');
4439 /* Save the current scope. */
4442 d_save_scope (struct d_print_info
*dpi
,
4443 const struct demangle_component
*container
)
4445 struct d_saved_scope
*scope
;
4446 struct d_print_template
*src
, **link
;
4448 if (dpi
->next_saved_scope
>= dpi
->num_saved_scopes
)
4450 d_print_error (dpi
);
4453 scope
= &dpi
->saved_scopes
[dpi
->next_saved_scope
];
4454 dpi
->next_saved_scope
++;
4456 scope
->container
= container
;
4457 link
= &scope
->templates
;
4459 for (src
= dpi
->templates
; src
!= NULL
; src
= src
->next
)
4461 struct d_print_template
*dst
;
4463 if (dpi
->next_copy_template
>= dpi
->num_copy_templates
)
4465 d_print_error (dpi
);
4468 dst
= &dpi
->copy_templates
[dpi
->next_copy_template
];
4469 dpi
->next_copy_template
++;
4471 dst
->template_decl
= src
->template_decl
;
4479 /* Attempt to locate a previously saved scope. Returns NULL if no
4480 corresponding saved scope was found. */
4482 static struct d_saved_scope
*
4483 d_get_saved_scope (struct d_print_info
*dpi
,
4484 const struct demangle_component
*container
)
4488 for (i
= 0; i
< dpi
->next_saved_scope
; i
++)
4489 if (dpi
->saved_scopes
[i
].container
== container
)
4490 return &dpi
->saved_scopes
[i
];
4495 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4499 d_maybe_print_fold_expression (struct d_print_info
*dpi
, int options
,
4500 const struct demangle_component
*dc
)
4502 const struct demangle_component
*ops
, *operator_
, *op1
, *op2
;
4505 const char *fold_code
= d_left (dc
)->u
.s_operator
.op
->code
;
4506 if (fold_code
[0] != 'f')
4510 operator_
= d_left (ops
);
4511 op1
= d_right (ops
);
4513 if (op1
->type
== DEMANGLE_COMPONENT_TRINARY_ARG2
)
4515 op2
= d_right (op1
);
4519 /* Print the whole pack. */
4520 save_idx
= dpi
->pack_index
;
4521 dpi
->pack_index
= -1;
4523 switch (fold_code
[1])
4525 /* Unary left fold, (... + X). */
4527 d_append_string (dpi
, "(...");
4528 d_print_expr_op (dpi
, options
, operator_
);
4529 d_print_subexpr (dpi
, options
, op1
);
4530 d_append_char (dpi
, ')');
4533 /* Unary right fold, (X + ...). */
4535 d_append_char (dpi
, '(');
4536 d_print_subexpr (dpi
, options
, op1
);
4537 d_print_expr_op (dpi
, options
, operator_
);
4538 d_append_string (dpi
, "...)");
4541 /* Binary left fold, (42 + ... + X). */
4543 /* Binary right fold, (X + ... + 42). */
4545 d_append_char (dpi
, '(');
4546 d_print_subexpr (dpi
, options
, op1
);
4547 d_print_expr_op (dpi
, options
, operator_
);
4548 d_append_string (dpi
, "...");
4549 d_print_expr_op (dpi
, options
, operator_
);
4550 d_print_subexpr (dpi
, options
, op2
);
4551 d_append_char (dpi
, ')');
4555 dpi
->pack_index
= save_idx
;
4559 /* Subroutine to handle components. */
4562 d_print_comp_inner (struct d_print_info
*dpi
, int options
,
4563 const struct demangle_component
*dc
)
4565 /* Magic variable to let reference smashing skip over the next modifier
4566 without needing to modify *dc. */
4567 const struct demangle_component
*mod_inner
= NULL
;
4569 /* Variable used to store the current templates while a previously
4570 captured scope is used. */
4571 struct d_print_template
*saved_templates
;
4573 /* Nonzero if templates have been stored in the above variable. */
4574 int need_template_restore
= 0;
4578 d_print_error (dpi
);
4581 if (d_print_saw_error (dpi
))
4586 case DEMANGLE_COMPONENT_NAME
:
4587 if ((options
& DMGL_JAVA
) == 0)
4588 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4590 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
4593 case DEMANGLE_COMPONENT_TAGGED_NAME
:
4594 d_print_comp (dpi
, options
, d_left (dc
));
4595 d_append_string (dpi
, "[abi:");
4596 d_print_comp (dpi
, options
, d_right (dc
));
4597 d_append_char (dpi
, ']');
4600 case DEMANGLE_COMPONENT_QUAL_NAME
:
4601 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4602 d_print_comp (dpi
, options
, d_left (dc
));
4603 if ((options
& DMGL_JAVA
) == 0)
4604 d_append_string (dpi
, "::");
4606 d_append_char (dpi
, '.');
4608 struct demangle_component
*local_name
= d_right (dc
);
4609 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4611 d_append_string (dpi
, "{default arg#");
4612 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
4613 d_append_string (dpi
, "}::");
4614 local_name
= local_name
->u
.s_unary_num
.sub
;
4616 d_print_comp (dpi
, options
, local_name
);
4620 case DEMANGLE_COMPONENT_TYPED_NAME
:
4622 struct d_print_mod
*hold_modifiers
;
4623 struct demangle_component
*typed_name
;
4624 struct d_print_mod adpm
[4];
4626 struct d_print_template dpt
;
4628 /* Pass the name down to the type so that it can be printed in
4629 the right place for the type. We also have to pass down
4630 any CV-qualifiers, which apply to the this parameter. */
4631 hold_modifiers
= dpi
->modifiers
;
4634 typed_name
= d_left (dc
);
4635 while (typed_name
!= NULL
)
4637 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4639 d_print_error (dpi
);
4643 adpm
[i
].next
= dpi
->modifiers
;
4644 dpi
->modifiers
= &adpm
[i
];
4645 adpm
[i
].mod
= typed_name
;
4646 adpm
[i
].printed
= 0;
4647 adpm
[i
].templates
= dpi
->templates
;
4650 if (!is_fnqual_component_type (typed_name
->type
))
4653 typed_name
= d_left (typed_name
);
4656 if (typed_name
== NULL
)
4658 d_print_error (dpi
);
4662 /* If typed_name is a template, then it applies to the
4663 function type as well. */
4664 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4666 dpt
.next
= dpi
->templates
;
4667 dpi
->templates
= &dpt
;
4668 dpt
.template_decl
= typed_name
;
4671 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4672 there may be CV-qualifiers on its right argument which
4673 really apply here; this happens when parsing a class which
4674 is local to a function. */
4675 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4677 struct demangle_component
*local_name
;
4679 local_name
= d_right (typed_name
);
4680 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4681 local_name
= local_name
->u
.s_unary_num
.sub
;
4682 if (local_name
== NULL
)
4684 d_print_error (dpi
);
4687 while (is_fnqual_component_type (local_name
->type
))
4689 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4691 d_print_error (dpi
);
4695 adpm
[i
] = adpm
[i
- 1];
4696 adpm
[i
].next
= &adpm
[i
- 1];
4697 dpi
->modifiers
= &adpm
[i
];
4699 adpm
[i
- 1].mod
= local_name
;
4700 adpm
[i
- 1].printed
= 0;
4701 adpm
[i
- 1].templates
= dpi
->templates
;
4704 local_name
= d_left (local_name
);
4708 d_print_comp (dpi
, options
, d_right (dc
));
4710 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4711 dpi
->templates
= dpt
.next
;
4713 /* If the modifiers didn't get printed by the type, print them
4718 if (! adpm
[i
].printed
)
4720 d_append_char (dpi
, ' ');
4721 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4725 dpi
->modifiers
= hold_modifiers
;
4730 case DEMANGLE_COMPONENT_TEMPLATE
:
4732 struct d_print_mod
*hold_dpm
;
4733 struct demangle_component
*dcl
;
4734 const struct demangle_component
*hold_current
;
4736 /* This template may need to be referenced by a cast operator
4737 contained in its subtree. */
4738 hold_current
= dpi
->current_template
;
4739 dpi
->current_template
= dc
;
4741 /* Don't push modifiers into a template definition. Doing so
4742 could give the wrong definition for a template argument.
4743 Instead, treat the template essentially as a name. */
4745 hold_dpm
= dpi
->modifiers
;
4746 dpi
->modifiers
= NULL
;
4750 if ((options
& DMGL_JAVA
) != 0
4751 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4752 && dcl
->u
.s_name
.len
== 6
4753 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4755 /* Special-case Java arrays, so that JArray<TYPE> appears
4756 instead as TYPE[]. */
4758 d_print_comp (dpi
, options
, d_right (dc
));
4759 d_append_string (dpi
, "[]");
4763 d_print_comp (dpi
, options
, dcl
);
4764 if (d_last_char (dpi
) == '<')
4765 d_append_char (dpi
, ' ');
4766 d_append_char (dpi
, '<');
4767 d_print_comp (dpi
, options
, d_right (dc
));
4768 /* Avoid generating two consecutive '>' characters, to avoid
4769 the C++ syntactic ambiguity. */
4770 if (d_last_char (dpi
) == '>')
4771 d_append_char (dpi
, ' ');
4772 d_append_char (dpi
, '>');
4775 dpi
->modifiers
= hold_dpm
;
4776 dpi
->current_template
= hold_current
;
4781 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4783 struct d_print_template
*hold_dpt
;
4784 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4786 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4787 a
= d_index_template_argument (a
, dpi
->pack_index
);
4791 d_print_error (dpi
);
4795 /* While processing this parameter, we need to pop the list of
4796 templates. This is because the template parameter may
4797 itself be a reference to a parameter of an outer
4800 hold_dpt
= dpi
->templates
;
4801 dpi
->templates
= hold_dpt
->next
;
4803 d_print_comp (dpi
, options
, a
);
4805 dpi
->templates
= hold_dpt
;
4810 case DEMANGLE_COMPONENT_CTOR
:
4811 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4814 case DEMANGLE_COMPONENT_DTOR
:
4815 d_append_char (dpi
, '~');
4816 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4819 case DEMANGLE_COMPONENT_VTABLE
:
4820 d_append_string (dpi
, "vtable for ");
4821 d_print_comp (dpi
, options
, d_left (dc
));
4824 case DEMANGLE_COMPONENT_VTT
:
4825 d_append_string (dpi
, "VTT for ");
4826 d_print_comp (dpi
, options
, d_left (dc
));
4829 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4830 d_append_string (dpi
, "construction vtable for ");
4831 d_print_comp (dpi
, options
, d_left (dc
));
4832 d_append_string (dpi
, "-in-");
4833 d_print_comp (dpi
, options
, d_right (dc
));
4836 case DEMANGLE_COMPONENT_TYPEINFO
:
4837 d_append_string (dpi
, "typeinfo for ");
4838 d_print_comp (dpi
, options
, d_left (dc
));
4841 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4842 d_append_string (dpi
, "typeinfo name for ");
4843 d_print_comp (dpi
, options
, d_left (dc
));
4846 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4847 d_append_string (dpi
, "typeinfo fn for ");
4848 d_print_comp (dpi
, options
, d_left (dc
));
4851 case DEMANGLE_COMPONENT_THUNK
:
4852 d_append_string (dpi
, "non-virtual thunk to ");
4853 d_print_comp (dpi
, options
, d_left (dc
));
4856 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4857 d_append_string (dpi
, "virtual thunk to ");
4858 d_print_comp (dpi
, options
, d_left (dc
));
4861 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4862 d_append_string (dpi
, "covariant return thunk to ");
4863 d_print_comp (dpi
, options
, d_left (dc
));
4866 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4867 d_append_string (dpi
, "java Class for ");
4868 d_print_comp (dpi
, options
, d_left (dc
));
4871 case DEMANGLE_COMPONENT_GUARD
:
4872 d_append_string (dpi
, "guard variable for ");
4873 d_print_comp (dpi
, options
, d_left (dc
));
4876 case DEMANGLE_COMPONENT_TLS_INIT
:
4877 d_append_string (dpi
, "TLS init function for ");
4878 d_print_comp (dpi
, options
, d_left (dc
));
4881 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4882 d_append_string (dpi
, "TLS wrapper function for ");
4883 d_print_comp (dpi
, options
, d_left (dc
));
4886 case DEMANGLE_COMPONENT_REFTEMP
:
4887 d_append_string (dpi
, "reference temporary #");
4888 d_print_comp (dpi
, options
, d_right (dc
));
4889 d_append_string (dpi
, " for ");
4890 d_print_comp (dpi
, options
, d_left (dc
));
4893 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4894 d_append_string (dpi
, "hidden alias for ");
4895 d_print_comp (dpi
, options
, d_left (dc
));
4898 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4899 d_append_string (dpi
, "transaction clone for ");
4900 d_print_comp (dpi
, options
, d_left (dc
));
4903 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4904 d_append_string (dpi
, "non-transaction clone for ");
4905 d_print_comp (dpi
, options
, d_left (dc
));
4908 case DEMANGLE_COMPONENT_SUB_STD
:
4909 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
4912 case DEMANGLE_COMPONENT_RESTRICT
:
4913 case DEMANGLE_COMPONENT_VOLATILE
:
4914 case DEMANGLE_COMPONENT_CONST
:
4916 struct d_print_mod
*pdpm
;
4918 /* When printing arrays, it's possible to have cases where the
4919 same CV-qualifier gets pushed on the stack multiple times.
4920 We only need to print it once. */
4922 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
4924 if (! pdpm
->printed
)
4926 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
4927 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
4928 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
4930 if (pdpm
->mod
->type
== dc
->type
)
4932 d_print_comp (dpi
, options
, d_left (dc
));
4940 case DEMANGLE_COMPONENT_REFERENCE
:
4941 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4943 /* Handle reference smashing: & + && = &. */
4944 const struct demangle_component
*sub
= d_left (dc
);
4945 if (sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4947 struct d_saved_scope
*scope
= d_get_saved_scope (dpi
, sub
);
4948 struct demangle_component
*a
;
4952 /* This is the first time SUB has been traversed.
4953 We need to capture the current templates so
4954 they can be restored if SUB is reentered as a
4956 d_save_scope (dpi
, sub
);
4957 if (d_print_saw_error (dpi
))
4962 const struct d_component_stack
*dcse
;
4963 int found_self_or_parent
= 0;
4965 /* This traversal is reentering SUB as a substition.
4966 If we are not beneath SUB or DC in the tree then we
4967 need to restore SUB's template stack temporarily. */
4968 for (dcse
= dpi
->component_stack
; dcse
!= NULL
;
4969 dcse
= dcse
->parent
)
4973 && dcse
!= dpi
->component_stack
))
4975 found_self_or_parent
= 1;
4980 if (!found_self_or_parent
)
4982 saved_templates
= dpi
->templates
;
4983 dpi
->templates
= scope
->templates
;
4984 need_template_restore
= 1;
4988 a
= d_lookup_template_argument (dpi
, sub
);
4989 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4990 a
= d_index_template_argument (a
, dpi
->pack_index
);
4994 if (need_template_restore
)
4995 dpi
->templates
= saved_templates
;
4997 d_print_error (dpi
);
5004 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
5005 || sub
->type
== dc
->type
)
5007 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
5008 mod_inner
= d_left (sub
);
5012 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5013 case DEMANGLE_COMPONENT_POINTER
:
5014 case DEMANGLE_COMPONENT_COMPLEX
:
5015 case DEMANGLE_COMPONENT_IMAGINARY
:
5016 FNQUAL_COMPONENT_CASE
:
5019 /* We keep a list of modifiers on the stack. */
5020 struct d_print_mod dpm
;
5022 dpm
.next
= dpi
->modifiers
;
5023 dpi
->modifiers
= &dpm
;
5026 dpm
.templates
= dpi
->templates
;
5029 mod_inner
= d_left (dc
);
5031 d_print_comp (dpi
, options
, mod_inner
);
5033 /* If the modifier didn't get printed by the type, print it
5036 d_print_mod (dpi
, options
, dc
);
5038 dpi
->modifiers
= dpm
.next
;
5040 if (need_template_restore
)
5041 dpi
->templates
= saved_templates
;
5046 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
5047 if ((options
& DMGL_JAVA
) == 0)
5048 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
5049 dc
->u
.s_builtin
.type
->len
);
5051 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
5052 dc
->u
.s_builtin
.type
->java_len
);
5055 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
5056 d_print_comp (dpi
, options
, d_left (dc
));
5059 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
5061 if ((options
& DMGL_RET_POSTFIX
) != 0)
5062 d_print_function_type (dpi
,
5063 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5064 dc
, dpi
->modifiers
);
5066 /* Print return type if present */
5067 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
5068 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5070 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
5072 struct d_print_mod dpm
;
5074 /* We must pass this type down as a modifier in order to
5075 print it in the right location. */
5076 dpm
.next
= dpi
->modifiers
;
5077 dpi
->modifiers
= &dpm
;
5080 dpm
.templates
= dpi
->templates
;
5082 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5085 dpi
->modifiers
= dpm
.next
;
5090 /* In standard prefix notation, there is a space between the
5091 return type and the function signature. */
5092 if ((options
& DMGL_RET_POSTFIX
) == 0)
5093 d_append_char (dpi
, ' ');
5096 if ((options
& DMGL_RET_POSTFIX
) == 0)
5097 d_print_function_type (dpi
,
5098 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
5099 dc
, dpi
->modifiers
);
5104 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
5106 struct d_print_mod
*hold_modifiers
;
5107 struct d_print_mod adpm
[4];
5109 struct d_print_mod
*pdpm
;
5111 /* We must pass this type down as a modifier in order to print
5112 multi-dimensional arrays correctly. If the array itself is
5113 CV-qualified, we act as though the element type were
5114 CV-qualified. We do this by copying the modifiers down
5115 rather than fiddling pointers, so that we don't wind up
5116 with a d_print_mod higher on the stack pointing into our
5117 stack frame after we return. */
5119 hold_modifiers
= dpi
->modifiers
;
5121 adpm
[0].next
= hold_modifiers
;
5122 dpi
->modifiers
= &adpm
[0];
5124 adpm
[0].printed
= 0;
5125 adpm
[0].templates
= dpi
->templates
;
5128 pdpm
= hold_modifiers
;
5130 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
5131 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
5132 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
5134 if (! pdpm
->printed
)
5136 if (i
>= sizeof adpm
/ sizeof adpm
[0])
5138 d_print_error (dpi
);
5143 adpm
[i
].next
= dpi
->modifiers
;
5144 dpi
->modifiers
= &adpm
[i
];
5152 d_print_comp (dpi
, options
, d_right (dc
));
5154 dpi
->modifiers
= hold_modifiers
;
5156 if (adpm
[0].printed
)
5162 d_print_mod (dpi
, options
, adpm
[i
].mod
);
5165 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
5170 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5171 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5173 struct d_print_mod dpm
;
5175 dpm
.next
= dpi
->modifiers
;
5176 dpi
->modifiers
= &dpm
;
5179 dpm
.templates
= dpi
->templates
;
5181 d_print_comp (dpi
, options
, d_right (dc
));
5183 /* If the modifier didn't get printed by the type, print it
5186 d_print_mod (dpi
, options
, dc
);
5188 dpi
->modifiers
= dpm
.next
;
5193 case DEMANGLE_COMPONENT_FIXED_TYPE
:
5194 if (dc
->u
.s_fixed
.sat
)
5195 d_append_string (dpi
, "_Sat ");
5196 /* Don't print "int _Accum". */
5197 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
5198 != &cplus_demangle_builtin_types
['i'-'a'])
5200 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
5201 d_append_char (dpi
, ' ');
5203 if (dc
->u
.s_fixed
.accum
)
5204 d_append_string (dpi
, "_Accum");
5206 d_append_string (dpi
, "_Fract");
5209 case DEMANGLE_COMPONENT_ARGLIST
:
5210 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
5211 if (d_left (dc
) != NULL
)
5212 d_print_comp (dpi
, options
, d_left (dc
));
5213 if (d_right (dc
) != NULL
)
5216 unsigned long int flush_count
;
5217 /* Make sure ", " isn't flushed by d_append_string, otherwise
5218 dpi->len -= 2 wouldn't work. */
5219 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
5220 d_print_flush (dpi
);
5221 d_append_string (dpi
, ", ");
5223 flush_count
= dpi
->flush_count
;
5224 d_print_comp (dpi
, options
, d_right (dc
));
5225 /* If that didn't print anything (which can happen with empty
5226 template argument packs), remove the comma and space. */
5227 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
5232 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
5234 struct demangle_component
*type
= d_left (dc
);
5235 struct demangle_component
*list
= d_right (dc
);
5238 d_print_comp (dpi
, options
, type
);
5239 d_append_char (dpi
, '{');
5240 d_print_comp (dpi
, options
, list
);
5241 d_append_char (dpi
, '}');
5245 case DEMANGLE_COMPONENT_OPERATOR
:
5247 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
5250 d_append_string (dpi
, "operator");
5251 /* Add a space before new/delete. */
5252 if (IS_LOWER (op
->name
[0]))
5253 d_append_char (dpi
, ' ');
5254 /* Omit a trailing space. */
5255 if (op
->name
[len
-1] == ' ')
5257 d_append_buffer (dpi
, op
->name
, len
);
5261 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
5262 d_append_string (dpi
, "operator ");
5263 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
5266 case DEMANGLE_COMPONENT_CONVERSION
:
5267 d_append_string (dpi
, "operator ");
5268 d_print_conversion (dpi
, options
, dc
);
5271 case DEMANGLE_COMPONENT_NULLARY
:
5272 d_print_expr_op (dpi
, options
, d_left (dc
));
5275 case DEMANGLE_COMPONENT_UNARY
:
5277 struct demangle_component
*op
= d_left (dc
);
5278 struct demangle_component
*operand
= d_right (dc
);
5279 const char *code
= NULL
;
5281 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5283 code
= op
->u
.s_operator
.op
->code
;
5284 if (!strcmp (code
, "ad"))
5286 /* Don't print the argument list for the address of a
5288 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
5289 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
5290 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5291 operand
= d_left (operand
);
5293 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
5295 /* This indicates a suffix operator. */
5296 operand
= d_left (operand
);
5297 d_print_subexpr (dpi
, options
, operand
);
5298 d_print_expr_op (dpi
, options
, op
);
5303 /* For sizeof..., just print the pack length. */
5304 if (code
&& !strcmp (code
, "sZ"))
5306 struct demangle_component
*a
= d_find_pack (dpi
, operand
);
5307 int len
= d_pack_length (a
);
5308 d_append_num (dpi
, len
);
5311 else if (code
&& !strcmp (code
, "sP"))
5313 int len
= d_args_length (dpi
, operand
);
5314 d_append_num (dpi
, len
);
5318 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
5319 d_print_expr_op (dpi
, options
, op
);
5322 d_append_char (dpi
, '(');
5323 d_print_cast (dpi
, options
, op
);
5324 d_append_char (dpi
, ')');
5326 if (code
&& !strcmp (code
, "gs"))
5327 /* Avoid parens after '::'. */
5328 d_print_comp (dpi
, options
, operand
);
5329 else if (code
&& !strcmp (code
, "st"))
5330 /* Always print parens for sizeof (type). */
5332 d_append_char (dpi
, '(');
5333 d_print_comp (dpi
, options
, operand
);
5334 d_append_char (dpi
, ')');
5337 d_print_subexpr (dpi
, options
, operand
);
5341 case DEMANGLE_COMPONENT_BINARY
:
5342 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
5344 d_print_error (dpi
);
5348 if (op_is_new_cast (d_left (dc
)))
5350 d_print_expr_op (dpi
, options
, d_left (dc
));
5351 d_append_char (dpi
, '<');
5352 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
5353 d_append_string (dpi
, ">(");
5354 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5355 d_append_char (dpi
, ')');
5359 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5362 /* We wrap an expression which uses the greater-than operator in
5363 an extra layer of parens so that it does not get confused
5364 with the '>' which ends the template parameters. */
5365 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5366 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5367 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5368 d_append_char (dpi
, '(');
5370 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
5371 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
5373 /* Function call used in an expression should not have printed types
5374 of the function arguments. Values of the function arguments still
5375 get printed below. */
5377 const struct demangle_component
*func
= d_left (d_right (dc
));
5379 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5380 d_print_error (dpi
);
5381 d_print_subexpr (dpi
, options
, d_left (func
));
5384 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
5385 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
5387 d_append_char (dpi
, '[');
5388 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
5389 d_append_char (dpi
, ']');
5393 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
5394 d_print_expr_op (dpi
, options
, d_left (dc
));
5395 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
5398 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
5399 && d_left (dc
)->u
.s_operator
.op
->len
== 1
5400 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
5401 d_append_char (dpi
, ')');
5405 case DEMANGLE_COMPONENT_BINARY_ARGS
:
5406 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5407 d_print_error (dpi
);
5410 case DEMANGLE_COMPONENT_TRINARY
:
5411 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
5412 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
5414 d_print_error (dpi
);
5417 if (d_maybe_print_fold_expression (dpi
, options
, dc
))
5420 struct demangle_component
*op
= d_left (dc
);
5421 struct demangle_component
*first
= d_left (d_right (dc
));
5422 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
5423 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
5425 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
5427 d_print_subexpr (dpi
, options
, first
);
5428 d_print_expr_op (dpi
, options
, op
);
5429 d_print_subexpr (dpi
, options
, second
);
5430 d_append_string (dpi
, " : ");
5431 d_print_subexpr (dpi
, options
, third
);
5435 d_append_string (dpi
, "new ");
5436 if (d_left (first
) != NULL
)
5438 d_print_subexpr (dpi
, options
, first
);
5439 d_append_char (dpi
, ' ');
5441 d_print_comp (dpi
, options
, second
);
5443 d_print_subexpr (dpi
, options
, third
);
5448 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
5449 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
5450 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5451 d_print_error (dpi
);
5454 case DEMANGLE_COMPONENT_LITERAL
:
5455 case DEMANGLE_COMPONENT_LITERAL_NEG
:
5457 enum d_builtin_type_print tp
;
5459 /* For some builtin types, produce simpler output. */
5460 tp
= D_PRINT_DEFAULT
;
5461 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
5463 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
5467 case D_PRINT_UNSIGNED
:
5469 case D_PRINT_UNSIGNED_LONG
:
5470 case D_PRINT_LONG_LONG
:
5471 case D_PRINT_UNSIGNED_LONG_LONG
:
5472 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
5474 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5475 d_append_char (dpi
, '-');
5476 d_print_comp (dpi
, options
, d_right (dc
));
5481 case D_PRINT_UNSIGNED
:
5482 d_append_char (dpi
, 'u');
5485 d_append_char (dpi
, 'l');
5487 case D_PRINT_UNSIGNED_LONG
:
5488 d_append_string (dpi
, "ul");
5490 case D_PRINT_LONG_LONG
:
5491 d_append_string (dpi
, "ll");
5493 case D_PRINT_UNSIGNED_LONG_LONG
:
5494 d_append_string (dpi
, "ull");
5502 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
5503 && d_right (dc
)->u
.s_name
.len
== 1
5504 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
5506 switch (d_right (dc
)->u
.s_name
.s
[0])
5509 d_append_string (dpi
, "false");
5512 d_append_string (dpi
, "true");
5525 d_append_char (dpi
, '(');
5526 d_print_comp (dpi
, options
, d_left (dc
));
5527 d_append_char (dpi
, ')');
5528 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
5529 d_append_char (dpi
, '-');
5530 if (tp
== D_PRINT_FLOAT
)
5531 d_append_char (dpi
, '[');
5532 d_print_comp (dpi
, options
, d_right (dc
));
5533 if (tp
== D_PRINT_FLOAT
)
5534 d_append_char (dpi
, ']');
5538 case DEMANGLE_COMPONENT_NUMBER
:
5539 d_append_num (dpi
, dc
->u
.s_number
.number
);
5542 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
5543 d_append_string (dpi
, "java resource ");
5544 d_print_comp (dpi
, options
, d_left (dc
));
5547 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
5548 d_print_comp (dpi
, options
, d_left (dc
));
5549 d_print_comp (dpi
, options
, d_right (dc
));
5552 case DEMANGLE_COMPONENT_CHARACTER
:
5553 d_append_char (dpi
, dc
->u
.s_character
.character
);
5556 case DEMANGLE_COMPONENT_DECLTYPE
:
5557 d_append_string (dpi
, "decltype (");
5558 d_print_comp (dpi
, options
, d_left (dc
));
5559 d_append_char (dpi
, ')');
5562 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
5566 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
5569 /* d_find_pack won't find anything if the only packs involved
5570 in this expansion are function parameter packs; in that
5571 case, just print the pattern and "...". */
5572 d_print_subexpr (dpi
, options
, d_left (dc
));
5573 d_append_string (dpi
, "...");
5577 len
= d_pack_length (a
);
5579 for (i
= 0; i
< len
; ++i
)
5581 dpi
->pack_index
= i
;
5582 d_print_comp (dpi
, options
, dc
);
5584 d_append_string (dpi
, ", ");
5589 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
5591 long num
= dc
->u
.s_number
.number
;
5593 d_append_string (dpi
, "this");
5596 d_append_string (dpi
, "{parm#");
5597 d_append_num (dpi
, num
);
5598 d_append_char (dpi
, '}');
5603 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
5604 d_append_string (dpi
, "global constructors keyed to ");
5605 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5608 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
5609 d_append_string (dpi
, "global destructors keyed to ");
5610 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
5613 case DEMANGLE_COMPONENT_LAMBDA
:
5614 d_append_string (dpi
, "{lambda(");
5615 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
5616 d_append_string (dpi
, ")#");
5617 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5618 d_append_char (dpi
, '}');
5621 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
5622 d_append_string (dpi
, "{unnamed type#");
5623 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
5624 d_append_char (dpi
, '}');
5627 case DEMANGLE_COMPONENT_CLONE
:
5628 d_print_comp (dpi
, options
, d_left (dc
));
5629 d_append_string (dpi
, " [clone ");
5630 d_print_comp (dpi
, options
, d_right (dc
));
5631 d_append_char (dpi
, ']');
5635 d_print_error (dpi
);
5641 d_print_comp (struct d_print_info
*dpi
, int options
,
5642 const struct demangle_component
*dc
)
5644 struct d_component_stack self
;
5647 self
.parent
= dpi
->component_stack
;
5648 dpi
->component_stack
= &self
;
5650 d_print_comp_inner (dpi
, options
, dc
);
5652 dpi
->component_stack
= self
.parent
;
5655 /* Print a Java dentifier. For Java we try to handle encoded extended
5656 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5657 so we don't it for C++. Characters are encoded as
5661 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
5667 for (p
= name
; p
< end
; ++p
)
5678 for (q
= p
+ 3; q
< end
; ++q
)
5684 else if (*q
>= 'A' && *q
<= 'F')
5685 dig
= *q
- 'A' + 10;
5686 else if (*q
>= 'a' && *q
<= 'f')
5687 dig
= *q
- 'a' + 10;
5693 /* If the Unicode character is larger than 256, we don't try
5694 to deal with it here. FIXME. */
5695 if (q
< end
&& *q
== '_' && c
< 256)
5697 d_append_char (dpi
, c
);
5703 d_append_char (dpi
, *p
);
5707 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5708 qualifiers on this after printing a function. */
5711 d_print_mod_list (struct d_print_info
*dpi
, int options
,
5712 struct d_print_mod
*mods
, int suffix
)
5714 struct d_print_template
*hold_dpt
;
5716 if (mods
== NULL
|| d_print_saw_error (dpi
))
5721 && (is_fnqual_component_type (mods
->mod
->type
))))
5723 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5729 hold_dpt
= dpi
->templates
;
5730 dpi
->templates
= mods
->templates
;
5732 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5734 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5735 dpi
->templates
= hold_dpt
;
5738 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5740 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5741 dpi
->templates
= hold_dpt
;
5744 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5746 struct d_print_mod
*hold_modifiers
;
5747 struct demangle_component
*dc
;
5749 /* When this is on the modifier stack, we have pulled any
5750 qualifiers off the right argument already. Otherwise, we
5751 print it as usual, but don't let the left argument see any
5754 hold_modifiers
= dpi
->modifiers
;
5755 dpi
->modifiers
= NULL
;
5756 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5757 dpi
->modifiers
= hold_modifiers
;
5759 if ((options
& DMGL_JAVA
) == 0)
5760 d_append_string (dpi
, "::");
5762 d_append_char (dpi
, '.');
5764 dc
= d_right (mods
->mod
);
5766 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5768 d_append_string (dpi
, "{default arg#");
5769 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5770 d_append_string (dpi
, "}::");
5771 dc
= dc
->u
.s_unary_num
.sub
;
5774 while (is_fnqual_component_type (dc
->type
))
5777 d_print_comp (dpi
, options
, dc
);
5779 dpi
->templates
= hold_dpt
;
5783 d_print_mod (dpi
, options
, mods
->mod
);
5785 dpi
->templates
= hold_dpt
;
5787 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5790 /* Print a modifier. */
5793 d_print_mod (struct d_print_info
*dpi
, int options
,
5794 const struct demangle_component
*mod
)
5798 case DEMANGLE_COMPONENT_RESTRICT
:
5799 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5800 d_append_string (dpi
, " restrict");
5802 case DEMANGLE_COMPONENT_VOLATILE
:
5803 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5804 d_append_string (dpi
, " volatile");
5806 case DEMANGLE_COMPONENT_CONST
:
5807 case DEMANGLE_COMPONENT_CONST_THIS
:
5808 d_append_string (dpi
, " const");
5810 case DEMANGLE_COMPONENT_TRANSACTION_SAFE
:
5811 d_append_string (dpi
, " transaction_safe");
5813 case DEMANGLE_COMPONENT_NOEXCEPT
:
5814 d_append_string (dpi
, " noexcept");
5817 d_append_char (dpi
, '(');
5818 d_print_comp (dpi
, options
, d_right (mod
));
5819 d_append_char (dpi
, ')');
5822 case DEMANGLE_COMPONENT_THROW_SPEC
:
5823 d_append_string (dpi
, " throw");
5826 d_append_char (dpi
, '(');
5827 d_print_comp (dpi
, options
, d_right (mod
));
5828 d_append_char (dpi
, ')');
5831 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5832 d_append_char (dpi
, ' ');
5833 d_print_comp (dpi
, options
, d_right (mod
));
5835 case DEMANGLE_COMPONENT_POINTER
:
5836 /* There is no pointer symbol in Java. */
5837 if ((options
& DMGL_JAVA
) == 0)
5838 d_append_char (dpi
, '*');
5840 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5841 /* For the ref-qualifier, put a space before the &. */
5842 d_append_char (dpi
, ' ');
5844 case DEMANGLE_COMPONENT_REFERENCE
:
5845 d_append_char (dpi
, '&');
5847 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5848 d_append_char (dpi
, ' ');
5850 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5851 d_append_string (dpi
, "&&");
5853 case DEMANGLE_COMPONENT_COMPLEX
:
5854 d_append_string (dpi
, "complex ");
5856 case DEMANGLE_COMPONENT_IMAGINARY
:
5857 d_append_string (dpi
, "imaginary ");
5859 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5860 if (d_last_char (dpi
) != '(')
5861 d_append_char (dpi
, ' ');
5862 d_print_comp (dpi
, options
, d_left (mod
));
5863 d_append_string (dpi
, "::*");
5865 case DEMANGLE_COMPONENT_TYPED_NAME
:
5866 d_print_comp (dpi
, options
, d_left (mod
));
5868 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5869 d_append_string (dpi
, " __vector(");
5870 d_print_comp (dpi
, options
, d_left (mod
));
5871 d_append_char (dpi
, ')');
5875 /* Otherwise, we have something that won't go back on the
5876 modifier stack, so we can just print it. */
5877 d_print_comp (dpi
, options
, mod
);
5882 /* Print a function type, except for the return type. */
5885 d_print_function_type (struct d_print_info
*dpi
, int options
,
5886 const struct demangle_component
*dc
,
5887 struct d_print_mod
*mods
)
5891 struct d_print_mod
*p
;
5892 struct d_print_mod
*hold_modifiers
;
5896 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5901 switch (p
->mod
->type
)
5903 case DEMANGLE_COMPONENT_POINTER
:
5904 case DEMANGLE_COMPONENT_REFERENCE
:
5905 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5908 case DEMANGLE_COMPONENT_RESTRICT
:
5909 case DEMANGLE_COMPONENT_VOLATILE
:
5910 case DEMANGLE_COMPONENT_CONST
:
5911 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5912 case DEMANGLE_COMPONENT_COMPLEX
:
5913 case DEMANGLE_COMPONENT_IMAGINARY
:
5914 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5918 FNQUAL_COMPONENT_CASE
:
5931 if (d_last_char (dpi
) != '('
5932 && d_last_char (dpi
) != '*')
5935 if (need_space
&& d_last_char (dpi
) != ' ')
5936 d_append_char (dpi
, ' ');
5937 d_append_char (dpi
, '(');
5940 hold_modifiers
= dpi
->modifiers
;
5941 dpi
->modifiers
= NULL
;
5943 d_print_mod_list (dpi
, options
, mods
, 0);
5946 d_append_char (dpi
, ')');
5948 d_append_char (dpi
, '(');
5950 if (d_right (dc
) != NULL
)
5951 d_print_comp (dpi
, options
, d_right (dc
));
5953 d_append_char (dpi
, ')');
5955 d_print_mod_list (dpi
, options
, mods
, 1);
5957 dpi
->modifiers
= hold_modifiers
;
5960 /* Print an array type, except for the element type. */
5963 d_print_array_type (struct d_print_info
*dpi
, int options
,
5964 const struct demangle_component
*dc
,
5965 struct d_print_mod
*mods
)
5973 struct d_print_mod
*p
;
5976 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5980 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5995 d_append_string (dpi
, " (");
5997 d_print_mod_list (dpi
, options
, mods
, 0);
6000 d_append_char (dpi
, ')');
6004 d_append_char (dpi
, ' ');
6006 d_append_char (dpi
, '[');
6008 if (d_left (dc
) != NULL
)
6009 d_print_comp (dpi
, options
, d_left (dc
));
6011 d_append_char (dpi
, ']');
6014 /* Print an operator in an expression. */
6017 d_print_expr_op (struct d_print_info
*dpi
, int options
,
6018 const struct demangle_component
*dc
)
6020 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
6021 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
6022 dc
->u
.s_operator
.op
->len
);
6024 d_print_comp (dpi
, options
, dc
);
6030 d_print_cast (struct d_print_info
*dpi
, int options
,
6031 const struct demangle_component
*dc
)
6033 d_print_comp (dpi
, options
, d_left (dc
));
6036 /* Print a conversion operator. */
6039 d_print_conversion (struct d_print_info
*dpi
, int options
,
6040 const struct demangle_component
*dc
)
6042 struct d_print_template dpt
;
6044 /* For a conversion operator, we need the template parameters from
6045 the enclosing template in scope for processing the type. */
6046 if (dpi
->current_template
!= NULL
)
6048 dpt
.next
= dpi
->templates
;
6049 dpi
->templates
= &dpt
;
6050 dpt
.template_decl
= dpi
->current_template
;
6053 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
6055 d_print_comp (dpi
, options
, d_left (dc
));
6056 if (dpi
->current_template
!= NULL
)
6057 dpi
->templates
= dpt
.next
;
6061 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
6063 /* For a templated cast operator, we need to remove the template
6064 parameters from scope after printing the operator name,
6065 so we need to handle the template printing here. */
6066 if (dpi
->current_template
!= NULL
)
6067 dpi
->templates
= dpt
.next
;
6069 if (d_last_char (dpi
) == '<')
6070 d_append_char (dpi
, ' ');
6071 d_append_char (dpi
, '<');
6072 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
6073 /* Avoid generating two consecutive '>' characters, to avoid
6074 the C++ syntactic ambiguity. */
6075 if (d_last_char (dpi
) == '>')
6076 d_append_char (dpi
, ' ');
6077 d_append_char (dpi
, '>');
6081 /* Initialize the information structure we use to pass around
6084 CP_STATIC_IF_GLIBCPP_V3
6086 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
6090 di
->send
= mangled
+ len
;
6091 di
->options
= options
;
6095 /* We can not need more components than twice the number of chars in
6096 the mangled string. Most components correspond directly to
6097 chars, but the ARGLIST types are exceptions. */
6098 di
->num_comps
= 2 * len
;
6101 /* Similarly, we can not need more substitutions than there are
6102 chars in the mangled string. */
6107 di
->last_name
= NULL
;
6110 di
->is_expression
= 0;
6111 di
->is_conversion
= 0;
6114 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6115 mangled name, return strings in repeated callback giving the demangled
6116 name. OPTIONS is the usual libiberty demangler options. On success,
6117 this returns 1. On failure, returns 0. */
6120 d_demangle_callback (const char *mangled
, int options
,
6121 demangle_callbackref callback
, void *opaque
)
6132 struct demangle_component
*dc
;
6135 if (mangled
[0] == '_' && mangled
[1] == 'Z')
6137 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
6138 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
6139 && (mangled
[9] == 'D' || mangled
[9] == 'I')
6140 && mangled
[10] == '_')
6141 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
6144 if ((options
& DMGL_TYPES
) == 0)
6149 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
6152 #ifdef CP_DYNAMIC_ARRAYS
6153 __extension__
struct demangle_component comps
[di
.num_comps
];
6154 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6159 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6160 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6166 dc
= cplus_demangle_type (&di
);
6169 dc
= cplus_demangle_mangled_name (&di
, 1);
6171 case DCT_GLOBAL_CTORS
:
6172 case DCT_GLOBAL_DTORS
:
6173 d_advance (&di
, 11);
6174 dc
= d_make_comp (&di
,
6175 (type
== DCT_GLOBAL_CTORS
6176 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6177 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
6178 d_make_demangle_mangled_name (&di
, d_str (&di
)),
6180 d_advance (&di
, strlen (d_str (&di
)));
6183 abort (); /* We have listed all the cases. */
6186 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6187 mangled string, then we didn't successfully demangle it. If
6188 DMGL_PARAMS is not set, we didn't look at the trailing
6190 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
6193 #ifdef CP_DEMANGLE_DEBUG
6197 status
= (dc
!= NULL
)
6198 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
6205 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6206 name, return a buffer allocated with malloc holding the demangled
6207 name. OPTIONS is the usual libiberty demangler options. On
6208 success, this sets *PALC to the allocated size of the returned
6209 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6210 a memory allocation failure, and returns NULL. */
6213 d_demangle (const char *mangled
, int options
, size_t *palc
)
6215 struct d_growable_string dgs
;
6218 d_growable_string_init (&dgs
, 0);
6220 status
= d_demangle_callback (mangled
, options
,
6221 d_growable_string_callback_adapter
, &dgs
);
6229 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
6233 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6235 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6237 /* ia64 ABI-mandated entry point in the C++ runtime library for
6238 performing demangling. MANGLED_NAME is a NUL-terminated character
6239 string containing the name to be demangled.
6241 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6242 *LENGTH bytes, into which the demangled name is stored. If
6243 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6244 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6245 is placed in a region of memory allocated with malloc.
6247 If LENGTH is non-NULL, the length of the buffer containing the
6248 demangled name, is placed in *LENGTH.
6250 The return value is a pointer to the start of the NUL-terminated
6251 demangled name, or NULL if the demangling fails. The caller is
6252 responsible for deallocating this memory using free.
6254 *STATUS is set to one of the following values:
6255 0: The demangling operation succeeded.
6256 -1: A memory allocation failure occurred.
6257 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6258 -3: One of the arguments is invalid.
6260 The demangling is performed using the C++ ABI mangling rules, with
6264 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
6265 size_t *length
, int *status
)
6270 if (mangled_name
== NULL
)
6277 if (output_buffer
!= NULL
&& length
== NULL
)
6284 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
6286 if (demangled
== NULL
)
6298 if (output_buffer
== NULL
)
6305 if (strlen (demangled
) < *length
)
6307 strcpy (output_buffer
, demangled
);
6309 demangled
= output_buffer
;
6313 free (output_buffer
);
6324 extern int __gcclibcxx_demangle_callback (const char *,
6326 (const char *, size_t, void *),
6329 /* Alternative, allocationless entry point in the C++ runtime library
6330 for performing demangling. MANGLED_NAME is a NUL-terminated character
6331 string containing the name to be demangled.
6333 CALLBACK is a callback function, called with demangled string
6334 segments as demangling progresses; it is called at least once,
6335 but may be called more than once. OPAQUE is a generalized pointer
6336 used as a callback argument.
6338 The return code is one of the following values, equivalent to
6339 the STATUS values of __cxa_demangle() (excluding -1, since this
6340 function performs no memory allocations):
6341 0: The demangling operation succeeded.
6342 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6343 -3: One of the arguments is invalid.
6345 The demangling is performed using the C++ ABI mangling rules, with
6349 __gcclibcxx_demangle_callback (const char *mangled_name
,
6350 void (*callback
) (const char *, size_t, void *),
6355 if (mangled_name
== NULL
|| callback
== NULL
)
6358 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
6366 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6368 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6369 mangled name, return a buffer allocated with malloc holding the
6370 demangled name. Otherwise, return NULL. */
6373 cplus_demangle_v3 (const char *mangled
, int options
)
6377 return d_demangle (mangled
, options
, &alc
);
6381 cplus_demangle_v3_callback (const char *mangled
, int options
,
6382 demangle_callbackref callback
, void *opaque
)
6384 return d_demangle_callback (mangled
, options
, callback
, opaque
);
6387 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6388 conventions, but the output formatting is a little different.
6389 This instructs the C++ demangler not to emit pointer characters ("*"), to
6390 use Java's namespace separator symbol ("." instead of "::"), and to output
6391 JArray<TYPE> as TYPE[]. */
6394 java_demangle_v3 (const char *mangled
)
6398 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
6402 java_demangle_v3_callback (const char *mangled
,
6403 demangle_callbackref callback
, void *opaque
)
6405 return d_demangle_callback (mangled
,
6406 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
6410 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6412 #ifndef IN_GLIBCPP_V3
6414 /* Demangle a string in order to find out whether it is a constructor
6415 or destructor. Return non-zero on success. Set *CTOR_KIND and
6416 *DTOR_KIND appropriately. */
6419 is_ctor_or_dtor (const char *mangled
,
6420 enum gnu_v3_ctor_kinds
*ctor_kind
,
6421 enum gnu_v3_dtor_kinds
*dtor_kind
)
6424 struct demangle_component
*dc
;
6427 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
6428 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
6430 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
6433 #ifdef CP_DYNAMIC_ARRAYS
6434 __extension__
struct demangle_component comps
[di
.num_comps
];
6435 __extension__
struct demangle_component
*subs
[di
.num_subs
];
6440 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
6441 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
6444 dc
= cplus_demangle_mangled_name (&di
, 1);
6446 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6447 to demangle the entire string. */
6454 /* These cannot appear on a constructor or destructor. */
6455 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
6456 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
6457 case DEMANGLE_COMPONENT_CONST_THIS
:
6458 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
6459 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
6463 case DEMANGLE_COMPONENT_TYPED_NAME
:
6464 case DEMANGLE_COMPONENT_TEMPLATE
:
6467 case DEMANGLE_COMPONENT_QUAL_NAME
:
6468 case DEMANGLE_COMPONENT_LOCAL_NAME
:
6471 case DEMANGLE_COMPONENT_CTOR
:
6472 *ctor_kind
= dc
->u
.s_ctor
.kind
;
6476 case DEMANGLE_COMPONENT_DTOR
:
6477 *dtor_kind
= dc
->u
.s_dtor
.kind
;
6488 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6489 name. A non-zero return indicates the type of constructor. */
6491 enum gnu_v3_ctor_kinds
6492 is_gnu_v3_mangled_ctor (const char *name
)
6494 enum gnu_v3_ctor_kinds ctor_kind
;
6495 enum gnu_v3_dtor_kinds dtor_kind
;
6497 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6498 return (enum gnu_v3_ctor_kinds
) 0;
6503 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6504 name. A non-zero return indicates the type of destructor. */
6506 enum gnu_v3_dtor_kinds
6507 is_gnu_v3_mangled_dtor (const char *name
)
6509 enum gnu_v3_ctor_kinds ctor_kind
;
6510 enum gnu_v3_dtor_kinds dtor_kind
;
6512 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
6513 return (enum gnu_v3_dtor_kinds
) 0;
6517 #endif /* IN_GLIBCPP_V3 */
6519 #ifdef STANDALONE_DEMANGLER
6522 #include "dyn-string.h"
6524 static void print_usage (FILE* fp
, int exit_value
);
6526 #define IS_ALPHA(CHAR) \
6527 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6528 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6530 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6531 #define is_mangled_char(CHAR) \
6532 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6533 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6535 /* The name of this program, as invoked. */
6536 const char* program_name
;
6538 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6541 print_usage (FILE* fp
, int exit_value
)
6543 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
6544 fprintf (fp
, "Options:\n");
6545 fprintf (fp
, " -h,--help Display this message.\n");
6546 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
6547 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
6548 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6553 /* Option specification for getopt_long. */
6554 static const struct option long_options
[] =
6556 { "help", no_argument
, NULL
, 'h' },
6557 { "no-params", no_argument
, NULL
, 'p' },
6558 { "verbose", no_argument
, NULL
, 'v' },
6559 { NULL
, no_argument
, NULL
, 0 },
6562 /* Main entry for a demangling filter executable. It will demangle
6563 its command line arguments, if any. If none are provided, it will
6564 filter stdin to stdout, replacing any recognized mangled C++ names
6565 with their demangled equivalents. */
6568 main (int argc
, char *argv
[])
6572 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
6574 /* Use the program name of this program, as invoked. */
6575 program_name
= argv
[0];
6577 /* Parse options. */
6580 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
6583 case '?': /* Unrecognized option. */
6584 print_usage (stderr
, 1);
6588 print_usage (stdout
, 0);
6592 options
&= ~ DMGL_PARAMS
;
6596 options
|= DMGL_VERBOSE
;
6600 while (opt_char
!= -1);
6603 /* No command line arguments were provided. Filter stdin. */
6605 dyn_string_t mangled
= dyn_string_new (3);
6608 /* Read all of input. */
6609 while (!feof (stdin
))
6613 /* Pile characters into mangled until we hit one that can't
6614 occur in a mangled name. */
6616 while (!feof (stdin
) && is_mangled_char (c
))
6618 dyn_string_append_char (mangled
, c
);
6624 if (dyn_string_length (mangled
) > 0)
6626 #ifdef IN_GLIBCPP_V3
6627 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
6629 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
6639 /* It might not have been a mangled name. Print the
6641 fputs (dyn_string_buf (mangled
), stdout
);
6644 dyn_string_clear (mangled
);
6647 /* If we haven't hit EOF yet, we've read one character that
6648 can't occur in a mangled name, so print it out. */
6653 dyn_string_delete (mangled
);
6656 /* Demangle command line arguments. */
6658 /* Loop over command line arguments. */
6659 for (i
= optind
; i
< argc
; ++i
)
6662 #ifdef IN_GLIBCPP_V3
6666 /* Attempt to demangle. */
6667 #ifdef IN_GLIBCPP_V3
6668 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
6670 s
= cplus_demangle_v3 (argv
[i
], options
);
6673 /* If it worked, print the demangled name. */
6681 #ifdef IN_GLIBCPP_V3
6682 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
6684 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
6693 #endif /* STANDALONE_DEMANGLER */