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_TRANSACTION_CLONE
:
589 printf ("transaction clone\n");
591 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
592 printf ("non-transaction clone\n");
594 case DEMANGLE_COMPONENT_RESTRICT
:
595 printf ("restrict\n");
597 case DEMANGLE_COMPONENT_VOLATILE
:
598 printf ("volatile\n");
600 case DEMANGLE_COMPONENT_CONST
:
603 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
604 printf ("restrict this\n");
606 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
607 printf ("volatile this\n");
609 case DEMANGLE_COMPONENT_CONST_THIS
:
610 printf ("const this\n");
612 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
613 printf ("vendor type qualifier\n");
615 case DEMANGLE_COMPONENT_POINTER
:
616 printf ("pointer\n");
618 case DEMANGLE_COMPONENT_REFERENCE
:
619 printf ("reference\n");
621 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
622 printf ("rvalue reference\n");
624 case DEMANGLE_COMPONENT_COMPLEX
:
625 printf ("complex\n");
627 case DEMANGLE_COMPONENT_IMAGINARY
:
628 printf ("imaginary\n");
630 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
631 printf ("vendor type\n");
633 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
634 printf ("function type\n");
636 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
637 printf ("array type\n");
639 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
640 printf ("pointer to member type\n");
642 case DEMANGLE_COMPONENT_FIXED_TYPE
:
643 printf ("fixed-point type\n");
645 case DEMANGLE_COMPONENT_ARGLIST
:
646 printf ("argument list\n");
648 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
649 printf ("template argument list\n");
651 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
652 printf ("initializer list\n");
654 case DEMANGLE_COMPONENT_CAST
:
657 case DEMANGLE_COMPONENT_NULLARY
:
658 printf ("nullary operator\n");
660 case DEMANGLE_COMPONENT_UNARY
:
661 printf ("unary operator\n");
663 case DEMANGLE_COMPONENT_BINARY
:
664 printf ("binary operator\n");
666 case DEMANGLE_COMPONENT_BINARY_ARGS
:
667 printf ("binary operator arguments\n");
669 case DEMANGLE_COMPONENT_TRINARY
:
670 printf ("trinary operator\n");
672 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
673 printf ("trinary operator arguments 1\n");
675 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
676 printf ("trinary operator arguments 1\n");
678 case DEMANGLE_COMPONENT_LITERAL
:
679 printf ("literal\n");
681 case DEMANGLE_COMPONENT_LITERAL_NEG
:
682 printf ("negative literal\n");
684 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
685 printf ("java resource\n");
687 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
688 printf ("compound name\n");
690 case DEMANGLE_COMPONENT_CHARACTER
:
691 printf ("character '%c'\n", dc
->u
.s_character
.character
);
693 case DEMANGLE_COMPONENT_DECLTYPE
:
694 printf ("decltype\n");
696 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
697 printf ("pack expansion\n");
701 d_dump (d_left (dc
), indent
+ 2);
702 d_dump (d_right (dc
), indent
+ 2);
705 #endif /* CP_DEMANGLE_DEBUG */
707 /* Fill in a DEMANGLE_COMPONENT_NAME. */
709 CP_STATIC_IF_GLIBCPP_V3
711 cplus_demangle_fill_name (struct demangle_component
*p
, const char *s
, int len
)
713 if (p
== NULL
|| s
== NULL
|| len
== 0)
715 p
->type
= DEMANGLE_COMPONENT_NAME
;
717 p
->u
.s_name
.len
= len
;
721 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
723 CP_STATIC_IF_GLIBCPP_V3
725 cplus_demangle_fill_extended_operator (struct demangle_component
*p
, int args
,
726 struct demangle_component
*name
)
728 if (p
== NULL
|| args
< 0 || name
== NULL
)
730 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
731 p
->u
.s_extended_operator
.args
= args
;
732 p
->u
.s_extended_operator
.name
= name
;
736 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
738 CP_STATIC_IF_GLIBCPP_V3
740 cplus_demangle_fill_ctor (struct demangle_component
*p
,
741 enum gnu_v3_ctor_kinds kind
,
742 struct demangle_component
*name
)
746 || (int) kind
< gnu_v3_complete_object_ctor
747 || (int) kind
> gnu_v3_object_ctor_group
)
749 p
->type
= DEMANGLE_COMPONENT_CTOR
;
750 p
->u
.s_ctor
.kind
= kind
;
751 p
->u
.s_ctor
.name
= name
;
755 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
757 CP_STATIC_IF_GLIBCPP_V3
759 cplus_demangle_fill_dtor (struct demangle_component
*p
,
760 enum gnu_v3_dtor_kinds kind
,
761 struct demangle_component
*name
)
765 || (int) kind
< gnu_v3_deleting_dtor
766 || (int) kind
> gnu_v3_object_dtor_group
)
768 p
->type
= DEMANGLE_COMPONENT_DTOR
;
769 p
->u
.s_dtor
.kind
= kind
;
770 p
->u
.s_dtor
.name
= name
;
774 /* Add a new component. */
776 static struct demangle_component
*
777 d_make_empty (struct d_info
*di
)
779 struct demangle_component
*p
;
781 if (di
->next_comp
>= di
->num_comps
)
783 p
= &di
->comps
[di
->next_comp
];
788 /* Add a new generic component. */
790 static struct demangle_component
*
791 d_make_comp (struct d_info
*di
, enum demangle_component_type type
,
792 struct demangle_component
*left
,
793 struct demangle_component
*right
)
795 struct demangle_component
*p
;
797 /* We check for errors here. A typical error would be a NULL return
798 from a subroutine. We catch those here, and return NULL
802 /* These types require two parameters. */
803 case DEMANGLE_COMPONENT_QUAL_NAME
:
804 case DEMANGLE_COMPONENT_LOCAL_NAME
:
805 case DEMANGLE_COMPONENT_TYPED_NAME
:
806 case DEMANGLE_COMPONENT_TEMPLATE
:
807 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
808 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
809 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
810 case DEMANGLE_COMPONENT_UNARY
:
811 case DEMANGLE_COMPONENT_BINARY
:
812 case DEMANGLE_COMPONENT_BINARY_ARGS
:
813 case DEMANGLE_COMPONENT_TRINARY
:
814 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
815 case DEMANGLE_COMPONENT_LITERAL
:
816 case DEMANGLE_COMPONENT_LITERAL_NEG
:
817 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
818 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
819 case DEMANGLE_COMPONENT_CLONE
:
820 if (left
== NULL
|| right
== NULL
)
824 /* These types only require one parameter. */
825 case DEMANGLE_COMPONENT_VTABLE
:
826 case DEMANGLE_COMPONENT_VTT
:
827 case DEMANGLE_COMPONENT_TYPEINFO
:
828 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
829 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
830 case DEMANGLE_COMPONENT_THUNK
:
831 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
832 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
833 case DEMANGLE_COMPONENT_JAVA_CLASS
:
834 case DEMANGLE_COMPONENT_GUARD
:
835 case DEMANGLE_COMPONENT_REFTEMP
:
836 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
837 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
838 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
839 case DEMANGLE_COMPONENT_POINTER
:
840 case DEMANGLE_COMPONENT_REFERENCE
:
841 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
842 case DEMANGLE_COMPONENT_COMPLEX
:
843 case DEMANGLE_COMPONENT_IMAGINARY
:
844 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
845 case DEMANGLE_COMPONENT_CAST
:
846 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
847 case DEMANGLE_COMPONENT_DECLTYPE
:
848 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
849 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
850 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
851 case DEMANGLE_COMPONENT_NULLARY
:
852 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
857 /* This needs a right parameter, but the left parameter can be
859 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
860 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
865 /* These are allowed to have no parameters--in some cases they
866 will be filled in later. */
867 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
868 case DEMANGLE_COMPONENT_RESTRICT
:
869 case DEMANGLE_COMPONENT_VOLATILE
:
870 case DEMANGLE_COMPONENT_CONST
:
871 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
872 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
873 case DEMANGLE_COMPONENT_CONST_THIS
:
874 case DEMANGLE_COMPONENT_ARGLIST
:
875 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
878 /* Other types should not be seen here. */
883 p
= d_make_empty (di
);
887 p
->u
.s_binary
.left
= left
;
888 p
->u
.s_binary
.right
= right
;
893 /* Add a new demangle mangled name component. */
895 static struct demangle_component
*
896 d_make_demangle_mangled_name (struct d_info
*di
, const char *s
)
898 if (d_peek_char (di
) != '_' || d_peek_next_char (di
) != 'Z')
899 return d_make_name (di
, s
, strlen (s
));
901 return d_encoding (di
, 0);
904 /* Add a new name component. */
906 static struct demangle_component
*
907 d_make_name (struct d_info
*di
, const char *s
, int len
)
909 struct demangle_component
*p
;
911 p
= d_make_empty (di
);
912 if (! cplus_demangle_fill_name (p
, s
, len
))
917 /* Add a new builtin type component. */
919 static struct demangle_component
*
920 d_make_builtin_type (struct d_info
*di
,
921 const struct demangle_builtin_type_info
*type
)
923 struct demangle_component
*p
;
927 p
= d_make_empty (di
);
930 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
931 p
->u
.s_builtin
.type
= type
;
936 /* Add a new operator component. */
938 static struct demangle_component
*
939 d_make_operator (struct d_info
*di
, const struct demangle_operator_info
*op
)
941 struct demangle_component
*p
;
943 p
= d_make_empty (di
);
946 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
947 p
->u
.s_operator
.op
= op
;
952 /* Add a new extended operator component. */
954 static struct demangle_component
*
955 d_make_extended_operator (struct d_info
*di
, int args
,
956 struct demangle_component
*name
)
958 struct demangle_component
*p
;
960 p
= d_make_empty (di
);
961 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
966 static struct demangle_component
*
967 d_make_default_arg (struct d_info
*di
, int num
,
968 struct demangle_component
*sub
)
970 struct demangle_component
*p
= d_make_empty (di
);
973 p
->type
= DEMANGLE_COMPONENT_DEFAULT_ARG
;
974 p
->u
.s_unary_num
.num
= num
;
975 p
->u
.s_unary_num
.sub
= sub
;
980 /* Add a new constructor component. */
982 static struct demangle_component
*
983 d_make_ctor (struct d_info
*di
, enum gnu_v3_ctor_kinds kind
,
984 struct demangle_component
*name
)
986 struct demangle_component
*p
;
988 p
= d_make_empty (di
);
989 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
994 /* Add a new destructor component. */
996 static struct demangle_component
*
997 d_make_dtor (struct d_info
*di
, enum gnu_v3_dtor_kinds kind
,
998 struct demangle_component
*name
)
1000 struct demangle_component
*p
;
1002 p
= d_make_empty (di
);
1003 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
1008 /* Add a new template parameter. */
1010 static struct demangle_component
*
1011 d_make_template_param (struct d_info
*di
, long i
)
1013 struct demangle_component
*p
;
1015 p
= d_make_empty (di
);
1018 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
1019 p
->u
.s_number
.number
= i
;
1024 /* Add a new function parameter. */
1026 static struct demangle_component
*
1027 d_make_function_param (struct d_info
*di
, long i
)
1029 struct demangle_component
*p
;
1031 p
= d_make_empty (di
);
1034 p
->type
= DEMANGLE_COMPONENT_FUNCTION_PARAM
;
1035 p
->u
.s_number
.number
= i
;
1040 /* Add a new standard substitution component. */
1042 static struct demangle_component
*
1043 d_make_sub (struct d_info
*di
, const char *name
, int len
)
1045 struct demangle_component
*p
;
1047 p
= d_make_empty (di
);
1050 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
1051 p
->u
.s_string
.string
= name
;
1052 p
->u
.s_string
.len
= len
;
1057 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1059 TOP_LEVEL is non-zero when called at the top level. */
1061 CP_STATIC_IF_GLIBCPP_V3
1062 struct demangle_component
*
1063 cplus_demangle_mangled_name (struct d_info
*di
, int top_level
)
1065 struct demangle_component
*p
;
1067 if (! d_check_char (di
, '_')
1068 /* Allow missing _ if not at toplevel to work around a
1069 bug in G++ abi-version=2 mangling; see the comment in
1070 write_template_arg. */
1073 if (! d_check_char (di
, 'Z'))
1075 p
= d_encoding (di
, top_level
);
1077 /* If at top level and parsing parameters, check for a clone
1079 if (top_level
&& (di
->options
& DMGL_PARAMS
) != 0)
1080 while (d_peek_char (di
) == '.'
1081 && (IS_LOWER (d_peek_next_char (di
))
1082 || d_peek_next_char (di
) == '_'
1083 || IS_DIGIT (d_peek_next_char (di
))))
1084 p
= d_clone_suffix (di
, p
);
1089 /* Return whether a function should have a return type. The argument
1090 is the function name, which may be qualified in various ways. The
1091 rules are that template functions have return types with some
1092 exceptions, function types which are not part of a function name
1093 mangling have return types with some exceptions, and non-template
1094 function names do not have return types. The exceptions are that
1095 constructors, destructors, and conversion operators do not have
1099 has_return_type (struct demangle_component
*dc
)
1107 case DEMANGLE_COMPONENT_TEMPLATE
:
1108 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1109 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
1110 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
1111 case DEMANGLE_COMPONENT_CONST_THIS
:
1112 return has_return_type (d_left (dc
));
1116 /* Return whether a name is a constructor, a destructor, or a
1117 conversion operator. */
1120 is_ctor_dtor_or_conversion (struct demangle_component
*dc
)
1128 case DEMANGLE_COMPONENT_QUAL_NAME
:
1129 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1130 return is_ctor_dtor_or_conversion (d_right (dc
));
1131 case DEMANGLE_COMPONENT_CTOR
:
1132 case DEMANGLE_COMPONENT_DTOR
:
1133 case DEMANGLE_COMPONENT_CAST
:
1138 /* <encoding> ::= <(function) name> <bare-function-type>
1142 TOP_LEVEL is non-zero when called at the top level, in which case
1143 if DMGL_PARAMS is not set we do not demangle the function
1144 parameters. We only set this at the top level, because otherwise
1145 we would not correctly demangle names in local scopes. */
1147 static struct demangle_component
*
1148 d_encoding (struct d_info
*di
, int top_level
)
1150 char peek
= d_peek_char (di
);
1152 if (peek
== 'G' || peek
== 'T')
1153 return d_special_name (di
);
1156 struct demangle_component
*dc
;
1160 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1162 /* Strip off any initial CV-qualifiers, as they really apply
1163 to the `this' parameter, and they were not output by the
1164 v2 demangler without DMGL_PARAMS. */
1165 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1166 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1167 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1170 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1171 there may be CV-qualifiers on its right argument which
1172 really apply here; this happens when parsing a class
1173 which is local to a function. */
1174 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1176 struct demangle_component
*dcr
;
1179 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1180 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1181 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1183 dc
->u
.s_binary
.right
= dcr
;
1189 peek
= d_peek_char (di
);
1190 if (dc
== NULL
|| peek
== '\0' || peek
== 'E')
1192 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1193 d_bare_function_type (di
, has_return_type (dc
)));
1197 /* <name> ::= <nested-name>
1199 ::= <unscoped-template-name> <template-args>
1202 <unscoped-name> ::= <unqualified-name>
1203 ::= St <unqualified-name>
1205 <unscoped-template-name> ::= <unscoped-name>
1209 static struct demangle_component
*
1210 d_name (struct d_info
*di
)
1212 char peek
= d_peek_char (di
);
1213 struct demangle_component
*dc
;
1218 return d_nested_name (di
);
1221 return d_local_name (di
);
1225 return d_unqualified_name (di
);
1231 if (d_peek_next_char (di
) != 't')
1233 dc
= d_substitution (di
, 0);
1239 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1240 d_make_name (di
, "std", 3),
1241 d_unqualified_name (di
));
1246 if (d_peek_char (di
) != 'I')
1248 /* The grammar does not permit this case to occur if we
1249 called d_substitution() above (i.e., subst == 1). We
1250 don't bother to check. */
1254 /* This is <template-args>, which means that we just saw
1255 <unscoped-template-name>, which is a substitution
1256 candidate if we didn't just get it from a
1260 if (! d_add_substitution (di
, dc
))
1263 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1264 d_template_args (di
));
1271 dc
= d_unqualified_name (di
);
1272 if (d_peek_char (di
) == 'I')
1274 /* This is <template-args>, which means that we just saw
1275 <unscoped-template-name>, which is a substitution
1277 if (! d_add_substitution (di
, dc
))
1279 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1280 d_template_args (di
));
1286 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1287 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1290 static struct demangle_component
*
1291 d_nested_name (struct d_info
*di
)
1293 struct demangle_component
*ret
;
1294 struct demangle_component
**pret
;
1296 if (! d_check_char (di
, 'N'))
1299 pret
= d_cv_qualifiers (di
, &ret
, 1);
1303 *pret
= d_prefix (di
);
1307 if (! d_check_char (di
, 'E'))
1313 /* <prefix> ::= <prefix> <unqualified-name>
1314 ::= <template-prefix> <template-args>
1315 ::= <template-param>
1320 <template-prefix> ::= <prefix> <(template) unqualified-name>
1321 ::= <template-param>
1325 static struct demangle_component
*
1326 d_prefix (struct d_info
*di
)
1328 struct demangle_component
*ret
= NULL
;
1333 enum demangle_component_type comb_type
;
1334 struct demangle_component
*dc
;
1336 peek
= d_peek_char (di
);
1340 /* The older code accepts a <local-name> here, but I don't see
1341 that in the grammar. The older code does not accept a
1342 <template-param> here. */
1344 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1347 char peek2
= d_peek_next_char (di
);
1348 if (peek2
== 'T' || peek2
== 't')
1350 dc
= cplus_demangle_type (di
);
1352 /* Destructor name. */
1353 dc
= d_unqualified_name (di
);
1355 else if (IS_DIGIT (peek
)
1360 dc
= d_unqualified_name (di
);
1361 else if (peek
== 'S')
1362 dc
= d_substitution (di
, 1);
1363 else if (peek
== 'I')
1367 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1368 dc
= d_template_args (di
);
1370 else if (peek
== 'T')
1371 dc
= d_template_param (di
);
1372 else if (peek
== 'E')
1374 else if (peek
== 'M')
1376 /* Initializer scope for a lambda. We don't need to represent
1377 this; the normal code will just treat the variable as a type
1378 scope, which gives appropriate output. */
1390 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1392 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1394 if (! d_add_substitution (di
, ret
))
1400 /* <unqualified-name> ::= <operator-name>
1401 ::= <ctor-dtor-name>
1403 ::= <local-source-name>
1405 <local-source-name> ::= L <source-name> <discriminator>
1408 static struct demangle_component
*
1409 d_unqualified_name (struct d_info
*di
)
1413 peek
= d_peek_char (di
);
1414 if (IS_DIGIT (peek
))
1415 return d_source_name (di
);
1416 else if (IS_LOWER (peek
))
1418 struct demangle_component
*ret
;
1420 ret
= d_operator_name (di
);
1421 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1423 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1424 if (!strcmp (ret
->u
.s_operator
.op
->code
, "li"))
1425 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, ret
,
1426 d_source_name (di
));
1430 else if (peek
== 'C' || peek
== 'D')
1431 return d_ctor_dtor_name (di
);
1432 else if (peek
== 'L')
1434 struct demangle_component
* ret
;
1438 ret
= d_source_name (di
);
1441 if (! d_discriminator (di
))
1445 else if (peek
== 'U')
1447 switch (d_peek_next_char (di
))
1450 return d_lambda (di
);
1452 return d_unnamed_type (di
);
1461 /* <source-name> ::= <(positive length) number> <identifier> */
1463 static struct demangle_component
*
1464 d_source_name (struct d_info
*di
)
1467 struct demangle_component
*ret
;
1469 len
= d_number (di
);
1472 ret
= d_identifier (di
, len
);
1473 di
->last_name
= ret
;
1477 /* number ::= [n] <(non-negative decimal integer)> */
1480 d_number (struct d_info
*di
)
1487 peek
= d_peek_char (di
);
1492 peek
= d_peek_char (di
);
1498 if (! IS_DIGIT (peek
))
1504 ret
= ret
* 10 + peek
- '0';
1506 peek
= d_peek_char (di
);
1510 /* Like d_number, but returns a demangle_component. */
1512 static struct demangle_component
*
1513 d_number_component (struct d_info
*di
)
1515 struct demangle_component
*ret
= d_make_empty (di
);
1518 ret
->type
= DEMANGLE_COMPONENT_NUMBER
;
1519 ret
->u
.s_number
.number
= d_number (di
);
1524 /* identifier ::= <(unqualified source code identifier)> */
1526 static struct demangle_component
*
1527 d_identifier (struct d_info
*di
, int len
)
1533 if (di
->send
- name
< len
)
1536 d_advance (di
, len
);
1538 /* A Java mangled name may have a trailing '$' if it is a C++
1539 keyword. This '$' is not included in the length count. We just
1541 if ((di
->options
& DMGL_JAVA
) != 0
1542 && d_peek_char (di
) == '$')
1545 /* Look for something which looks like a gcc encoding of an
1546 anonymous namespace, and replace it with a more user friendly
1548 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1549 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1550 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1554 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1555 if ((*s
== '.' || *s
== '_' || *s
== '$')
1558 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1559 return d_make_name (di
, "(anonymous namespace)",
1560 sizeof "(anonymous namespace)" - 1);
1564 return d_make_name (di
, name
, len
);
1567 /* operator_name ::= many different two character encodings.
1569 ::= v <digit> <source-name>
1571 This list is sorted for binary search. */
1573 #define NL(s) s, (sizeof s) - 1
1575 CP_STATIC_IF_GLIBCPP_V3
1576 const struct demangle_operator_info cplus_demangle_operators
[] =
1578 { "aN", NL ("&="), 2 },
1579 { "aS", NL ("="), 2 },
1580 { "aa", NL ("&&"), 2 },
1581 { "ad", NL ("&"), 1 },
1582 { "an", NL ("&"), 2 },
1583 { "at", NL ("alignof "), 1 },
1584 { "az", NL ("alignof "), 1 },
1585 { "cl", NL ("()"), 2 },
1586 { "cm", NL (","), 2 },
1587 { "co", NL ("~"), 1 },
1588 { "dV", NL ("/="), 2 },
1589 { "da", NL ("delete[] "), 1 },
1590 { "de", NL ("*"), 1 },
1591 { "dl", NL ("delete "), 1 },
1592 { "ds", NL (".*"), 2 },
1593 { "dt", NL ("."), 2 },
1594 { "dv", NL ("/"), 2 },
1595 { "eO", NL ("^="), 2 },
1596 { "eo", NL ("^"), 2 },
1597 { "eq", NL ("=="), 2 },
1598 { "ge", NL (">="), 2 },
1599 { "gs", NL ("::"), 1 },
1600 { "gt", NL (">"), 2 },
1601 { "ix", NL ("[]"), 2 },
1602 { "lS", NL ("<<="), 2 },
1603 { "le", NL ("<="), 2 },
1604 { "li", NL ("operator\"\" "), 1 },
1605 { "ls", NL ("<<"), 2 },
1606 { "lt", NL ("<"), 2 },
1607 { "mI", NL ("-="), 2 },
1608 { "mL", NL ("*="), 2 },
1609 { "mi", NL ("-"), 2 },
1610 { "ml", NL ("*"), 2 },
1611 { "mm", NL ("--"), 1 },
1612 { "na", NL ("new[]"), 3 },
1613 { "ne", NL ("!="), 2 },
1614 { "ng", NL ("-"), 1 },
1615 { "nt", NL ("!"), 1 },
1616 { "nw", NL ("new"), 3 },
1617 { "oR", NL ("|="), 2 },
1618 { "oo", NL ("||"), 2 },
1619 { "or", NL ("|"), 2 },
1620 { "pL", NL ("+="), 2 },
1621 { "pl", NL ("+"), 2 },
1622 { "pm", NL ("->*"), 2 },
1623 { "pp", NL ("++"), 1 },
1624 { "ps", NL ("+"), 1 },
1625 { "pt", NL ("->"), 2 },
1626 { "qu", NL ("?"), 3 },
1627 { "rM", NL ("%="), 2 },
1628 { "rS", NL (">>="), 2 },
1629 { "rm", NL ("%"), 2 },
1630 { "rs", NL (">>"), 2 },
1631 { "st", NL ("sizeof "), 1 },
1632 { "sz", NL ("sizeof "), 1 },
1633 { "tr", NL ("throw"), 0 },
1634 { "tw", NL ("throw "), 1 },
1635 { NULL
, NULL
, 0, 0 }
1638 static struct demangle_component
*
1639 d_operator_name (struct d_info
*di
)
1644 c1
= d_next_char (di
);
1645 c2
= d_next_char (di
);
1646 if (c1
== 'v' && IS_DIGIT (c2
))
1647 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1648 else if (c1
== 'c' && c2
== 'v')
1649 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1650 cplus_demangle_type (di
), NULL
);
1653 /* LOW is the inclusive lower bound. */
1655 /* HIGH is the exclusive upper bound. We subtract one to ignore
1656 the sentinel at the end of the array. */
1657 int high
= ((sizeof (cplus_demangle_operators
)
1658 / sizeof (cplus_demangle_operators
[0]))
1664 const struct demangle_operator_info
*p
;
1666 i
= low
+ (high
- low
) / 2;
1667 p
= cplus_demangle_operators
+ i
;
1669 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1670 return d_make_operator (di
, p
);
1672 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1682 static struct demangle_component
*
1683 d_make_character (struct d_info
*di
, int c
)
1685 struct demangle_component
*p
;
1686 p
= d_make_empty (di
);
1689 p
->type
= DEMANGLE_COMPONENT_CHARACTER
;
1690 p
->u
.s_character
.character
= c
;
1695 static struct demangle_component
*
1696 d_java_resource (struct d_info
*di
)
1698 struct demangle_component
*p
= NULL
;
1699 struct demangle_component
*next
= NULL
;
1704 len
= d_number (di
);
1708 /* Eat the leading '_'. */
1709 if (d_next_char (di
) != '_')
1722 /* Each chunk is either a '$' escape... */
1740 next
= d_make_character (di
, c
);
1748 /* ... or a sequence of characters. */
1751 while (i
< len
&& str
[i
] && str
[i
] != '$')
1754 next
= d_make_name (di
, str
, i
);
1767 p
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPOUND_NAME
, p
, next
);
1773 p
= d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_RESOURCE
, p
, NULL
);
1778 /* <special-name> ::= TV <type>
1782 ::= GV <(object) name>
1783 ::= T <call-offset> <(base) encoding>
1784 ::= Tc <call-offset> <call-offset> <(base) encoding>
1785 Also g++ extensions:
1786 ::= TC <type> <(offset) number> _ <(base) type>
1791 ::= Gr <resource name>
1796 static struct demangle_component
*
1797 d_special_name (struct d_info
*di
)
1799 di
->expansion
+= 20;
1800 if (d_check_char (di
, 'T'))
1802 switch (d_next_char (di
))
1806 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1807 cplus_demangle_type (di
), NULL
);
1809 di
->expansion
-= 10;
1810 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1811 cplus_demangle_type (di
), NULL
);
1813 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1814 cplus_demangle_type (di
), NULL
);
1816 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1817 cplus_demangle_type (di
), NULL
);
1820 if (! d_call_offset (di
, 'h'))
1822 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1823 d_encoding (di
, 0), NULL
);
1826 if (! d_call_offset (di
, 'v'))
1828 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1829 d_encoding (di
, 0), NULL
);
1832 if (! d_call_offset (di
, '\0'))
1834 if (! d_call_offset (di
, '\0'))
1836 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1837 d_encoding (di
, 0), NULL
);
1841 struct demangle_component
*derived_type
;
1843 struct demangle_component
*base_type
;
1845 derived_type
= cplus_demangle_type (di
);
1846 offset
= d_number (di
);
1849 if (! d_check_char (di
, '_'))
1851 base_type
= cplus_demangle_type (di
);
1852 /* We don't display the offset. FIXME: We should display
1853 it in verbose mode. */
1855 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1856 base_type
, derived_type
);
1860 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1861 cplus_demangle_type (di
), NULL
);
1863 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1864 cplus_demangle_type (di
), NULL
);
1870 else if (d_check_char (di
, 'G'))
1872 switch (d_next_char (di
))
1875 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1879 struct demangle_component
*name
= d_name (di
);
1880 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, name
,
1881 d_number_component (di
));
1885 return d_make_comp (di
, DEMANGLE_COMPONENT_HIDDEN_ALIAS
,
1886 d_encoding (di
, 0), NULL
);
1889 switch (d_next_char (di
))
1892 return d_make_comp (di
, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
,
1893 d_encoding (di
, 0), NULL
);
1895 /* ??? The proposal is that other letters (such as 'h') stand
1896 for different variants of transaction cloning, such as
1897 compiling directly for hardware transaction support. But
1898 they still should all be transactional clones of some sort
1899 so go ahead and call them that. */
1901 return d_make_comp (di
, DEMANGLE_COMPONENT_TRANSACTION_CLONE
,
1902 d_encoding (di
, 0), NULL
);
1906 return d_java_resource (di
);
1916 /* <call-offset> ::= h <nv-offset> _
1919 <nv-offset> ::= <(offset) number>
1921 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1923 The C parameter, if not '\0', is a character we just read which is
1924 the start of the <call-offset>.
1926 We don't display the offset information anywhere. FIXME: We should
1927 display it in verbose mode. */
1930 d_call_offset (struct d_info
*di
, int c
)
1933 c
= d_next_char (di
);
1940 if (! d_check_char (di
, '_'))
1947 if (! d_check_char (di
, '_'))
1953 /* <ctor-dtor-name> ::= C1
1961 static struct demangle_component
*
1962 d_ctor_dtor_name (struct d_info
*di
)
1964 if (di
->last_name
!= NULL
)
1966 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
1967 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
1968 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1969 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
1971 switch (d_peek_char (di
))
1975 enum gnu_v3_ctor_kinds kind
;
1977 switch (d_peek_next_char (di
))
1980 kind
= gnu_v3_complete_object_ctor
;
1983 kind
= gnu_v3_base_object_ctor
;
1986 kind
= gnu_v3_complete_object_allocating_ctor
;
1989 kind
= gnu_v3_object_ctor_group
;
1995 return d_make_ctor (di
, kind
, di
->last_name
);
2000 enum gnu_v3_dtor_kinds kind
;
2002 switch (d_peek_next_char (di
))
2005 kind
= gnu_v3_deleting_dtor
;
2008 kind
= gnu_v3_complete_object_dtor
;
2011 kind
= gnu_v3_base_object_dtor
;
2014 kind
= gnu_v3_object_dtor_group
;
2020 return d_make_dtor (di
, kind
, di
->last_name
);
2028 /* <type> ::= <builtin-type>
2030 ::= <class-enum-type>
2032 ::= <pointer-to-member-type>
2033 ::= <template-param>
2034 ::= <template-template-param> <template-args>
2036 ::= <CV-qualifiers> <type>
2039 ::= O <type> (C++0x)
2042 ::= U <source-name> <type>
2044 <builtin-type> ::= various one letter codes
2048 CP_STATIC_IF_GLIBCPP_V3
2049 const struct demangle_builtin_type_info
2050 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
2052 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT
},
2053 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
2054 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT
},
2055 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT
},
2056 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT
},
2057 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT
},
2058 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT
},
2059 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT
},
2060 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
2061 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED
},
2062 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2063 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
2064 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG
},
2065 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
2066 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2068 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2069 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2070 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2071 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT
},
2072 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT
},
2073 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
2074 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
2075 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT
},
2076 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG
},
2077 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2078 D_PRINT_UNSIGNED_LONG_LONG
},
2079 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
2080 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT
},
2081 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT
},
2082 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT
},
2083 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT
},
2084 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT
},
2085 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT
},
2086 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2090 CP_STATIC_IF_GLIBCPP_V3
2091 struct demangle_component
*
2092 cplus_demangle_type (struct d_info
*di
)
2095 struct demangle_component
*ret
;
2098 /* The ABI specifies that when CV-qualifiers are used, the base type
2099 is substitutable, and the fully qualified type is substitutable,
2100 but the base type with a strict subset of the CV-qualifiers is
2101 not substitutable. The natural recursive implementation of the
2102 CV-qualifiers would cause subsets to be substitutable, so instead
2103 we pull them all off now.
2105 FIXME: The ABI says that order-insensitive vendor qualifiers
2106 should be handled in the same way, but we have no way to tell
2107 which vendor qualifiers are order-insensitive and which are
2108 order-sensitive. So we just assume that they are all
2109 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2110 __vector, and it treats it as order-sensitive when mangling
2113 peek
= d_peek_char (di
);
2114 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
2116 struct demangle_component
**pret
;
2118 pret
= d_cv_qualifiers (di
, &ret
, 0);
2121 *pret
= cplus_demangle_type (di
);
2122 if (! *pret
|| ! d_add_substitution (di
, ret
))
2131 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2132 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2133 case 'o': case 's': case 't':
2134 case 'v': case 'w': case 'x': case 'y': case 'z':
2135 ret
= d_make_builtin_type (di
,
2136 &cplus_demangle_builtin_types
[peek
- 'a']);
2137 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2144 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
2145 d_source_name (di
), NULL
);
2149 ret
= d_function_type (di
);
2152 case '0': case '1': case '2': case '3': case '4':
2153 case '5': case '6': case '7': case '8': case '9':
2156 ret
= d_class_enum_type (di
);
2160 ret
= d_array_type (di
);
2164 ret
= d_pointer_to_member_type (di
);
2168 ret
= d_template_param (di
);
2169 if (d_peek_char (di
) == 'I')
2171 /* This is <template-template-param> <template-args>. The
2172 <template-template-param> part is a substitution
2174 if (! d_add_substitution (di
, ret
))
2176 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2177 d_template_args (di
));
2182 /* If this is a special substitution, then it is the start of
2183 <class-enum-type>. */
2187 peek_next
= d_peek_next_char (di
);
2188 if (IS_DIGIT (peek_next
)
2190 || IS_UPPER (peek_next
))
2192 ret
= d_substitution (di
, 0);
2193 /* The substituted name may have been a template name and
2194 may be followed by tepmlate args. */
2195 if (d_peek_char (di
) == 'I')
2196 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
2197 d_template_args (di
));
2203 ret
= d_class_enum_type (di
);
2204 /* If the substitution was a complete type, then it is not
2205 a new substitution candidate. However, if the
2206 substitution was followed by template arguments, then
2207 the whole thing is a substitution candidate. */
2208 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
2216 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_RVALUE_REFERENCE
,
2217 cplus_demangle_type (di
), NULL
);
2222 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
2223 cplus_demangle_type (di
), NULL
);
2228 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
2229 cplus_demangle_type (di
), NULL
);
2234 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
2235 cplus_demangle_type (di
), NULL
);
2240 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
2241 cplus_demangle_type (di
), NULL
);
2246 ret
= d_source_name (di
);
2247 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
2248 cplus_demangle_type (di
), ret
);
2254 peek
= d_next_char (di
);
2259 /* decltype (expression) */
2260 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_DECLTYPE
,
2261 d_expression (di
), NULL
);
2262 if (ret
&& d_next_char (di
) != 'E')
2268 /* Pack expansion. */
2269 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2270 cplus_demangle_type (di
), NULL
);
2276 ret
= d_make_name (di
, "auto", 4);
2280 /* 32-bit decimal floating point */
2281 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[26]);
2282 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2286 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[27]);
2287 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2291 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[28]);
2292 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2295 /* 16-bit half-precision FP */
2296 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[29]);
2297 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2301 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[30]);
2302 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2306 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[31]);
2307 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2311 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2312 ret
= d_make_empty (di
);
2313 ret
->type
= DEMANGLE_COMPONENT_FIXED_TYPE
;
2314 if ((ret
->u
.s_fixed
.accum
= IS_DIGIT (d_peek_char (di
))))
2315 /* For demangling we don't care about the bits. */
2317 ret
->u
.s_fixed
.length
= cplus_demangle_type (di
);
2318 if (ret
->u
.s_fixed
.length
== NULL
)
2321 peek
= d_next_char (di
);
2322 ret
->u
.s_fixed
.sat
= (peek
== 's');
2326 ret
= d_vector_type (di
);
2331 /* decltype(nullptr) */
2332 ret
= d_make_builtin_type (di
, &cplus_demangle_builtin_types
[32]);
2333 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
2347 if (! d_add_substitution (di
, ret
))
2354 /* <CV-qualifiers> ::= [r] [V] [K] */
2356 static struct demangle_component
**
2357 d_cv_qualifiers (struct d_info
*di
,
2358 struct demangle_component
**pret
, int member_fn
)
2360 struct demangle_component
**pstart
;
2364 peek
= d_peek_char (di
);
2365 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
2367 enum demangle_component_type t
;
2373 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2374 : DEMANGLE_COMPONENT_RESTRICT
);
2375 di
->expansion
+= sizeof "restrict";
2377 else if (peek
== 'V')
2380 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2381 : DEMANGLE_COMPONENT_VOLATILE
);
2382 di
->expansion
+= sizeof "volatile";
2387 ? DEMANGLE_COMPONENT_CONST_THIS
2388 : DEMANGLE_COMPONENT_CONST
);
2389 di
->expansion
+= sizeof "const";
2392 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
2395 pret
= &d_left (*pret
);
2397 peek
= d_peek_char (di
);
2400 if (!member_fn
&& peek
== 'F')
2402 while (pstart
!= pret
)
2404 switch ((*pstart
)->type
)
2406 case DEMANGLE_COMPONENT_RESTRICT
:
2407 (*pstart
)->type
= DEMANGLE_COMPONENT_RESTRICT_THIS
;
2409 case DEMANGLE_COMPONENT_VOLATILE
:
2410 (*pstart
)->type
= DEMANGLE_COMPONENT_VOLATILE_THIS
;
2412 case DEMANGLE_COMPONENT_CONST
:
2413 (*pstart
)->type
= DEMANGLE_COMPONENT_CONST_THIS
;
2418 pstart
= &d_left (*pstart
);
2425 /* <function-type> ::= F [Y] <bare-function-type> E */
2427 static struct demangle_component
*
2428 d_function_type (struct d_info
*di
)
2430 struct demangle_component
*ret
;
2432 if (! d_check_char (di
, 'F'))
2434 if (d_peek_char (di
) == 'Y')
2436 /* Function has C linkage. We don't print this information.
2437 FIXME: We should print it in verbose mode. */
2440 ret
= d_bare_function_type (di
, 1);
2441 if (! d_check_char (di
, 'E'))
2448 static struct demangle_component
*
2449 d_parmlist (struct d_info
*di
)
2451 struct demangle_component
*tl
;
2452 struct demangle_component
**ptl
;
2458 struct demangle_component
*type
;
2460 char peek
= d_peek_char (di
);
2461 if (peek
== '\0' || peek
== 'E' || peek
== '.')
2463 type
= cplus_demangle_type (di
);
2466 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2469 ptl
= &d_right (*ptl
);
2472 /* There should be at least one parameter type besides the optional
2473 return type. A function which takes no arguments will have a
2474 single parameter type void. */
2478 /* If we have a single parameter type void, omit it. */
2479 if (d_right (tl
) == NULL
2480 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2481 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2483 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2490 /* <bare-function-type> ::= [J]<type>+ */
2492 static struct demangle_component
*
2493 d_bare_function_type (struct d_info
*di
, int has_return_type
)
2495 struct demangle_component
*return_type
;
2496 struct demangle_component
*tl
;
2499 /* Detect special qualifier indicating that the first argument
2500 is the return type. */
2501 peek
= d_peek_char (di
);
2505 has_return_type
= 1;
2508 if (has_return_type
)
2510 return_type
= cplus_demangle_type (di
);
2511 if (return_type
== NULL
)
2517 tl
= d_parmlist (di
);
2521 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
,
2525 /* <class-enum-type> ::= <name> */
2527 static struct demangle_component
*
2528 d_class_enum_type (struct d_info
*di
)
2533 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2534 ::= A [<(dimension) expression>] _ <(element) type>
2537 static struct demangle_component
*
2538 d_array_type (struct d_info
*di
)
2541 struct demangle_component
*dim
;
2543 if (! d_check_char (di
, 'A'))
2546 peek
= d_peek_char (di
);
2549 else if (IS_DIGIT (peek
))
2557 peek
= d_peek_char (di
);
2559 while (IS_DIGIT (peek
));
2560 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2566 dim
= d_expression (di
);
2571 if (! d_check_char (di
, '_'))
2574 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2575 cplus_demangle_type (di
));
2578 /* <vector-type> ::= Dv <number> _ <type>
2579 ::= Dv _ <expression> _ <type> */
2581 static struct demangle_component
*
2582 d_vector_type (struct d_info
*di
)
2585 struct demangle_component
*dim
;
2587 peek
= d_peek_char (di
);
2591 dim
= d_expression (di
);
2594 dim
= d_number_component (di
);
2599 if (! d_check_char (di
, '_'))
2602 return d_make_comp (di
, DEMANGLE_COMPONENT_VECTOR_TYPE
, dim
,
2603 cplus_demangle_type (di
));
2606 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2608 static struct demangle_component
*
2609 d_pointer_to_member_type (struct d_info
*di
)
2611 struct demangle_component
*cl
;
2612 struct demangle_component
*mem
;
2613 struct demangle_component
**pmem
;
2615 if (! d_check_char (di
, 'M'))
2618 cl
= cplus_demangle_type (di
);
2620 /* The ABI specifies that any type can be a substitution source, and
2621 that M is followed by two types, and that when a CV-qualified
2622 type is seen both the base type and the CV-qualified types are
2623 substitution sources. The ABI also specifies that for a pointer
2624 to a CV-qualified member function, the qualifiers are attached to
2625 the second type. Given the grammar, a plain reading of the ABI
2626 suggests that both the CV-qualified member function and the
2627 non-qualified member function are substitution sources. However,
2628 g++ does not work that way. g++ treats only the CV-qualified
2629 member function as a substitution source. FIXME. So to work
2630 with g++, we need to pull off the CV-qualifiers here, in order to
2631 avoid calling add_substitution() in cplus_demangle_type(). But
2632 for a CV-qualified member which is not a function, g++ does
2633 follow the ABI, so we need to handle that case here by calling
2634 d_add_substitution ourselves. */
2636 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2639 *pmem
= cplus_demangle_type (di
);
2643 if (pmem
!= &mem
&& (*pmem
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
2645 if (! d_add_substitution (di
, mem
))
2649 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2652 /* <non-negative number> _ */
2655 d_compact_number (struct d_info
*di
)
2658 if (d_peek_char (di
) == '_')
2660 else if (d_peek_char (di
) == 'n')
2663 num
= d_number (di
) + 1;
2665 if (! d_check_char (di
, '_'))
2670 /* <template-param> ::= T_
2671 ::= T <(parameter-2 non-negative) number> _
2674 static struct demangle_component
*
2675 d_template_param (struct d_info
*di
)
2679 if (! d_check_char (di
, 'T'))
2682 param
= d_compact_number (di
);
2688 return d_make_template_param (di
, param
);
2691 /* <template-args> ::= I <template-arg>+ E */
2693 static struct demangle_component
*
2694 d_template_args (struct d_info
*di
)
2696 struct demangle_component
*hold_last_name
;
2697 struct demangle_component
*al
;
2698 struct demangle_component
**pal
;
2700 /* Preserve the last name we saw--don't let the template arguments
2701 clobber it, as that would give us the wrong name for a subsequent
2702 constructor or destructor. */
2703 hold_last_name
= di
->last_name
;
2705 if (d_peek_char (di
) != 'I'
2706 && d_peek_char (di
) != 'J')
2710 if (d_peek_char (di
) == 'E')
2712 /* An argument pack can be empty. */
2714 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, NULL
, NULL
);
2721 struct demangle_component
*a
;
2723 a
= d_template_arg (di
);
2727 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2730 pal
= &d_right (*pal
);
2732 if (d_peek_char (di
) == 'E')
2739 di
->last_name
= hold_last_name
;
2744 /* <template-arg> ::= <type>
2745 ::= X <expression> E
2749 static struct demangle_component
*
2750 d_template_arg (struct d_info
*di
)
2752 struct demangle_component
*ret
;
2754 switch (d_peek_char (di
))
2758 ret
= d_expression (di
);
2759 if (! d_check_char (di
, 'E'))
2764 return d_expr_primary (di
);
2768 /* An argument pack. */
2769 return d_template_args (di
);
2772 return cplus_demangle_type (di
);
2776 /* Parse a sequence of expressions until we hit the terminator
2779 static struct demangle_component
*
2780 d_exprlist (struct d_info
*di
, char terminator
)
2782 struct demangle_component
*list
= NULL
;
2783 struct demangle_component
**p
= &list
;
2785 if (d_peek_char (di
) == terminator
)
2788 return d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, NULL
, NULL
);
2793 struct demangle_component
*arg
= d_expression (di
);
2797 *p
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, arg
, NULL
);
2802 if (d_peek_char (di
) == terminator
)
2812 /* <expression> ::= <(unary) operator-name> <expression>
2813 ::= <(binary) operator-name> <expression> <expression>
2814 ::= <(trinary) operator-name> <expression> <expression> <expression>
2815 ::= cl <expression>+ E
2817 ::= <template-param>
2818 ::= sr <type> <unqualified-name>
2819 ::= sr <type> <unqualified-name> <template-args>
2823 static struct demangle_component
*
2824 d_expression (struct d_info
*di
)
2828 peek
= d_peek_char (di
);
2830 return d_expr_primary (di
);
2831 else if (peek
== 'T')
2832 return d_template_param (di
);
2833 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2835 struct demangle_component
*type
;
2836 struct demangle_component
*name
;
2839 type
= cplus_demangle_type (di
);
2840 name
= d_unqualified_name (di
);
2841 if (d_peek_char (di
) != 'I')
2842 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2844 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2845 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2846 d_template_args (di
)));
2848 else if (peek
== 's' && d_peek_next_char (di
) == 'p')
2851 return d_make_comp (di
, DEMANGLE_COMPONENT_PACK_EXPANSION
,
2852 d_expression (di
), NULL
);
2854 else if (peek
== 'f' && d_peek_next_char (di
) == 'p')
2856 /* Function parameter used in a late-specified return type. */
2859 if (d_peek_char (di
) == 'T')
2861 /* 'this' parameter. */
2867 index
= d_compact_number (di
) + 1;
2871 return d_make_function_param (di
, index
);
2873 else if (IS_DIGIT (peek
)
2874 || (peek
== 'o' && d_peek_next_char (di
) == 'n'))
2876 /* We can get an unqualified name as an expression in the case of
2877 a dependent function call, i.e. decltype(f(t)). */
2878 struct demangle_component
*name
;
2881 /* operator-function-id, i.e. operator+(t). */
2884 name
= d_unqualified_name (di
);
2887 if (d_peek_char (di
) == 'I')
2888 return d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2889 d_template_args (di
));
2893 else if ((peek
== 'i' || peek
== 't')
2894 && d_peek_next_char (di
) == 'l')
2896 /* Brace-enclosed initializer list, untyped or typed. */
2897 struct demangle_component
*type
= NULL
;
2899 type
= cplus_demangle_type (di
);
2901 return d_make_comp (di
, DEMANGLE_COMPONENT_INITIALIZER_LIST
,
2902 type
, d_exprlist (di
, 'E'));
2906 struct demangle_component
*op
;
2907 const char *code
= NULL
;
2910 op
= d_operator_name (di
);
2914 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
2916 code
= op
->u
.s_operator
.op
->code
;
2917 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
2918 if (strcmp (code
, "st") == 0)
2919 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2920 cplus_demangle_type (di
));
2927 case DEMANGLE_COMPONENT_OPERATOR
:
2928 args
= op
->u
.s_operator
.op
->args
;
2930 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
2931 args
= op
->u
.s_extended_operator
.args
;
2933 case DEMANGLE_COMPONENT_CAST
:
2941 return d_make_comp (di
, DEMANGLE_COMPONENT_NULLARY
, op
, NULL
);
2945 struct demangle_component
*operand
;
2948 if (code
&& (code
[0] == 'p' || code
[0] == 'm')
2949 && code
[1] == code
[0])
2950 /* pp_ and mm_ are the prefix variants. */
2951 suffix
= !d_check_char (di
, '_');
2953 if (op
->type
== DEMANGLE_COMPONENT_CAST
2954 && d_check_char (di
, '_'))
2955 operand
= d_exprlist (di
, 'E');
2957 operand
= d_expression (di
);
2960 /* Indicate the suffix variant for d_print_comp. */
2961 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2963 DEMANGLE_COMPONENT_BINARY_ARGS
,
2966 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2971 struct demangle_component
*left
;
2972 struct demangle_component
*right
;
2974 left
= d_expression (di
);
2975 if (!strcmp (code
, "cl"))
2976 right
= d_exprlist (di
, 'E');
2977 else if (!strcmp (code
, "dt") || !strcmp (code
, "pt"))
2979 right
= d_unqualified_name (di
);
2980 if (d_peek_char (di
) == 'I')
2981 right
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
,
2982 right
, d_template_args (di
));
2985 right
= d_expression (di
);
2987 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
2989 DEMANGLE_COMPONENT_BINARY_ARGS
,
2994 struct demangle_component
*first
;
2995 struct demangle_component
*second
;
2996 struct demangle_component
*third
;
2998 if (!strcmp (code
, "qu"))
3000 /* ?: expression. */
3001 first
= d_expression (di
);
3002 second
= d_expression (di
);
3003 third
= d_expression (di
);
3005 else if (code
[0] == 'n')
3007 /* new-expression. */
3008 if (code
[1] != 'w' && code
[1] != 'a')
3010 first
= d_exprlist (di
, '_');
3011 second
= cplus_demangle_type (di
);
3012 if (d_peek_char (di
) == 'E')
3017 else if (d_peek_char (di
) == 'p'
3018 && d_peek_next_char (di
) == 'i')
3020 /* Parenthesized initializer. */
3022 third
= d_exprlist (di
, 'E');
3024 else if (d_peek_char (di
) == 'i'
3025 && d_peek_next_char (di
) == 'l')
3026 /* initializer-list. */
3027 third
= d_expression (di
);
3033 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
3035 DEMANGLE_COMPONENT_TRINARY_ARG1
,
3038 DEMANGLE_COMPONENT_TRINARY_ARG2
,
3047 /* <expr-primary> ::= L <type> <(value) number> E
3048 ::= L <type> <(value) float> E
3049 ::= L <mangled-name> E
3052 static struct demangle_component
*
3053 d_expr_primary (struct d_info
*di
)
3055 struct demangle_component
*ret
;
3057 if (! d_check_char (di
, 'L'))
3059 if (d_peek_char (di
) == '_'
3060 /* Workaround for G++ bug; see comment in write_template_arg. */
3061 || d_peek_char (di
) == 'Z')
3062 ret
= cplus_demangle_mangled_name (di
, 0);
3065 struct demangle_component
*type
;
3066 enum demangle_component_type t
;
3069 type
= cplus_demangle_type (di
);
3073 /* If we have a type we know how to print, we aren't going to
3074 print the type name itself. */
3075 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
3076 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
3077 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
3079 /* Rather than try to interpret the literal value, we just
3080 collect it as a string. Note that it's possible to have a
3081 floating point literal here. The ABI specifies that the
3082 format of such literals is machine independent. That's fine,
3083 but what's not fine is that versions of g++ up to 3.2 with
3084 -fabi-version=1 used upper case letters in the hex constant,
3085 and dumped out gcc's internal representation. That makes it
3086 hard to tell where the constant ends, and hard to dump the
3087 constant in any readable form anyhow. We don't attempt to
3088 handle these cases. */
3090 t
= DEMANGLE_COMPONENT_LITERAL
;
3091 if (d_peek_char (di
) == 'n')
3093 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
3097 while (d_peek_char (di
) != 'E')
3099 if (d_peek_char (di
) == '\0')
3103 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
3105 if (! d_check_char (di
, 'E'))
3110 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3111 ::= Z <(function) encoding> E s [<discriminator>]
3114 static struct demangle_component
*
3115 d_local_name (struct d_info
*di
)
3117 struct demangle_component
*function
;
3119 if (! d_check_char (di
, 'Z'))
3122 function
= d_encoding (di
, 0);
3124 if (! d_check_char (di
, 'E'))
3127 if (d_peek_char (di
) == 's')
3130 if (! d_discriminator (di
))
3132 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
3133 d_make_name (di
, "string literal",
3134 sizeof "string literal" - 1));
3138 struct demangle_component
*name
;
3141 if (d_peek_char (di
) == 'd')
3143 /* Default argument scope: d <number> _. */
3145 num
= d_compact_number (di
);
3154 /* Lambdas and unnamed types have internal discriminators. */
3155 case DEMANGLE_COMPONENT_LAMBDA
:
3156 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3159 if (! d_discriminator (di
))
3163 name
= d_make_default_arg (di
, num
, name
);
3164 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
3168 /* <discriminator> ::= _ <(non-negative) number>
3170 We demangle the discriminator, but we don't print it out. FIXME:
3171 We should print it out in verbose mode. */
3174 d_discriminator (struct d_info
*di
)
3178 if (d_peek_char (di
) != '_')
3181 discrim
= d_number (di
);
3187 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3189 static struct demangle_component
*
3190 d_lambda (struct d_info
*di
)
3192 struct demangle_component
*tl
;
3193 struct demangle_component
*ret
;
3196 if (! d_check_char (di
, 'U'))
3198 if (! d_check_char (di
, 'l'))
3201 tl
= d_parmlist (di
);
3205 if (! d_check_char (di
, 'E'))
3208 num
= d_compact_number (di
);
3212 ret
= d_make_empty (di
);
3215 ret
->type
= DEMANGLE_COMPONENT_LAMBDA
;
3216 ret
->u
.s_unary_num
.sub
= tl
;
3217 ret
->u
.s_unary_num
.num
= num
;
3220 if (! d_add_substitution (di
, ret
))
3226 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3228 static struct demangle_component
*
3229 d_unnamed_type (struct d_info
*di
)
3231 struct demangle_component
*ret
;
3234 if (! d_check_char (di
, 'U'))
3236 if (! d_check_char (di
, 't'))
3239 num
= d_compact_number (di
);
3243 ret
= d_make_empty (di
);
3246 ret
->type
= DEMANGLE_COMPONENT_UNNAMED_TYPE
;
3247 ret
->u
.s_number
.number
= num
;
3250 if (! d_add_substitution (di
, ret
))
3256 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3259 static struct demangle_component
*
3260 d_clone_suffix (struct d_info
*di
, struct demangle_component
*encoding
)
3262 const char *suffix
= d_str (di
);
3263 const char *pend
= suffix
;
3264 struct demangle_component
*n
;
3266 if (*pend
== '.' && (IS_LOWER (pend
[1]) || pend
[1] == '_'))
3269 while (IS_LOWER (*pend
) || *pend
== '_')
3272 while (*pend
== '.' && IS_DIGIT (pend
[1]))
3275 while (IS_DIGIT (*pend
))
3278 d_advance (di
, pend
- suffix
);
3279 n
= d_make_name (di
, suffix
, pend
- suffix
);
3280 return d_make_comp (di
, DEMANGLE_COMPONENT_CLONE
, encoding
, n
);
3283 /* Add a new substitution. */
3286 d_add_substitution (struct d_info
*di
, struct demangle_component
*dc
)
3290 if (di
->next_sub
>= di
->num_subs
)
3292 di
->subs
[di
->next_sub
] = dc
;
3297 /* <substitution> ::= S <seq-id> _
3307 If PREFIX is non-zero, then this type is being used as a prefix in
3308 a qualified name. In this case, for the standard substitutions, we
3309 need to check whether we are being used as a prefix for a
3310 constructor or destructor, and return a full template name.
3311 Otherwise we will get something like std::iostream::~iostream()
3312 which does not correspond particularly well to any function which
3313 actually appears in the source.
3316 static const struct d_standard_sub_info standard_subs
[] =
3321 { 'a', NL ("std::allocator"),
3322 NL ("std::allocator"),
3324 { 'b', NL ("std::basic_string"),
3325 NL ("std::basic_string"),
3326 NL ("basic_string") },
3327 { 's', NL ("std::string"),
3328 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3329 NL ("basic_string") },
3330 { 'i', NL ("std::istream"),
3331 NL ("std::basic_istream<char, std::char_traits<char> >"),
3332 NL ("basic_istream") },
3333 { 'o', NL ("std::ostream"),
3334 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3335 NL ("basic_ostream") },
3336 { 'd', NL ("std::iostream"),
3337 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3338 NL ("basic_iostream") }
3341 static struct demangle_component
*
3342 d_substitution (struct d_info
*di
, int prefix
)
3346 if (! d_check_char (di
, 'S'))
3349 c
= d_next_char (di
);
3350 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
3359 unsigned int new_id
;
3362 new_id
= id
* 36 + c
- '0';
3363 else if (IS_UPPER (c
))
3364 new_id
= id
* 36 + c
- 'A' + 10;
3370 c
= d_next_char (di
);
3377 if (id
>= (unsigned int) di
->next_sub
)
3382 return di
->subs
[id
];
3387 const struct d_standard_sub_info
*p
;
3388 const struct d_standard_sub_info
*pend
;
3390 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
3391 if (! verbose
&& prefix
)
3395 peek
= d_peek_char (di
);
3396 if (peek
== 'C' || peek
== 'D')
3400 pend
= (&standard_subs
[0]
3401 + sizeof standard_subs
/ sizeof standard_subs
[0]);
3402 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
3409 if (p
->set_last_name
!= NULL
)
3410 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
3411 p
->set_last_name_len
);
3414 s
= p
->full_expansion
;
3419 s
= p
->simple_expansion
;
3420 len
= p
->simple_len
;
3422 di
->expansion
+= len
;
3423 return d_make_sub (di
, s
, len
);
3431 /* Initialize a growable string. */
3434 d_growable_string_init (struct d_growable_string
*dgs
, size_t estimate
)
3439 dgs
->allocation_failure
= 0;
3442 d_growable_string_resize (dgs
, estimate
);
3445 /* Grow a growable string to a given size. */
3448 d_growable_string_resize (struct d_growable_string
*dgs
, size_t need
)
3453 if (dgs
->allocation_failure
)
3456 /* Start allocation at two bytes to avoid any possibility of confusion
3457 with the special value of 1 used as a return in *palc to indicate
3458 allocation failures. */
3459 newalc
= dgs
->alc
> 0 ? dgs
->alc
: 2;
3460 while (newalc
< need
)
3463 newbuf
= (char *) realloc (dgs
->buf
, newalc
);
3470 dgs
->allocation_failure
= 1;
3477 /* Append a buffer to a growable string. */
3480 d_growable_string_append_buffer (struct d_growable_string
*dgs
,
3481 const char *s
, size_t l
)
3485 need
= dgs
->len
+ l
+ 1;
3486 if (need
> dgs
->alc
)
3487 d_growable_string_resize (dgs
, need
);
3489 if (dgs
->allocation_failure
)
3492 memcpy (dgs
->buf
+ dgs
->len
, s
, l
);
3493 dgs
->buf
[dgs
->len
+ l
] = '\0';
3497 /* Bridge growable strings to the callback mechanism. */
3500 d_growable_string_callback_adapter (const char *s
, size_t l
, void *opaque
)
3502 struct d_growable_string
*dgs
= (struct d_growable_string
*) opaque
;
3504 d_growable_string_append_buffer (dgs
, s
, l
);
3507 /* Initialize a print information structure. */
3510 d_print_init (struct d_print_info
*dpi
, demangle_callbackref callback
,
3514 dpi
->last_char
= '\0';
3515 dpi
->templates
= NULL
;
3516 dpi
->modifiers
= NULL
;
3517 dpi
->pack_index
= 0;
3518 dpi
->flush_count
= 0;
3520 dpi
->callback
= callback
;
3521 dpi
->opaque
= opaque
;
3523 dpi
->demangle_failure
= 0;
3526 /* Indicate that an error occurred during printing, and test for error. */
3529 d_print_error (struct d_print_info
*dpi
)
3531 dpi
->demangle_failure
= 1;
3535 d_print_saw_error (struct d_print_info
*dpi
)
3537 return dpi
->demangle_failure
!= 0;
3540 /* Flush buffered characters to the callback. */
3543 d_print_flush (struct d_print_info
*dpi
)
3545 dpi
->buf
[dpi
->len
] = '\0';
3546 dpi
->callback (dpi
->buf
, dpi
->len
, dpi
->opaque
);
3551 /* Append characters and buffers for printing. */
3554 d_append_char (struct d_print_info
*dpi
, char c
)
3556 if (dpi
->len
== sizeof (dpi
->buf
) - 1)
3557 d_print_flush (dpi
);
3559 dpi
->buf
[dpi
->len
++] = c
;
3564 d_append_buffer (struct d_print_info
*dpi
, const char *s
, size_t l
)
3568 for (i
= 0; i
< l
; i
++)
3569 d_append_char (dpi
, s
[i
]);
3573 d_append_string (struct d_print_info
*dpi
, const char *s
)
3575 d_append_buffer (dpi
, s
, strlen (s
));
3579 d_append_num (struct d_print_info
*dpi
, long l
)
3582 sprintf (buf
,"%ld", l
);
3583 d_append_string (dpi
, buf
);
3587 d_last_char (struct d_print_info
*dpi
)
3589 return dpi
->last_char
;
3592 /* Turn components into a human readable string. OPTIONS is the
3593 options bits passed to the demangler. DC is the tree to print.
3594 CALLBACK is a function to call to flush demangled string segments
3595 as they fill the intermediate buffer, and OPAQUE is a generalized
3596 callback argument. On success, this returns 1. On failure,
3597 it returns 0, indicating a bad parse. It does not use heap
3598 memory to build an output string, so cannot encounter memory
3599 allocation failure. */
3601 CP_STATIC_IF_GLIBCPP_V3
3603 cplus_demangle_print_callback (int options
,
3604 const struct demangle_component
*dc
,
3605 demangle_callbackref callback
, void *opaque
)
3607 struct d_print_info dpi
;
3609 d_print_init (&dpi
, callback
, opaque
);
3611 d_print_comp (&dpi
, options
, dc
);
3613 d_print_flush (&dpi
);
3615 return ! d_print_saw_error (&dpi
);
3618 /* Turn components into a human readable string. OPTIONS is the
3619 options bits passed to the demangler. DC is the tree to print.
3620 ESTIMATE is a guess at the length of the result. This returns a
3621 string allocated by malloc, or NULL on error. On success, this
3622 sets *PALC to the size of the allocated buffer. On failure, this
3623 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3626 CP_STATIC_IF_GLIBCPP_V3
3628 cplus_demangle_print (int options
, const struct demangle_component
*dc
,
3629 int estimate
, size_t *palc
)
3631 struct d_growable_string dgs
;
3633 d_growable_string_init (&dgs
, estimate
);
3635 if (! cplus_demangle_print_callback (options
, dc
,
3636 d_growable_string_callback_adapter
,
3644 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
3648 /* Returns the I'th element of the template arglist ARGS, or NULL on
3651 static struct demangle_component
*
3652 d_index_template_argument (struct demangle_component
*args
, int i
)
3654 struct demangle_component
*a
;
3660 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3666 if (i
!= 0 || a
== NULL
)
3672 /* Returns the template argument from the current context indicated by DC,
3673 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3675 static struct demangle_component
*
3676 d_lookup_template_argument (struct d_print_info
*dpi
,
3677 const struct demangle_component
*dc
)
3679 if (dpi
->templates
== NULL
)
3681 d_print_error (dpi
);
3685 return d_index_template_argument
3686 (d_right (dpi
->templates
->template_decl
),
3687 dc
->u
.s_number
.number
);
3690 /* Returns a template argument pack used in DC (any will do), or NULL. */
3692 static struct demangle_component
*
3693 d_find_pack (struct d_print_info
*dpi
,
3694 const struct demangle_component
*dc
)
3696 struct demangle_component
*a
;
3702 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3703 a
= d_lookup_template_argument (dpi
, dc
);
3704 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3708 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
3711 case DEMANGLE_COMPONENT_LAMBDA
:
3712 case DEMANGLE_COMPONENT_NAME
:
3713 case DEMANGLE_COMPONENT_OPERATOR
:
3714 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3715 case DEMANGLE_COMPONENT_SUB_STD
:
3716 case DEMANGLE_COMPONENT_CHARACTER
:
3717 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
3718 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
3721 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3722 return d_find_pack (dpi
, dc
->u
.s_extended_operator
.name
);
3723 case DEMANGLE_COMPONENT_CTOR
:
3724 return d_find_pack (dpi
, dc
->u
.s_ctor
.name
);
3725 case DEMANGLE_COMPONENT_DTOR
:
3726 return d_find_pack (dpi
, dc
->u
.s_dtor
.name
);
3729 a
= d_find_pack (dpi
, d_left (dc
));
3732 return d_find_pack (dpi
, d_right (dc
));
3736 /* Returns the length of the template argument pack DC. */
3739 d_pack_length (const struct demangle_component
*dc
)
3742 while (dc
&& dc
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3743 && d_left (dc
) != NULL
)
3751 /* DC is a component of a mangled expression. Print it, wrapped in parens
3755 d_print_subexpr (struct d_print_info
*dpi
, int options
,
3756 const struct demangle_component
*dc
)
3759 if (dc
->type
== DEMANGLE_COMPONENT_NAME
3760 || dc
->type
== DEMANGLE_COMPONENT_QUAL_NAME
3761 || dc
->type
== DEMANGLE_COMPONENT_INITIALIZER_LIST
3762 || dc
->type
== DEMANGLE_COMPONENT_FUNCTION_PARAM
)
3765 d_append_char (dpi
, '(');
3766 d_print_comp (dpi
, options
, dc
);
3768 d_append_char (dpi
, ')');
3771 /* Subroutine to handle components. */
3774 d_print_comp (struct d_print_info
*dpi
, int options
,
3775 const struct demangle_component
*dc
)
3777 /* Magic variable to let reference smashing skip over the next modifier
3778 without needing to modify *dc. */
3779 const struct demangle_component
*mod_inner
= NULL
;
3783 d_print_error (dpi
);
3786 if (d_print_saw_error (dpi
))
3791 case DEMANGLE_COMPONENT_NAME
:
3792 if ((options
& DMGL_JAVA
) == 0)
3793 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3795 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
3798 case DEMANGLE_COMPONENT_QUAL_NAME
:
3799 case DEMANGLE_COMPONENT_LOCAL_NAME
:
3800 d_print_comp (dpi
, options
, d_left (dc
));
3801 if ((options
& DMGL_JAVA
) == 0)
3802 d_append_string (dpi
, "::");
3804 d_append_char (dpi
, '.');
3805 d_print_comp (dpi
, options
, d_right (dc
));
3808 case DEMANGLE_COMPONENT_TYPED_NAME
:
3810 struct d_print_mod
*hold_modifiers
;
3811 struct demangle_component
*typed_name
;
3812 struct d_print_mod adpm
[4];
3814 struct d_print_template dpt
;
3816 /* Pass the name down to the type so that it can be printed in
3817 the right place for the type. We also have to pass down
3818 any CV-qualifiers, which apply to the this parameter. */
3819 hold_modifiers
= dpi
->modifiers
;
3822 typed_name
= d_left (dc
);
3823 while (typed_name
!= NULL
)
3825 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3827 d_print_error (dpi
);
3831 adpm
[i
].next
= dpi
->modifiers
;
3832 dpi
->modifiers
= &adpm
[i
];
3833 adpm
[i
].mod
= typed_name
;
3834 adpm
[i
].printed
= 0;
3835 adpm
[i
].templates
= dpi
->templates
;
3838 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
3839 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
3840 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
)
3843 typed_name
= d_left (typed_name
);
3846 if (typed_name
== NULL
)
3848 d_print_error (dpi
);
3852 /* If typed_name is a template, then it applies to the
3853 function type as well. */
3854 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
3856 dpt
.next
= dpi
->templates
;
3857 dpi
->templates
= &dpt
;
3858 dpt
.template_decl
= typed_name
;
3861 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3862 there may be CV-qualifiers on its right argument which
3863 really apply here; this happens when parsing a class which
3864 is local to a function. */
3865 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
3867 struct demangle_component
*local_name
;
3869 local_name
= d_right (typed_name
);
3870 if (local_name
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
3871 local_name
= local_name
->u
.s_unary_num
.sub
;
3872 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3873 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3874 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
3876 if (i
>= sizeof adpm
/ sizeof adpm
[0])
3878 d_print_error (dpi
);
3882 adpm
[i
] = adpm
[i
- 1];
3883 adpm
[i
].next
= &adpm
[i
- 1];
3884 dpi
->modifiers
= &adpm
[i
];
3886 adpm
[i
- 1].mod
= local_name
;
3887 adpm
[i
- 1].printed
= 0;
3888 adpm
[i
- 1].templates
= dpi
->templates
;
3891 local_name
= d_left (local_name
);
3895 d_print_comp (dpi
, options
, d_right (dc
));
3897 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
3898 dpi
->templates
= dpt
.next
;
3900 /* If the modifiers didn't get printed by the type, print them
3905 if (! adpm
[i
].printed
)
3907 d_append_char (dpi
, ' ');
3908 d_print_mod (dpi
, options
, adpm
[i
].mod
);
3912 dpi
->modifiers
= hold_modifiers
;
3917 case DEMANGLE_COMPONENT_TEMPLATE
:
3919 struct d_print_mod
*hold_dpm
;
3920 struct demangle_component
*dcl
;
3922 /* Don't push modifiers into a template definition. Doing so
3923 could give the wrong definition for a template argument.
3924 Instead, treat the template essentially as a name. */
3926 hold_dpm
= dpi
->modifiers
;
3927 dpi
->modifiers
= NULL
;
3931 if ((options
& DMGL_JAVA
) != 0
3932 && dcl
->type
== DEMANGLE_COMPONENT_NAME
3933 && dcl
->u
.s_name
.len
== 6
3934 && strncmp (dcl
->u
.s_name
.s
, "JArray", 6) == 0)
3936 /* Special-case Java arrays, so that JArray<TYPE> appears
3937 instead as TYPE[]. */
3939 d_print_comp (dpi
, options
, d_right (dc
));
3940 d_append_string (dpi
, "[]");
3944 d_print_comp (dpi
, options
, dcl
);
3945 if (d_last_char (dpi
) == '<')
3946 d_append_char (dpi
, ' ');
3947 d_append_char (dpi
, '<');
3948 d_print_comp (dpi
, options
, d_right (dc
));
3949 /* Avoid generating two consecutive '>' characters, to avoid
3950 the C++ syntactic ambiguity. */
3951 if (d_last_char (dpi
) == '>')
3952 d_append_char (dpi
, ' ');
3953 d_append_char (dpi
, '>');
3956 dpi
->modifiers
= hold_dpm
;
3961 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
3963 struct d_print_template
*hold_dpt
;
3964 struct demangle_component
*a
= d_lookup_template_argument (dpi
, dc
);
3966 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
3967 a
= d_index_template_argument (a
, dpi
->pack_index
);
3971 d_print_error (dpi
);
3975 /* While processing this parameter, we need to pop the list of
3976 templates. This is because the template parameter may
3977 itself be a reference to a parameter of an outer
3980 hold_dpt
= dpi
->templates
;
3981 dpi
->templates
= hold_dpt
->next
;
3983 d_print_comp (dpi
, options
, a
);
3985 dpi
->templates
= hold_dpt
;
3990 case DEMANGLE_COMPONENT_CTOR
:
3991 d_print_comp (dpi
, options
, dc
->u
.s_ctor
.name
);
3994 case DEMANGLE_COMPONENT_DTOR
:
3995 d_append_char (dpi
, '~');
3996 d_print_comp (dpi
, options
, dc
->u
.s_dtor
.name
);
3999 case DEMANGLE_COMPONENT_VTABLE
:
4000 d_append_string (dpi
, "vtable for ");
4001 d_print_comp (dpi
, options
, d_left (dc
));
4004 case DEMANGLE_COMPONENT_VTT
:
4005 d_append_string (dpi
, "VTT for ");
4006 d_print_comp (dpi
, options
, d_left (dc
));
4009 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
4010 d_append_string (dpi
, "construction vtable for ");
4011 d_print_comp (dpi
, options
, d_left (dc
));
4012 d_append_string (dpi
, "-in-");
4013 d_print_comp (dpi
, options
, d_right (dc
));
4016 case DEMANGLE_COMPONENT_TYPEINFO
:
4017 d_append_string (dpi
, "typeinfo for ");
4018 d_print_comp (dpi
, options
, d_left (dc
));
4021 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
4022 d_append_string (dpi
, "typeinfo name for ");
4023 d_print_comp (dpi
, options
, d_left (dc
));
4026 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
4027 d_append_string (dpi
, "typeinfo fn for ");
4028 d_print_comp (dpi
, options
, d_left (dc
));
4031 case DEMANGLE_COMPONENT_THUNK
:
4032 d_append_string (dpi
, "non-virtual thunk to ");
4033 d_print_comp (dpi
, options
, d_left (dc
));
4036 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
4037 d_append_string (dpi
, "virtual thunk to ");
4038 d_print_comp (dpi
, options
, d_left (dc
));
4041 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
4042 d_append_string (dpi
, "covariant return thunk to ");
4043 d_print_comp (dpi
, options
, d_left (dc
));
4046 case DEMANGLE_COMPONENT_JAVA_CLASS
:
4047 d_append_string (dpi
, "java Class for ");
4048 d_print_comp (dpi
, options
, d_left (dc
));
4051 case DEMANGLE_COMPONENT_GUARD
:
4052 d_append_string (dpi
, "guard variable for ");
4053 d_print_comp (dpi
, options
, d_left (dc
));
4056 case DEMANGLE_COMPONENT_REFTEMP
:
4057 d_append_string (dpi
, "reference temporary #");
4058 d_print_comp (dpi
, options
, d_right (dc
));
4059 d_append_string (dpi
, " for ");
4060 d_print_comp (dpi
, options
, d_left (dc
));
4063 case DEMANGLE_COMPONENT_HIDDEN_ALIAS
:
4064 d_append_string (dpi
, "hidden alias for ");
4065 d_print_comp (dpi
, options
, d_left (dc
));
4068 case DEMANGLE_COMPONENT_TRANSACTION_CLONE
:
4069 d_append_string (dpi
, "transaction clone for ");
4070 d_print_comp (dpi
, options
, d_left (dc
));
4073 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE
:
4074 d_append_string (dpi
, "non-transaction clone for ");
4075 d_print_comp (dpi
, options
, d_left (dc
));
4078 case DEMANGLE_COMPONENT_SUB_STD
:
4079 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
4082 case DEMANGLE_COMPONENT_RESTRICT
:
4083 case DEMANGLE_COMPONENT_VOLATILE
:
4084 case DEMANGLE_COMPONENT_CONST
:
4086 struct d_print_mod
*pdpm
;
4088 /* When printing arrays, it's possible to have cases where the
4089 same CV-qualifier gets pushed on the stack multiple times.
4090 We only need to print it once. */
4092 for (pdpm
= dpi
->modifiers
; pdpm
!= NULL
; pdpm
= pdpm
->next
)
4094 if (! pdpm
->printed
)
4096 if (pdpm
->mod
->type
!= DEMANGLE_COMPONENT_RESTRICT
4097 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_VOLATILE
4098 && pdpm
->mod
->type
!= DEMANGLE_COMPONENT_CONST
)
4100 if (pdpm
->mod
->type
== dc
->type
)
4102 d_print_comp (dpi
, options
, d_left (dc
));
4110 case DEMANGLE_COMPONENT_REFERENCE
:
4111 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4113 /* Handle reference smashing: & + && = &. */
4114 const struct demangle_component
*sub
= d_left (dc
);
4115 if (sub
->type
== DEMANGLE_COMPONENT_TEMPLATE_PARAM
)
4117 struct demangle_component
*a
= d_lookup_template_argument (dpi
, sub
);
4118 if (a
&& a
->type
== DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
4119 a
= d_index_template_argument (a
, dpi
->pack_index
);
4123 d_print_error (dpi
);
4130 if (sub
->type
== DEMANGLE_COMPONENT_REFERENCE
4131 || sub
->type
== dc
->type
)
4133 else if (sub
->type
== DEMANGLE_COMPONENT_RVALUE_REFERENCE
)
4134 mod_inner
= d_left (sub
);
4138 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4139 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4140 case DEMANGLE_COMPONENT_CONST_THIS
:
4141 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4142 case DEMANGLE_COMPONENT_POINTER
:
4143 case DEMANGLE_COMPONENT_COMPLEX
:
4144 case DEMANGLE_COMPONENT_IMAGINARY
:
4147 /* We keep a list of modifiers on the stack. */
4148 struct d_print_mod dpm
;
4150 dpm
.next
= dpi
->modifiers
;
4151 dpi
->modifiers
= &dpm
;
4154 dpm
.templates
= dpi
->templates
;
4157 mod_inner
= d_left (dc
);
4159 d_print_comp (dpi
, options
, mod_inner
);
4161 /* If the modifier didn't get printed by the type, print it
4164 d_print_mod (dpi
, options
, dc
);
4166 dpi
->modifiers
= dpm
.next
;
4171 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
4172 if ((options
& DMGL_JAVA
) == 0)
4173 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
4174 dc
->u
.s_builtin
.type
->len
);
4176 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
4177 dc
->u
.s_builtin
.type
->java_len
);
4180 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
4181 d_print_comp (dpi
, options
, d_left (dc
));
4184 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
4186 if ((options
& DMGL_RET_POSTFIX
) != 0)
4187 d_print_function_type (dpi
,
4188 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4189 dc
, dpi
->modifiers
);
4191 /* Print return type if present */
4192 if (d_left (dc
) != NULL
&& (options
& DMGL_RET_POSTFIX
) != 0)
4193 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4195 else if (d_left (dc
) != NULL
&& (options
& DMGL_RET_DROP
) == 0)
4197 struct d_print_mod dpm
;
4199 /* We must pass this type down as a modifier in order to
4200 print it in the right location. */
4201 dpm
.next
= dpi
->modifiers
;
4202 dpi
->modifiers
= &dpm
;
4205 dpm
.templates
= dpi
->templates
;
4207 d_print_comp (dpi
, options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4210 dpi
->modifiers
= dpm
.next
;
4215 /* In standard prefix notation, there is a space between the
4216 return type and the function signature. */
4217 if ((options
& DMGL_RET_POSTFIX
) == 0)
4218 d_append_char (dpi
, ' ');
4221 if ((options
& DMGL_RET_POSTFIX
) == 0)
4222 d_print_function_type (dpi
,
4223 options
& ~(DMGL_RET_POSTFIX
| DMGL_RET_DROP
),
4224 dc
, dpi
->modifiers
);
4229 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
4231 struct d_print_mod
*hold_modifiers
;
4232 struct d_print_mod adpm
[4];
4234 struct d_print_mod
*pdpm
;
4236 /* We must pass this type down as a modifier in order to print
4237 multi-dimensional arrays correctly. If the array itself is
4238 CV-qualified, we act as though the element type were
4239 CV-qualified. We do this by copying the modifiers down
4240 rather than fiddling pointers, so that we don't wind up
4241 with a d_print_mod higher on the stack pointing into our
4242 stack frame after we return. */
4244 hold_modifiers
= dpi
->modifiers
;
4246 adpm
[0].next
= hold_modifiers
;
4247 dpi
->modifiers
= &adpm
[0];
4249 adpm
[0].printed
= 0;
4250 adpm
[0].templates
= dpi
->templates
;
4253 pdpm
= hold_modifiers
;
4255 && (pdpm
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT
4256 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE
4257 || pdpm
->mod
->type
== DEMANGLE_COMPONENT_CONST
))
4259 if (! pdpm
->printed
)
4261 if (i
>= sizeof adpm
/ sizeof adpm
[0])
4263 d_print_error (dpi
);
4268 adpm
[i
].next
= dpi
->modifiers
;
4269 dpi
->modifiers
= &adpm
[i
];
4277 d_print_comp (dpi
, options
, d_right (dc
));
4279 dpi
->modifiers
= hold_modifiers
;
4281 if (adpm
[0].printed
)
4287 d_print_mod (dpi
, options
, adpm
[i
].mod
);
4290 d_print_array_type (dpi
, options
, dc
, dpi
->modifiers
);
4295 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4296 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4298 struct d_print_mod dpm
;
4300 dpm
.next
= dpi
->modifiers
;
4301 dpi
->modifiers
= &dpm
;
4304 dpm
.templates
= dpi
->templates
;
4306 d_print_comp (dpi
, options
, d_right (dc
));
4308 /* If the modifier didn't get printed by the type, print it
4311 d_print_mod (dpi
, options
, dc
);
4313 dpi
->modifiers
= dpm
.next
;
4318 case DEMANGLE_COMPONENT_FIXED_TYPE
:
4319 if (dc
->u
.s_fixed
.sat
)
4320 d_append_string (dpi
, "_Sat ");
4321 /* Don't print "int _Accum". */
4322 if (dc
->u
.s_fixed
.length
->u
.s_builtin
.type
4323 != &cplus_demangle_builtin_types
['i'-'a'])
4325 d_print_comp (dpi
, options
, dc
->u
.s_fixed
.length
);
4326 d_append_char (dpi
, ' ');
4328 if (dc
->u
.s_fixed
.accum
)
4329 d_append_string (dpi
, "_Accum");
4331 d_append_string (dpi
, "_Fract");
4334 case DEMANGLE_COMPONENT_ARGLIST
:
4335 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
4336 if (d_left (dc
) != NULL
)
4337 d_print_comp (dpi
, options
, d_left (dc
));
4338 if (d_right (dc
) != NULL
)
4341 unsigned long int flush_count
;
4342 /* Make sure ", " isn't flushed by d_append_string, otherwise
4343 dpi->len -= 2 wouldn't work. */
4344 if (dpi
->len
>= sizeof (dpi
->buf
) - 2)
4345 d_print_flush (dpi
);
4346 d_append_string (dpi
, ", ");
4348 flush_count
= dpi
->flush_count
;
4349 d_print_comp (dpi
, options
, d_right (dc
));
4350 /* If that didn't print anything (which can happen with empty
4351 template argument packs), remove the comma and space. */
4352 if (dpi
->flush_count
== flush_count
&& dpi
->len
== len
)
4357 case DEMANGLE_COMPONENT_INITIALIZER_LIST
:
4359 struct demangle_component
*type
= d_left (dc
);
4360 struct demangle_component
*list
= d_right (dc
);
4363 d_print_comp (dpi
, options
, type
);
4364 d_append_char (dpi
, '{');
4365 d_print_comp (dpi
, options
, list
);
4366 d_append_char (dpi
, '}');
4370 case DEMANGLE_COMPONENT_OPERATOR
:
4372 const struct demangle_operator_info
*op
= dc
->u
.s_operator
.op
;
4375 d_append_string (dpi
, "operator");
4376 /* Add a space before new/delete. */
4377 if (IS_LOWER (op
->name
[0]))
4378 d_append_char (dpi
, ' ');
4379 /* Omit a trailing space. */
4380 if (op
->name
[len
-1] == ' ')
4382 d_append_buffer (dpi
, op
->name
, len
);
4386 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
4387 d_append_string (dpi
, "operator ");
4388 d_print_comp (dpi
, options
, dc
->u
.s_extended_operator
.name
);
4391 case DEMANGLE_COMPONENT_CAST
:
4392 d_append_string (dpi
, "operator ");
4393 d_print_cast (dpi
, options
, dc
);
4396 case DEMANGLE_COMPONENT_NULLARY
:
4397 d_print_expr_op (dpi
, options
, d_left (dc
));
4400 case DEMANGLE_COMPONENT_UNARY
:
4402 struct demangle_component
*op
= d_left (dc
);
4403 struct demangle_component
*operand
= d_right (dc
);
4404 const char *code
= NULL
;
4406 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
4408 code
= op
->u
.s_operator
.op
->code
;
4409 if (!strcmp (code
, "ad"))
4411 /* Don't print the argument list for the address of a
4413 if (operand
->type
== DEMANGLE_COMPONENT_TYPED_NAME
4414 && d_left (operand
)->type
== DEMANGLE_COMPONENT_QUAL_NAME
4415 && d_right (operand
)->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4416 operand
= d_left (operand
);
4418 if (operand
->type
== DEMANGLE_COMPONENT_BINARY_ARGS
)
4420 /* This indicates a suffix operator. */
4421 operand
= d_left (operand
);
4422 d_print_subexpr (dpi
, options
, operand
);
4423 d_print_expr_op (dpi
, options
, op
);
4428 if (op
->type
!= DEMANGLE_COMPONENT_CAST
)
4429 d_print_expr_op (dpi
, options
, op
);
4432 d_append_char (dpi
, '(');
4433 d_print_cast (dpi
, options
, op
);
4434 d_append_char (dpi
, ')');
4436 if (code
&& !strcmp (code
, "gs"))
4437 /* Avoid parens after '::'. */
4438 d_print_comp (dpi
, options
, operand
);
4439 else if (code
&& !strcmp (code
, "st"))
4440 /* Always print parens for sizeof (type). */
4442 d_append_char (dpi
, '(');
4443 d_print_comp (dpi
, options
, operand
);
4444 d_append_char (dpi
, ')');
4447 d_print_subexpr (dpi
, options
, operand
);
4451 case DEMANGLE_COMPONENT_BINARY
:
4452 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
4454 d_print_error (dpi
);
4458 /* We wrap an expression which uses the greater-than operator in
4459 an extra layer of parens so that it does not get confused
4460 with the '>' which ends the template parameters. */
4461 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4462 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4463 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4464 d_append_char (dpi
, '(');
4466 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") == 0
4467 && d_left (d_right (dc
))->type
== DEMANGLE_COMPONENT_TYPED_NAME
)
4469 /* Function call used in an expression should not have printed types
4470 of the function arguments. Values of the function arguments still
4471 get printed below. */
4473 const struct demangle_component
*func
= d_left (d_right (dc
));
4475 if (d_right (func
)->type
!= DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4476 d_print_error (dpi
);
4477 d_print_subexpr (dpi
, options
, d_left (func
));
4480 d_print_subexpr (dpi
, options
, d_left (d_right (dc
)));
4481 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "ix") == 0)
4483 d_append_char (dpi
, '[');
4484 d_print_comp (dpi
, options
, d_right (d_right (dc
)));
4485 d_append_char (dpi
, ']');
4489 if (strcmp (d_left (dc
)->u
.s_operator
.op
->code
, "cl") != 0)
4490 d_print_expr_op (dpi
, options
, d_left (dc
));
4491 d_print_subexpr (dpi
, options
, d_right (d_right (dc
)));
4494 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
4495 && d_left (dc
)->u
.s_operator
.op
->len
== 1
4496 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
4497 d_append_char (dpi
, ')');
4501 case DEMANGLE_COMPONENT_BINARY_ARGS
:
4502 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
4503 d_print_error (dpi
);
4506 case DEMANGLE_COMPONENT_TRINARY
:
4507 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
4508 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
4510 d_print_error (dpi
);
4514 struct demangle_component
*op
= d_left (dc
);
4515 struct demangle_component
*first
= d_left (d_right (dc
));
4516 struct demangle_component
*second
= d_left (d_right (d_right (dc
)));
4517 struct demangle_component
*third
= d_right (d_right (d_right (dc
)));
4519 if (!strcmp (op
->u
.s_operator
.op
->code
, "qu"))
4521 d_print_subexpr (dpi
, options
, first
);
4522 d_print_expr_op (dpi
, options
, op
);
4523 d_print_subexpr (dpi
, options
, second
);
4524 d_append_string (dpi
, " : ");
4525 d_print_subexpr (dpi
, options
, third
);
4529 d_append_string (dpi
, "new ");
4530 if (d_left (first
) != NULL
)
4532 d_print_subexpr (dpi
, options
, first
);
4533 d_append_char (dpi
, ' ');
4535 d_print_comp (dpi
, options
, second
);
4537 d_print_subexpr (dpi
, options
, third
);
4542 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
4543 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
4544 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
4545 d_print_error (dpi
);
4548 case DEMANGLE_COMPONENT_LITERAL
:
4549 case DEMANGLE_COMPONENT_LITERAL_NEG
:
4551 enum d_builtin_type_print tp
;
4553 /* For some builtin types, produce simpler output. */
4554 tp
= D_PRINT_DEFAULT
;
4555 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
4557 tp
= d_left (dc
)->u
.s_builtin
.type
->print
;
4561 case D_PRINT_UNSIGNED
:
4563 case D_PRINT_UNSIGNED_LONG
:
4564 case D_PRINT_LONG_LONG
:
4565 case D_PRINT_UNSIGNED_LONG_LONG
:
4566 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
4568 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4569 d_append_char (dpi
, '-');
4570 d_print_comp (dpi
, options
, d_right (dc
));
4575 case D_PRINT_UNSIGNED
:
4576 d_append_char (dpi
, 'u');
4579 d_append_char (dpi
, 'l');
4581 case D_PRINT_UNSIGNED_LONG
:
4582 d_append_string (dpi
, "ul");
4584 case D_PRINT_LONG_LONG
:
4585 d_append_string (dpi
, "ll");
4587 case D_PRINT_UNSIGNED_LONG_LONG
:
4588 d_append_string (dpi
, "ull");
4596 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
4597 && d_right (dc
)->u
.s_name
.len
== 1
4598 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
4600 switch (d_right (dc
)->u
.s_name
.s
[0])
4603 d_append_string (dpi
, "false");
4606 d_append_string (dpi
, "true");
4619 d_append_char (dpi
, '(');
4620 d_print_comp (dpi
, options
, d_left (dc
));
4621 d_append_char (dpi
, ')');
4622 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
4623 d_append_char (dpi
, '-');
4624 if (tp
== D_PRINT_FLOAT
)
4625 d_append_char (dpi
, '[');
4626 d_print_comp (dpi
, options
, d_right (dc
));
4627 if (tp
== D_PRINT_FLOAT
)
4628 d_append_char (dpi
, ']');
4632 case DEMANGLE_COMPONENT_NUMBER
:
4633 d_append_num (dpi
, dc
->u
.s_number
.number
);
4636 case DEMANGLE_COMPONENT_JAVA_RESOURCE
:
4637 d_append_string (dpi
, "java resource ");
4638 d_print_comp (dpi
, options
, d_left (dc
));
4641 case DEMANGLE_COMPONENT_COMPOUND_NAME
:
4642 d_print_comp (dpi
, options
, d_left (dc
));
4643 d_print_comp (dpi
, options
, d_right (dc
));
4646 case DEMANGLE_COMPONENT_CHARACTER
:
4647 d_append_char (dpi
, dc
->u
.s_character
.character
);
4650 case DEMANGLE_COMPONENT_DECLTYPE
:
4651 d_append_string (dpi
, "decltype (");
4652 d_print_comp (dpi
, options
, d_left (dc
));
4653 d_append_char (dpi
, ')');
4656 case DEMANGLE_COMPONENT_PACK_EXPANSION
:
4660 struct demangle_component
*a
= d_find_pack (dpi
, d_left (dc
));
4663 /* d_find_pack won't find anything if the only packs involved
4664 in this expansion are function parameter packs; in that
4665 case, just print the pattern and "...". */
4666 d_print_subexpr (dpi
, options
, d_left (dc
));
4667 d_append_string (dpi
, "...");
4671 len
= d_pack_length (a
);
4673 for (i
= 0; i
< len
; ++i
)
4675 dpi
->pack_index
= i
;
4676 d_print_comp (dpi
, options
, dc
);
4678 d_append_string (dpi
, ", ");
4683 case DEMANGLE_COMPONENT_FUNCTION_PARAM
:
4685 long num
= dc
->u
.s_number
.number
;
4687 d_append_string (dpi
, "this");
4690 d_append_string (dpi
, "{parm#");
4691 d_append_num (dpi
, num
);
4692 d_append_char (dpi
, '}');
4697 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
:
4698 d_append_string (dpi
, "global constructors keyed to ");
4699 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4702 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
:
4703 d_append_string (dpi
, "global destructors keyed to ");
4704 d_print_comp (dpi
, options
, dc
->u
.s_binary
.left
);
4707 case DEMANGLE_COMPONENT_LAMBDA
:
4708 d_append_string (dpi
, "{lambda(");
4709 d_print_comp (dpi
, options
, dc
->u
.s_unary_num
.sub
);
4710 d_append_string (dpi
, ")#");
4711 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
4712 d_append_char (dpi
, '}');
4715 case DEMANGLE_COMPONENT_UNNAMED_TYPE
:
4716 d_append_string (dpi
, "{unnamed type#");
4717 d_append_num (dpi
, dc
->u
.s_number
.number
+ 1);
4718 d_append_char (dpi
, '}');
4721 case DEMANGLE_COMPONENT_CLONE
:
4722 d_print_comp (dpi
, options
, d_left (dc
));
4723 d_append_string (dpi
, " [clone ");
4724 d_print_comp (dpi
, options
, d_right (dc
));
4725 d_append_char (dpi
, ']');
4729 d_print_error (dpi
);
4734 /* Print a Java dentifier. For Java we try to handle encoded extended
4735 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4736 so we don't it for C++. Characters are encoded as
4740 d_print_java_identifier (struct d_print_info
*dpi
, const char *name
, int len
)
4746 for (p
= name
; p
< end
; ++p
)
4757 for (q
= p
+ 3; q
< end
; ++q
)
4763 else if (*q
>= 'A' && *q
<= 'F')
4764 dig
= *q
- 'A' + 10;
4765 else if (*q
>= 'a' && *q
<= 'f')
4766 dig
= *q
- 'a' + 10;
4772 /* If the Unicode character is larger than 256, we don't try
4773 to deal with it here. FIXME. */
4774 if (q
< end
&& *q
== '_' && c
< 256)
4776 d_append_char (dpi
, c
);
4782 d_append_char (dpi
, *p
);
4786 /* Print a list of modifiers. SUFFIX is 1 if we are printing
4787 qualifiers on this after printing a function. */
4790 d_print_mod_list (struct d_print_info
*dpi
, int options
,
4791 struct d_print_mod
*mods
, int suffix
)
4793 struct d_print_template
*hold_dpt
;
4795 if (mods
== NULL
|| d_print_saw_error (dpi
))
4800 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
4801 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
4802 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
)))
4804 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
4810 hold_dpt
= dpi
->templates
;
4811 dpi
->templates
= mods
->templates
;
4813 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
4815 d_print_function_type (dpi
, options
, mods
->mod
, mods
->next
);
4816 dpi
->templates
= hold_dpt
;
4819 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
4821 d_print_array_type (dpi
, options
, mods
->mod
, mods
->next
);
4822 dpi
->templates
= hold_dpt
;
4825 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
4827 struct d_print_mod
*hold_modifiers
;
4828 struct demangle_component
*dc
;
4830 /* When this is on the modifier stack, we have pulled any
4831 qualifiers off the right argument already. Otherwise, we
4832 print it as usual, but don't let the left argument see any
4835 hold_modifiers
= dpi
->modifiers
;
4836 dpi
->modifiers
= NULL
;
4837 d_print_comp (dpi
, options
, d_left (mods
->mod
));
4838 dpi
->modifiers
= hold_modifiers
;
4840 if ((options
& DMGL_JAVA
) == 0)
4841 d_append_string (dpi
, "::");
4843 d_append_char (dpi
, '.');
4845 dc
= d_right (mods
->mod
);
4847 if (dc
->type
== DEMANGLE_COMPONENT_DEFAULT_ARG
)
4849 d_append_string (dpi
, "{default arg#");
4850 d_append_num (dpi
, dc
->u
.s_unary_num
.num
+ 1);
4851 d_append_string (dpi
, "}::");
4852 dc
= dc
->u
.s_unary_num
.sub
;
4855 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
4856 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
4857 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
4860 d_print_comp (dpi
, options
, dc
);
4862 dpi
->templates
= hold_dpt
;
4866 d_print_mod (dpi
, options
, mods
->mod
);
4868 dpi
->templates
= hold_dpt
;
4870 d_print_mod_list (dpi
, options
, mods
->next
, suffix
);
4873 /* Print a modifier. */
4876 d_print_mod (struct d_print_info
*dpi
, int options
,
4877 const struct demangle_component
*mod
)
4881 case DEMANGLE_COMPONENT_RESTRICT
:
4882 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4883 d_append_string (dpi
, " restrict");
4885 case DEMANGLE_COMPONENT_VOLATILE
:
4886 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4887 d_append_string (dpi
, " volatile");
4889 case DEMANGLE_COMPONENT_CONST
:
4890 case DEMANGLE_COMPONENT_CONST_THIS
:
4891 d_append_string (dpi
, " const");
4893 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4894 d_append_char (dpi
, ' ');
4895 d_print_comp (dpi
, options
, d_right (mod
));
4897 case DEMANGLE_COMPONENT_POINTER
:
4898 /* There is no pointer symbol in Java. */
4899 if ((options
& DMGL_JAVA
) == 0)
4900 d_append_char (dpi
, '*');
4902 case DEMANGLE_COMPONENT_REFERENCE
:
4903 d_append_char (dpi
, '&');
4905 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4906 d_append_string (dpi
, "&&");
4908 case DEMANGLE_COMPONENT_COMPLEX
:
4909 d_append_string (dpi
, "complex ");
4911 case DEMANGLE_COMPONENT_IMAGINARY
:
4912 d_append_string (dpi
, "imaginary ");
4914 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4915 if (d_last_char (dpi
) != '(')
4916 d_append_char (dpi
, ' ');
4917 d_print_comp (dpi
, options
, d_left (mod
));
4918 d_append_string (dpi
, "::*");
4920 case DEMANGLE_COMPONENT_TYPED_NAME
:
4921 d_print_comp (dpi
, options
, d_left (mod
));
4923 case DEMANGLE_COMPONENT_VECTOR_TYPE
:
4924 d_append_string (dpi
, " __vector(");
4925 d_print_comp (dpi
, options
, d_left (mod
));
4926 d_append_char (dpi
, ')');
4930 /* Otherwise, we have something that won't go back on the
4931 modifier stack, so we can just print it. */
4932 d_print_comp (dpi
, options
, mod
);
4937 /* Print a function type, except for the return type. */
4940 d_print_function_type (struct d_print_info
*dpi
, int options
,
4941 const struct demangle_component
*dc
,
4942 struct d_print_mod
*mods
)
4946 struct d_print_mod
*p
;
4947 struct d_print_mod
*hold_modifiers
;
4951 for (p
= mods
; p
!= NULL
; p
= p
->next
)
4956 switch (p
->mod
->type
)
4958 case DEMANGLE_COMPONENT_POINTER
:
4959 case DEMANGLE_COMPONENT_REFERENCE
:
4960 case DEMANGLE_COMPONENT_RVALUE_REFERENCE
:
4963 case DEMANGLE_COMPONENT_RESTRICT
:
4964 case DEMANGLE_COMPONENT_VOLATILE
:
4965 case DEMANGLE_COMPONENT_CONST
:
4966 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
4967 case DEMANGLE_COMPONENT_COMPLEX
:
4968 case DEMANGLE_COMPONENT_IMAGINARY
:
4969 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
4973 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4974 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4975 case DEMANGLE_COMPONENT_CONST_THIS
:
4988 if (d_last_char (dpi
) != '('
4989 && d_last_char (dpi
) != '*')
4992 if (need_space
&& d_last_char (dpi
) != ' ')
4993 d_append_char (dpi
, ' ');
4994 d_append_char (dpi
, '(');
4997 hold_modifiers
= dpi
->modifiers
;
4998 dpi
->modifiers
= NULL
;
5000 d_print_mod_list (dpi
, options
, mods
, 0);
5003 d_append_char (dpi
, ')');
5005 d_append_char (dpi
, '(');
5007 if (d_right (dc
) != NULL
)
5008 d_print_comp (dpi
, options
, d_right (dc
));
5010 d_append_char (dpi
, ')');
5012 d_print_mod_list (dpi
, options
, mods
, 1);
5014 dpi
->modifiers
= hold_modifiers
;
5017 /* Print an array type, except for the element type. */
5020 d_print_array_type (struct d_print_info
*dpi
, int options
,
5021 const struct demangle_component
*dc
,
5022 struct d_print_mod
*mods
)
5030 struct d_print_mod
*p
;
5033 for (p
= mods
; p
!= NULL
; p
= p
->next
)
5037 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
5052 d_append_string (dpi
, " (");
5054 d_print_mod_list (dpi
, options
, mods
, 0);
5057 d_append_char (dpi
, ')');
5061 d_append_char (dpi
, ' ');
5063 d_append_char (dpi
, '[');
5065 if (d_left (dc
) != NULL
)
5066 d_print_comp (dpi
, options
, d_left (dc
));
5068 d_append_char (dpi
, ']');
5071 /* Print an operator in an expression. */
5074 d_print_expr_op (struct d_print_info
*dpi
, int options
,
5075 const struct demangle_component
*dc
)
5077 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
5078 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
5079 dc
->u
.s_operator
.op
->len
);
5081 d_print_comp (dpi
, options
, dc
);
5087 d_print_cast (struct d_print_info
*dpi
, int options
,
5088 const struct demangle_component
*dc
)
5090 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
5091 d_print_comp (dpi
, options
, d_left (dc
));
5094 struct d_print_mod
*hold_dpm
;
5095 struct d_print_template dpt
;
5097 /* It appears that for a templated cast operator, we need to put
5098 the template parameters in scope for the operator name, but
5099 not for the parameters. The effect is that we need to handle
5100 the template printing here. */
5102 hold_dpm
= dpi
->modifiers
;
5103 dpi
->modifiers
= NULL
;
5105 dpt
.next
= dpi
->templates
;
5106 dpi
->templates
= &dpt
;
5107 dpt
.template_decl
= d_left (dc
);
5109 d_print_comp (dpi
, options
, d_left (d_left (dc
)));
5111 dpi
->templates
= dpt
.next
;
5113 if (d_last_char (dpi
) == '<')
5114 d_append_char (dpi
, ' ');
5115 d_append_char (dpi
, '<');
5116 d_print_comp (dpi
, options
, d_right (d_left (dc
)));
5117 /* Avoid generating two consecutive '>' characters, to avoid
5118 the C++ syntactic ambiguity. */
5119 if (d_last_char (dpi
) == '>')
5120 d_append_char (dpi
, ' ');
5121 d_append_char (dpi
, '>');
5123 dpi
->modifiers
= hold_dpm
;
5127 /* Initialize the information structure we use to pass around
5130 CP_STATIC_IF_GLIBCPP_V3
5132 cplus_demangle_init_info (const char *mangled
, int options
, size_t len
,
5136 di
->send
= mangled
+ len
;
5137 di
->options
= options
;
5141 /* We can not need more components than twice the number of chars in
5142 the mangled string. Most components correspond directly to
5143 chars, but the ARGLIST types are exceptions. */
5144 di
->num_comps
= 2 * len
;
5147 /* Similarly, we can not need more substitutions than there are
5148 chars in the mangled string. */
5153 di
->last_name
= NULL
;
5158 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
5159 mangled name, return strings in repeated callback giving the demangled
5160 name. OPTIONS is the usual libiberty demangler options. On success,
5161 this returns 1. On failure, returns 0. */
5164 d_demangle_callback (const char *mangled
, int options
,
5165 demangle_callbackref callback
, void *opaque
)
5176 struct demangle_component
*dc
;
5179 if (mangled
[0] == '_' && mangled
[1] == 'Z')
5181 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
5182 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
5183 && (mangled
[9] == 'D' || mangled
[9] == 'I')
5184 && mangled
[10] == '_')
5185 type
= mangled
[9] == 'I' ? DCT_GLOBAL_CTORS
: DCT_GLOBAL_DTORS
;
5188 if ((options
& DMGL_TYPES
) == 0)
5193 cplus_demangle_init_info (mangled
, options
, strlen (mangled
), &di
);
5196 #ifdef CP_DYNAMIC_ARRAYS
5197 __extension__
struct demangle_component comps
[di
.num_comps
];
5198 __extension__
struct demangle_component
*subs
[di
.num_subs
];
5203 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
5204 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
5210 dc
= cplus_demangle_type (&di
);
5213 dc
= cplus_demangle_mangled_name (&di
, 1);
5215 case DCT_GLOBAL_CTORS
:
5216 case DCT_GLOBAL_DTORS
:
5217 d_advance (&di
, 11);
5218 dc
= d_make_comp (&di
,
5219 (type
== DCT_GLOBAL_CTORS
5220 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
5221 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS
),
5222 d_make_demangle_mangled_name (&di
, d_str (&di
)),
5224 d_advance (&di
, strlen (d_str (&di
)));
5228 /* If DMGL_PARAMS is set, then if we didn't consume the entire
5229 mangled string, then we didn't successfully demangle it. If
5230 DMGL_PARAMS is not set, we didn't look at the trailing
5232 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
5235 #ifdef CP_DEMANGLE_DEBUG
5239 status
= (dc
!= NULL
)
5240 ? cplus_demangle_print_callback (options
, dc
, callback
, opaque
)
5247 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
5248 name, return a buffer allocated with malloc holding the demangled
5249 name. OPTIONS is the usual libiberty demangler options. On
5250 success, this sets *PALC to the allocated size of the returned
5251 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
5252 a memory allocation failure, and returns NULL. */
5255 d_demangle (const char *mangled
, int options
, size_t *palc
)
5257 struct d_growable_string dgs
;
5260 d_growable_string_init (&dgs
, 0);
5262 status
= d_demangle_callback (mangled
, options
,
5263 d_growable_string_callback_adapter
, &dgs
);
5271 *palc
= dgs
.allocation_failure
? 1 : dgs
.alc
;
5275 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
5277 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
5279 /* ia64 ABI-mandated entry point in the C++ runtime library for
5280 performing demangling. MANGLED_NAME is a NUL-terminated character
5281 string containing the name to be demangled.
5283 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
5284 *LENGTH bytes, into which the demangled name is stored. If
5285 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
5286 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
5287 is placed in a region of memory allocated with malloc.
5289 If LENGTH is non-NULL, the length of the buffer containing the
5290 demangled name, is placed in *LENGTH.
5292 The return value is a pointer to the start of the NUL-terminated
5293 demangled name, or NULL if the demangling fails. The caller is
5294 responsible for deallocating this memory using free.
5296 *STATUS is set to one of the following values:
5297 0: The demangling operation succeeded.
5298 -1: A memory allocation failure occurred.
5299 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5300 -3: One of the arguments is invalid.
5302 The demangling is performed using the C++ ABI mangling rules, with
5306 __cxa_demangle (const char *mangled_name
, char *output_buffer
,
5307 size_t *length
, int *status
)
5312 if (mangled_name
== NULL
)
5319 if (output_buffer
!= NULL
&& length
== NULL
)
5326 demangled
= d_demangle (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
, &alc
);
5328 if (demangled
== NULL
)
5340 if (output_buffer
== NULL
)
5347 if (strlen (demangled
) < *length
)
5349 strcpy (output_buffer
, demangled
);
5351 demangled
= output_buffer
;
5355 free (output_buffer
);
5366 extern int __gcclibcxx_demangle_callback (const char *,
5368 (const char *, size_t, void *),
5371 /* Alternative, allocationless entry point in the C++ runtime library
5372 for performing demangling. MANGLED_NAME is a NUL-terminated character
5373 string containing the name to be demangled.
5375 CALLBACK is a callback function, called with demangled string
5376 segments as demangling progresses; it is called at least once,
5377 but may be called more than once. OPAQUE is a generalized pointer
5378 used as a callback argument.
5380 The return code is one of the following values, equivalent to
5381 the STATUS values of __cxa_demangle() (excluding -1, since this
5382 function performs no memory allocations):
5383 0: The demangling operation succeeded.
5384 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5385 -3: One of the arguments is invalid.
5387 The demangling is performed using the C++ ABI mangling rules, with
5391 __gcclibcxx_demangle_callback (const char *mangled_name
,
5392 void (*callback
) (const char *, size_t, void *),
5397 if (mangled_name
== NULL
|| callback
== NULL
)
5400 status
= d_demangle_callback (mangled_name
, DMGL_PARAMS
| DMGL_TYPES
,
5408 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5410 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
5411 mangled name, return a buffer allocated with malloc holding the
5412 demangled name. Otherwise, return NULL. */
5415 cplus_demangle_v3 (const char *mangled
, int options
)
5419 return d_demangle (mangled
, options
, &alc
);
5423 cplus_demangle_v3_callback (const char *mangled
, int options
,
5424 demangle_callbackref callback
, void *opaque
)
5426 return d_demangle_callback (mangled
, options
, callback
, opaque
);
5429 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
5430 conventions, but the output formatting is a little different.
5431 This instructs the C++ demangler not to emit pointer characters ("*"), to
5432 use Java's namespace separator symbol ("." instead of "::"), and to output
5433 JArray<TYPE> as TYPE[]. */
5436 java_demangle_v3 (const char *mangled
)
5440 return d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
, &alc
);
5444 java_demangle_v3_callback (const char *mangled
,
5445 demangle_callbackref callback
, void *opaque
)
5447 return d_demangle_callback (mangled
,
5448 DMGL_JAVA
| DMGL_PARAMS
| DMGL_RET_POSTFIX
,
5452 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5454 #ifndef IN_GLIBCPP_V3
5456 /* Demangle a string in order to find out whether it is a constructor
5457 or destructor. Return non-zero on success. Set *CTOR_KIND and
5458 *DTOR_KIND appropriately. */
5461 is_ctor_or_dtor (const char *mangled
,
5462 enum gnu_v3_ctor_kinds
*ctor_kind
,
5463 enum gnu_v3_dtor_kinds
*dtor_kind
)
5466 struct demangle_component
*dc
;
5469 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
5470 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
5472 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
5475 #ifdef CP_DYNAMIC_ARRAYS
5476 __extension__
struct demangle_component comps
[di
.num_comps
];
5477 __extension__
struct demangle_component
*subs
[di
.num_subs
];
5482 di
.comps
= alloca (di
.num_comps
* sizeof (*di
.comps
));
5483 di
.subs
= alloca (di
.num_subs
* sizeof (*di
.subs
));
5486 dc
= cplus_demangle_mangled_name (&di
, 1);
5488 /* Note that because we did not pass DMGL_PARAMS, we don't expect
5489 to demangle the entire string. */
5499 case DEMANGLE_COMPONENT_TYPED_NAME
:
5500 case DEMANGLE_COMPONENT_TEMPLATE
:
5501 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
5502 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
5503 case DEMANGLE_COMPONENT_CONST_THIS
:
5506 case DEMANGLE_COMPONENT_QUAL_NAME
:
5507 case DEMANGLE_COMPONENT_LOCAL_NAME
:
5510 case DEMANGLE_COMPONENT_CTOR
:
5511 *ctor_kind
= dc
->u
.s_ctor
.kind
;
5515 case DEMANGLE_COMPONENT_DTOR
:
5516 *dtor_kind
= dc
->u
.s_dtor
.kind
;
5527 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5528 name. A non-zero return indicates the type of constructor. */
5530 enum gnu_v3_ctor_kinds
5531 is_gnu_v3_mangled_ctor (const char *name
)
5533 enum gnu_v3_ctor_kinds ctor_kind
;
5534 enum gnu_v3_dtor_kinds dtor_kind
;
5536 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5537 return (enum gnu_v3_ctor_kinds
) 0;
5542 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5543 name. A non-zero return indicates the type of destructor. */
5545 enum gnu_v3_dtor_kinds
5546 is_gnu_v3_mangled_dtor (const char *name
)
5548 enum gnu_v3_ctor_kinds ctor_kind
;
5549 enum gnu_v3_dtor_kinds dtor_kind
;
5551 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
5552 return (enum gnu_v3_dtor_kinds
) 0;
5556 #endif /* IN_GLIBCPP_V3 */
5558 #ifdef STANDALONE_DEMANGLER
5561 #include "dyn-string.h"
5563 static void print_usage (FILE* fp
, int exit_value
);
5565 #define IS_ALPHA(CHAR) \
5566 (((CHAR) >= 'a' && (CHAR) <= 'z') \
5567 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5569 /* Non-zero if CHAR is a character than can occur in a mangled name. */
5570 #define is_mangled_char(CHAR) \
5571 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
5572 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5574 /* The name of this program, as invoked. */
5575 const char* program_name
;
5577 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
5580 print_usage (FILE* fp
, int exit_value
)
5582 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
5583 fprintf (fp
, "Options:\n");
5584 fprintf (fp
, " -h,--help Display this message.\n");
5585 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
5586 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
5587 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
5592 /* Option specification for getopt_long. */
5593 static const struct option long_options
[] =
5595 { "help", no_argument
, NULL
, 'h' },
5596 { "no-params", no_argument
, NULL
, 'p' },
5597 { "verbose", no_argument
, NULL
, 'v' },
5598 { NULL
, no_argument
, NULL
, 0 },
5601 /* Main entry for a demangling filter executable. It will demangle
5602 its command line arguments, if any. If none are provided, it will
5603 filter stdin to stdout, replacing any recognized mangled C++ names
5604 with their demangled equivalents. */
5607 main (int argc
, char *argv
[])
5611 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
5613 /* Use the program name of this program, as invoked. */
5614 program_name
= argv
[0];
5616 /* Parse options. */
5619 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
5622 case '?': /* Unrecognized option. */
5623 print_usage (stderr
, 1);
5627 print_usage (stdout
, 0);
5631 options
&= ~ DMGL_PARAMS
;
5635 options
|= DMGL_VERBOSE
;
5639 while (opt_char
!= -1);
5642 /* No command line arguments were provided. Filter stdin. */
5644 dyn_string_t mangled
= dyn_string_new (3);
5647 /* Read all of input. */
5648 while (!feof (stdin
))
5652 /* Pile characters into mangled until we hit one that can't
5653 occur in a mangled name. */
5655 while (!feof (stdin
) && is_mangled_char (c
))
5657 dyn_string_append_char (mangled
, c
);
5663 if (dyn_string_length (mangled
) > 0)
5665 #ifdef IN_GLIBCPP_V3
5666 s
= __cxa_demangle (dyn_string_buf (mangled
), NULL
, NULL
, NULL
);
5668 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
5678 /* It might not have been a mangled name. Print the
5680 fputs (dyn_string_buf (mangled
), stdout
);
5683 dyn_string_clear (mangled
);
5686 /* If we haven't hit EOF yet, we've read one character that
5687 can't occur in a mangled name, so print it out. */
5692 dyn_string_delete (mangled
);
5695 /* Demangle command line arguments. */
5697 /* Loop over command line arguments. */
5698 for (i
= optind
; i
< argc
; ++i
)
5701 #ifdef IN_GLIBCPP_V3
5705 /* Attempt to demangle. */
5706 #ifdef IN_GLIBCPP_V3
5707 s
= __cxa_demangle (argv
[i
], NULL
, NULL
, &status
);
5709 s
= cplus_demangle_v3 (argv
[i
], options
);
5712 /* If it worked, print the demangled name. */
5720 #ifdef IN_GLIBCPP_V3
5721 fprintf (stderr
, "Failed: %s (status %d)\n", argv
[i
], status
);
5723 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
5732 #endif /* STANDALONE_DEMANGLER */