1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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 (_AIX) && !defined (__GNUC__)
120 # define alloca __builtin_alloca
122 extern char *alloca ();
123 # endif /* __GNUC__ */
125 #endif /* HAVE_ALLOCA_H */
127 #include "ansidecl.h"
128 #include "libiberty.h"
129 #include "demangle.h"
130 #include "cp-demangle.h"
132 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
133 also rename them via #define to avoid compiler errors when the
134 static definition conflicts with the extern declaration in a header
138 #define CP_STATIC_IF_GLIBCPP_V3 static
140 #define cplus_demangle_fill_name d_fill_name
141 static int d_fill_name (struct demangle_component
*, const char *, int);
143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
145 d_fill_extended_operator (struct demangle_component
*, int,
146 struct demangle_component
*);
148 #define cplus_demangle_fill_ctor d_fill_ctor
150 d_fill_ctor (struct demangle_component
*, enum gnu_v3_ctor_kinds
,
151 struct demangle_component
*);
153 #define cplus_demangle_fill_dtor d_fill_dtor
155 d_fill_dtor (struct demangle_component
*, enum gnu_v3_dtor_kinds
,
156 struct demangle_component
*);
158 #define cplus_demangle_mangled_name d_mangled_name
159 static struct demangle_component
*d_mangled_name (struct d_info
*, int);
161 #define cplus_demangle_type d_type
162 static struct demangle_component
*d_type (struct d_info
*);
164 #define cplus_demangle_print d_print
165 static char *d_print (int, const struct demangle_component
*, int, size_t *);
167 #define cplus_demangle_print_callback d_print_callback
168 static int d_print_callback (int, const struct demangle_component
*,
169 demangle_callbackref
, void *);
171 #define cplus_demangle_init_info d_init_info
172 static void d_init_info (const char *, int, size_t, struct d_info
*);
174 #else /* ! defined(IN_GLIBCPP_V3) */
175 #define CP_STATIC_IF_GLIBCPP_V3
176 #endif /* ! defined(IN_GLIBCPP_V3) */
178 /* See if the compiler supports dynamic arrays. */
181 #define CP_DYNAMIC_ARRAYS
184 #ifdef __STDC_VERSION__
185 #if __STDC_VERSION__ >= 199901L
186 #define CP_DYNAMIC_ARRAYS
187 #endif /* __STDC__VERSION >= 199901L */
188 #endif /* defined (__STDC_VERSION__) */
189 #endif /* defined (__STDC__) */
190 #endif /* ! defined (__GNUC__) */
192 /* We avoid pulling in the ctype tables, to prevent pulling in
193 additional unresolved symbols when this code is used in a library.
194 FIXME: Is this really a valid reason? This comes from the original
197 As of this writing this file has the following undefined references
198 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
205 /* The prefix prepended by GCC to an identifier represnting the
206 anonymous namespace. */
207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
209 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
211 /* Information we keep for the standard substitutions. */
213 struct d_standard_sub_info
215 /* The code for this substitution. */
217 /* The simple string it expands to. */
218 const char *simple_expansion
;
219 /* The length of the simple expansion. */
221 /* The results of a full, verbose, expansion. This is used when
222 qualifying a constructor/destructor, or when in verbose mode. */
223 const char *full_expansion
;
224 /* The length of the full expansion. */
226 /* What to set the last_name field of d_info to; NULL if we should
227 not set it. This is only relevant when qualifying a
228 constructor/destructor. */
229 const char *set_last_name
;
230 /* The length of set_last_name. */
231 int set_last_name_len
;
234 /* Accessors for subtrees of struct demangle_component. */
236 #define d_left(dc) ((dc)->u.s_binary.left)
237 #define d_right(dc) ((dc)->u.s_binary.right)
239 /* A list of templates. This is used while printing. */
241 struct d_print_template
243 /* Next template on the list. */
244 struct d_print_template
*next
;
246 const struct demangle_component
*template_decl
;
249 /* A list of type modifiers. This is used while printing. */
253 /* Next modifier on the list. These are in the reverse of the order
254 in which they appeared in the mangled string. */
255 struct d_print_mod
*next
;
257 const struct demangle_component
*mod
;
258 /* Whether this modifier was printed. */
260 /* The list of templates which applies to this modifier. */
261 struct d_print_template
*templates
;
264 /* We use these structures to hold information during printing. */
266 struct d_growable_string
268 /* Buffer holding the result. */
270 /* Current length of data in buffer. */
272 /* Allocated size of buffer. */
274 /* Set to 1 if we had a memory allocation failure. */
275 int allocation_failure
;
278 enum { D_PRINT_BUFFER_LENGTH
= 256 };
281 /* Fixed-length allocated buffer for demangled data, flushed to the
282 callback with a NUL termination once full. */
283 char buf
[D_PRINT_BUFFER_LENGTH
];
284 /* Current length of data in buffer. */
286 /* The last character printed, saved individually so that it survives
289 /* Callback function to handle demangled buffer flush. */
290 demangle_callbackref callback
;
291 /* Opaque callback argument. */
293 /* The current list of templates, if any. */
294 struct d_print_template
*templates
;
295 /* The current list of modifiers (e.g., pointer, reference, etc.),
297 struct d_print_mod
*modifiers
;
298 /* Set to 1 if we saw a demangling error. */
299 int demangle_failure
;
300 /* The current index into any template argument packs we are using
303 /* Number of d_print_flush calls so far. */
304 unsigned long int flush_count
;
307 #ifdef CP_DEMANGLE_DEBUG
308 static void d_dump (struct demangle_component
*, int);
311 static struct demangle_component
*
312 d_make_empty (struct d_info
*);
314 static struct demangle_component
*
315 d_make_comp (struct d_info
*, enum demangle_component_type
,
316 struct demangle_component
*,
317 struct demangle_component
*);
319 static struct demangle_component
*
320 d_make_name (struct d_info
*, const char *, int);
322 static struct demangle_component
*
323 d_make_demangle_mangled_name (struct d_info
*, const char *);
325 static struct demangle_component
*
326 d_make_builtin_type (struct d_info
*,
327 const struct demangle_builtin_type_info
*);
329 static struct demangle_component
*
330 d_make_operator (struct d_info
*,
331 const struct demangle_operator_info
*);
333 static struct demangle_component
*
334 d_make_extended_operator (struct d_info
*, int,
335 struct demangle_component
*);
337 static struct demangle_component
*
338 d_make_ctor (struct d_info
*, enum gnu_v3_ctor_kinds
,
339 struct demangle_component
*);
341 static struct demangle_component
*
342 d_make_dtor (struct d_info
*, enum gnu_v3_dtor_kinds
,
343 struct demangle_component
*);
345 static struct demangle_component
*
346 d_make_template_param (struct d_info
*, long);
348 static struct demangle_component
*
349 d_make_sub (struct d_info
*, const char *, int);
352 has_return_type (struct demangle_component
*);
355 is_ctor_dtor_or_conversion (struct demangle_component
*);
357 static struct demangle_component
*d_encoding (struct d_info
*, int);
359 static struct demangle_component
*d_name (struct d_info
*);
361 static struct demangle_component
*d_nested_name (struct d_info
*);
363 static struct demangle_component
*d_prefix (struct d_info
*);
365 static struct demangle_component
*d_unqualified_name (struct d_info
*);
367 static struct demangle_component
*d_source_name (struct d_info
*);
369 static long d_number (struct d_info
*);
371 static struct demangle_component
*d_identifier (struct d_info
*, int);
373 static struct demangle_component
*d_operator_name (struct d_info
*);
375 static struct demangle_component
*d_special_name (struct d_info
*);
377 static int d_call_offset (struct d_info
*, int);
379 static struct demangle_component
*d_ctor_dtor_name (struct d_info
*);
381 static struct demangle_component
**
382 d_cv_qualifiers (struct d_info
*, struct demangle_component
**, int);
384 static struct demangle_component
*
385 d_ref_qualifier (struct d_info
*, struct demangle_component
*);
387 static struct demangle_component
*
388 d_function_type (struct d_info
*);
390 static struct demangle_component
*
391 d_bare_function_type (struct d_info
*, int);
393 static struct demangle_component
*
394 d_class_enum_type (struct d_info
*);
396 static struct demangle_component
*d_array_type (struct d_info
*);
398 static struct demangle_component
*d_vector_type (struct d_info
*);
400 static struct demangle_component
*
401 d_pointer_to_member_type (struct d_info
*);
403 static struct demangle_component
*
404 d_template_param (struct d_info
*);
406 static struct demangle_component
*d_template_args (struct d_info
*);
408 static struct demangle_component
*
409 d_template_arg (struct d_info
*);
411 static struct demangle_component
*d_expression (struct d_info
*);
413 static struct demangle_component
*d_expr_primary (struct d_info
*);
415 static struct demangle_component
*d_local_name (struct d_info
*);
417 static int d_discriminator (struct d_info
*);
419 static struct demangle_component
*d_lambda (struct d_info
*);
421 static struct demangle_component
*d_unnamed_type (struct d_info
*);
423 static struct demangle_component
*
424 d_clone_suffix (struct d_info
*, struct demangle_component
*);
427 d_add_substitution (struct d_info
*, struct demangle_component
*);
429 static struct demangle_component
*d_substitution (struct d_info
*, int);
431 static void d_growable_string_init (struct d_growable_string
*, size_t);
434 d_growable_string_resize (struct d_growable_string
*, size_t);
437 d_growable_string_append_buffer (struct d_growable_string
*,
438 const char *, size_t);
440 d_growable_string_callback_adapter (const char *, size_t, void *);
443 d_print_init (struct d_print_info
*, demangle_callbackref
, void *);
445 static inline void d_print_error (struct d_print_info
*);
447 static inline int d_print_saw_error (struct d_print_info
*);
449 static inline void d_print_flush (struct d_print_info
*);
451 static inline void d_append_char (struct d_print_info
*, char);
453 static inline void d_append_buffer (struct d_print_info
*,
454 const char *, size_t);
456 static inline void d_append_string (struct d_print_info
*, const char *);
458 static inline char d_last_char (struct d_print_info
*);
461 d_print_comp (struct d_print_info
*, int, const struct demangle_component
*);
464 d_print_java_identifier (struct d_print_info
*, const char *, int);
467 d_print_mod_list (struct d_print_info
*, int, struct d_print_mod
*, int);
470 d_print_mod (struct d_print_info
*, int, const struct demangle_component
*);
473 d_print_function_type (struct d_print_info
*, int,
474 const struct demangle_component
*,
475 struct d_print_mod
*);
478 d_print_array_type (struct d_print_info
*, int,
479 const struct demangle_component
*,
480 struct d_print_mod
*);
483 d_print_expr_op (struct d_print_info
*, int, const struct demangle_component
*);
486 d_print_cast (struct d_print_info
*, int, const struct demangle_component
*);
488 static int d_demangle_callback (const char *, int,
489 demangle_callbackref
, void *);
490 static char *d_demangle (const char *, int, size_t *);
492 #ifdef CP_DEMANGLE_DEBUG
495 d_dump (struct demangle_component
*dc
, int indent
)
502 printf ("failed demangling\n");
506 for (i
= 0; i
< indent
; ++i
)
511 case DEMANGLE_COMPONENT_NAME
:
512 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
514 case DEMANGLE_COMPONENT_TAGGED_NAME
:
515 printf ("tagged name\n");
516 d_dump (dc
->u
.s_binary
.left
, indent
+ 2);
517 d_dump (dc
->u
.s_binary
.right
, indent
+ 2);
519 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
520 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
522 case DEMANGLE_COMPONENT_CTOR
:
523 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
524 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
526 case DEMANGLE_COMPONENT_DTOR
:
527 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
528 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
530 case DEMANGLE_COMPONENT_SUB_STD
:
531 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
533 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
534 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
536 case DEMANGLE_COMPONENT_OPERATOR
:
537 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
539 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
540 printf ("extended operator with %d args\n",
541 dc
->u
.s_extended_operator
.args
);
542 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
545 case DEMANGLE_COMPONENT_QUAL_NAME
:
546 printf ("qualified name\n");
548 case DEMANGLE_COMPONENT_LOCAL_NAME
:
549 printf ("local name\n");
551 case DEMANGLE_COMPONENT_TYPED_NAME
:
552 printf ("typed name\n");
554 case DEMANGLE_COMPONENT_TEMPLATE
:
555 printf ("template\n");
557 case DEMANGLE_COMPONENT_VTABLE
:
560 case DEMANGLE_COMPONENT_VTT
:
563 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
564 printf ("construction vtable\n");
566 case DEMANGLE_COMPONENT_TYPEINFO
:
567 printf ("typeinfo\n");
569 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
570 printf ("typeinfo name\n");
572 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
573 printf ("typeinfo function\n");
575 case DEMANGLE_COMPONENT_THUNK
:
578 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
579 printf ("virtual thunk\n");
581 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
582 printf ("covariant thunk\n");
584 case DEMANGLE_COMPONENT_JAVA_CLASS
:
585 printf ("java class\n");
587 case DEMANGLE_COMPONENT_GUARD
:
590 case DEMANGLE_COMPONENT_REFTEMP
:
591 printf ("reference temporary\n");
593 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
594 printf ("hidden alias\n");
596 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
597 printf ("transaction clone\n");
599 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
600 printf ("non-transaction clone\n");
602 case DEMANGLE_COMPONENT_RESTRICT
:
603 printf ("restrict\n");
605 case DEMANGLE_COMPONENT_VOLATILE
:
606 printf ("volatile\n");
608 case DEMANGLE_COMPONENT_CONST
:
611 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
612 printf ("restrict this\n");
614 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
615 printf ("volatile this\n");
617 case DEMANGLE_COMPONENT_CONST_THIS
:
618 printf ("const this\n");
620 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
621 printf ("reference this\n");
623 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
624 printf ("rvalue reference this\n");
626 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
627 printf ("vendor type qualifier\n");
629 case DEMANGLE_COMPONENT_POINTER
:
630 printf ("pointer\n");
632 case DEMANGLE_COMPONENT_REFERENCE
:
633 printf ("reference\n");
635 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
636 printf ("rvalue reference\n");
638 case DEMANGLE_COMPONENT_COMPLEX
:
639 printf ("complex\n");
641 case DEMANGLE_COMPONENT_IMAGINARY
:
642 printf ("imaginary\n");
644 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
645 printf ("vendor type\n");
647 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
648 printf ("function type\n");
650 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
651 printf ("array type\n");
653 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
654 printf ("pointer to member type\n");
656 case DEMANGLE_COMPONENT_FIXED_TYPE
:
657 printf ("fixed-point type\n");
659 case DEMANGLE_COMPONENT_ARGLIST
:
660 printf ("argument list\n");
662 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
663 printf ("template argument list\n");
665 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
666 printf ("initializer list\n");
668 case DEMANGLE_COMPONENT_CAST
:
671 case DEMANGLE_COMPONENT_NULLARY
:
672 printf ("nullary operator\n");
674 case DEMANGLE_COMPONENT_UNARY
:
675 printf ("unary operator\n");
677 case DEMANGLE_COMPONENT_BINARY
:
678 printf ("binary operator\n");
680 case DEMANGLE_COMPONENT_BINARY_ARGS
:
681 printf ("binary operator arguments\n");
683 case DEMANGLE_COMPONENT_TRINARY
:
684 printf ("trinary operator\n");
686 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
687 printf ("trinary operator arguments 1\n");
689 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
690 printf ("trinary operator arguments 1\n");
692 case DEMANGLE_COMPONENT_LITERAL
:
693 printf ("literal\n");
695 case DEMANGLE_COMPONENT_LITERAL_NEG
:
696 printf ("negative literal\n");
698 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
699 printf ("java resource\n");
701 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
702 printf ("compound name\n");
704 case DEMANGLE_COMPONENT_CHARACTER
:
705 printf ("character '%c'\n", dc
->u
.s_character
.character
);
707 case DEMANGLE_COMPONENT_DECLTYPE
:
708 printf ("decltype\n");
710 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
711 printf ("pack expansion\n");
713 case DEMANGLE_COMPONENT_TLS_INIT
:
714 printf ("tls init function\n");
716 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
717 printf ("tls wrapper function\n");
719 case DEMANGLE_COMPONENT_DEFAULT_ARG
:
720 printf ("default argument %d\n", dc
->u
.s_unary_num
.num
);
721 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
723 case DEMANGLE_COMPONENT_LAMBDA
:
724 printf ("lambda %d\n", dc
->u
.s_unary_num
.num
);
725 d_dump (dc
->u
.s_unary_num
.sub
, indent
+2);
729 d_dump (d_left (dc
), indent
+ 2);
730 d_dump (d_right (dc
), indent
+ 2);
733 #endif /* CP_DEMANGLE_DEBUG */
735 /* Fill in a DEMANGLE_COMPONENT_NAME. */
737 CP_STATIC_IF_GLIBCPP_V3
739 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
741 if (p
== NULL
|| s
== NULL
|| len
== 0)
743 p
->type
= DEMANGLE_COMPONENT_NAME
;
745 p
->u
.s_name
.len
= len
;
749 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
751 CP_STATIC_IF_GLIBCPP_V3
753 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
754 struct demangle_component
*name
)
756 if (p
== NULL
|| args
< 0 || name
== NULL
)
758 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
759 p
->u
.s_extended_operator
.args
= args
;
760 p
->u
.s_extended_operator
.name
= name
;
764 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
766 CP_STATIC_IF_GLIBCPP_V3
768 cplus_demangle_fill_ctor (struct demangle_component
*p
,
769 enum gnu_v3_ctor_kinds kind
,
770 struct demangle_component
*name
)
774 || (int) kind
< gnu_v3_complete_object_ctor
775 || (int) kind
> gnu_v3_object_ctor_group
)
777 p
->type
= DEMANGLE_COMPONENT_CTOR
;
778 p
->u
.s_ctor
.kind
= kind
;
779 p
->u
.s_ctor
.name
= name
;
783 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
785 CP_STATIC_IF_GLIBCPP_V3
787 cplus_demangle_fill_dtor (struct demangle_component
*p
,
788 enum gnu_v3_dtor_kinds kind
,
789 struct demangle_component
*name
)
793 || (int) kind
< gnu_v3_deleting_dtor
794 || (int) kind
> gnu_v3_object_dtor_group
)
796 p
->type
= DEMANGLE_COMPONENT_DTOR
;
797 p
->u
.s_dtor
.kind
= kind
;
798 p
->u
.s_dtor
.name
= name
;
802 /* Add a new component. */
804 static struct demangle_component
*
805 d_make_empty (struct d_info
*di
)
807 struct demangle_component
*p
;
809 if (di
->next_comp
>= di
->num_comps
)
811 p
= &di
->comps
[di
->next_comp
];
816 /* Add a new generic component. */
818 static struct demangle_component
*
819 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
820 struct demangle_component
*left
,
821 struct demangle_component
*right
)
823 struct demangle_component
*p
;
825 /* We check for errors here. A typical error would be a NULL return
826 from a subroutine. We catch those here, and return NULL
830 /* These types require two parameters. */
831 case DEMANGLE_COMPONENT_QUAL_NAME
:
832 case DEMANGLE_COMPONENT_LOCAL_NAME
:
833 case DEMANGLE_COMPONENT_TYPED_NAME
:
834 case DEMANGLE_COMPONENT_TAGGED_NAME
:
835 case DEMANGLE_COMPONENT_TEMPLATE
:
836 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
837 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
838 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
839 case DEMANGLE_COMPONENT_UNARY
:
840 case DEMANGLE_COMPONENT_BINARY
:
841 case DEMANGLE_COMPONENT_BINARY_ARGS
:
842 case DEMANGLE_COMPONENT_TRINARY
:
843 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
844 case DEMANGLE_COMPONENT_LITERAL
:
845 case DEMANGLE_COMPONENT_LITERAL_NEG
:
846 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
847 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
848 case DEMANGLE_COMPONENT_CLONE
:
849 if (left
== NULL
|| right
== NULL
)
853 /* These types only require one parameter. */
854 case DEMANGLE_COMPONENT_VTABLE
:
855 case DEMANGLE_COMPONENT_VTT
:
856 case DEMANGLE_COMPONENT_TYPEINFO
:
857 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
858 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
859 case DEMANGLE_COMPONENT_THUNK
:
860 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
861 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
862 case DEMANGLE_COMPONENT_JAVA_CLASS
:
863 case DEMANGLE_COMPONENT_GUARD
:
864 case DEMANGLE_COMPONENT_TLS_INIT
:
865 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
866 case DEMANGLE_COMPONENT_REFTEMP
:
867 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
868 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
869 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
870 case DEMANGLE_COMPONENT_POINTER
:
871 case DEMANGLE_COMPONENT_REFERENCE
:
872 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
873 case DEMANGLE_COMPONENT_COMPLEX
:
874 case DEMANGLE_COMPONENT_IMAGINARY
:
875 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
876 case DEMANGLE_COMPONENT_CAST
:
877 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
878 case DEMANGLE_COMPONENT_DECLTYPE
:
879 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
880 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
881 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
882 case DEMANGLE_COMPONENT_NULLARY
:
883 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
888 /* This needs a right parameter, but the left parameter can be
890 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
891 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
896 /* These are allowed to have no parameters--in some cases they
897 will be filled in later. */
898 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
899 case DEMANGLE_COMPONENT_RESTRICT
:
900 case DEMANGLE_COMPONENT_VOLATILE
:
901 case DEMANGLE_COMPONENT_CONST
:
902 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
903 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
904 case DEMANGLE_COMPONENT_CONST_THIS
:
905 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
906 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
907 case DEMANGLE_COMPONENT_ARGLIST
:
908 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
911 /* Other types should not be seen here. */
916 p
= d_make_empty (di
);
920 p
->u
.s_binary
.left
= left
;
921 p
->u
.s_binary
.right
= right
;
926 /* Add a new demangle mangled name component. */
928 static struct demangle_component
*
929 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
931 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
932 return d_make_name (di
, s
, strlen (s
));
934 return d_encoding (di
, 0);
937 /* Add a new name component. */
939 static struct demangle_component
*
940 d_make_name (struct d_info
*di
, const char *s
, int len
)
942 struct demangle_component
*p
;
944 p
= d_make_empty (di
);
945 if (! cplus_demangle_fill_name (p
, s
, len
))
950 /* Add a new builtin type component. */
952 static struct demangle_component
*
953 d_make_builtin_type (struct d_info
*di
,
954 const struct demangle_builtin_type_info
*type
)
956 struct demangle_component
*p
;
960 p
= d_make_empty (di
);
963 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
964 p
->u
.s_builtin
.type
= type
;
969 /* Add a new operator component. */
971 static struct demangle_component
*
972 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
974 struct demangle_component
*p
;
976 p
= d_make_empty (di
);
979 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
980 p
->u
.s_operator
.op
= op
;
985 /* Add a new extended operator component. */
987 static struct demangle_component
*
988 d_make_extended_operator (struct d_info
*di
, int args
,
989 struct demangle_component
*name
)
991 struct demangle_component
*p
;
993 p
= d_make_empty (di
);
994 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
999 static struct demangle_component
*
1000 d_make_default_arg (struct d_info
*di
, int num
,
1001 struct demangle_component
*sub
)
1003 struct demangle_component
*p
= d_make_empty (di
);
1006 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
1007 p
->u
.s_unary_num
.num
= num
;
1008 p
->u
.s_unary_num
.sub
= sub
;
1013 /* Add a new constructor component. */
1015 static struct demangle_component
*
1016 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
1017 struct demangle_component
*name
)
1019 struct demangle_component
*p
;
1021 p
= d_make_empty (di
);
1022 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
1027 /* Add a new destructor component. */
1029 static struct demangle_component
*
1030 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
1031 struct demangle_component
*name
)
1033 struct demangle_component
*p
;
1035 p
= d_make_empty (di
);
1036 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1041 /* Add a new template parameter. */
1043 static struct demangle_component
*
1044 d_make_template_param (struct d_info
*di
, long i
)
1046 struct demangle_component
*p
;
1048 p
= d_make_empty (di
);
1051 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1052 p
->u
.s_number
.number
= i
;
1057 /* Add a new function parameter. */
1059 static struct demangle_component
*
1060 d_make_function_param (struct d_info
*di
, long i
)
1062 struct demangle_component
*p
;
1064 p
= d_make_empty (di
);
1067 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1068 p
->u
.s_number
.number
= i
;
1073 /* Add a new standard substitution component. */
1075 static struct demangle_component
*
1076 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1078 struct demangle_component
*p
;
1080 p
= d_make_empty (di
);
1083 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1084 p
->u
.s_string
.string
= name
;
1085 p
->u
.s_string
.len
= len
;
1090 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1092 TOP_LEVEL is non-zero when called at the top level. */
1094 CP_STATIC_IF_GLIBCPP_V3
1095 struct demangle_component
*
1096 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1098 struct demangle_component
*p
;
1100 if (! d_check_char (di
, '_')
1101 /* Allow missing _ if not at toplevel to work around a
1102 bug in G++ abi-version=2 mangling; see the comment in
1103 write_template_arg. */
1106 if (! d_check_char (di
, 'Z'))
1108 p
= d_encoding (di
, top_level
);
1110 /* If at top level and parsing parameters, check for a clone
1112 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1113 while (d_peek_char (di
) == '.'
1114 && (IS_LOWER (d_peek_next_char (di
))
1115 || d_peek_next_char (di
) == '_'
1116 || IS_DIGIT (d_peek_next_char (di
))))
1117 p
= d_clone_suffix (di
, p
);
1122 /* Return whether a function should have a return type. The argument
1123 is the function name, which may be qualified in various ways. The
1124 rules are that template functions have return types with some
1125 exceptions, function types which are not part of a function name
1126 mangling have return types with some exceptions, and non-template
1127 function names do not have return types. The exceptions are that
1128 constructors, destructors, and conversion operators do not have
1132 has_return_type (struct demangle_component
*dc
)
1140 case DEMANGLE_COMPONENT_TEMPLATE
:
1141 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1142 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
1143 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
1144 case DEMANGLE_COMPONENT_CONST_THIS
:
1145 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
1146 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
1147 return has_return_type (d_left (dc
));
1151 /* Return whether a name is a constructor, a destructor, or a
1152 conversion operator. */
1155 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1163 case DEMANGLE_COMPONENT_QUAL_NAME
:
1164 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1165 return is_ctor_dtor_or_conversion (d_right (dc
));
1166 case DEMANGLE_COMPONENT_CTOR
:
1167 case DEMANGLE_COMPONENT_DTOR
:
1168 case DEMANGLE_COMPONENT_CAST
:
1173 /* <encoding> ::= <(function) name> <bare-function-type>
1177 TOP_LEVEL is non-zero when called at the top level, in which case
1178 if DMGL_PARAMS is not set we do not demangle the function
1179 parameters. We only set this at the top level, because otherwise
1180 we would not correctly demangle names in local scopes. */
1182 static struct demangle_component
*
1183 d_encoding (struct d_info
*di
, int top_level
)
1185 char peek
= d_peek_char (di
);
1187 if (peek
== 'G' || peek
== 'T')
1188 return d_special_name (di
);
1191 struct demangle_component
*dc
;
1195 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1197 /* Strip off any initial CV-qualifiers, as they really apply
1198 to the `this' parameter, and they were not output by the
1199 v2 demangler without DMGL_PARAMS. */
1200 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1201 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1202 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
1203 || dc
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
1204 || dc
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
)
1207 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1208 there may be CV-qualifiers on its right argument which
1209 really apply here; this happens when parsing a class
1210 which is local to a function. */
1211 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1213 struct demangle_component
*dcr
;
1216 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1217 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1218 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
1219 || dcr
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
1220 || dcr
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
)
1222 dc
->u
.s_binary
.right
= dcr
;
1228 peek
= d_peek_char (di
);
1229 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1231 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1232 d_bare_function_type (di
, has_return_type (dc
)));
1236 /* <tagged-name> ::= <name> B <source-name> */
1238 static struct demangle_component
*
1239 d_abi_tags (struct d_info
*di
, struct demangle_component
*dc
)
1242 while (peek
= d_peek_char (di
),
1245 struct demangle_component
*tag
;
1247 tag
= d_source_name (di
);
1248 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TAGGED_NAME
, dc
, tag
);
1253 /* <name> ::= <nested-name>
1255 ::= <unscoped-template-name> <template-args>
1258 <unscoped-name> ::= <unqualified-name>
1259 ::= St <unqualified-name>
1261 <unscoped-template-name> ::= <unscoped-name>
1265 static struct demangle_component
*
1266 d_name (struct d_info
*di
)
1268 char peek
= d_peek_char (di
);
1269 struct demangle_component
*dc
;
1274 return d_nested_name (di
);
1277 return d_local_name (di
);
1281 return d_unqualified_name (di
);
1287 if (d_peek_next_char (di
) != 't')
1289 dc
= d_substitution (di
, 0);
1295 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1296 d_make_name (di
, "std", 3),
1297 d_unqualified_name (di
));
1302 if (d_peek_char (di
) != 'I')
1304 /* The grammar does not permit this case to occur if we
1305 called d_substitution() above (i.e., subst == 1). We
1306 don't bother to check. */
1310 /* This is <template-args>, which means that we just saw
1311 <unscoped-template-name>, which is a substitution
1312 candidate if we didn't just get it from a
1316 if (! d_add_substitution (di
, dc
))
1319 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1320 d_template_args (di
));
1327 dc
= d_unqualified_name (di
);
1328 if (d_peek_char (di
) == 'I')
1330 /* This is <template-args>, which means that we just saw
1331 <unscoped-template-name>, which is a substitution
1333 if (! d_add_substitution (di
, dc
))
1335 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1336 d_template_args (di
));
1342 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1343 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1346 static struct demangle_component
*
1347 d_nested_name (struct d_info
*di
)
1349 struct demangle_component
*ret
;
1350 struct demangle_component
**pret
;
1351 struct demangle_component
*rqual
;
1353 if (! d_check_char (di
, 'N'))
1356 pret
= d_cv_qualifiers (di
, &ret
, 1);
1360 /* Parse the ref-qualifier now and then attach it
1361 once we have something to attach it to. */
1362 rqual
= d_ref_qualifier (di
, NULL
);
1364 *pret
= d_prefix (di
);
1370 d_left (rqual
) = ret
;
1374 if (! d_check_char (di
, 'E'))
1380 /* <prefix> ::= <prefix> <unqualified-name>
1381 ::= <template-prefix> <template-args>
1382 ::= <template-param>
1387 <template-prefix> ::= <prefix> <(template) unqualified-name>
1388 ::= <template-param>
1392 static struct demangle_component
*
1393 d_prefix (struct d_info
*di
)
1395 struct demangle_component
*ret
= NULL
;
1400 enum demangle_component_type comb_type
;
1401 struct demangle_component
*dc
;
1403 peek
= d_peek_char (di
);
1407 /* The older code accepts a <local-name> here, but I don't see
1408 that in the grammar. The older code does not accept a
1409 <template-param> here. */
1411 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1414 char peek2
= d_peek_next_char (di
);
1415 if (peek2
== 'T' || peek2
== 't')
1417 dc
= cplus_demangle_type (di
);
1419 /* Destructor name. */
1420 dc
= d_unqualified_name (di
);
1422 else if (IS_DIGIT (peek
)
1427 dc
= d_unqualified_name (di
);
1428 else if (peek
== 'S')
1429 dc
= d_substitution (di
, 1);
1430 else if (peek
== 'I')
1434 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1435 dc
= d_template_args (di
);
1437 else if (peek
== 'T')
1438 dc
= d_template_param (di
);
1439 else if (peek
== 'E')
1441 else if (peek
== 'M')
1443 /* Initializer scope for a lambda. We don't need to represent
1444 this; the normal code will just treat the variable as a type
1445 scope, which gives appropriate output. */
1457 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1459 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1461 if (! d_add_substitution (di
, ret
))
1467 /* <unqualified-name> ::= <operator-name>
1468 ::= <ctor-dtor-name>
1470 ::= <local-source-name>
1472 <local-source-name> ::= L <source-name> <discriminator>
1475 static struct demangle_component
*
1476 d_unqualified_name (struct d_info
*di
)
1478 struct demangle_component
*ret
;
1481 peek
= d_peek_char (di
);
1482 if (IS_DIGIT (peek
))
1483 ret
= d_source_name (di
);
1484 else if (IS_LOWER (peek
))
1486 ret
= d_operator_name (di
);
1487 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1489 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1490 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1491 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1492 d_source_name (di
));
1495 else if (peek
== 'C' || peek
== 'D')
1496 ret
= d_ctor_dtor_name (di
);
1497 else if (peek
== 'L')
1501 ret
= d_source_name (di
);
1504 if (! d_discriminator (di
))
1507 else if (peek
== 'U')
1509 switch (d_peek_next_char (di
))
1512 ret
= d_lambda (di
);
1515 ret
= d_unnamed_type (di
);
1524 if (d_peek_char (di
) == 'B')
1525 ret
= d_abi_tags (di
, ret
);
1529 /* <source-name> ::= <(positive length) number> <identifier> */
1531 static struct demangle_component
*
1532 d_source_name (struct d_info
*di
)
1535 struct demangle_component
*ret
;
1537 len
= d_number (di
);
1540 ret
= d_identifier (di
, len
);
1541 di
->last_name
= ret
;
1545 /* number ::= [n] <(non-negative decimal integer)> */
1548 d_number (struct d_info
*di
)
1555 peek
= d_peek_char (di
);
1560 peek
= d_peek_char (di
);
1566 if (! IS_DIGIT (peek
))
1572 ret
= ret
* 10 + peek
- '0';
1574 peek
= d_peek_char (di
);
1578 /* Like d_number, but returns a demangle_component. */
1580 static struct demangle_component
*
1581 d_number_component (struct d_info
*di
)
1583 struct demangle_component
*ret
= d_make_empty (di
);
1586 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1587 ret
->u
.s_number
.number
= d_number (di
);
1592 /* identifier ::= <(unqualified source code identifier)> */
1594 static struct demangle_component
*
1595 d_identifier (struct d_info
*di
, int len
)
1601 if (di
->send
- name
< len
)
1604 d_advance (di
, len
);
1606 /* A Java mangled name may have a trailing '$' if it is a C++
1607 keyword. This '$' is not included in the length count. We just
1609 if ((di
->options
& DMGL_JAVA
) != 0
1610 && d_peek_char (di
) == '$')
1613 /* Look for something which looks like a gcc encoding of an
1614 anonymous namespace, and replace it with a more user friendly
1616 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1617 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1618 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1622 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1623 if ((*s
== '.' || *s
== '_' || *s
== '$')
1626 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1627 return d_make_name (di
, "(anonymous namespace)",
1628 sizeof "(anonymous namespace)" - 1);
1632 return d_make_name (di
, name
, len
);
1635 /* operator_name ::= many different two character encodings.
1637 ::= v <digit> <source-name>
1639 This list is sorted for binary search. */
1641 #define NL(s) s, (sizeof s) - 1
1643 CP_STATIC_IF_GLIBCPP_V3
1644 const struct demangle_operator_info cplus_demangle_operators
[] =
1646 { "aN", NL ("&="), 2 },
1647 { "aS", NL ("="), 2 },
1648 { "aa", NL ("&&"), 2 },
1649 { "ad", NL ("&"), 1 },
1650 { "an", NL ("&"), 2 },
1651 { "at", NL ("alignof "), 1 },
1652 { "az", NL ("alignof "), 1 },
1653 { "cc", NL ("const_cast"), 2 },
1654 { "cl", NL ("()"), 2 },
1655 { "cm", NL (","), 2 },
1656 { "co", NL ("~"), 1 },
1657 { "dV", NL ("/="), 2 },
1658 { "da", NL ("delete[] "), 1 },
1659 { "dc", NL ("dynamic_cast"), 2 },
1660 { "de", NL ("*"), 1 },
1661 { "dl", NL ("delete "), 1 },
1662 { "ds", NL (".*"), 2 },
1663 { "dt", NL ("."), 2 },
1664 { "dv", NL ("/"), 2 },
1665 { "eO", NL ("^="), 2 },
1666 { "eo", NL ("^"), 2 },
1667 { "eq", NL ("=="), 2 },
1668 { "ge", NL (">="), 2 },
1669 { "gs", NL ("::"), 1 },
1670 { "gt", NL (">"), 2 },
1671 { "ix", NL ("[]"), 2 },
1672 { "lS", NL ("<<="), 2 },
1673 { "le", NL ("<="), 2 },
1674 { "li", NL ("operator\"\" "), 1 },
1675 { "ls", NL ("<<"), 2 },
1676 { "lt", NL ("<"), 2 },
1677 { "mI", NL ("-="), 2 },
1678 { "mL", NL ("*="), 2 },
1679 { "mi", NL ("-"), 2 },
1680 { "ml", NL ("*"), 2 },
1681 { "mm", NL ("--"), 1 },
1682 { "na", NL ("new[]"), 3 },
1683 { "ne", NL ("!="), 2 },
1684 { "ng", NL ("-"), 1 },
1685 { "nt", NL ("!"), 1 },
1686 { "nw", NL ("new"), 3 },
1687 { "oR", NL ("|="), 2 },
1688 { "oo", NL ("||"), 2 },
1689 { "or", NL ("|"), 2 },
1690 { "pL", NL ("+="), 2 },
1691 { "pl", NL ("+"), 2 },
1692 { "pm", NL ("->*"), 2 },
1693 { "pp", NL ("++"), 1 },
1694 { "ps", NL ("+"), 1 },
1695 { "pt", NL ("->"), 2 },
1696 { "qu", NL ("?"), 3 },
1697 { "rM", NL ("%="), 2 },
1698 { "rS", NL (">>="), 2 },
1699 { "rc", NL ("reinterpret_cast"), 2 },
1700 { "rm", NL ("%"), 2 },
1701 { "rs", NL (">>"), 2 },
1702 { "sc", NL ("static_cast"), 2 },
1703 { "st", NL ("sizeof "), 1 },
1704 { "sz", NL ("sizeof "), 1 },
1705 { "tr", NL ("throw"), 0 },
1706 { "tw", NL ("throw "), 1 },
1707 { NULL
, NULL
, 0, 0 }
1710 static struct demangle_component
*
1711 d_operator_name (struct d_info
*di
)
1716 c1
= d_next_char (di
);
1717 c2
= d_next_char (di
);
1718 if (c1
== 'v' && IS_DIGIT (c2
))
1719 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1720 else if (c1
== 'c' && c2
== 'v')
1721 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1722 cplus_demangle_type (di
), NULL
);
1725 /* LOW is the inclusive lower bound. */
1727 /* HIGH is the exclusive upper bound. We subtract one to ignore
1728 the sentinel at the end of the array. */
1729 int high
= ((sizeof (cplus_demangle_operators
)
1730 / sizeof (cplus_demangle_operators
[0]))
1736 const struct demangle_operator_info
*p
;
1738 i
= low
+ (high
- low
) / 2;
1739 p
= cplus_demangle_operators
+ i
;
1741 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1742 return d_make_operator (di
, p
);
1744 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1754 static struct demangle_component
*
1755 d_make_character (struct d_info
*di
, int c
)
1757 struct demangle_component
*p
;
1758 p
= d_make_empty (di
);
1761 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1762 p
->u
.s_character
.character
= c
;
1767 static struct demangle_component
*
1768 d_java_resource (struct d_info
*di
)
1770 struct demangle_component
*p
= NULL
;
1771 struct demangle_component
*next
= NULL
;
1776 len
= d_number (di
);
1780 /* Eat the leading '_'. */
1781 if (d_next_char (di
) != '_')
1794 /* Each chunk is either a '$' escape... */
1812 next
= d_make_character (di
, c
);
1820 /* ... or a sequence of characters. */
1823 while (i
< len
&& str
[i
] && str
[i
] != '$')
1826 next
= d_make_name (di
, str
, i
);
1839 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
1845 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
1850 /* <special-name> ::= TV <type>
1854 ::= GV <(object) name>
1855 ::= T <call-offset> <(base) encoding>
1856 ::= Tc <call-offset> <call-offset> <(base) encoding>
1857 Also g++ extensions:
1858 ::= TC <type> <(offset) number> _ <(base) type>
1863 ::= Gr <resource name>
1868 static struct demangle_component
*
1869 d_special_name (struct d_info
*di
)
1871 di
->expansion
+= 20;
1872 if (d_check_char (di
, 'T'))
1874 switch (d_next_char (di
))
1878 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1879 cplus_demangle_type (di
), NULL
);
1881 di
->expansion
-= 10;
1882 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1883 cplus_demangle_type (di
), NULL
);
1885 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1886 cplus_demangle_type (di
), NULL
);
1888 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1889 cplus_demangle_type (di
), NULL
);
1892 if (! d_call_offset (di
, 'h'))
1894 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1895 d_encoding (di
, 0), NULL
);
1898 if (! d_call_offset (di
, 'v'))
1900 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1901 d_encoding (di
, 0), NULL
);
1904 if (! d_call_offset (di
, '\0'))
1906 if (! d_call_offset (di
, '\0'))
1908 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1909 d_encoding (di
, 0), NULL
);
1913 struct demangle_component
*derived_type
;
1915 struct demangle_component
*base_type
;
1917 derived_type
= cplus_demangle_type (di
);
1918 offset
= d_number (di
);
1921 if (! d_check_char (di
, '_'))
1923 base_type
= cplus_demangle_type (di
);
1924 /* We don't display the offset. FIXME: We should display
1925 it in verbose mode. */
1927 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1928 base_type
, derived_type
);
1932 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1933 cplus_demangle_type (di
), NULL
);
1935 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1936 cplus_demangle_type (di
), NULL
);
1939 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_INIT
,
1943 return d_make_comp (di
, DEMANGLE_COMPONENT_TLS_WRAPPER
,
1950 else if (d_check_char (di
, 'G'))
1952 switch (d_next_char (di
))
1955 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1959 struct demangle_component
*name
= d_name (di
);
1960 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
1961 d_number_component (di
));
1965 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
1966 d_encoding (di
, 0), NULL
);
1969 switch (d_next_char (di
))
1972 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
1973 d_encoding (di
, 0), NULL
);
1975 /* ??? The proposal is that other letters (such as 'h') stand
1976 for different variants of transaction cloning, such as
1977 compiling directly for hardware transaction support. But
1978 they still should all be transactional clones of some sort
1979 so go ahead and call them that. */
1981 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
1982 d_encoding (di
, 0), NULL
);
1986 return d_java_resource (di
);
1996 /* <call-offset> ::= h <nv-offset> _
1999 <nv-offset> ::= <(offset) number>
2001 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2003 The C parameter, if not '\0', is a character we just read which is
2004 the start of the <call-offset>.
2006 We don't display the offset information anywhere. FIXME: We should
2007 display it in verbose mode. */
2010 d_call_offset (struct d_info
*di
, int c
)
2013 c
= d_next_char (di
);
2020 if (! d_check_char (di
, '_'))
2027 if (! d_check_char (di
, '_'))
2033 /* <ctor-dtor-name> ::= C1
2041 static struct demangle_component
*
2042 d_ctor_dtor_name (struct d_info
*di
)
2044 if (di
->last_name
!= NULL
)
2046 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
2047 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
2048 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2049 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
2051 switch (d_peek_char (di
))
2055 enum gnu_v3_ctor_kinds kind
;
2057 switch (d_peek_next_char (di
))
2060 kind
= gnu_v3_complete_object_ctor
;
2063 kind
= gnu_v3_base_object_ctor
;
2066 kind
= gnu_v3_complete_object_allocating_ctor
;
2069 kind
= gnu_v3_object_ctor_group
;
2075 return d_make_ctor (di
, kind
, di
->last_name
);
2080 enum gnu_v3_dtor_kinds kind
;
2082 switch (d_peek_next_char (di
))
2085 kind
= gnu_v3_deleting_dtor
;
2088 kind
= gnu_v3_complete_object_dtor
;
2091 kind
= gnu_v3_base_object_dtor
;
2094 kind
= gnu_v3_object_dtor_group
;
2100 return d_make_dtor (di
, kind
, di
->last_name
);
2108 /* <type> ::= <builtin-type>
2110 ::= <class-enum-type>
2112 ::= <pointer-to-member-type>
2113 ::= <template-param>
2114 ::= <template-template-param> <template-args>
2116 ::= <CV-qualifiers> <type>
2119 ::= O <type> (C++0x)
2122 ::= U <source-name> <type>
2124 <builtin-type> ::= various one letter codes
2128 CP_STATIC_IF_GLIBCPP_V3
2129 const struct demangle_builtin_type_info
2130 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2132 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2133 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2134 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2135 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2136 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2137 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2138 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2139 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2140 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2141 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2142 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2143 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2144 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2145 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2146 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2148 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2149 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2150 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2151 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2152 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2153 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2154 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2155 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2156 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2157 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2158 D_PRINT_UNSIGNED_LONG_LONG
},
2159 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2160 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2161 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2162 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2163 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2164 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2165 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2166 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2170 CP_STATIC_IF_GLIBCPP_V3
2171 struct demangle_component
*
2172 cplus_demangle_type (struct d_info
*di
)
2175 struct demangle_component
*ret
;
2178 /* The ABI specifies that when CV-qualifiers are used, the base type
2179 is substitutable, and the fully qualified type is substitutable,
2180 but the base type with a strict subset of the CV-qualifiers is
2181 not substitutable. The natural recursive implementation of the
2182 CV-qualifiers would cause subsets to be substitutable, so instead
2183 we pull them all off now.
2185 FIXME: The ABI says that order-insensitive vendor qualifiers
2186 should be handled in the same way, but we have no way to tell
2187 which vendor qualifiers are order-insensitive and which are
2188 order-sensitive. So we just assume that they are all
2189 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2190 __vector, and it treats it as order-sensitive when mangling
2193 peek
= d_peek_char (di
);
2194 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2196 struct demangle_component
**pret
;
2198 pret
= d_cv_qualifiers (di
, &ret
, 0);
2201 *pret
= cplus_demangle_type (di
);
2204 if ((*pret
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2205 || (*pret
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
)
2207 /* Move the ref-qualifier outside the cv-qualifiers so that
2208 they are printed in the right order. */
2209 struct demangle_component
*fn
= d_left (*pret
);
2210 d_left (*pret
) = ret
;
2214 if (! d_add_substitution (di
, ret
))
2223 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2224 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2225 case 'o': case 's': case 't':
2226 case 'v': case 'w': case 'x': case 'y': case 'z':
2227 ret
= d_make_builtin_type (di
,
2228 &cplus_demangle_builtin_types
[peek
- 'a']);
2229 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2236 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2237 d_source_name (di
), NULL
);
2241 ret
= d_function_type (di
);
2244 case '0': case '1': case '2': case '3': case '4':
2245 case '5': case '6': case '7': case '8': case '9':
2248 ret
= d_class_enum_type (di
);
2252 ret
= d_array_type (di
);
2256 ret
= d_pointer_to_member_type (di
);
2260 ret
= d_template_param (di
);
2261 if (d_peek_char (di
) == 'I')
2263 /* This is <template-template-param> <template-args>. The
2264 <template-template-param> part is a substitution
2266 if (! d_add_substitution (di
, ret
))
2268 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2269 d_template_args (di
));
2274 /* If this is a special substitution, then it is the start of
2275 <class-enum-type>. */
2279 peek_next
= d_peek_next_char (di
);
2280 if (IS_DIGIT (peek_next
)
2282 || IS_UPPER (peek_next
))
2284 ret
= d_substitution (di
, 0);
2285 /* The substituted name may have been a template name and
2286 may be followed by tepmlate args. */
2287 if (d_peek_char (di
) == 'I')
2288 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2289 d_template_args (di
));
2295 ret
= d_class_enum_type (di
);
2296 /* If the substitution was a complete type, then it is not
2297 a new substitution candidate. However, if the
2298 substitution was followed by template arguments, then
2299 the whole thing is a substitution candidate. */
2300 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2308 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2309 cplus_demangle_type (di
), NULL
);
2314 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2315 cplus_demangle_type (di
), NULL
);
2320 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2321 cplus_demangle_type (di
), NULL
);
2326 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2327 cplus_demangle_type (di
), NULL
);
2332 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2333 cplus_demangle_type (di
), NULL
);
2338 ret
= d_source_name (di
);
2339 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2340 cplus_demangle_type (di
), ret
);
2346 peek
= d_next_char (di
);
2351 /* decltype (expression) */
2352 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2353 d_expression (di
), NULL
);
2354 if (ret
&& d_next_char (di
) != 'E')
2360 /* Pack expansion. */
2361 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2362 cplus_demangle_type (di
), NULL
);
2368 ret
= d_make_name (di
, "auto", 4);
2372 /* 32-bit decimal floating point */
2373 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2374 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2378 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2379 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2383 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2384 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2387 /* 16-bit half-precision FP */
2388 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2389 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2393 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2394 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2398 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2399 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2403 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2404 ret
= d_make_empty (di
);
2405 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2406 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2407 /* For demangling we don't care about the bits. */
2409 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2410 if (ret
->u
.s_fixed
.length
== NULL
)
2413 peek
= d_next_char (di
);
2414 ret
->u
.s_fixed
.sat
= (peek
== 's');
2418 ret
= d_vector_type (di
);
2423 /* decltype(nullptr) */
2424 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2425 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2439 if (! d_add_substitution (di
, ret
))
2446 /* <CV-qualifiers> ::= [r] [V] [K] */
2448 static struct demangle_component
**
2449 d_cv_qualifiers (struct d_info
*di
,
2450 struct demangle_component
**pret
, int member_fn
)
2452 struct demangle_component
**pstart
;
2456 peek
= d_peek_char (di
);
2457 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
2459 enum demangle_component_type t
;
2465 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2466 : DEMANGLE_COMPONENT_RESTRICT
);
2467 di
->expansion
+= sizeof "restrict";
2469 else if (peek
== 'V')
2472 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2473 : DEMANGLE_COMPONENT_VOLATILE
);
2474 di
->expansion
+= sizeof "volatile";
2479 ? DEMANGLE_COMPONENT_CONST_THIS
2480 : DEMANGLE_COMPONENT_CONST
);
2481 di
->expansion
+= sizeof "const";
2484 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
2487 pret
= &d_left (*pret
);
2489 peek
= d_peek_char (di
);
2492 if (!member_fn
&& peek
== 'F')
2494 while (pstart
!= pret
)
2496 switch ((*pstart
)->type
)
2498 case DEMANGLE_COMPONENT_RESTRICT
:
2499 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2501 case DEMANGLE_COMPONENT_VOLATILE
:
2502 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2504 case DEMANGLE_COMPONENT_CONST
:
2505 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2510 pstart
= &d_left (*pstart
);
2517 /* <ref-qualifier> ::= R
2520 static struct demangle_component
*
2521 d_ref_qualifier (struct d_info
*di
, struct demangle_component
*sub
)
2523 struct demangle_component
*ret
= sub
;
2526 peek
= d_peek_char (di
);
2527 if (peek
== 'R' || peek
== 'O')
2529 enum demangle_component_type t
;
2532 t
= DEMANGLE_COMPONENT_REFERENCE_THIS
;
2533 di
->expansion
+= sizeof "&";
2537 t
= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
;
2538 di
->expansion
+= sizeof "&&";
2542 ret
= d_make_comp (di
, t
, ret
, NULL
);
2548 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */
2550 static struct demangle_component
*
2551 d_function_type (struct d_info
*di
)
2553 struct demangle_component
*ret
;
2555 if (! d_check_char (di
, 'F'))
2557 if (d_peek_char (di
) == 'Y')
2559 /* Function has C linkage. We don't print this information.
2560 FIXME: We should print it in verbose mode. */
2563 ret
= d_bare_function_type (di
, 1);
2564 ret
= d_ref_qualifier (di
, ret
);
2566 if (! d_check_char (di
, 'E'))
2573 static struct demangle_component
*
2574 d_parmlist (struct d_info
*di
)
2576 struct demangle_component
*tl
;
2577 struct demangle_component
**ptl
;
2583 struct demangle_component
*type
;
2585 char peek
= d_peek_char (di
);
2586 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2588 if ((peek
== 'R' || peek
== 'O')
2589 && d_peek_next_char (di
) == 'E')
2590 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2592 type
= cplus_demangle_type (di
);
2595 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2598 ptl
= &d_right (*ptl
);
2601 /* There should be at least one parameter type besides the optional
2602 return type. A function which takes no arguments will have a
2603 single parameter type void. */
2607 /* If we have a single parameter type void, omit it. */
2608 if (d_right (tl
) == NULL
2609 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2610 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2612 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2619 /* <bare-function-type> ::= [J]<type>+ */
2621 static struct demangle_component
*
2622 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2624 struct demangle_component
*return_type
;
2625 struct demangle_component
*tl
;
2628 /* Detect special qualifier indicating that the first argument
2629 is the return type. */
2630 peek
= d_peek_char (di
);
2634 has_return_type
= 1;
2637 if (has_return_type
)
2639 return_type
= cplus_demangle_type (di
);
2640 if (return_type
== NULL
)
2646 tl
= d_parmlist (di
);
2650 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2654 /* <class-enum-type> ::= <name> */
2656 static struct demangle_component
*
2657 d_class_enum_type (struct d_info
*di
)
2662 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2663 ::= A [<(dimension) expression>] _ <(element) type>
2666 static struct demangle_component
*
2667 d_array_type (struct d_info
*di
)
2670 struct demangle_component
*dim
;
2672 if (! d_check_char (di
, 'A'))
2675 peek
= d_peek_char (di
);
2678 else if (IS_DIGIT (peek
))
2686 peek
= d_peek_char (di
);
2688 while (IS_DIGIT (peek
));
2689 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2695 dim
= d_expression (di
);
2700 if (! d_check_char (di
, '_'))
2703 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2704 cplus_demangle_type (di
));
2707 /* <vector-type> ::= Dv <number> _ <type>
2708 ::= Dv _ <expression> _ <type> */
2710 static struct demangle_component
*
2711 d_vector_type (struct d_info
*di
)
2714 struct demangle_component
*dim
;
2716 peek
= d_peek_char (di
);
2720 dim
= d_expression (di
);
2723 dim
= d_number_component (di
);
2728 if (! d_check_char (di
, '_'))
2731 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
2732 cplus_demangle_type (di
));
2735 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2737 static struct demangle_component
*
2738 d_pointer_to_member_type (struct d_info
*di
)
2740 struct demangle_component
*cl
;
2741 struct demangle_component
*mem
;
2742 struct demangle_component
**pmem
;
2744 if (! d_check_char (di
, 'M'))
2747 cl
= cplus_demangle_type (di
);
2749 /* The ABI specifies that any type can be a substitution source, and
2750 that M is followed by two types, and that when a CV-qualified
2751 type is seen both the base type and the CV-qualified types are
2752 substitution sources. The ABI also specifies that for a pointer
2753 to a CV-qualified member function, the qualifiers are attached to
2754 the second type. Given the grammar, a plain reading of the ABI
2755 suggests that both the CV-qualified member function and the
2756 non-qualified member function are substitution sources. However,
2757 g++ does not work that way. g++ treats only the CV-qualified
2758 member function as a substitution source. FIXME. So to work
2759 with g++, we need to pull off the CV-qualifiers here, in order to
2760 avoid calling add_substitution() in cplus_demangle_type(). But
2761 for a CV-qualified member which is not a function, g++ does
2762 follow the ABI, so we need to handle that case here by calling
2763 d_add_substitution ourselves. */
2765 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2768 *pmem
= cplus_demangle_type (di
);
2773 && ((*pmem
)->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2774 || (*pmem
)->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
))
2776 /* Move the ref-qualifier outside the cv-qualifiers so that
2777 they are printed in the right order. */
2778 struct demangle_component
*fn
= d_left (*pmem
);
2779 d_left (*pmem
) = mem
;
2784 if (pmem
!= &mem
&& (*pmem
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
2786 if (! d_add_substitution (di
, mem
))
2790 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2793 /* <non-negative number> _ */
2796 d_compact_number (struct d_info
*di
)
2799 if (d_peek_char (di
) == '_')
2801 else if (d_peek_char (di
) == 'n')
2804 num
= d_number (di
) + 1;
2806 if (! d_check_char (di
, '_'))
2811 /* <template-param> ::= T_
2812 ::= T <(parameter-2 non-negative) number> _
2815 static struct demangle_component
*
2816 d_template_param (struct d_info
*di
)
2820 if (! d_check_char (di
, 'T'))
2823 param
= d_compact_number (di
);
2829 return d_make_template_param (di
, param
);
2832 /* <template-args> ::= I <template-arg>+ E */
2834 static struct demangle_component
*
2835 d_template_args (struct d_info
*di
)
2837 struct demangle_component
*hold_last_name
;
2838 struct demangle_component
*al
;
2839 struct demangle_component
**pal
;
2841 /* Preserve the last name we saw--don't let the template arguments
2842 clobber it, as that would give us the wrong name for a subsequent
2843 constructor or destructor. */
2844 hold_last_name
= di
->last_name
;
2846 if (d_peek_char (di
) != 'I'
2847 && d_peek_char (di
) != 'J')
2851 if (d_peek_char (di
) == 'E')
2853 /* An argument pack can be empty. */
2855 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
2862 struct demangle_component
*a
;
2864 a
= d_template_arg (di
);
2868 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2871 pal
= &d_right (*pal
);
2873 if (d_peek_char (di
) == 'E')
2880 di
->last_name
= hold_last_name
;
2885 /* <template-arg> ::= <type>
2886 ::= X <expression> E
2890 static struct demangle_component
*
2891 d_template_arg (struct d_info
*di
)
2893 struct demangle_component
*ret
;
2895 switch (d_peek_char (di
))
2899 ret
= d_expression (di
);
2900 if (! d_check_char (di
, 'E'))
2905 return d_expr_primary (di
);
2909 /* An argument pack. */
2910 return d_template_args (di
);
2913 return cplus_demangle_type (di
);
2917 /* Parse a sequence of expressions until we hit the terminator
2920 static struct demangle_component
*
2921 d_exprlist (struct d_info
*di
, char terminator
)
2923 struct demangle_component
*list
= NULL
;
2924 struct demangle_component
**p
= &list
;
2926 if (d_peek_char (di
) == terminator
)
2929 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
2934 struct demangle_component
*arg
= d_expression (di
);
2938 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
2943 if (d_peek_char (di
) == terminator
)
2953 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
2954 dynamic_cast, static_cast or reinterpret_cast. */
2957 op_is_new_cast (struct demangle_component
*op
)
2959 const char *code
= op
->u
.s_operator
.op
->code
;
2960 return (code
[1] == 'c'
2961 && (code
[0] == 's' || code
[0] == 'd'
2962 || code
[0] == 'c' || code
[0] == 'r'));
2965 /* <expression> ::= <(unary) operator-name> <expression>
2966 ::= <(binary) operator-name> <expression> <expression>
2967 ::= <(trinary) operator-name> <expression> <expression> <expression>
2968 ::= cl <expression>+ E
2970 ::= <template-param>
2971 ::= sr <type> <unqualified-name>
2972 ::= sr <type> <unqualified-name> <template-args>
2976 static struct demangle_component
*
2977 d_expression (struct d_info
*di
)
2981 peek
= d_peek_char (di
);
2983 return d_expr_primary (di
);
2984 else if (peek
== 'T')
2985 return d_template_param (di
);
2986 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2988 struct demangle_component
*type
;
2989 struct demangle_component
*name
;
2992 type
= cplus_demangle_type (di
);
2993 name
= d_unqualified_name (di
);
2994 if (d_peek_char (di
) != 'I')
2995 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2997 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2998 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2999 d_template_args (di
)));
3001 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
3004 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
3005 d_expression (di
), NULL
);
3007 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
3009 /* Function parameter used in a late-specified return type. */
3012 if (d_peek_char (di
) == 'T')
3014 /* 'this' parameter. */
3020 index
= d_compact_number (di
) + 1;
3024 return d_make_function_param (di
, index
);
3026 else if (IS_DIGIT (peek
)
3027 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
3029 /* We can get an unqualified name as an expression in the case of
3030 a dependent function call, i.e. decltype(f(t)). */
3031 struct demangle_component
*name
;
3034 /* operator-function-id, i.e. operator+(t). */
3037 name
= d_unqualified_name (di
);
3040 if (d_peek_char (di
) == 'I')
3041 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
3042 d_template_args (di
));
3046 else if ((peek
== 'i' || peek
== 't')
3047 && d_peek_next_char (di
) == 'l')
3049 /* Brace-enclosed initializer list, untyped or typed. */
3050 struct demangle_component
*type
= NULL
;
3052 type
= cplus_demangle_type (di
);
3054 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
3055 type
, d_exprlist (di
, 'E'));
3059 struct demangle_component
*op
;
3060 const char *code
= NULL
;
3063 op
= d_operator_name (di
);
3067 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3069 code
= op
->u
.s_operator
.op
->code
;
3070 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
3071 if (strcmp (code
, "st") == 0)
3072 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3073 cplus_demangle_type (di
));
3080 case DEMANGLE_COMPONENT_OPERATOR
:
3081 args
= op
->u
.s_operator
.op
->args
;
3083 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3084 args
= op
->u
.s_extended_operator
.args
;
3086 case DEMANGLE_COMPONENT_CAST
:
3094 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
3098 struct demangle_component
*operand
;
3101 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
3102 && code
[1] == code
[0])
3103 /* pp_ and mm_ are the prefix variants. */
3104 suffix
= !d_check_char (di
, '_');
3106 if (op
->type
== DEMANGLE_COMPONENT_CAST
3107 && d_check_char (di
, '_'))
3108 operand
= d_exprlist (di
, 'E');
3110 operand
= d_expression (di
);
3113 /* Indicate the suffix variant for d_print_comp. */
3114 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3116 DEMANGLE_COMPONENT_BINARY_ARGS
,
3119 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
3124 struct demangle_component
*left
;
3125 struct demangle_component
*right
;
3127 if (op_is_new_cast (op
))
3128 left
= cplus_demangle_type (di
);
3130 left
= d_expression (di
);
3131 if (!strcmp (code
, "cl"))
3132 right
= d_exprlist (di
, 'E');
3133 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
3135 right
= d_unqualified_name (di
);
3136 if (d_peek_char (di
) == 'I')
3137 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
3138 right
, d_template_args (di
));
3141 right
= d_expression (di
);
3143 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
3145 DEMANGLE_COMPONENT_BINARY_ARGS
,
3150 struct demangle_component
*first
;
3151 struct demangle_component
*second
;
3152 struct demangle_component
*third
;
3154 if (!strcmp (code
, "qu"))
3156 /* ?: expression. */
3157 first
= d_expression (di
);
3158 second
= d_expression (di
);
3159 third
= d_expression (di
);
3161 else if (code
[0] == 'n')
3163 /* new-expression. */
3164 if (code
[1] != 'w' && code
[1] != 'a')
3166 first
= d_exprlist (di
, '_');
3167 second
= cplus_demangle_type (di
);
3168 if (d_peek_char (di
) == 'E')
3173 else if (d_peek_char (di
) == 'p'
3174 && d_peek_next_char (di
) == 'i')
3176 /* Parenthesized initializer. */
3178 third
= d_exprlist (di
, 'E');
3180 else if (d_peek_char (di
) == 'i'
3181 && d_peek_next_char (di
) == 'l')
3182 /* initializer-list. */
3183 third
= d_expression (di
);
3189 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3191 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3194 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3203 /* <expr-primary> ::= L <type> <(value) number> E
3204 ::= L <type> <(value) float> E
3205 ::= L <mangled-name> E
3208 static struct demangle_component
*
3209 d_expr_primary (struct d_info
*di
)
3211 struct demangle_component
*ret
;
3213 if (! d_check_char (di
, 'L'))
3215 if (d_peek_char (di
) == '_'
3216 /* Workaround for G++ bug; see comment in write_template_arg. */
3217 || d_peek_char (di
) == 'Z')
3218 ret
= cplus_demangle_mangled_name (di
, 0);
3221 struct demangle_component
*type
;
3222 enum demangle_component_type t
;
3225 type
= cplus_demangle_type (di
);
3229 /* If we have a type we know how to print, we aren't going to
3230 print the type name itself. */
3231 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3232 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3233 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3235 /* Rather than try to interpret the literal value, we just
3236 collect it as a string. Note that it's possible to have a
3237 floating point literal here. The ABI specifies that the
3238 format of such literals is machine independent. That's fine,
3239 but what's not fine is that versions of g++ up to 3.2 with
3240 -fabi-version=1 used upper case letters in the hex constant,
3241 and dumped out gcc's internal representation. That makes it
3242 hard to tell where the constant ends, and hard to dump the
3243 constant in any readable form anyhow. We don't attempt to
3244 handle these cases. */
3246 t
= DEMANGLE_COMPONENT_LITERAL
;
3247 if (d_peek_char (di
) == 'n')
3249 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3253 while (d_peek_char (di
) != 'E')
3255 if (d_peek_char (di
) == '\0')
3259 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3261 if (! d_check_char (di
, 'E'))
3266 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3267 ::= Z <(function) encoding> E s [<discriminator>]
3268 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3271 static struct demangle_component
*
3272 d_local_name (struct d_info
*di
)
3274 struct demangle_component
*function
;
3276 if (! d_check_char (di
, 'Z'))
3279 function
= d_encoding (di
, 0);
3281 if (! d_check_char (di
, 'E'))
3284 if (d_peek_char (di
) == 's')
3287 if (! d_discriminator (di
))
3289 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
3290 d_make_name (di
, "string literal",
3291 sizeof "string literal" - 1));
3295 struct demangle_component
*name
;
3298 if (d_peek_char (di
) == 'd')
3300 /* Default argument scope: d <number> _. */
3302 num
= d_compact_number (di
);
3311 /* Lambdas and unnamed types have internal discriminators. */
3312 case DEMANGLE_COMPONENT_LAMBDA
:
3313 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3316 if (! d_discriminator (di
))
3320 name
= d_make_default_arg (di
, num
, name
);
3321 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3325 /* <discriminator> ::= _ <(non-negative) number>
3327 We demangle the discriminator, but we don't print it out. FIXME:
3328 We should print it out in verbose mode. */
3331 d_discriminator (struct d_info
*di
)
3335 if (d_peek_char (di
) != '_')
3338 discrim
= d_number (di
);
3344 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3346 static struct demangle_component
*
3347 d_lambda (struct d_info
*di
)
3349 struct demangle_component
*tl
;
3350 struct demangle_component
*ret
;
3353 if (! d_check_char (di
, 'U'))
3355 if (! d_check_char (di
, 'l'))
3358 tl
= d_parmlist (di
);
3362 if (! d_check_char (di
, 'E'))
3365 num
= d_compact_number (di
);
3369 ret
= d_make_empty (di
);
3372 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3373 ret
->u
.s_unary_num
.sub
= tl
;
3374 ret
->u
.s_unary_num
.num
= num
;
3377 if (! d_add_substitution (di
, ret
))
3383 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3385 static struct demangle_component
*
3386 d_unnamed_type (struct d_info
*di
)
3388 struct demangle_component
*ret
;
3391 if (! d_check_char (di
, 'U'))
3393 if (! d_check_char (di
, 't'))
3396 num
= d_compact_number (di
);
3400 ret
= d_make_empty (di
);
3403 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3404 ret
->u
.s_number
.number
= num
;
3407 if (! d_add_substitution (di
, ret
))
3413 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3416 static struct demangle_component
*
3417 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3419 const char *suffix
= d_str (di
);
3420 const char *pend
= suffix
;
3421 struct demangle_component
*n
;
3423 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3426 while (IS_LOWER (*pend
) || *pend
== '_')
3429 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3432 while (IS_DIGIT (*pend
))
3435 d_advance (di
, pend
- suffix
);
3436 n
= d_make_name (di
, suffix
, pend
- suffix
);
3437 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3440 /* Add a new substitution. */
3443 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3447 if (di
->next_sub
>= di
->num_subs
)
3449 di
->subs
[di
->next_sub
] = dc
;
3454 /* <substitution> ::= S <seq-id> _
3464 If PREFIX is non-zero, then this type is being used as a prefix in
3465 a qualified name. In this case, for the standard substitutions, we
3466 need to check whether we are being used as a prefix for a
3467 constructor or destructor, and return a full template name.
3468 Otherwise we will get something like std::iostream::~iostream()
3469 which does not correspond particularly well to any function which
3470 actually appears in the source.
3473 static const struct d_standard_sub_info standard_subs
[] =
3478 { 'a', NL ("std::allocator"),
3479 NL ("std::allocator"),
3481 { 'b', NL ("std::basic_string"),
3482 NL ("std::basic_string"),
3483 NL ("basic_string") },
3484 { 's', NL ("std::string"),
3485 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3486 NL ("basic_string") },
3487 { 'i', NL ("std::istream"),
3488 NL ("std::basic_istream<char, std::char_traits<char> >"),
3489 NL ("basic_istream") },
3490 { 'o', NL ("std::ostream"),
3491 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3492 NL ("basic_ostream") },
3493 { 'd', NL ("std::iostream"),
3494 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3495 NL ("basic_iostream") }
3498 static struct demangle_component
*
3499 d_substitution (struct d_info
*di
, int prefix
)
3503 if (! d_check_char (di
, 'S'))
3506 c
= d_next_char (di
);
3507 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3516 unsigned int new_id
;
3519 new_id
= id
* 36 + c
- '0';
3520 else if (IS_UPPER (c
))
3521 new_id
= id
* 36 + c
- 'A' + 10;
3527 c
= d_next_char (di
);
3534 if (id
>= (unsigned int) di
->next_sub
)
3539 return di
->subs
[id
];
3544 const struct d_standard_sub_info
*p
;
3545 const struct d_standard_sub_info
*pend
;
3547 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3548 if (! verbose
&& prefix
)
3552 peek
= d_peek_char (di
);
3553 if (peek
== 'C' || peek
== 'D')
3557 pend
= (&standard_subs
[0]
3558 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3559 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3566 if (p
->set_last_name
!= NULL
)
3567 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3568 p
->set_last_name_len
);
3571 s
= p
->full_expansion
;
3576 s
= p
->simple_expansion
;
3577 len
= p
->simple_len
;
3579 di
->expansion
+= len
;
3580 return d_make_sub (di
, s
, len
);
3588 /* Initialize a growable string. */
3591 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3596 dgs
->allocation_failure
= 0;
3599 d_growable_string_resize (dgs
, estimate
);
3602 /* Grow a growable string to a given size. */
3605 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
3610 if (dgs
->allocation_failure
)
3613 /* Start allocation at two bytes to avoid any possibility of confusion
3614 with the special value of 1 used as a return in *palc to indicate
3615 allocation failures. */
3616 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
3617 while (newalc
< need
)
3620 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
3627 dgs
->allocation_failure
= 1;
3634 /* Append a buffer to a growable string. */
3637 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
3638 const char *s
, size_t l
)
3642 need
= dgs
->len
+ l
+ 1;
3643 if (need
> dgs
->alc
)
3644 d_growable_string_resize (dgs
, need
);
3646 if (dgs
->allocation_failure
)
3649 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
3650 dgs
->buf
[dgs
->len
+ l
] = '\0';
3654 /* Bridge growable strings to the callback mechanism. */
3657 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
3659 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
3661 d_growable_string_append_buffer (dgs
, s
, l
);
3664 /* Initialize a print information structure. */
3667 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
3671 dpi
->last_char
= '\0';
3672 dpi
->templates
= NULL
;
3673 dpi
->modifiers
= NULL
;
3674 dpi
->pack_index
= 0;
3675 dpi
->flush_count
= 0;
3677 dpi
->callback
= callback
;
3678 dpi
->opaque
= opaque
;
3680 dpi
->demangle_failure
= 0;
3683 /* Indicate that an error occurred during printing, and test for error. */
3686 d_print_error (struct d_print_info
*dpi
)
3688 dpi
->demangle_failure
= 1;
3692 d_print_saw_error (struct d_print_info
*dpi
)
3694 return dpi
->demangle_failure
!= 0;
3697 /* Flush buffered characters to the callback. */
3700 d_print_flush (struct d_print_info
*dpi
)
3702 dpi
->buf
[dpi
->len
] = '\0';
3703 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
3708 /* Append characters and buffers for printing. */
3711 d_append_char (struct d_print_info
*dpi
, char c
)
3713 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
3714 d_print_flush (dpi
);
3716 dpi
->buf
[dpi
->len
++] = c
;
3721 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
3725 for (i
= 0; i
< l
; i
++)
3726 d_append_char (dpi
, s
[i
]);
3730 d_append_string (struct d_print_info
*dpi
, const char *s
)
3732 d_append_buffer (dpi
, s
, strlen (s
));
3736 d_append_num (struct d_print_info
*dpi
, long l
)
3739 sprintf (buf
,"%ld", l
);
3740 d_append_string (dpi
, buf
);
3744 d_last_char (struct d_print_info
*dpi
)
3746 return dpi
->last_char
;
3749 /* Turn components into a human readable string. OPTIONS is the
3750 options bits passed to the demangler. DC is the tree to print.
3751 CALLBACK is a function to call to flush demangled string segments
3752 as they fill the intermediate buffer, and OPAQUE is a generalized
3753 callback argument. On success, this returns 1. On failure,
3754 it returns 0, indicating a bad parse. It does not use heap
3755 memory to build an output string, so cannot encounter memory
3756 allocation failure. */
3758 CP_STATIC_IF_GLIBCPP_V3
3760 cplus_demangle_print_callback (int options
,
3761 const struct demangle_component
*dc
,
3762 demangle_callbackref callback
, void *opaque
)
3764 struct d_print_info dpi
;
3766 d_print_init (&dpi
, callback
, opaque
);
3768 d_print_comp (&dpi
, options
, dc
);
3770 d_print_flush (&dpi
);
3772 return ! d_print_saw_error (&dpi
);
3775 /* Turn components into a human readable string. OPTIONS is the
3776 options bits passed to the demangler. DC is the tree to print.
3777 ESTIMATE is a guess at the length of the result. This returns a
3778 string allocated by malloc, or NULL on error. On success, this
3779 sets *PALC to the size of the allocated buffer. On failure, this
3780 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3783 CP_STATIC_IF_GLIBCPP_V3
3785 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
3786 int estimate
, size_t *palc
)
3788 struct d_growable_string dgs
;
3790 d_growable_string_init (&dgs
, estimate
);
3792 if (! cplus_demangle_print_callback (options
, dc
,
3793 d_growable_string_callback_adapter
,
3801 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
3805 /* Returns the I'th element of the template arglist ARGS, or NULL on
3808 static struct demangle_component
*
3809 d_index_template_argument (struct demangle_component
*args
, int i
)
3811 struct demangle_component
*a
;
3817 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3823 if (i
!= 0 || a
== NULL
)
3829 /* Returns the template argument from the current context indicated by DC,
3830 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3832 static struct demangle_component
*
3833 d_lookup_template_argument (struct d_print_info
*dpi
,
3834 const struct demangle_component
*dc
)
3836 if (dpi
->templates
== NULL
)
3838 d_print_error (dpi
);
3842 return d_index_template_argument
3843 (d_right (dpi
->templates
->template_decl
),
3844 dc
->u
.s_number
.number
);
3847 /* Returns a template argument pack used in DC (any will do), or NULL. */
3849 static struct demangle_component
*
3850 d_find_pack (struct d_print_info
*dpi
,
3851 const struct demangle_component
*dc
)
3853 struct demangle_component
*a
;
3859 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3860 a
= d_lookup_template_argument (dpi
, dc
);
3861 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3865 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
3868 case DEMANGLE_COMPONENT_LAMBDA
:
3869 case DEMANGLE_COMPONENT_NAME
:
3870 case DEMANGLE_COMPONENT_TAGGED_NAME
:
3871 case DEMANGLE_COMPONENT_OPERATOR
:
3872 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3873 case DEMANGLE_COMPONENT_SUB_STD
:
3874 case DEMANGLE_COMPONENT_CHARACTER
:
3875 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
3876 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3879 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3880 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
3881 case DEMANGLE_COMPONENT_CTOR
:
3882 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
3883 case DEMANGLE_COMPONENT_DTOR
:
3884 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
3887 a
= d_find_pack (dpi
, d_left (dc
));
3890 return d_find_pack (dpi
, d_right (dc
));
3894 /* Returns the length of the template argument pack DC. */
3897 d_pack_length (const struct demangle_component
*dc
)
3900 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3901 && d_left (dc
) != NULL
)
3909 /* DC is a component of a mangled expression. Print it, wrapped in parens
3913 d_print_subexpr (struct d_print_info
*dpi
, int options
,
3914 const struct demangle_component
*dc
)
3917 if (dc
->type
== DEMANGLE_COMPONENT_NAME
3918 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
3919 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
3920 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
3923 d_append_char (dpi
, '(');
3924 d_print_comp (dpi
, options
, dc
);
3926 d_append_char (dpi
, ')');
3929 /* Subroutine to handle components. */
3932 d_print_comp (struct d_print_info
*dpi
, int options
,
3933 const struct demangle_component
*dc
)
3935 /* Magic variable to let reference smashing skip over the next modifier
3936 without needing to modify *dc. */
3937 const struct demangle_component
*mod_inner
= NULL
;
3941 d_print_error (dpi
);
3944 if (d_print_saw_error (dpi
))
3949 case DEMANGLE_COMPONENT_NAME
:
3950 if ((options
& DMGL_JAVA
) == 0)
3951 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3953 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3956 case DEMANGLE_COMPONENT_TAGGED_NAME
:
3957 d_print_comp (dpi
, options
, d_left (dc
));
3958 d_append_string (dpi
, "[abi:");
3959 d_print_comp (dpi
, options
, d_right (dc
));
3960 d_append_char (dpi
, ']');
3963 case DEMANGLE_COMPONENT_QUAL_NAME
:
3964 case DEMANGLE_COMPONENT_LOCAL_NAME
:
3965 d_print_comp (dpi
, options
, d_left (dc
));
3966 if ((options
& DMGL_JAVA
) == 0)
3967 d_append_string (dpi
, "::");
3969 d_append_char (dpi
, '.');
3971 struct demangle_component
*local_name
= d_right (dc
);
3972 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
3974 d_append_string (dpi
, "{default arg#");
3975 d_append_num (dpi
, local_name
->u
.s_unary_num
.num
+ 1);
3976 d_append_string (dpi
, "}::");
3977 local_name
= local_name
->u
.s_unary_num
.sub
;
3979 d_print_comp (dpi
, options
, local_name
);
3983 case DEMANGLE_COMPONENT_TYPED_NAME
:
3985 struct d_print_mod
*hold_modifiers
;
3986 struct demangle_component
*typed_name
;
3987 struct d_print_mod adpm
[4];
3989 struct d_print_template dpt
;
3991 /* Pass the name down to the type so that it can be printed in
3992 the right place for the type. We also have to pass down
3993 any CV-qualifiers, which apply to the this parameter. */
3994 hold_modifiers
= dpi
->modifiers
;
3997 typed_name
= d_left (dc
);
3998 while (typed_name
!= NULL
)
4000 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4002 d_print_error (dpi
);
4006 adpm
[i
].next
= dpi
->modifiers
;
4007 dpi
->modifiers
= &adpm
[i
];
4008 adpm
[i
].mod
= typed_name
;
4009 adpm
[i
].printed
= 0;
4010 adpm
[i
].templates
= dpi
->templates
;
4013 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
4014 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
4015 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
4016 && typed_name
->type
!= DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
4017 && typed_name
->type
!= DEMANGLE_COMPONENT_REFERENCE_THIS
)
4020 typed_name
= d_left (typed_name
);
4023 if (typed_name
== NULL
)
4025 d_print_error (dpi
);
4029 /* If typed_name is a template, then it applies to the
4030 function type as well. */
4031 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4033 dpt
.next
= dpi
->templates
;
4034 dpi
->templates
= &dpt
;
4035 dpt
.template_decl
= typed_name
;
4038 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4039 there may be CV-qualifiers on its right argument which
4040 really apply here; this happens when parsing a class which
4041 is local to a function. */
4042 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4044 struct demangle_component
*local_name
;
4046 local_name
= d_right (typed_name
);
4047 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4048 local_name
= local_name
->u
.s_unary_num
.sub
;
4049 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
4050 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
4051 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
4052 || local_name
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
4053 || (local_name
->type
4054 == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
))
4056 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4058 d_print_error (dpi
);
4062 adpm
[i
] = adpm
[i
- 1];
4063 adpm
[i
].next
= &adpm
[i
- 1];
4064 dpi
->modifiers
= &adpm
[i
];
4066 adpm
[i
- 1].mod
= local_name
;
4067 adpm
[i
- 1].printed
= 0;
4068 adpm
[i
- 1].templates
= dpi
->templates
;
4071 local_name
= d_left (local_name
);
4075 d_print_comp (dpi
, options
, d_right (dc
));
4077 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
4078 dpi
->templates
= dpt
.next
;
4080 /* If the modifiers didn't get printed by the type, print them
4085 if (! adpm
[i
].printed
)
4087 d_append_char (dpi
, ' ');
4088 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4092 dpi
->modifiers
= hold_modifiers
;
4097 case DEMANGLE_COMPONENT_TEMPLATE
:
4099 struct d_print_mod
*hold_dpm
;
4100 struct demangle_component
*dcl
;
4102 /* Don't push modifiers into a template definition. Doing so
4103 could give the wrong definition for a template argument.
4104 Instead, treat the template essentially as a name. */
4106 hold_dpm
= dpi
->modifiers
;
4107 dpi
->modifiers
= NULL
;
4111 if ((options
& DMGL_JAVA
) != 0
4112 && dcl
->type
== DEMANGLE_COMPONENT_NAME
4113 && dcl
->u
.s_name
.len
== 6
4114 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
4116 /* Special-case Java arrays, so that JArray<TYPE> appears
4117 instead as TYPE[]. */
4119 d_print_comp (dpi
, options
, d_right (dc
));
4120 d_append_string (dpi
, "[]");
4124 d_print_comp (dpi
, options
, dcl
);
4125 if (d_last_char (dpi
) == '<')
4126 d_append_char (dpi
, ' ');
4127 d_append_char (dpi
, '<');
4128 d_print_comp (dpi
, options
, d_right (dc
));
4129 /* Avoid generating two consecutive '>' characters, to avoid
4130 the C++ syntactic ambiguity. */
4131 if (d_last_char (dpi
) == '>')
4132 d_append_char (dpi
, ' ');
4133 d_append_char (dpi
, '>');
4136 dpi
->modifiers
= hold_dpm
;
4141 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
4143 struct d_print_template
*hold_dpt
;
4144 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
4146 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4147 a
= d_index_template_argument (a
, dpi
->pack_index
);
4151 d_print_error (dpi
);
4155 /* While processing this parameter, we need to pop the list of
4156 templates. This is because the template parameter may
4157 itself be a reference to a parameter of an outer
4160 hold_dpt
= dpi
->templates
;
4161 dpi
->templates
= hold_dpt
->next
;
4163 d_print_comp (dpi
, options
, a
);
4165 dpi
->templates
= hold_dpt
;
4170 case DEMANGLE_COMPONENT_CTOR
:
4171 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
4174 case DEMANGLE_COMPONENT_DTOR
:
4175 d_append_char (dpi
, '~');
4176 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
4179 case DEMANGLE_COMPONENT_VTABLE
:
4180 d_append_string (dpi
, "vtable for ");
4181 d_print_comp (dpi
, options
, d_left (dc
));
4184 case DEMANGLE_COMPONENT_VTT
:
4185 d_append_string (dpi
, "VTT for ");
4186 d_print_comp (dpi
, options
, d_left (dc
));
4189 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4190 d_append_string (dpi
, "construction vtable for ");
4191 d_print_comp (dpi
, options
, d_left (dc
));
4192 d_append_string (dpi
, "-in-");
4193 d_print_comp (dpi
, options
, d_right (dc
));
4196 case DEMANGLE_COMPONENT_TYPEINFO
:
4197 d_append_string (dpi
, "typeinfo for ");
4198 d_print_comp (dpi
, options
, d_left (dc
));
4201 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4202 d_append_string (dpi
, "typeinfo name for ");
4203 d_print_comp (dpi
, options
, d_left (dc
));
4206 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4207 d_append_string (dpi
, "typeinfo fn for ");
4208 d_print_comp (dpi
, options
, d_left (dc
));
4211 case DEMANGLE_COMPONENT_THUNK
:
4212 d_append_string (dpi
, "non-virtual thunk to ");
4213 d_print_comp (dpi
, options
, d_left (dc
));
4216 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4217 d_append_string (dpi
, "virtual thunk to ");
4218 d_print_comp (dpi
, options
, d_left (dc
));
4221 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4222 d_append_string (dpi
, "covariant return thunk to ");
4223 d_print_comp (dpi
, options
, d_left (dc
));
4226 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4227 d_append_string (dpi
, "java Class for ");
4228 d_print_comp (dpi
, options
, d_left (dc
));
4231 case DEMANGLE_COMPONENT_GUARD
:
4232 d_append_string (dpi
, "guard variable for ");
4233 d_print_comp (dpi
, options
, d_left (dc
));
4236 case DEMANGLE_COMPONENT_TLS_INIT
:
4237 d_append_string (dpi
, "TLS init function for ");
4238 d_print_comp (dpi
, options
, d_left (dc
));
4241 case DEMANGLE_COMPONENT_TLS_WRAPPER
:
4242 d_append_string (dpi
, "TLS wrapper function for ");
4243 d_print_comp (dpi
, options
, d_left (dc
));
4246 case DEMANGLE_COMPONENT_REFTEMP
:
4247 d_append_string (dpi
, "reference temporary #");
4248 d_print_comp (dpi
, options
, d_right (dc
));
4249 d_append_string (dpi
, " for ");
4250 d_print_comp (dpi
, options
, d_left (dc
));
4253 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4254 d_append_string (dpi
, "hidden alias for ");
4255 d_print_comp (dpi
, options
, d_left (dc
));
4258 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4259 d_append_string (dpi
, "transaction clone for ");
4260 d_print_comp (dpi
, options
, d_left (dc
));
4263 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4264 d_append_string (dpi
, "non-transaction clone for ");
4265 d_print_comp (dpi
, options
, d_left (dc
));
4268 case DEMANGLE_COMPONENT_SUB_STD
:
4269 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
4272 case DEMANGLE_COMPONENT_RESTRICT
:
4273 case DEMANGLE_COMPONENT_VOLATILE
:
4274 case DEMANGLE_COMPONENT_CONST
:
4276 struct d_print_mod
*pdpm
;
4278 /* When printing arrays, it's possible to have cases where the
4279 same CV-qualifier gets pushed on the stack multiple times.
4280 We only need to print it once. */
4282 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
4284 if (! pdpm
->printed
)
4286 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
4287 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
4288 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
4290 if (pdpm
->mod
->type
== dc
->type
)
4292 d_print_comp (dpi
, options
, d_left (dc
));
4300 case DEMANGLE_COMPONENT_REFERENCE
:
4301 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4303 /* Handle reference smashing: & + && = &. */
4304 const struct demangle_component
*sub
= d_left (dc
);
4305 if (sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4307 struct demangle_component
*a
= d_lookup_template_argument (dpi
, sub
);
4308 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4309 a
= d_index_template_argument (a
, dpi
->pack_index
);
4313 d_print_error (dpi
);
4320 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
4321 || sub
->type
== dc
->type
)
4323 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
4324 mod_inner
= d_left (sub
);
4328 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4329 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4330 case DEMANGLE_COMPONENT_CONST_THIS
:
4331 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
4332 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
4333 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4334 case DEMANGLE_COMPONENT_POINTER
:
4335 case DEMANGLE_COMPONENT_COMPLEX
:
4336 case DEMANGLE_COMPONENT_IMAGINARY
:
4339 /* We keep a list of modifiers on the stack. */
4340 struct d_print_mod dpm
;
4342 dpm
.next
= dpi
->modifiers
;
4343 dpi
->modifiers
= &dpm
;
4346 dpm
.templates
= dpi
->templates
;
4349 mod_inner
= d_left (dc
);
4351 d_print_comp (dpi
, options
, mod_inner
);
4353 /* If the modifier didn't get printed by the type, print it
4356 d_print_mod (dpi
, options
, dc
);
4358 dpi
->modifiers
= dpm
.next
;
4363 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4364 if ((options
& DMGL_JAVA
) == 0)
4365 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
4366 dc
->u
.s_builtin
.type
->len
);
4368 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
4369 dc
->u
.s_builtin
.type
->java_len
);
4372 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4373 d_print_comp (dpi
, options
, d_left (dc
));
4376 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4378 if ((options
& DMGL_RET_POSTFIX
) != 0)
4379 d_print_function_type (dpi
,
4380 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4381 dc
, dpi
->modifiers
);
4383 /* Print return type if present */
4384 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
4385 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4387 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
4389 struct d_print_mod dpm
;
4391 /* We must pass this type down as a modifier in order to
4392 print it in the right location. */
4393 dpm
.next
= dpi
->modifiers
;
4394 dpi
->modifiers
= &dpm
;
4397 dpm
.templates
= dpi
->templates
;
4399 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4402 dpi
->modifiers
= dpm
.next
;
4407 /* In standard prefix notation, there is a space between the
4408 return type and the function signature. */
4409 if ((options
& DMGL_RET_POSTFIX
) == 0)
4410 d_append_char (dpi
, ' ');
4413 if ((options
& DMGL_RET_POSTFIX
) == 0)
4414 d_print_function_type (dpi
,
4415 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4416 dc
, dpi
->modifiers
);
4421 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4423 struct d_print_mod
*hold_modifiers
;
4424 struct d_print_mod adpm
[4];
4426 struct d_print_mod
*pdpm
;
4428 /* We must pass this type down as a modifier in order to print
4429 multi-dimensional arrays correctly. If the array itself is
4430 CV-qualified, we act as though the element type were
4431 CV-qualified. We do this by copying the modifiers down
4432 rather than fiddling pointers, so that we don't wind up
4433 with a d_print_mod higher on the stack pointing into our
4434 stack frame after we return. */
4436 hold_modifiers
= dpi
->modifiers
;
4438 adpm
[0].next
= hold_modifiers
;
4439 dpi
->modifiers
= &adpm
[0];
4441 adpm
[0].printed
= 0;
4442 adpm
[0].templates
= dpi
->templates
;
4445 pdpm
= hold_modifiers
;
4447 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
4448 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
4449 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
4451 if (! pdpm
->printed
)
4453 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4455 d_print_error (dpi
);
4460 adpm
[i
].next
= dpi
->modifiers
;
4461 dpi
->modifiers
= &adpm
[i
];
4469 d_print_comp (dpi
, options
, d_right (dc
));
4471 dpi
->modifiers
= hold_modifiers
;
4473 if (adpm
[0].printed
)
4479 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4482 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
4487 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4488 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4490 struct d_print_mod dpm
;
4492 dpm
.next
= dpi
->modifiers
;
4493 dpi
->modifiers
= &dpm
;
4496 dpm
.templates
= dpi
->templates
;
4498 d_print_comp (dpi
, options
, d_right (dc
));
4500 /* If the modifier didn't get printed by the type, print it
4503 d_print_mod (dpi
, options
, dc
);
4505 dpi
->modifiers
= dpm
.next
;
4510 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4511 if (dc
->u
.s_fixed
.sat
)
4512 d_append_string (dpi
, "_Sat ");
4513 /* Don't print "int _Accum". */
4514 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
4515 != &cplus_demangle_builtin_types
['i'-'a'])
4517 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
4518 d_append_char (dpi
, ' ');
4520 if (dc
->u
.s_fixed
.accum
)
4521 d_append_string (dpi
, "_Accum");
4523 d_append_string (dpi
, "_Fract");
4526 case DEMANGLE_COMPONENT_ARGLIST
:
4527 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4528 if (d_left (dc
) != NULL
)
4529 d_print_comp (dpi
, options
, d_left (dc
));
4530 if (d_right (dc
) != NULL
)
4533 unsigned long int flush_count
;
4534 /* Make sure ", " isn't flushed by d_append_string, otherwise
4535 dpi->len -= 2 wouldn't work. */
4536 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
4537 d_print_flush (dpi
);
4538 d_append_string (dpi
, ", ");
4540 flush_count
= dpi
->flush_count
;
4541 d_print_comp (dpi
, options
, d_right (dc
));
4542 /* If that didn't print anything (which can happen with empty
4543 template argument packs), remove the comma and space. */
4544 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
4549 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4551 struct demangle_component
*type
= d_left (dc
);
4552 struct demangle_component
*list
= d_right (dc
);
4555 d_print_comp (dpi
, options
, type
);
4556 d_append_char (dpi
, '{');
4557 d_print_comp (dpi
, options
, list
);
4558 d_append_char (dpi
, '}');
4562 case DEMANGLE_COMPONENT_OPERATOR
:
4564 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
4567 d_append_string (dpi
, "operator");
4568 /* Add a space before new/delete. */
4569 if (IS_LOWER (op
->name
[0]))
4570 d_append_char (dpi
, ' ');
4571 /* Omit a trailing space. */
4572 if (op
->name
[len
-1] == ' ')
4574 d_append_buffer (dpi
, op
->name
, len
);
4578 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4579 d_append_string (dpi
, "operator ");
4580 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
4583 case DEMANGLE_COMPONENT_CAST
:
4584 d_append_string (dpi
, "operator ");
4585 d_print_cast (dpi
, options
, dc
);
4588 case DEMANGLE_COMPONENT_NULLARY
:
4589 d_print_expr_op (dpi
, options
, d_left (dc
));
4592 case DEMANGLE_COMPONENT_UNARY
:
4594 struct demangle_component
*op
= d_left (dc
);
4595 struct demangle_component
*operand
= d_right (dc
);
4596 const char *code
= NULL
;
4598 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
4600 code
= op
->u
.s_operator
.op
->code
;
4601 if (!strcmp (code
, "ad"))
4603 /* Don't print the argument list for the address of a
4605 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
4606 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
4607 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4608 operand
= d_left (operand
);
4610 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
4612 /* This indicates a suffix operator. */
4613 operand
= d_left (operand
);
4614 d_print_subexpr (dpi
, options
, operand
);
4615 d_print_expr_op (dpi
, options
, op
);
4620 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
4621 d_print_expr_op (dpi
, options
, op
);
4624 d_append_char (dpi
, '(');
4625 d_print_cast (dpi
, options
, op
);
4626 d_append_char (dpi
, ')');
4628 if (code
&& !strcmp (code
, "gs"))
4629 /* Avoid parens after '::'. */
4630 d_print_comp (dpi
, options
, operand
);
4631 else if (code
&& !strcmp (code
, "st"))
4632 /* Always print parens for sizeof (type). */
4634 d_append_char (dpi
, '(');
4635 d_print_comp (dpi
, options
, operand
);
4636 d_append_char (dpi
, ')');
4639 d_print_subexpr (dpi
, options
, operand
);
4643 case DEMANGLE_COMPONENT_BINARY
:
4644 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
4646 d_print_error (dpi
);
4650 if (op_is_new_cast (d_left (dc
)))
4652 d_print_expr_op (dpi
, options
, d_left (dc
));
4653 d_append_char (dpi
, '<');
4654 d_print_comp (dpi
, options
, d_left (d_right (dc
)));
4655 d_append_string (dpi
, ">(");
4656 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
4657 d_append_char (dpi
, ')');
4661 /* We wrap an expression which uses the greater-than operator in
4662 an extra layer of parens so that it does not get confused
4663 with the '>' which ends the template parameters. */
4664 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4665 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4666 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4667 d_append_char (dpi
, '(');
4669 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
4670 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
4672 /* Function call used in an expression should not have printed types
4673 of the function arguments. Values of the function arguments still
4674 get printed below. */
4676 const struct demangle_component
*func
= d_left (d_right (dc
));
4678 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4679 d_print_error (dpi
);
4680 d_print_subexpr (dpi
, options
, d_left (func
));
4683 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
4684 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
4686 d_append_char (dpi
, '[');
4687 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
4688 d_append_char (dpi
, ']');
4692 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
4693 d_print_expr_op (dpi
, options
, d_left (dc
));
4694 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
4697 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4698 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4699 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4700 d_append_char (dpi
, ')');
4704 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4705 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
4706 d_print_error (dpi
);
4709 case DEMANGLE_COMPONENT_TRINARY
:
4710 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
4711 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
4713 d_print_error (dpi
);
4717 struct demangle_component
*op
= d_left (dc
);
4718 struct demangle_component
*first
= d_left (d_right (dc
));
4719 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
4720 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
4722 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
4724 d_print_subexpr (dpi
, options
, first
);
4725 d_print_expr_op (dpi
, options
, op
);
4726 d_print_subexpr (dpi
, options
, second
);
4727 d_append_string (dpi
, " : ");
4728 d_print_subexpr (dpi
, options
, third
);
4732 d_append_string (dpi
, "new ");
4733 if (d_left (first
) != NULL
)
4735 d_print_subexpr (dpi
, options
, first
);
4736 d_append_char (dpi
, ' ');
4738 d_print_comp (dpi
, options
, second
);
4740 d_print_subexpr (dpi
, options
, third
);
4745 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4746 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4747 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
4748 d_print_error (dpi
);
4751 case DEMANGLE_COMPONENT_LITERAL
:
4752 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4754 enum d_builtin_type_print tp
;
4756 /* For some builtin types, produce simpler output. */
4757 tp
= D_PRINT_DEFAULT
;
4758 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
4760 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
4764 case D_PRINT_UNSIGNED
:
4766 case D_PRINT_UNSIGNED_LONG
:
4767 case D_PRINT_LONG_LONG
:
4768 case D_PRINT_UNSIGNED_LONG_LONG
:
4769 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
4771 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4772 d_append_char (dpi
, '-');
4773 d_print_comp (dpi
, options
, d_right (dc
));
4778 case D_PRINT_UNSIGNED
:
4779 d_append_char (dpi
, 'u');
4782 d_append_char (dpi
, 'l');
4784 case D_PRINT_UNSIGNED_LONG
:
4785 d_append_string (dpi
, "ul");
4787 case D_PRINT_LONG_LONG
:
4788 d_append_string (dpi
, "ll");
4790 case D_PRINT_UNSIGNED_LONG_LONG
:
4791 d_append_string (dpi
, "ull");
4799 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
4800 && d_right (dc
)->u
.s_name
.len
== 1
4801 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
4803 switch (d_right (dc
)->u
.s_name
.s
[0])
4806 d_append_string (dpi
, "false");
4809 d_append_string (dpi
, "true");
4822 d_append_char (dpi
, '(');
4823 d_print_comp (dpi
, options
, d_left (dc
));
4824 d_append_char (dpi
, ')');
4825 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4826 d_append_char (dpi
, '-');
4827 if (tp
== D_PRINT_FLOAT
)
4828 d_append_char (dpi
, '[');
4829 d_print_comp (dpi
, options
, d_right (dc
));
4830 if (tp
== D_PRINT_FLOAT
)
4831 d_append_char (dpi
, ']');
4835 case DEMANGLE_COMPONENT_NUMBER
:
4836 d_append_num (dpi
, dc
->u
.s_number
.number
);
4839 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4840 d_append_string (dpi
, "java resource ");
4841 d_print_comp (dpi
, options
, d_left (dc
));
4844 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4845 d_print_comp (dpi
, options
, d_left (dc
));
4846 d_print_comp (dpi
, options
, d_right (dc
));
4849 case DEMANGLE_COMPONENT_CHARACTER
:
4850 d_append_char (dpi
, dc
->u
.s_character
.character
);
4853 case DEMANGLE_COMPONENT_DECLTYPE
:
4854 d_append_string (dpi
, "decltype (");
4855 d_print_comp (dpi
, options
, d_left (dc
));
4856 d_append_char (dpi
, ')');
4859 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4863 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
4866 /* d_find_pack won't find anything if the only packs involved
4867 in this expansion are function parameter packs; in that
4868 case, just print the pattern and "...". */
4869 d_print_subexpr (dpi
, options
, d_left (dc
));
4870 d_append_string (dpi
, "...");
4874 len
= d_pack_length (a
);
4876 for (i
= 0; i
< len
; ++i
)
4878 dpi
->pack_index
= i
;
4879 d_print_comp (dpi
, options
, dc
);
4881 d_append_string (dpi
, ", ");
4886 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4888 long num
= dc
->u
.s_number
.number
;
4890 d_append_string (dpi
, "this");
4893 d_append_string (dpi
, "{parm#");
4894 d_append_num (dpi
, num
);
4895 d_append_char (dpi
, '}');
4900 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4901 d_append_string (dpi
, "global constructors keyed to ");
4902 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4905 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4906 d_append_string (dpi
, "global destructors keyed to ");
4907 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4910 case DEMANGLE_COMPONENT_LAMBDA
:
4911 d_append_string (dpi
, "{lambda(");
4912 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
4913 d_append_string (dpi
, ")#");
4914 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
4915 d_append_char (dpi
, '}');
4918 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4919 d_append_string (dpi
, "{unnamed type#");
4920 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4921 d_append_char (dpi
, '}');
4924 case DEMANGLE_COMPONENT_CLONE
:
4925 d_print_comp (dpi
, options
, d_left (dc
));
4926 d_append_string (dpi
, " [clone ");
4927 d_print_comp (dpi
, options
, d_right (dc
));
4928 d_append_char (dpi
, ']');
4932 d_print_error (dpi
);
4937 /* Print a Java dentifier. For Java we try to handle encoded extended
4938 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4939 so we don't it for C++. Characters are encoded as
4943 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
4949 for (p
= name
; p
< end
; ++p
)
4960 for (q
= p
+ 3; q
< end
; ++q
)
4966 else if (*q
>= 'A' && *q
<= 'F')
4967 dig
= *q
- 'A' + 10;
4968 else if (*q
>= 'a' && *q
<= 'f')
4969 dig
= *q
- 'a' + 10;
4975 /* If the Unicode character is larger than 256, we don't try
4976 to deal with it here. FIXME. */
4977 if (q
< end
&& *q
== '_' && c
< 256)
4979 d_append_char (dpi
, c
);
4985 d_append_char (dpi
, *p
);
4989 /* Print a list of modifiers. SUFFIX is 1 if we are printing
4990 qualifiers on this after printing a function. */
4993 d_print_mod_list (struct d_print_info
*dpi
, int options
,
4994 struct d_print_mod
*mods
, int suffix
)
4996 struct d_print_template
*hold_dpt
;
4998 if (mods
== NULL
|| d_print_saw_error (dpi
))
5003 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
5004 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
5005 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
5006 || mods
->mod
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
5008 == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
))))
5010 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5016 hold_dpt
= dpi
->templates
;
5017 dpi
->templates
= mods
->templates
;
5019 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
5021 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
5022 dpi
->templates
= hold_dpt
;
5025 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5027 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
5028 dpi
->templates
= hold_dpt
;
5031 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
5033 struct d_print_mod
*hold_modifiers
;
5034 struct demangle_component
*dc
;
5036 /* When this is on the modifier stack, we have pulled any
5037 qualifiers off the right argument already. Otherwise, we
5038 print it as usual, but don't let the left argument see any
5041 hold_modifiers
= dpi
->modifiers
;
5042 dpi
->modifiers
= NULL
;
5043 d_print_comp (dpi
, options
, d_left (mods
->mod
));
5044 dpi
->modifiers
= hold_modifiers
;
5046 if ((options
& DMGL_JAVA
) == 0)
5047 d_append_string (dpi
, "::");
5049 d_append_char (dpi
, '.');
5051 dc
= d_right (mods
->mod
);
5053 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
5055 d_append_string (dpi
, "{default arg#");
5056 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
5057 d_append_string (dpi
, "}::");
5058 dc
= dc
->u
.s_unary_num
.sub
;
5061 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
5062 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
5063 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
5064 || dc
->type
== DEMANGLE_COMPONENT_REFERENCE_THIS
5065 || dc
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
)
5068 d_print_comp (dpi
, options
, dc
);
5070 dpi
->templates
= hold_dpt
;
5074 d_print_mod (dpi
, options
, mods
->mod
);
5076 dpi
->templates
= hold_dpt
;
5078 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
5081 /* Print a modifier. */
5084 d_print_mod (struct d_print_info
*dpi
, int options
,
5085 const struct demangle_component
*mod
)
5089 case DEMANGLE_COMPONENT_RESTRICT
:
5090 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5091 d_append_string (dpi
, " restrict");
5093 case DEMANGLE_COMPONENT_VOLATILE
:
5094 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5095 d_append_string (dpi
, " volatile");
5097 case DEMANGLE_COMPONENT_CONST
:
5098 case DEMANGLE_COMPONENT_CONST_THIS
:
5099 d_append_string (dpi
, " const");
5101 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5102 d_append_char (dpi
, ' ');
5103 d_print_comp (dpi
, options
, d_right (mod
));
5105 case DEMANGLE_COMPONENT_POINTER
:
5106 /* There is no pointer symbol in Java. */
5107 if ((options
& DMGL_JAVA
) == 0)
5108 d_append_char (dpi
, '*');
5110 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5111 /* For the ref-qualifier, put a space before the &. */
5112 d_append_char (dpi
, ' ');
5113 case DEMANGLE_COMPONENT_REFERENCE
:
5114 d_append_char (dpi
, '&');
5116 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5117 d_append_char (dpi
, ' ');
5118 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5119 d_append_string (dpi
, "&&");
5121 case DEMANGLE_COMPONENT_COMPLEX
:
5122 d_append_string (dpi
, "complex ");
5124 case DEMANGLE_COMPONENT_IMAGINARY
:
5125 d_append_string (dpi
, "imaginary ");
5127 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5128 if (d_last_char (dpi
) != '(')
5129 d_append_char (dpi
, ' ');
5130 d_print_comp (dpi
, options
, d_left (mod
));
5131 d_append_string (dpi
, "::*");
5133 case DEMANGLE_COMPONENT_TYPED_NAME
:
5134 d_print_comp (dpi
, options
, d_left (mod
));
5136 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
5137 d_append_string (dpi
, " __vector(");
5138 d_print_comp (dpi
, options
, d_left (mod
));
5139 d_append_char (dpi
, ')');
5143 /* Otherwise, we have something that won't go back on the
5144 modifier stack, so we can just print it. */
5145 d_print_comp (dpi
, options
, mod
);
5150 /* Print a function type, except for the return type. */
5153 d_print_function_type (struct d_print_info
*dpi
, int options
,
5154 const struct demangle_component
*dc
,
5155 struct d_print_mod
*mods
)
5159 struct d_print_mod
*p
;
5160 struct d_print_mod
*hold_modifiers
;
5164 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5169 switch (p
->mod
->type
)
5171 case DEMANGLE_COMPONENT_POINTER
:
5172 case DEMANGLE_COMPONENT_REFERENCE
:
5173 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
5176 case DEMANGLE_COMPONENT_RESTRICT
:
5177 case DEMANGLE_COMPONENT_VOLATILE
:
5178 case DEMANGLE_COMPONENT_CONST
:
5179 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
5180 case DEMANGLE_COMPONENT_COMPLEX
:
5181 case DEMANGLE_COMPONENT_IMAGINARY
:
5182 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
5186 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5187 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5188 case DEMANGLE_COMPONENT_CONST_THIS
:
5189 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5190 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5203 if (d_last_char (dpi
) != '('
5204 && d_last_char (dpi
) != '*')
5207 if (need_space
&& d_last_char (dpi
) != ' ')
5208 d_append_char (dpi
, ' ');
5209 d_append_char (dpi
, '(');
5212 hold_modifiers
= dpi
->modifiers
;
5213 dpi
->modifiers
= NULL
;
5215 d_print_mod_list (dpi
, options
, mods
, 0);
5218 d_append_char (dpi
, ')');
5220 d_append_char (dpi
, '(');
5222 if (d_right (dc
) != NULL
)
5223 d_print_comp (dpi
, options
, d_right (dc
));
5225 d_append_char (dpi
, ')');
5227 d_print_mod_list (dpi
, options
, mods
, 1);
5229 dpi
->modifiers
= hold_modifiers
;
5232 /* Print an array type, except for the element type. */
5235 d_print_array_type (struct d_print_info
*dpi
, int options
,
5236 const struct demangle_component
*dc
,
5237 struct d_print_mod
*mods
)
5245 struct d_print_mod
*p
;
5248 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5252 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5267 d_append_string (dpi
, " (");
5269 d_print_mod_list (dpi
, options
, mods
, 0);
5272 d_append_char (dpi
, ')');
5276 d_append_char (dpi
, ' ');
5278 d_append_char (dpi
, '[');
5280 if (d_left (dc
) != NULL
)
5281 d_print_comp (dpi
, options
, d_left (dc
));
5283 d_append_char (dpi
, ']');
5286 /* Print an operator in an expression. */
5289 d_print_expr_op (struct d_print_info
*dpi
, int options
,
5290 const struct demangle_component
*dc
)
5292 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5293 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
5294 dc
->u
.s_operator
.op
->len
);
5296 d_print_comp (dpi
, options
, dc
);
5302 d_print_cast (struct d_print_info
*dpi
, int options
,
5303 const struct demangle_component
*dc
)
5305 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
5306 d_print_comp (dpi
, options
, d_left (dc
));
5309 struct d_print_mod
*hold_dpm
;
5310 struct d_print_template dpt
;
5312 /* It appears that for a templated cast operator, we need to put
5313 the template parameters in scope for the operator name, but
5314 not for the parameters. The effect is that we need to handle
5315 the template printing here. */
5317 hold_dpm
= dpi
->modifiers
;
5318 dpi
->modifiers
= NULL
;
5320 dpt
.next
= dpi
->templates
;
5321 dpi
->templates
= &dpt
;
5322 dpt
.template_decl
= d_left (dc
);
5324 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
5326 dpi
->templates
= dpt
.next
;
5328 if (d_last_char (dpi
) == '<')
5329 d_append_char (dpi
, ' ');
5330 d_append_char (dpi
, '<');
5331 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
5332 /* Avoid generating two consecutive '>' characters, to avoid
5333 the C++ syntactic ambiguity. */
5334 if (d_last_char (dpi
) == '>')
5335 d_append_char (dpi
, ' ');
5336 d_append_char (dpi
, '>');
5338 dpi
->modifiers
= hold_dpm
;
5342 /* Initialize the information structure we use to pass around
5345 CP_STATIC_IF_GLIBCPP_V3
5347 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
5351 di
->send
= mangled
+ len
;
5352 di
->options
= options
;
5356 /* We can not need more components than twice the number of chars in
5357 the mangled string. Most components correspond directly to
5358 chars, but the ARGLIST types are exceptions. */
5359 di
->num_comps
= 2 * len
;
5362 /* Similarly, we can not need more substitutions than there are
5363 chars in the mangled string. */
5368 di
->last_name
= NULL
;
5373 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
5374 mangled name, return strings in repeated callback giving the demangled
5375 name. OPTIONS is the usual libiberty demangler options. On success,
5376 this returns 1. On failure, returns 0. */
5379 d_demangle_callback (const char *mangled
, int options
,
5380 demangle_callbackref callback
, void *opaque
)
5391 struct demangle_component
*dc
;
5394 if (mangled
[0] == '_' && mangled
[1] == 'Z')
5396 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
5397 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
5398 && (mangled
[9] == 'D' || mangled
[9] == 'I')
5399 && mangled
[10] == '_')
5400 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
5403 if ((options
& DMGL_TYPES
) == 0)
5408 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
5411 #ifdef CP_DYNAMIC_ARRAYS
5412 __extension__
struct demangle_component comps
[di
.num_comps
];
5413 __extension__
struct demangle_component
*subs
[di
.num_subs
];
5418 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
5419 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
5425 dc
= cplus_demangle_type (&di
);
5428 dc
= cplus_demangle_mangled_name (&di
, 1);
5430 case DCT_GLOBAL_CTORS
:
5431 case DCT_GLOBAL_DTORS
:
5432 d_advance (&di
, 11);
5433 dc
= d_make_comp (&di
,
5434 (type
== DCT_GLOBAL_CTORS
5435 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5436 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
5437 d_make_demangle_mangled_name (&di
, d_str (&di
)),
5439 d_advance (&di
, strlen (d_str (&di
)));
5443 /* If DMGL_PARAMS is set, then if we didn't consume the entire
5444 mangled string, then we didn't successfully demangle it. If
5445 DMGL_PARAMS is not set, we didn't look at the trailing
5447 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
5450 #ifdef CP_DEMANGLE_DEBUG
5454 status
= (dc
!= NULL
)
5455 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
5462 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
5463 name, return a buffer allocated with malloc holding the demangled
5464 name. OPTIONS is the usual libiberty demangler options. On
5465 success, this sets *PALC to the allocated size of the returned
5466 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
5467 a memory allocation failure, and returns NULL. */
5470 d_demangle (const char *mangled
, int options
, size_t *palc
)
5472 struct d_growable_string dgs
;
5475 d_growable_string_init (&dgs
, 0);
5477 status
= d_demangle_callback (mangled
, options
,
5478 d_growable_string_callback_adapter
, &dgs
);
5486 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
5490 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5492 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5494 /* ia64 ABI-mandated entry point in the C++ runtime library for
5495 performing demangling. MANGLED_NAME is a NUL-terminated character
5496 string containing the name to be demangled.
5498 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5499 *LENGTH bytes, into which the demangled name is stored. If
5500 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5501 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5502 is placed in a region of memory allocated with malloc.
5504 If LENGTH is non-NULL, the length of the buffer containing the
5505 demangled name, is placed in *LENGTH.
5507 The return value is a pointer to the start of the NUL-terminated
5508 demangled name, or NULL if the demangling fails. The caller is
5509 responsible for deallocating this memory using free.
5511 *STATUS is set to one of the following values:
5512 0: The demangling operation succeeded.
5513 -1: A memory allocation failure occurred.
5514 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5515 -3: One of the arguments is invalid.
5517 The demangling is performed using the C++ ABI mangling rules, with
5521 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
5522 size_t *length
, int *status
)
5527 if (mangled_name
== NULL
)
5534 if (output_buffer
!= NULL
&& length
== NULL
)
5541 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
5543 if (demangled
== NULL
)
5555 if (output_buffer
== NULL
)
5562 if (strlen (demangled
) < *length
)
5564 strcpy (output_buffer
, demangled
);
5566 demangled
= output_buffer
;
5570 free (output_buffer
);
5581 extern int __gcclibcxx_demangle_callback (const char *,
5583 (const char *, size_t, void *),
5586 /* Alternative, allocationless entry point in the C++ runtime library
5587 for performing demangling. MANGLED_NAME is a NUL-terminated character
5588 string containing the name to be demangled.
5590 CALLBACK is a callback function, called with demangled string
5591 segments as demangling progresses; it is called at least once,
5592 but may be called more than once. OPAQUE is a generalized pointer
5593 used as a callback argument.
5595 The return code is one of the following values, equivalent to
5596 the STATUS values of __cxa_demangle() (excluding -1, since this
5597 function performs no memory allocations):
5598 0: The demangling operation succeeded.
5599 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5600 -3: One of the arguments is invalid.
5602 The demangling is performed using the C++ ABI mangling rules, with
5606 __gcclibcxx_demangle_callback (const char *mangled_name
,
5607 void (*callback
) (const char *, size_t, void *),
5612 if (mangled_name
== NULL
|| callback
== NULL
)
5615 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
5623 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5625 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
5626 mangled name, return a buffer allocated with malloc holding the
5627 demangled name. Otherwise, return NULL. */
5630 cplus_demangle_v3 (const char *mangled
, int options
)
5634 return d_demangle (mangled
, options
, &alc
);
5638 cplus_demangle_v3_callback (const char *mangled
, int options
,
5639 demangle_callbackref callback
, void *opaque
)
5641 return d_demangle_callback (mangled
, options
, callback
, opaque
);
5644 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
5645 conventions, but the output formatting is a little different.
5646 This instructs the C++ demangler not to emit pointer characters ("*"), to
5647 use Java's namespace separator symbol ("." instead of "::"), and to output
5648 JArray<TYPE> as TYPE[]. */
5651 java_demangle_v3 (const char *mangled
)
5655 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
5659 java_demangle_v3_callback (const char *mangled
,
5660 demangle_callbackref callback
, void *opaque
)
5662 return d_demangle_callback (mangled
,
5663 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
5667 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5669 #ifndef IN_GLIBCPP_V3
5671 /* Demangle a string in order to find out whether it is a constructor
5672 or destructor. Return non-zero on success. Set *CTOR_KIND and
5673 *DTOR_KIND appropriately. */
5676 is_ctor_or_dtor (const char *mangled
,
5677 enum gnu_v3_ctor_kinds
*ctor_kind
,
5678 enum gnu_v3_dtor_kinds
*dtor_kind
)
5681 struct demangle_component
*dc
;
5684 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
5685 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
5687 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
5690 #ifdef CP_DYNAMIC_ARRAYS
5691 __extension__
struct demangle_component comps
[di
.num_comps
];
5692 __extension__
struct demangle_component
*subs
[di
.num_subs
];
5697 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
5698 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
5701 dc
= cplus_demangle_mangled_name (&di
, 1);
5703 /* Note that because we did not pass DMGL_PARAMS, we don't expect
5704 to demangle the entire string. */
5711 /* These cannot appear on a constructor or destructor. */
5712 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5713 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5714 case DEMANGLE_COMPONENT_CONST_THIS
:
5715 case DEMANGLE_COMPONENT_REFERENCE_THIS
:
5716 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
:
5720 case DEMANGLE_COMPONENT_TYPED_NAME
:
5721 case DEMANGLE_COMPONENT_TEMPLATE
:
5724 case DEMANGLE_COMPONENT_QUAL_NAME
:
5725 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5728 case DEMANGLE_COMPONENT_CTOR
:
5729 *ctor_kind
= dc
->u
.s_ctor
.kind
;
5733 case DEMANGLE_COMPONENT_DTOR
:
5734 *dtor_kind
= dc
->u
.s_dtor
.kind
;
5745 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5746 name. A non-zero return indicates the type of constructor. */
5748 enum gnu_v3_ctor_kinds
5749 is_gnu_v3_mangled_ctor (const char *name
)
5751 enum gnu_v3_ctor_kinds ctor_kind
;
5752 enum gnu_v3_dtor_kinds dtor_kind
;
5754 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5755 return (enum gnu_v3_ctor_kinds
) 0;
5760 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5761 name. A non-zero return indicates the type of destructor. */
5763 enum gnu_v3_dtor_kinds
5764 is_gnu_v3_mangled_dtor (const char *name
)
5766 enum gnu_v3_ctor_kinds ctor_kind
;
5767 enum gnu_v3_dtor_kinds dtor_kind
;
5769 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5770 return (enum gnu_v3_dtor_kinds
) 0;
5774 #endif /* IN_GLIBCPP_V3 */
5776 #ifdef STANDALONE_DEMANGLER
5779 #include "dyn-string.h"
5781 static void print_usage (FILE* fp
, int exit_value
);
5783 #define IS_ALPHA(CHAR) \
5784 (((CHAR) >= 'a' && (CHAR) <= 'z') \
5785 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5787 /* Non-zero if CHAR is a character than can occur in a mangled name. */
5788 #define is_mangled_char(CHAR) \
5789 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
5790 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5792 /* The name of this program, as invoked. */
5793 const char* program_name
;
5795 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
5798 print_usage (FILE* fp
, int exit_value
)
5800 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
5801 fprintf (fp
, "Options:\n");
5802 fprintf (fp
, " -h,--help Display this message.\n");
5803 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
5804 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
5805 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
5810 /* Option specification for getopt_long. */
5811 static const struct option long_options
[] =
5813 { "help", no_argument
, NULL
, 'h' },
5814 { "no-params", no_argument
, NULL
, 'p' },
5815 { "verbose", no_argument
, NULL
, 'v' },
5816 { NULL
, no_argument
, NULL
, 0 },
5819 /* Main entry for a demangling filter executable. It will demangle
5820 its command line arguments, if any. If none are provided, it will
5821 filter stdin to stdout, replacing any recognized mangled C++ names
5822 with their demangled equivalents. */
5825 main (int argc
, char *argv
[])
5829 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
5831 /* Use the program name of this program, as invoked. */
5832 program_name
= argv
[0];
5834 /* Parse options. */
5837 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
5840 case '?': /* Unrecognized option. */
5841 print_usage (stderr
, 1);
5845 print_usage (stdout
, 0);
5849 options
&= ~ DMGL_PARAMS
;
5853 options
|= DMGL_VERBOSE
;
5857 while (opt_char
!= -1);
5860 /* No command line arguments were provided. Filter stdin. */
5862 dyn_string_t mangled
= dyn_string_new (3);
5865 /* Read all of input. */
5866 while (!feof (stdin
))
5870 /* Pile characters into mangled until we hit one that can't
5871 occur in a mangled name. */
5873 while (!feof (stdin
) && is_mangled_char (c
))
5875 dyn_string_append_char (mangled
, c
);
5881 if (dyn_string_length (mangled
) > 0)
5883 #ifdef IN_GLIBCPP_V3
5884 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
5886 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
5896 /* It might not have been a mangled name. Print the
5898 fputs (dyn_string_buf (mangled
), stdout
);
5901 dyn_string_clear (mangled
);
5904 /* If we haven't hit EOF yet, we've read one character that
5905 can't occur in a mangled name, so print it out. */
5910 dyn_string_delete (mangled
);
5913 /* Demangle command line arguments. */
5915 /* Loop over command line arguments. */
5916 for (i
= optind
; i
< argc
; ++i
)
5919 #ifdef IN_GLIBCPP_V3
5923 /* Attempt to demangle. */
5924 #ifdef IN_GLIBCPP_V3
5925 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
5927 s
= cplus_demangle_v3 (argv
[i
], options
);
5930 /* If it worked, print the demangled name. */
5938 #ifdef IN_GLIBCPP_V3
5939 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
5941 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
5950 #endif /* STANDALONE_DEMANGLER */