1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003 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 Preprocessor macros you can define while compiling this file:
51 If defined, this file defines the following function, q.v.:
52 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
54 instead of cplus_demangle_v3() and java_demangle_v3().
57 If defined, this file defines only __cxa_demangle().
60 If defined, this file defines a main() function which demangles
61 any arguments, or, if none, demangles stdin.
64 If defined, turns on debugging mode, which prints information on
65 stdout about the mangled string. This is not generally useful.
82 #include "libiberty.h"
85 /* We avoid pulling in the ctype tables, to prevent pulling in
86 additional unresolved symbols when this code is used in a library.
87 FIXME: Is this really a valid reason? This comes from the original
90 As of this writing this file has the following undefined references
91 when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy,
92 strcpy, strcat, strlen. */
94 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
95 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
96 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
98 /* The prefix prepended by GCC to an identifier represnting the
99 anonymous namespace. */
100 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
101 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
102 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
104 /* Information we keep for operators. */
106 struct d_operator_info
112 /* Number of arguments. */
116 /* How to print the value of a builtin type. */
118 enum d_builtin_type_print
120 /* Print as (type)val. */
122 /* Print as integer. */
124 /* Print as long, with trailing `l'. */
128 /* Print in usual way, but here to detect void. */
132 /* Information we keep for a builtin type. */
134 struct d_builtin_type_info
138 /* Type name when using Java. */
139 const char *java_name
;
140 /* How to print a value of this type. */
141 enum d_builtin_type_print print
;
144 /* Information we keep for the standard substitutions. */
146 struct d_standard_sub_info
148 /* The code for this substitution. */
150 /* The simple string it expands to. */
151 const char *simple_expansion
;
152 /* The results of a full, verbose, expansion. This is used when
153 qualifying a constructor/destructor, or when in verbose mode. */
154 const char *full_expansion
;
155 /* What to set the last_name field of d_info to; NULL if we should
156 not set it. This is only relevant when qualifying a
157 constructor/destructor. */
158 const char *set_last_name
;
161 /* Component types found in mangled names. */
167 /* A qualified name. */
175 /* A template parameter. */
176 D_COMP_TEMPLATE_PARAM
,
183 /* A VTT structure. */
185 /* A construction vtable. */
186 D_COMP_CONSTRUCTION_VTABLE
,
187 /* A typeinfo structure. */
189 /* A typeinfo name. */
190 D_COMP_TYPEINFO_NAME
,
191 /* A typeinfo function. */
195 /* A virtual thunk. */
196 D_COMP_VIRTUAL_THUNK
,
197 /* A covariant thunk. */
198 D_COMP_COVARIANT_THUNK
,
201 /* A guard variable. */
203 /* A reference temporary. */
205 /* A standard substitution. */
207 /* The restrict qualifier. */
209 /* The volatile qualifier. */
211 /* The const qualifier. */
213 /* The restrict qualifier modifying a member function. */
214 D_COMP_RESTRICT_THIS
,
215 /* The volatile qualifier modifying a member function. */
216 D_COMP_VOLATILE_THIS
,
217 /* The const qualifier modifying a member function. */
219 /* A vendor qualifier. */
220 D_COMP_VENDOR_TYPE_QUAL
,
225 /* A complex type. */
227 /* An imaginary type. */
229 /* A builtin type. */
231 /* A vendor's builtin type. */
233 /* A function type. */
234 D_COMP_FUNCTION_TYPE
,
237 /* A pointer to member type. */
239 /* An argument list. */
241 /* A template argument list. */
242 D_COMP_TEMPLATE_ARGLIST
,
245 /* An extended operator. */
246 D_COMP_EXTENDED_OPERATOR
,
249 /* A unary expression. */
251 /* A binary expression. */
253 /* Arguments to a binary expression. */
255 /* A trinary expression. */
257 /* Arguments to a trinary expression. */
262 /* A negative literal. */
266 /* A component of the mangled name. */
270 /* The type of this component. */
271 enum d_comp_type type
;
274 /* For D_COMP_NAME. */
277 /* A pointer to the name (not NULL terminated) and it's
283 /* For D_COMP_OPERATOR. */
287 const struct d_operator_info
*op
;
290 /* For D_COMP_EXTENDED_OPERATOR. */
293 /* Number of arguments. */
297 } s_extended_operator
;
299 /* For D_COMP_CTOR. */
302 enum gnu_v3_ctor_kinds kind
;
306 /* For D_COMP_DTOR. */
309 enum gnu_v3_dtor_kinds kind
;
313 /* For D_COMP_BUILTIN_TYPE. */
316 const struct d_builtin_type_info
*type
;
319 /* For D_COMP_SUB_STD. */
325 /* For D_COMP_TEMPLATE_PARAM. */
331 /* For other types. */
335 struct d_comp
*right
;
341 #define d_left(dc) ((dc)->u.s_binary.left)
342 #define d_right(dc) ((dc)->u.s_binary.right)
344 /* The information structure we pass around. */
348 /* The string we are demangling. */
350 /* The options passed to the demangler. */
352 /* The next character in the string to consider. */
354 /* The array of components. */
355 struct d_comp
*comps
;
356 /* The index of the next available component. */
358 /* The number of available component structures. */
360 /* The array of substitutions. */
361 struct d_comp
**subs
;
362 /* The index of the next substitution. */
364 /* The number of available entries in the subs array. */
366 /* The last name we saw, for constructors and destructors. */
367 struct d_comp
*last_name
;
370 #define d_peek_char(di) (*((di)->n))
371 #define d_peek_next_char(di) ((di)->n[1])
372 #define d_advance(di, i) ((di)->n += (i))
373 #define d_next_char(di) (*((di)->n++))
374 #define d_str(di) ((di)->n)
376 /* A list of templates. This is used while printing. */
378 struct d_print_template
380 /* Next template on the list. */
381 struct d_print_template
*next
;
383 const struct d_comp
*template;
386 /* A list of type modifiers. This is used while printing. */
390 /* Next modifier on the list. These are in the reverse of the order
391 in which they appeared in the mangled string. */
392 struct d_print_mod
*next
;
394 const struct d_comp
*mod
;
395 /* Whether this modifier was printed. */
397 /* The list of templates which applies to this modifier. */
398 struct d_print_template
*templates
;
401 /* We use this structure to hold information during printing. */
405 /* The options passed to the demangler. */
407 /* Buffer holding the result. */
409 /* Current length of data in buffer. */
411 /* Allocated size of buffer. */
413 /* The current list of templates, if any. */
414 struct d_print_template
*templates
;
415 /* The current list of modifiers (e.g., pointer, reference, etc.),
417 struct d_print_mod
*modifiers
;
418 /* Set to 1 if we had a memory allocation failure. */
419 int allocation_failure
;
422 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
424 #define d_append_char(dpi, c) \
427 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
428 (dpi)->buf[(dpi)->len++] = (c); \
430 d_print_append_char ((dpi), (c)); \
434 #define d_append_buffer(dpi, s, l) \
437 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
439 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
443 d_print_append_buffer ((dpi), (s), (l)); \
447 #define d_append_string(dpi, s) \
450 size_t d_append_string_len = strlen (s); \
451 d_append_buffer ((dpi), (s), d_append_string_len); \
455 #define d_last_char(dpi) \
456 ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
458 #ifdef CP_DEMANGLE_DEBUG
459 static void d_dump
PARAMS ((struct d_comp
*, int));
461 static struct d_comp
*d_make_empty
PARAMS ((struct d_info
*,
463 static struct d_comp
*d_make_comp
PARAMS ((struct d_info
*, enum d_comp_type
,
464 struct d_comp
*, struct d_comp
*));
465 static struct d_comp
*d_make_name
PARAMS ((struct d_info
*, const char *,
467 static struct d_comp
*d_make_builtin_type
PARAMS ((struct d_info
*,
468 const struct d_builtin_type_info
*));
469 static struct d_comp
*d_make_operator
PARAMS ((struct d_info
*,
470 const struct d_operator_info
*));
471 static struct d_comp
*d_make_extended_operator
PARAMS ((struct d_info
*,
474 static struct d_comp
*d_make_ctor
PARAMS ((struct d_info
*,
475 enum gnu_v3_ctor_kinds
,
477 static struct d_comp
*d_make_dtor
PARAMS ((struct d_info
*,
478 enum gnu_v3_dtor_kinds
,
480 static struct d_comp
*d_make_template_param
PARAMS ((struct d_info
*, long));
481 static struct d_comp
*d_make_sub
PARAMS ((struct d_info
*, const char *));
482 static struct d_comp
*d_mangled_name
PARAMS ((struct d_info
*, int));
483 static int has_return_type
PARAMS ((struct d_comp
*));
484 static int is_ctor_dtor_or_conversion
PARAMS ((struct d_comp
*));
485 static struct d_comp
*d_encoding
PARAMS ((struct d_info
*, int));
486 static struct d_comp
*d_name
PARAMS ((struct d_info
*));
487 static struct d_comp
*d_nested_name
PARAMS ((struct d_info
*));
488 static struct d_comp
*d_prefix
PARAMS ((struct d_info
*));
489 static struct d_comp
*d_unqualified_name
PARAMS ((struct d_info
*));
490 static struct d_comp
*d_source_name
PARAMS ((struct d_info
*));
491 static long d_number
PARAMS ((struct d_info
*));
492 static struct d_comp
*d_identifier
PARAMS ((struct d_info
*, int));
493 static struct d_comp
*d_operator_name
PARAMS ((struct d_info
*));
494 static struct d_comp
*d_special_name
PARAMS ((struct d_info
*));
495 static int d_call_offset
PARAMS ((struct d_info
*, int));
496 static struct d_comp
*d_ctor_dtor_name
PARAMS ((struct d_info
*));
497 static struct d_comp
*d_type
PARAMS ((struct d_info
*));
498 static struct d_comp
**d_cv_qualifiers
PARAMS ((struct d_info
*,
499 struct d_comp
**, int));
500 static struct d_comp
*d_function_type
PARAMS ((struct d_info
*));
501 static struct d_comp
*d_bare_function_type
PARAMS ((struct d_info
*, int));
502 static struct d_comp
*d_class_enum_type
PARAMS ((struct d_info
*));
503 static struct d_comp
*d_array_type
PARAMS ((struct d_info
*));
504 static struct d_comp
*d_pointer_to_member_type
PARAMS ((struct d_info
*));
505 static struct d_comp
*d_template_param
PARAMS ((struct d_info
*));
506 static struct d_comp
*d_template_args
PARAMS ((struct d_info
*));
507 static struct d_comp
*d_template_arg
PARAMS ((struct d_info
*));
508 static struct d_comp
*d_expression
PARAMS ((struct d_info
*));
509 static struct d_comp
*d_expr_primary
PARAMS ((struct d_info
*));
510 static struct d_comp
*d_local_name
PARAMS ((struct d_info
*));
511 static int d_discriminator
PARAMS ((struct d_info
*));
512 static int d_add_substitution
PARAMS ((struct d_info
*, struct d_comp
*));
513 static struct d_comp
*d_substitution
PARAMS ((struct d_info
*, int));
514 static void d_print_resize
PARAMS ((struct d_print_info
*, size_t));
515 static void d_print_append_char
PARAMS ((struct d_print_info
*, int));
516 static void d_print_append_buffer
PARAMS ((struct d_print_info
*, const char *,
518 static void d_print_error
PARAMS ((struct d_print_info
*));
519 static char *d_print
PARAMS ((int, const struct d_comp
*, size_t *));
520 static void d_print_comp
PARAMS ((struct d_print_info
*,
521 const struct d_comp
*));
522 static void d_print_identifier
PARAMS ((struct d_print_info
*, const char *,
524 static void d_print_mod_list
PARAMS ((struct d_print_info
*,
525 struct d_print_mod
*, int));
526 static void d_print_mod
PARAMS ((struct d_print_info
*,
527 const struct d_comp
*));
528 static void d_print_function_type
PARAMS ((struct d_print_info
*,
529 const struct d_comp
*,
530 struct d_print_mod
*));
531 static void d_print_array_type
PARAMS ((struct d_print_info
*,
532 const struct d_comp
*,
533 struct d_print_mod
*));
534 static void d_print_expr_op
PARAMS ((struct d_print_info
*,
535 const struct d_comp
*));
536 static void d_print_cast
PARAMS ((struct d_print_info
*,
537 const struct d_comp
*));
538 static int d_init_info
PARAMS ((const char *, int, size_t, struct d_info
*));
539 static char *d_demangle
PARAMS ((const char *, int, size_t *));
541 #ifdef CP_DEMANGLE_DEBUG
553 for (i
= 0; i
< indent
; ++i
)
559 printf ("name '%.*s'\n", dc
->u
.s_name
.len
, dc
->u
.s_name
.s
);
561 case D_COMP_TEMPLATE_PARAM
:
562 printf ("template parameter %ld\n", dc
->u
.s_number
.number
);
565 printf ("constructor %d\n", (int) dc
->u
.s_ctor
.kind
);
566 d_dump (dc
->u
.s_ctor
.name
, indent
+ 2);
569 printf ("destructor %d\n", (int) dc
->u
.s_dtor
.kind
);
570 d_dump (dc
->u
.s_dtor
.name
, indent
+ 2);
573 printf ("standard substitution %s\n", dc
->u
.s_string
.string
);
575 case D_COMP_BUILTIN_TYPE
:
576 printf ("builtin type %s\n", dc
->u
.s_builtin
.type
->name
);
578 case D_COMP_OPERATOR
:
579 printf ("operator %s\n", dc
->u
.s_operator
.op
->name
);
581 case D_COMP_EXTENDED_OPERATOR
:
582 printf ("extended operator with %d args\n",
583 dc
->u
.s_extended_operator
.args
);
584 d_dump (dc
->u
.s_extended_operator
.name
, indent
+ 2);
587 case D_COMP_QUAL_NAME
:
588 printf ("qualified name\n");
590 case D_COMP_LOCAL_NAME
:
591 printf ("local name\n");
593 case D_COMP_TYPED_NAME
:
594 printf ("typed name\n");
596 case D_COMP_TEMPLATE
:
597 printf ("template\n");
605 case D_COMP_CONSTRUCTION_VTABLE
:
606 printf ("construction vtable\n");
608 case D_COMP_TYPEINFO
:
609 printf ("typeinfo\n");
611 case D_COMP_TYPEINFO_NAME
:
612 printf ("typeinfo name\n");
614 case D_COMP_TYPEINFO_FN
:
615 printf ("typeinfo function\n");
620 case D_COMP_VIRTUAL_THUNK
:
621 printf ("virtual thunk\n");
623 case D_COMP_COVARIANT_THUNK
:
624 printf ("covariant thunk\n");
626 case D_COMP_JAVA_CLASS
:
627 printf ("java class\n");
633 printf ("reference temporary\n");
635 case D_COMP_RESTRICT
:
636 printf ("restrict\n");
638 case D_COMP_VOLATILE
:
639 printf ("volatile\n");
644 case D_COMP_RESTRICT_THIS
:
645 printf ("restrict this\n");
647 case D_COMP_VOLATILE_THIS
:
648 printf ("volatile this\n");
650 case D_COMP_CONST_THIS
:
651 printf ("const this\n");
653 case D_COMP_VENDOR_TYPE_QUAL
:
654 printf ("vendor type qualifier\n");
657 printf ("pointer\n");
659 case D_COMP_REFERENCE
:
660 printf ("reference\n");
663 printf ("complex\n");
665 case D_COMP_IMAGINARY
:
666 printf ("imaginary\n");
668 case D_COMP_VENDOR_TYPE
:
669 printf ("vendor type\n");
671 case D_COMP_FUNCTION_TYPE
:
672 printf ("function type\n");
674 case D_COMP_ARRAY_TYPE
:
675 printf ("array type\n");
677 case D_COMP_PTRMEM_TYPE
:
678 printf ("pointer to member type\n");
681 printf ("argument list\n");
683 case D_COMP_TEMPLATE_ARGLIST
:
684 printf ("template argument list\n");
690 printf ("unary operator\n");
693 printf ("binary operator\n");
695 case D_COMP_BINARY_ARGS
:
696 printf ("binary operator arguments\n");
699 printf ("trinary operator\n");
701 case D_COMP_TRINARY_ARG1
:
702 printf ("trinary operator arguments 1\n");
704 case D_COMP_TRINARY_ARG2
:
705 printf ("trinary operator arguments 1\n");
708 printf ("literal\n");
710 case D_COMP_LITERAL_NEG
:
711 printf ("negative literal\n");
715 d_dump (d_left (dc
), indent
+ 2);
716 d_dump (d_right (dc
), indent
+ 2);
719 #endif /* CP_DEMANGLE_DEBUG */
721 /* Add a new component. */
723 static struct d_comp
*
724 d_make_empty (di
, type
)
726 enum d_comp_type type
;
730 if (di
->next_comp
>= di
->num_comps
)
732 p
= &di
->comps
[di
->next_comp
];
738 /* Add a new generic component. */
740 static struct d_comp
*
741 d_make_comp (di
, type
, left
, right
)
743 enum d_comp_type type
;
745 struct d_comp
*right
;
749 /* We check for errors here. A typical error would be a NULL return
750 from a subroutine. We catch those here, and return NULL
754 /* These types require two parameters. */
755 case D_COMP_QUAL_NAME
:
756 case D_COMP_LOCAL_NAME
:
757 case D_COMP_TYPED_NAME
:
758 case D_COMP_TEMPLATE
:
759 case D_COMP_VENDOR_TYPE_QUAL
:
760 case D_COMP_PTRMEM_TYPE
:
763 case D_COMP_BINARY_ARGS
:
765 case D_COMP_TRINARY_ARG1
:
766 case D_COMP_TRINARY_ARG2
:
768 case D_COMP_LITERAL_NEG
:
769 if (left
== NULL
|| right
== NULL
)
773 /* These types only require one parameter. */
776 case D_COMP_CONSTRUCTION_VTABLE
:
777 case D_COMP_TYPEINFO
:
778 case D_COMP_TYPEINFO_NAME
:
779 case D_COMP_TYPEINFO_FN
:
781 case D_COMP_VIRTUAL_THUNK
:
782 case D_COMP_COVARIANT_THUNK
:
783 case D_COMP_JAVA_CLASS
:
787 case D_COMP_REFERENCE
:
789 case D_COMP_IMAGINARY
:
790 case D_COMP_VENDOR_TYPE
:
792 case D_COMP_TEMPLATE_ARGLIST
:
798 /* This needs a right parameter, but the left parameter can be
800 case D_COMP_ARRAY_TYPE
:
805 /* These are allowed to have no parameters--in some cases they
806 will be filled in later. */
807 case D_COMP_FUNCTION_TYPE
:
808 case D_COMP_RESTRICT
:
809 case D_COMP_VOLATILE
:
811 case D_COMP_RESTRICT_THIS
:
812 case D_COMP_VOLATILE_THIS
:
813 case D_COMP_CONST_THIS
:
816 /* Other types should not be seen here. */
821 p
= d_make_empty (di
, type
);
824 p
->u
.s_binary
.left
= left
;
825 p
->u
.s_binary
.right
= right
;
830 /* Add a new name component. */
832 static struct d_comp
*
833 d_make_name (di
, s
, len
)
840 if (s
== NULL
|| len
== 0)
842 p
= d_make_empty (di
, D_COMP_NAME
);
846 p
->u
.s_name
.len
= len
;
851 /* Add a new builtin type component. */
853 static struct d_comp
*
854 d_make_builtin_type (di
, type
)
856 const struct d_builtin_type_info
*type
;
862 p
= d_make_empty (di
, D_COMP_BUILTIN_TYPE
);
864 p
->u
.s_builtin
.type
= type
;
868 /* Add a new operator component. */
870 static struct d_comp
*
871 d_make_operator (di
, op
)
873 const struct d_operator_info
*op
;
877 p
= d_make_empty (di
, D_COMP_OPERATOR
);
879 p
->u
.s_operator
.op
= op
;
883 /* Add a new extended operator component. */
885 static struct d_comp
*
886 d_make_extended_operator (di
, args
, name
)
895 p
= d_make_empty (di
, D_COMP_EXTENDED_OPERATOR
);
898 p
->u
.s_extended_operator
.args
= args
;
899 p
->u
.s_extended_operator
.name
= name
;
904 /* Add a new constructor component. */
906 static struct d_comp
*
907 d_make_ctor (di
, kind
, name
)
909 enum gnu_v3_ctor_kinds kind
;
916 p
= d_make_empty (di
, D_COMP_CTOR
);
919 p
->u
.s_ctor
.kind
= kind
;
920 p
->u
.s_ctor
.name
= name
;
925 /* Add a new destructor component. */
927 static struct d_comp
*
928 d_make_dtor (di
, kind
, name
)
930 enum gnu_v3_dtor_kinds kind
;
937 p
= d_make_empty (di
, D_COMP_DTOR
);
940 p
->u
.s_dtor
.kind
= kind
;
941 p
->u
.s_dtor
.name
= name
;
946 /* Add a new template parameter. */
948 static struct d_comp
*
949 d_make_template_param (di
, i
)
955 p
= d_make_empty (di
, D_COMP_TEMPLATE_PARAM
);
957 p
->u
.s_number
.number
= i
;
961 /* Add a new standard substitution component. */
963 static struct d_comp
*
964 d_make_sub (di
, name
)
970 p
= d_make_empty (di
, D_COMP_SUB_STD
);
972 p
->u
.s_string
.string
= name
;
976 /* <mangled-name> ::= _Z <encoding>
978 TOP_LEVEL is non-zero when called at the top level. */
980 static struct d_comp
*
981 d_mangled_name (di
, top_level
)
985 if (d_next_char (di
) != '_')
987 if (d_next_char (di
) != 'Z')
989 return d_encoding (di
, top_level
);
992 /* Return whether a function should have a return type. The argument
993 is the function name, which may be qualified in various ways. The
994 rules are that template functions have return types with some
995 exceptions, function types which are not part of a function name
996 mangling have return types with some exceptions, and non-template
997 function names do not have return types. The exceptions are that
998 constructors, destructors, and conversion operators do not have
1002 has_return_type (dc
)
1011 case D_COMP_TEMPLATE
:
1012 return ! is_ctor_dtor_or_conversion (d_left (dc
));
1013 case D_COMP_RESTRICT_THIS
:
1014 case D_COMP_VOLATILE_THIS
:
1015 case D_COMP_CONST_THIS
:
1016 return has_return_type (d_left (dc
));
1020 /* Return whether a name is a constructor, a destructor, or a
1021 conversion operator. */
1024 is_ctor_dtor_or_conversion (dc
)
1033 case D_COMP_QUAL_NAME
:
1034 case D_COMP_LOCAL_NAME
:
1035 return is_ctor_dtor_or_conversion (d_right (dc
));
1043 /* <encoding> ::= <(function) name> <bare-function-type>
1047 TOP_LEVEL is non-zero when called at the top level, in which case
1048 if DMGL_PARAMS is not set we do not demangle the function
1049 parameters. We only set this at the top level, because otherwise
1050 we would not correctly demangle names in local scopes. */
1052 static struct d_comp
*
1053 d_encoding (di
, top_level
)
1057 char peek
= d_peek_char (di
);
1059 if (peek
== 'G' || peek
== 'T')
1060 return d_special_name (di
);
1067 if (dc
!= NULL
&& top_level
&& (di
->options
& DMGL_PARAMS
) == 0)
1069 /* Strip off any initial CV-qualifiers, as they really apply
1070 to the `this' parameter, and they were not output by the
1071 v2 demangler without DMGL_PARAMS. */
1072 while (dc
->type
== D_COMP_RESTRICT_THIS
1073 || dc
->type
== D_COMP_VOLATILE_THIS
1074 || dc
->type
== D_COMP_CONST_THIS
)
1079 peek
= d_peek_char (di
);
1080 if (peek
== '\0' || peek
== 'E')
1082 return d_make_comp (di
, D_COMP_TYPED_NAME
, dc
,
1083 d_bare_function_type (di
, has_return_type (dc
)));
1087 /* <name> ::= <nested-name>
1089 ::= <unscoped-template-name> <template-args>
1092 <unscoped-name> ::= <unqualified-name>
1093 ::= St <unqualified-name>
1095 <unscoped-template-name> ::= <unscoped-name>
1099 static struct d_comp
*
1103 char peek
= d_peek_char (di
);
1109 return d_nested_name (di
);
1112 return d_local_name (di
);
1118 if (d_peek_next_char (di
) != 't')
1120 dc
= d_substitution (di
, 0);
1126 dc
= d_make_comp (di
, D_COMP_QUAL_NAME
, d_make_name (di
, "std", 3),
1127 d_unqualified_name (di
));
1131 if (d_peek_char (di
) != 'I')
1133 /* The grammar does not permit this case to occur if we
1134 called d_substitution() above (i.e., subst == 1). We
1135 don't bother to check. */
1139 /* This is <template-args>, which means that we just saw
1140 <unscoped-template-name>, which is a substitution
1141 candidate if we didn't just get it from a
1145 if (! d_add_substitution (di
, dc
))
1148 dc
= d_make_comp (di
, D_COMP_TEMPLATE
, dc
, d_template_args (di
));
1155 dc
= d_unqualified_name (di
);
1156 if (d_peek_char (di
) == 'I')
1158 /* This is <template-args>, which means that we just saw
1159 <unscoped-template-name>, which is a substitution
1161 if (! d_add_substitution (di
, dc
))
1163 dc
= d_make_comp (di
, D_COMP_TEMPLATE
, dc
, d_template_args (di
));
1169 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1170 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1173 static struct d_comp
*
1178 struct d_comp
**pret
;
1180 if (d_next_char (di
) != 'N')
1183 pret
= d_cv_qualifiers (di
, &ret
, 1);
1187 *pret
= d_prefix (di
);
1191 if (d_next_char (di
) != 'E')
1197 /* <prefix> ::= <prefix> <unqualified-name>
1198 ::= <template-prefix> <template-args>
1199 ::= <template-param>
1203 <template-prefix> ::= <prefix> <(template) unqualified-name>
1204 ::= <template-param>
1208 static struct d_comp
*
1212 struct d_comp
*ret
= NULL
;
1217 enum d_comp_type comb_type
;
1220 peek
= d_peek_char (di
);
1224 /* The older code accepts a <local-name> here, but I don't see
1225 that in the grammar. The older code does not accept a
1226 <template-param> here. */
1228 comb_type
= D_COMP_QUAL_NAME
;
1233 dc
= d_unqualified_name (di
);
1234 else if (peek
== 'S')
1235 dc
= d_substitution (di
, 1);
1236 else if (peek
== 'I')
1240 comb_type
= D_COMP_TEMPLATE
;
1241 dc
= d_template_args (di
);
1243 else if (peek
== 'T')
1244 dc
= d_template_param (di
);
1245 else if (peek
== 'E')
1253 ret
= d_make_comp (di
, comb_type
, ret
, dc
);
1255 if (peek
!= 'S' && d_peek_char (di
) != 'E')
1257 if (! d_add_substitution (di
, ret
))
1263 /* <unqualified-name> ::= <operator-name>
1264 ::= <ctor-dtor-name>
1268 static struct d_comp
*
1269 d_unqualified_name (di
)
1274 peek
= d_peek_char (di
);
1275 if (IS_DIGIT (peek
))
1276 return d_source_name (di
);
1277 else if (IS_LOWER (peek
))
1278 return d_operator_name (di
);
1279 else if (peek
== 'C' || peek
== 'D')
1280 return d_ctor_dtor_name (di
);
1285 /* <source-name> ::= <(positive length) number> <identifier> */
1287 static struct d_comp
*
1294 len
= d_number (di
);
1297 ret
= d_identifier (di
, len
);
1298 di
->last_name
= ret
;
1302 /* number ::= [n] <(non-negative decimal integer)> */
1313 peek
= d_peek_char (di
);
1318 peek
= d_peek_char (di
);
1324 if (! IS_DIGIT (peek
))
1326 ret
= ret
* 10 + peek
- '0';
1328 peek
= d_peek_char (di
);
1332 /* identifier ::= <(unqualified source code identifier)> */
1334 static struct d_comp
*
1335 d_identifier (di
, len
)
1342 d_advance (di
, len
);
1344 /* Look for something which looks like a gcc encoding of an
1345 anonymous namespace, and replace it with a more user friendly
1347 if (len
>= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN
+ 2
1348 && memcmp (name
, ANONYMOUS_NAMESPACE_PREFIX
,
1349 ANONYMOUS_NAMESPACE_PREFIX_LEN
) == 0)
1353 s
= name
+ ANONYMOUS_NAMESPACE_PREFIX_LEN
;
1354 if ((*s
== '.' || *s
== '_' || *s
== '$')
1356 return d_make_name (di
, "(anonymous namespace)",
1357 sizeof "(anonymous namespace)" - 1);
1360 return d_make_name (di
, name
, len
);
1363 /* operator_name ::= many different two character encodings.
1365 ::= v <digit> <source-name>
1368 static const struct d_operator_info d_operators
[] =
1379 { "da", "delete[]", 1 },
1381 { "dl", "delete", 1 },
1398 { "na", "new[]", 1 },
1417 { "st", "sizeof ", 1 },
1418 { "sz", "sizeof ", 1 }
1421 static struct d_comp
*
1422 d_operator_name (di
)
1428 c1
= d_next_char (di
);
1429 c2
= d_next_char (di
);
1430 if (c1
== 'v' && IS_DIGIT (c2
))
1431 return d_make_extended_operator (di
, c2
- '0', d_source_name (di
));
1432 else if (c1
== 'c' && c2
== 'v')
1433 return d_make_comp (di
, D_COMP_CAST
, d_type (di
), NULL
);
1437 int high
= sizeof (d_operators
) / sizeof (d_operators
[0]);
1442 const struct d_operator_info
*p
;
1444 i
= low
+ (high
- low
) / 2;
1445 p
= d_operators
+ i
;
1447 if (c1
== p
->code
[0] && c2
== p
->code
[1])
1448 return d_make_operator (di
, p
);
1450 if (c1
< p
->code
[0] || (c1
== p
->code
[0] && c2
< p
->code
[1]))
1460 /* <special-name> ::= TV <type>
1464 ::= GV <(object) name>
1465 ::= T <call-offset> <(base) encoding>
1466 ::= Tc <call-offset> <call-offset> <(base) encoding>
1467 Also g++ extensions:
1468 ::= TC <type> <(offset) number> _ <(base) type>
1474 static struct d_comp
*
1480 c
= d_next_char (di
);
1483 switch (d_next_char (di
))
1486 return d_make_comp (di
, D_COMP_VTABLE
, d_type (di
), NULL
);
1488 return d_make_comp (di
, D_COMP_VTT
, d_type (di
), NULL
);
1490 return d_make_comp (di
, D_COMP_TYPEINFO
, d_type (di
), NULL
);
1492 return d_make_comp (di
, D_COMP_TYPEINFO_NAME
, d_type (di
), NULL
);
1495 if (! d_call_offset (di
, 'h'))
1497 return d_make_comp (di
, D_COMP_THUNK
, d_encoding (di
, 0), NULL
);
1500 if (! d_call_offset (di
, 'v'))
1502 return d_make_comp (di
, D_COMP_VIRTUAL_THUNK
, d_encoding (di
, 0),
1506 if (! d_call_offset (di
, '\0'))
1508 if (! d_call_offset (di
, '\0'))
1510 return d_make_comp (di
, D_COMP_COVARIANT_THUNK
, d_encoding (di
, 0),
1515 struct d_comp
*derived_type
;
1517 struct d_comp
*base_type
;
1519 derived_type
= d_type (di
);
1520 offset
= d_number (di
);
1523 if (d_next_char (di
) != '_')
1525 base_type
= d_type (di
);
1526 /* We don't display the offset. FIXME: We should display
1527 it in verbose mode. */
1528 return d_make_comp (di
, D_COMP_CONSTRUCTION_VTABLE
, base_type
,
1533 return d_make_comp (di
, D_COMP_TYPEINFO_FN
, d_type (di
), NULL
);
1535 return d_make_comp (di
, D_COMP_JAVA_CLASS
, d_type (di
), NULL
);
1543 switch (d_next_char (di
))
1546 return d_make_comp (di
, D_COMP_GUARD
, d_name (di
), NULL
);
1549 return d_make_comp (di
, D_COMP_REFTEMP
, d_name (di
), NULL
);
1559 /* <call-offset> ::= h <nv-offset> _
1562 <nv-offset> ::= <(offset) number>
1564 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1566 The C parameter, if not '\0', is a character we just read which is
1567 the start of the <call-offset>.
1569 We don't display the offset information anywhere. FIXME: We should
1570 display it in verbose mode. */
1573 d_call_offset (di
, c
)
1578 long virtual_offset
;
1581 c
= d_next_char (di
);
1584 offset
= d_number (di
);
1587 offset
= d_number (di
);
1588 if (d_next_char (di
) != '_')
1590 virtual_offset
= d_number (di
);
1595 if (d_next_char (di
) != '_')
1601 /* <ctor-dtor-name> ::= C1
1609 static struct d_comp
*
1610 d_ctor_dtor_name (di
)
1613 switch (d_next_char (di
))
1617 enum gnu_v3_ctor_kinds kind
;
1619 switch (d_next_char (di
))
1622 kind
= gnu_v3_complete_object_ctor
;
1625 kind
= gnu_v3_base_object_ctor
;
1628 kind
= gnu_v3_complete_object_allocating_ctor
;
1633 return d_make_ctor (di
, kind
, di
->last_name
);
1638 enum gnu_v3_dtor_kinds kind
;
1640 switch (d_next_char (di
))
1643 kind
= gnu_v3_deleting_dtor
;
1646 kind
= gnu_v3_complete_object_dtor
;
1649 kind
= gnu_v3_base_object_dtor
;
1654 return d_make_dtor (di
, kind
, di
->last_name
);
1662 /* <type> ::= <builtin-type>
1664 ::= <class-enum-type>
1666 ::= <pointer-to-member-type>
1667 ::= <template-param>
1668 ::= <template-template-param> <template-args>
1670 ::= <CV-qualifiers> <type>
1675 ::= U <source-name> <type>
1677 <builtin-type> ::= various one letter codes
1681 static const struct d_builtin_type_info d_builtin_types
[26] =
1683 /* a */ { "signed char", "signed char", D_PRINT_INT
},
1684 /* b */ { "bool", "boolean", D_PRINT_BOOL
},
1685 /* c */ { "char", "byte", D_PRINT_INT
},
1686 /* d */ { "double", "double", D_PRINT_DEFAULT
},
1687 /* e */ { "long double", "long double", D_PRINT_DEFAULT
},
1688 /* f */ { "float", "float", D_PRINT_DEFAULT
},
1689 /* g */ { "__float128", "__float128", D_PRINT_DEFAULT
},
1690 /* h */ { "unsigned char", "unsigned char", D_PRINT_INT
},
1691 /* i */ { "int", "int", D_PRINT_INT
},
1692 /* j */ { "unsigned int", "unsigned", D_PRINT_INT
},
1693 /* k */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1694 /* l */ { "long", "long", D_PRINT_LONG
},
1695 /* m */ { "unsigned long", "unsigned long", D_PRINT_LONG
},
1696 /* n */ { "__int128", "__int128", D_PRINT_DEFAULT
},
1697 /* o */ { "unsigned __int128", "unsigned __int128", D_PRINT_DEFAULT
},
1698 /* p */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1699 /* q */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1700 /* r */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1701 /* s */ { "short", "short", D_PRINT_INT
},
1702 /* t */ { "unsigned short", "unsigned short", D_PRINT_INT
},
1703 /* u */ { NULL
, NULL
, D_PRINT_DEFAULT
},
1704 /* v */ { "void", "void", D_PRINT_VOID
},
1705 /* w */ { "wchar_t", "char", D_PRINT_INT
},
1706 /* x */ { "long long", "long", D_PRINT_DEFAULT
},
1707 /* y */ { "unsigned long long", "unsigned long long", D_PRINT_DEFAULT
},
1708 /* z */ { "...", "...", D_PRINT_DEFAULT
},
1711 static struct d_comp
*
1719 /* The ABI specifies that when CV-qualifiers are used, the base type
1720 is substitutable, and the fully qualified type is substitutable,
1721 but the base type with a strict subset of the CV-qualifiers is
1722 not substitutable. The natural recursive implementation of the
1723 CV-qualifiers would cause subsets to be substitutable, so instead
1724 we pull them all off now.
1726 FIXME: The ABI says that order-insensitive vendor qualifiers
1727 should be handled in the same way, but we have no way to tell
1728 which vendor qualifiers are order-insensitive and which are
1729 order-sensitive. So we just assume that they are all
1730 order-sensitive. g++ 3.4 supports only one vendor qualifier,
1731 __vector, and it treats it as order-sensitive when mangling
1734 peek
= d_peek_char (di
);
1735 if (peek
== 'r' || peek
== 'V' || peek
== 'K')
1737 struct d_comp
**pret
;
1739 pret
= d_cv_qualifiers (di
, &ret
, 0);
1742 *pret
= d_type (di
);
1743 if (! d_add_substitution (di
, ret
))
1752 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1753 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
1754 case 'o': case 's': case 't':
1755 case 'v': case 'w': case 'x': case 'y': case 'z':
1756 ret
= d_make_builtin_type (di
, &d_builtin_types
[peek
- 'a']);
1763 ret
= d_make_comp (di
, D_COMP_VENDOR_TYPE
, d_source_name (di
), NULL
);
1767 ret
= d_function_type (di
);
1770 case '0': case '1': case '2': case '3': case '4':
1771 case '5': case '6': case '7': case '8': case '9':
1774 ret
= d_class_enum_type (di
);
1778 ret
= d_array_type (di
);
1782 ret
= d_pointer_to_member_type (di
);
1786 ret
= d_template_param (di
);
1787 if (d_peek_char (di
) == 'I')
1789 /* This is <template-template-param> <template-args>. The
1790 <template-template-param> part is a substitution
1792 if (! d_add_substitution (di
, ret
))
1794 ret
= d_make_comp (di
, D_COMP_TEMPLATE
, ret
, d_template_args (di
));
1799 /* If this is a special substitution, then it is the start of
1800 <class-enum-type>. */
1804 peek_next
= d_peek_next_char (di
);
1805 if (IS_DIGIT (peek_next
)
1807 || IS_UPPER (peek_next
))
1809 ret
= d_substitution (di
, 0);
1810 /* The substituted name may have been a template name and
1811 may be followed by tepmlate args. */
1812 if (d_peek_char (di
) == 'I')
1813 ret
= d_make_comp (di
, D_COMP_TEMPLATE
, ret
,
1814 d_template_args (di
));
1820 ret
= d_class_enum_type (di
);
1821 /* If the substitution was a complete type, then it is not
1822 a new substitution candidate. However, if the
1823 substitution was followed by template arguments, then
1824 the whole thing is a substitution candidate. */
1825 if (ret
!= NULL
&& ret
->type
== D_COMP_SUB_STD
)
1833 ret
= d_make_comp (di
, D_COMP_POINTER
, d_type (di
), NULL
);
1838 ret
= d_make_comp (di
, D_COMP_REFERENCE
, d_type (di
), NULL
);
1843 ret
= d_make_comp (di
, D_COMP_COMPLEX
, d_type (di
), NULL
);
1848 ret
= d_make_comp (di
, D_COMP_IMAGINARY
, d_type (di
), NULL
);
1853 ret
= d_source_name (di
);
1854 ret
= d_make_comp (di
, D_COMP_VENDOR_TYPE_QUAL
, d_type (di
), ret
);
1863 if (! d_add_substitution (di
, ret
))
1870 /* <CV-qualifiers> ::= [r] [V] [K] */
1872 static struct d_comp
**
1873 d_cv_qualifiers (di
, pret
, member_fn
)
1875 struct d_comp
**pret
;
1880 peek
= d_peek_char (di
);
1881 while (peek
== 'r' || peek
== 'V' || peek
== 'K')
1887 t
= member_fn
? D_COMP_RESTRICT_THIS
: D_COMP_RESTRICT
;
1888 else if (peek
== 'V')
1889 t
= member_fn
? D_COMP_VOLATILE_THIS
: D_COMP_VOLATILE
;
1891 t
= member_fn
? D_COMP_CONST_THIS
: D_COMP_CONST
;
1893 *pret
= d_make_comp (di
, t
, NULL
, NULL
);
1896 pret
= &d_left (*pret
);
1898 peek
= d_peek_char (di
);
1904 /* <function-type> ::= F [Y] <bare-function-type> E */
1906 static struct d_comp
*
1907 d_function_type (di
)
1912 if (d_next_char (di
) != 'F')
1914 if (d_peek_char (di
) == 'Y')
1916 /* Function has C linkage. We don't print this information.
1917 FIXME: We should print it in verbose mode. */
1920 ret
= d_bare_function_type (di
, 1);
1921 if (d_next_char (di
) != 'E')
1926 /* <bare-function-type> ::= <type>+ */
1928 static struct d_comp
*
1929 d_bare_function_type (di
, has_return_type
)
1931 int has_return_type
;
1933 struct d_comp
*return_type
;
1935 struct d_comp
**ptl
;
1943 struct d_comp
*type
;
1945 peek
= d_peek_char (di
);
1946 if (peek
== '\0' || peek
== 'E')
1951 if (has_return_type
)
1954 has_return_type
= 0;
1958 *ptl
= d_make_comp (di
, D_COMP_ARGLIST
, type
, NULL
);
1961 ptl
= &d_right (*ptl
);
1965 /* There should be at least one parameter type besides the optional
1966 return type. A function which takes no arguments will have a
1967 single parameter type void. */
1971 /* If we have a single parameter type void, omit it. */
1972 if (d_right (tl
) == NULL
1973 && d_left (tl
)->type
== D_COMP_BUILTIN_TYPE
1974 && d_left (tl
)->u
.s_builtin
.type
->print
== D_PRINT_VOID
)
1977 return d_make_comp (di
, D_COMP_FUNCTION_TYPE
, return_type
, tl
);
1980 /* <class-enum-type> ::= <name> */
1982 static struct d_comp
*
1983 d_class_enum_type (di
)
1989 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
1990 ::= A [<(dimension) expression>] _ <(element) type>
1993 static struct d_comp
*
2000 if (d_next_char (di
) != 'A')
2003 peek
= d_peek_char (di
);
2006 else if (IS_DIGIT (peek
))
2014 peek
= d_peek_char (di
);
2016 while (IS_DIGIT (peek
));
2017 dim
= d_make_name (di
, s
, d_str (di
) - s
);
2023 dim
= d_expression (di
);
2028 if (d_next_char (di
) != '_')
2031 return d_make_comp (di
, D_COMP_ARRAY_TYPE
, dim
, d_type (di
));
2034 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2036 static struct d_comp
*
2037 d_pointer_to_member_type (di
)
2042 struct d_comp
**pmem
;
2044 if (d_next_char (di
) != 'M')
2049 /* The ABI specifies that any type can be a substitution source, and
2050 that M is followed by two types, and that when a CV-qualified
2051 type is seen both the base type and the CV-qualified types are
2052 substitution sources. The ABI also specifies that for a pointer
2053 to a CV-qualified member function, the qualifiers are attached to
2054 the second type. Given the grammar, a plain reading of the ABI
2055 suggests that both the CV-qualified member function and the
2056 non-qualified member function are substitution sources. However,
2057 g++ does not work that way. g++ treats only the CV-qualified
2058 member function as a substitution source. FIXME. So to work
2059 with g++, we need to pull off the CV-qualifiers here, in order to
2060 avoid calling add_substitution() in d_type(). */
2062 pmem
= d_cv_qualifiers (di
, &mem
, 1);
2065 *pmem
= d_type (di
);
2067 return d_make_comp (di
, D_COMP_PTRMEM_TYPE
, cl
, mem
);
2070 /* <template-param> ::= T_
2071 ::= T <(parameter-2 non-negative) number> _
2074 static struct d_comp
*
2075 d_template_param (di
)
2080 if (d_next_char (di
) != 'T')
2083 if (d_peek_char (di
) == '_')
2087 param
= d_number (di
);
2093 if (d_next_char (di
) != '_')
2096 return d_make_template_param (di
, param
);
2099 /* <template-args> ::= I <template-arg>+ E */
2101 static struct d_comp
*
2102 d_template_args (di
)
2105 struct d_comp
*hold_last_name
;
2107 struct d_comp
**pal
;
2109 /* Preserve the last name we saw--don't let the template arguments
2110 clobber it, as that would give us the wrong name for a subsequent
2111 constructor or destructor. */
2112 hold_last_name
= di
->last_name
;
2114 if (d_next_char (di
) != 'I')
2123 a
= d_template_arg (di
);
2127 *pal
= d_make_comp (di
, D_COMP_TEMPLATE_ARGLIST
, a
, NULL
);
2130 pal
= &d_right (*pal
);
2132 if (d_peek_char (di
) == 'E')
2139 di
->last_name
= hold_last_name
;
2144 /* <template-arg> ::= <type>
2145 ::= X <expression> E
2149 static struct d_comp
*
2155 switch (d_peek_char (di
))
2159 ret
= d_expression (di
);
2160 if (d_next_char (di
) != 'E')
2165 return d_expr_primary (di
);
2172 /* <expression> ::= <(unary) operator-name> <expression>
2173 ::= <(binary) operator-name> <expression> <expression>
2174 ::= <(trinary) operator-name> <expression> <expression> <expression>
2176 ::= <template-param>
2177 ::= sr <type> <unqualified-name>
2178 ::= sr <type> <unqualified-name> <template-args>
2182 static struct d_comp
*
2188 peek
= d_peek_char (di
);
2190 return d_expr_primary (di
);
2191 else if (peek
== 'T')
2192 return d_template_param (di
);
2193 else if (peek
== 's' && d_peek_next_char (di
) == 'r')
2195 struct d_comp
*type
;
2196 struct d_comp
*name
;
2200 name
= d_unqualified_name (di
);
2201 if (d_peek_char (di
) != 'I')
2202 return d_make_comp (di
, D_COMP_QUAL_NAME
, type
, name
);
2204 return d_make_comp (di
, D_COMP_QUAL_NAME
, type
,
2205 d_make_comp (di
, D_COMP_TEMPLATE
, name
,
2206 d_template_args (di
)));
2213 op
= d_operator_name (di
);
2217 if (op
->type
== D_COMP_OPERATOR
2218 && strcmp (op
->u
.s_operator
.op
->code
, "st") == 0)
2219 return d_make_comp (di
, D_COMP_UNARY
, op
, d_type (di
));
2225 case D_COMP_OPERATOR
:
2226 args
= op
->u
.s_operator
.op
->args
;
2228 case D_COMP_EXTENDED_OPERATOR
:
2229 args
= op
->u
.s_extended_operator
.args
;
2239 return d_make_comp (di
, D_COMP_UNARY
, op
, d_expression (di
));
2242 struct d_comp
*left
;
2244 left
= d_expression (di
);
2245 return d_make_comp (di
, D_COMP_BINARY
, op
,
2246 d_make_comp (di
, D_COMP_BINARY_ARGS
, left
,
2247 d_expression (di
)));
2251 struct d_comp
*first
;
2252 struct d_comp
*second
;
2254 first
= d_expression (di
);
2255 second
= d_expression (di
);
2256 return d_make_comp (di
, D_COMP_TRINARY
, op
,
2257 d_make_comp (di
, D_COMP_TRINARY_ARG1
, first
,
2259 D_COMP_TRINARY_ARG2
,
2261 d_expression (di
))));
2269 /* <expr-primary> ::= L <type> <(value) number> E
2270 ::= L <type> <(value) float> E
2271 ::= L <mangled-name> E
2274 static struct d_comp
*
2280 if (d_next_char (di
) != 'L')
2282 if (d_peek_char (di
) == '_')
2283 ret
= d_mangled_name (di
, 0);
2286 struct d_comp
*type
;
2292 /* Rather than try to interpret the literal value, we just
2293 collect it as a string. Note that it's possible to have a
2294 floating point literal here. The ABI specifies that the
2295 format of such literals is machine independent. That's fine,
2296 but what's not fine is that versions of g++ up to 3.2 with
2297 -fabi-version=1 used upper case letters in the hex constant,
2298 and dumped out gcc's internal representation. That makes it
2299 hard to tell where the constant ends, and hard to dump the
2300 constant in any readable form anyhow. We don't attempt to
2301 handle these cases. */
2304 if (d_peek_char (di
) == 'n')
2306 t
= D_COMP_LITERAL_NEG
;
2310 while (d_peek_char (di
) != 'E')
2312 ret
= d_make_comp (di
, t
, type
, d_make_name (di
, s
, d_str (di
) - s
));
2314 if (d_next_char (di
) != 'E')
2319 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2320 ::= Z <(function) encoding> E s [<discriminator>]
2323 static struct d_comp
*
2327 struct d_comp
*function
;
2329 if (d_next_char (di
) != 'Z')
2332 function
= d_encoding (di
, 0);
2334 if (d_next_char (di
) != 'E')
2337 if (d_peek_char (di
) == 's')
2340 if (! d_discriminator (di
))
2342 return d_make_comp (di
, D_COMP_LOCAL_NAME
, function
,
2343 d_make_name (di
, "string literal",
2344 sizeof "string literal" - 1));
2348 struct d_comp
*name
;
2351 if (! d_discriminator (di
))
2353 return d_make_comp (di
, D_COMP_LOCAL_NAME
, function
, name
);
2357 /* <discriminator> ::= _ <(non-negative) number>
2359 We demangle the discriminator, but we don't print it out. FIXME:
2360 We should print it out in verbose mode. */
2363 d_discriminator (di
)
2368 if (d_peek_char (di
) != '_')
2371 discrim
= d_number (di
);
2377 /* Add a new substitution. */
2380 d_add_substitution (di
, dc
)
2386 if (di
->next_sub
>= di
->num_subs
)
2388 di
->subs
[di
->next_sub
] = dc
;
2393 /* <substitution> ::= S <seq-id> _
2403 If PREFIX is non-zero, then this type is being used as a prefix in
2404 a qualified name. In this case, for the standard substitutions, we
2405 need to check whether we are being used as a prefix for a
2406 constructor or destructor, and return a full template name.
2407 Otherwise we will get something like std::iostream::~iostream()
2408 which does not correspond particularly well to any function which
2409 actually appears in the source.
2412 static const struct d_standard_sub_info standard_subs
[] =
2414 { 't', "std", "std", NULL
},
2415 { 'a', "std::allocator", "std::allocator", "allocator" },
2416 { 'b', "std::basic_string", "std::basic_string", "basic_string" },
2417 { 's', "std::string",
2418 "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
2420 { 'i', "std::istream",
2421 "std::basic_istream<char, std::char_traits<char> >",
2423 { 'o', "std::ostream",
2424 "std::basic_ostream<char, std::char_traits<char> >",
2426 { 'd', "std::iostream",
2427 "std::basic_iostream<char, std::char_traits<char> >",
2431 static struct d_comp
*
2432 d_substitution (di
, prefix
)
2438 if (d_next_char (di
) != 'S')
2441 c
= d_next_char (di
);
2442 if (c
== '_' || IS_DIGIT (c
) || IS_UPPER (c
))
2452 id
= id
* 36 + c
- '0';
2453 else if (IS_UPPER (c
))
2454 id
= id
* 36 + c
- 'A' + 10;
2457 c
= d_next_char (di
);
2464 if (id
>= di
->next_sub
)
2467 return di
->subs
[id
];
2472 const struct d_standard_sub_info
*p
;
2473 const struct d_standard_sub_info
*pend
;
2475 verbose
= (di
->options
& DMGL_VERBOSE
) != 0;
2476 if (! verbose
&& prefix
)
2480 peek
= d_peek_char (di
);
2481 if (peek
== 'C' || peek
== 'D')
2485 pend
= (&standard_subs
[0]
2486 + sizeof standard_subs
/ sizeof standard_subs
[0]);
2487 for (p
= &standard_subs
[0]; p
< pend
; ++p
)
2491 if (p
->set_last_name
!= NULL
)
2492 di
->last_name
= d_make_sub (di
, p
->set_last_name
);
2494 return d_make_sub (di
, p
->full_expansion
);
2496 return d_make_sub (di
, p
->simple_expansion
);
2504 /* Resize the print buffer. */
2507 d_print_resize (dpi
, add
)
2508 struct d_print_info
*dpi
;
2513 if (dpi
->buf
== NULL
)
2515 need
= dpi
->len
+ add
;
2516 while (need
> dpi
->alc
)
2521 newalc
= dpi
->alc
* 2;
2522 newbuf
= realloc (dpi
->buf
, newalc
);
2527 dpi
->allocation_failure
= 1;
2535 /* Append a character to the print buffer. */
2538 d_print_append_char (dpi
, c
)
2539 struct d_print_info
*dpi
;
2542 if (dpi
->buf
!= NULL
)
2544 if (dpi
->len
>= dpi
->alc
)
2546 d_print_resize (dpi
, 1);
2547 if (dpi
->buf
== NULL
)
2551 dpi
->buf
[dpi
->len
] = c
;
2556 /* Append a buffer to the print buffer. */
2559 d_print_append_buffer (dpi
, s
, l
)
2560 struct d_print_info
*dpi
;
2564 if (dpi
->buf
!= NULL
)
2566 if (dpi
->len
+ l
> dpi
->alc
)
2568 d_print_resize (dpi
, l
);
2569 if (dpi
->buf
== NULL
)
2573 memcpy (dpi
->buf
+ dpi
->len
, s
, l
);
2578 /* Indicate that an error occurred during printing. */
2582 struct d_print_info
*dpi
;
2588 /* Turn components into a human readable string. Returns a string
2589 allocated by malloc, or NULL on error. On success, this sets *PALC
2590 to the size of the allocated buffer. On failure, this sets *PALC
2591 to 0 for a bad parse, or to 1 for a memory allocation failure. */
2594 d_print (options
, dc
, palc
)
2596 const struct d_comp
*dc
;
2599 struct d_print_info dpi
;
2601 dpi
.options
= options
;
2604 dpi
.buf
= malloc (dpi
.alc
);
2605 if (dpi
.buf
== NULL
)
2612 dpi
.templates
= NULL
;
2613 dpi
.modifiers
= NULL
;
2615 dpi
.allocation_failure
= 0;
2617 d_print_comp (&dpi
, dc
);
2619 d_append_char (&dpi
, '\0');
2621 if (dpi
.buf
!= NULL
)
2624 *palc
= dpi
.allocation_failure
;
2629 /* Subroutine to handle components. */
2632 d_print_comp (dpi
, dc
)
2633 struct d_print_info
*dpi
;
2634 const struct d_comp
*dc
;
2638 d_print_error (dpi
);
2641 if (d_print_saw_error (dpi
))
2647 d_print_identifier (dpi
, dc
->u
.s_name
.s
, dc
->u
.s_name
.len
);
2650 case D_COMP_QUAL_NAME
:
2651 case D_COMP_LOCAL_NAME
:
2652 d_print_comp (dpi
, d_left (dc
));
2653 d_append_string (dpi
, (dpi
->options
& DMGL_JAVA
) == 0 ? "::" : ".");
2654 d_print_comp (dpi
, d_right (dc
));
2657 case D_COMP_TYPED_NAME
:
2659 struct d_print_mod
*hold_modifiers
;
2660 struct d_comp
*typed_name
;
2661 struct d_print_mod adpm
[4];
2663 struct d_print_template dpt
;
2665 /* Pass the name down to the type so that it can be printed in
2666 the right place for the type. We also have to pass down
2667 any CV-qualifiers, which apply to the this parameter. */
2668 hold_modifiers
= dpi
->modifiers
;
2670 typed_name
= d_left (dc
);
2671 while (typed_name
!= NULL
)
2673 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2675 d_print_error (dpi
);
2679 adpm
[i
].next
= dpi
->modifiers
;
2680 dpi
->modifiers
= &adpm
[i
];
2681 adpm
[i
].mod
= typed_name
;
2682 adpm
[i
].printed
= 0;
2683 adpm
[i
].templates
= dpi
->templates
;
2686 if (typed_name
->type
!= D_COMP_RESTRICT_THIS
2687 && typed_name
->type
!= D_COMP_VOLATILE_THIS
2688 && typed_name
->type
!= D_COMP_CONST_THIS
)
2691 typed_name
= d_left (typed_name
);
2694 /* If typed_name is a template, then it applies to the
2695 function type as well. */
2696 if (typed_name
->type
== D_COMP_TEMPLATE
)
2698 dpt
.next
= dpi
->templates
;
2699 dpi
->templates
= &dpt
;
2700 dpt
.template = typed_name
;
2703 /* If typed_name is a D_COMP_LOCAL_NAME, then there may be
2704 CV-qualifiers on its right argument which really apply
2705 here; this happens when parsing a class which is local to a
2707 if (typed_name
->type
== D_COMP_LOCAL_NAME
)
2709 struct d_comp
*local_name
;
2711 local_name
= d_right (typed_name
);
2712 while (local_name
->type
== D_COMP_RESTRICT_THIS
2713 || local_name
->type
== D_COMP_VOLATILE_THIS
2714 || local_name
->type
== D_COMP_CONST_THIS
)
2716 if (i
>= sizeof adpm
/ sizeof adpm
[0])
2718 d_print_error (dpi
);
2722 adpm
[i
] = adpm
[i
- 1];
2723 adpm
[i
].next
= &adpm
[i
- 1];
2724 dpi
->modifiers
= &adpm
[i
];
2726 adpm
[i
- 1].mod
= local_name
;
2727 adpm
[i
- 1].printed
= 0;
2728 adpm
[i
- 1].templates
= dpi
->templates
;
2731 local_name
= d_left (local_name
);
2735 d_print_comp (dpi
, d_right (dc
));
2737 if (typed_name
->type
== D_COMP_TEMPLATE
)
2738 dpi
->templates
= dpt
.next
;
2740 /* If the modifiers didn't get printed by the type, print them
2745 if (! adpm
[i
].printed
)
2747 d_append_char (dpi
, ' ');
2748 d_print_mod (dpi
, adpm
[i
].mod
);
2752 dpi
->modifiers
= hold_modifiers
;
2757 case D_COMP_TEMPLATE
:
2759 struct d_print_mod
*hold_dpm
;
2761 /* Don't push modifiers into a template definition. Doing so
2762 could give the wrong definition for a template argument.
2763 Instead, treat the template essentially as a name. */
2765 hold_dpm
= dpi
->modifiers
;
2766 dpi
->modifiers
= NULL
;
2768 d_print_comp (dpi
, d_left (dc
));
2769 if (d_last_char (dpi
) == '<')
2770 d_append_char (dpi
, ' ');
2771 d_append_char (dpi
, '<');
2772 d_print_comp (dpi
, d_right (dc
));
2773 /* Avoid generating two consecutive '>' characters, to avoid
2774 the C++ syntactic ambiguity. */
2775 if (d_last_char (dpi
) == '>')
2776 d_append_char (dpi
, ' ');
2777 d_append_char (dpi
, '>');
2779 dpi
->modifiers
= hold_dpm
;
2784 case D_COMP_TEMPLATE_PARAM
:
2788 struct d_print_template
*hold_dpt
;
2790 if (dpi
->templates
== NULL
)
2792 d_print_error (dpi
);
2795 i
= dc
->u
.s_number
.number
;
2796 for (a
= d_right (dpi
->templates
->template);
2800 if (a
->type
!= D_COMP_TEMPLATE_ARGLIST
)
2802 d_print_error (dpi
);
2809 if (i
!= 0 || a
== NULL
)
2811 d_print_error (dpi
);
2815 /* While processing this parameter, we need to pop the list of
2816 templates. This is because the template parameter may
2817 itself be a reference to a parameter of an outer
2820 hold_dpt
= dpi
->templates
;
2821 dpi
->templates
= hold_dpt
->next
;
2823 d_print_comp (dpi
, d_left (a
));
2825 dpi
->templates
= hold_dpt
;
2831 d_print_comp (dpi
, dc
->u
.s_ctor
.name
);
2835 d_append_char (dpi
, '~');
2836 d_print_comp (dpi
, dc
->u
.s_dtor
.name
);
2840 d_append_string (dpi
, "vtable for ");
2841 d_print_comp (dpi
, d_left (dc
));
2845 d_append_string (dpi
, "VTT for ");
2846 d_print_comp (dpi
, d_left (dc
));
2849 case D_COMP_CONSTRUCTION_VTABLE
:
2850 d_append_string (dpi
, "construction vtable for ");
2851 d_print_comp (dpi
, d_left (dc
));
2852 d_append_string (dpi
, "-in-");
2853 d_print_comp (dpi
, d_right (dc
));
2856 case D_COMP_TYPEINFO
:
2857 d_append_string (dpi
, "typeinfo for ");
2858 d_print_comp (dpi
, d_left (dc
));
2861 case D_COMP_TYPEINFO_NAME
:
2862 d_append_string (dpi
, "typeinfo name for ");
2863 d_print_comp (dpi
, d_left (dc
));
2866 case D_COMP_TYPEINFO_FN
:
2867 d_append_string (dpi
, "typeinfo fn for ");
2868 d_print_comp (dpi
, d_left (dc
));
2872 d_append_string (dpi
, "non-virtual thunk to ");
2873 d_print_comp (dpi
, d_left (dc
));
2876 case D_COMP_VIRTUAL_THUNK
:
2877 d_append_string (dpi
, "virtual thunk to ");
2878 d_print_comp (dpi
, d_left (dc
));
2881 case D_COMP_COVARIANT_THUNK
:
2882 d_append_string (dpi
, "covariant return thunk to ");
2883 d_print_comp (dpi
, d_left (dc
));
2886 case D_COMP_JAVA_CLASS
:
2887 d_append_string (dpi
, "java Class for ");
2888 d_print_comp (dpi
, d_left (dc
));
2892 d_append_string (dpi
, "guard variable for ");
2893 d_print_comp (dpi
, d_left (dc
));
2896 case D_COMP_REFTEMP
:
2897 d_append_string (dpi
, "reference temporary for ");
2898 d_print_comp (dpi
, d_left (dc
));
2901 case D_COMP_SUB_STD
:
2902 d_append_string (dpi
, dc
->u
.s_string
.string
);
2905 case D_COMP_RESTRICT
:
2906 case D_COMP_VOLATILE
:
2908 case D_COMP_RESTRICT_THIS
:
2909 case D_COMP_VOLATILE_THIS
:
2910 case D_COMP_CONST_THIS
:
2911 case D_COMP_VENDOR_TYPE_QUAL
:
2912 case D_COMP_POINTER
:
2913 case D_COMP_REFERENCE
:
2914 case D_COMP_COMPLEX
:
2915 case D_COMP_IMAGINARY
:
2917 /* We keep a list of modifiers on the stack. */
2918 struct d_print_mod dpm
;
2920 dpm
.next
= dpi
->modifiers
;
2921 dpi
->modifiers
= &dpm
;
2924 dpm
.templates
= dpi
->templates
;
2926 d_print_comp (dpi
, d_left (dc
));
2928 /* If the modifier didn't get printed by the type, print it
2931 d_print_mod (dpi
, dc
);
2933 dpi
->modifiers
= dpm
.next
;
2938 case D_COMP_BUILTIN_TYPE
:
2939 if ((dpi
->options
& DMGL_JAVA
) == 0)
2940 d_append_string (dpi
, dc
->u
.s_builtin
.type
->name
);
2942 d_append_string (dpi
, dc
->u
.s_builtin
.type
->java_name
);
2945 case D_COMP_VENDOR_TYPE
:
2946 d_print_comp (dpi
, d_left (dc
));
2949 case D_COMP_FUNCTION_TYPE
:
2951 if (d_left (dc
) != NULL
)
2953 struct d_print_mod dpm
;
2955 /* We must pass this type down as a modifier in order to
2956 print it in the right location. */
2958 dpm
.next
= dpi
->modifiers
;
2959 dpi
->modifiers
= &dpm
;
2962 dpm
.templates
= dpi
->templates
;
2964 d_print_comp (dpi
, d_left (dc
));
2966 dpi
->modifiers
= dpm
.next
;
2971 d_append_char (dpi
, ' ');
2974 d_print_function_type (dpi
, dc
, dpi
->modifiers
);
2979 case D_COMP_ARRAY_TYPE
:
2981 struct d_print_mod dpm
;
2983 /* We must pass this type down as a modifier in order to print
2984 multi-dimensional arrays correctly. */
2986 dpm
.next
= dpi
->modifiers
;
2987 dpi
->modifiers
= &dpm
;
2990 dpm
.templates
= dpi
->templates
;
2992 d_print_comp (dpi
, d_right (dc
));
2994 dpi
->modifiers
= dpm
.next
;
2999 d_print_array_type (dpi
, dc
, dpi
->modifiers
);
3004 case D_COMP_PTRMEM_TYPE
:
3006 struct d_print_mod dpm
;
3008 dpm
.next
= dpi
->modifiers
;
3009 dpi
->modifiers
= &dpm
;
3012 dpm
.templates
= dpi
->templates
;
3014 d_print_comp (dpi
, d_right (dc
));
3016 /* If the modifier didn't get printed by the type, print it
3020 d_append_char (dpi
, ' ');
3021 d_print_comp (dpi
, d_left (dc
));
3022 d_append_string (dpi
, "::*");
3025 dpi
->modifiers
= dpm
.next
;
3030 case D_COMP_ARGLIST
:
3031 case D_COMP_TEMPLATE_ARGLIST
:
3032 d_print_comp (dpi
, d_left (dc
));
3033 if (d_right (dc
) != NULL
)
3035 d_append_string (dpi
, ", ");
3036 d_print_comp (dpi
, d_right (dc
));
3040 case D_COMP_OPERATOR
:
3044 d_append_string (dpi
, "operator");
3045 c
= dc
->u
.s_operator
.op
->name
[0];
3047 d_append_char (dpi
, ' ');
3048 d_append_string (dpi
, dc
->u
.s_operator
.op
->name
);
3052 case D_COMP_EXTENDED_OPERATOR
:
3053 d_append_string (dpi
, "operator ");
3054 d_print_comp (dpi
, dc
->u
.s_extended_operator
.name
);
3058 d_append_string (dpi
, "operator ");
3059 d_print_cast (dpi
, dc
);
3063 if (d_left (dc
)->type
!= D_COMP_CAST
)
3064 d_print_expr_op (dpi
, d_left (dc
));
3067 d_append_string (dpi
, "((");
3068 d_print_cast (dpi
, d_left (dc
));
3069 d_append_char (dpi
, ')');
3071 d_append_char (dpi
, '(');
3072 d_print_comp (dpi
, d_right (dc
));
3073 d_append_char (dpi
, ')');
3074 if (d_left (dc
)->type
== D_COMP_CAST
)
3075 d_append_char (dpi
, ')');
3079 if (d_right (dc
)->type
!= D_COMP_BINARY_ARGS
)
3081 d_print_error (dpi
);
3085 /* We wrap an expression which uses the greater-than operator in
3086 an extra layer of parens so that it does not get confused
3087 with the '>' which ends the template parameters. */
3088 if (d_left (dc
)->type
== D_COMP_OPERATOR
3089 && strcmp (d_left (dc
)->u
.s_operator
.op
->name
, ">") == 0)
3090 d_append_char (dpi
, '(');
3092 d_append_char (dpi
, '(');
3093 d_print_comp (dpi
, d_left (d_right (dc
)));
3094 d_append_string (dpi
, ") ");
3095 d_print_expr_op (dpi
, d_left (dc
));
3096 d_append_string (dpi
, " (");
3097 d_print_comp (dpi
, d_right (d_right (dc
)));
3098 d_append_char (dpi
, ')');
3100 if (d_left (dc
)->type
== D_COMP_OPERATOR
3101 && strcmp (d_left (dc
)->u
.s_operator
.op
->name
, ">") == 0)
3102 d_append_char (dpi
, ')');
3106 case D_COMP_BINARY_ARGS
:
3107 /* We should only see this as part of D_COMP_BINARY. */
3108 d_print_error (dpi
);
3111 case D_COMP_TRINARY
:
3112 if (d_right (dc
)->type
!= D_COMP_TRINARY_ARG1
3113 || d_right (d_right (dc
))->type
!= D_COMP_TRINARY_ARG2
)
3115 d_print_error (dpi
);
3118 d_append_char (dpi
, '(');
3119 d_print_comp (dpi
, d_left (d_right (dc
)));
3120 d_append_string (dpi
, ") ");
3121 d_print_expr_op (dpi
, d_left (dc
));
3122 d_append_string (dpi
, " (");
3123 d_print_comp (dpi
, d_left (d_right (d_right (dc
))));
3124 d_append_string (dpi
, ") : (");
3125 d_print_comp (dpi
, d_right (d_right (d_right (dc
))));
3126 d_append_char (dpi
, ')');
3129 case D_COMP_TRINARY_ARG1
:
3130 case D_COMP_TRINARY_ARG2
:
3131 /* We should only see these are part of D_COMP_TRINARY. */
3132 d_print_error (dpi
);
3135 case D_COMP_LITERAL
:
3136 case D_COMP_LITERAL_NEG
:
3137 /* For some builtin types, produce simpler output. */
3138 if (d_left (dc
)->type
== D_COMP_BUILTIN_TYPE
)
3140 switch (d_left (dc
)->u
.s_builtin
.type
->print
)
3143 if (d_right (dc
)->type
== D_COMP_NAME
)
3145 if (dc
->type
== D_COMP_LITERAL_NEG
)
3146 d_append_char (dpi
, '-');
3147 d_print_comp (dpi
, d_right (dc
));
3153 if (d_right (dc
)->type
== D_COMP_NAME
)
3155 if (dc
->type
== D_COMP_LITERAL_NEG
)
3156 d_append_char (dpi
, '-');
3157 d_print_comp (dpi
, d_right (dc
));
3158 d_append_char (dpi
, 'l');
3164 if (d_right (dc
)->type
== D_COMP_NAME
3165 && d_right (dc
)->u
.s_name
.len
== 1
3166 && dc
->type
== D_COMP_LITERAL
)
3168 switch (d_right (dc
)->u
.s_name
.s
[0])
3171 d_append_string (dpi
, "false");
3174 d_append_string (dpi
, "true");
3187 d_append_char (dpi
, '(');
3188 d_print_comp (dpi
, d_left (dc
));
3189 d_append_char (dpi
, ')');
3190 if (dc
->type
== D_COMP_LITERAL_NEG
)
3191 d_append_char (dpi
, '-');
3192 d_print_comp (dpi
, d_right (dc
));
3196 d_print_error (dpi
);
3201 /* Print an identifier. */
3204 d_print_identifier (dpi
, name
, len
)
3205 struct d_print_info
*dpi
;
3209 if ((dpi
->options
& DMGL_JAVA
) == 0)
3210 d_append_buffer (dpi
, name
, len
);
3216 /* For Java we try to handle encoded extended Unicode
3217 characters. The C++ ABI doesn't mention Unicode encoding, so
3218 we don't it for C++. Characters are encoded as
3221 for (p
= name
; p
< end
; ++p
)
3232 for (q
= p
+ 3; q
< end
; ++q
)
3238 else if (*q
>= 'A' && *q
<= 'F')
3239 dig
= *q
- 'A' + 10;
3240 else if (*q
>= 'a' && *q
<= 'f')
3241 dig
= *q
- 'a' + 10;
3247 /* If the Unicode character is larger than 256, we don't
3248 try to deal with it here. FIXME. */
3249 if (q
< end
&& *q
== '_' && c
< 256)
3251 d_append_char (dpi
, c
);
3257 d_append_char (dpi
, *p
);
3262 /* Print a list of modifiers. SUFFIX is 1 if we are printing
3263 qualifiers on this after printing a function. */
3266 d_print_mod_list (dpi
, mods
, suffix
)
3267 struct d_print_info
*dpi
;
3268 struct d_print_mod
*mods
;
3271 struct d_print_template
*hold_dpt
;
3273 if (mods
== NULL
|| d_print_saw_error (dpi
))
3278 && (mods
->mod
->type
== D_COMP_RESTRICT_THIS
3279 || mods
->mod
->type
== D_COMP_VOLATILE_THIS
3280 || mods
->mod
->type
== D_COMP_CONST_THIS
)))
3282 d_print_mod_list (dpi
, mods
->next
, suffix
);
3288 hold_dpt
= dpi
->templates
;
3289 dpi
->templates
= mods
->templates
;
3291 if (mods
->mod
->type
== D_COMP_FUNCTION_TYPE
)
3293 d_print_function_type (dpi
, mods
->mod
, mods
->next
);
3294 dpi
->templates
= hold_dpt
;
3297 else if (mods
->mod
->type
== D_COMP_ARRAY_TYPE
)
3299 d_print_array_type (dpi
, mods
->mod
, mods
->next
);
3300 dpi
->templates
= hold_dpt
;
3303 else if (mods
->mod
->type
== D_COMP_LOCAL_NAME
)
3305 struct d_print_mod
*hold_modifiers
;
3308 /* When this is on the modifier stack, we have pulled any
3309 qualifiers off the right argument already. Otherwise, we
3310 print it as usual, but don't let the left argument see any
3313 hold_modifiers
= dpi
->modifiers
;
3314 dpi
->modifiers
= NULL
;
3315 d_print_comp (dpi
, d_left (mods
->mod
));
3316 dpi
->modifiers
= hold_modifiers
;
3318 d_append_string (dpi
, (dpi
->options
& DMGL_JAVA
) == 0 ? "::" : ".");
3320 dc
= d_right (mods
->mod
);
3321 while (dc
->type
== D_COMP_RESTRICT_THIS
3322 || dc
->type
== D_COMP_VOLATILE_THIS
3323 || dc
->type
== D_COMP_CONST_THIS
)
3326 d_print_comp (dpi
, dc
);
3328 dpi
->templates
= hold_dpt
;
3332 d_print_mod (dpi
, mods
->mod
);
3334 dpi
->templates
= hold_dpt
;
3336 d_print_mod_list (dpi
, mods
->next
, suffix
);
3339 /* Print a modifier. */
3342 d_print_mod (dpi
, mod
)
3343 struct d_print_info
*dpi
;
3344 const struct d_comp
*mod
;
3348 case D_COMP_RESTRICT
:
3349 case D_COMP_RESTRICT_THIS
:
3350 d_append_string (dpi
, " restrict");
3352 case D_COMP_VOLATILE
:
3353 case D_COMP_VOLATILE_THIS
:
3354 d_append_string (dpi
, " volatile");
3357 case D_COMP_CONST_THIS
:
3358 d_append_string (dpi
, " const");
3360 case D_COMP_VENDOR_TYPE_QUAL
:
3361 d_append_char (dpi
, ' ');
3362 d_print_comp (dpi
, d_right (mod
));
3364 case D_COMP_POINTER
:
3365 /* There is no pointer symbol in Java. */
3366 if ((dpi
->options
& DMGL_JAVA
) == 0)
3367 d_append_char (dpi
, '*');
3369 case D_COMP_REFERENCE
:
3370 d_append_char (dpi
, '&');
3372 case D_COMP_COMPLEX
:
3373 d_append_string (dpi
, "complex ");
3375 case D_COMP_IMAGINARY
:
3376 d_append_string (dpi
, "imaginary ");
3378 case D_COMP_PTRMEM_TYPE
:
3379 if (d_last_char (dpi
) != '(')
3380 d_append_char (dpi
, ' ');
3381 d_print_comp (dpi
, d_left (mod
));
3382 d_append_string (dpi
, "::*");
3384 case D_COMP_TYPED_NAME
:
3385 d_print_comp (dpi
, d_left (mod
));
3388 /* Otherwise, we have something that won't go back on the
3389 modifier stack, so we can just print it. */
3390 d_print_comp (dpi
, mod
);
3395 /* Print a function type, except for the return type. */
3398 d_print_function_type (dpi
, dc
, mods
)
3399 struct d_print_info
*dpi
;
3400 const struct d_comp
*dc
;
3401 struct d_print_mod
*mods
;
3405 struct d_print_mod
*p
;
3406 struct d_print_mod
*hold_modifiers
;
3410 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3416 switch (p
->mod
->type
)
3418 case D_COMP_RESTRICT
:
3419 case D_COMP_VOLATILE
:
3421 case D_COMP_VENDOR_TYPE_QUAL
:
3422 case D_COMP_POINTER
:
3423 case D_COMP_REFERENCE
:
3424 case D_COMP_COMPLEX
:
3425 case D_COMP_IMAGINARY
:
3426 case D_COMP_PTRMEM_TYPE
:
3429 case D_COMP_RESTRICT_THIS
:
3430 case D_COMP_VOLATILE_THIS
:
3431 case D_COMP_CONST_THIS
:
3440 if (d_left (dc
) != NULL
&& ! saw_mod
)
3445 switch (d_last_char (dpi
))
3453 d_append_char (dpi
, ' ');
3457 d_append_char (dpi
, '(');
3460 hold_modifiers
= dpi
->modifiers
;
3461 dpi
->modifiers
= NULL
;
3463 d_print_mod_list (dpi
, mods
, 0);
3466 d_append_char (dpi
, ')');
3468 d_append_char (dpi
, '(');
3470 if (d_right (dc
) != NULL
)
3471 d_print_comp (dpi
, d_right (dc
));
3473 d_append_char (dpi
, ')');
3475 d_print_mod_list (dpi
, mods
, 1);
3477 dpi
->modifiers
= hold_modifiers
;
3480 /* Print an array type, except for the element type. */
3483 d_print_array_type (dpi
, dc
, mods
)
3484 struct d_print_info
*dpi
;
3485 const struct d_comp
*dc
;
3486 struct d_print_mod
*mods
;
3494 struct d_print_mod
*p
;
3497 for (p
= mods
; p
!= NULL
; p
= p
->next
)
3502 if (p
->mod
->type
== D_COMP_ARRAY_TYPE
)
3516 d_append_string (dpi
, " (");
3518 d_print_mod_list (dpi
, mods
, 0);
3521 d_append_char (dpi
, ')');
3525 d_append_char (dpi
, ' ');
3527 d_append_char (dpi
, '[');
3529 if (d_left (dc
) != NULL
)
3530 d_print_comp (dpi
, d_left (dc
));
3532 d_append_char (dpi
, ']');
3535 /* Print an operator in an expression. */
3538 d_print_expr_op (dpi
, dc
)
3539 struct d_print_info
*dpi
;
3540 const struct d_comp
*dc
;
3542 if (dc
->type
== D_COMP_OPERATOR
)
3543 d_append_string (dpi
, dc
->u
.s_operator
.op
->name
);
3545 d_print_comp (dpi
, dc
);
3551 d_print_cast (dpi
, dc
)
3552 struct d_print_info
*dpi
;
3553 const struct d_comp
*dc
;
3555 if (d_left (dc
)->type
!= D_COMP_TEMPLATE
)
3556 d_print_comp (dpi
, d_left (dc
));
3559 struct d_print_mod
*hold_dpm
;
3560 struct d_print_template dpt
;
3562 /* It appears that for a templated cast operator, we need to put
3563 the template parameters in scope for the operator name, but
3564 not for the parameters. The effect is that we need to handle
3565 the template printing here. */
3567 hold_dpm
= dpi
->modifiers
;
3568 dpi
->modifiers
= NULL
;
3570 dpt
.next
= dpi
->templates
;
3571 dpi
->templates
= &dpt
;
3572 dpt
.template = d_left (dc
);
3574 d_print_comp (dpi
, d_left (d_left (dc
)));
3576 dpi
->templates
= dpt
.next
;
3578 if (d_last_char (dpi
) == '<')
3579 d_append_char (dpi
, ' ');
3580 d_append_char (dpi
, '<');
3581 d_print_comp (dpi
, d_right (d_left (dc
)));
3582 /* Avoid generating two consecutive '>' characters, to avoid
3583 the C++ syntactic ambiguity. */
3584 if (d_last_char (dpi
) == '>')
3585 d_append_char (dpi
, ' ');
3586 d_append_char (dpi
, '>');
3588 dpi
->modifiers
= hold_dpm
;
3592 /* Initialize the information structure we use to pass around
3596 d_init_info (mangled
, options
, len
, di
)
3597 const char *mangled
;
3603 di
->options
= options
;
3607 /* We can not need more components than twice the number of chars in
3608 the mangled string. Most components correspond directly to
3609 chars, but the ARGLIST types are exceptions. */
3610 di
->num_comps
= 2 * len
;
3611 di
->comps
= (struct d_comp
*) malloc (di
->num_comps
3612 * sizeof (struct d_comp
));
3615 /* Similarly, we can not need more substitutions than there are
3616 chars in the mangled string. */
3618 di
->subs
= (struct d_comp
**) malloc (di
->num_subs
3619 * sizeof (struct d_comp
*));
3622 di
->last_name
= NULL
;
3624 if (di
->comps
== NULL
|| di
->subs
== NULL
)
3626 if (di
->comps
!= NULL
)
3628 if (di
->subs
!= NULL
)
3636 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
3637 name, return a buffer allocated with malloc holding the demangled
3638 name. OPTIONS is the usual libiberty demangler options. On
3639 success, this sets *PALC to the allocated size of the returned
3640 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
3641 a memory allocation failure. On failure, this returns NULL. */
3644 d_demangle (mangled
, options
, palc
)
3645 const char* mangled
;
3657 len
= strlen (mangled
);
3659 if (mangled
[0] == '_' && mangled
[1] == 'Z')
3661 else if (strncmp (mangled
, "_GLOBAL_", 8) == 0
3662 && (mangled
[8] == '.' || mangled
[8] == '_' || mangled
[8] == '$')
3663 && (mangled
[9] == 'D' || mangled
[9] == 'I')
3664 && mangled
[10] == '_')
3668 r
= malloc (40 + len
- 11);
3673 if (mangled
[9] == 'I')
3674 strcpy (r
, "global constructors keyed to ");
3676 strcpy (r
, "global destructors keyed to ");
3677 strcat (r
, mangled
+ 11);
3683 if ((options
& DMGL_TYPES
) == 0)
3688 if (! d_init_info (mangled
, options
, len
, &di
))
3695 dc
= d_mangled_name (&di
, 1);
3699 /* If DMGL_PARAMS is set, then if we didn't consume the entire
3700 mangled string, then we didn't successfully demangle it. If
3701 DMGL_PARAMS is not set, we didn't look at the trailing
3703 if (((options
& DMGL_PARAMS
) != 0) && d_peek_char (&di
) != '\0')
3706 #ifdef CP_DEMANGLE_DEBUG
3708 printf ("failed demangling\n");
3718 ret
= d_print (options
, dc
, palc
);
3725 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3727 extern char *__cxa_demangle
PARAMS ((const char *, char *, size_t *, int *));
3729 /* ia64 ABI-mandated entry point in the C++ runtime library for
3730 performing demangling. MANGLED_NAME is a NUL-terminated character
3731 string containing the name to be demangled.
3733 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3734 *LENGTH bytes, into which the demangled name is stored. If
3735 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3736 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3737 is placed in a region of memory allocated with malloc.
3739 If LENGTH is non-NULL, the length of the buffer conaining the
3740 demangled name, is placed in *LENGTH.
3742 The return value is a pointer to the start of the NUL-terminated
3743 demangled name, or NULL if the demangling fails. The caller is
3744 responsible for deallocating this memory using free.
3746 *STATUS is set to one of the following values:
3747 0: The demangling operation succeeded.
3748 -1: A memory allocation failure occurred.
3749 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3750 -3: One of the arguments is invalid.
3752 The demangling is performed using the C++ ABI mangling rules, with
3756 __cxa_demangle (mangled_name
, output_buffer
, length
, status
)
3757 const char *mangled_name
;
3758 char *output_buffer
;
3768 if (mangled_name
== NULL
)
3774 if (output_buffer
!= NULL
&& length
== NULL
)
3780 demangled
= d_demangle (mangled_name
, DMGL_TYPES
, &alc
);
3782 if (demangled
== NULL
)
3791 if (output_buffer
== NULL
)
3798 if (strlen (demangled
) < *length
)
3800 strcpy (output_buffer
, demangled
);
3802 demangled
= output_buffer
;
3806 free (output_buffer
);
3816 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
3818 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
3819 mangled name, return a buffer allocated with malloc holding the
3820 demangled name. Otherwise, return NULL. */
3823 cplus_demangle_v3 (mangled
, options
)
3824 const char* mangled
;
3829 return d_demangle (mangled
, options
, &alc
);
3832 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
3833 conventions, but the output formatting is a little different.
3834 This instructs the C++ demangler not to emit pointer characters ("*"), and
3835 to use Java's namespace separator symbol ("." instead of "::"). It then
3836 does an additional pass over the demangled output to replace instances
3837 of JArray<TYPE> with TYPE[]. */
3840 java_demangle_v3 (mangled
)
3841 const char* mangled
;
3849 demangled
= d_demangle (mangled
, DMGL_JAVA
| DMGL_PARAMS
, &alc
);
3851 if (demangled
== NULL
)
3857 while (*from
!= '\0')
3859 if (strncmp (from
, "JArray<", 7) == 0)
3864 else if (nesting
> 0 && *from
== '>')
3866 while (to
> demangled
&& to
[-1] == ' ')
3882 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
3884 #ifndef IN_GLIBCPP_V3
3886 /* Demangle a string in order to find out whether it is a constructor
3887 or destructor. Return non-zero on success. Set *CTOR_KIND and
3888 *DTOR_KIND appropriately. */
3891 is_ctor_or_dtor (mangled
, ctor_kind
, dtor_kind
)
3892 const char *mangled
;
3893 enum gnu_v3_ctor_kinds
*ctor_kind
;
3894 enum gnu_v3_dtor_kinds
*dtor_kind
;
3900 *ctor_kind
= (enum gnu_v3_ctor_kinds
) 0;
3901 *dtor_kind
= (enum gnu_v3_dtor_kinds
) 0;
3903 if (! d_init_info (mangled
, DMGL_GNU_V3
, strlen (mangled
), &di
))
3906 dc
= d_mangled_name (&di
, 1);
3908 /* Note that because we did not pass DMGL_PARAMS, we don't expect to
3909 demangle the entire string. */
3919 case D_COMP_TYPED_NAME
:
3920 case D_COMP_TEMPLATE
:
3921 case D_COMP_RESTRICT_THIS
:
3922 case D_COMP_VOLATILE_THIS
:
3923 case D_COMP_CONST_THIS
:
3926 case D_COMP_QUAL_NAME
:
3927 case D_COMP_LOCAL_NAME
:
3931 *ctor_kind
= dc
->u
.s_ctor
.kind
;
3936 *dtor_kind
= dc
->u
.s_dtor
.kind
;
3949 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
3950 name. A non-zero return indicates the type of constructor. */
3952 enum gnu_v3_ctor_kinds
3953 is_gnu_v3_mangled_ctor (name
)
3956 enum gnu_v3_ctor_kinds ctor_kind
;
3957 enum gnu_v3_dtor_kinds dtor_kind
;
3959 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
3960 return (enum gnu_v3_ctor_kinds
) 0;
3965 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
3966 name. A non-zero return indicates the type of destructor. */
3968 enum gnu_v3_dtor_kinds
3969 is_gnu_v3_mangled_dtor (name
)
3972 enum gnu_v3_ctor_kinds ctor_kind
;
3973 enum gnu_v3_dtor_kinds dtor_kind
;
3975 if (! is_ctor_or_dtor (name
, &ctor_kind
, &dtor_kind
))
3976 return (enum gnu_v3_dtor_kinds
) 0;
3980 #endif /* IN_GLIBCPP_V3 */
3982 #ifdef STANDALONE_DEMANGLER
3985 #include "dyn-string.h"
3987 static void print_usage
PARAMS ((FILE* fp
, int exit_value
));
3989 #define IS_ALPHA(CHAR) \
3990 (((CHAR) >= 'a' && (CHAR) <= 'z') \
3991 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
3993 /* Non-zero if CHAR is a character than can occur in a mangled name. */
3994 #define is_mangled_char(CHAR) \
3995 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
3996 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
3998 /* The name of this program, as invoked. */
3999 const char* program_name
;
4001 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
4004 print_usage (fp
, exit_value
)
4008 fprintf (fp
, "Usage: %s [options] [names ...]\n", program_name
);
4009 fprintf (fp
, "Options:\n");
4010 fprintf (fp
, " -h,--help Display this message.\n");
4011 fprintf (fp
, " -p,--no-params Don't display function parameters\n");
4012 fprintf (fp
, " -v,--verbose Produce verbose demanglings.\n");
4013 fprintf (fp
, "If names are provided, they are demangled. Otherwise filters standard input.\n");
4018 /* Option specification for getopt_long. */
4019 static const struct option long_options
[] =
4021 { "help", no_argument
, NULL
, 'h' },
4022 { "no-params", no_argument
, NULL
, 'p' },
4023 { "verbose", no_argument
, NULL
, 'v' },
4024 { NULL
, no_argument
, NULL
, 0 },
4027 /* Main entry for a demangling filter executable. It will demangle
4028 its command line arguments, if any. If none are provided, it will
4029 filter stdin to stdout, replacing any recognized mangled C++ names
4030 with their demangled equivalents. */
4039 int options
= DMGL_PARAMS
| DMGL_ANSI
| DMGL_TYPES
;
4041 /* Use the program name of this program, as invoked. */
4042 program_name
= argv
[0];
4044 /* Parse options. */
4047 opt_char
= getopt_long (argc
, argv
, "hpv", long_options
, NULL
);
4050 case '?': /* Unrecognized option. */
4051 print_usage (stderr
, 1);
4055 print_usage (stdout
, 0);
4059 options
&= ~ DMGL_PARAMS
;
4063 options
|= DMGL_VERBOSE
;
4067 while (opt_char
!= -1);
4070 /* No command line arguments were provided. Filter stdin. */
4072 dyn_string_t mangled
= dyn_string_new (3);
4075 /* Read all of input. */
4076 while (!feof (stdin
))
4080 /* Pile characters into mangled until we hit one that can't
4081 occur in a mangled name. */
4083 while (!feof (stdin
) && is_mangled_char (c
))
4085 dyn_string_append_char (mangled
, c
);
4091 if (dyn_string_length (mangled
) > 0)
4093 s
= cplus_demangle_v3 (dyn_string_buf (mangled
), options
);
4102 /* It might not have been a mangled name. Print the
4104 fputs (dyn_string_buf (mangled
), stdout
);
4107 dyn_string_clear (mangled
);
4110 /* If we haven't hit EOF yet, we've read one character that
4111 can't occur in a mangled name, so print it out. */
4116 dyn_string_delete (mangled
);
4119 /* Demangle command line arguments. */
4121 /* Loop over command line arguments. */
4122 for (i
= optind
; i
< argc
; ++i
)
4126 /* Attempt to demangle. */
4127 s
= cplus_demangle_v3 (argv
[i
], options
);
4129 /* If it worked, print the demangled name. */
4136 fprintf (stderr
, "Failed: %s\n", argv
[i
]);
4143 #endif /* STANDALONE_DEMANGLER */