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_function_type (struct d_info *);
387 static struct demangle_component *
388 d_bare_function_type (struct d_info *, int);
390 static struct demangle_component *
391 d_class_enum_type (struct d_info *);
393 static struct demangle_component *d_array_type (struct d_info *);
395 static struct demangle_component *d_vector_type (struct d_info *);
397 static struct demangle_component *
398 d_pointer_to_member_type (struct d_info *);
400 static struct demangle_component *
401 d_template_param (struct d_info *);
403 static struct demangle_component *d_template_args (struct d_info *);
405 static struct demangle_component *
406 d_template_arg (struct d_info *);
408 static struct demangle_component *d_expression (struct d_info *);
410 static struct demangle_component *d_expr_primary (struct d_info *);
412 static struct demangle_component *d_local_name (struct d_info *);
414 static int d_discriminator (struct d_info *);
416 static struct demangle_component *d_lambda (struct d_info *);
418 static struct demangle_component *d_unnamed_type (struct d_info *);
420 static struct demangle_component *
421 d_clone_suffix (struct d_info *, struct demangle_component *);
424 d_add_substitution (struct d_info *, struct demangle_component *);
426 static struct demangle_component *d_substitution (struct d_info *, int);
428 static void d_growable_string_init (struct d_growable_string *, size_t);
431 d_growable_string_resize (struct d_growable_string *, size_t);
434 d_growable_string_append_buffer (struct d_growable_string *,
435 const char *, size_t);
437 d_growable_string_callback_adapter (const char *, size_t, void *);
440 d_print_init (struct d_print_info *, demangle_callbackref, void *);
442 static inline void d_print_error (struct d_print_info *);
444 static inline int d_print_saw_error (struct d_print_info *);
446 static inline void d_print_flush (struct d_print_info *);
448 static inline void d_append_char (struct d_print_info *, char);
450 static inline void d_append_buffer (struct d_print_info *,
451 const char *, size_t);
453 static inline void d_append_string (struct d_print_info *, const char *);
455 static inline char d_last_char (struct d_print_info *);
458 d_print_comp (struct d_print_info *, int, const struct demangle_component *);
461 d_print_java_identifier (struct d_print_info *, const char *, int);
464 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
467 d_print_mod (struct d_print_info *, int, const struct demangle_component *);
470 d_print_function_type (struct d_print_info *, int,
471 const struct demangle_component *,
472 struct d_print_mod *);
475 d_print_array_type (struct d_print_info *, int,
476 const struct demangle_component *,
477 struct d_print_mod *);
480 d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
483 d_print_cast (struct d_print_info *, int, const struct demangle_component *);
485 static int d_demangle_callback (const char *, int,
486 demangle_callbackref, void *);
487 static char *d_demangle (const char *, int, size_t *);
489 #ifdef CP_DEMANGLE_DEBUG
492 d_dump (struct demangle_component *dc, int indent)
499 printf ("failed demangling\n");
503 for (i = 0; i < indent; ++i)
508 case DEMANGLE_COMPONENT_NAME:
509 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
511 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
512 printf ("template parameter %ld\n", dc->u.s_number.number);
514 case DEMANGLE_COMPONENT_CTOR:
515 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
516 d_dump (dc->u.s_ctor.name, indent + 2);
518 case DEMANGLE_COMPONENT_DTOR:
519 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
520 d_dump (dc->u.s_dtor.name, indent + 2);
522 case DEMANGLE_COMPONENT_SUB_STD:
523 printf ("standard substitution %s\n", dc->u.s_string.string);
525 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
526 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
528 case DEMANGLE_COMPONENT_OPERATOR:
529 printf ("operator %s\n", dc->u.s_operator.op->name);
531 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
532 printf ("extended operator with %d args\n",
533 dc->u.s_extended_operator.args);
534 d_dump (dc->u.s_extended_operator.name, indent + 2);
537 case DEMANGLE_COMPONENT_QUAL_NAME:
538 printf ("qualified name\n");
540 case DEMANGLE_COMPONENT_LOCAL_NAME:
541 printf ("local name\n");
543 case DEMANGLE_COMPONENT_TYPED_NAME:
544 printf ("typed name\n");
546 case DEMANGLE_COMPONENT_TEMPLATE:
547 printf ("template\n");
549 case DEMANGLE_COMPONENT_VTABLE:
552 case DEMANGLE_COMPONENT_VTT:
555 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
556 printf ("construction vtable\n");
558 case DEMANGLE_COMPONENT_TYPEINFO:
559 printf ("typeinfo\n");
561 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
562 printf ("typeinfo name\n");
564 case DEMANGLE_COMPONENT_TYPEINFO_FN:
565 printf ("typeinfo function\n");
567 case DEMANGLE_COMPONENT_THUNK:
570 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
571 printf ("virtual thunk\n");
573 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
574 printf ("covariant thunk\n");
576 case DEMANGLE_COMPONENT_JAVA_CLASS:
577 printf ("java class\n");
579 case DEMANGLE_COMPONENT_GUARD:
582 case DEMANGLE_COMPONENT_REFTEMP:
583 printf ("reference temporary\n");
585 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
586 printf ("hidden alias\n");
588 case DEMANGLE_COMPONENT_RESTRICT:
589 printf ("restrict\n");
591 case DEMANGLE_COMPONENT_VOLATILE:
592 printf ("volatile\n");
594 case DEMANGLE_COMPONENT_CONST:
597 case DEMANGLE_COMPONENT_RESTRICT_THIS:
598 printf ("restrict this\n");
600 case DEMANGLE_COMPONENT_VOLATILE_THIS:
601 printf ("volatile this\n");
603 case DEMANGLE_COMPONENT_CONST_THIS:
604 printf ("const this\n");
606 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
607 printf ("vendor type qualifier\n");
609 case DEMANGLE_COMPONENT_POINTER:
610 printf ("pointer\n");
612 case DEMANGLE_COMPONENT_REFERENCE:
613 printf ("reference\n");
615 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
616 printf ("rvalue reference\n");
618 case DEMANGLE_COMPONENT_COMPLEX:
619 printf ("complex\n");
621 case DEMANGLE_COMPONENT_IMAGINARY:
622 printf ("imaginary\n");
624 case DEMANGLE_COMPONENT_VENDOR_TYPE:
625 printf ("vendor type\n");
627 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
628 printf ("function type\n");
630 case DEMANGLE_COMPONENT_ARRAY_TYPE:
631 printf ("array type\n");
633 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
634 printf ("pointer to member type\n");
636 case DEMANGLE_COMPONENT_FIXED_TYPE:
637 printf ("fixed-point type\n");
639 case DEMANGLE_COMPONENT_ARGLIST:
640 printf ("argument list\n");
642 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
643 printf ("template argument list\n");
645 case DEMANGLE_COMPONENT_CAST:
648 case DEMANGLE_COMPONENT_UNARY:
649 printf ("unary operator\n");
651 case DEMANGLE_COMPONENT_BINARY:
652 printf ("binary operator\n");
654 case DEMANGLE_COMPONENT_BINARY_ARGS:
655 printf ("binary operator arguments\n");
657 case DEMANGLE_COMPONENT_TRINARY:
658 printf ("trinary operator\n");
660 case DEMANGLE_COMPONENT_TRINARY_ARG1:
661 printf ("trinary operator arguments 1\n");
663 case DEMANGLE_COMPONENT_TRINARY_ARG2:
664 printf ("trinary operator arguments 1\n");
666 case DEMANGLE_COMPONENT_LITERAL:
667 printf ("literal\n");
669 case DEMANGLE_COMPONENT_LITERAL_NEG:
670 printf ("negative literal\n");
672 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
673 printf ("java resource\n");
675 case DEMANGLE_COMPONENT_COMPOUND_NAME:
676 printf ("compound name\n");
678 case DEMANGLE_COMPONENT_CHARACTER:
679 printf ("character '%c'\n", dc->u.s_character.character);
681 case DEMANGLE_COMPONENT_DECLTYPE:
682 printf ("decltype\n");
684 case DEMANGLE_COMPONENT_PACK_EXPANSION:
685 printf ("pack expansion\n");
689 d_dump (d_left (dc), indent + 2);
690 d_dump (d_right (dc), indent + 2);
693 #endif /* CP_DEMANGLE_DEBUG */
695 /* Fill in a DEMANGLE_COMPONENT_NAME. */
697 CP_STATIC_IF_GLIBCPP_V3
699 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
701 if (p == NULL || s == NULL || len == 0)
703 p->type = DEMANGLE_COMPONENT_NAME;
705 p->u.s_name.len = len;
709 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
711 CP_STATIC_IF_GLIBCPP_V3
713 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
714 struct demangle_component *name)
716 if (p == NULL || args < 0 || name == NULL)
718 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
719 p->u.s_extended_operator.args = args;
720 p->u.s_extended_operator.name = name;
724 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
726 CP_STATIC_IF_GLIBCPP_V3
728 cplus_demangle_fill_ctor (struct demangle_component *p,
729 enum gnu_v3_ctor_kinds kind,
730 struct demangle_component *name)
734 || (int) kind < gnu_v3_complete_object_ctor
735 || (int) kind > gnu_v3_complete_object_allocating_ctor)
737 p->type = DEMANGLE_COMPONENT_CTOR;
738 p->u.s_ctor.kind = kind;
739 p->u.s_ctor.name = name;
743 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
745 CP_STATIC_IF_GLIBCPP_V3
747 cplus_demangle_fill_dtor (struct demangle_component *p,
748 enum gnu_v3_dtor_kinds kind,
749 struct demangle_component *name)
753 || (int) kind < gnu_v3_deleting_dtor
754 || (int) kind > gnu_v3_base_object_dtor)
756 p->type = DEMANGLE_COMPONENT_DTOR;
757 p->u.s_dtor.kind = kind;
758 p->u.s_dtor.name = name;
762 /* Add a new component. */
764 static struct demangle_component *
765 d_make_empty (struct d_info *di)
767 struct demangle_component *p;
769 if (di->next_comp >= di->num_comps)
771 p = &di->comps[di->next_comp];
776 /* Add a new generic component. */
778 static struct demangle_component *
779 d_make_comp (struct d_info *di, enum demangle_component_type type,
780 struct demangle_component *left,
781 struct demangle_component *right)
783 struct demangle_component *p;
785 /* We check for errors here. A typical error would be a NULL return
786 from a subroutine. We catch those here, and return NULL
790 /* These types require two parameters. */
791 case DEMANGLE_COMPONENT_QUAL_NAME:
792 case DEMANGLE_COMPONENT_LOCAL_NAME:
793 case DEMANGLE_COMPONENT_TYPED_NAME:
794 case DEMANGLE_COMPONENT_TEMPLATE:
795 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
796 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
797 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
798 case DEMANGLE_COMPONENT_UNARY:
799 case DEMANGLE_COMPONENT_BINARY:
800 case DEMANGLE_COMPONENT_BINARY_ARGS:
801 case DEMANGLE_COMPONENT_TRINARY:
802 case DEMANGLE_COMPONENT_TRINARY_ARG1:
803 case DEMANGLE_COMPONENT_TRINARY_ARG2:
804 case DEMANGLE_COMPONENT_LITERAL:
805 case DEMANGLE_COMPONENT_LITERAL_NEG:
806 case DEMANGLE_COMPONENT_COMPOUND_NAME:
807 case DEMANGLE_COMPONENT_VECTOR_TYPE:
808 case DEMANGLE_COMPONENT_CLONE:
809 if (left == NULL || right == NULL)
813 /* These types only require one parameter. */
814 case DEMANGLE_COMPONENT_VTABLE:
815 case DEMANGLE_COMPONENT_VTT:
816 case DEMANGLE_COMPONENT_TYPEINFO:
817 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
818 case DEMANGLE_COMPONENT_TYPEINFO_FN:
819 case DEMANGLE_COMPONENT_THUNK:
820 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
821 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
822 case DEMANGLE_COMPONENT_JAVA_CLASS:
823 case DEMANGLE_COMPONENT_GUARD:
824 case DEMANGLE_COMPONENT_REFTEMP:
825 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
826 case DEMANGLE_COMPONENT_POINTER:
827 case DEMANGLE_COMPONENT_REFERENCE:
828 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
829 case DEMANGLE_COMPONENT_COMPLEX:
830 case DEMANGLE_COMPONENT_IMAGINARY:
831 case DEMANGLE_COMPONENT_VENDOR_TYPE:
832 case DEMANGLE_COMPONENT_CAST:
833 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
834 case DEMANGLE_COMPONENT_DECLTYPE:
835 case DEMANGLE_COMPONENT_PACK_EXPANSION:
836 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
837 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
842 /* This needs a right parameter, but the left parameter can be
844 case DEMANGLE_COMPONENT_ARRAY_TYPE:
849 /* These are allowed to have no parameters--in some cases they
850 will be filled in later. */
851 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
852 case DEMANGLE_COMPONENT_RESTRICT:
853 case DEMANGLE_COMPONENT_VOLATILE:
854 case DEMANGLE_COMPONENT_CONST:
855 case DEMANGLE_COMPONENT_RESTRICT_THIS:
856 case DEMANGLE_COMPONENT_VOLATILE_THIS:
857 case DEMANGLE_COMPONENT_CONST_THIS:
858 case DEMANGLE_COMPONENT_ARGLIST:
859 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
862 /* Other types should not be seen here. */
867 p = d_make_empty (di);
871 p->u.s_binary.left = left;
872 p->u.s_binary.right = right;
877 /* Add a new demangle mangled name component. */
879 static struct demangle_component *
880 d_make_demangle_mangled_name (struct d_info *di, const char *s)
882 if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
883 return d_make_name (di, s, strlen (s));
885 return d_encoding (di, 0);
888 /* Add a new name component. */
890 static struct demangle_component *
891 d_make_name (struct d_info *di, const char *s, int len)
893 struct demangle_component *p;
895 p = d_make_empty (di);
896 if (! cplus_demangle_fill_name (p, s, len))
901 /* Add a new builtin type component. */
903 static struct demangle_component *
904 d_make_builtin_type (struct d_info *di,
905 const struct demangle_builtin_type_info *type)
907 struct demangle_component *p;
911 p = d_make_empty (di);
914 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
915 p->u.s_builtin.type = type;
920 /* Add a new operator component. */
922 static struct demangle_component *
923 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
925 struct demangle_component *p;
927 p = d_make_empty (di);
930 p->type = DEMANGLE_COMPONENT_OPERATOR;
931 p->u.s_operator.op = op;
936 /* Add a new extended operator component. */
938 static struct demangle_component *
939 d_make_extended_operator (struct d_info *di, int args,
940 struct demangle_component *name)
942 struct demangle_component *p;
944 p = d_make_empty (di);
945 if (! cplus_demangle_fill_extended_operator (p, args, name))
950 static struct demangle_component *
951 d_make_default_arg (struct d_info *di, int num,
952 struct demangle_component *sub)
954 struct demangle_component *p = d_make_empty (di);
957 p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
958 p->u.s_unary_num.num = num;
959 p->u.s_unary_num.sub = sub;
964 /* Add a new constructor component. */
966 static struct demangle_component *
967 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
968 struct demangle_component *name)
970 struct demangle_component *p;
972 p = d_make_empty (di);
973 if (! cplus_demangle_fill_ctor (p, kind, name))
978 /* Add a new destructor component. */
980 static struct demangle_component *
981 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
982 struct demangle_component *name)
984 struct demangle_component *p;
986 p = d_make_empty (di);
987 if (! cplus_demangle_fill_dtor (p, kind, name))
992 /* Add a new template parameter. */
994 static struct demangle_component *
995 d_make_template_param (struct d_info *di, long i)
997 struct demangle_component *p;
999 p = d_make_empty (di);
1002 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1003 p->u.s_number.number = i;
1008 /* Add a new function parameter. */
1010 static struct demangle_component *
1011 d_make_function_param (struct d_info *di, long i)
1013 struct demangle_component *p;
1015 p = d_make_empty (di);
1018 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1019 p->u.s_number.number = i;
1024 /* Add a new standard substitution component. */
1026 static struct demangle_component *
1027 d_make_sub (struct d_info *di, const char *name, int len)
1029 struct demangle_component *p;
1031 p = d_make_empty (di);
1034 p->type = DEMANGLE_COMPONENT_SUB_STD;
1035 p->u.s_string.string = name;
1036 p->u.s_string.len = len;
1041 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1043 TOP_LEVEL is non-zero when called at the top level. */
1045 CP_STATIC_IF_GLIBCPP_V3
1046 struct demangle_component *
1047 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1049 struct demangle_component *p;
1051 if (! d_check_char (di, '_')
1052 /* Allow missing _ if not at toplevel to work around a
1053 bug in G++ abi-version=2 mangling; see the comment in
1054 write_template_arg. */
1057 if (! d_check_char (di, 'Z'))
1059 p = d_encoding (di, top_level);
1061 /* If at top level and parsing parameters, check for a clone
1063 if (top_level && (di->options & DMGL_PARAMS) != 0)
1064 while (d_peek_char (di) == '.'
1065 && (IS_LOWER (d_peek_next_char (di))
1066 || d_peek_next_char (di) == '_'
1067 || IS_DIGIT (d_peek_next_char (di))))
1068 p = d_clone_suffix (di, p);
1073 /* Return whether a function should have a return type. The argument
1074 is the function name, which may be qualified in various ways. The
1075 rules are that template functions have return types with some
1076 exceptions, function types which are not part of a function name
1077 mangling have return types with some exceptions, and non-template
1078 function names do not have return types. The exceptions are that
1079 constructors, destructors, and conversion operators do not have
1083 has_return_type (struct demangle_component *dc)
1091 case DEMANGLE_COMPONENT_TEMPLATE:
1092 return ! is_ctor_dtor_or_conversion (d_left (dc));
1093 case DEMANGLE_COMPONENT_RESTRICT_THIS:
1094 case DEMANGLE_COMPONENT_VOLATILE_THIS:
1095 case DEMANGLE_COMPONENT_CONST_THIS:
1096 return has_return_type (d_left (dc));
1100 /* Return whether a name is a constructor, a destructor, or a
1101 conversion operator. */
1104 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1112 case DEMANGLE_COMPONENT_QUAL_NAME:
1113 case DEMANGLE_COMPONENT_LOCAL_NAME:
1114 return is_ctor_dtor_or_conversion (d_right (dc));
1115 case DEMANGLE_COMPONENT_CTOR:
1116 case DEMANGLE_COMPONENT_DTOR:
1117 case DEMANGLE_COMPONENT_CAST:
1122 /* <encoding> ::= <(function) name> <bare-function-type>
1126 TOP_LEVEL is non-zero when called at the top level, in which case
1127 if DMGL_PARAMS is not set we do not demangle the function
1128 parameters. We only set this at the top level, because otherwise
1129 we would not correctly demangle names in local scopes. */
1131 static struct demangle_component *
1132 d_encoding (struct d_info *di, int top_level)
1134 char peek = d_peek_char (di);
1136 if (peek == 'G' || peek == 'T')
1137 return d_special_name (di);
1140 struct demangle_component *dc;
1144 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1146 /* Strip off any initial CV-qualifiers, as they really apply
1147 to the `this' parameter, and they were not output by the
1148 v2 demangler without DMGL_PARAMS. */
1149 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1150 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1151 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1154 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1155 there may be CV-qualifiers on its right argument which
1156 really apply here; this happens when parsing a class
1157 which is local to a function. */
1158 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1160 struct demangle_component *dcr;
1163 while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1164 || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1165 || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1167 dc->u.s_binary.right = dcr;
1173 peek = d_peek_char (di);
1174 if (dc == NULL || peek == '\0' || peek == 'E')
1176 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1177 d_bare_function_type (di, has_return_type (dc)));
1181 /* <name> ::= <nested-name>
1183 ::= <unscoped-template-name> <template-args>
1186 <unscoped-name> ::= <unqualified-name>
1187 ::= St <unqualified-name>
1189 <unscoped-template-name> ::= <unscoped-name>
1193 static struct demangle_component *
1194 d_name (struct d_info *di)
1196 char peek = d_peek_char (di);
1197 struct demangle_component *dc;
1202 return d_nested_name (di);
1205 return d_local_name (di);
1209 return d_unqualified_name (di);
1215 if (d_peek_next_char (di) != 't')
1217 dc = d_substitution (di, 0);
1223 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1224 d_make_name (di, "std", 3),
1225 d_unqualified_name (di));
1230 if (d_peek_char (di) != 'I')
1232 /* The grammar does not permit this case to occur if we
1233 called d_substitution() above (i.e., subst == 1). We
1234 don't bother to check. */
1238 /* This is <template-args>, which means that we just saw
1239 <unscoped-template-name>, which is a substitution
1240 candidate if we didn't just get it from a
1244 if (! d_add_substitution (di, dc))
1247 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1248 d_template_args (di));
1255 dc = d_unqualified_name (di);
1256 if (d_peek_char (di) == 'I')
1258 /* This is <template-args>, which means that we just saw
1259 <unscoped-template-name>, which is a substitution
1261 if (! d_add_substitution (di, dc))
1263 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1264 d_template_args (di));
1270 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1271 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1274 static struct demangle_component *
1275 d_nested_name (struct d_info *di)
1277 struct demangle_component *ret;
1278 struct demangle_component **pret;
1280 if (! d_check_char (di, 'N'))
1283 pret = d_cv_qualifiers (di, &ret, 1);
1287 *pret = d_prefix (di);
1291 if (! d_check_char (di, 'E'))
1297 /* <prefix> ::= <prefix> <unqualified-name>
1298 ::= <template-prefix> <template-args>
1299 ::= <template-param>
1304 <template-prefix> ::= <prefix> <(template) unqualified-name>
1305 ::= <template-param>
1309 static struct demangle_component *
1310 d_prefix (struct d_info *di)
1312 struct demangle_component *ret = NULL;
1317 enum demangle_component_type comb_type;
1318 struct demangle_component *dc;
1320 peek = d_peek_char (di);
1324 /* The older code accepts a <local-name> here, but I don't see
1325 that in the grammar. The older code does not accept a
1326 <template-param> here. */
1328 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1331 char peek2 = d_peek_next_char (di);
1332 if (peek2 == 'T' || peek2 == 't')
1334 dc = cplus_demangle_type (di);
1336 /* Destructor name. */
1337 dc = d_unqualified_name (di);
1339 else if (IS_DIGIT (peek)
1344 dc = d_unqualified_name (di);
1345 else if (peek == 'S')
1346 dc = d_substitution (di, 1);
1347 else if (peek == 'I')
1351 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1352 dc = d_template_args (di);
1354 else if (peek == 'T')
1355 dc = d_template_param (di);
1356 else if (peek == 'E')
1358 else if (peek == 'M')
1360 /* Initializer scope for a lambda. We don't need to represent
1361 this; the normal code will just treat the variable as a type
1362 scope, which gives appropriate output. */
1374 ret = d_make_comp (di, comb_type, ret, dc);
1376 if (peek != 'S' && d_peek_char (di) != 'E')
1378 if (! d_add_substitution (di, ret))
1384 /* <unqualified-name> ::= <operator-name>
1385 ::= <ctor-dtor-name>
1387 ::= <local-source-name>
1389 <local-source-name> ::= L <source-name> <discriminator>
1392 static struct demangle_component *
1393 d_unqualified_name (struct d_info *di)
1397 peek = d_peek_char (di);
1398 if (IS_DIGIT (peek))
1399 return d_source_name (di);
1400 else if (IS_LOWER (peek))
1402 struct demangle_component *ret;
1404 ret = d_operator_name (di);
1405 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1406 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1409 else if (peek == 'C' || peek == 'D')
1410 return d_ctor_dtor_name (di);
1411 else if (peek == 'L')
1413 struct demangle_component * ret;
1417 ret = d_source_name (di);
1420 if (! d_discriminator (di))
1424 else if (peek == 'U')
1426 switch (d_peek_next_char (di))
1429 return d_lambda (di);
1431 return d_unnamed_type (di);
1440 /* <source-name> ::= <(positive length) number> <identifier> */
1442 static struct demangle_component *
1443 d_source_name (struct d_info *di)
1446 struct demangle_component *ret;
1448 len = d_number (di);
1451 ret = d_identifier (di, len);
1452 di->last_name = ret;
1456 /* number ::= [n] <(non-negative decimal integer)> */
1459 d_number (struct d_info *di)
1466 peek = d_peek_char (di);
1471 peek = d_peek_char (di);
1477 if (! IS_DIGIT (peek))
1483 ret = ret * 10 + peek - '0';
1485 peek = d_peek_char (di);
1489 /* Like d_number, but returns a demangle_component. */
1491 static struct demangle_component *
1492 d_number_component (struct d_info *di)
1494 struct demangle_component *ret = d_make_empty (di);
1497 ret->type = DEMANGLE_COMPONENT_NUMBER;
1498 ret->u.s_number.number = d_number (di);
1503 /* identifier ::= <(unqualified source code identifier)> */
1505 static struct demangle_component *
1506 d_identifier (struct d_info *di, int len)
1512 if (di->send - name < len)
1515 d_advance (di, len);
1517 /* A Java mangled name may have a trailing '$' if it is a C++
1518 keyword. This '$' is not included in the length count. We just
1520 if ((di->options & DMGL_JAVA) != 0
1521 && d_peek_char (di) == '$')
1524 /* Look for something which looks like a gcc encoding of an
1525 anonymous namespace, and replace it with a more user friendly
1527 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1528 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1529 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1533 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1534 if ((*s == '.' || *s == '_' || *s == '$')
1537 di->expansion -= len - sizeof "(anonymous namespace)";
1538 return d_make_name (di, "(anonymous namespace)",
1539 sizeof "(anonymous namespace)" - 1);
1543 return d_make_name (di, name, len);
1546 /* operator_name ::= many different two character encodings.
1548 ::= v <digit> <source-name>
1551 #define NL(s) s, (sizeof s) - 1
1553 CP_STATIC_IF_GLIBCPP_V3
1554 const struct demangle_operator_info cplus_demangle_operators[] =
1556 { "aN", NL ("&="), 2 },
1557 { "aS", NL ("="), 2 },
1558 { "aa", NL ("&&"), 2 },
1559 { "ad", NL ("&"), 1 },
1560 { "an", NL ("&"), 2 },
1561 { "cl", NL ("()"), 2 },
1562 { "cm", NL (","), 2 },
1563 { "co", NL ("~"), 1 },
1564 { "dV", NL ("/="), 2 },
1565 { "da", NL ("delete[]"), 1 },
1566 { "de", NL ("*"), 1 },
1567 { "dl", NL ("delete"), 1 },
1568 { "dt", NL ("."), 2 },
1569 { "dv", NL ("/"), 2 },
1570 { "eO", NL ("^="), 2 },
1571 { "eo", NL ("^"), 2 },
1572 { "eq", NL ("=="), 2 },
1573 { "ge", NL (">="), 2 },
1574 { "gt", NL (">"), 2 },
1575 { "ix", NL ("[]"), 2 },
1576 { "lS", NL ("<<="), 2 },
1577 { "le", NL ("<="), 2 },
1578 { "ls", NL ("<<"), 2 },
1579 { "lt", NL ("<"), 2 },
1580 { "mI", NL ("-="), 2 },
1581 { "mL", NL ("*="), 2 },
1582 { "mi", NL ("-"), 2 },
1583 { "ml", NL ("*"), 2 },
1584 { "mm", NL ("--"), 1 },
1585 { "na", NL ("new[]"), 1 },
1586 { "ne", NL ("!="), 2 },
1587 { "ng", NL ("-"), 1 },
1588 { "nt", NL ("!"), 1 },
1589 { "nw", NL ("new"), 1 },
1590 { "oR", NL ("|="), 2 },
1591 { "oo", NL ("||"), 2 },
1592 { "or", NL ("|"), 2 },
1593 { "pL", NL ("+="), 2 },
1594 { "pl", NL ("+"), 2 },
1595 { "pm", NL ("->*"), 2 },
1596 { "pp", NL ("++"), 1 },
1597 { "ps", NL ("+"), 1 },
1598 { "pt", NL ("->"), 2 },
1599 { "qu", NL ("?"), 3 },
1600 { "rM", NL ("%="), 2 },
1601 { "rS", NL (">>="), 2 },
1602 { "rm", NL ("%"), 2 },
1603 { "rs", NL (">>"), 2 },
1604 { "st", NL ("sizeof "), 1 },
1605 { "sz", NL ("sizeof "), 1 },
1606 { "at", NL ("alignof "), 1 },
1607 { "az", NL ("alignof "), 1 },
1608 { NULL, NULL, 0, 0 }
1611 static struct demangle_component *
1612 d_operator_name (struct d_info *di)
1617 c1 = d_next_char (di);
1618 c2 = d_next_char (di);
1619 if (c1 == 'v' && IS_DIGIT (c2))
1620 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1621 else if (c1 == 'c' && c2 == 'v')
1622 return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1623 cplus_demangle_type (di), NULL);
1626 /* LOW is the inclusive lower bound. */
1628 /* HIGH is the exclusive upper bound. We subtract one to ignore
1629 the sentinel at the end of the array. */
1630 int high = ((sizeof (cplus_demangle_operators)
1631 / sizeof (cplus_demangle_operators[0]))
1637 const struct demangle_operator_info *p;
1639 i = low + (high - low) / 2;
1640 p = cplus_demangle_operators + i;
1642 if (c1 == p->code[0] && c2 == p->code[1])
1643 return d_make_operator (di, p);
1645 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1655 static struct demangle_component *
1656 d_make_character (struct d_info *di, int c)
1658 struct demangle_component *p;
1659 p = d_make_empty (di);
1662 p->type = DEMANGLE_COMPONENT_CHARACTER;
1663 p->u.s_character.character = c;
1668 static struct demangle_component *
1669 d_java_resource (struct d_info *di)
1671 struct demangle_component *p = NULL;
1672 struct demangle_component *next = NULL;
1677 len = d_number (di);
1681 /* Eat the leading '_'. */
1682 if (d_next_char (di) != '_')
1695 /* Each chunk is either a '$' escape... */
1713 next = d_make_character (di, c);
1721 /* ... or a sequence of characters. */
1724 while (i < len && str[i] && str[i] != '$')
1727 next = d_make_name (di, str, i);
1740 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1746 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1751 /* <special-name> ::= TV <type>
1755 ::= GV <(object) name>
1756 ::= T <call-offset> <(base) encoding>
1757 ::= Tc <call-offset> <call-offset> <(base) encoding>
1758 Also g++ extensions:
1759 ::= TC <type> <(offset) number> _ <(base) type>
1764 ::= Gr <resource name>
1767 static struct demangle_component *
1768 d_special_name (struct d_info *di)
1770 di->expansion += 20;
1771 if (d_check_char (di, 'T'))
1773 switch (d_next_char (di))
1777 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1778 cplus_demangle_type (di), NULL);
1780 di->expansion -= 10;
1781 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1782 cplus_demangle_type (di), NULL);
1784 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1785 cplus_demangle_type (di), NULL);
1787 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1788 cplus_demangle_type (di), NULL);
1791 if (! d_call_offset (di, 'h'))
1793 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1794 d_encoding (di, 0), NULL);
1797 if (! d_call_offset (di, 'v'))
1799 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1800 d_encoding (di, 0), NULL);
1803 if (! d_call_offset (di, '\0'))
1805 if (! d_call_offset (di, '\0'))
1807 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1808 d_encoding (di, 0), NULL);
1812 struct demangle_component *derived_type;
1814 struct demangle_component *base_type;
1816 derived_type = cplus_demangle_type (di);
1817 offset = d_number (di);
1820 if (! d_check_char (di, '_'))
1822 base_type = cplus_demangle_type (di);
1823 /* We don't display the offset. FIXME: We should display
1824 it in verbose mode. */
1826 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1827 base_type, derived_type);
1831 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1832 cplus_demangle_type (di), NULL);
1834 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1835 cplus_demangle_type (di), NULL);
1841 else if (d_check_char (di, 'G'))
1843 switch (d_next_char (di))
1846 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1849 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1853 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1854 d_encoding (di, 0), NULL);
1857 return d_java_resource (di);
1867 /* <call-offset> ::= h <nv-offset> _
1870 <nv-offset> ::= <(offset) number>
1872 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1874 The C parameter, if not '\0', is a character we just read which is
1875 the start of the <call-offset>.
1877 We don't display the offset information anywhere. FIXME: We should
1878 display it in verbose mode. */
1881 d_call_offset (struct d_info *di, int c)
1884 c = d_next_char (di);
1891 if (! d_check_char (di, '_'))
1898 if (! d_check_char (di, '_'))
1904 /* <ctor-dtor-name> ::= C1
1912 static struct demangle_component *
1913 d_ctor_dtor_name (struct d_info *di)
1915 if (di->last_name != NULL)
1917 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
1918 di->expansion += di->last_name->u.s_name.len;
1919 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
1920 di->expansion += di->last_name->u.s_string.len;
1922 switch (d_peek_char (di))
1926 enum gnu_v3_ctor_kinds kind;
1928 switch (d_peek_next_char (di))
1931 kind = gnu_v3_complete_object_ctor;
1934 kind = gnu_v3_base_object_ctor;
1937 kind = gnu_v3_complete_object_allocating_ctor;
1943 return d_make_ctor (di, kind, di->last_name);
1948 enum gnu_v3_dtor_kinds kind;
1950 switch (d_peek_next_char (di))
1953 kind = gnu_v3_deleting_dtor;
1956 kind = gnu_v3_complete_object_dtor;
1959 kind = gnu_v3_base_object_dtor;
1965 return d_make_dtor (di, kind, di->last_name);
1973 /* <type> ::= <builtin-type>
1975 ::= <class-enum-type>
1977 ::= <pointer-to-member-type>
1978 ::= <template-param>
1979 ::= <template-template-param> <template-args>
1981 ::= <CV-qualifiers> <type>
1984 ::= O <type> (C++0x)
1987 ::= U <source-name> <type>
1989 <builtin-type> ::= various one letter codes
1993 CP_STATIC_IF_GLIBCPP_V3
1994 const struct demangle_builtin_type_info
1995 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1997 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
1998 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
1999 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2000 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2001 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2002 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2003 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2004 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2005 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2006 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
2007 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2008 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2009 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2010 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2011 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2013 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2014 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2015 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2016 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2017 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2018 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2019 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2020 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2021 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2022 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2023 D_PRINT_UNSIGNED_LONG_LONG },
2024 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
2025 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2026 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2027 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2028 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2029 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2030 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2031 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2035 CP_STATIC_IF_GLIBCPP_V3
2036 struct demangle_component *
2037 cplus_demangle_type (struct d_info *di)
2040 struct demangle_component *ret;
2043 /* The ABI specifies that when CV-qualifiers are used, the base type
2044 is substitutable, and the fully qualified type is substitutable,
2045 but the base type with a strict subset of the CV-qualifiers is
2046 not substitutable. The natural recursive implementation of the
2047 CV-qualifiers would cause subsets to be substitutable, so instead
2048 we pull them all off now.
2050 FIXME: The ABI says that order-insensitive vendor qualifiers
2051 should be handled in the same way, but we have no way to tell
2052 which vendor qualifiers are order-insensitive and which are
2053 order-sensitive. So we just assume that they are all
2054 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2055 __vector, and it treats it as order-sensitive when mangling
2058 peek = d_peek_char (di);
2059 if (peek == 'r' || peek == 'V' || peek == 'K')
2061 struct demangle_component **pret;
2063 pret = d_cv_qualifiers (di, &ret, 0);
2066 *pret = cplus_demangle_type (di);
2067 if (! *pret || ! d_add_substitution (di, ret))
2076 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2077 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2078 case 'o': case 's': case 't':
2079 case 'v': case 'w': case 'x': case 'y': case 'z':
2080 ret = d_make_builtin_type (di,
2081 &cplus_demangle_builtin_types[peek - 'a']);
2082 di->expansion += ret->u.s_builtin.type->len;
2089 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2090 d_source_name (di), NULL);
2094 ret = d_function_type (di);
2097 case '0': case '1': case '2': case '3': case '4':
2098 case '5': case '6': case '7': case '8': case '9':
2101 ret = d_class_enum_type (di);
2105 ret = d_array_type (di);
2109 ret = d_pointer_to_member_type (di);
2113 ret = d_template_param (di);
2114 if (d_peek_char (di) == 'I')
2116 /* This is <template-template-param> <template-args>. The
2117 <template-template-param> part is a substitution
2119 if (! d_add_substitution (di, ret))
2121 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2122 d_template_args (di));
2127 /* If this is a special substitution, then it is the start of
2128 <class-enum-type>. */
2132 peek_next = d_peek_next_char (di);
2133 if (IS_DIGIT (peek_next)
2135 || IS_UPPER (peek_next))
2137 ret = d_substitution (di, 0);
2138 /* The substituted name may have been a template name and
2139 may be followed by tepmlate args. */
2140 if (d_peek_char (di) == 'I')
2141 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2142 d_template_args (di));
2148 ret = d_class_enum_type (di);
2149 /* If the substitution was a complete type, then it is not
2150 a new substitution candidate. However, if the
2151 substitution was followed by template arguments, then
2152 the whole thing is a substitution candidate. */
2153 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2161 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2162 cplus_demangle_type (di), NULL);
2167 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2168 cplus_demangle_type (di), NULL);
2173 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2174 cplus_demangle_type (di), NULL);
2179 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2180 cplus_demangle_type (di), NULL);
2185 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2186 cplus_demangle_type (di), NULL);
2191 ret = d_source_name (di);
2192 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2193 cplus_demangle_type (di), ret);
2199 peek = d_next_char (di);
2204 /* decltype (expression) */
2205 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2206 d_expression (di), NULL);
2207 if (ret && d_next_char (di) != 'E')
2212 /* Pack expansion. */
2213 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2214 cplus_demangle_type (di), NULL);
2218 /* 32-bit decimal floating point */
2219 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2220 di->expansion += ret->u.s_builtin.type->len;
2224 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2225 di->expansion += ret->u.s_builtin.type->len;
2229 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2230 di->expansion += ret->u.s_builtin.type->len;
2233 /* 16-bit half-precision FP */
2234 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2235 di->expansion += ret->u.s_builtin.type->len;
2239 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2240 di->expansion += ret->u.s_builtin.type->len;
2244 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2245 di->expansion += ret->u.s_builtin.type->len;
2249 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2250 ret = d_make_empty (di);
2251 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2252 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2253 /* For demangling we don't care about the bits. */
2255 ret->u.s_fixed.length = cplus_demangle_type (di);
2256 if (ret->u.s_fixed.length == NULL)
2259 peek = d_next_char (di);
2260 ret->u.s_fixed.sat = (peek == 's');
2264 ret = d_vector_type (di);
2268 /* decltype(nullptr) */
2269 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2270 di->expansion += ret->u.s_builtin.type->len;
2284 if (! d_add_substitution (di, ret))
2291 /* <CV-qualifiers> ::= [r] [V] [K] */
2293 static struct demangle_component **
2294 d_cv_qualifiers (struct d_info *di,
2295 struct demangle_component **pret, int member_fn)
2299 peek = d_peek_char (di);
2300 while (peek == 'r' || peek == 'V' || peek == 'K')
2302 enum demangle_component_type t;
2308 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2309 : DEMANGLE_COMPONENT_RESTRICT);
2310 di->expansion += sizeof "restrict";
2312 else if (peek == 'V')
2315 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2316 : DEMANGLE_COMPONENT_VOLATILE);
2317 di->expansion += sizeof "volatile";
2322 ? DEMANGLE_COMPONENT_CONST_THIS
2323 : DEMANGLE_COMPONENT_CONST);
2324 di->expansion += sizeof "const";
2327 *pret = d_make_comp (di, t, NULL, NULL);
2330 pret = &d_left (*pret);
2332 peek = d_peek_char (di);
2338 /* <function-type> ::= F [Y] <bare-function-type> E */
2340 static struct demangle_component *
2341 d_function_type (struct d_info *di)
2343 struct demangle_component *ret;
2345 if (! d_check_char (di, 'F'))
2347 if (d_peek_char (di) == 'Y')
2349 /* Function has C linkage. We don't print this information.
2350 FIXME: We should print it in verbose mode. */
2353 ret = d_bare_function_type (di, 1);
2354 if (! d_check_char (di, 'E'))
2361 static struct demangle_component *
2362 d_parmlist (struct d_info *di)
2364 struct demangle_component *tl;
2365 struct demangle_component **ptl;
2371 struct demangle_component *type;
2373 char peek = d_peek_char (di);
2374 if (peek == '\0' || peek == 'E' || peek == '.')
2376 type = cplus_demangle_type (di);
2379 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2382 ptl = &d_right (*ptl);
2385 /* There should be at least one parameter type besides the optional
2386 return type. A function which takes no arguments will have a
2387 single parameter type void. */
2391 /* If we have a single parameter type void, omit it. */
2392 if (d_right (tl) == NULL
2393 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2394 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2396 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2403 /* <bare-function-type> ::= [J]<type>+ */
2405 static struct demangle_component *
2406 d_bare_function_type (struct d_info *di, int has_return_type)
2408 struct demangle_component *return_type;
2409 struct demangle_component *tl;
2412 /* Detect special qualifier indicating that the first argument
2413 is the return type. */
2414 peek = d_peek_char (di);
2418 has_return_type = 1;
2421 if (has_return_type)
2423 return_type = cplus_demangle_type (di);
2424 if (return_type == NULL)
2430 tl = d_parmlist (di);
2434 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2438 /* <class-enum-type> ::= <name> */
2440 static struct demangle_component *
2441 d_class_enum_type (struct d_info *di)
2446 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2447 ::= A [<(dimension) expression>] _ <(element) type>
2450 static struct demangle_component *
2451 d_array_type (struct d_info *di)
2454 struct demangle_component *dim;
2456 if (! d_check_char (di, 'A'))
2459 peek = d_peek_char (di);
2462 else if (IS_DIGIT (peek))
2470 peek = d_peek_char (di);
2472 while (IS_DIGIT (peek));
2473 dim = d_make_name (di, s, d_str (di) - s);
2479 dim = d_expression (di);
2484 if (! d_check_char (di, '_'))
2487 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2488 cplus_demangle_type (di));
2491 /* <vector-type> ::= Dv <number> _ <type>
2492 ::= Dv _ <expression> _ <type> */
2494 static struct demangle_component *
2495 d_vector_type (struct d_info *di)
2498 struct demangle_component *dim;
2500 peek = d_peek_char (di);
2504 dim = d_expression (di);
2507 dim = d_number_component (di);
2512 if (! d_check_char (di, '_'))
2515 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2516 cplus_demangle_type (di));
2519 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2521 static struct demangle_component *
2522 d_pointer_to_member_type (struct d_info *di)
2524 struct demangle_component *cl;
2525 struct demangle_component *mem;
2526 struct demangle_component **pmem;
2528 if (! d_check_char (di, 'M'))
2531 cl = cplus_demangle_type (di);
2533 /* The ABI specifies that any type can be a substitution source, and
2534 that M is followed by two types, and that when a CV-qualified
2535 type is seen both the base type and the CV-qualified types are
2536 substitution sources. The ABI also specifies that for a pointer
2537 to a CV-qualified member function, the qualifiers are attached to
2538 the second type. Given the grammar, a plain reading of the ABI
2539 suggests that both the CV-qualified member function and the
2540 non-qualified member function are substitution sources. However,
2541 g++ does not work that way. g++ treats only the CV-qualified
2542 member function as a substitution source. FIXME. So to work
2543 with g++, we need to pull off the CV-qualifiers here, in order to
2544 avoid calling add_substitution() in cplus_demangle_type(). But
2545 for a CV-qualified member which is not a function, g++ does
2546 follow the ABI, so we need to handle that case here by calling
2547 d_add_substitution ourselves. */
2549 pmem = d_cv_qualifiers (di, &mem, 1);
2552 *pmem = cplus_demangle_type (di);
2556 if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2558 if (! d_add_substitution (di, mem))
2562 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2565 /* <non-negative number> _ */
2568 d_compact_number (struct d_info *di)
2571 if (d_peek_char (di) == '_')
2573 else if (d_peek_char (di) == 'n')
2576 num = d_number (di) + 1;
2578 if (! d_check_char (di, '_'))
2583 /* <template-param> ::= T_
2584 ::= T <(parameter-2 non-negative) number> _
2587 static struct demangle_component *
2588 d_template_param (struct d_info *di)
2592 if (! d_check_char (di, 'T'))
2595 param = d_compact_number (di);
2601 return d_make_template_param (di, param);
2604 /* <template-args> ::= I <template-arg>+ E */
2606 static struct demangle_component *
2607 d_template_args (struct d_info *di)
2609 struct demangle_component *hold_last_name;
2610 struct demangle_component *al;
2611 struct demangle_component **pal;
2613 /* Preserve the last name we saw--don't let the template arguments
2614 clobber it, as that would give us the wrong name for a subsequent
2615 constructor or destructor. */
2616 hold_last_name = di->last_name;
2618 if (! d_check_char (di, 'I'))
2621 if (d_peek_char (di) == 'E')
2623 /* An argument pack can be empty. */
2625 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2632 struct demangle_component *a;
2634 a = d_template_arg (di);
2638 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2641 pal = &d_right (*pal);
2643 if (d_peek_char (di) == 'E')
2650 di->last_name = hold_last_name;
2655 /* <template-arg> ::= <type>
2656 ::= X <expression> E
2660 static struct demangle_component *
2661 d_template_arg (struct d_info *di)
2663 struct demangle_component *ret;
2665 switch (d_peek_char (di))
2669 ret = d_expression (di);
2670 if (! d_check_char (di, 'E'))
2675 return d_expr_primary (di);
2678 /* An argument pack. */
2679 return d_template_args (di);
2682 return cplus_demangle_type (di);
2686 /* Subroutine of <expression> ::= cl <expression>+ E */
2688 static struct demangle_component *
2689 d_exprlist (struct d_info *di)
2691 struct demangle_component *list = NULL;
2692 struct demangle_component **p = &list;
2694 if (d_peek_char (di) == 'E')
2697 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2702 struct demangle_component *arg = d_expression (di);
2706 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2711 if (d_peek_char (di) == 'E')
2721 /* <expression> ::= <(unary) operator-name> <expression>
2722 ::= <(binary) operator-name> <expression> <expression>
2723 ::= <(trinary) operator-name> <expression> <expression> <expression>
2724 ::= cl <expression>+ E
2726 ::= <template-param>
2727 ::= sr <type> <unqualified-name>
2728 ::= sr <type> <unqualified-name> <template-args>
2732 static struct demangle_component *
2733 d_expression (struct d_info *di)
2737 peek = d_peek_char (di);
2739 return d_expr_primary (di);
2740 else if (peek == 'T')
2741 return d_template_param (di);
2742 else if (peek == 's' && d_peek_next_char (di) == 'r')
2744 struct demangle_component *type;
2745 struct demangle_component *name;
2748 type = cplus_demangle_type (di);
2749 name = d_unqualified_name (di);
2750 if (d_peek_char (di) != 'I')
2751 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2753 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2754 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2755 d_template_args (di)));
2757 else if (peek == 's' && d_peek_next_char (di) == 'p')
2760 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2761 d_expression (di), NULL);
2763 else if (peek == 'f' && d_peek_next_char (di) == 'p')
2765 /* Function parameter used in a late-specified return type. */
2768 if (d_peek_char (di) == 'T')
2770 /* 'this' parameter. */
2776 index = d_compact_number (di) + 1;
2780 return d_make_function_param (di, index);
2782 else if (IS_DIGIT (peek)
2783 || (peek == 'o' && d_peek_next_char (di) == 'n'))
2785 /* We can get an unqualified name as an expression in the case of
2786 a dependent function call, i.e. decltype(f(t)). */
2787 struct demangle_component *name;
2790 /* operator-function-id, i.e. operator+(t). */
2793 name = d_unqualified_name (di);
2796 if (d_peek_char (di) == 'I')
2797 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2798 d_template_args (di));
2804 struct demangle_component *op;
2807 op = d_operator_name (di);
2811 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2812 di->expansion += op->u.s_operator.op->len - 2;
2814 if (op->type == DEMANGLE_COMPONENT_OPERATOR
2815 && strcmp (op->u.s_operator.op->code, "st") == 0)
2816 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2817 cplus_demangle_type (di));
2823 case DEMANGLE_COMPONENT_OPERATOR:
2824 args = op->u.s_operator.op->args;
2826 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2827 args = op->u.s_extended_operator.args;
2829 case DEMANGLE_COMPONENT_CAST:
2838 struct demangle_component *operand;
2839 if (op->type == DEMANGLE_COMPONENT_CAST
2840 && d_check_char (di, '_'))
2841 operand = d_exprlist (di);
2843 operand = d_expression (di);
2844 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2849 struct demangle_component *left;
2850 struct demangle_component *right;
2851 const char *code = op->u.s_operator.op->code;
2853 left = d_expression (di);
2854 if (!strcmp (code, "cl"))
2855 right = d_exprlist (di);
2856 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
2858 right = d_unqualified_name (di);
2859 if (d_peek_char (di) == 'I')
2860 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
2861 right, d_template_args (di));
2864 right = d_expression (di);
2866 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2868 DEMANGLE_COMPONENT_BINARY_ARGS,
2873 struct demangle_component *first;
2874 struct demangle_component *second;
2876 first = d_expression (di);
2877 second = d_expression (di);
2878 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2880 DEMANGLE_COMPONENT_TRINARY_ARG1,
2883 DEMANGLE_COMPONENT_TRINARY_ARG2,
2885 d_expression (di))));
2893 /* <expr-primary> ::= L <type> <(value) number> E
2894 ::= L <type> <(value) float> E
2895 ::= L <mangled-name> E
2898 static struct demangle_component *
2899 d_expr_primary (struct d_info *di)
2901 struct demangle_component *ret;
2903 if (! d_check_char (di, 'L'))
2905 if (d_peek_char (di) == '_'
2906 /* Workaround for G++ bug; see comment in write_template_arg. */
2907 || d_peek_char (di) == 'Z')
2908 ret = cplus_demangle_mangled_name (di, 0);
2911 struct demangle_component *type;
2912 enum demangle_component_type t;
2915 type = cplus_demangle_type (di);
2919 /* If we have a type we know how to print, we aren't going to
2920 print the type name itself. */
2921 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2922 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2923 di->expansion -= type->u.s_builtin.type->len;
2925 /* Rather than try to interpret the literal value, we just
2926 collect it as a string. Note that it's possible to have a
2927 floating point literal here. The ABI specifies that the
2928 format of such literals is machine independent. That's fine,
2929 but what's not fine is that versions of g++ up to 3.2 with
2930 -fabi-version=1 used upper case letters in the hex constant,
2931 and dumped out gcc's internal representation. That makes it
2932 hard to tell where the constant ends, and hard to dump the
2933 constant in any readable form anyhow. We don't attempt to
2934 handle these cases. */
2936 t = DEMANGLE_COMPONENT_LITERAL;
2937 if (d_peek_char (di) == 'n')
2939 t = DEMANGLE_COMPONENT_LITERAL_NEG;
2943 while (d_peek_char (di) != 'E')
2945 if (d_peek_char (di) == '\0')
2949 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2951 if (! d_check_char (di, 'E'))
2956 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2957 ::= Z <(function) encoding> E s [<discriminator>]
2960 static struct demangle_component *
2961 d_local_name (struct d_info *di)
2963 struct demangle_component *function;
2965 if (! d_check_char (di, 'Z'))
2968 function = d_encoding (di, 0);
2970 if (! d_check_char (di, 'E'))
2973 if (d_peek_char (di) == 's')
2976 if (! d_discriminator (di))
2978 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2979 d_make_name (di, "string literal",
2980 sizeof "string literal" - 1));
2984 struct demangle_component *name;
2987 if (d_peek_char (di) == 'd')
2989 /* Default argument scope: d <number> _. */
2991 num = d_compact_number (di);
3000 /* Lambdas and unnamed types have internal discriminators. */
3001 case DEMANGLE_COMPONENT_LAMBDA:
3002 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3005 if (! d_discriminator (di))
3009 name = d_make_default_arg (di, num, name);
3010 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3014 /* <discriminator> ::= _ <(non-negative) number>
3016 We demangle the discriminator, but we don't print it out. FIXME:
3017 We should print it out in verbose mode. */
3020 d_discriminator (struct d_info *di)
3024 if (d_peek_char (di) != '_')
3027 discrim = d_number (di);
3033 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3035 static struct demangle_component *
3036 d_lambda (struct d_info *di)
3038 struct demangle_component *tl;
3039 struct demangle_component *ret;
3042 if (! d_check_char (di, 'U'))
3044 if (! d_check_char (di, 'l'))
3047 tl = d_parmlist (di);
3051 if (! d_check_char (di, 'E'))
3054 num = d_compact_number (di);
3058 ret = d_make_empty (di);
3061 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3062 ret->u.s_unary_num.sub = tl;
3063 ret->u.s_unary_num.num = num;
3066 if (! d_add_substitution (di, ret))
3072 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3074 static struct demangle_component *
3075 d_unnamed_type (struct d_info *di)
3077 struct demangle_component *ret;
3080 if (! d_check_char (di, 'U'))
3082 if (! d_check_char (di, 't'))
3085 num = d_compact_number (di);
3089 ret = d_make_empty (di);
3092 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3093 ret->u.s_number.number = num;
3096 if (! d_add_substitution (di, ret))
3102 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3105 static struct demangle_component *
3106 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3108 const char *suffix = d_str (di);
3109 const char *pend = suffix;
3110 struct demangle_component *n;
3112 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3115 while (IS_LOWER (*pend) || *pend == '_')
3118 while (*pend == '.' && IS_DIGIT (pend[1]))
3121 while (IS_DIGIT (*pend))
3124 d_advance (di, pend - suffix);
3125 n = d_make_name (di, suffix, pend - suffix);
3126 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3129 /* Add a new substitution. */
3132 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3136 if (di->next_sub >= di->num_subs)
3138 di->subs[di->next_sub] = dc;
3143 /* <substitution> ::= S <seq-id> _
3153 If PREFIX is non-zero, then this type is being used as a prefix in
3154 a qualified name. In this case, for the standard substitutions, we
3155 need to check whether we are being used as a prefix for a
3156 constructor or destructor, and return a full template name.
3157 Otherwise we will get something like std::iostream::~iostream()
3158 which does not correspond particularly well to any function which
3159 actually appears in the source.
3162 static const struct d_standard_sub_info standard_subs[] =
3167 { 'a', NL ("std::allocator"),
3168 NL ("std::allocator"),
3170 { 'b', NL ("std::basic_string"),
3171 NL ("std::basic_string"),
3172 NL ("basic_string") },
3173 { 's', NL ("std::string"),
3174 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3175 NL ("basic_string") },
3176 { 'i', NL ("std::istream"),
3177 NL ("std::basic_istream<char, std::char_traits<char> >"),
3178 NL ("basic_istream") },
3179 { 'o', NL ("std::ostream"),
3180 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3181 NL ("basic_ostream") },
3182 { 'd', NL ("std::iostream"),
3183 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3184 NL ("basic_iostream") }
3187 static struct demangle_component *
3188 d_substitution (struct d_info *di, int prefix)
3192 if (! d_check_char (di, 'S'))
3195 c = d_next_char (di);
3196 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3205 unsigned int new_id;
3208 new_id = id * 36 + c - '0';
3209 else if (IS_UPPER (c))
3210 new_id = id * 36 + c - 'A' + 10;
3216 c = d_next_char (di);
3223 if (id >= (unsigned int) di->next_sub)
3228 return di->subs[id];
3233 const struct d_standard_sub_info *p;
3234 const struct d_standard_sub_info *pend;
3236 verbose = (di->options & DMGL_VERBOSE) != 0;
3237 if (! verbose && prefix)
3241 peek = d_peek_char (di);
3242 if (peek == 'C' || peek == 'D')
3246 pend = (&standard_subs[0]
3247 + sizeof standard_subs / sizeof standard_subs[0]);
3248 for (p = &standard_subs[0]; p < pend; ++p)
3255 if (p->set_last_name != NULL)
3256 di->last_name = d_make_sub (di, p->set_last_name,
3257 p->set_last_name_len);
3260 s = p->full_expansion;
3265 s = p->simple_expansion;
3266 len = p->simple_len;
3268 di->expansion += len;
3269 return d_make_sub (di, s, len);
3277 /* Initialize a growable string. */
3280 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3285 dgs->allocation_failure = 0;
3288 d_growable_string_resize (dgs, estimate);
3291 /* Grow a growable string to a given size. */
3294 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3299 if (dgs->allocation_failure)
3302 /* Start allocation at two bytes to avoid any possibility of confusion
3303 with the special value of 1 used as a return in *palc to indicate
3304 allocation failures. */
3305 newalc = dgs->alc > 0 ? dgs->alc : 2;
3306 while (newalc < need)
3309 newbuf = (char *) realloc (dgs->buf, newalc);
3316 dgs->allocation_failure = 1;
3323 /* Append a buffer to a growable string. */
3326 d_growable_string_append_buffer (struct d_growable_string *dgs,
3327 const char *s, size_t l)
3331 need = dgs->len + l + 1;
3332 if (need > dgs->alc)
3333 d_growable_string_resize (dgs, need);
3335 if (dgs->allocation_failure)
3338 memcpy (dgs->buf + dgs->len, s, l);
3339 dgs->buf[dgs->len + l] = '\0';
3343 /* Bridge growable strings to the callback mechanism. */
3346 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3348 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3350 d_growable_string_append_buffer (dgs, s, l);
3353 /* Initialize a print information structure. */
3356 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3360 dpi->last_char = '\0';
3361 dpi->templates = NULL;
3362 dpi->modifiers = NULL;
3363 dpi->pack_index = 0;
3364 dpi->flush_count = 0;
3366 dpi->callback = callback;
3367 dpi->opaque = opaque;
3369 dpi->demangle_failure = 0;
3372 /* Indicate that an error occurred during printing, and test for error. */
3375 d_print_error (struct d_print_info *dpi)
3377 dpi->demangle_failure = 1;
3381 d_print_saw_error (struct d_print_info *dpi)
3383 return dpi->demangle_failure != 0;
3386 /* Flush buffered characters to the callback. */
3389 d_print_flush (struct d_print_info *dpi)
3391 dpi->buf[dpi->len] = '\0';
3392 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3397 /* Append characters and buffers for printing. */
3400 d_append_char (struct d_print_info *dpi, char c)
3402 if (dpi->len == sizeof (dpi->buf) - 1)
3403 d_print_flush (dpi);
3405 dpi->buf[dpi->len++] = c;
3410 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3414 for (i = 0; i < l; i++)
3415 d_append_char (dpi, s[i]);
3419 d_append_string (struct d_print_info *dpi, const char *s)
3421 d_append_buffer (dpi, s, strlen (s));
3425 d_append_num (struct d_print_info *dpi, long l)
3428 sprintf (buf,"%ld", l);
3429 d_append_string (dpi, buf);
3433 d_last_char (struct d_print_info *dpi)
3435 return dpi->last_char;
3438 /* Turn components into a human readable string. OPTIONS is the
3439 options bits passed to the demangler. DC is the tree to print.
3440 CALLBACK is a function to call to flush demangled string segments
3441 as they fill the intermediate buffer, and OPAQUE is a generalized
3442 callback argument. On success, this returns 1. On failure,
3443 it returns 0, indicating a bad parse. It does not use heap
3444 memory to build an output string, so cannot encounter memory
3445 allocation failure. */
3447 CP_STATIC_IF_GLIBCPP_V3
3449 cplus_demangle_print_callback (int options,
3450 const struct demangle_component *dc,
3451 demangle_callbackref callback, void *opaque)
3453 struct d_print_info dpi;
3455 d_print_init (&dpi, callback, opaque);
3457 d_print_comp (&dpi, options, dc);
3459 d_print_flush (&dpi);
3461 return ! d_print_saw_error (&dpi);
3464 /* Turn components into a human readable string. OPTIONS is the
3465 options bits passed to the demangler. DC is the tree to print.
3466 ESTIMATE is a guess at the length of the result. This returns a
3467 string allocated by malloc, or NULL on error. On success, this
3468 sets *PALC to the size of the allocated buffer. On failure, this
3469 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3472 CP_STATIC_IF_GLIBCPP_V3
3474 cplus_demangle_print (int options, const struct demangle_component *dc,
3475 int estimate, size_t *palc)
3477 struct d_growable_string dgs;
3479 d_growable_string_init (&dgs, estimate);
3481 if (! cplus_demangle_print_callback (options, dc,
3482 d_growable_string_callback_adapter,
3490 *palc = dgs.allocation_failure ? 1 : dgs.alc;
3494 /* Returns the I'th element of the template arglist ARGS, or NULL on
3497 static struct demangle_component *
3498 d_index_template_argument (struct demangle_component *args, int i)
3500 struct demangle_component *a;
3506 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3512 if (i != 0 || a == NULL)
3518 /* Returns the template argument from the current context indicated by DC,
3519 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3521 static struct demangle_component *
3522 d_lookup_template_argument (struct d_print_info *dpi,
3523 const struct demangle_component *dc)
3525 if (dpi->templates == NULL)
3527 d_print_error (dpi);
3531 return d_index_template_argument
3532 (d_right (dpi->templates->template_decl),
3533 dc->u.s_number.number);
3536 /* Returns a template argument pack used in DC (any will do), or NULL. */
3538 static struct demangle_component *
3539 d_find_pack (struct d_print_info *dpi,
3540 const struct demangle_component *dc)
3542 struct demangle_component *a;
3548 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3549 a = d_lookup_template_argument (dpi, dc);
3550 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3554 case DEMANGLE_COMPONENT_PACK_EXPANSION:
3557 case DEMANGLE_COMPONENT_LAMBDA:
3558 case DEMANGLE_COMPONENT_NAME:
3559 case DEMANGLE_COMPONENT_OPERATOR:
3560 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3561 case DEMANGLE_COMPONENT_SUB_STD:
3562 case DEMANGLE_COMPONENT_CHARACTER:
3563 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3566 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3567 return d_find_pack (dpi, dc->u.s_extended_operator.name);
3568 case DEMANGLE_COMPONENT_CTOR:
3569 return d_find_pack (dpi, dc->u.s_ctor.name);
3570 case DEMANGLE_COMPONENT_DTOR:
3571 return d_find_pack (dpi, dc->u.s_dtor.name);
3574 a = d_find_pack (dpi, d_left (dc));
3577 return d_find_pack (dpi, d_right (dc));
3581 /* Returns the length of the template argument pack DC. */
3584 d_pack_length (const struct demangle_component *dc)
3587 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3588 && d_left (dc) != NULL)
3596 /* DC is a component of a mangled expression. Print it, wrapped in parens
3600 d_print_subexpr (struct d_print_info *dpi, int options,
3601 const struct demangle_component *dc)
3604 if (dc->type == DEMANGLE_COMPONENT_NAME
3605 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3608 d_append_char (dpi, '(');
3609 d_print_comp (dpi, options, dc);
3611 d_append_char (dpi, ')');
3614 /* Subroutine to handle components. */
3617 d_print_comp (struct d_print_info *dpi, int options,
3618 const struct demangle_component *dc)
3620 /* Magic variable to let reference smashing skip over the next modifier
3621 without needing to modify *dc. */
3622 const struct demangle_component *mod_inner = NULL;
3626 d_print_error (dpi);
3629 if (d_print_saw_error (dpi))
3634 case DEMANGLE_COMPONENT_NAME:
3635 if ((options & DMGL_JAVA) == 0)
3636 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3638 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3641 case DEMANGLE_COMPONENT_QUAL_NAME:
3642 case DEMANGLE_COMPONENT_LOCAL_NAME:
3643 d_print_comp (dpi, options, d_left (dc));
3644 if ((options & DMGL_JAVA) == 0)
3645 d_append_string (dpi, "::");
3647 d_append_char (dpi, '.');
3648 d_print_comp (dpi, options, d_right (dc));
3651 case DEMANGLE_COMPONENT_TYPED_NAME:
3653 struct d_print_mod *hold_modifiers;
3654 struct demangle_component *typed_name;
3655 struct d_print_mod adpm[4];
3657 struct d_print_template dpt;
3659 /* Pass the name down to the type so that it can be printed in
3660 the right place for the type. We also have to pass down
3661 any CV-qualifiers, which apply to the this parameter. */
3662 hold_modifiers = dpi->modifiers;
3665 typed_name = d_left (dc);
3666 while (typed_name != NULL)
3668 if (i >= sizeof adpm / sizeof adpm[0])
3670 d_print_error (dpi);
3674 adpm[i].next = dpi->modifiers;
3675 dpi->modifiers = &adpm[i];
3676 adpm[i].mod = typed_name;
3677 adpm[i].printed = 0;
3678 adpm[i].templates = dpi->templates;
3681 if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3682 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3683 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3686 typed_name = d_left (typed_name);
3689 if (typed_name == NULL)
3691 d_print_error (dpi);
3695 /* If typed_name is a template, then it applies to the
3696 function type as well. */
3697 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3699 dpt.next = dpi->templates;
3700 dpi->templates = &dpt;
3701 dpt.template_decl = typed_name;
3704 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3705 there may be CV-qualifiers on its right argument which
3706 really apply here; this happens when parsing a class which
3707 is local to a function. */
3708 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3710 struct demangle_component *local_name;
3712 local_name = d_right (typed_name);
3713 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3714 local_name = local_name->u.s_unary_num.sub;
3715 while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3716 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3717 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3719 if (i >= sizeof adpm / sizeof adpm[0])
3721 d_print_error (dpi);
3725 adpm[i] = adpm[i - 1];
3726 adpm[i].next = &adpm[i - 1];
3727 dpi->modifiers = &adpm[i];
3729 adpm[i - 1].mod = local_name;
3730 adpm[i - 1].printed = 0;
3731 adpm[i - 1].templates = dpi->templates;
3734 local_name = d_left (local_name);
3738 d_print_comp (dpi, options, d_right (dc));
3740 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3741 dpi->templates = dpt.next;
3743 /* If the modifiers didn't get printed by the type, print them
3748 if (! adpm[i].printed)
3750 d_append_char (dpi, ' ');
3751 d_print_mod (dpi, options, adpm[i].mod);
3755 dpi->modifiers = hold_modifiers;
3760 case DEMANGLE_COMPONENT_TEMPLATE:
3762 struct d_print_mod *hold_dpm;
3763 struct demangle_component *dcl;
3765 /* Don't push modifiers into a template definition. Doing so
3766 could give the wrong definition for a template argument.
3767 Instead, treat the template essentially as a name. */
3769 hold_dpm = dpi->modifiers;
3770 dpi->modifiers = NULL;
3774 if ((options & DMGL_JAVA) != 0
3775 && dcl->type == DEMANGLE_COMPONENT_NAME
3776 && dcl->u.s_name.len == 6
3777 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3779 /* Special-case Java arrays, so that JArray<TYPE> appears
3780 instead as TYPE[]. */
3782 d_print_comp (dpi, options, d_right (dc));
3783 d_append_string (dpi, "[]");
3787 d_print_comp (dpi, options, dcl);
3788 if (d_last_char (dpi) == '<')
3789 d_append_char (dpi, ' ');
3790 d_append_char (dpi, '<');
3791 d_print_comp (dpi, options, d_right (dc));
3792 /* Avoid generating two consecutive '>' characters, to avoid
3793 the C++ syntactic ambiguity. */
3794 if (d_last_char (dpi) == '>')
3795 d_append_char (dpi, ' ');
3796 d_append_char (dpi, '>');
3799 dpi->modifiers = hold_dpm;
3804 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3806 struct d_print_template *hold_dpt;
3807 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3809 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3810 a = d_index_template_argument (a, dpi->pack_index);
3814 d_print_error (dpi);
3818 /* While processing this parameter, we need to pop the list of
3819 templates. This is because the template parameter may
3820 itself be a reference to a parameter of an outer
3823 hold_dpt = dpi->templates;
3824 dpi->templates = hold_dpt->next;
3826 d_print_comp (dpi, options, a);
3828 dpi->templates = hold_dpt;
3833 case DEMANGLE_COMPONENT_CTOR:
3834 d_print_comp (dpi, options, dc->u.s_ctor.name);
3837 case DEMANGLE_COMPONENT_DTOR:
3838 d_append_char (dpi, '~');
3839 d_print_comp (dpi, options, dc->u.s_dtor.name);
3842 case DEMANGLE_COMPONENT_VTABLE:
3843 d_append_string (dpi, "vtable for ");
3844 d_print_comp (dpi, options, d_left (dc));
3847 case DEMANGLE_COMPONENT_VTT:
3848 d_append_string (dpi, "VTT for ");
3849 d_print_comp (dpi, options, d_left (dc));
3852 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3853 d_append_string (dpi, "construction vtable for ");
3854 d_print_comp (dpi, options, d_left (dc));
3855 d_append_string (dpi, "-in-");
3856 d_print_comp (dpi, options, d_right (dc));
3859 case DEMANGLE_COMPONENT_TYPEINFO:
3860 d_append_string (dpi, "typeinfo for ");
3861 d_print_comp (dpi, options, d_left (dc));
3864 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3865 d_append_string (dpi, "typeinfo name for ");
3866 d_print_comp (dpi, options, d_left (dc));
3869 case DEMANGLE_COMPONENT_TYPEINFO_FN:
3870 d_append_string (dpi, "typeinfo fn for ");
3871 d_print_comp (dpi, options, d_left (dc));
3874 case DEMANGLE_COMPONENT_THUNK:
3875 d_append_string (dpi, "non-virtual thunk to ");
3876 d_print_comp (dpi, options, d_left (dc));
3879 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3880 d_append_string (dpi, "virtual thunk to ");
3881 d_print_comp (dpi, options, d_left (dc));
3884 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3885 d_append_string (dpi, "covariant return thunk to ");
3886 d_print_comp (dpi, options, d_left (dc));
3889 case DEMANGLE_COMPONENT_JAVA_CLASS:
3890 d_append_string (dpi, "java Class for ");
3891 d_print_comp (dpi, options, d_left (dc));
3894 case DEMANGLE_COMPONENT_GUARD:
3895 d_append_string (dpi, "guard variable for ");
3896 d_print_comp (dpi, options, d_left (dc));
3899 case DEMANGLE_COMPONENT_REFTEMP:
3900 d_append_string (dpi, "reference temporary for ");
3901 d_print_comp (dpi, options, d_left (dc));
3904 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3905 d_append_string (dpi, "hidden alias for ");
3906 d_print_comp (dpi, options, d_left (dc));
3909 case DEMANGLE_COMPONENT_SUB_STD:
3910 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3913 case DEMANGLE_COMPONENT_RESTRICT:
3914 case DEMANGLE_COMPONENT_VOLATILE:
3915 case DEMANGLE_COMPONENT_CONST:
3917 struct d_print_mod *pdpm;
3919 /* When printing arrays, it's possible to have cases where the
3920 same CV-qualifier gets pushed on the stack multiple times.
3921 We only need to print it once. */
3923 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3925 if (! pdpm->printed)
3927 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3928 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3929 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3931 if (pdpm->mod->type == dc->type)
3933 d_print_comp (dpi, options, d_left (dc));
3941 case DEMANGLE_COMPONENT_REFERENCE:
3942 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3944 /* Handle reference smashing: & + && = &. */
3945 const struct demangle_component *sub = d_left (dc);
3946 if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
3948 struct demangle_component *a = d_lookup_template_argument (dpi, sub);
3949 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3950 a = d_index_template_argument (a, dpi->pack_index);
3954 d_print_error (dpi);
3961 if (sub->type == DEMANGLE_COMPONENT_REFERENCE
3962 || sub->type == dc->type)
3964 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
3965 mod_inner = d_left (sub);
3969 case DEMANGLE_COMPONENT_RESTRICT_THIS:
3970 case DEMANGLE_COMPONENT_VOLATILE_THIS:
3971 case DEMANGLE_COMPONENT_CONST_THIS:
3972 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3973 case DEMANGLE_COMPONENT_POINTER:
3974 case DEMANGLE_COMPONENT_COMPLEX:
3975 case DEMANGLE_COMPONENT_IMAGINARY:
3978 /* We keep a list of modifiers on the stack. */
3979 struct d_print_mod dpm;
3981 dpm.next = dpi->modifiers;
3982 dpi->modifiers = &dpm;
3985 dpm.templates = dpi->templates;
3988 mod_inner = d_left (dc);
3990 d_print_comp (dpi, options, mod_inner);
3992 /* If the modifier didn't get printed by the type, print it
3995 d_print_mod (dpi, options, dc);
3997 dpi->modifiers = dpm.next;
4002 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4003 if ((options & DMGL_JAVA) == 0)
4004 d_append_buffer (dpi, dc->u.s_builtin.type->name,
4005 dc->u.s_builtin.type->len);
4007 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
4008 dc->u.s_builtin.type->java_len);
4011 case DEMANGLE_COMPONENT_VENDOR_TYPE:
4012 d_print_comp (dpi, options, d_left (dc));
4015 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4017 if ((options & DMGL_RET_POSTFIX) != 0)
4018 d_print_function_type (dpi,
4019 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4020 dc, dpi->modifiers);
4022 /* Print return type if present */
4023 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
4024 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4026 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
4028 struct d_print_mod dpm;
4030 /* We must pass this type down as a modifier in order to
4031 print it in the right location. */
4032 dpm.next = dpi->modifiers;
4033 dpi->modifiers = &dpm;
4036 dpm.templates = dpi->templates;
4038 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4041 dpi->modifiers = dpm.next;
4046 /* In standard prefix notation, there is a space between the
4047 return type and the function signature. */
4048 if ((options & DMGL_RET_POSTFIX) == 0)
4049 d_append_char (dpi, ' ');
4052 if ((options & DMGL_RET_POSTFIX) == 0)
4053 d_print_function_type (dpi,
4054 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
4055 dc, dpi->modifiers);
4060 case DEMANGLE_COMPONENT_ARRAY_TYPE:
4062 struct d_print_mod *hold_modifiers;
4063 struct d_print_mod adpm[4];
4065 struct d_print_mod *pdpm;
4067 /* We must pass this type down as a modifier in order to print
4068 multi-dimensional arrays correctly. If the array itself is
4069 CV-qualified, we act as though the element type were
4070 CV-qualified. We do this by copying the modifiers down
4071 rather than fiddling pointers, so that we don't wind up
4072 with a d_print_mod higher on the stack pointing into our
4073 stack frame after we return. */
4075 hold_modifiers = dpi->modifiers;
4077 adpm[0].next = hold_modifiers;
4078 dpi->modifiers = &adpm[0];
4080 adpm[0].printed = 0;
4081 adpm[0].templates = dpi->templates;
4084 pdpm = hold_modifiers;
4086 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
4087 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
4088 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
4090 if (! pdpm->printed)
4092 if (i >= sizeof adpm / sizeof adpm[0])
4094 d_print_error (dpi);
4099 adpm[i].next = dpi->modifiers;
4100 dpi->modifiers = &adpm[i];
4108 d_print_comp (dpi, options, d_right (dc));
4110 dpi->modifiers = hold_modifiers;
4112 if (adpm[0].printed)
4118 d_print_mod (dpi, options, adpm[i].mod);
4121 d_print_array_type (dpi, options, dc, dpi->modifiers);
4126 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4127 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4129 struct d_print_mod dpm;
4131 dpm.next = dpi->modifiers;
4132 dpi->modifiers = &dpm;
4135 dpm.templates = dpi->templates;
4137 d_print_comp (dpi, options, d_right (dc));
4139 /* If the modifier didn't get printed by the type, print it
4142 d_print_mod (dpi, options, dc);
4144 dpi->modifiers = dpm.next;
4149 case DEMANGLE_COMPONENT_FIXED_TYPE:
4150 if (dc->u.s_fixed.sat)
4151 d_append_string (dpi, "_Sat ");
4152 /* Don't print "int _Accum". */
4153 if (dc->u.s_fixed.length->u.s_builtin.type
4154 != &cplus_demangle_builtin_types['i'-'a'])
4156 d_print_comp (dpi, options, dc->u.s_fixed.length);
4157 d_append_char (dpi, ' ');
4159 if (dc->u.s_fixed.accum)
4160 d_append_string (dpi, "_Accum");
4162 d_append_string (dpi, "_Fract");
4165 case DEMANGLE_COMPONENT_ARGLIST:
4166 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4167 if (d_left (dc) != NULL)
4168 d_print_comp (dpi, options, d_left (dc));
4169 if (d_right (dc) != NULL)
4172 unsigned long int flush_count;
4173 /* Make sure ", " isn't flushed by d_append_string, otherwise
4174 dpi->len -= 2 wouldn't work. */
4175 if (dpi->len >= sizeof (dpi->buf) - 2)
4176 d_print_flush (dpi);
4177 d_append_string (dpi, ", ");
4179 flush_count = dpi->flush_count;
4180 d_print_comp (dpi, options, d_right (dc));
4181 /* If that didn't print anything (which can happen with empty
4182 template argument packs), remove the comma and space. */
4183 if (dpi->flush_count == flush_count && dpi->len == len)
4188 case DEMANGLE_COMPONENT_OPERATOR:
4192 d_append_string (dpi, "operator");
4193 c = dc->u.s_operator.op->name[0];
4195 d_append_char (dpi, ' ');
4196 d_append_buffer (dpi, dc->u.s_operator.op->name,
4197 dc->u.s_operator.op->len);
4201 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4202 d_append_string (dpi, "operator ");
4203 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
4206 case DEMANGLE_COMPONENT_CAST:
4207 d_append_string (dpi, "operator ");
4208 d_print_cast (dpi, options, dc);
4211 case DEMANGLE_COMPONENT_UNARY:
4212 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4213 && d_left (dc)->u.s_operator.op->len == 1
4214 && d_left (dc)->u.s_operator.op->name[0] == '&'
4215 && d_right (dc)->type == DEMANGLE_COMPONENT_TYPED_NAME
4216 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_QUAL_NAME
4217 && d_right (d_right (dc))->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4219 /* Address of a function (therefore in an expression context) must
4220 have its argument list suppressed.
4222 unary operator ... dc
4223 operator & ... d_left (dc)
4224 typed name ... d_right (dc)
4225 qualified name ... d_left (d_right (dc))
4227 function type ... d_right (d_right (dc))
4231 d_print_expr_op (dpi, options, d_left (dc));
4232 d_print_comp (dpi, options, d_left (d_right (dc)));
4235 else if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4236 && d_left (dc)->u.s_operator.op->len == 1
4237 && d_left (dc)->u.s_operator.op->name[0] == '&'
4238 && d_right (dc)->type == DEMANGLE_COMPONENT_QUAL_NAME)
4240 /* Keep also already processed variant without the argument list.
4242 unary operator ... dc
4243 operator & ... d_left (dc)
4244 qualified name ... d_right (dc)
4247 d_print_expr_op (dpi, options, d_left (dc));
4248 d_print_comp (dpi, options, d_right (dc));
4251 else if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
4252 d_print_expr_op (dpi, options, d_left (dc));
4255 d_append_char (dpi, '(');
4256 d_print_cast (dpi, options, d_left (dc));
4257 d_append_char (dpi, ')');
4259 d_print_subexpr (dpi, options, d_right (dc));
4262 case DEMANGLE_COMPONENT_BINARY:
4263 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4265 d_print_error (dpi);
4269 /* We wrap an expression which uses the greater-than operator in
4270 an extra layer of parens so that it does not get confused
4271 with the '>' which ends the template parameters. */
4272 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4273 && d_left (dc)->u.s_operator.op->len == 1
4274 && d_left (dc)->u.s_operator.op->name[0] == '>')
4275 d_append_char (dpi, '(');
4277 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
4278 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
4280 /* Function call used in an expression should not have printed types
4281 of the function arguments. Values of the function arguments still
4282 get printed below. */
4284 const struct demangle_component *func = d_left (d_right (dc));
4286 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
4287 d_print_error (dpi);
4288 d_print_subexpr (dpi, options, d_left (func));
4291 d_print_subexpr (dpi, options, d_left (d_right (dc)));
4292 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4294 d_append_char (dpi, '[');
4295 d_print_comp (dpi, options, d_right (d_right (dc)));
4296 d_append_char (dpi, ']');
4300 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4301 d_print_expr_op (dpi, options, d_left (dc));
4302 d_print_subexpr (dpi, options, d_right (d_right (dc)));
4305 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4306 && d_left (dc)->u.s_operator.op->len == 1
4307 && d_left (dc)->u.s_operator.op->name[0] == '>')
4308 d_append_char (dpi, ')');
4312 case DEMANGLE_COMPONENT_BINARY_ARGS:
4313 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
4314 d_print_error (dpi);
4317 case DEMANGLE_COMPONENT_TRINARY:
4318 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4319 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4321 d_print_error (dpi);
4324 d_print_subexpr (dpi, options, d_left (d_right (dc)));
4325 d_print_expr_op (dpi, options, d_left (dc));
4326 d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
4327 d_append_string (dpi, " : ");
4328 d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
4331 case DEMANGLE_COMPONENT_TRINARY_ARG1:
4332 case DEMANGLE_COMPONENT_TRINARY_ARG2:
4333 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
4334 d_print_error (dpi);
4337 case DEMANGLE_COMPONENT_LITERAL:
4338 case DEMANGLE_COMPONENT_LITERAL_NEG:
4340 enum d_builtin_type_print tp;
4342 /* For some builtin types, produce simpler output. */
4343 tp = D_PRINT_DEFAULT;
4344 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4346 tp = d_left (dc)->u.s_builtin.type->print;
4350 case D_PRINT_UNSIGNED:
4352 case D_PRINT_UNSIGNED_LONG:
4353 case D_PRINT_LONG_LONG:
4354 case D_PRINT_UNSIGNED_LONG_LONG:
4355 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4357 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4358 d_append_char (dpi, '-');
4359 d_print_comp (dpi, options, d_right (dc));
4364 case D_PRINT_UNSIGNED:
4365 d_append_char (dpi, 'u');
4368 d_append_char (dpi, 'l');
4370 case D_PRINT_UNSIGNED_LONG:
4371 d_append_string (dpi, "ul");
4373 case D_PRINT_LONG_LONG:
4374 d_append_string (dpi, "ll");
4376 case D_PRINT_UNSIGNED_LONG_LONG:
4377 d_append_string (dpi, "ull");
4385 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4386 && d_right (dc)->u.s_name.len == 1
4387 && dc->type == DEMANGLE_COMPONENT_LITERAL)
4389 switch (d_right (dc)->u.s_name.s[0])
4392 d_append_string (dpi, "false");
4395 d_append_string (dpi, "true");
4408 d_append_char (dpi, '(');
4409 d_print_comp (dpi, options, d_left (dc));
4410 d_append_char (dpi, ')');
4411 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4412 d_append_char (dpi, '-');
4413 if (tp == D_PRINT_FLOAT)
4414 d_append_char (dpi, '[');
4415 d_print_comp (dpi, options, d_right (dc));
4416 if (tp == D_PRINT_FLOAT)
4417 d_append_char (dpi, ']');
4421 case DEMANGLE_COMPONENT_NUMBER:
4422 d_append_num (dpi, dc->u.s_number.number);
4425 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4426 d_append_string (dpi, "java resource ");
4427 d_print_comp (dpi, options, d_left (dc));
4430 case DEMANGLE_COMPONENT_COMPOUND_NAME:
4431 d_print_comp (dpi, options, d_left (dc));
4432 d_print_comp (dpi, options, d_right (dc));
4435 case DEMANGLE_COMPONENT_CHARACTER:
4436 d_append_char (dpi, dc->u.s_character.character);
4439 case DEMANGLE_COMPONENT_DECLTYPE:
4440 d_append_string (dpi, "decltype (");
4441 d_print_comp (dpi, options, d_left (dc));
4442 d_append_char (dpi, ')');
4445 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4449 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4452 /* d_find_pack won't find anything if the only packs involved
4453 in this expansion are function parameter packs; in that
4454 case, just print the pattern and "...". */
4455 d_print_subexpr (dpi, options, d_left (dc));
4456 d_append_string (dpi, "...");
4460 len = d_pack_length (a);
4462 for (i = 0; i < len; ++i)
4464 dpi->pack_index = i;
4465 d_print_comp (dpi, options, dc);
4467 d_append_string (dpi, ", ");
4472 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4474 long num = dc->u.s_number.number;
4476 d_append_string (dpi, "this");
4479 d_append_string (dpi, "{parm#");
4480 d_append_num (dpi, num);
4481 d_append_char (dpi, '}');
4486 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4487 d_append_string (dpi, "global constructors keyed to ");
4488 d_print_comp (dpi, options, dc->u.s_binary.left);
4491 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4492 d_append_string (dpi, "global destructors keyed to ");
4493 d_print_comp (dpi, options, dc->u.s_binary.left);
4496 case DEMANGLE_COMPONENT_LAMBDA:
4497 d_append_string (dpi, "{lambda(");
4498 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
4499 d_append_string (dpi, ")#");
4500 d_append_num (dpi, dc->u.s_unary_num.num + 1);
4501 d_append_char (dpi, '}');
4504 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4505 d_append_string (dpi, "{unnamed type#");
4506 d_append_num (dpi, dc->u.s_number.number + 1);
4507 d_append_char (dpi, '}');
4510 case DEMANGLE_COMPONENT_CLONE:
4511 d_print_comp (dpi, options, d_left (dc));
4512 d_append_string (dpi, " [clone ");
4513 d_print_comp (dpi, options, d_right (dc));
4514 d_append_char (dpi, ']');
4518 d_print_error (dpi);
4523 /* Print a Java dentifier. For Java we try to handle encoded extended
4524 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4525 so we don't it for C++. Characters are encoded as
4529 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4535 for (p = name; p < end; ++p)
4546 for (q = p + 3; q < end; ++q)
4552 else if (*q >= 'A' && *q <= 'F')
4553 dig = *q - 'A' + 10;
4554 else if (*q >= 'a' && *q <= 'f')
4555 dig = *q - 'a' + 10;
4561 /* If the Unicode character is larger than 256, we don't try
4562 to deal with it here. FIXME. */
4563 if (q < end && *q == '_' && c < 256)
4565 d_append_char (dpi, c);
4571 d_append_char (dpi, *p);
4575 /* Print a list of modifiers. SUFFIX is 1 if we are printing
4576 qualifiers on this after printing a function. */
4579 d_print_mod_list (struct d_print_info *dpi, int options,
4580 struct d_print_mod *mods, int suffix)
4582 struct d_print_template *hold_dpt;
4584 if (mods == NULL || d_print_saw_error (dpi))
4589 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4590 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4591 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4593 d_print_mod_list (dpi, options, mods->next, suffix);
4599 hold_dpt = dpi->templates;
4600 dpi->templates = mods->templates;
4602 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4604 d_print_function_type (dpi, options, mods->mod, mods->next);
4605 dpi->templates = hold_dpt;
4608 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4610 d_print_array_type (dpi, options, mods->mod, mods->next);
4611 dpi->templates = hold_dpt;
4614 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4616 struct d_print_mod *hold_modifiers;
4617 struct demangle_component *dc;
4619 /* When this is on the modifier stack, we have pulled any
4620 qualifiers off the right argument already. Otherwise, we
4621 print it as usual, but don't let the left argument see any
4624 hold_modifiers = dpi->modifiers;
4625 dpi->modifiers = NULL;
4626 d_print_comp (dpi, options, d_left (mods->mod));
4627 dpi->modifiers = hold_modifiers;
4629 if ((options & DMGL_JAVA) == 0)
4630 d_append_string (dpi, "::");
4632 d_append_char (dpi, '.');
4634 dc = d_right (mods->mod);
4636 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4638 d_append_string (dpi, "{default arg#");
4639 d_append_num (dpi, dc->u.s_unary_num.num + 1);
4640 d_append_string (dpi, "}::");
4641 dc = dc->u.s_unary_num.sub;
4644 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4645 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4646 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4649 d_print_comp (dpi, options, dc);
4651 dpi->templates = hold_dpt;
4655 d_print_mod (dpi, options, mods->mod);
4657 dpi->templates = hold_dpt;
4659 d_print_mod_list (dpi, options, mods->next, suffix);
4662 /* Print a modifier. */
4665 d_print_mod (struct d_print_info *dpi, int options,
4666 const struct demangle_component *mod)
4670 case DEMANGLE_COMPONENT_RESTRICT:
4671 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4672 d_append_string (dpi, " restrict");
4674 case DEMANGLE_COMPONENT_VOLATILE:
4675 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4676 d_append_string (dpi, " volatile");
4678 case DEMANGLE_COMPONENT_CONST:
4679 case DEMANGLE_COMPONENT_CONST_THIS:
4680 d_append_string (dpi, " const");
4682 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4683 d_append_char (dpi, ' ');
4684 d_print_comp (dpi, options, d_right (mod));
4686 case DEMANGLE_COMPONENT_POINTER:
4687 /* There is no pointer symbol in Java. */
4688 if ((options & DMGL_JAVA) == 0)
4689 d_append_char (dpi, '*');
4691 case DEMANGLE_COMPONENT_REFERENCE:
4692 d_append_char (dpi, '&');
4694 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4695 d_append_string (dpi, "&&");
4697 case DEMANGLE_COMPONENT_COMPLEX:
4698 d_append_string (dpi, "complex ");
4700 case DEMANGLE_COMPONENT_IMAGINARY:
4701 d_append_string (dpi, "imaginary ");
4703 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4704 if (d_last_char (dpi) != '(')
4705 d_append_char (dpi, ' ');
4706 d_print_comp (dpi, options, d_left (mod));
4707 d_append_string (dpi, "::*");
4709 case DEMANGLE_COMPONENT_TYPED_NAME:
4710 d_print_comp (dpi, options, d_left (mod));
4712 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4713 d_append_string (dpi, " __vector(");
4714 d_print_comp (dpi, options, d_left (mod));
4715 d_append_char (dpi, ')');
4719 /* Otherwise, we have something that won't go back on the
4720 modifier stack, so we can just print it. */
4721 d_print_comp (dpi, options, mod);
4726 /* Print a function type, except for the return type. */
4729 d_print_function_type (struct d_print_info *dpi, int options,
4730 const struct demangle_component *dc,
4731 struct d_print_mod *mods)
4735 struct d_print_mod *p;
4736 struct d_print_mod *hold_modifiers;
4740 for (p = mods; p != NULL; p = p->next)
4745 switch (p->mod->type)
4747 case DEMANGLE_COMPONENT_POINTER:
4748 case DEMANGLE_COMPONENT_REFERENCE:
4749 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4752 case DEMANGLE_COMPONENT_RESTRICT:
4753 case DEMANGLE_COMPONENT_VOLATILE:
4754 case DEMANGLE_COMPONENT_CONST:
4755 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4756 case DEMANGLE_COMPONENT_COMPLEX:
4757 case DEMANGLE_COMPONENT_IMAGINARY:
4758 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4762 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4763 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4764 case DEMANGLE_COMPONENT_CONST_THIS:
4777 if (d_last_char (dpi) != '('
4778 && d_last_char (dpi) != '*')
4781 if (need_space && d_last_char (dpi) != ' ')
4782 d_append_char (dpi, ' ');
4783 d_append_char (dpi, '(');
4786 hold_modifiers = dpi->modifiers;
4787 dpi->modifiers = NULL;
4789 d_print_mod_list (dpi, options, mods, 0);
4792 d_append_char (dpi, ')');
4794 d_append_char (dpi, '(');
4796 if (d_right (dc) != NULL)
4797 d_print_comp (dpi, options, d_right (dc));
4799 d_append_char (dpi, ')');
4801 d_print_mod_list (dpi, options, mods, 1);
4803 dpi->modifiers = hold_modifiers;
4806 /* Print an array type, except for the element type. */
4809 d_print_array_type (struct d_print_info *dpi, int options,
4810 const struct demangle_component *dc,
4811 struct d_print_mod *mods)
4819 struct d_print_mod *p;
4822 for (p = mods; p != NULL; p = p->next)
4826 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4841 d_append_string (dpi, " (");
4843 d_print_mod_list (dpi, options, mods, 0);
4846 d_append_char (dpi, ')');
4850 d_append_char (dpi, ' ');
4852 d_append_char (dpi, '[');
4854 if (d_left (dc) != NULL)
4855 d_print_comp (dpi, options, d_left (dc));
4857 d_append_char (dpi, ']');
4860 /* Print an operator in an expression. */
4863 d_print_expr_op (struct d_print_info *dpi, int options,
4864 const struct demangle_component *dc)
4866 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4867 d_append_buffer (dpi, dc->u.s_operator.op->name,
4868 dc->u.s_operator.op->len);
4870 d_print_comp (dpi, options, dc);
4876 d_print_cast (struct d_print_info *dpi, int options,
4877 const struct demangle_component *dc)
4879 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4880 d_print_comp (dpi, options, d_left (dc));
4883 struct d_print_mod *hold_dpm;
4884 struct d_print_template dpt;
4886 /* It appears that for a templated cast operator, we need to put
4887 the template parameters in scope for the operator name, but
4888 not for the parameters. The effect is that we need to handle
4889 the template printing here. */
4891 hold_dpm = dpi->modifiers;
4892 dpi->modifiers = NULL;
4894 dpt.next = dpi->templates;
4895 dpi->templates = &dpt;
4896 dpt.template_decl = d_left (dc);
4898 d_print_comp (dpi, options, d_left (d_left (dc)));
4900 dpi->templates = dpt.next;
4902 if (d_last_char (dpi) == '<')
4903 d_append_char (dpi, ' ');
4904 d_append_char (dpi, '<');
4905 d_print_comp (dpi, options, d_right (d_left (dc)));
4906 /* Avoid generating two consecutive '>' characters, to avoid
4907 the C++ syntactic ambiguity. */
4908 if (d_last_char (dpi) == '>')
4909 d_append_char (dpi, ' ');
4910 d_append_char (dpi, '>');
4912 dpi->modifiers = hold_dpm;
4916 /* Initialize the information structure we use to pass around
4919 CP_STATIC_IF_GLIBCPP_V3
4921 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4925 di->send = mangled + len;
4926 di->options = options;
4930 /* We can not need more components than twice the number of chars in
4931 the mangled string. Most components correspond directly to
4932 chars, but the ARGLIST types are exceptions. */
4933 di->num_comps = 2 * len;
4936 /* Similarly, we can not need more substitutions than there are
4937 chars in the mangled string. */
4942 di->last_name = NULL;
4947 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
4948 mangled name, return strings in repeated callback giving the demangled
4949 name. OPTIONS is the usual libiberty demangler options. On success,
4950 this returns 1. On failure, returns 0. */
4953 d_demangle_callback (const char *mangled, int options,
4954 demangle_callbackref callback, void *opaque)
4965 struct demangle_component *dc;
4968 if (mangled[0] == '_' && mangled[1] == 'Z')
4970 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4971 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4972 && (mangled[9] == 'D' || mangled[9] == 'I')
4973 && mangled[10] == '_')
4974 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4977 if ((options & DMGL_TYPES) == 0)
4982 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4985 #ifdef CP_DYNAMIC_ARRAYS
4986 __extension__ struct demangle_component comps[di.num_comps];
4987 __extension__ struct demangle_component *subs[di.num_subs];
4992 di.comps = alloca (di.num_comps * sizeof (*di.comps));
4993 di.subs = alloca (di.num_subs * sizeof (*di.subs));
4999 dc = cplus_demangle_type (&di);
5002 dc = cplus_demangle_mangled_name (&di, 1);
5004 case DCT_GLOBAL_CTORS:
5005 case DCT_GLOBAL_DTORS:
5006 d_advance (&di, 11);
5007 dc = d_make_comp (&di,
5008 (type == DCT_GLOBAL_CTORS
5009 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5010 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
5011 d_make_demangle_mangled_name (&di, d_str (&di)),
5013 d_advance (&di, strlen (d_str (&di)));
5017 /* If DMGL_PARAMS is set, then if we didn't consume the entire
5018 mangled string, then we didn't successfully demangle it. If
5019 DMGL_PARAMS is not set, we didn't look at the trailing
5021 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
5024 #ifdef CP_DEMANGLE_DEBUG
5028 status = (dc != NULL)
5029 ? cplus_demangle_print_callback (options, dc, callback, opaque)
5036 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
5037 name, return a buffer allocated with malloc holding the demangled
5038 name. OPTIONS is the usual libiberty demangler options. On
5039 success, this sets *PALC to the allocated size of the returned
5040 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
5041 a memory allocation failure, and returns NULL. */
5044 d_demangle (const char *mangled, int options, size_t *palc)
5046 struct d_growable_string dgs;
5049 d_growable_string_init (&dgs, 0);
5051 status = d_demangle_callback (mangled, options,
5052 d_growable_string_callback_adapter, &dgs);
5060 *palc = dgs.allocation_failure ? 1 : dgs.alc;
5064 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5066 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5068 /* ia64 ABI-mandated entry point in the C++ runtime library for
5069 performing demangling. MANGLED_NAME is a NUL-terminated character
5070 string containing the name to be demangled.
5072 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5073 *LENGTH bytes, into which the demangled name is stored. If
5074 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5075 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5076 is placed in a region of memory allocated with malloc.
5078 If LENGTH is non-NULL, the length of the buffer containing the
5079 demangled name, is placed in *LENGTH.
5081 The return value is a pointer to the start of the NUL-terminated
5082 demangled name, or NULL if the demangling fails. The caller is
5083 responsible for deallocating this memory using free.
5085 *STATUS is set to one of the following values:
5086 0: The demangling operation succeeded.
5087 -1: A memory allocation failure occurred.
5088 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5089 -3: One of the arguments is invalid.
5091 The demangling is performed using the C++ ABI mangling rules, with
5095 __cxa_demangle (const char *mangled_name, char *output_buffer,
5096 size_t *length, int *status)
5101 if (mangled_name == NULL)
5108 if (output_buffer != NULL && length == NULL)
5115 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
5117 if (demangled == NULL)
5129 if (output_buffer == NULL)
5136 if (strlen (demangled) < *length)
5138 strcpy (output_buffer, demangled);
5140 demangled = output_buffer;
5144 free (output_buffer);
5155 extern int __gcclibcxx_demangle_callback (const char *,
5157 (const char *, size_t, void *),
5160 /* Alternative, allocationless entry point in the C++ runtime library
5161 for performing demangling. MANGLED_NAME is a NUL-terminated character
5162 string containing the name to be demangled.
5164 CALLBACK is a callback function, called with demangled string
5165 segments as demangling progresses; it is called at least once,
5166 but may be called more than once. OPAQUE is a generalized pointer
5167 used as a callback argument.
5169 The return code is one of the following values, equivalent to
5170 the STATUS values of __cxa_demangle() (excluding -1, since this
5171 function performs no memory allocations):
5172 0: The demangling operation succeeded.
5173 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5174 -3: One of the arguments is invalid.
5176 The demangling is performed using the C++ ABI mangling rules, with
5180 __gcclibcxx_demangle_callback (const char *mangled_name,
5181 void (*callback) (const char *, size_t, void *),
5186 if (mangled_name == NULL || callback == NULL)
5189 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5197 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5199 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
5200 mangled name, return a buffer allocated with malloc holding the
5201 demangled name. Otherwise, return NULL. */
5204 cplus_demangle_v3 (const char *mangled, int options)
5208 return d_demangle (mangled, options, &alc);
5212 cplus_demangle_v3_callback (const char *mangled, int options,
5213 demangle_callbackref callback, void *opaque)
5215 return d_demangle_callback (mangled, options, callback, opaque);
5218 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
5219 conventions, but the output formatting is a little different.
5220 This instructs the C++ demangler not to emit pointer characters ("*"), to
5221 use Java's namespace separator symbol ("." instead of "::"), and to output
5222 JArray<TYPE> as TYPE[]. */
5225 java_demangle_v3 (const char *mangled)
5229 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5233 java_demangle_v3_callback (const char *mangled,
5234 demangle_callbackref callback, void *opaque)
5236 return d_demangle_callback (mangled,
5237 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5241 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5243 #ifndef IN_GLIBCPP_V3
5245 /* Demangle a string in order to find out whether it is a constructor
5246 or destructor. Return non-zero on success. Set *CTOR_KIND and
5247 *DTOR_KIND appropriately. */
5250 is_ctor_or_dtor (const char *mangled,
5251 enum gnu_v3_ctor_kinds *ctor_kind,
5252 enum gnu_v3_dtor_kinds *dtor_kind)
5255 struct demangle_component *dc;
5258 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5259 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5261 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5264 #ifdef CP_DYNAMIC_ARRAYS
5265 __extension__ struct demangle_component comps[di.num_comps];
5266 __extension__ struct demangle_component *subs[di.num_subs];
5271 di.comps = alloca (di.num_comps * sizeof (*di.comps));
5272 di.subs = alloca (di.num_subs * sizeof (*di.subs));
5275 dc = cplus_demangle_mangled_name (&di, 1);
5277 /* Note that because we did not pass DMGL_PARAMS, we don't expect
5278 to demangle the entire string. */
5288 case DEMANGLE_COMPONENT_TYPED_NAME:
5289 case DEMANGLE_COMPONENT_TEMPLATE:
5290 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5291 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5292 case DEMANGLE_COMPONENT_CONST_THIS:
5295 case DEMANGLE_COMPONENT_QUAL_NAME:
5296 case DEMANGLE_COMPONENT_LOCAL_NAME:
5299 case DEMANGLE_COMPONENT_CTOR:
5300 *ctor_kind = dc->u.s_ctor.kind;
5304 case DEMANGLE_COMPONENT_DTOR:
5305 *dtor_kind = dc->u.s_dtor.kind;
5316 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5317 name. A non-zero return indicates the type of constructor. */
5319 enum gnu_v3_ctor_kinds
5320 is_gnu_v3_mangled_ctor (const char *name)
5322 enum gnu_v3_ctor_kinds ctor_kind;
5323 enum gnu_v3_dtor_kinds dtor_kind;
5325 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5326 return (enum gnu_v3_ctor_kinds) 0;
5331 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5332 name. A non-zero return indicates the type of destructor. */
5334 enum gnu_v3_dtor_kinds
5335 is_gnu_v3_mangled_dtor (const char *name)
5337 enum gnu_v3_ctor_kinds ctor_kind;
5338 enum gnu_v3_dtor_kinds dtor_kind;
5340 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5341 return (enum gnu_v3_dtor_kinds) 0;
5345 #endif /* IN_GLIBCPP_V3 */
5347 #ifdef STANDALONE_DEMANGLER
5350 #include "dyn-string.h"
5352 static void print_usage (FILE* fp, int exit_value);
5354 #define IS_ALPHA(CHAR) \
5355 (((CHAR) >= 'a' && (CHAR) <= 'z') \
5356 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5358 /* Non-zero if CHAR is a character than can occur in a mangled name. */
5359 #define is_mangled_char(CHAR) \
5360 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
5361 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5363 /* The name of this program, as invoked. */
5364 const char* program_name;
5366 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
5369 print_usage (FILE* fp, int exit_value)
5371 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5372 fprintf (fp, "Options:\n");
5373 fprintf (fp, " -h,--help Display this message.\n");
5374 fprintf (fp, " -p,--no-params Don't display function parameters\n");
5375 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
5376 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
5381 /* Option specification for getopt_long. */
5382 static const struct option long_options[] =
5384 { "help", no_argument, NULL, 'h' },
5385 { "no-params", no_argument, NULL, 'p' },
5386 { "verbose", no_argument, NULL, 'v' },
5387 { NULL, no_argument, NULL, 0 },
5390 /* Main entry for a demangling filter executable. It will demangle
5391 its command line arguments, if any. If none are provided, it will
5392 filter stdin to stdout, replacing any recognized mangled C++ names
5393 with their demangled equivalents. */
5396 main (int argc, char *argv[])
5400 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5402 /* Use the program name of this program, as invoked. */
5403 program_name = argv[0];
5405 /* Parse options. */
5408 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5411 case '?': /* Unrecognized option. */
5412 print_usage (stderr, 1);
5416 print_usage (stdout, 0);
5420 options &= ~ DMGL_PARAMS;
5424 options |= DMGL_VERBOSE;
5428 while (opt_char != -1);
5431 /* No command line arguments were provided. Filter stdin. */
5433 dyn_string_t mangled = dyn_string_new (3);
5436 /* Read all of input. */
5437 while (!feof (stdin))
5441 /* Pile characters into mangled until we hit one that can't
5442 occur in a mangled name. */
5444 while (!feof (stdin) && is_mangled_char (c))
5446 dyn_string_append_char (mangled, c);
5452 if (dyn_string_length (mangled) > 0)
5454 #ifdef IN_GLIBCPP_V3
5455 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5457 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5467 /* It might not have been a mangled name. Print the
5469 fputs (dyn_string_buf (mangled), stdout);
5472 dyn_string_clear (mangled);
5475 /* If we haven't hit EOF yet, we've read one character that
5476 can't occur in a mangled name, so print it out. */
5481 dyn_string_delete (mangled);
5484 /* Demangle command line arguments. */
5486 /* Loop over command line arguments. */
5487 for (i = optind; i < argc; ++i)
5490 #ifdef IN_GLIBCPP_V3
5494 /* Attempt to demangle. */
5495 #ifdef IN_GLIBCPP_V3
5496 s = __cxa_demangle (argv[i], NULL, NULL, &status);
5498 s = cplus_demangle_v3 (argv[i], options);
5501 /* If it worked, print the demangled name. */
5509 #ifdef IN_GLIBCPP_V3
5510 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5512 fprintf (stderr, "Failed: %s\n", argv[i]);
5521 #endif /* STANDALONE_DEMANGLER */