1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 http://www.codesourcery.com/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
42 This file will normally define the following functions, q.v.:
43 char *cplus_demangle_v3(const char *mangled, int options)
44 char *java_demangle_v3(const char *mangled)
45 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
46 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
48 Also, the interface to the component list is public, and defined in
49 demangle.h. The interface consists of these types, which are
50 defined in demangle.h:
51 enum demangle_component_type
52 struct demangle_component
53 and these functions defined in this file:
54 cplus_demangle_fill_name
55 cplus_demangle_fill_extended_operator
56 cplus_demangle_fill_ctor
57 cplus_demangle_fill_dtor
59 and other functions defined in the file cp-demint.c.
61 This file also defines some other functions and variables which are
62 only to be used by the file cp-demint.c.
64 Preprocessor macros you can define while compiling this file:
67 If defined, this file defines the following function, q.v.:
68 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
70 instead of cplus_demangle_v3() and java_demangle_v3().
73 If defined, this file defines only __cxa_demangle(), and no other
74 publically visible functions or variables.
77 If defined, this file defines a main() function which demangles
78 any arguments, or, if none, demangles stdin.
81 If defined, turns on debugging mode, which prints information on
82 stdout about the mangled string. This is not generally useful.
99 #include "libiberty.h"
100 #include "demangle.h"
101 #include "cp-demangle.h"
103 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
104 also rename them via #define to avoid compiler errors when the
105 static definition conflicts with the extern declaration in a header
109 #define CP_STATIC_IF_GLIBCPP_V3 static
111 #define cplus_demangle_fill_name d_fill_name
113 d_fill_name
PARAMS ((struct demangle_component
*, const char *, int));
115 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
117 d_fill_extended_operator
PARAMS ((struct demangle_component
*, int,
118 struct demangle_component
*));
120 #define cplus_demangle_fill_ctor d_fill_ctor
122 d_fill_ctor
PARAMS ((struct demangle_component
*, enum gnu_v3_ctor_kinds
,
123 struct demangle_component
*));
125 #define cplus_demangle_fill_dtor d_fill_dtor
127 d_fill_dtor
PARAMS ((struct demangle_component
*, enum gnu_v3_dtor_kinds
,
128 struct demangle_component
*));
130 #define cplus_demangle_mangled_name d_mangled_name
131 static struct demangle_component
*
132 d_mangled_name
PARAMS ((struct d_info
*, int));
134 #define cplus_demangle_type d_type
135 static struct demangle_component
*
136 d_type
PARAMS ((struct d_info
*));
138 #define cplus_demangle_print d_print
140 d_print
PARAMS ((int, const struct demangle_component
*, int, size_t *));
142 #define cplus_demangle_init_info d_init_info
144 d_init_info
PARAMS ((const char *, int, size_t, struct d_info
*));
146 #else /* ! defined(IN_GLIBCPP_V3) */
147 #define CP_STATIC_IF_GLIBCPP_V3
148 #endif /* ! defined(IN_GLIBCPP_V3) */
150 /* See if the compiler supports dynamic arrays. */
153 #define CP_DYNAMIC_ARRAYS
156 #ifdef __STDC_VERSION__
157 #if __STDC_VERSION__ >= 199901L
158 #define CP_DYNAMIC_ARRAYS
159 #endif /* __STDC__VERSION >= 199901L */
160 #endif /* defined (__STDC_VERSION__) */
161 #endif /* defined (__STDC__) */
162 #endif /* ! defined (__GNUC__) */
164 /* We avoid pulling in the ctype tables, to prevent pulling in
165 additional unresolved symbols when this code is used in a library.
166 FIXME: Is this really a valid reason? This comes from the original
169 As of this writing this file has the following undefined references
170 when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy,
171 strcpy, strcat, strlen. */
173 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
174 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
175 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
177 /* The prefix prepended by GCC to an identifier represnting the
178 anonymous namespace. */
179 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
180 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
181 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
183 /* Information we keep for the standard substitutions. */
185 struct d_standard_sub_info
187 /* The code for this substitution. */
189 /* The simple string it expands to. */
190 const char *simple_expansion
;
191 /* The length of the simple expansion. */
193 /* The results of a full, verbose, expansion. This is used when
194 qualifying a constructor/destructor, or when in verbose mode. */
195 const char *full_expansion
;
196 /* The length of the full expansion. */
198 /* What to set the last_name field of d_info to; NULL if we should
199 not set it. This is only relevant when qualifying a
200 constructor/destructor. */
201 const char *set_last_name
;
202 /* The length of set_last_name. */
203 int set_last_name_len
;
206 /* Accessors for subtrees of struct demangle_component. */
208 #define d_left(dc) ((dc)->u.s_binary.left)
209 #define d_right(dc) ((dc)->u.s_binary.right)
211 /* A list of templates. This is used while printing. */
213 struct d_print_template
215 /* Next template on the list. */
216 struct d_print_template
*next
;
218 const struct demangle_component
*template;
221 /* A list of type modifiers. This is used while printing. */
225 /* Next modifier on the list. These are in the reverse of the order
226 in which they appeared in the mangled string. */
227 struct d_print_mod
*next
;
229 const struct demangle_component
*mod
;
230 /* Whether this modifier was printed. */
232 /* The list of templates which applies to this modifier. */
233 struct d_print_template
*templates
;
236 /* We use this structure to hold information during printing. */
240 /* The options passed to the demangler. */
242 /* Buffer holding the result. */
244 /* Current length of data in buffer. */
246 /* Allocated size of buffer. */
248 /* The current list of templates, if any. */
249 struct d_print_template
*templates
;
250 /* The current list of modifiers (e.g., pointer, reference, etc.),
252 struct d_print_mod
*modifiers
;
253 /* Set to 1 if we had a memory allocation failure. */
254 int allocation_failure
;
257 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
259 #define d_append_char(dpi, c) \
262 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
263 (dpi)->buf[(dpi)->len++] = (c); \
265 d_print_append_char ((dpi), (c)); \
269 #define d_append_buffer(dpi, s, l) \
272 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
274 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
278 d_print_append_buffer ((dpi), (s), (l)); \
282 #define d_append_string_constant(dpi, s) \
283 d_append_buffer (dpi, (s), sizeof (s) - 1)
285 #define d_last_char(dpi) \
286 ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
288 #ifdef CP_DEMANGLE_DEBUG
290 d_dump
PARAMS ((struct demangle_component
*, int));
293 static struct demangle_component
*
294 d_make_empty
PARAMS ((struct d_info
*));
296 static struct demangle_component
*
297 d_make_comp
PARAMS ((struct d_info
*, enum demangle_component_type
,
298 struct demangle_component
*,
299 struct demangle_component
*));
301 static struct demangle_component
*
302 d_make_name
PARAMS ((struct d_info
*, const char *, int));
304 static struct demangle_component
*
305 d_make_builtin_type
PARAMS ((struct d_info
*,
306 const struct demangle_builtin_type_info
*));
308 static struct demangle_component
*
309 d_make_operator
PARAMS ((struct d_info
*,
310 const struct demangle_operator_info
*));
312 static struct demangle_component
*
313 d_make_extended_operator
PARAMS ((struct d_info
*, int,
314 struct demangle_component
*));
316 static struct demangle_component
*
317 d_make_ctor
PARAMS ((struct d_info
*, enum gnu_v3_ctor_kinds
,
318 struct demangle_component
*));
320 static struct demangle_component
*
321 d_make_dtor
PARAMS ((struct d_info
*, enum gnu_v3_dtor_kinds
,
322 struct demangle_component
*));
324 static struct demangle_component
*
325 d_make_template_param
PARAMS ((struct d_info
*, long));
327 static struct demangle_component
*
328 d_make_sub
PARAMS ((struct d_info
*, const char *, int));
331 has_return_type
PARAMS ((struct demangle_component
*));
334 is_ctor_dtor_or_conversion
PARAMS ((struct demangle_component
*));
336 static struct demangle_component
*
337 d_encoding
PARAMS ((struct d_info
*, int));
339 static struct demangle_component
*
340 d_name
PARAMS ((struct d_info
*));
342 static struct demangle_component
*
343 d_nested_name
PARAMS ((struct d_info
*));
345 static struct demangle_component
*
346 d_prefix
PARAMS ((struct d_info
*));
348 static struct demangle_component
*
349 d_unqualified_name
PARAMS ((struct d_info
*));
351 static struct demangle_component
*
352 d_source_name
PARAMS ((struct d_info
*));
355 d_number
PARAMS ((struct d_info
*));
357 static struct demangle_component
*
358 d_identifier
PARAMS ((struct d_info
*, int));
360 static struct demangle_component
*
361 d_operator_name
PARAMS ((struct d_info
*));
363 static struct demangle_component
*
364 d_special_name
PARAMS ((struct d_info
*));
367 d_call_offset
PARAMS ((struct d_info
*, int));
369 static struct demangle_component
*
370 d_ctor_dtor_name
PARAMS ((struct d_info
*));
372 static struct demangle_component
**
373 d_cv_qualifiers
PARAMS ((struct d_info
*, struct demangle_component
**, int));
375 static struct demangle_component
*
376 d_function_type
PARAMS ((struct d_info
*));
378 static struct demangle_component
*
379 d_bare_function_type
PARAMS ((struct d_info
*, int));
381 static struct demangle_component
*
382 d_class_enum_type
PARAMS ((struct d_info
*));
384 static struct demangle_component
*
385 d_array_type
PARAMS ((struct d_info
*));
387 static struct demangle_component
*
388 d_pointer_to_member_type
PARAMS ((struct d_info
*));
390 static struct demangle_component
*
391 d_template_param
PARAMS ((struct d_info
*));
393 static struct demangle_component
*
394 d_template_args
PARAMS ((struct d_info
*));
396 static struct demangle_component
*
397 d_template_arg
PARAMS ((struct d_info
*));
399 static struct demangle_component
*
400 d_expression
PARAMS ((struct d_info
*));
402 static struct demangle_component
*
403 d_expr_primary
PARAMS ((struct d_info
*));
405 static struct demangle_component
*
406 d_local_name
PARAMS ((struct d_info
*));
409 d_discriminator
PARAMS ((struct d_info
*));
412 d_add_substitution
PARAMS ((struct d_info
*, struct demangle_component
*));
414 static struct demangle_component
*
415 d_substitution
PARAMS ((struct d_info
*, int));
418 d_print_resize
PARAMS ((struct d_print_info
*, size_t));
421 d_print_append_char
PARAMS ((struct d_print_info
*, int));
424 d_print_append_buffer
PARAMS ((struct d_print_info
*, const char *, size_t));
427 d_print_error
PARAMS ((struct d_print_info
*));
430 d_print_comp
PARAMS ((struct d_print_info
*,
431 const struct demangle_component
*));
434 d_print_java_identifier
PARAMS ((struct d_print_info
*, const char *, int));
437 d_print_mod_list
PARAMS ((struct d_print_info
*, struct d_print_mod
*, int));
440 d_print_mod
PARAMS ((struct d_print_info
*,
441 const struct demangle_component
*));
444 d_print_function_type
PARAMS ((struct d_print_info
*,
445 const struct demangle_component
*,
446 struct d_print_mod
*));
449 d_print_array_type
PARAMS ((struct d_print_info
*,
450 const struct demangle_component
*,
451 struct d_print_mod
*));
454 d_print_expr_op
PARAMS ((struct d_print_info
*,
455 const struct demangle_component
*));
458 d_print_cast
PARAMS ((struct d_print_info
*,
459 const struct demangle_component
*));
462 d_demangle
PARAMS ((const char *, int, size_t *));
464 #ifdef CP_DEMANGLE_DEBUG
468 struct demangle_component
*dc
;
476 for (i
= 0; i
< indent
; ++i
)
481 case DEMANGLE_COMPONENT_NAME
:
482 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
484 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
485 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
487 case DEMANGLE_COMPONENT_CTOR
:
488 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
489 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
491 case DEMANGLE_COMPONENT_DTOR
:
492 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
493 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
495 case DEMANGLE_COMPONENT_SUB_STD
:
496 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
498 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
499 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
501 case DEMANGLE_COMPONENT_OPERATOR
:
502 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
504 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
505 printf ("extended operator with %d args\n",
506 dc
->u
.s_extended_operator
.args
);
507 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
510 case DEMANGLE_COMPONENT_QUAL_NAME
:
511 printf ("qualified name\n");
513 case DEMANGLE_COMPONENT_LOCAL_NAME
:
514 printf ("local name\n");
516 case DEMANGLE_COMPONENT_TYPED_NAME
:
517 printf ("typed name\n");
519 case DEMANGLE_COMPONENT_TEMPLATE
:
520 printf ("template\n");
522 case DEMANGLE_COMPONENT_VTABLE
:
525 case DEMANGLE_COMPONENT_VTT
:
528 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
529 printf ("construction vtable\n");
531 case DEMANGLE_COMPONENT_TYPEINFO
:
532 printf ("typeinfo\n");
534 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
535 printf ("typeinfo name\n");
537 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
538 printf ("typeinfo function\n");
540 case DEMANGLE_COMPONENT_THUNK
:
543 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
544 printf ("virtual thunk\n");
546 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
547 printf ("covariant thunk\n");
549 case DEMANGLE_COMPONENT_JAVA_CLASS
:
550 printf ("java class\n");
552 case DEMANGLE_COMPONENT_GUARD
:
555 case DEMANGLE_COMPONENT_REFTEMP
:
556 printf ("reference temporary\n");
558 case DEMANGLE_COMPONENT_RESTRICT
:
559 printf ("restrict\n");
561 case DEMANGLE_COMPONENT_VOLATILE
:
562 printf ("volatile\n");
564 case DEMANGLE_COMPONENT_CONST
:
567 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
568 printf ("restrict this\n");
570 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
571 printf ("volatile this\n");
573 case DEMANGLE_COMPONENT_CONST_THIS
:
574 printf ("const this\n");
576 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
577 printf ("vendor type qualifier\n");
579 case DEMANGLE_COMPONENT_POINTER
:
580 printf ("pointer\n");
582 case DEMANGLE_COMPONENT_REFERENCE
:
583 printf ("reference\n");
585 case DEMANGLE_COMPONENT_COMPLEX
:
586 printf ("complex\n");
588 case DEMANGLE_COMPONENT_IMAGINARY
:
589 printf ("imaginary\n");
591 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
592 printf ("vendor type\n");
594 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
595 printf ("function type\n");
597 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
598 printf ("array type\n");
600 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
601 printf ("pointer to member type\n");
603 case DEMANGLE_COMPONENT_ARGLIST
:
604 printf ("argument list\n");
606 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
607 printf ("template argument list\n");
609 case DEMANGLE_COMPONENT_CAST
:
612 case DEMANGLE_COMPONENT_UNARY
:
613 printf ("unary operator\n");
615 case DEMANGLE_COMPONENT_BINARY
:
616 printf ("binary operator\n");
618 case DEMANGLE_COMPONENT_BINARY_ARGS
:
619 printf ("binary operator arguments\n");
621 case DEMANGLE_COMPONENT_TRINARY
:
622 printf ("trinary operator\n");
624 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
625 printf ("trinary operator arguments 1\n");
627 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
628 printf ("trinary operator arguments 1\n");
630 case DEMANGLE_COMPONENT_LITERAL
:
631 printf ("literal\n");
633 case DEMANGLE_COMPONENT_LITERAL_NEG
:
634 printf ("negative literal\n");
638 d_dump (d_left (dc
), indent
+ 2);
639 d_dump (d_right (dc
), indent
+ 2);
642 #endif /* CP_DEMANGLE_DEBUG */
644 /* Fill in a DEMANGLE_COMPONENT_NAME. */
646 CP_STATIC_IF_GLIBCPP_V3
648 cplus_demangle_fill_name (p
, s
, len
)
649 struct demangle_component
*p
;
653 if (p
== NULL
|| s
== NULL
|| len
== 0)
655 p
->type
= DEMANGLE_COMPONENT_NAME
;
657 p
->u
.s_name
.len
= len
;
661 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
663 CP_STATIC_IF_GLIBCPP_V3
665 cplus_demangle_fill_extended_operator (p
, args
, name
)
666 struct demangle_component
*p
;
668 struct demangle_component
*name
;
670 if (p
== NULL
|| args
< 0 || name
== NULL
)
672 p
->type
= DEMANGLE_COMPONENT_EXTENDED_OPERATOR
;
673 p
->u
.s_extended_operator
.args
= args
;
674 p
->u
.s_extended_operator
.name
= name
;
678 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
680 CP_STATIC_IF_GLIBCPP_V3
682 cplus_demangle_fill_ctor (p
, kind
, name
)
683 struct demangle_component
*p
;
684 enum gnu_v3_ctor_kinds kind
;
685 struct demangle_component
*name
;
689 || (kind
< gnu_v3_complete_object_ctor
690 && kind
> gnu_v3_complete_object_allocating_ctor
))
692 p
->type
= DEMANGLE_COMPONENT_CTOR
;
693 p
->u
.s_ctor
.kind
= kind
;
694 p
->u
.s_ctor
.name
= name
;
698 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
700 CP_STATIC_IF_GLIBCPP_V3
702 cplus_demangle_fill_dtor (p
, kind
, name
)
703 struct demangle_component
*p
;
704 enum gnu_v3_dtor_kinds kind
;
705 struct demangle_component
*name
;
709 || (kind
< gnu_v3_deleting_dtor
710 && kind
> gnu_v3_base_object_dtor
))
712 p
->type
= DEMANGLE_COMPONENT_DTOR
;
713 p
->u
.s_dtor
.kind
= kind
;
714 p
->u
.s_dtor
.name
= name
;
718 /* Add a new component. */
720 static struct demangle_component
*
724 struct demangle_component
*p
;
726 if (di
->next_comp
>= di
->num_comps
)
728 p
= &di
->comps
[di
->next_comp
];
733 /* Add a new generic component. */
735 static struct demangle_component
*
736 d_make_comp (di
, type
, left
, right
)
738 enum demangle_component_type type
;
739 struct demangle_component
*left
;
740 struct demangle_component
*right
;
742 struct demangle_component
*p
;
744 /* We check for errors here. A typical error would be a NULL return
745 from a subroutine. We catch those here, and return NULL
749 /* These types require two parameters. */
750 case DEMANGLE_COMPONENT_QUAL_NAME
:
751 case DEMANGLE_COMPONENT_LOCAL_NAME
:
752 case DEMANGLE_COMPONENT_TYPED_NAME
:
753 case DEMANGLE_COMPONENT_TEMPLATE
:
754 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
755 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
756 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
757 case DEMANGLE_COMPONENT_UNARY
:
758 case DEMANGLE_COMPONENT_BINARY
:
759 case DEMANGLE_COMPONENT_BINARY_ARGS
:
760 case DEMANGLE_COMPONENT_TRINARY
:
761 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
762 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
763 case DEMANGLE_COMPONENT_LITERAL
:
764 case DEMANGLE_COMPONENT_LITERAL_NEG
:
765 if (left
== NULL
|| right
== NULL
)
769 /* These types only require one parameter. */
770 case DEMANGLE_COMPONENT_VTABLE
:
771 case DEMANGLE_COMPONENT_VTT
:
772 case DEMANGLE_COMPONENT_TYPEINFO
:
773 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
774 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
775 case DEMANGLE_COMPONENT_THUNK
:
776 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
777 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
778 case DEMANGLE_COMPONENT_JAVA_CLASS
:
779 case DEMANGLE_COMPONENT_GUARD
:
780 case DEMANGLE_COMPONENT_REFTEMP
:
781 case DEMANGLE_COMPONENT_POINTER
:
782 case DEMANGLE_COMPONENT_REFERENCE
:
783 case DEMANGLE_COMPONENT_COMPLEX
:
784 case DEMANGLE_COMPONENT_IMAGINARY
:
785 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
786 case DEMANGLE_COMPONENT_ARGLIST
:
787 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
788 case DEMANGLE_COMPONENT_CAST
:
793 /* This needs a right parameter, but the left parameter can be
795 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
800 /* These are allowed to have no parameters--in some cases they
801 will be filled in later. */
802 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
803 case DEMANGLE_COMPONENT_RESTRICT
:
804 case DEMANGLE_COMPONENT_VOLATILE
:
805 case DEMANGLE_COMPONENT_CONST
:
806 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
807 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
808 case DEMANGLE_COMPONENT_CONST_THIS
:
811 /* Other types should not be seen here. */
816 p
= d_make_empty (di
);
820 p
->u
.s_binary
.left
= left
;
821 p
->u
.s_binary
.right
= right
;
826 /* Add a new name component. */
828 static struct demangle_component
*
829 d_make_name (di
, s
, len
)
834 struct demangle_component
*p
;
836 p
= d_make_empty (di
);
837 if (! cplus_demangle_fill_name (p
, s
, len
))
842 /* Add a new builtin type component. */
844 static struct demangle_component
*
845 d_make_builtin_type (di
, type
)
847 const struct demangle_builtin_type_info
*type
;
849 struct demangle_component
*p
;
853 p
= d_make_empty (di
);
856 p
->type
= DEMANGLE_COMPONENT_BUILTIN_TYPE
;
857 p
->u
.s_builtin
.type
= type
;
862 /* Add a new operator component. */
864 static struct demangle_component
*
865 d_make_operator (di
, op
)
867 const struct demangle_operator_info
*op
;
869 struct demangle_component
*p
;
871 p
= d_make_empty (di
);
874 p
->type
= DEMANGLE_COMPONENT_OPERATOR
;
875 p
->u
.s_operator
.op
= op
;
880 /* Add a new extended operator component. */
882 static struct demangle_component
*
883 d_make_extended_operator (di
, args
, name
)
886 struct demangle_component
*name
;
888 struct demangle_component
*p
;
890 p
= d_make_empty (di
);
891 if (! cplus_demangle_fill_extended_operator (p
, args
, name
))
896 /* Add a new constructor component. */
898 static struct demangle_component
*
899 d_make_ctor (di
, kind
, name
)
901 enum gnu_v3_ctor_kinds kind
;
902 struct demangle_component
*name
;
904 struct demangle_component
*p
;
906 p
= d_make_empty (di
);
907 if (! cplus_demangle_fill_ctor (p
, kind
, name
))
912 /* Add a new destructor component. */
914 static struct demangle_component
*
915 d_make_dtor (di
, kind
, name
)
917 enum gnu_v3_dtor_kinds kind
;
918 struct demangle_component
*name
;
920 struct demangle_component
*p
;
922 p
= d_make_empty (di
);
923 if (! cplus_demangle_fill_dtor (p
, kind
, name
))
928 /* Add a new template parameter. */
930 static struct demangle_component
*
931 d_make_template_param (di
, i
)
935 struct demangle_component
*p
;
937 p
= d_make_empty (di
);
940 p
->type
= DEMANGLE_COMPONENT_TEMPLATE_PARAM
;
941 p
->u
.s_number
.number
= i
;
946 /* Add a new standard substitution component. */
948 static struct demangle_component
*
949 d_make_sub (di
, name
, len
)
954 struct demangle_component
*p
;
956 p
= d_make_empty (di
);
959 p
->type
= DEMANGLE_COMPONENT_SUB_STD
;
960 p
->u
.s_string
.string
= name
;
961 p
->u
.s_string
.len
= len
;
966 /* <mangled-name> ::= _Z <encoding>
968 TOP_LEVEL is non-zero when called at the top level. */
970 CP_STATIC_IF_GLIBCPP_V3
971 struct demangle_component
*
972 cplus_demangle_mangled_name (di
, top_level
)
976 if (d_next_char (di
) != '_')
978 if (d_next_char (di
) != 'Z')
980 return d_encoding (di
, top_level
);
983 /* Return whether a function should have a return type. The argument
984 is the function name, which may be qualified in various ways. The
985 rules are that template functions have return types with some
986 exceptions, function types which are not part of a function name
987 mangling have return types with some exceptions, and non-template
988 function names do not have return types. The exceptions are that
989 constructors, destructors, and conversion operators do not have
994 struct demangle_component
*dc
;
1002 case DEMANGLE_COMPONENT_TEMPLATE
:
1003 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1004 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
1005 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
1006 case DEMANGLE_COMPONENT_CONST_THIS
:
1007 return has_return_type (d_left (dc
));
1011 /* Return whether a name is a constructor, a destructor, or a
1012 conversion operator. */
1015 is_ctor_dtor_or_conversion (dc
)
1016 struct demangle_component
*dc
;
1024 case DEMANGLE_COMPONENT_QUAL_NAME
:
1025 case DEMANGLE_COMPONENT_LOCAL_NAME
:
1026 return is_ctor_dtor_or_conversion (d_right (dc
));
1027 case DEMANGLE_COMPONENT_CTOR
:
1028 case DEMANGLE_COMPONENT_DTOR
:
1029 case DEMANGLE_COMPONENT_CAST
:
1034 /* <encoding> ::= <(function) name> <bare-function-type>
1038 TOP_LEVEL is non-zero when called at the top level, in which case
1039 if DMGL_PARAMS is not set we do not demangle the function
1040 parameters. We only set this at the top level, because otherwise
1041 we would not correctly demangle names in local scopes. */
1043 static struct demangle_component
*
1044 d_encoding (di
, top_level
)
1048 char peek
= d_peek_char (di
);
1050 if (peek
== 'G' || peek
== 'T')
1051 return d_special_name (di
);
1054 struct demangle_component
*dc
;
1058 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1060 /* Strip off any initial CV-qualifiers, as they really apply
1061 to the `this' parameter, and they were not output by the
1062 v2 demangler without DMGL_PARAMS. */
1063 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1064 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1065 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1068 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1069 there may be CV-qualifiers on its right argument which
1070 really apply here; this happens when parsing a class
1071 which is local to a function. */
1072 if (dc
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
1074 struct demangle_component
*dcr
;
1077 while (dcr
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
1078 || dcr
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
1079 || dcr
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
1081 dc
->u
.s_binary
.right
= dcr
;
1087 peek
= d_peek_char (di
);
1088 if (peek
== '\0' || peek
== 'E')
1090 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPED_NAME
, dc
,
1091 d_bare_function_type (di
, has_return_type (dc
)));
1095 /* <name> ::= <nested-name>
1097 ::= <unscoped-template-name> <template-args>
1100 <unscoped-name> ::= <unqualified-name>
1101 ::= St <unqualified-name>
1103 <unscoped-template-name> ::= <unscoped-name>
1107 static struct demangle_component
*
1111 char peek
= d_peek_char (di
);
1112 struct demangle_component
*dc
;
1117 return d_nested_name (di
);
1120 return d_local_name (di
);
1126 if (d_peek_next_char (di
) != 't')
1128 dc
= d_substitution (di
, 0);
1134 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
,
1135 d_make_name (di
, "std", 3),
1136 d_unqualified_name (di
));
1141 if (d_peek_char (di
) != 'I')
1143 /* The grammar does not permit this case to occur if we
1144 called d_substitution() above (i.e., subst == 1). We
1145 don't bother to check. */
1149 /* This is <template-args>, which means that we just saw
1150 <unscoped-template-name>, which is a substitution
1151 candidate if we didn't just get it from a
1155 if (! d_add_substitution (di
, dc
))
1158 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1159 d_template_args (di
));
1166 dc
= d_unqualified_name (di
);
1167 if (d_peek_char (di
) == 'I')
1169 /* This is <template-args>, which means that we just saw
1170 <unscoped-template-name>, which is a substitution
1172 if (! d_add_substitution (di
, dc
))
1174 dc
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, dc
,
1175 d_template_args (di
));
1181 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1182 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1185 static struct demangle_component
*
1189 struct demangle_component
*ret
;
1190 struct demangle_component
**pret
;
1192 if (d_next_char (di
) != 'N')
1195 pret
= d_cv_qualifiers (di
, &ret
, 1);
1199 *pret
= d_prefix (di
);
1203 if (d_next_char (di
) != 'E')
1209 /* <prefix> ::= <prefix> <unqualified-name>
1210 ::= <template-prefix> <template-args>
1211 ::= <template-param>
1215 <template-prefix> ::= <prefix> <(template) unqualified-name>
1216 ::= <template-param>
1220 static struct demangle_component
*
1224 struct demangle_component
*ret
= NULL
;
1229 enum demangle_component_type comb_type
;
1230 struct demangle_component
*dc
;
1232 peek
= d_peek_char (di
);
1236 /* The older code accepts a <local-name> here, but I don't see
1237 that in the grammar. The older code does not accept a
1238 <template-param> here. */
1240 comb_type
= DEMANGLE_COMPONENT_QUAL_NAME
;
1245 dc
= d_unqualified_name (di
);
1246 else if (peek
== 'S')
1247 dc
= d_substitution (di
, 1);
1248 else if (peek
== 'I')
1252 comb_type
= DEMANGLE_COMPONENT_TEMPLATE
;
1253 dc
= d_template_args (di
);
1255 else if (peek
== 'T')
1256 dc
= d_template_param (di
);
1257 else if (peek
== 'E')
1265 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1267 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1269 if (! d_add_substitution (di
, ret
))
1275 /* <unqualified-name> ::= <operator-name>
1276 ::= <ctor-dtor-name>
1280 static struct demangle_component
*
1281 d_unqualified_name (di
)
1286 peek
= d_peek_char (di
);
1287 if (IS_DIGIT (peek
))
1288 return d_source_name (di
);
1289 else if (IS_LOWER (peek
))
1291 struct demangle_component
*ret
;
1293 ret
= d_operator_name (di
);
1294 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_OPERATOR
)
1295 di
->expansion
+= sizeof "operator" + ret
->u
.s_operator
.op
->len
- 2;
1298 else if (peek
== 'C' || peek
== 'D')
1299 return d_ctor_dtor_name (di
);
1304 /* <source-name> ::= <(positive length) number> <identifier> */
1306 static struct demangle_component
*
1311 struct demangle_component
*ret
;
1313 len
= d_number (di
);
1316 ret
= d_identifier (di
, len
);
1317 di
->last_name
= ret
;
1321 /* number ::= [n] <(non-negative decimal integer)> */
1332 peek
= d_peek_char (di
);
1337 peek
= d_peek_char (di
);
1343 if (! IS_DIGIT (peek
))
1349 ret
= ret
* 10 + peek
- '0';
1351 peek
= d_peek_char (di
);
1355 /* identifier ::= <(unqualified source code identifier)> */
1357 static struct demangle_component
*
1358 d_identifier (di
, len
)
1366 if (di
->send
- name
< len
)
1369 d_advance (di
, len
);
1371 /* A Java mangled name may have a trailing '$' if it is a C++
1372 keyword. This '$' is not included in the length count. We just
1374 if ((di
->options
& DMGL_JAVA
) != 0
1375 && d_peek_char (di
) == '$')
1378 /* Look for something which looks like a gcc encoding of an
1379 anonymous namespace, and replace it with a more user friendly
1381 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1382 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1383 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1387 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1388 if ((*s
== '.' || *s
== '_' || *s
== '$')
1391 di
->expansion
-= len
- sizeof "(anonymous namespace)";
1392 return d_make_name (di
, "(anonymous namespace)",
1393 sizeof "(anonymous namespace)" - 1);
1397 return d_make_name (di
, name
, len
);
1400 /* operator_name ::= many different two character encodings.
1402 ::= v <digit> <source-name>
1405 #define NL(s) s, (sizeof s) - 1
1407 CP_STATIC_IF_GLIBCPP_V3
1408 const struct demangle_operator_info cplus_demangle_operators
[] =
1410 { "aN", NL ("&="), 2 },
1411 { "aS", NL ("="), 2 },
1412 { "aa", NL ("&&"), 2 },
1413 { "ad", NL ("&"), 1 },
1414 { "an", NL ("&"), 2 },
1415 { "cl", NL ("()"), 0 },
1416 { "cm", NL (","), 2 },
1417 { "co", NL ("~"), 1 },
1418 { "dV", NL ("/="), 2 },
1419 { "da", NL ("delete[]"), 1 },
1420 { "de", NL ("*"), 1 },
1421 { "dl", NL ("delete"), 1 },
1422 { "dv", NL ("/"), 2 },
1423 { "eO", NL ("^="), 2 },
1424 { "eo", NL ("^"), 2 },
1425 { "eq", NL ("=="), 2 },
1426 { "ge", NL (">="), 2 },
1427 { "gt", NL (">"), 2 },
1428 { "ix", NL ("[]"), 2 },
1429 { "lS", NL ("<<="), 2 },
1430 { "le", NL ("<="), 2 },
1431 { "ls", NL ("<<"), 2 },
1432 { "lt", NL ("<"), 2 },
1433 { "mI", NL ("-="), 2 },
1434 { "mL", NL ("*="), 2 },
1435 { "mi", NL ("-"), 2 },
1436 { "ml", NL ("*"), 2 },
1437 { "mm", NL ("--"), 1 },
1438 { "na", NL ("new[]"), 1 },
1439 { "ne", NL ("!="), 2 },
1440 { "ng", NL ("-"), 1 },
1441 { "nt", NL ("!"), 1 },
1442 { "nw", NL ("new"), 1 },
1443 { "oR", NL ("|="), 2 },
1444 { "oo", NL ("||"), 2 },
1445 { "or", NL ("|"), 2 },
1446 { "pL", NL ("+="), 2 },
1447 { "pl", NL ("+"), 2 },
1448 { "pm", NL ("->*"), 2 },
1449 { "pp", NL ("++"), 1 },
1450 { "ps", NL ("+"), 1 },
1451 { "pt", NL ("->"), 2 },
1452 { "qu", NL ("?"), 3 },
1453 { "rM", NL ("%="), 2 },
1454 { "rS", NL (">>="), 2 },
1455 { "rm", NL ("%"), 2 },
1456 { "rs", NL (">>"), 2 },
1457 { "st", NL ("sizeof "), 1 },
1458 { "sz", NL ("sizeof "), 1 },
1459 { NULL
, NULL
, 0, 0 }
1462 static struct demangle_component
*
1463 d_operator_name (di
)
1469 c1
= d_next_char (di
);
1470 c2
= d_next_char (di
);
1471 if (c1
== 'v' && IS_DIGIT (c2
))
1472 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1473 else if (c1
== 'c' && c2
== 'v')
1474 return d_make_comp (di
, DEMANGLE_COMPONENT_CAST
,
1475 cplus_demangle_type (di
), NULL
);
1478 /* LOW is the inclusive lower bound. */
1480 /* HIGH is the exclusive upper bound. We subtract one to ignore
1481 the sentinel at the end of the array. */
1482 int high
= ((sizeof (cplus_demangle_operators
)
1483 / sizeof (cplus_demangle_operators
[0]))
1489 const struct demangle_operator_info
*p
;
1491 i
= low
+ (high
- low
) / 2;
1492 p
= cplus_demangle_operators
+ i
;
1494 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1495 return d_make_operator (di
, p
);
1497 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1507 /* <special-name> ::= TV <type>
1511 ::= GV <(object) name>
1512 ::= T <call-offset> <(base) encoding>
1513 ::= Tc <call-offset> <call-offset> <(base) encoding>
1514 Also g++ extensions:
1515 ::= TC <type> <(offset) number> _ <(base) type>
1521 static struct demangle_component
*
1527 di
->expansion
+= 20;
1528 c
= d_next_char (di
);
1531 switch (d_next_char (di
))
1535 return d_make_comp (di
, DEMANGLE_COMPONENT_VTABLE
,
1536 cplus_demangle_type (di
), NULL
);
1538 di
->expansion
-= 10;
1539 return d_make_comp (di
, DEMANGLE_COMPONENT_VTT
,
1540 cplus_demangle_type (di
), NULL
);
1542 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO
,
1543 cplus_demangle_type (di
), NULL
);
1545 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_NAME
,
1546 cplus_demangle_type (di
), NULL
);
1549 if (! d_call_offset (di
, 'h'))
1551 return d_make_comp (di
, DEMANGLE_COMPONENT_THUNK
,
1552 d_encoding (di
, 0), NULL
);
1555 if (! d_call_offset (di
, 'v'))
1557 return d_make_comp (di
, DEMANGLE_COMPONENT_VIRTUAL_THUNK
,
1558 d_encoding (di
, 0), NULL
);
1561 if (! d_call_offset (di
, '\0'))
1563 if (! d_call_offset (di
, '\0'))
1565 return d_make_comp (di
, DEMANGLE_COMPONENT_COVARIANT_THUNK
,
1566 d_encoding (di
, 0), NULL
);
1570 struct demangle_component
*derived_type
;
1572 struct demangle_component
*base_type
;
1574 derived_type
= cplus_demangle_type (di
);
1575 offset
= d_number (di
);
1578 if (d_next_char (di
) != '_')
1580 base_type
= cplus_demangle_type (di
);
1581 /* We don't display the offset. FIXME: We should display
1582 it in verbose mode. */
1584 return d_make_comp (di
, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
,
1585 base_type
, derived_type
);
1589 return d_make_comp (di
, DEMANGLE_COMPONENT_TYPEINFO_FN
,
1590 cplus_demangle_type (di
), NULL
);
1592 return d_make_comp (di
, DEMANGLE_COMPONENT_JAVA_CLASS
,
1593 cplus_demangle_type (di
), NULL
);
1601 switch (d_next_char (di
))
1604 return d_make_comp (di
, DEMANGLE_COMPONENT_GUARD
, d_name (di
), NULL
);
1607 return d_make_comp (di
, DEMANGLE_COMPONENT_REFTEMP
, d_name (di
),
1618 /* <call-offset> ::= h <nv-offset> _
1621 <nv-offset> ::= <(offset) number>
1623 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1625 The C parameter, if not '\0', is a character we just read which is
1626 the start of the <call-offset>.
1628 We don't display the offset information anywhere. FIXME: We should
1629 display it in verbose mode. */
1632 d_call_offset (di
, c
)
1637 long virtual_offset
;
1640 c
= d_next_char (di
);
1643 offset
= d_number (di
);
1646 offset
= d_number (di
);
1647 if (d_next_char (di
) != '_')
1649 virtual_offset
= d_number (di
);
1654 if (d_next_char (di
) != '_')
1660 /* <ctor-dtor-name> ::= C1
1668 static struct demangle_component
*
1669 d_ctor_dtor_name (di
)
1672 if (di
->last_name
!= NULL
)
1674 if (di
->last_name
->type
== DEMANGLE_COMPONENT_NAME
)
1675 di
->expansion
+= di
->last_name
->u
.s_name
.len
;
1676 else if (di
->last_name
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1677 di
->expansion
+= di
->last_name
->u
.s_string
.len
;
1679 switch (d_next_char (di
))
1683 enum gnu_v3_ctor_kinds kind
;
1685 switch (d_next_char (di
))
1688 kind
= gnu_v3_complete_object_ctor
;
1691 kind
= gnu_v3_base_object_ctor
;
1694 kind
= gnu_v3_complete_object_allocating_ctor
;
1699 return d_make_ctor (di
, kind
, di
->last_name
);
1704 enum gnu_v3_dtor_kinds kind
;
1706 switch (d_next_char (di
))
1709 kind
= gnu_v3_deleting_dtor
;
1712 kind
= gnu_v3_complete_object_dtor
;
1715 kind
= gnu_v3_base_object_dtor
;
1720 return d_make_dtor (di
, kind
, di
->last_name
);
1728 /* <type> ::= <builtin-type>
1730 ::= <class-enum-type>
1732 ::= <pointer-to-member-type>
1733 ::= <template-param>
1734 ::= <template-template-param> <template-args>
1736 ::= <CV-qualifiers> <type>
1741 ::= U <source-name> <type>
1743 <builtin-type> ::= various one letter codes
1747 CP_STATIC_IF_GLIBCPP_V3
1748 const struct demangle_builtin_type_info
1749 cplus_demangle_builtin_types
[D_BUILTIN_TYPE_COUNT
] =
1751 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_INT
},
1752 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL
},
1753 /* c */ { NL ("char"), NL ("byte"), D_PRINT_INT
},
1754 /* d */ { NL ("double"), NL ("double"), D_PRINT_DEFAULT
},
1755 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_DEFAULT
},
1756 /* f */ { NL ("float"), NL ("float"), D_PRINT_DEFAULT
},
1757 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_DEFAULT
},
1758 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_INT
},
1759 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT
},
1760 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_INT
},
1761 /* k */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1762 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG
},
1763 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_LONG
},
1764 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT
},
1765 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), D_PRINT_DEFAULT
},
1766 /* p */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1767 /* q */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1768 /* r */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1769 /* s */ { NL ("short"), NL ("short"), D_PRINT_INT
},
1770 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_INT
},
1771 /* u */ { NULL
, 0, NULL
, 0, D_PRINT_DEFAULT
},
1772 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID
},
1773 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_INT
},
1774 /* x */ { NL ("long long"), NL ("long"), D_PRINT_DEFAULT
},
1775 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), D_PRINT_DEFAULT
},
1776 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT
},
1779 CP_STATIC_IF_GLIBCPP_V3
1780 struct demangle_component
*
1781 cplus_demangle_type (di
)
1785 struct demangle_component
*ret
;
1788 /* The ABI specifies that when CV-qualifiers are used, the base type
1789 is substitutable, and the fully qualified type is substitutable,
1790 but the base type with a strict subset of the CV-qualifiers is
1791 not substitutable. The natural recursive implementation of the
1792 CV-qualifiers would cause subsets to be substitutable, so instead
1793 we pull them all off now.
1795 FIXME: The ABI says that order-insensitive vendor qualifiers
1796 should be handled in the same way, but we have no way to tell
1797 which vendor qualifiers are order-insensitive and which are
1798 order-sensitive. So we just assume that they are all
1799 order-sensitive. g++ 3.4 supports only one vendor qualifier,
1800 __vector, and it treats it as order-sensitive when mangling
1803 peek
= d_peek_char (di
);
1804 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
1806 struct demangle_component
**pret
;
1808 pret
= d_cv_qualifiers (di
, &ret
, 0);
1811 *pret
= cplus_demangle_type (di
);
1812 if (! d_add_substitution (di
, ret
))
1821 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1822 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1823 case 'o': case 's': case 't':
1824 case 'v': case 'w': case 'x': case 'y': case 'z':
1825 ret
= d_make_builtin_type (di
,
1826 &cplus_demangle_builtin_types
[peek
- 'a']);
1827 di
->expansion
+= ret
->u
.s_builtin
.type
->len
;
1834 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE
,
1835 d_source_name (di
), NULL
);
1839 ret
= d_function_type (di
);
1842 case '0': case '1': case '2': case '3': case '4':
1843 case '5': case '6': case '7': case '8': case '9':
1846 ret
= d_class_enum_type (di
);
1850 ret
= d_array_type (di
);
1854 ret
= d_pointer_to_member_type (di
);
1858 ret
= d_template_param (di
);
1859 if (d_peek_char (di
) == 'I')
1861 /* This is <template-template-param> <template-args>. The
1862 <template-template-param> part is a substitution
1864 if (! d_add_substitution (di
, ret
))
1866 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1867 d_template_args (di
));
1872 /* If this is a special substitution, then it is the start of
1873 <class-enum-type>. */
1877 peek_next
= d_peek_next_char (di
);
1878 if (IS_DIGIT (peek_next
)
1880 || IS_UPPER (peek_next
))
1882 ret
= d_substitution (di
, 0);
1883 /* The substituted name may have been a template name and
1884 may be followed by tepmlate args. */
1885 if (d_peek_char (di
) == 'I')
1886 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, ret
,
1887 d_template_args (di
));
1893 ret
= d_class_enum_type (di
);
1894 /* If the substitution was a complete type, then it is not
1895 a new substitution candidate. However, if the
1896 substitution was followed by template arguments, then
1897 the whole thing is a substitution candidate. */
1898 if (ret
!= NULL
&& ret
->type
== DEMANGLE_COMPONENT_SUB_STD
)
1906 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_POINTER
,
1907 cplus_demangle_type (di
), NULL
);
1912 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_REFERENCE
,
1913 cplus_demangle_type (di
), NULL
);
1918 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_COMPLEX
,
1919 cplus_demangle_type (di
), NULL
);
1924 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_IMAGINARY
,
1925 cplus_demangle_type (di
), NULL
);
1930 ret
= d_source_name (di
);
1931 ret
= d_make_comp (di
, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
,
1932 cplus_demangle_type (di
), ret
);
1941 if (! d_add_substitution (di
, ret
))
1948 /* <CV-qualifiers> ::= [r] [V] [K] */
1950 static struct demangle_component
**
1951 d_cv_qualifiers (di
, pret
, member_fn
)
1953 struct demangle_component
**pret
;
1958 peek
= d_peek_char (di
);
1959 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
1961 enum demangle_component_type t
;
1967 ? DEMANGLE_COMPONENT_RESTRICT_THIS
1968 : DEMANGLE_COMPONENT_RESTRICT
);
1969 di
->expansion
+= sizeof "restrict";
1971 else if (peek
== 'V')
1974 ? DEMANGLE_COMPONENT_VOLATILE_THIS
1975 : DEMANGLE_COMPONENT_VOLATILE
);
1976 di
->expansion
+= sizeof "volatile";
1981 ? DEMANGLE_COMPONENT_CONST_THIS
1982 : DEMANGLE_COMPONENT_CONST
);
1983 di
->expansion
+= sizeof "const";
1986 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
1989 pret
= &d_left (*pret
);
1991 peek
= d_peek_char (di
);
1997 /* <function-type> ::= F [Y] <bare-function-type> E */
1999 static struct demangle_component
*
2000 d_function_type (di
)
2003 struct demangle_component
*ret
;
2005 if (d_next_char (di
) != 'F')
2007 if (d_peek_char (di
) == 'Y')
2009 /* Function has C linkage. We don't print this information.
2010 FIXME: We should print it in verbose mode. */
2013 ret
= d_bare_function_type (di
, 1);
2014 if (d_next_char (di
) != 'E')
2019 /* <bare-function-type> ::= <type>+ */
2021 static struct demangle_component
*
2022 d_bare_function_type (di
, has_return_type
)
2024 int has_return_type
;
2026 struct demangle_component
*return_type
;
2027 struct demangle_component
*tl
;
2028 struct demangle_component
**ptl
;
2036 struct demangle_component
*type
;
2038 peek
= d_peek_char (di
);
2039 if (peek
== '\0' || peek
== 'E')
2041 type
= cplus_demangle_type (di
);
2044 if (has_return_type
)
2047 has_return_type
= 0;
2051 *ptl
= d_make_comp (di
, DEMANGLE_COMPONENT_ARGLIST
, type
, NULL
);
2054 ptl
= &d_right (*ptl
);
2058 /* There should be at least one parameter type besides the optional
2059 return type. A function which takes no arguments will have a
2060 single parameter type void. */
2064 /* If we have a single parameter type void, omit it. */
2065 if (d_right (tl
) == NULL
2066 && d_left (tl
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2067 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
2069 di
->expansion
-= d_left (tl
)->u
.s_builtin
.type
->len
;
2073 return d_make_comp (di
, DEMANGLE_COMPONENT_FUNCTION_TYPE
, return_type
, tl
);
2076 /* <class-enum-type> ::= <name> */
2078 static struct demangle_component
*
2079 d_class_enum_type (di
)
2085 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2086 ::= A [<(dimension) expression>] _ <(element) type>
2089 static struct demangle_component
*
2094 struct demangle_component
*dim
;
2096 if (d_next_char (di
) != 'A')
2099 peek
= d_peek_char (di
);
2102 else if (IS_DIGIT (peek
))
2110 peek
= d_peek_char (di
);
2112 while (IS_DIGIT (peek
));
2113 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2119 dim
= d_expression (di
);
2124 if (d_next_char (di
) != '_')
2127 return d_make_comp (di
, DEMANGLE_COMPONENT_ARRAY_TYPE
, dim
,
2128 cplus_demangle_type (di
));
2131 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2133 static struct demangle_component
*
2134 d_pointer_to_member_type (di
)
2137 struct demangle_component
*cl
;
2138 struct demangle_component
*mem
;
2139 struct demangle_component
**pmem
;
2141 if (d_next_char (di
) != 'M')
2144 cl
= cplus_demangle_type (di
);
2146 /* The ABI specifies that any type can be a substitution source, and
2147 that M is followed by two types, and that when a CV-qualified
2148 type is seen both the base type and the CV-qualified types are
2149 substitution sources. The ABI also specifies that for a pointer
2150 to a CV-qualified member function, the qualifiers are attached to
2151 the second type. Given the grammar, a plain reading of the ABI
2152 suggests that both the CV-qualified member function and the
2153 non-qualified member function are substitution sources. However,
2154 g++ does not work that way. g++ treats only the CV-qualified
2155 member function as a substitution source. FIXME. So to work
2156 with g++, we need to pull off the CV-qualifiers here, in order to
2157 avoid calling add_substitution() in cplus_demangle_type(). */
2159 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2162 *pmem
= cplus_demangle_type (di
);
2164 return d_make_comp (di
, DEMANGLE_COMPONENT_PTRMEM_TYPE
, cl
, mem
);
2167 /* <template-param> ::= T_
2168 ::= T <(parameter-2 non-negative) number> _
2171 static struct demangle_component
*
2172 d_template_param (di
)
2177 if (d_next_char (di
) != 'T')
2180 if (d_peek_char (di
) == '_')
2184 param
= d_number (di
);
2190 if (d_next_char (di
) != '_')
2195 return d_make_template_param (di
, param
);
2198 /* <template-args> ::= I <template-arg>+ E */
2200 static struct demangle_component
*
2201 d_template_args (di
)
2204 struct demangle_component
*hold_last_name
;
2205 struct demangle_component
*al
;
2206 struct demangle_component
**pal
;
2208 /* Preserve the last name we saw--don't let the template arguments
2209 clobber it, as that would give us the wrong name for a subsequent
2210 constructor or destructor. */
2211 hold_last_name
= di
->last_name
;
2213 if (d_next_char (di
) != 'I')
2220 struct demangle_component
*a
;
2222 a
= d_template_arg (di
);
2226 *pal
= d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
, a
, NULL
);
2229 pal
= &d_right (*pal
);
2231 if (d_peek_char (di
) == 'E')
2238 di
->last_name
= hold_last_name
;
2243 /* <template-arg> ::= <type>
2244 ::= X <expression> E
2248 static struct demangle_component
*
2252 struct demangle_component
*ret
;
2254 switch (d_peek_char (di
))
2258 ret
= d_expression (di
);
2259 if (d_next_char (di
) != 'E')
2264 return d_expr_primary (di
);
2267 return cplus_demangle_type (di
);
2271 /* <expression> ::= <(unary) operator-name> <expression>
2272 ::= <(binary) operator-name> <expression> <expression>
2273 ::= <(trinary) operator-name> <expression> <expression> <expression>
2275 ::= <template-param>
2276 ::= sr <type> <unqualified-name>
2277 ::= sr <type> <unqualified-name> <template-args>
2281 static struct demangle_component
*
2287 peek
= d_peek_char (di
);
2289 return d_expr_primary (di
);
2290 else if (peek
== 'T')
2291 return d_template_param (di
);
2292 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2294 struct demangle_component
*type
;
2295 struct demangle_component
*name
;
2298 type
= cplus_demangle_type (di
);
2299 name
= d_unqualified_name (di
);
2300 if (d_peek_char (di
) != 'I')
2301 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
, name
);
2303 return d_make_comp (di
, DEMANGLE_COMPONENT_QUAL_NAME
, type
,
2304 d_make_comp (di
, DEMANGLE_COMPONENT_TEMPLATE
, name
,
2305 d_template_args (di
)));
2309 struct demangle_component
*op
;
2312 op
= d_operator_name (di
);
2316 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
)
2317 di
->expansion
+= op
->u
.s_operator
.op
->len
- 2;
2319 if (op
->type
== DEMANGLE_COMPONENT_OPERATOR
2320 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2321 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2322 cplus_demangle_type (di
));
2328 case DEMANGLE_COMPONENT_OPERATOR
:
2329 args
= op
->u
.s_operator
.op
->args
;
2331 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
2332 args
= op
->u
.s_extended_operator
.args
;
2334 case DEMANGLE_COMPONENT_CAST
:
2342 return d_make_comp (di
, DEMANGLE_COMPONENT_UNARY
, op
,
2346 struct demangle_component
*left
;
2348 left
= d_expression (di
);
2349 return d_make_comp (di
, DEMANGLE_COMPONENT_BINARY
, op
,
2351 DEMANGLE_COMPONENT_BINARY_ARGS
,
2353 d_expression (di
)));
2357 struct demangle_component
*first
;
2358 struct demangle_component
*second
;
2360 first
= d_expression (di
);
2361 second
= d_expression (di
);
2362 return d_make_comp (di
, DEMANGLE_COMPONENT_TRINARY
, op
,
2364 DEMANGLE_COMPONENT_TRINARY_ARG1
,
2367 DEMANGLE_COMPONENT_TRINARY_ARG2
,
2369 d_expression (di
))));
2377 /* <expr-primary> ::= L <type> <(value) number> E
2378 ::= L <type> <(value) float> E
2379 ::= L <mangled-name> E
2382 static struct demangle_component
*
2386 struct demangle_component
*ret
;
2388 if (d_next_char (di
) != 'L')
2390 if (d_peek_char (di
) == '_')
2391 ret
= cplus_demangle_mangled_name (di
, 0);
2394 struct demangle_component
*type
;
2395 enum demangle_component_type t
;
2398 type
= cplus_demangle_type (di
);
2400 /* If we have a type we know how to print, we aren't going to
2401 print the type name itself. */
2402 if (type
->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
2403 && type
->u
.s_builtin
.type
->print
!= D_PRINT_DEFAULT
)
2404 di
->expansion
-= type
->u
.s_builtin
.type
->len
;
2406 /* Rather than try to interpret the literal value, we just
2407 collect it as a string. Note that it's possible to have a
2408 floating point literal here. The ABI specifies that the
2409 format of such literals is machine independent. That's fine,
2410 but what's not fine is that versions of g++ up to 3.2 with
2411 -fabi-version=1 used upper case letters in the hex constant,
2412 and dumped out gcc's internal representation. That makes it
2413 hard to tell where the constant ends, and hard to dump the
2414 constant in any readable form anyhow. We don't attempt to
2415 handle these cases. */
2417 t
= DEMANGLE_COMPONENT_LITERAL
;
2418 if (d_peek_char (di
) == 'n')
2420 t
= DEMANGLE_COMPONENT_LITERAL_NEG
;
2424 while (d_peek_char (di
) != 'E')
2426 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
2428 if (d_next_char (di
) != 'E')
2433 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2434 ::= Z <(function) encoding> E s [<discriminator>]
2437 static struct demangle_component
*
2441 struct demangle_component
*function
;
2443 if (d_next_char (di
) != 'Z')
2446 function
= d_encoding (di
, 0);
2448 if (d_next_char (di
) != 'E')
2451 if (d_peek_char (di
) == 's')
2454 if (! d_discriminator (di
))
2456 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
,
2457 d_make_name (di
, "string literal",
2458 sizeof "string literal" - 1));
2462 struct demangle_component
*name
;
2465 if (! d_discriminator (di
))
2467 return d_make_comp (di
, DEMANGLE_COMPONENT_LOCAL_NAME
, function
, name
);
2471 /* <discriminator> ::= _ <(non-negative) number>
2473 We demangle the discriminator, but we don't print it out. FIXME:
2474 We should print it out in verbose mode. */
2477 d_discriminator (di
)
2482 if (d_peek_char (di
) != '_')
2485 discrim
= d_number (di
);
2491 /* Add a new substitution. */
2494 d_add_substitution (di
, dc
)
2496 struct demangle_component
*dc
;
2500 if (di
->next_sub
>= di
->num_subs
)
2502 di
->subs
[di
->next_sub
] = dc
;
2507 /* <substitution> ::= S <seq-id> _
2517 If PREFIX is non-zero, then this type is being used as a prefix in
2518 a qualified name. In this case, for the standard substitutions, we
2519 need to check whether we are being used as a prefix for a
2520 constructor or destructor, and return a full template name.
2521 Otherwise we will get something like std::iostream::~iostream()
2522 which does not correspond particularly well to any function which
2523 actually appears in the source.
2526 static const struct d_standard_sub_info standard_subs
[] =
2531 { 'a', NL ("std::allocator"),
2532 NL ("std::allocator"),
2534 { 'b', NL ("std::basic_string"),
2535 NL ("std::basic_string"),
2536 NL ("basic_string") },
2537 { 's', NL ("std::string"),
2538 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2539 NL ("basic_string") },
2540 { 'i', NL ("std::istream"),
2541 NL ("std::basic_istream<char, std::char_traits<char> >"),
2542 NL ("basic_istream") },
2543 { 'o', NL ("std::ostream"),
2544 NL ("std::basic_ostream<char, std::char_traits<char> >"),
2545 NL ("basic_ostream") },
2546 { 'd', NL ("std::iostream"),
2547 NL ("std::basic_iostream<char, std::char_traits<char> >"),
2548 NL ("basic_iostream") }
2551 static struct demangle_component
*
2552 d_substitution (di
, prefix
)
2558 if (d_next_char (di
) != 'S')
2561 c
= d_next_char (di
);
2562 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
2572 id
= id
* 36 + c
- '0';
2573 else if (IS_UPPER (c
))
2574 id
= id
* 36 + c
- 'A' + 10;
2577 c
= d_next_char (di
);
2584 if (id
>= di
->next_sub
)
2589 return di
->subs
[id
];
2594 const struct d_standard_sub_info
*p
;
2595 const struct d_standard_sub_info
*pend
;
2597 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
2598 if (! verbose
&& prefix
)
2602 peek
= d_peek_char (di
);
2603 if (peek
== 'C' || peek
== 'D')
2607 pend
= (&standard_subs
[0]
2608 + sizeof standard_subs
/ sizeof standard_subs
[0]);
2609 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
2616 if (p
->set_last_name
!= NULL
)
2617 di
->last_name
= d_make_sub (di
, p
->set_last_name
,
2618 p
->set_last_name_len
);
2621 s
= p
->full_expansion
;
2626 s
= p
->simple_expansion
;
2627 len
= p
->simple_len
;
2629 di
->expansion
+= len
;
2630 return d_make_sub (di
, s
, len
);
2638 /* Resize the print buffer. */
2641 d_print_resize (dpi
, add
)
2642 struct d_print_info
*dpi
;
2647 if (dpi
->buf
== NULL
)
2649 need
= dpi
->len
+ add
;
2650 while (need
> dpi
->alc
)
2655 newalc
= dpi
->alc
* 2;
2656 newbuf
= realloc (dpi
->buf
, newalc
);
2661 dpi
->allocation_failure
= 1;
2669 /* Append a character to the print buffer. */
2672 d_print_append_char (dpi
, c
)
2673 struct d_print_info
*dpi
;
2676 if (dpi
->buf
!= NULL
)
2678 if (dpi
->len
>= dpi
->alc
)
2680 d_print_resize (dpi
, 1);
2681 if (dpi
->buf
== NULL
)
2685 dpi
->buf
[dpi
->len
] = c
;
2690 /* Append a buffer to the print buffer. */
2693 d_print_append_buffer (dpi
, s
, l
)
2694 struct d_print_info
*dpi
;
2698 if (dpi
->buf
!= NULL
)
2700 if (dpi
->len
+ l
> dpi
->alc
)
2702 d_print_resize (dpi
, l
);
2703 if (dpi
->buf
== NULL
)
2707 memcpy (dpi
->buf
+ dpi
->len
, s
, l
);
2712 /* Indicate that an error occurred during printing. */
2716 struct d_print_info
*dpi
;
2722 /* Turn components into a human readable string. OPTIONS is the
2723 options bits passed to the demangler. DC is the tree to print.
2724 ESTIMATE is a guess at the length of the result. This returns a
2725 string allocated by malloc, or NULL on error. On success, this
2726 sets *PALC to the size of the allocated buffer. On failure, this
2727 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
2730 CP_STATIC_IF_GLIBCPP_V3
2732 cplus_demangle_print (options
, dc
, estimate
, palc
)
2734 const struct demangle_component
*dc
;
2738 struct d_print_info dpi
;
2740 dpi
.options
= options
;
2742 dpi
.alc
= estimate
+ 1;
2743 dpi
.buf
= malloc (dpi
.alc
);
2744 if (dpi
.buf
== NULL
)
2751 dpi
.templates
= NULL
;
2752 dpi
.modifiers
= NULL
;
2754 dpi
.allocation_failure
= 0;
2756 d_print_comp (&dpi
, dc
);
2758 d_append_char (&dpi
, '\0');
2760 if (dpi
.buf
!= NULL
)
2763 *palc
= dpi
.allocation_failure
;
2768 /* Subroutine to handle components. */
2771 d_print_comp (dpi
, dc
)
2772 struct d_print_info
*dpi
;
2773 const struct demangle_component
*dc
;
2777 d_print_error (dpi
);
2780 if (d_print_saw_error (dpi
))
2785 case DEMANGLE_COMPONENT_NAME
:
2786 if ((dpi
->options
& DMGL_JAVA
) == 0)
2787 d_append_buffer (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2789 d_print_java_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2792 case DEMANGLE_COMPONENT_QUAL_NAME
:
2793 case DEMANGLE_COMPONENT_LOCAL_NAME
:
2794 d_print_comp (dpi
, d_left (dc
));
2795 if ((dpi
->options
& DMGL_JAVA
) == 0)
2796 d_append_string_constant (dpi
, "::");
2798 d_append_char (dpi
, '.');
2799 d_print_comp (dpi
, d_right (dc
));
2802 case DEMANGLE_COMPONENT_TYPED_NAME
:
2804 struct d_print_mod
*hold_modifiers
;
2805 struct demangle_component
*typed_name
;
2806 struct d_print_mod adpm
[4];
2808 struct d_print_template dpt
;
2810 /* Pass the name down to the type so that it can be printed in
2811 the right place for the type. We also have to pass down
2812 any CV-qualifiers, which apply to the this parameter. */
2813 hold_modifiers
= dpi
->modifiers
;
2815 typed_name
= d_left (dc
);
2816 while (typed_name
!= NULL
)
2818 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2820 d_print_error (dpi
);
2824 adpm
[i
].next
= dpi
->modifiers
;
2825 dpi
->modifiers
= &adpm
[i
];
2826 adpm
[i
].mod
= typed_name
;
2827 adpm
[i
].printed
= 0;
2828 adpm
[i
].templates
= dpi
->templates
;
2831 if (typed_name
->type
!= DEMANGLE_COMPONENT_RESTRICT_THIS
2832 && typed_name
->type
!= DEMANGLE_COMPONENT_VOLATILE_THIS
2833 && typed_name
->type
!= DEMANGLE_COMPONENT_CONST_THIS
)
2836 typed_name
= d_left (typed_name
);
2839 /* If typed_name is a template, then it applies to the
2840 function type as well. */
2841 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2843 dpt
.next
= dpi
->templates
;
2844 dpi
->templates
= &dpt
;
2845 dpt
.template = typed_name
;
2848 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
2849 there may be CV-qualifiers on its right argument which
2850 really apply here; this happens when parsing a class which
2851 is local to a function. */
2852 if (typed_name
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
2854 struct demangle_component
*local_name
;
2856 local_name
= d_right (typed_name
);
2857 while (local_name
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
2858 || local_name
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
2859 || local_name
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
2861 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2863 d_print_error (dpi
);
2867 adpm
[i
] = adpm
[i
- 1];
2868 adpm
[i
].next
= &adpm
[i
- 1];
2869 dpi
->modifiers
= &adpm
[i
];
2871 adpm
[i
- 1].mod
= local_name
;
2872 adpm
[i
- 1].printed
= 0;
2873 adpm
[i
- 1].templates
= dpi
->templates
;
2876 local_name
= d_left (local_name
);
2880 d_print_comp (dpi
, d_right (dc
));
2882 if (typed_name
->type
== DEMANGLE_COMPONENT_TEMPLATE
)
2883 dpi
->templates
= dpt
.next
;
2885 /* If the modifiers didn't get printed by the type, print them
2890 if (! adpm
[i
].printed
)
2892 d_append_char (dpi
, ' ');
2893 d_print_mod (dpi
, adpm
[i
].mod
);
2897 dpi
->modifiers
= hold_modifiers
;
2902 case DEMANGLE_COMPONENT_TEMPLATE
:
2904 struct d_print_mod
*hold_dpm
;
2906 /* Don't push modifiers into a template definition. Doing so
2907 could give the wrong definition for a template argument.
2908 Instead, treat the template essentially as a name. */
2910 hold_dpm
= dpi
->modifiers
;
2911 dpi
->modifiers
= NULL
;
2913 d_print_comp (dpi
, d_left (dc
));
2914 if (d_last_char (dpi
) == '<')
2915 d_append_char (dpi
, ' ');
2916 d_append_char (dpi
, '<');
2917 d_print_comp (dpi
, d_right (dc
));
2918 /* Avoid generating two consecutive '>' characters, to avoid
2919 the C++ syntactic ambiguity. */
2920 if (d_last_char (dpi
) == '>')
2921 d_append_char (dpi
, ' ');
2922 d_append_char (dpi
, '>');
2924 dpi
->modifiers
= hold_dpm
;
2929 case DEMANGLE_COMPONENT_TEMPLATE_PARAM
:
2932 struct demangle_component
*a
;
2933 struct d_print_template
*hold_dpt
;
2935 if (dpi
->templates
== NULL
)
2937 d_print_error (dpi
);
2940 i
= dc
->u
.s_number
.number
;
2941 for (a
= d_right (dpi
->templates
->template);
2945 if (a
->type
!= DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
)
2947 d_print_error (dpi
);
2954 if (i
!= 0 || a
== NULL
)
2956 d_print_error (dpi
);
2960 /* While processing this parameter, we need to pop the list of
2961 templates. This is because the template parameter may
2962 itself be a reference to a parameter of an outer
2965 hold_dpt
= dpi
->templates
;
2966 dpi
->templates
= hold_dpt
->next
;
2968 d_print_comp (dpi
, d_left (a
));
2970 dpi
->templates
= hold_dpt
;
2975 case DEMANGLE_COMPONENT_CTOR
:
2976 d_print_comp (dpi
, dc
->u
.s_ctor
.name
);
2979 case DEMANGLE_COMPONENT_DTOR
:
2980 d_append_char (dpi
, '~');
2981 d_print_comp (dpi
, dc
->u
.s_dtor
.name
);
2984 case DEMANGLE_COMPONENT_VTABLE
:
2985 d_append_string_constant (dpi
, "vtable for ");
2986 d_print_comp (dpi
, d_left (dc
));
2989 case DEMANGLE_COMPONENT_VTT
:
2990 d_append_string_constant (dpi
, "VTT for ");
2991 d_print_comp (dpi
, d_left (dc
));
2994 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE
:
2995 d_append_string_constant (dpi
, "construction vtable for ");
2996 d_print_comp (dpi
, d_left (dc
));
2997 d_append_string_constant (dpi
, "-in-");
2998 d_print_comp (dpi
, d_right (dc
));
3001 case DEMANGLE_COMPONENT_TYPEINFO
:
3002 d_append_string_constant (dpi
, "typeinfo for ");
3003 d_print_comp (dpi
, d_left (dc
));
3006 case DEMANGLE_COMPONENT_TYPEINFO_NAME
:
3007 d_append_string_constant (dpi
, "typeinfo name for ");
3008 d_print_comp (dpi
, d_left (dc
));
3011 case DEMANGLE_COMPONENT_TYPEINFO_FN
:
3012 d_append_string_constant (dpi
, "typeinfo fn for ");
3013 d_print_comp (dpi
, d_left (dc
));
3016 case DEMANGLE_COMPONENT_THUNK
:
3017 d_append_string_constant (dpi
, "non-virtual thunk to ");
3018 d_print_comp (dpi
, d_left (dc
));
3021 case DEMANGLE_COMPONENT_VIRTUAL_THUNK
:
3022 d_append_string_constant (dpi
, "virtual thunk to ");
3023 d_print_comp (dpi
, d_left (dc
));
3026 case DEMANGLE_COMPONENT_COVARIANT_THUNK
:
3027 d_append_string_constant (dpi
, "covariant return thunk to ");
3028 d_print_comp (dpi
, d_left (dc
));
3031 case DEMANGLE_COMPONENT_JAVA_CLASS
:
3032 d_append_string_constant (dpi
, "java Class for ");
3033 d_print_comp (dpi
, d_left (dc
));
3036 case DEMANGLE_COMPONENT_GUARD
:
3037 d_append_string_constant (dpi
, "guard variable for ");
3038 d_print_comp (dpi
, d_left (dc
));
3041 case DEMANGLE_COMPONENT_REFTEMP
:
3042 d_append_string_constant (dpi
, "reference temporary for ");
3043 d_print_comp (dpi
, d_left (dc
));
3046 case DEMANGLE_COMPONENT_SUB_STD
:
3047 d_append_buffer (dpi
, dc
->u
.s_string
.string
, dc
->u
.s_string
.len
);
3050 case DEMANGLE_COMPONENT_RESTRICT
:
3051 case DEMANGLE_COMPONENT_VOLATILE
:
3052 case DEMANGLE_COMPONENT_CONST
:
3053 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3054 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3055 case DEMANGLE_COMPONENT_CONST_THIS
:
3056 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3057 case DEMANGLE_COMPONENT_POINTER
:
3058 case DEMANGLE_COMPONENT_REFERENCE
:
3059 case DEMANGLE_COMPONENT_COMPLEX
:
3060 case DEMANGLE_COMPONENT_IMAGINARY
:
3062 /* We keep a list of modifiers on the stack. */
3063 struct d_print_mod dpm
;
3065 dpm
.next
= dpi
->modifiers
;
3066 dpi
->modifiers
= &dpm
;
3069 dpm
.templates
= dpi
->templates
;
3071 d_print_comp (dpi
, d_left (dc
));
3073 /* If the modifier didn't get printed by the type, print it
3076 d_print_mod (dpi
, dc
);
3078 dpi
->modifiers
= dpm
.next
;
3083 case DEMANGLE_COMPONENT_BUILTIN_TYPE
:
3084 if ((dpi
->options
& DMGL_JAVA
) == 0)
3085 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->name
,
3086 dc
->u
.s_builtin
.type
->len
);
3088 d_append_buffer (dpi
, dc
->u
.s_builtin
.type
->java_name
,
3089 dc
->u
.s_builtin
.type
->java_len
);
3092 case DEMANGLE_COMPONENT_VENDOR_TYPE
:
3093 d_print_comp (dpi
, d_left (dc
));
3096 case DEMANGLE_COMPONENT_FUNCTION_TYPE
:
3098 if (d_left (dc
) != NULL
)
3100 struct d_print_mod dpm
;
3102 /* We must pass this type down as a modifier in order to
3103 print it in the right location. */
3105 dpm
.next
= dpi
->modifiers
;
3106 dpi
->modifiers
= &dpm
;
3109 dpm
.templates
= dpi
->templates
;
3111 d_print_comp (dpi
, d_left (dc
));
3113 dpi
->modifiers
= dpm
.next
;
3118 d_append_char (dpi
, ' ');
3121 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
3126 case DEMANGLE_COMPONENT_ARRAY_TYPE
:
3128 struct d_print_mod dpm
;
3130 /* We must pass this type down as a modifier in order to print
3131 multi-dimensional arrays correctly. */
3133 dpm
.next
= dpi
->modifiers
;
3134 dpi
->modifiers
= &dpm
;
3137 dpm
.templates
= dpi
->templates
;
3139 d_print_comp (dpi
, d_right (dc
));
3141 dpi
->modifiers
= dpm
.next
;
3146 d_print_array_type (dpi
, dc
, dpi
->modifiers
);
3151 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3153 struct d_print_mod dpm
;
3155 dpm
.next
= dpi
->modifiers
;
3156 dpi
->modifiers
= &dpm
;
3159 dpm
.templates
= dpi
->templates
;
3161 d_print_comp (dpi
, d_right (dc
));
3163 /* If the modifier didn't get printed by the type, print it
3167 d_append_char (dpi
, ' ');
3168 d_print_comp (dpi
, d_left (dc
));
3169 d_append_string_constant (dpi
, "::*");
3172 dpi
->modifiers
= dpm
.next
;
3177 case DEMANGLE_COMPONENT_ARGLIST
:
3178 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
:
3179 d_print_comp (dpi
, d_left (dc
));
3180 if (d_right (dc
) != NULL
)
3182 d_append_string_constant (dpi
, ", ");
3183 d_print_comp (dpi
, d_right (dc
));
3187 case DEMANGLE_COMPONENT_OPERATOR
:
3191 d_append_string_constant (dpi
, "operator");
3192 c
= dc
->u
.s_operator
.op
->name
[0];
3194 d_append_char (dpi
, ' ');
3195 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3196 dc
->u
.s_operator
.op
->len
);
3200 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR
:
3201 d_append_string_constant (dpi
, "operator ");
3202 d_print_comp (dpi
, dc
->u
.s_extended_operator
.name
);
3205 case DEMANGLE_COMPONENT_CAST
:
3206 d_append_string_constant (dpi
, "operator ");
3207 d_print_cast (dpi
, dc
);
3210 case DEMANGLE_COMPONENT_UNARY
:
3211 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_CAST
)
3212 d_print_expr_op (dpi
, d_left (dc
));
3215 d_append_string_constant (dpi
, "((");
3216 d_print_cast (dpi
, d_left (dc
));
3217 d_append_char (dpi
, ')');
3219 d_append_char (dpi
, '(');
3220 d_print_comp (dpi
, d_right (dc
));
3221 d_append_char (dpi
, ')');
3222 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_CAST
)
3223 d_append_char (dpi
, ')');
3226 case DEMANGLE_COMPONENT_BINARY
:
3227 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_BINARY_ARGS
)
3229 d_print_error (dpi
);
3233 /* We wrap an expression which uses the greater-than operator in
3234 an extra layer of parens so that it does not get confused
3235 with the '>' which ends the template parameters. */
3236 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3237 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3238 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3239 d_append_char (dpi
, '(');
3241 d_append_char (dpi
, '(');
3242 d_print_comp (dpi
, d_left (d_right (dc
)));
3243 d_append_string_constant (dpi
, ") ");
3244 d_print_expr_op (dpi
, d_left (dc
));
3245 d_append_string_constant (dpi
, " (");
3246 d_print_comp (dpi
, d_right (d_right (dc
)));
3247 d_append_char (dpi
, ')');
3249 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_OPERATOR
3250 && d_left (dc
)->u
.s_operator
.op
->len
== 1
3251 && d_left (dc
)->u
.s_operator
.op
->name
[0] == '>')
3252 d_append_char (dpi
, ')');
3256 case DEMANGLE_COMPONENT_BINARY_ARGS
:
3257 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
3258 d_print_error (dpi
);
3261 case DEMANGLE_COMPONENT_TRINARY
:
3262 if (d_right (dc
)->type
!= DEMANGLE_COMPONENT_TRINARY_ARG1
3263 || d_right (d_right (dc
))->type
!= DEMANGLE_COMPONENT_TRINARY_ARG2
)
3265 d_print_error (dpi
);
3268 d_append_char (dpi
, '(');
3269 d_print_comp (dpi
, d_left (d_right (dc
)));
3270 d_append_string_constant (dpi
, ") ");
3271 d_print_expr_op (dpi
, d_left (dc
));
3272 d_append_string_constant (dpi
, " (");
3273 d_print_comp (dpi
, d_left (d_right (d_right (dc
))));
3274 d_append_string_constant (dpi
, ") : (");
3275 d_print_comp (dpi
, d_right (d_right (d_right (dc
))));
3276 d_append_char (dpi
, ')');
3279 case DEMANGLE_COMPONENT_TRINARY_ARG1
:
3280 case DEMANGLE_COMPONENT_TRINARY_ARG2
:
3281 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
3282 d_print_error (dpi
);
3285 case DEMANGLE_COMPONENT_LITERAL
:
3286 case DEMANGLE_COMPONENT_LITERAL_NEG
:
3287 /* For some builtin types, produce simpler output. */
3288 if (d_left (dc
)->type
== DEMANGLE_COMPONENT_BUILTIN_TYPE
)
3290 switch (d_left (dc
)->u
.s_builtin
.type
->print
)
3293 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
3295 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3296 d_append_char (dpi
, '-');
3297 d_print_comp (dpi
, d_right (dc
));
3303 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
)
3305 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3306 d_append_char (dpi
, '-');
3307 d_print_comp (dpi
, d_right (dc
));
3308 d_append_char (dpi
, 'l');
3314 if (d_right (dc
)->type
== DEMANGLE_COMPONENT_NAME
3315 && d_right (dc
)->u
.s_name
.len
== 1
3316 && dc
->type
== DEMANGLE_COMPONENT_LITERAL
)
3318 switch (d_right (dc
)->u
.s_name
.s
[0])
3321 d_append_string_constant (dpi
, "false");
3324 d_append_string_constant (dpi
, "true");
3337 d_append_char (dpi
, '(');
3338 d_print_comp (dpi
, d_left (dc
));
3339 d_append_char (dpi
, ')');
3340 if (dc
->type
== DEMANGLE_COMPONENT_LITERAL_NEG
)
3341 d_append_char (dpi
, '-');
3342 d_print_comp (dpi
, d_right (dc
));
3346 d_print_error (dpi
);
3351 /* Print a Java dentifier. For Java we try to handle encoded extended
3352 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
3353 so we don't it for C++. Characters are encoded as
3357 d_print_java_identifier (dpi
, name
, len
)
3358 struct d_print_info
*dpi
;
3366 for (p
= name
; p
< end
; ++p
)
3377 for (q
= p
+ 3; q
< end
; ++q
)
3383 else if (*q
>= 'A' && *q
<= 'F')
3384 dig
= *q
- 'A' + 10;
3385 else if (*q
>= 'a' && *q
<= 'f')
3386 dig
= *q
- 'a' + 10;
3392 /* If the Unicode character is larger than 256, we don't try
3393 to deal with it here. FIXME. */
3394 if (q
< end
&& *q
== '_' && c
< 256)
3396 d_append_char (dpi
, c
);
3402 d_append_char (dpi
, *p
);
3406 /* Print a list of modifiers. SUFFIX is 1 if we are printing
3407 qualifiers on this after printing a function. */
3410 d_print_mod_list (dpi
, mods
, suffix
)
3411 struct d_print_info
*dpi
;
3412 struct d_print_mod
*mods
;
3415 struct d_print_template
*hold_dpt
;
3417 if (mods
== NULL
|| d_print_saw_error (dpi
))
3422 && (mods
->mod
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3423 || mods
->mod
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3424 || mods
->mod
->type
== DEMANGLE_COMPONENT_CONST_THIS
)))
3426 d_print_mod_list (dpi
, mods
->next
, suffix
);
3432 hold_dpt
= dpi
->templates
;
3433 dpi
->templates
= mods
->templates
;
3435 if (mods
->mod
->type
== DEMANGLE_COMPONENT_FUNCTION_TYPE
)
3437 d_print_function_type (dpi
, mods
->mod
, mods
->next
);
3438 dpi
->templates
= hold_dpt
;
3441 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3443 d_print_array_type (dpi
, mods
->mod
, mods
->next
);
3444 dpi
->templates
= hold_dpt
;
3447 else if (mods
->mod
->type
== DEMANGLE_COMPONENT_LOCAL_NAME
)
3449 struct d_print_mod
*hold_modifiers
;
3450 struct demangle_component
*dc
;
3452 /* When this is on the modifier stack, we have pulled any
3453 qualifiers off the right argument already. Otherwise, we
3454 print it as usual, but don't let the left argument see any
3457 hold_modifiers
= dpi
->modifiers
;
3458 dpi
->modifiers
= NULL
;
3459 d_print_comp (dpi
, d_left (mods
->mod
));
3460 dpi
->modifiers
= hold_modifiers
;
3462 if ((dpi
->options
& DMGL_JAVA
) == 0)
3463 d_append_string_constant (dpi
, "::");
3465 d_append_char (dpi
, '.');
3467 dc
= d_right (mods
->mod
);
3468 while (dc
->type
== DEMANGLE_COMPONENT_RESTRICT_THIS
3469 || dc
->type
== DEMANGLE_COMPONENT_VOLATILE_THIS
3470 || dc
->type
== DEMANGLE_COMPONENT_CONST_THIS
)
3473 d_print_comp (dpi
, dc
);
3475 dpi
->templates
= hold_dpt
;
3479 d_print_mod (dpi
, mods
->mod
);
3481 dpi
->templates
= hold_dpt
;
3483 d_print_mod_list (dpi
, mods
->next
, suffix
);
3486 /* Print a modifier. */
3489 d_print_mod (dpi
, mod
)
3490 struct d_print_info
*dpi
;
3491 const struct demangle_component
*mod
;
3495 case DEMANGLE_COMPONENT_RESTRICT
:
3496 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3497 d_append_string_constant (dpi
, " restrict");
3499 case DEMANGLE_COMPONENT_VOLATILE
:
3500 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3501 d_append_string_constant (dpi
, " volatile");
3503 case DEMANGLE_COMPONENT_CONST
:
3504 case DEMANGLE_COMPONENT_CONST_THIS
:
3505 d_append_string_constant (dpi
, " const");
3507 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3508 d_append_char (dpi
, ' ');
3509 d_print_comp (dpi
, d_right (mod
));
3511 case DEMANGLE_COMPONENT_POINTER
:
3512 /* There is no pointer symbol in Java. */
3513 if ((dpi
->options
& DMGL_JAVA
) == 0)
3514 d_append_char (dpi
, '*');
3516 case DEMANGLE_COMPONENT_REFERENCE
:
3517 d_append_char (dpi
, '&');
3519 case DEMANGLE_COMPONENT_COMPLEX
:
3520 d_append_string_constant (dpi
, "complex ");
3522 case DEMANGLE_COMPONENT_IMAGINARY
:
3523 d_append_string_constant (dpi
, "imaginary ");
3525 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3526 if (d_last_char (dpi
) != '(')
3527 d_append_char (dpi
, ' ');
3528 d_print_comp (dpi
, d_left (mod
));
3529 d_append_string_constant (dpi
, "::*");
3531 case DEMANGLE_COMPONENT_TYPED_NAME
:
3532 d_print_comp (dpi
, d_left (mod
));
3535 /* Otherwise, we have something that won't go back on the
3536 modifier stack, so we can just print it. */
3537 d_print_comp (dpi
, mod
);
3542 /* Print a function type, except for the return type. */
3545 d_print_function_type (dpi
, dc
, mods
)
3546 struct d_print_info
*dpi
;
3547 const struct demangle_component
*dc
;
3548 struct d_print_mod
*mods
;
3552 struct d_print_mod
*p
;
3553 struct d_print_mod
*hold_modifiers
;
3557 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3563 switch (p
->mod
->type
)
3565 case DEMANGLE_COMPONENT_RESTRICT
:
3566 case DEMANGLE_COMPONENT_VOLATILE
:
3567 case DEMANGLE_COMPONENT_CONST
:
3568 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL
:
3569 case DEMANGLE_COMPONENT_POINTER
:
3570 case DEMANGLE_COMPONENT_REFERENCE
:
3571 case DEMANGLE_COMPONENT_COMPLEX
:
3572 case DEMANGLE_COMPONENT_IMAGINARY
:
3573 case DEMANGLE_COMPONENT_PTRMEM_TYPE
:
3576 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
3577 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
3578 case DEMANGLE_COMPONENT_CONST_THIS
:
3587 if (d_left (dc
) != NULL
&& ! saw_mod
)
3592 switch (d_last_char (dpi
))
3600 d_append_char (dpi
, ' ');
3604 d_append_char (dpi
, '(');
3607 hold_modifiers
= dpi
->modifiers
;
3608 dpi
->modifiers
= NULL
;
3610 d_print_mod_list (dpi
, mods
, 0);
3613 d_append_char (dpi
, ')');
3615 d_append_char (dpi
, '(');
3617 if (d_right (dc
) != NULL
)
3618 d_print_comp (dpi
, d_right (dc
));
3620 d_append_char (dpi
, ')');
3622 d_print_mod_list (dpi
, mods
, 1);
3624 dpi
->modifiers
= hold_modifiers
;
3627 /* Print an array type, except for the element type. */
3630 d_print_array_type (dpi
, dc
, mods
)
3631 struct d_print_info
*dpi
;
3632 const struct demangle_component
*dc
;
3633 struct d_print_mod
*mods
;
3641 struct d_print_mod
*p
;
3644 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3649 if (p
->mod
->type
== DEMANGLE_COMPONENT_ARRAY_TYPE
)
3663 d_append_string_constant (dpi
, " (");
3665 d_print_mod_list (dpi
, mods
, 0);
3668 d_append_char (dpi
, ')');
3672 d_append_char (dpi
, ' ');
3674 d_append_char (dpi
, '[');
3676 if (d_left (dc
) != NULL
)
3677 d_print_comp (dpi
, d_left (dc
));
3679 d_append_char (dpi
, ']');
3682 /* Print an operator in an expression. */
3685 d_print_expr_op (dpi
, dc
)
3686 struct d_print_info
*dpi
;
3687 const struct demangle_component
*dc
;
3689 if (dc
->type
== DEMANGLE_COMPONENT_OPERATOR
)
3690 d_append_buffer (dpi
, dc
->u
.s_operator
.op
->name
,
3691 dc
->u
.s_operator
.op
->len
);
3693 d_print_comp (dpi
, dc
);
3699 d_print_cast (dpi
, dc
)
3700 struct d_print_info
*dpi
;
3701 const struct demangle_component
*dc
;
3703 if (d_left (dc
)->type
!= DEMANGLE_COMPONENT_TEMPLATE
)
3704 d_print_comp (dpi
, d_left (dc
));
3707 struct d_print_mod
*hold_dpm
;
3708 struct d_print_template dpt
;
3710 /* It appears that for a templated cast operator, we need to put
3711 the template parameters in scope for the operator name, but
3712 not for the parameters. The effect is that we need to handle
3713 the template printing here. */
3715 hold_dpm
= dpi
->modifiers
;
3716 dpi
->modifiers
= NULL
;
3718 dpt
.next
= dpi
->templates
;
3719 dpi
->templates
= &dpt
;
3720 dpt
.template = d_left (dc
);
3722 d_print_comp (dpi
, d_left (d_left (dc
)));
3724 dpi
->templates
= dpt
.next
;
3726 if (d_last_char (dpi
) == '<')
3727 d_append_char (dpi
, ' ');
3728 d_append_char (dpi
, '<');
3729 d_print_comp (dpi
, d_right (d_left (dc
)));
3730 /* Avoid generating two consecutive '>' characters, to avoid
3731 the C++ syntactic ambiguity. */
3732 if (d_last_char (dpi
) == '>')
3733 d_append_char (dpi
, ' ');
3734 d_append_char (dpi
, '>');
3736 dpi
->modifiers
= hold_dpm
;
3740 /* Initialize the information structure we use to pass around
3743 CP_STATIC_IF_GLIBCPP_V3
3745 cplus_demangle_init_info (mangled
, options
, len
, di
)
3746 const char *mangled
;
3752 di
->send
= mangled
+ len
;
3753 di
->options
= options
;
3757 /* We can not need more components than twice the number of chars in
3758 the mangled string. Most components correspond directly to
3759 chars, but the ARGLIST types are exceptions. */
3760 di
->num_comps
= 2 * len
;
3763 /* Similarly, we can not need more substitutions than there are
3764 chars in the mangled string. */
3769 di
->last_name
= NULL
;
3774 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
3775 name, return a buffer allocated with malloc holding the demangled
3776 name. OPTIONS is the usual libiberty demangler options. On
3777 success, this sets *PALC to the allocated size of the returned
3778 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
3779 a memory allocation failure. On failure, this returns NULL. */
3782 d_demangle (mangled
, options
, palc
)
3783 const char* mangled
;
3790 struct demangle_component
*dc
;
3796 len
= strlen (mangled
);
3798 if (mangled
[0] == '_' && mangled
[1] == 'Z')
3800 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
3801 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
3802 && (mangled
[9] == 'D' || mangled
[9] == 'I')
3803 && mangled
[10] == '_')
3807 r
= malloc (40 + len
- 11);
3812 if (mangled
[9] == 'I')
3813 strcpy (r
, "global constructors keyed to ");
3815 strcpy (r
, "global destructors keyed to ");
3816 strcat (r
, mangled
+ 11);
3822 if ((options
& DMGL_TYPES
) == 0)
3827 cplus_demangle_init_info (mangled
, options
, len
, &di
);
3830 #ifdef CP_DYNAMIC_ARRAYS
3831 __extension__
struct demangle_component comps
[di
.num_comps
];
3832 __extension__
struct demangle_component
*subs
[di
.num_subs
];
3834 di
.comps
= &comps
[0];
3837 di
.comps
= ((struct demangle_component
*)
3838 malloc (di
.num_comps
* sizeof (struct demangle_component
)));
3839 di
.subs
= ((struct demangle_component
**)
3840 malloc (di
.num_subs
* sizeof (struct demangle_component
*)));
3841 if (di
.comps
== NULL
|| di
.subs
== NULL
)
3843 if (di
.comps
!= NULL
)
3845 if (di
.subs
!= NULL
)
3853 dc
= cplus_demangle_mangled_name (&di
, 1);
3855 dc
= cplus_demangle_type (&di
);
3857 /* If DMGL_PARAMS is set, then if we didn't consume the entire
3858 mangled string, then we didn't successfully demangle it. If
3859 DMGL_PARAMS is not set, we didn't look at the trailing
3861 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
3864 #ifdef CP_DEMANGLE_DEBUG
3866 printf ("failed demangling\n");
3871 /* We try to guess the length of the demangled string, to minimize
3872 calls to realloc during demangling. */
3873 estimate
= len
+ di
.expansion
+ 10 * di
.did_subs
;
3874 estimate
+= estimate
/ 8;
3878 ret
= cplus_demangle_print (options
, dc
, estimate
, palc
);
3880 #ifndef CP_DYNAMIC_ARRAYS
3885 #ifdef CP_DEMANGLE_DEBUG
3890 rlen
= strlen (ret
);
3891 if (rlen
> 2 * estimate
)
3892 printf ("*** Length %d much greater than estimate %d\n",
3894 else if (rlen
> estimate
)
3895 printf ("*** Length %d greater than estimate %d\n",
3897 else if (rlen
< estimate
/ 2)
3898 printf ("*** Length %d much less than estimate %d\n",
3907 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3909 extern char *__cxa_demangle
PARAMS ((const char *, char *, size_t *, int *));
3911 /* ia64 ABI-mandated entry point in the C++ runtime library for
3912 performing demangling. MANGLED_NAME is a NUL-terminated character
3913 string containing the name to be demangled.
3915 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3916 *LENGTH bytes, into which the demangled name is stored. If
3917 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3918 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3919 is placed in a region of memory allocated with malloc.
3921 If LENGTH is non-NULL, the length of the buffer conaining the
3922 demangled name, is placed in *LENGTH.
3924 The return value is a pointer to the start of the NUL-terminated
3925 demangled name, or NULL if the demangling fails. The caller is
3926 responsible for deallocating this memory using free.
3928 *STATUS is set to one of the following values:
3929 0: The demangling operation succeeded.
3930 -1: A memory allocation failure occurred.
3931 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3932 -3: One of the arguments is invalid.
3934 The demangling is performed using the C++ ABI mangling rules, with
3938 __cxa_demangle (mangled_name
, output_buffer
, length
, status
)
3939 const char *mangled_name
;
3940 char *output_buffer
;
3950 if (mangled_name
== NULL
)
3956 if (output_buffer
!= NULL
&& length
== NULL
)
3962 demangled
= d_demangle (mangled_name
, DMGL_TYPES
, &alc
);
3964 if (demangled
== NULL
)
3973 if (output_buffer
== NULL
)
3980 if (strlen (demangled
) < *length
)
3982 strcpy (output_buffer
, demangled
);
3984 demangled
= output_buffer
;
3988 free (output_buffer
);
3998 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4000 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
4001 mangled name, return a buffer allocated with malloc holding the
4002 demangled name. Otherwise, return NULL. */
4005 cplus_demangle_v3 (mangled
, options
)
4006 const char* mangled
;
4011 return d_demangle (mangled
, options
, &alc
);
4014 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
4015 conventions, but the output formatting is a little different.
4016 This instructs the C++ demangler not to emit pointer characters ("*"), and
4017 to use Java's namespace separator symbol ("." instead of "::"). It then
4018 does an additional pass over the demangled output to replace instances
4019 of JArray<TYPE> with TYPE[]. */
4022 java_demangle_v3 (mangled
)
4023 const char* mangled
;
4031 demangled
= d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
, &alc
);
4033 if (demangled
== NULL
)
4039 while (*from
!= '\0')
4041 if (strncmp (from
, "JArray<", 7) == 0)
4046 else if (nesting
> 0 && *from
== '>')
4048 while (to
> demangled
&& to
[-1] == ' ')
4064 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4066 #ifndef IN_GLIBCPP_V3
4068 /* Demangle a string in order to find out whether it is a constructor
4069 or destructor. Return non-zero on success. Set *CTOR_KIND and
4070 *DTOR_KIND appropriately. */
4073 is_ctor_or_dtor (mangled
, ctor_kind
, dtor_kind
)
4074 const char *mangled
;
4075 enum gnu_v3_ctor_kinds
*ctor_kind
;
4076 enum gnu_v3_dtor_kinds
*dtor_kind
;
4079 struct demangle_component
*dc
;
4082 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
4083 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
4085 cplus_demangle_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
);
4088 #ifdef CP_DYNAMIC_ARRAYS
4089 __extension__
struct demangle_component comps
[di
.num_comps
];
4090 __extension__
struct demangle_component
*subs
[di
.num_subs
];
4092 di
.comps
= &comps
[0];
4095 di
.comps
= ((struct demangle_component
*)
4096 malloc (di
.num_comps
* sizeof (struct demangle_component
)));
4097 di
.subs
= ((struct demangle_component
**)
4098 malloc (di
.num_subs
* sizeof (struct demangle_component
*)));
4099 if (di
.comps
== NULL
|| di
.subs
== NULL
)
4101 if (di
.comps
!= NULL
)
4103 if (di
.subs
!= NULL
)
4109 dc
= cplus_demangle_mangled_name (&di
, 1);
4111 /* Note that because we did not pass DMGL_PARAMS, we don't expect
4112 to demangle the entire string. */
4122 case DEMANGLE_COMPONENT_TYPED_NAME
:
4123 case DEMANGLE_COMPONENT_TEMPLATE
:
4124 case DEMANGLE_COMPONENT_RESTRICT_THIS
:
4125 case DEMANGLE_COMPONENT_VOLATILE_THIS
:
4126 case DEMANGLE_COMPONENT_CONST_THIS
:
4129 case DEMANGLE_COMPONENT_QUAL_NAME
:
4130 case DEMANGLE_COMPONENT_LOCAL_NAME
:
4133 case DEMANGLE_COMPONENT_CTOR
:
4134 *ctor_kind
= dc
->u
.s_ctor
.kind
;
4138 case DEMANGLE_COMPONENT_DTOR
:
4139 *dtor_kind
= dc
->u
.s_dtor
.kind
;
4146 #ifndef CP_DYNAMIC_ARRAYS
4155 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4156 name. A non-zero return indicates the type of constructor. */
4158 enum gnu_v3_ctor_kinds
4159 is_gnu_v3_mangled_ctor (name
)
4162 enum gnu_v3_ctor_kinds ctor_kind
;
4163 enum gnu_v3_dtor_kinds dtor_kind
;
4165 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4166 return (enum gnu_v3_ctor_kinds
) 0;
4171 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4172 name. A non-zero return indicates the type of destructor. */
4174 enum gnu_v3_dtor_kinds
4175 is_gnu_v3_mangled_dtor (name
)
4178 enum gnu_v3_ctor_kinds ctor_kind
;
4179 enum gnu_v3_dtor_kinds dtor_kind
;
4181 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
4182 return (enum gnu_v3_dtor_kinds
) 0;
4186 #endif /* IN_GLIBCPP_V3 */
4188 #ifdef STANDALONE_DEMANGLER
4191 #include "dyn-string.h"
4193 static void print_usage
PARAMS ((FILE* fp
, int exit_value
));
4195 #define IS_ALPHA(CHAR) \
4196 (((CHAR) >= 'a' && (CHAR) <= 'z') \
4197 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4199 /* Non-zero if CHAR is a character than can occur in a mangled name. */
4200 #define is_mangled_char(CHAR) \
4201 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
4202 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4204 /* The name of this program, as invoked. */
4205 const char* program_name
;
4207 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
4210 print_usage (fp
, exit_value
)
4214 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
4215 fprintf (fp
, "Options:\n");
4216 fprintf (fp
, " -h,--help Display this message.\n");
4217 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
4218 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
4219 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
4224 /* Option specification for getopt_long. */
4225 static const struct option long_options
[] =
4227 { "help", no_argument
, NULL
, 'h' },
4228 { "no-params", no_argument
, NULL
, 'p' },
4229 { "verbose", no_argument
, NULL
, 'v' },
4230 { NULL
, no_argument
, NULL
, 0 },
4233 /* Main entry for a demangling filter executable. It will demangle
4234 its command line arguments, if any. If none are provided, it will
4235 filter stdin to stdout, replacing any recognized mangled C++ names
4236 with their demangled equivalents. */
4245 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
4247 /* Use the program name of this program, as invoked. */
4248 program_name
= argv
[0];
4250 /* Parse options. */
4253 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
4256 case '?': /* Unrecognized option. */
4257 print_usage (stderr
, 1);
4261 print_usage (stdout
, 0);
4265 options
&= ~ DMGL_PARAMS
;
4269 options
|= DMGL_VERBOSE
;
4273 while (opt_char
!= -1);
4276 /* No command line arguments were provided. Filter stdin. */
4278 dyn_string_t mangled
= dyn_string_new (3);
4281 /* Read all of input. */
4282 while (!feof (stdin
))
4286 /* Pile characters into mangled until we hit one that can't
4287 occur in a mangled name. */
4289 while (!feof (stdin
) && is_mangled_char (c
))
4291 dyn_string_append_char (mangled
, c
);
4297 if (dyn_string_length (mangled
) > 0)
4299 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
4308 /* It might not have been a mangled name. Print the
4310 fputs (dyn_string_buf (mangled
), stdout
);
4313 dyn_string_clear (mangled
);
4316 /* If we haven't hit EOF yet, we've read one character that
4317 can't occur in a mangled name, so print it out. */
4322 dyn_string_delete (mangled
);
4325 /* Demangle command line arguments. */
4327 /* Loop over command line arguments. */
4328 for (i
= optind
; i
< argc
; ++i
)
4332 /* Attempt to demangle. */
4333 s
= cplus_demangle_v3 (argv
[i
], options
);
4335 /* If it worked, print the demangled name. */
4342 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
4349 #endif /* STANDALONE_DEMANGLER */