1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
4
5 This file is part of the libiberty library, which is part of GCC.
6
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.
11
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
19 executable.)
20
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.
25
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.
29 */
30
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
34
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
37
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
40 name.
41
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)
47
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
58 cplus_demangle_print
59 and other functions defined in the file cp-demint.c.
60
61 This file also defines some other functions and variables which are
62 only to be used by the file cp-demint.c.
63
64 Preprocessor macros you can define while compiling this file:
65
66 IN_LIBGCC2
67 If defined, this file defines the following function, q.v.:
68 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
69 int *status)
70 instead of cplus_demangle_v3() and java_demangle_v3().
71
72 IN_GLIBCPP_V3
73 If defined, this file defines only __cxa_demangle(), and no other
74 publically visible functions or variables.
75
76 STANDALONE_DEMANGLER
77 If defined, this file defines a main() function which demangles
78 any arguments, or, if none, demangles stdin.
79
80 CP_DEMANGLE_DEBUG
81 If defined, turns on debugging mode, which prints information on
82 stdout about the mangled string. This is not generally useful.
83 */
84
85 #ifdef HAVE_CONFIG_H
86 #include "config.h"
87 #endif
88
89 #include <stdio.h>
90
91 #ifdef HAVE_STDLIB_H
92 #include <stdlib.h>
93 #endif
94 #ifdef HAVE_STRING_H
95 #include <string.h>
96 #endif
97
98 #include "ansidecl.h"
99 #include "libiberty.h"
100 #include "demangle.h"
101 #include "cp-demangle.h"
102
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
106 file. */
107 #ifdef IN_GLIBCPP_V3
108
109 #define CP_STATIC_IF_GLIBCPP_V3 static
110
111 #define cplus_demangle_fill_name d_fill_name
112 static int
113 d_fill_name PARAMS ((struct demangle_component *, const char *, int));
114
115 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
116 static int
117 d_fill_extended_operator PARAMS ((struct demangle_component *, int,
118 struct demangle_component *));
119
120 #define cplus_demangle_fill_ctor d_fill_ctor
121 static int
122 d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
123 struct demangle_component *));
124
125 #define cplus_demangle_fill_dtor d_fill_dtor
126 static int
127 d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
128 struct demangle_component *));
129
130 #define cplus_demangle_mangled_name d_mangled_name
131 static struct demangle_component *
132 d_mangled_name PARAMS ((struct d_info *, int));
133
134 #define cplus_demangle_type d_type
135 static struct demangle_component *
136 d_type PARAMS ((struct d_info *));
137
138 #define cplus_demangle_print d_print
139 static char *
140 d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
141
142 #define cplus_demangle_init_info d_init_info
143 static void
144 d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
145
146 #else /* ! defined(IN_GLIBCPP_V3) */
147 #define CP_STATIC_IF_GLIBCPP_V3
148 #endif /* ! defined(IN_GLIBCPP_V3) */
149
150 /* See if the compiler supports dynamic arrays. */
151
152 #ifdef __GNUC__
153 #define CP_DYNAMIC_ARRAYS
154 #else
155 #ifdef __STDC__
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__) */
163
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
167 V3 demangler code.
168
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. */
172
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')
176
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)
182
183 /* Information we keep for the standard substitutions. */
184
185 struct d_standard_sub_info
186 {
187 /* The code for this substitution. */
188 char code;
189 /* The simple string it expands to. */
190 const char *simple_expansion;
191 /* The length of the simple expansion. */
192 int simple_len;
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. */
197 int full_len;
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;
204 };
205
206 /* Accessors for subtrees of struct demangle_component. */
207
208 #define d_left(dc) ((dc)->u.s_binary.left)
209 #define d_right(dc) ((dc)->u.s_binary.right)
210
211 /* A list of templates. This is used while printing. */
212
213 struct d_print_template
214 {
215 /* Next template on the list. */
216 struct d_print_template *next;
217 /* This template. */
218 const struct demangle_component *template;
219 };
220
221 /* A list of type modifiers. This is used while printing. */
222
223 struct d_print_mod
224 {
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;
228 /* The modifier. */
229 const struct demangle_component *mod;
230 /* Whether this modifier was printed. */
231 int printed;
232 /* The list of templates which applies to this modifier. */
233 struct d_print_template *templates;
234 };
235
236 /* We use this structure to hold information during printing. */
237
238 struct d_print_info
239 {
240 /* The options passed to the demangler. */
241 int options;
242 /* Buffer holding the result. */
243 char *buf;
244 /* Current length of data in buffer. */
245 size_t len;
246 /* Allocated size of buffer. */
247 size_t alc;
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.),
251 if any. */
252 struct d_print_mod *modifiers;
253 /* Set to 1 if we had a memory allocation failure. */
254 int allocation_failure;
255 };
256
257 #define d_print_saw_error(dpi) ((dpi)->buf == NULL)
258
259 #define d_append_char(dpi, c) \
260 do \
261 { \
262 if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
263 (dpi)->buf[(dpi)->len++] = (c); \
264 else \
265 d_print_append_char ((dpi), (c)); \
266 } \
267 while (0)
268
269 #define d_append_buffer(dpi, s, l) \
270 do \
271 { \
272 if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
273 { \
274 memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
275 (dpi)->len += l; \
276 } \
277 else \
278 d_print_append_buffer ((dpi), (s), (l)); \
279 } \
280 while (0)
281
282 #define d_append_string_constant(dpi, s) \
283 d_append_buffer (dpi, (s), sizeof (s) - 1)
284
285 #define d_last_char(dpi) \
286 ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
287
288 #ifdef CP_DEMANGLE_DEBUG
289 static void
290 d_dump PARAMS ((struct demangle_component *, int));
291 #endif
292
293 static struct demangle_component *
294 d_make_empty PARAMS ((struct d_info *));
295
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 *));
300
301 static struct demangle_component *
302 d_make_name PARAMS ((struct d_info *, const char *, int));
303
304 static struct demangle_component *
305 d_make_builtin_type PARAMS ((struct d_info *,
306 const struct demangle_builtin_type_info *));
307
308 static struct demangle_component *
309 d_make_operator PARAMS ((struct d_info *,
310 const struct demangle_operator_info *));
311
312 static struct demangle_component *
313 d_make_extended_operator PARAMS ((struct d_info *, int,
314 struct demangle_component *));
315
316 static struct demangle_component *
317 d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
318 struct demangle_component *));
319
320 static struct demangle_component *
321 d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
322 struct demangle_component *));
323
324 static struct demangle_component *
325 d_make_template_param PARAMS ((struct d_info *, long));
326
327 static struct demangle_component *
328 d_make_sub PARAMS ((struct d_info *, const char *, int));
329
330 static int
331 has_return_type PARAMS ((struct demangle_component *));
332
333 static int
334 is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
335
336 static struct demangle_component *
337 d_encoding PARAMS ((struct d_info *, int));
338
339 static struct demangle_component *
340 d_name PARAMS ((struct d_info *));
341
342 static struct demangle_component *
343 d_nested_name PARAMS ((struct d_info *));
344
345 static struct demangle_component *
346 d_prefix PARAMS ((struct d_info *));
347
348 static struct demangle_component *
349 d_unqualified_name PARAMS ((struct d_info *));
350
351 static struct demangle_component *
352 d_source_name PARAMS ((struct d_info *));
353
354 static long
355 d_number PARAMS ((struct d_info *));
356
357 static struct demangle_component *
358 d_identifier PARAMS ((struct d_info *, int));
359
360 static struct demangle_component *
361 d_operator_name PARAMS ((struct d_info *));
362
363 static struct demangle_component *
364 d_special_name PARAMS ((struct d_info *));
365
366 static int
367 d_call_offset PARAMS ((struct d_info *, int));
368
369 static struct demangle_component *
370 d_ctor_dtor_name PARAMS ((struct d_info *));
371
372 static struct demangle_component **
373 d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
374
375 static struct demangle_component *
376 d_function_type PARAMS ((struct d_info *));
377
378 static struct demangle_component *
379 d_bare_function_type PARAMS ((struct d_info *, int));
380
381 static struct demangle_component *
382 d_class_enum_type PARAMS ((struct d_info *));
383
384 static struct demangle_component *
385 d_array_type PARAMS ((struct d_info *));
386
387 static struct demangle_component *
388 d_pointer_to_member_type PARAMS ((struct d_info *));
389
390 static struct demangle_component *
391 d_template_param PARAMS ((struct d_info *));
392
393 static struct demangle_component *
394 d_template_args PARAMS ((struct d_info *));
395
396 static struct demangle_component *
397 d_template_arg PARAMS ((struct d_info *));
398
399 static struct demangle_component *
400 d_expression PARAMS ((struct d_info *));
401
402 static struct demangle_component *
403 d_expr_primary PARAMS ((struct d_info *));
404
405 static struct demangle_component *
406 d_local_name PARAMS ((struct d_info *));
407
408 static int
409 d_discriminator PARAMS ((struct d_info *));
410
411 static int
412 d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
413
414 static struct demangle_component *
415 d_substitution PARAMS ((struct d_info *, int));
416
417 static void
418 d_print_resize PARAMS ((struct d_print_info *, size_t));
419
420 static void
421 d_print_append_char PARAMS ((struct d_print_info *, int));
422
423 static void
424 d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
425
426 static void
427 d_print_error PARAMS ((struct d_print_info *));
428
429 static void
430 d_print_comp PARAMS ((struct d_print_info *,
431 const struct demangle_component *));
432
433 static void
434 d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
435
436 static void
437 d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
438
439 static void
440 d_print_mod PARAMS ((struct d_print_info *,
441 const struct demangle_component *));
442
443 static void
444 d_print_function_type PARAMS ((struct d_print_info *,
445 const struct demangle_component *,
446 struct d_print_mod *));
447
448 static void
449 d_print_array_type PARAMS ((struct d_print_info *,
450 const struct demangle_component *,
451 struct d_print_mod *));
452
453 static void
454 d_print_expr_op PARAMS ((struct d_print_info *,
455 const struct demangle_component *));
456
457 static void
458 d_print_cast PARAMS ((struct d_print_info *,
459 const struct demangle_component *));
460
461 static char *
462 d_demangle PARAMS ((const char *, int, size_t *));
463
464 #ifdef CP_DEMANGLE_DEBUG
465
466 static void
d_dump(dc,indent)467 d_dump (dc, indent)
468 struct demangle_component *dc;
469 int indent;
470 {
471 int i;
472
473 if (dc == NULL)
474 return;
475
476 for (i = 0; i < indent; ++i)
477 putchar (' ');
478
479 switch (dc->type)
480 {
481 case DEMANGLE_COMPONENT_NAME:
482 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
483 return;
484 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
485 printf ("template parameter %ld\n", dc->u.s_number.number);
486 return;
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);
490 return;
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);
494 return;
495 case DEMANGLE_COMPONENT_SUB_STD:
496 printf ("standard substitution %s\n", dc->u.s_string.string);
497 return;
498 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
499 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
500 return;
501 case DEMANGLE_COMPONENT_OPERATOR:
502 printf ("operator %s\n", dc->u.s_operator.op->name);
503 return;
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);
508 return;
509
510 case DEMANGLE_COMPONENT_QUAL_NAME:
511 printf ("qualified name\n");
512 break;
513 case DEMANGLE_COMPONENT_LOCAL_NAME:
514 printf ("local name\n");
515 break;
516 case DEMANGLE_COMPONENT_TYPED_NAME:
517 printf ("typed name\n");
518 break;
519 case DEMANGLE_COMPONENT_TEMPLATE:
520 printf ("template\n");
521 break;
522 case DEMANGLE_COMPONENT_VTABLE:
523 printf ("vtable\n");
524 break;
525 case DEMANGLE_COMPONENT_VTT:
526 printf ("VTT\n");
527 break;
528 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
529 printf ("construction vtable\n");
530 break;
531 case DEMANGLE_COMPONENT_TYPEINFO:
532 printf ("typeinfo\n");
533 break;
534 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
535 printf ("typeinfo name\n");
536 break;
537 case DEMANGLE_COMPONENT_TYPEINFO_FN:
538 printf ("typeinfo function\n");
539 break;
540 case DEMANGLE_COMPONENT_THUNK:
541 printf ("thunk\n");
542 break;
543 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
544 printf ("virtual thunk\n");
545 break;
546 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
547 printf ("covariant thunk\n");
548 break;
549 case DEMANGLE_COMPONENT_JAVA_CLASS:
550 printf ("java class\n");
551 break;
552 case DEMANGLE_COMPONENT_GUARD:
553 printf ("guard\n");
554 break;
555 case DEMANGLE_COMPONENT_REFTEMP:
556 printf ("reference temporary\n");
557 break;
558 case DEMANGLE_COMPONENT_RESTRICT:
559 printf ("restrict\n");
560 break;
561 case DEMANGLE_COMPONENT_VOLATILE:
562 printf ("volatile\n");
563 break;
564 case DEMANGLE_COMPONENT_CONST:
565 printf ("const\n");
566 break;
567 case DEMANGLE_COMPONENT_RESTRICT_THIS:
568 printf ("restrict this\n");
569 break;
570 case DEMANGLE_COMPONENT_VOLATILE_THIS:
571 printf ("volatile this\n");
572 break;
573 case DEMANGLE_COMPONENT_CONST_THIS:
574 printf ("const this\n");
575 break;
576 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
577 printf ("vendor type qualifier\n");
578 break;
579 case DEMANGLE_COMPONENT_POINTER:
580 printf ("pointer\n");
581 break;
582 case DEMANGLE_COMPONENT_REFERENCE:
583 printf ("reference\n");
584 break;
585 case DEMANGLE_COMPONENT_COMPLEX:
586 printf ("complex\n");
587 break;
588 case DEMANGLE_COMPONENT_IMAGINARY:
589 printf ("imaginary\n");
590 break;
591 case DEMANGLE_COMPONENT_VENDOR_TYPE:
592 printf ("vendor type\n");
593 break;
594 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
595 printf ("function type\n");
596 break;
597 case DEMANGLE_COMPONENT_ARRAY_TYPE:
598 printf ("array type\n");
599 break;
600 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
601 printf ("pointer to member type\n");
602 break;
603 case DEMANGLE_COMPONENT_ARGLIST:
604 printf ("argument list\n");
605 break;
606 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
607 printf ("template argument list\n");
608 break;
609 case DEMANGLE_COMPONENT_CAST:
610 printf ("cast\n");
611 break;
612 case DEMANGLE_COMPONENT_UNARY:
613 printf ("unary operator\n");
614 break;
615 case DEMANGLE_COMPONENT_BINARY:
616 printf ("binary operator\n");
617 break;
618 case DEMANGLE_COMPONENT_BINARY_ARGS:
619 printf ("binary operator arguments\n");
620 break;
621 case DEMANGLE_COMPONENT_TRINARY:
622 printf ("trinary operator\n");
623 break;
624 case DEMANGLE_COMPONENT_TRINARY_ARG1:
625 printf ("trinary operator arguments 1\n");
626 break;
627 case DEMANGLE_COMPONENT_TRINARY_ARG2:
628 printf ("trinary operator arguments 1\n");
629 break;
630 case DEMANGLE_COMPONENT_LITERAL:
631 printf ("literal\n");
632 break;
633 case DEMANGLE_COMPONENT_LITERAL_NEG:
634 printf ("negative literal\n");
635 break;
636 }
637
638 d_dump (d_left (dc), indent + 2);
639 d_dump (d_right (dc), indent + 2);
640 }
641
642 #endif /* CP_DEMANGLE_DEBUG */
643
644 /* Fill in a DEMANGLE_COMPONENT_NAME. */
645
646 CP_STATIC_IF_GLIBCPP_V3
647 int
cplus_demangle_fill_name(p,s,len)648 cplus_demangle_fill_name (p, s, len)
649 struct demangle_component *p;
650 const char *s;
651 int len;
652 {
653 if (p == NULL || s == NULL || len == 0)
654 return 0;
655 p->type = DEMANGLE_COMPONENT_NAME;
656 p->u.s_name.s = s;
657 p->u.s_name.len = len;
658 return 1;
659 }
660
661 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
662
663 CP_STATIC_IF_GLIBCPP_V3
664 int
cplus_demangle_fill_extended_operator(p,args,name)665 cplus_demangle_fill_extended_operator (p, args, name)
666 struct demangle_component *p;
667 int args;
668 struct demangle_component *name;
669 {
670 if (p == NULL || args < 0 || name == NULL)
671 return 0;
672 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
673 p->u.s_extended_operator.args = args;
674 p->u.s_extended_operator.name = name;
675 return 1;
676 }
677
678 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
679
680 CP_STATIC_IF_GLIBCPP_V3
681 int
cplus_demangle_fill_ctor(p,kind,name)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;
686 {
687 if (p == NULL
688 || name == NULL
689 || (kind < gnu_v3_complete_object_ctor
690 && kind > gnu_v3_complete_object_allocating_ctor))
691 return 0;
692 p->type = DEMANGLE_COMPONENT_CTOR;
693 p->u.s_ctor.kind = kind;
694 p->u.s_ctor.name = name;
695 return 1;
696 }
697
698 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
699
700 CP_STATIC_IF_GLIBCPP_V3
701 int
cplus_demangle_fill_dtor(p,kind,name)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;
706 {
707 if (p == NULL
708 || name == NULL
709 || (kind < gnu_v3_deleting_dtor
710 && kind > gnu_v3_base_object_dtor))
711 return 0;
712 p->type = DEMANGLE_COMPONENT_DTOR;
713 p->u.s_dtor.kind = kind;
714 p->u.s_dtor.name = name;
715 return 1;
716 }
717
718 /* Add a new component. */
719
720 static struct demangle_component *
d_make_empty(di)721 d_make_empty (di)
722 struct d_info *di;
723 {
724 struct demangle_component *p;
725
726 if (di->next_comp >= di->num_comps)
727 return NULL;
728 p = &di->comps[di->next_comp];
729 ++di->next_comp;
730 return p;
731 }
732
733 /* Add a new generic component. */
734
735 static struct demangle_component *
d_make_comp(di,type,left,right)736 d_make_comp (di, type, left, right)
737 struct d_info *di;
738 enum demangle_component_type type;
739 struct demangle_component *left;
740 struct demangle_component *right;
741 {
742 struct demangle_component *p;
743
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
746 upward. */
747 switch (type)
748 {
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)
766 return NULL;
767 break;
768
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:
789 if (left == NULL)
790 return NULL;
791 break;
792
793 /* This needs a right parameter, but the left parameter can be
794 empty. */
795 case DEMANGLE_COMPONENT_ARRAY_TYPE:
796 if (right == NULL)
797 return NULL;
798 break;
799
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:
809 break;
810
811 /* Other types should not be seen here. */
812 default:
813 return NULL;
814 }
815
816 p = d_make_empty (di);
817 if (p != NULL)
818 {
819 p->type = type;
820 p->u.s_binary.left = left;
821 p->u.s_binary.right = right;
822 }
823 return p;
824 }
825
826 /* Add a new name component. */
827
828 static struct demangle_component *
d_make_name(di,s,len)829 d_make_name (di, s, len)
830 struct d_info *di;
831 const char *s;
832 int len;
833 {
834 struct demangle_component *p;
835
836 p = d_make_empty (di);
837 if (! cplus_demangle_fill_name (p, s, len))
838 return NULL;
839 return p;
840 }
841
842 /* Add a new builtin type component. */
843
844 static struct demangle_component *
d_make_builtin_type(di,type)845 d_make_builtin_type (di, type)
846 struct d_info *di;
847 const struct demangle_builtin_type_info *type;
848 {
849 struct demangle_component *p;
850
851 if (type == NULL)
852 return NULL;
853 p = d_make_empty (di);
854 if (p != NULL)
855 {
856 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
857 p->u.s_builtin.type = type;
858 }
859 return p;
860 }
861
862 /* Add a new operator component. */
863
864 static struct demangle_component *
d_make_operator(di,op)865 d_make_operator (di, op)
866 struct d_info *di;
867 const struct demangle_operator_info *op;
868 {
869 struct demangle_component *p;
870
871 p = d_make_empty (di);
872 if (p != NULL)
873 {
874 p->type = DEMANGLE_COMPONENT_OPERATOR;
875 p->u.s_operator.op = op;
876 }
877 return p;
878 }
879
880 /* Add a new extended operator component. */
881
882 static struct demangle_component *
d_make_extended_operator(di,args,name)883 d_make_extended_operator (di, args, name)
884 struct d_info *di;
885 int args;
886 struct demangle_component *name;
887 {
888 struct demangle_component *p;
889
890 p = d_make_empty (di);
891 if (! cplus_demangle_fill_extended_operator (p, args, name))
892 return NULL;
893 return p;
894 }
895
896 /* Add a new constructor component. */
897
898 static struct demangle_component *
d_make_ctor(di,kind,name)899 d_make_ctor (di, kind, name)
900 struct d_info *di;
901 enum gnu_v3_ctor_kinds kind;
902 struct demangle_component *name;
903 {
904 struct demangle_component *p;
905
906 p = d_make_empty (di);
907 if (! cplus_demangle_fill_ctor (p, kind, name))
908 return NULL;
909 return p;
910 }
911
912 /* Add a new destructor component. */
913
914 static struct demangle_component *
d_make_dtor(di,kind,name)915 d_make_dtor (di, kind, name)
916 struct d_info *di;
917 enum gnu_v3_dtor_kinds kind;
918 struct demangle_component *name;
919 {
920 struct demangle_component *p;
921
922 p = d_make_empty (di);
923 if (! cplus_demangle_fill_dtor (p, kind, name))
924 return NULL;
925 return p;
926 }
927
928 /* Add a new template parameter. */
929
930 static struct demangle_component *
d_make_template_param(di,i)931 d_make_template_param (di, i)
932 struct d_info *di;
933 long i;
934 {
935 struct demangle_component *p;
936
937 p = d_make_empty (di);
938 if (p != NULL)
939 {
940 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
941 p->u.s_number.number = i;
942 }
943 return p;
944 }
945
946 /* Add a new standard substitution component. */
947
948 static struct demangle_component *
d_make_sub(di,name,len)949 d_make_sub (di, name, len)
950 struct d_info *di;
951 const char *name;
952 int len;
953 {
954 struct demangle_component *p;
955
956 p = d_make_empty (di);
957 if (p != NULL)
958 {
959 p->type = DEMANGLE_COMPONENT_SUB_STD;
960 p->u.s_string.string = name;
961 p->u.s_string.len = len;
962 }
963 return p;
964 }
965
966 /* <mangled-name> ::= _Z <encoding>
967
968 TOP_LEVEL is non-zero when called at the top level. */
969
970 CP_STATIC_IF_GLIBCPP_V3
971 struct demangle_component *
cplus_demangle_mangled_name(di,top_level)972 cplus_demangle_mangled_name (di, top_level)
973 struct d_info *di;
974 int top_level;
975 {
976 if (d_next_char (di) != '_')
977 return NULL;
978 if (d_next_char (di) != 'Z')
979 return NULL;
980 return d_encoding (di, top_level);
981 }
982
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
990 return types. */
991
992 static int
has_return_type(dc)993 has_return_type (dc)
994 struct demangle_component *dc;
995 {
996 if (dc == NULL)
997 return 0;
998 switch (dc->type)
999 {
1000 default:
1001 return 0;
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));
1008 }
1009 }
1010
1011 /* Return whether a name is a constructor, a destructor, or a
1012 conversion operator. */
1013
1014 static int
is_ctor_dtor_or_conversion(dc)1015 is_ctor_dtor_or_conversion (dc)
1016 struct demangle_component *dc;
1017 {
1018 if (dc == NULL)
1019 return 0;
1020 switch (dc->type)
1021 {
1022 default:
1023 return 0;
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:
1030 return 1;
1031 }
1032 }
1033
1034 /* <encoding> ::= <(function) name> <bare-function-type>
1035 ::= <(data) name>
1036 ::= <special-name>
1037
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. */
1042
1043 static struct demangle_component *
d_encoding(di,top_level)1044 d_encoding (di, top_level)
1045 struct d_info *di;
1046 int top_level;
1047 {
1048 char peek = d_peek_char (di);
1049
1050 if (peek == 'G' || peek == 'T')
1051 return d_special_name (di);
1052 else
1053 {
1054 struct demangle_component *dc;
1055
1056 dc = d_name (di);
1057
1058 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1059 {
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)
1066 dc = d_left (dc);
1067
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)
1073 {
1074 struct demangle_component *dcr;
1075
1076 dcr = d_right (dc);
1077 while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1078 || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1079 || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1080 dcr = d_left (dcr);
1081 dc->u.s_binary.right = dcr;
1082 }
1083
1084 return dc;
1085 }
1086
1087 peek = d_peek_char (di);
1088 if (peek == '\0' || peek == 'E')
1089 return dc;
1090 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1091 d_bare_function_type (di, has_return_type (dc)));
1092 }
1093 }
1094
1095 /* <name> ::= <nested-name>
1096 ::= <unscoped-name>
1097 ::= <unscoped-template-name> <template-args>
1098 ::= <local-name>
1099
1100 <unscoped-name> ::= <unqualified-name>
1101 ::= St <unqualified-name>
1102
1103 <unscoped-template-name> ::= <unscoped-name>
1104 ::= <substitution>
1105 */
1106
1107 static struct demangle_component *
d_name(di)1108 d_name (di)
1109 struct d_info *di;
1110 {
1111 char peek = d_peek_char (di);
1112 struct demangle_component *dc;
1113
1114 switch (peek)
1115 {
1116 case 'N':
1117 return d_nested_name (di);
1118
1119 case 'Z':
1120 return d_local_name (di);
1121
1122 case 'S':
1123 {
1124 int subst;
1125
1126 if (d_peek_next_char (di) != 't')
1127 {
1128 dc = d_substitution (di, 0);
1129 subst = 1;
1130 }
1131 else
1132 {
1133 d_advance (di, 2);
1134 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1135 d_make_name (di, "std", 3),
1136 d_unqualified_name (di));
1137 di->expansion += 3;
1138 subst = 0;
1139 }
1140
1141 if (d_peek_char (di) != 'I')
1142 {
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. */
1146 }
1147 else
1148 {
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
1152 substitution. */
1153 if (! subst)
1154 {
1155 if (! d_add_substitution (di, dc))
1156 return NULL;
1157 }
1158 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1159 d_template_args (di));
1160 }
1161
1162 return dc;
1163 }
1164
1165 default:
1166 dc = d_unqualified_name (di);
1167 if (d_peek_char (di) == 'I')
1168 {
1169 /* This is <template-args>, which means that we just saw
1170 <unscoped-template-name>, which is a substitution
1171 candidate. */
1172 if (! d_add_substitution (di, dc))
1173 return NULL;
1174 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1175 d_template_args (di));
1176 }
1177 return dc;
1178 }
1179 }
1180
1181 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1182 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1183 */
1184
1185 static struct demangle_component *
d_nested_name(di)1186 d_nested_name (di)
1187 struct d_info *di;
1188 {
1189 struct demangle_component *ret;
1190 struct demangle_component **pret;
1191
1192 if (d_next_char (di) != 'N')
1193 return NULL;
1194
1195 pret = d_cv_qualifiers (di, &ret, 1);
1196 if (pret == NULL)
1197 return NULL;
1198
1199 *pret = d_prefix (di);
1200 if (*pret == NULL)
1201 return NULL;
1202
1203 if (d_next_char (di) != 'E')
1204 return NULL;
1205
1206 return ret;
1207 }
1208
1209 /* <prefix> ::= <prefix> <unqualified-name>
1210 ::= <template-prefix> <template-args>
1211 ::= <template-param>
1212 ::=
1213 ::= <substitution>
1214
1215 <template-prefix> ::= <prefix> <(template) unqualified-name>
1216 ::= <template-param>
1217 ::= <substitution>
1218 */
1219
1220 static struct demangle_component *
d_prefix(di)1221 d_prefix (di)
1222 struct d_info *di;
1223 {
1224 struct demangle_component *ret = NULL;
1225
1226 while (1)
1227 {
1228 char peek;
1229 enum demangle_component_type comb_type;
1230 struct demangle_component *dc;
1231
1232 peek = d_peek_char (di);
1233 if (peek == '\0')
1234 return NULL;
1235
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. */
1239
1240 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1241 if (IS_DIGIT (peek)
1242 || IS_LOWER (peek)
1243 || peek == 'C'
1244 || peek == 'D')
1245 dc = d_unqualified_name (di);
1246 else if (peek == 'S')
1247 dc = d_substitution (di, 1);
1248 else if (peek == 'I')
1249 {
1250 if (ret == NULL)
1251 return NULL;
1252 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1253 dc = d_template_args (di);
1254 }
1255 else if (peek == 'T')
1256 dc = d_template_param (di);
1257 else if (peek == 'E')
1258 return ret;
1259 else
1260 return NULL;
1261
1262 if (ret == NULL)
1263 ret = dc;
1264 else
1265 ret = d_make_comp (di, comb_type, ret, dc);
1266
1267 if (peek != 'S' && d_peek_char (di) != 'E')
1268 {
1269 if (! d_add_substitution (di, ret))
1270 return NULL;
1271 }
1272 }
1273 }
1274
1275 /* <unqualified-name> ::= <operator-name>
1276 ::= <ctor-dtor-name>
1277 ::= <source-name>
1278 */
1279
1280 static struct demangle_component *
d_unqualified_name(di)1281 d_unqualified_name (di)
1282 struct d_info *di;
1283 {
1284 char peek;
1285
1286 peek = d_peek_char (di);
1287 if (IS_DIGIT (peek))
1288 return d_source_name (di);
1289 else if (IS_LOWER (peek))
1290 {
1291 struct demangle_component *ret;
1292
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;
1296 return ret;
1297 }
1298 else if (peek == 'C' || peek == 'D')
1299 return d_ctor_dtor_name (di);
1300 else
1301 return NULL;
1302 }
1303
1304 /* <source-name> ::= <(positive length) number> <identifier> */
1305
1306 static struct demangle_component *
d_source_name(di)1307 d_source_name (di)
1308 struct d_info *di;
1309 {
1310 long len;
1311 struct demangle_component *ret;
1312
1313 len = d_number (di);
1314 if (len <= 0)
1315 return NULL;
1316 ret = d_identifier (di, len);
1317 di->last_name = ret;
1318 return ret;
1319 }
1320
1321 /* number ::= [n] <(non-negative decimal integer)> */
1322
1323 static long
d_number(di)1324 d_number (di)
1325 struct d_info *di;
1326 {
1327 int negative;
1328 char peek;
1329 long ret;
1330
1331 negative = 0;
1332 peek = d_peek_char (di);
1333 if (peek == 'n')
1334 {
1335 negative = 1;
1336 d_advance (di, 1);
1337 peek = d_peek_char (di);
1338 }
1339
1340 ret = 0;
1341 while (1)
1342 {
1343 if (! IS_DIGIT (peek))
1344 {
1345 if (negative)
1346 ret = - ret;
1347 return ret;
1348 }
1349 ret = ret * 10 + peek - '0';
1350 d_advance (di, 1);
1351 peek = d_peek_char (di);
1352 }
1353 }
1354
1355 /* identifier ::= <(unqualified source code identifier)> */
1356
1357 static struct demangle_component *
d_identifier(di,len)1358 d_identifier (di, len)
1359 struct d_info *di;
1360 int len;
1361 {
1362 const char *name;
1363
1364 name = d_str (di);
1365
1366 if (di->send - name < len)
1367 return NULL;
1368
1369 d_advance (di, len);
1370
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
1373 ignore the '$'. */
1374 if ((di->options & DMGL_JAVA) != 0
1375 && d_peek_char (di) == '$')
1376 d_advance (di, 1);
1377
1378 /* Look for something which looks like a gcc encoding of an
1379 anonymous namespace, and replace it with a more user friendly
1380 name. */
1381 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1382 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1383 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1384 {
1385 const char *s;
1386
1387 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1388 if ((*s == '.' || *s == '_' || *s == '$')
1389 && s[1] == 'N')
1390 {
1391 di->expansion -= len - sizeof "(anonymous namespace)";
1392 return d_make_name (di, "(anonymous namespace)",
1393 sizeof "(anonymous namespace)" - 1);
1394 }
1395 }
1396
1397 return d_make_name (di, name, len);
1398 }
1399
1400 /* operator_name ::= many different two character encodings.
1401 ::= cv <type>
1402 ::= v <digit> <source-name>
1403 */
1404
1405 #define NL(s) s, (sizeof s) - 1
1406
1407 CP_STATIC_IF_GLIBCPP_V3
1408 const struct demangle_operator_info cplus_demangle_operators[] =
1409 {
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 }
1460 };
1461
1462 static struct demangle_component *
d_operator_name(di)1463 d_operator_name (di)
1464 struct d_info *di;
1465 {
1466 char c1;
1467 char c2;
1468
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);
1476 else
1477 {
1478 /* LOW is the inclusive lower bound. */
1479 int low = 0;
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]))
1484 - 1);
1485
1486 while (1)
1487 {
1488 int i;
1489 const struct demangle_operator_info *p;
1490
1491 i = low + (high - low) / 2;
1492 p = cplus_demangle_operators + i;
1493
1494 if (c1 == p->code[0] && c2 == p->code[1])
1495 return d_make_operator (di, p);
1496
1497 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1498 high = i;
1499 else
1500 low = i + 1;
1501 if (low == high)
1502 return NULL;
1503 }
1504 }
1505 }
1506
1507 /* <special-name> ::= TV <type>
1508 ::= TT <type>
1509 ::= TI <type>
1510 ::= TS <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>
1516 ::= TF <type>
1517 ::= TJ <type>
1518 ::= GR <name>
1519 */
1520
1521 static struct demangle_component *
d_special_name(di)1522 d_special_name (di)
1523 struct d_info *di;
1524 {
1525 char c;
1526
1527 di->expansion += 20;
1528 c = d_next_char (di);
1529 if (c == 'T')
1530 {
1531 switch (d_next_char (di))
1532 {
1533 case 'V':
1534 di->expansion -= 5;
1535 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1536 cplus_demangle_type (di), NULL);
1537 case 'T':
1538 di->expansion -= 10;
1539 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1540 cplus_demangle_type (di), NULL);
1541 case 'I':
1542 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1543 cplus_demangle_type (di), NULL);
1544 case 'S':
1545 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1546 cplus_demangle_type (di), NULL);
1547
1548 case 'h':
1549 if (! d_call_offset (di, 'h'))
1550 return NULL;
1551 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1552 d_encoding (di, 0), NULL);
1553
1554 case 'v':
1555 if (! d_call_offset (di, 'v'))
1556 return NULL;
1557 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1558 d_encoding (di, 0), NULL);
1559
1560 case 'c':
1561 if (! d_call_offset (di, '\0'))
1562 return NULL;
1563 if (! d_call_offset (di, '\0'))
1564 return NULL;
1565 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1566 d_encoding (di, 0), NULL);
1567
1568 case 'C':
1569 {
1570 struct demangle_component *derived_type;
1571 long offset;
1572 struct demangle_component *base_type;
1573
1574 derived_type = cplus_demangle_type (di);
1575 offset = d_number (di);
1576 if (offset < 0)
1577 return NULL;
1578 if (d_next_char (di) != '_')
1579 return NULL;
1580 base_type = cplus_demangle_type (di);
1581 /* We don't display the offset. FIXME: We should display
1582 it in verbose mode. */
1583 di->expansion += 5;
1584 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1585 base_type, derived_type);
1586 }
1587
1588 case 'F':
1589 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1590 cplus_demangle_type (di), NULL);
1591 case 'J':
1592 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1593 cplus_demangle_type (di), NULL);
1594
1595 default:
1596 return NULL;
1597 }
1598 }
1599 else if (c == 'G')
1600 {
1601 switch (d_next_char (di))
1602 {
1603 case 'V':
1604 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1605
1606 case 'R':
1607 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1608 NULL);
1609
1610 default:
1611 return NULL;
1612 }
1613 }
1614 else
1615 return NULL;
1616 }
1617
1618 /* <call-offset> ::= h <nv-offset> _
1619 ::= v <v-offset> _
1620
1621 <nv-offset> ::= <(offset) number>
1622
1623 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1624
1625 The C parameter, if not '\0', is a character we just read which is
1626 the start of the <call-offset>.
1627
1628 We don't display the offset information anywhere. FIXME: We should
1629 display it in verbose mode. */
1630
1631 static int
d_call_offset(di,c)1632 d_call_offset (di, c)
1633 struct d_info *di;
1634 int c;
1635 {
1636 long offset;
1637 long virtual_offset;
1638
1639 if (c == '\0')
1640 c = d_next_char (di);
1641
1642 if (c == 'h')
1643 offset = d_number (di);
1644 else if (c == 'v')
1645 {
1646 offset = d_number (di);
1647 if (d_next_char (di) != '_')
1648 return 0;
1649 virtual_offset = d_number (di);
1650 }
1651 else
1652 return 0;
1653
1654 if (d_next_char (di) != '_')
1655 return 0;
1656
1657 return 1;
1658 }
1659
1660 /* <ctor-dtor-name> ::= C1
1661 ::= C2
1662 ::= C3
1663 ::= D0
1664 ::= D1
1665 ::= D2
1666 */
1667
1668 static struct demangle_component *
d_ctor_dtor_name(di)1669 d_ctor_dtor_name (di)
1670 struct d_info *di;
1671 {
1672 if (di->last_name != NULL)
1673 {
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;
1678 }
1679 switch (d_next_char (di))
1680 {
1681 case 'C':
1682 {
1683 enum gnu_v3_ctor_kinds kind;
1684
1685 switch (d_next_char (di))
1686 {
1687 case '1':
1688 kind = gnu_v3_complete_object_ctor;
1689 break;
1690 case '2':
1691 kind = gnu_v3_base_object_ctor;
1692 break;
1693 case '3':
1694 kind = gnu_v3_complete_object_allocating_ctor;
1695 break;
1696 default:
1697 return NULL;
1698 }
1699 return d_make_ctor (di, kind, di->last_name);
1700 }
1701
1702 case 'D':
1703 {
1704 enum gnu_v3_dtor_kinds kind;
1705
1706 switch (d_next_char (di))
1707 {
1708 case '0':
1709 kind = gnu_v3_deleting_dtor;
1710 break;
1711 case '1':
1712 kind = gnu_v3_complete_object_dtor;
1713 break;
1714 case '2':
1715 kind = gnu_v3_base_object_dtor;
1716 break;
1717 default:
1718 return NULL;
1719 }
1720 return d_make_dtor (di, kind, di->last_name);
1721 }
1722
1723 default:
1724 return NULL;
1725 }
1726 }
1727
1728 /* <type> ::= <builtin-type>
1729 ::= <function-type>
1730 ::= <class-enum-type>
1731 ::= <array-type>
1732 ::= <pointer-to-member-type>
1733 ::= <template-param>
1734 ::= <template-template-param> <template-args>
1735 ::= <substitution>
1736 ::= <CV-qualifiers> <type>
1737 ::= P <type>
1738 ::= R <type>
1739 ::= C <type>
1740 ::= G <type>
1741 ::= U <source-name> <type>
1742
1743 <builtin-type> ::= various one letter codes
1744 ::= u <source-name>
1745 */
1746
1747 CP_STATIC_IF_GLIBCPP_V3
1748 const struct demangle_builtin_type_info
1749 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1750 {
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 },
1777 };
1778
1779 CP_STATIC_IF_GLIBCPP_V3
1780 struct demangle_component *
cplus_demangle_type(di)1781 cplus_demangle_type (di)
1782 struct d_info *di;
1783 {
1784 char peek;
1785 struct demangle_component *ret;
1786 int can_subst;
1787
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.
1794
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
1801 names. */
1802
1803 peek = d_peek_char (di);
1804 if (peek == 'r' || peek == 'V' || peek == 'K')
1805 {
1806 struct demangle_component **pret;
1807
1808 pret = d_cv_qualifiers (di, &ret, 0);
1809 if (pret == NULL)
1810 return NULL;
1811 *pret = cplus_demangle_type (di);
1812 if (! d_add_substitution (di, ret))
1813 return NULL;
1814 return ret;
1815 }
1816
1817 can_subst = 1;
1818
1819 switch (peek)
1820 {
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;
1828 can_subst = 0;
1829 d_advance (di, 1);
1830 break;
1831
1832 case 'u':
1833 d_advance (di, 1);
1834 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
1835 d_source_name (di), NULL);
1836 break;
1837
1838 case 'F':
1839 ret = d_function_type (di);
1840 break;
1841
1842 case '0': case '1': case '2': case '3': case '4':
1843 case '5': case '6': case '7': case '8': case '9':
1844 case 'N':
1845 case 'Z':
1846 ret = d_class_enum_type (di);
1847 break;
1848
1849 case 'A':
1850 ret = d_array_type (di);
1851 break;
1852
1853 case 'M':
1854 ret = d_pointer_to_member_type (di);
1855 break;
1856
1857 case 'T':
1858 ret = d_template_param (di);
1859 if (d_peek_char (di) == 'I')
1860 {
1861 /* This is <template-template-param> <template-args>. The
1862 <template-template-param> part is a substitution
1863 candidate. */
1864 if (! d_add_substitution (di, ret))
1865 return NULL;
1866 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
1867 d_template_args (di));
1868 }
1869 break;
1870
1871 case 'S':
1872 /* If this is a special substitution, then it is the start of
1873 <class-enum-type>. */
1874 {
1875 char peek_next;
1876
1877 peek_next = d_peek_next_char (di);
1878 if (IS_DIGIT (peek_next)
1879 || peek_next == '_'
1880 || IS_UPPER (peek_next))
1881 {
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));
1888 else
1889 can_subst = 0;
1890 }
1891 else
1892 {
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)
1899 can_subst = 0;
1900 }
1901 }
1902 break;
1903
1904 case 'P':
1905 d_advance (di, 1);
1906 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
1907 cplus_demangle_type (di), NULL);
1908 break;
1909
1910 case 'R':
1911 d_advance (di, 1);
1912 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
1913 cplus_demangle_type (di), NULL);
1914 break;
1915
1916 case 'C':
1917 d_advance (di, 1);
1918 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
1919 cplus_demangle_type (di), NULL);
1920 break;
1921
1922 case 'G':
1923 d_advance (di, 1);
1924 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
1925 cplus_demangle_type (di), NULL);
1926 break;
1927
1928 case 'U':
1929 d_advance (di, 1);
1930 ret = d_source_name (di);
1931 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
1932 cplus_demangle_type (di), ret);
1933 break;
1934
1935 default:
1936 return NULL;
1937 }
1938
1939 if (can_subst)
1940 {
1941 if (! d_add_substitution (di, ret))
1942 return NULL;
1943 }
1944
1945 return ret;
1946 }
1947
1948 /* <CV-qualifiers> ::= [r] [V] [K] */
1949
1950 static struct demangle_component **
d_cv_qualifiers(di,pret,member_fn)1951 d_cv_qualifiers (di, pret, member_fn)
1952 struct d_info *di;
1953 struct demangle_component **pret;
1954 int member_fn;
1955 {
1956 char peek;
1957
1958 peek = d_peek_char (di);
1959 while (peek == 'r' || peek == 'V' || peek == 'K')
1960 {
1961 enum demangle_component_type t;
1962
1963 d_advance (di, 1);
1964 if (peek == 'r')
1965 {
1966 t = (member_fn
1967 ? DEMANGLE_COMPONENT_RESTRICT_THIS
1968 : DEMANGLE_COMPONENT_RESTRICT);
1969 di->expansion += sizeof "restrict";
1970 }
1971 else if (peek == 'V')
1972 {
1973 t = (member_fn
1974 ? DEMANGLE_COMPONENT_VOLATILE_THIS
1975 : DEMANGLE_COMPONENT_VOLATILE);
1976 di->expansion += sizeof "volatile";
1977 }
1978 else
1979 {
1980 t = (member_fn
1981 ? DEMANGLE_COMPONENT_CONST_THIS
1982 : DEMANGLE_COMPONENT_CONST);
1983 di->expansion += sizeof "const";
1984 }
1985
1986 *pret = d_make_comp (di, t, NULL, NULL);
1987 if (*pret == NULL)
1988 return NULL;
1989 pret = &d_left (*pret);
1990
1991 peek = d_peek_char (di);
1992 }
1993
1994 return pret;
1995 }
1996
1997 /* <function-type> ::= F [Y] <bare-function-type> E */
1998
1999 static struct demangle_component *
d_function_type(di)2000 d_function_type (di)
2001 struct d_info *di;
2002 {
2003 struct demangle_component *ret;
2004
2005 if (d_next_char (di) != 'F')
2006 return NULL;
2007 if (d_peek_char (di) == 'Y')
2008 {
2009 /* Function has C linkage. We don't print this information.
2010 FIXME: We should print it in verbose mode. */
2011 d_advance (di, 1);
2012 }
2013 ret = d_bare_function_type (di, 1);
2014 if (d_next_char (di) != 'E')
2015 return NULL;
2016 return ret;
2017 }
2018
2019 /* <bare-function-type> ::= <type>+ */
2020
2021 static struct demangle_component *
d_bare_function_type(di,has_return_type)2022 d_bare_function_type (di, has_return_type)
2023 struct d_info *di;
2024 int has_return_type;
2025 {
2026 struct demangle_component *return_type;
2027 struct demangle_component *tl;
2028 struct demangle_component **ptl;
2029
2030 return_type = NULL;
2031 tl = NULL;
2032 ptl = &tl;
2033 while (1)
2034 {
2035 char peek;
2036 struct demangle_component *type;
2037
2038 peek = d_peek_char (di);
2039 if (peek == '\0' || peek == 'E')
2040 break;
2041 type = cplus_demangle_type (di);
2042 if (type == NULL)
2043 return NULL;
2044 if (has_return_type)
2045 {
2046 return_type = type;
2047 has_return_type = 0;
2048 }
2049 else
2050 {
2051 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2052 if (*ptl == NULL)
2053 return NULL;
2054 ptl = &d_right (*ptl);
2055 }
2056 }
2057
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. */
2061 if (tl == NULL)
2062 return NULL;
2063
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)
2068 {
2069 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2070 tl = NULL;
2071 }
2072
2073 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
2074 }
2075
2076 /* <class-enum-type> ::= <name> */
2077
2078 static struct demangle_component *
d_class_enum_type(di)2079 d_class_enum_type (di)
2080 struct d_info *di;
2081 {
2082 return d_name (di);
2083 }
2084
2085 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2086 ::= A [<(dimension) expression>] _ <(element) type>
2087 */
2088
2089 static struct demangle_component *
d_array_type(di)2090 d_array_type (di)
2091 struct d_info *di;
2092 {
2093 char peek;
2094 struct demangle_component *dim;
2095
2096 if (d_next_char (di) != 'A')
2097 return NULL;
2098
2099 peek = d_peek_char (di);
2100 if (peek == '_')
2101 dim = NULL;
2102 else if (IS_DIGIT (peek))
2103 {
2104 const char *s;
2105
2106 s = d_str (di);
2107 do
2108 {
2109 d_advance (di, 1);
2110 peek = d_peek_char (di);
2111 }
2112 while (IS_DIGIT (peek));
2113 dim = d_make_name (di, s, d_str (di) - s);
2114 if (dim == NULL)
2115 return NULL;
2116 }
2117 else
2118 {
2119 dim = d_expression (di);
2120 if (dim == NULL)
2121 return NULL;
2122 }
2123
2124 if (d_next_char (di) != '_')
2125 return NULL;
2126
2127 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2128 cplus_demangle_type (di));
2129 }
2130
2131 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2132
2133 static struct demangle_component *
d_pointer_to_member_type(di)2134 d_pointer_to_member_type (di)
2135 struct d_info *di;
2136 {
2137 struct demangle_component *cl;
2138 struct demangle_component *mem;
2139 struct demangle_component **pmem;
2140
2141 if (d_next_char (di) != 'M')
2142 return NULL;
2143
2144 cl = cplus_demangle_type (di);
2145
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(). */
2158
2159 pmem = d_cv_qualifiers (di, &mem, 1);
2160 if (pmem == NULL)
2161 return NULL;
2162 *pmem = cplus_demangle_type (di);
2163
2164 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2165 }
2166
2167 /* <template-param> ::= T_
2168 ::= T <(parameter-2 non-negative) number> _
2169 */
2170
2171 static struct demangle_component *
d_template_param(di)2172 d_template_param (di)
2173 struct d_info *di;
2174 {
2175 long param;
2176
2177 if (d_next_char (di) != 'T')
2178 return NULL;
2179
2180 if (d_peek_char (di) == '_')
2181 param = 0;
2182 else
2183 {
2184 param = d_number (di);
2185 if (param < 0)
2186 return NULL;
2187 param += 1;
2188 }
2189
2190 if (d_next_char (di) != '_')
2191 return NULL;
2192
2193 ++di->did_subs;
2194
2195 return d_make_template_param (di, param);
2196 }
2197
2198 /* <template-args> ::= I <template-arg>+ E */
2199
2200 static struct demangle_component *
d_template_args(di)2201 d_template_args (di)
2202 struct d_info *di;
2203 {
2204 struct demangle_component *hold_last_name;
2205 struct demangle_component *al;
2206 struct demangle_component **pal;
2207
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;
2212
2213 if (d_next_char (di) != 'I')
2214 return NULL;
2215
2216 al = NULL;
2217 pal = &al;
2218 while (1)
2219 {
2220 struct demangle_component *a;
2221
2222 a = d_template_arg (di);
2223 if (a == NULL)
2224 return NULL;
2225
2226 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2227 if (*pal == NULL)
2228 return NULL;
2229 pal = &d_right (*pal);
2230
2231 if (d_peek_char (di) == 'E')
2232 {
2233 d_advance (di, 1);
2234 break;
2235 }
2236 }
2237
2238 di->last_name = hold_last_name;
2239
2240 return al;
2241 }
2242
2243 /* <template-arg> ::= <type>
2244 ::= X <expression> E
2245 ::= <expr-primary>
2246 */
2247
2248 static struct demangle_component *
d_template_arg(di)2249 d_template_arg (di)
2250 struct d_info *di;
2251 {
2252 struct demangle_component *ret;
2253
2254 switch (d_peek_char (di))
2255 {
2256 case 'X':
2257 d_advance (di, 1);
2258 ret = d_expression (di);
2259 if (d_next_char (di) != 'E')
2260 return NULL;
2261 return ret;
2262
2263 case 'L':
2264 return d_expr_primary (di);
2265
2266 default:
2267 return cplus_demangle_type (di);
2268 }
2269 }
2270
2271 /* <expression> ::= <(unary) operator-name> <expression>
2272 ::= <(binary) operator-name> <expression> <expression>
2273 ::= <(trinary) operator-name> <expression> <expression> <expression>
2274 ::= st <type>
2275 ::= <template-param>
2276 ::= sr <type> <unqualified-name>
2277 ::= sr <type> <unqualified-name> <template-args>
2278 ::= <expr-primary>
2279 */
2280
2281 static struct demangle_component *
d_expression(di)2282 d_expression (di)
2283 struct d_info *di;
2284 {
2285 char peek;
2286
2287 peek = d_peek_char (di);
2288 if (peek == 'L')
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')
2293 {
2294 struct demangle_component *type;
2295 struct demangle_component *name;
2296
2297 d_advance (di, 2);
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);
2302 else
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)));
2306 }
2307 else
2308 {
2309 struct demangle_component *op;
2310 int args;
2311
2312 op = d_operator_name (di);
2313 if (op == NULL)
2314 return NULL;
2315
2316 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2317 di->expansion += op->u.s_operator.op->len - 2;
2318
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));
2323
2324 switch (op->type)
2325 {
2326 default:
2327 return NULL;
2328 case DEMANGLE_COMPONENT_OPERATOR:
2329 args = op->u.s_operator.op->args;
2330 break;
2331 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2332 args = op->u.s_extended_operator.args;
2333 break;
2334 case DEMANGLE_COMPONENT_CAST:
2335 args = 1;
2336 break;
2337 }
2338
2339 switch (args)
2340 {
2341 case 1:
2342 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2343 d_expression (di));
2344 case 2:
2345 {
2346 struct demangle_component *left;
2347
2348 left = d_expression (di);
2349 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2350 d_make_comp (di,
2351 DEMANGLE_COMPONENT_BINARY_ARGS,
2352 left,
2353 d_expression (di)));
2354 }
2355 case 3:
2356 {
2357 struct demangle_component *first;
2358 struct demangle_component *second;
2359
2360 first = d_expression (di);
2361 second = d_expression (di);
2362 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2363 d_make_comp (di,
2364 DEMANGLE_COMPONENT_TRINARY_ARG1,
2365 first,
2366 d_make_comp (di,
2367 DEMANGLE_COMPONENT_TRINARY_ARG2,
2368 second,
2369 d_expression (di))));
2370 }
2371 default:
2372 return NULL;
2373 }
2374 }
2375 }
2376
2377 /* <expr-primary> ::= L <type> <(value) number> E
2378 ::= L <type> <(value) float> E
2379 ::= L <mangled-name> E
2380 */
2381
2382 static struct demangle_component *
d_expr_primary(di)2383 d_expr_primary (di)
2384 struct d_info *di;
2385 {
2386 struct demangle_component *ret;
2387
2388 if (d_next_char (di) != 'L')
2389 return NULL;
2390 if (d_peek_char (di) == '_')
2391 ret = cplus_demangle_mangled_name (di, 0);
2392 else
2393 {
2394 struct demangle_component *type;
2395 enum demangle_component_type t;
2396 const char *s;
2397
2398 type = cplus_demangle_type (di);
2399
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;
2405
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. */
2416
2417 t = DEMANGLE_COMPONENT_LITERAL;
2418 if (d_peek_char (di) == 'n')
2419 {
2420 t = DEMANGLE_COMPONENT_LITERAL_NEG;
2421 d_advance (di, 1);
2422 }
2423 s = d_str (di);
2424 while (d_peek_char (di) != 'E')
2425 d_advance (di, 1);
2426 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2427 }
2428 if (d_next_char (di) != 'E')
2429 return NULL;
2430 return ret;
2431 }
2432
2433 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2434 ::= Z <(function) encoding> E s [<discriminator>]
2435 */
2436
2437 static struct demangle_component *
d_local_name(di)2438 d_local_name (di)
2439 struct d_info *di;
2440 {
2441 struct demangle_component *function;
2442
2443 if (d_next_char (di) != 'Z')
2444 return NULL;
2445
2446 function = d_encoding (di, 0);
2447
2448 if (d_next_char (di) != 'E')
2449 return NULL;
2450
2451 if (d_peek_char (di) == 's')
2452 {
2453 d_advance (di, 1);
2454 if (! d_discriminator (di))
2455 return NULL;
2456 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2457 d_make_name (di, "string literal",
2458 sizeof "string literal" - 1));
2459 }
2460 else
2461 {
2462 struct demangle_component *name;
2463
2464 name = d_name (di);
2465 if (! d_discriminator (di))
2466 return NULL;
2467 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2468 }
2469 }
2470
2471 /* <discriminator> ::= _ <(non-negative) number>
2472
2473 We demangle the discriminator, but we don't print it out. FIXME:
2474 We should print it out in verbose mode. */
2475
2476 static int
d_discriminator(di)2477 d_discriminator (di)
2478 struct d_info *di;
2479 {
2480 long discrim;
2481
2482 if (d_peek_char (di) != '_')
2483 return 1;
2484 d_advance (di, 1);
2485 discrim = d_number (di);
2486 if (discrim < 0)
2487 return 0;
2488 return 1;
2489 }
2490
2491 /* Add a new substitution. */
2492
2493 static int
d_add_substitution(di,dc)2494 d_add_substitution (di, dc)
2495 struct d_info *di;
2496 struct demangle_component *dc;
2497 {
2498 if (dc == NULL)
2499 return 0;
2500 if (di->next_sub >= di->num_subs)
2501 return 0;
2502 di->subs[di->next_sub] = dc;
2503 ++di->next_sub;
2504 return 1;
2505 }
2506
2507 /* <substitution> ::= S <seq-id> _
2508 ::= S_
2509 ::= St
2510 ::= Sa
2511 ::= Sb
2512 ::= Ss
2513 ::= Si
2514 ::= So
2515 ::= Sd
2516
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.
2524 */
2525
2526 static const struct d_standard_sub_info standard_subs[] =
2527 {
2528 { 't', NL ("std"),
2529 NL ("std"),
2530 NULL, 0 },
2531 { 'a', NL ("std::allocator"),
2532 NL ("std::allocator"),
2533 NL ("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") }
2549 };
2550
2551 static struct demangle_component *
d_substitution(di,prefix)2552 d_substitution (di, prefix)
2553 struct d_info *di;
2554 int prefix;
2555 {
2556 char c;
2557
2558 if (d_next_char (di) != 'S')
2559 return NULL;
2560
2561 c = d_next_char (di);
2562 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
2563 {
2564 int id;
2565
2566 id = 0;
2567 if (c != '_')
2568 {
2569 do
2570 {
2571 if (IS_DIGIT (c))
2572 id = id * 36 + c - '0';
2573 else if (IS_UPPER (c))
2574 id = id * 36 + c - 'A' + 10;
2575 else
2576 return NULL;
2577 c = d_next_char (di);
2578 }
2579 while (c != '_');
2580
2581 ++id;
2582 }
2583
2584 if (id >= di->next_sub)
2585 return NULL;
2586
2587 ++di->did_subs;
2588
2589 return di->subs[id];
2590 }
2591 else
2592 {
2593 int verbose;
2594 const struct d_standard_sub_info *p;
2595 const struct d_standard_sub_info *pend;
2596
2597 verbose = (di->options & DMGL_VERBOSE) != 0;
2598 if (! verbose && prefix)
2599 {
2600 char peek;
2601
2602 peek = d_peek_char (di);
2603 if (peek == 'C' || peek == 'D')
2604 verbose = 1;
2605 }
2606
2607 pend = (&standard_subs[0]
2608 + sizeof standard_subs / sizeof standard_subs[0]);
2609 for (p = &standard_subs[0]; p < pend; ++p)
2610 {
2611 if (c == p->code)
2612 {
2613 const char *s;
2614 int len;
2615
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);
2619 if (verbose)
2620 {
2621 s = p->full_expansion;
2622 len = p->full_len;
2623 }
2624 else
2625 {
2626 s = p->simple_expansion;
2627 len = p->simple_len;
2628 }
2629 di->expansion += len;
2630 return d_make_sub (di, s, len);
2631 }
2632 }
2633
2634 return NULL;
2635 }
2636 }
2637
2638 /* Resize the print buffer. */
2639
2640 static void
d_print_resize(dpi,add)2641 d_print_resize (dpi, add)
2642 struct d_print_info *dpi;
2643 size_t add;
2644 {
2645 size_t need;
2646
2647 if (dpi->buf == NULL)
2648 return;
2649 need = dpi->len + add;
2650 while (need > dpi->alc)
2651 {
2652 size_t newalc;
2653 char *newbuf;
2654
2655 newalc = dpi->alc * 2;
2656 newbuf = realloc (dpi->buf, newalc);
2657 if (newbuf == NULL)
2658 {
2659 free (dpi->buf);
2660 dpi->buf = NULL;
2661 dpi->allocation_failure = 1;
2662 return;
2663 }
2664 dpi->buf = newbuf;
2665 dpi->alc = newalc;
2666 }
2667 }
2668
2669 /* Append a character to the print buffer. */
2670
2671 static void
d_print_append_char(dpi,c)2672 d_print_append_char (dpi, c)
2673 struct d_print_info *dpi;
2674 int c;
2675 {
2676 if (dpi->buf != NULL)
2677 {
2678 if (dpi->len >= dpi->alc)
2679 {
2680 d_print_resize (dpi, 1);
2681 if (dpi->buf == NULL)
2682 return;
2683 }
2684
2685 dpi->buf[dpi->len] = c;
2686 ++dpi->len;
2687 }
2688 }
2689
2690 /* Append a buffer to the print buffer. */
2691
2692 static void
d_print_append_buffer(dpi,s,l)2693 d_print_append_buffer (dpi, s, l)
2694 struct d_print_info *dpi;
2695 const char *s;
2696 size_t l;
2697 {
2698 if (dpi->buf != NULL)
2699 {
2700 if (dpi->len + l > dpi->alc)
2701 {
2702 d_print_resize (dpi, l);
2703 if (dpi->buf == NULL)
2704 return;
2705 }
2706
2707 memcpy (dpi->buf + dpi->len, s, l);
2708 dpi->len += l;
2709 }
2710 }
2711
2712 /* Indicate that an error occurred during printing. */
2713
2714 static void
d_print_error(dpi)2715 d_print_error (dpi)
2716 struct d_print_info *dpi;
2717 {
2718 free (dpi->buf);
2719 dpi->buf = NULL;
2720 }
2721
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
2728 failure. */
2729
2730 CP_STATIC_IF_GLIBCPP_V3
2731 char *
cplus_demangle_print(options,dc,estimate,palc)2732 cplus_demangle_print (options, dc, estimate, palc)
2733 int options;
2734 const struct demangle_component *dc;
2735 int estimate;
2736 size_t *palc;
2737 {
2738 struct d_print_info dpi;
2739
2740 dpi.options = options;
2741
2742 dpi.alc = estimate + 1;
2743 dpi.buf = malloc (dpi.alc);
2744 if (dpi.buf == NULL)
2745 {
2746 *palc = 1;
2747 return NULL;
2748 }
2749
2750 dpi.len = 0;
2751 dpi.templates = NULL;
2752 dpi.modifiers = NULL;
2753
2754 dpi.allocation_failure = 0;
2755
2756 d_print_comp (&dpi, dc);
2757
2758 d_append_char (&dpi, '\0');
2759
2760 if (dpi.buf != NULL)
2761 *palc = dpi.alc;
2762 else
2763 *palc = dpi.allocation_failure;
2764
2765 return dpi.buf;
2766 }
2767
2768 /* Subroutine to handle components. */
2769
2770 static void
d_print_comp(dpi,dc)2771 d_print_comp (dpi, dc)
2772 struct d_print_info *dpi;
2773 const struct demangle_component *dc;
2774 {
2775 if (dc == NULL)
2776 {
2777 d_print_error (dpi);
2778 return;
2779 }
2780 if (d_print_saw_error (dpi))
2781 return;
2782
2783 switch (dc->type)
2784 {
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);
2788 else
2789 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
2790 return;
2791
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, "::");
2797 else
2798 d_append_char (dpi, '.');
2799 d_print_comp (dpi, d_right (dc));
2800 return;
2801
2802 case DEMANGLE_COMPONENT_TYPED_NAME:
2803 {
2804 struct d_print_mod *hold_modifiers;
2805 struct demangle_component *typed_name;
2806 struct d_print_mod adpm[4];
2807 unsigned int i;
2808 struct d_print_template dpt;
2809
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;
2814 i = 0;
2815 typed_name = d_left (dc);
2816 while (typed_name != NULL)
2817 {
2818 if (i >= sizeof adpm / sizeof adpm[0])
2819 {
2820 d_print_error (dpi);
2821 return;
2822 }
2823
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;
2829 ++i;
2830
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)
2834 break;
2835
2836 typed_name = d_left (typed_name);
2837 }
2838
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)
2842 {
2843 dpt.next = dpi->templates;
2844 dpi->templates = &dpt;
2845 dpt.template = typed_name;
2846 }
2847
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)
2853 {
2854 struct demangle_component *local_name;
2855
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)
2860 {
2861 if (i >= sizeof adpm / sizeof adpm[0])
2862 {
2863 d_print_error (dpi);
2864 return;
2865 }
2866
2867 adpm[i] = adpm[i - 1];
2868 adpm[i].next = &adpm[i - 1];
2869 dpi->modifiers = &adpm[i];
2870
2871 adpm[i - 1].mod = local_name;
2872 adpm[i - 1].printed = 0;
2873 adpm[i - 1].templates = dpi->templates;
2874 ++i;
2875
2876 local_name = d_left (local_name);
2877 }
2878 }
2879
2880 d_print_comp (dpi, d_right (dc));
2881
2882 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2883 dpi->templates = dpt.next;
2884
2885 /* If the modifiers didn't get printed by the type, print them
2886 now. */
2887 while (i > 0)
2888 {
2889 --i;
2890 if (! adpm[i].printed)
2891 {
2892 d_append_char (dpi, ' ');
2893 d_print_mod (dpi, adpm[i].mod);
2894 }
2895 }
2896
2897 dpi->modifiers = hold_modifiers;
2898
2899 return;
2900 }
2901
2902 case DEMANGLE_COMPONENT_TEMPLATE:
2903 {
2904 struct d_print_mod *hold_dpm;
2905
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. */
2909
2910 hold_dpm = dpi->modifiers;
2911 dpi->modifiers = NULL;
2912
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, '>');
2923
2924 dpi->modifiers = hold_dpm;
2925
2926 return;
2927 }
2928
2929 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
2930 {
2931 long i;
2932 struct demangle_component *a;
2933 struct d_print_template *hold_dpt;
2934
2935 if (dpi->templates == NULL)
2936 {
2937 d_print_error (dpi);
2938 return;
2939 }
2940 i = dc->u.s_number.number;
2941 for (a = d_right (dpi->templates->template);
2942 a != NULL;
2943 a = d_right (a))
2944 {
2945 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
2946 {
2947 d_print_error (dpi);
2948 return;
2949 }
2950 if (i <= 0)
2951 break;
2952 --i;
2953 }
2954 if (i != 0 || a == NULL)
2955 {
2956 d_print_error (dpi);
2957 return;
2958 }
2959
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
2963 template. */
2964
2965 hold_dpt = dpi->templates;
2966 dpi->templates = hold_dpt->next;
2967
2968 d_print_comp (dpi, d_left (a));
2969
2970 dpi->templates = hold_dpt;
2971
2972 return;
2973 }
2974
2975 case DEMANGLE_COMPONENT_CTOR:
2976 d_print_comp (dpi, dc->u.s_ctor.name);
2977 return;
2978
2979 case DEMANGLE_COMPONENT_DTOR:
2980 d_append_char (dpi, '~');
2981 d_print_comp (dpi, dc->u.s_dtor.name);
2982 return;
2983
2984 case DEMANGLE_COMPONENT_VTABLE:
2985 d_append_string_constant (dpi, "vtable for ");
2986 d_print_comp (dpi, d_left (dc));
2987 return;
2988
2989 case DEMANGLE_COMPONENT_VTT:
2990 d_append_string_constant (dpi, "VTT for ");
2991 d_print_comp (dpi, d_left (dc));
2992 return;
2993
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));
2999 return;
3000
3001 case DEMANGLE_COMPONENT_TYPEINFO:
3002 d_append_string_constant (dpi, "typeinfo for ");
3003 d_print_comp (dpi, d_left (dc));
3004 return;
3005
3006 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3007 d_append_string_constant (dpi, "typeinfo name for ");
3008 d_print_comp (dpi, d_left (dc));
3009 return;
3010
3011 case DEMANGLE_COMPONENT_TYPEINFO_FN:
3012 d_append_string_constant (dpi, "typeinfo fn for ");
3013 d_print_comp (dpi, d_left (dc));
3014 return;
3015
3016 case DEMANGLE_COMPONENT_THUNK:
3017 d_append_string_constant (dpi, "non-virtual thunk to ");
3018 d_print_comp (dpi, d_left (dc));
3019 return;
3020
3021 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3022 d_append_string_constant (dpi, "virtual thunk to ");
3023 d_print_comp (dpi, d_left (dc));
3024 return;
3025
3026 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3027 d_append_string_constant (dpi, "covariant return thunk to ");
3028 d_print_comp (dpi, d_left (dc));
3029 return;
3030
3031 case DEMANGLE_COMPONENT_JAVA_CLASS:
3032 d_append_string_constant (dpi, "java Class for ");
3033 d_print_comp (dpi, d_left (dc));
3034 return;
3035
3036 case DEMANGLE_COMPONENT_GUARD:
3037 d_append_string_constant (dpi, "guard variable for ");
3038 d_print_comp (dpi, d_left (dc));
3039 return;
3040
3041 case DEMANGLE_COMPONENT_REFTEMP:
3042 d_append_string_constant (dpi, "reference temporary for ");
3043 d_print_comp (dpi, d_left (dc));
3044 return;
3045
3046 case DEMANGLE_COMPONENT_SUB_STD:
3047 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3048 return;
3049
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:
3061 {
3062 /* We keep a list of modifiers on the stack. */
3063 struct d_print_mod dpm;
3064
3065 dpm.next = dpi->modifiers;
3066 dpi->modifiers = &dpm;
3067 dpm.mod = dc;
3068 dpm.printed = 0;
3069 dpm.templates = dpi->templates;
3070
3071 d_print_comp (dpi, d_left (dc));
3072
3073 /* If the modifier didn't get printed by the type, print it
3074 now. */
3075 if (! dpm.printed)
3076 d_print_mod (dpi, dc);
3077
3078 dpi->modifiers = dpm.next;
3079
3080 return;
3081 }
3082
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);
3087 else
3088 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3089 dc->u.s_builtin.type->java_len);
3090 return;
3091
3092 case DEMANGLE_COMPONENT_VENDOR_TYPE:
3093 d_print_comp (dpi, d_left (dc));
3094 return;
3095
3096 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3097 {
3098 if (d_left (dc) != NULL)
3099 {
3100 struct d_print_mod dpm;
3101
3102 /* We must pass this type down as a modifier in order to
3103 print it in the right location. */
3104
3105 dpm.next = dpi->modifiers;
3106 dpi->modifiers = &dpm;
3107 dpm.mod = dc;
3108 dpm.printed = 0;
3109 dpm.templates = dpi->templates;
3110
3111 d_print_comp (dpi, d_left (dc));
3112
3113 dpi->modifiers = dpm.next;
3114
3115 if (dpm.printed)
3116 return;
3117
3118 d_append_char (dpi, ' ');
3119 }
3120
3121 d_print_function_type (dpi, dc, dpi->modifiers);
3122
3123 return;
3124 }
3125
3126 case DEMANGLE_COMPONENT_ARRAY_TYPE:
3127 {
3128 struct d_print_mod dpm;
3129
3130 /* We must pass this type down as a modifier in order to print
3131 multi-dimensional arrays correctly. */
3132
3133 dpm.next = dpi->modifiers;
3134 dpi->modifiers = &dpm;
3135 dpm.mod = dc;
3136 dpm.printed = 0;
3137 dpm.templates = dpi->templates;
3138
3139 d_print_comp (dpi, d_right (dc));
3140
3141 dpi->modifiers = dpm.next;
3142
3143 if (dpm.printed)
3144 return;
3145
3146 d_print_array_type (dpi, dc, dpi->modifiers);
3147
3148 return;
3149 }
3150
3151 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3152 {
3153 struct d_print_mod dpm;
3154
3155 dpm.next = dpi->modifiers;
3156 dpi->modifiers = &dpm;
3157 dpm.mod = dc;
3158 dpm.printed = 0;
3159 dpm.templates = dpi->templates;
3160
3161 d_print_comp (dpi, d_right (dc));
3162
3163 /* If the modifier didn't get printed by the type, print it
3164 now. */
3165 if (! dpm.printed)
3166 {
3167 d_append_char (dpi, ' ');
3168 d_print_comp (dpi, d_left (dc));
3169 d_append_string_constant (dpi, "::*");
3170 }
3171
3172 dpi->modifiers = dpm.next;
3173
3174 return;
3175 }
3176
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)
3181 {
3182 d_append_string_constant (dpi, ", ");
3183 d_print_comp (dpi, d_right (dc));
3184 }
3185 return;
3186
3187 case DEMANGLE_COMPONENT_OPERATOR:
3188 {
3189 char c;
3190
3191 d_append_string_constant (dpi, "operator");
3192 c = dc->u.s_operator.op->name[0];
3193 if (IS_LOWER (c))
3194 d_append_char (dpi, ' ');
3195 d_append_buffer (dpi, dc->u.s_operator.op->name,
3196 dc->u.s_operator.op->len);
3197 return;
3198 }
3199
3200 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3201 d_append_string_constant (dpi, "operator ");
3202 d_print_comp (dpi, dc->u.s_extended_operator.name);
3203 return;
3204
3205 case DEMANGLE_COMPONENT_CAST:
3206 d_append_string_constant (dpi, "operator ");
3207 d_print_cast (dpi, dc);
3208 return;
3209
3210 case DEMANGLE_COMPONENT_UNARY:
3211 if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3212 d_print_expr_op (dpi, d_left (dc));
3213 else
3214 {
3215 d_append_string_constant (dpi, "((");
3216 d_print_cast (dpi, d_left (dc));
3217 d_append_char (dpi, ')');
3218 }
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, ')');
3224 return;
3225
3226 case DEMANGLE_COMPONENT_BINARY:
3227 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3228 {
3229 d_print_error (dpi);
3230 return;
3231 }
3232
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, '(');
3240
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, ')');
3248
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, ')');
3253
3254 return;
3255
3256 case DEMANGLE_COMPONENT_BINARY_ARGS:
3257 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
3258 d_print_error (dpi);
3259 return;
3260
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)
3264 {
3265 d_print_error (dpi);
3266 return;
3267 }
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, ')');
3277 return;
3278
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);
3283 return;
3284
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)
3289 {
3290 switch (d_left (dc)->u.s_builtin.type->print)
3291 {
3292 case D_PRINT_INT:
3293 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3294 {
3295 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3296 d_append_char (dpi, '-');
3297 d_print_comp (dpi, d_right (dc));
3298 return;
3299 }
3300 break;
3301
3302 case D_PRINT_LONG:
3303 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3304 {
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');
3309 return;
3310 }
3311 break;
3312
3313 case D_PRINT_BOOL:
3314 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3315 && d_right (dc)->u.s_name.len == 1
3316 && dc->type == DEMANGLE_COMPONENT_LITERAL)
3317 {
3318 switch (d_right (dc)->u.s_name.s[0])
3319 {
3320 case '0':
3321 d_append_string_constant (dpi, "false");
3322 return;
3323 case '1':
3324 d_append_string_constant (dpi, "true");
3325 return;
3326 default:
3327 break;
3328 }
3329 }
3330 break;
3331
3332 default:
3333 break;
3334 }
3335 }
3336
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));
3343 return;
3344
3345 default:
3346 d_print_error (dpi);
3347 return;
3348 }
3349 }
3350
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
3354 __U<hex-char>+_. */
3355
3356 static void
d_print_java_identifier(dpi,name,len)3357 d_print_java_identifier (dpi, name, len)
3358 struct d_print_info *dpi;
3359 const char *name;
3360 int len;
3361 {
3362 const char *p;
3363 const char *end;
3364
3365 end = name + len;
3366 for (p = name; p < end; ++p)
3367 {
3368 if (end - p > 3
3369 && p[0] == '_'
3370 && p[1] == '_'
3371 && p[2] == 'U')
3372 {
3373 unsigned long c;
3374 const char *q;
3375
3376 c = 0;
3377 for (q = p + 3; q < end; ++q)
3378 {
3379 int dig;
3380
3381 if (IS_DIGIT (*q))
3382 dig = *q - '0';
3383 else if (*q >= 'A' && *q <= 'F')
3384 dig = *q - 'A' + 10;
3385 else if (*q >= 'a' && *q <= 'f')
3386 dig = *q - 'a' + 10;
3387 else
3388 break;
3389
3390 c = c * 16 + dig;
3391 }
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)
3395 {
3396 d_append_char (dpi, c);
3397 p = q;
3398 continue;
3399 }
3400 }
3401
3402 d_append_char (dpi, *p);
3403 }
3404 }
3405
3406 /* Print a list of modifiers. SUFFIX is 1 if we are printing
3407 qualifiers on this after printing a function. */
3408
3409 static void
d_print_mod_list(dpi,mods,suffix)3410 d_print_mod_list (dpi, mods, suffix)
3411 struct d_print_info *dpi;
3412 struct d_print_mod *mods;
3413 int suffix;
3414 {
3415 struct d_print_template *hold_dpt;
3416
3417 if (mods == NULL || d_print_saw_error (dpi))
3418 return;
3419
3420 if (mods->printed
3421 || (! suffix
3422 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3423 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3424 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
3425 {
3426 d_print_mod_list (dpi, mods->next, suffix);
3427 return;
3428 }
3429
3430 mods->printed = 1;
3431
3432 hold_dpt = dpi->templates;
3433 dpi->templates = mods->templates;
3434
3435 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3436 {
3437 d_print_function_type (dpi, mods->mod, mods->next);
3438 dpi->templates = hold_dpt;
3439 return;
3440 }
3441 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3442 {
3443 d_print_array_type (dpi, mods->mod, mods->next);
3444 dpi->templates = hold_dpt;
3445 return;
3446 }
3447 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3448 {
3449 struct d_print_mod *hold_modifiers;
3450 struct demangle_component *dc;
3451
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
3455 modifiers. */
3456
3457 hold_modifiers = dpi->modifiers;
3458 dpi->modifiers = NULL;
3459 d_print_comp (dpi, d_left (mods->mod));
3460 dpi->modifiers = hold_modifiers;
3461
3462 if ((dpi->options & DMGL_JAVA) == 0)
3463 d_append_string_constant (dpi, "::");
3464 else
3465 d_append_char (dpi, '.');
3466
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)
3471 dc = d_left (dc);
3472
3473 d_print_comp (dpi, dc);
3474
3475 dpi->templates = hold_dpt;
3476 return;
3477 }
3478
3479 d_print_mod (dpi, mods->mod);
3480
3481 dpi->templates = hold_dpt;
3482
3483 d_print_mod_list (dpi, mods->next, suffix);
3484 }
3485
3486 /* Print a modifier. */
3487
3488 static void
d_print_mod(dpi,mod)3489 d_print_mod (dpi, mod)
3490 struct d_print_info *dpi;
3491 const struct demangle_component *mod;
3492 {
3493 switch (mod->type)
3494 {
3495 case DEMANGLE_COMPONENT_RESTRICT:
3496 case DEMANGLE_COMPONENT_RESTRICT_THIS:
3497 d_append_string_constant (dpi, " restrict");
3498 return;
3499 case DEMANGLE_COMPONENT_VOLATILE:
3500 case DEMANGLE_COMPONENT_VOLATILE_THIS:
3501 d_append_string_constant (dpi, " volatile");
3502 return;
3503 case DEMANGLE_COMPONENT_CONST:
3504 case DEMANGLE_COMPONENT_CONST_THIS:
3505 d_append_string_constant (dpi, " const");
3506 return;
3507 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3508 d_append_char (dpi, ' ');
3509 d_print_comp (dpi, d_right (mod));
3510 return;
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, '*');
3515 return;
3516 case DEMANGLE_COMPONENT_REFERENCE:
3517 d_append_char (dpi, '&');
3518 return;
3519 case DEMANGLE_COMPONENT_COMPLEX:
3520 d_append_string_constant (dpi, "complex ");
3521 return;
3522 case DEMANGLE_COMPONENT_IMAGINARY:
3523 d_append_string_constant (dpi, "imaginary ");
3524 return;
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, "::*");
3530 return;
3531 case DEMANGLE_COMPONENT_TYPED_NAME:
3532 d_print_comp (dpi, d_left (mod));
3533 return;
3534 default:
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);
3538 return;
3539 }
3540 }
3541
3542 /* Print a function type, except for the return type. */
3543
3544 static void
d_print_function_type(dpi,dc,mods)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;
3549 {
3550 int need_paren;
3551 int saw_mod;
3552 struct d_print_mod *p;
3553 struct d_print_mod *hold_modifiers;
3554
3555 need_paren = 0;
3556 saw_mod = 0;
3557 for (p = mods; p != NULL; p = p->next)
3558 {
3559 if (p->printed)
3560 break;
3561
3562 saw_mod = 1;
3563 switch (p->mod->type)
3564 {
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:
3574 need_paren = 1;
3575 break;
3576 case DEMANGLE_COMPONENT_RESTRICT_THIS:
3577 case DEMANGLE_COMPONENT_VOLATILE_THIS:
3578 case DEMANGLE_COMPONENT_CONST_THIS:
3579 break;
3580 default:
3581 break;
3582 }
3583 if (need_paren)
3584 break;
3585 }
3586
3587 if (d_left (dc) != NULL && ! saw_mod)
3588 need_paren = 1;
3589
3590 if (need_paren)
3591 {
3592 switch (d_last_char (dpi))
3593 {
3594 case ' ':
3595 case '(':
3596 case '*':
3597 break;
3598
3599 default:
3600 d_append_char (dpi, ' ');
3601 break;
3602 }
3603
3604 d_append_char (dpi, '(');
3605 }
3606
3607 hold_modifiers = dpi->modifiers;
3608 dpi->modifiers = NULL;
3609
3610 d_print_mod_list (dpi, mods, 0);
3611
3612 if (need_paren)
3613 d_append_char (dpi, ')');
3614
3615 d_append_char (dpi, '(');
3616
3617 if (d_right (dc) != NULL)
3618 d_print_comp (dpi, d_right (dc));
3619
3620 d_append_char (dpi, ')');
3621
3622 d_print_mod_list (dpi, mods, 1);
3623
3624 dpi->modifiers = hold_modifiers;
3625 }
3626
3627 /* Print an array type, except for the element type. */
3628
3629 static void
d_print_array_type(dpi,dc,mods)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;
3634 {
3635 int need_space;
3636
3637 need_space = 1;
3638 if (mods != NULL)
3639 {
3640 int need_paren;
3641 struct d_print_mod *p;
3642
3643 need_paren = 0;
3644 for (p = mods; p != NULL; p = p->next)
3645 {
3646 if (p->printed)
3647 break;
3648
3649 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3650 {
3651 need_space = 0;
3652 break;
3653 }
3654 else
3655 {
3656 need_paren = 1;
3657 need_space = 1;
3658 break;
3659 }
3660 }
3661
3662 if (need_paren)
3663 d_append_string_constant (dpi, " (");
3664
3665 d_print_mod_list (dpi, mods, 0);
3666
3667 if (need_paren)
3668 d_append_char (dpi, ')');
3669 }
3670
3671 if (need_space)
3672 d_append_char (dpi, ' ');
3673
3674 d_append_char (dpi, '[');
3675
3676 if (d_left (dc) != NULL)
3677 d_print_comp (dpi, d_left (dc));
3678
3679 d_append_char (dpi, ']');
3680 }
3681
3682 /* Print an operator in an expression. */
3683
3684 static void
d_print_expr_op(dpi,dc)3685 d_print_expr_op (dpi, dc)
3686 struct d_print_info *dpi;
3687 const struct demangle_component *dc;
3688 {
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);
3692 else
3693 d_print_comp (dpi, dc);
3694 }
3695
3696 /* Print a cast. */
3697
3698 static void
d_print_cast(dpi,dc)3699 d_print_cast (dpi, dc)
3700 struct d_print_info *dpi;
3701 const struct demangle_component *dc;
3702 {
3703 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
3704 d_print_comp (dpi, d_left (dc));
3705 else
3706 {
3707 struct d_print_mod *hold_dpm;
3708 struct d_print_template dpt;
3709
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. */
3714
3715 hold_dpm = dpi->modifiers;
3716 dpi->modifiers = NULL;
3717
3718 dpt.next = dpi->templates;
3719 dpi->templates = &dpt;
3720 dpt.template = d_left (dc);
3721
3722 d_print_comp (dpi, d_left (d_left (dc)));
3723
3724 dpi->templates = dpt.next;
3725
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, '>');
3735
3736 dpi->modifiers = hold_dpm;
3737 }
3738 }
3739
3740 /* Initialize the information structure we use to pass around
3741 information. */
3742
3743 CP_STATIC_IF_GLIBCPP_V3
3744 void
cplus_demangle_init_info(mangled,options,len,di)3745 cplus_demangle_init_info (mangled, options, len, di)
3746 const char *mangled;
3747 int options;
3748 size_t len;
3749 struct d_info *di;
3750 {
3751 di->s = mangled;
3752 di->send = mangled + len;
3753 di->options = options;
3754
3755 di->n = mangled;
3756
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;
3761 di->next_comp = 0;
3762
3763 /* Similarly, we can not need more substitutions than there are
3764 chars in the mangled string. */
3765 di->num_subs = len;
3766 di->next_sub = 0;
3767 di->did_subs = 0;
3768
3769 di->last_name = NULL;
3770
3771 di->expansion = 0;
3772 }
3773
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. */
3780
3781 static char *
d_demangle(mangled,options,palc)3782 d_demangle (mangled, options, palc)
3783 const char* mangled;
3784 int options;
3785 size_t *palc;
3786 {
3787 size_t len;
3788 int type;
3789 struct d_info di;
3790 struct demangle_component *dc;
3791 int estimate;
3792 char *ret;
3793
3794 *palc = 0;
3795
3796 len = strlen (mangled);
3797
3798 if (mangled[0] == '_' && mangled[1] == 'Z')
3799 type = 0;
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] == '_')
3804 {
3805 char *r;
3806
3807 r = malloc (40 + len - 11);
3808 if (r == NULL)
3809 *palc = 1;
3810 else
3811 {
3812 if (mangled[9] == 'I')
3813 strcpy (r, "global constructors keyed to ");
3814 else
3815 strcpy (r, "global destructors keyed to ");
3816 strcat (r, mangled + 11);
3817 }
3818 return r;
3819 }
3820 else
3821 {
3822 if ((options & DMGL_TYPES) == 0)
3823 return NULL;
3824 type = 1;
3825 }
3826
3827 cplus_demangle_init_info (mangled, options, len, &di);
3828
3829 {
3830 #ifdef CP_DYNAMIC_ARRAYS
3831 __extension__ struct demangle_component comps[di.num_comps];
3832 __extension__ struct demangle_component *subs[di.num_subs];
3833
3834 di.comps = &comps[0];
3835 di.subs = &subs[0];
3836 #else
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)
3842 {
3843 if (di.comps != NULL)
3844 free (di.comps);
3845 if (di.subs != NULL)
3846 free (di.subs);
3847 *palc = 1;
3848 return NULL;
3849 }
3850 #endif
3851
3852 if (! type)
3853 dc = cplus_demangle_mangled_name (&di, 1);
3854 else
3855 dc = cplus_demangle_type (&di);
3856
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
3860 parameters. */
3861 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
3862 dc = NULL;
3863
3864 #ifdef CP_DEMANGLE_DEBUG
3865 if (dc == NULL)
3866 printf ("failed demangling\n");
3867 else
3868 d_dump (dc, 0);
3869 #endif
3870
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;
3875
3876 ret = NULL;
3877 if (dc != NULL)
3878 ret = cplus_demangle_print (options, dc, estimate, palc);
3879
3880 #ifndef CP_DYNAMIC_ARRAYS
3881 free (di.comps);
3882 free (di.subs);
3883 #endif
3884
3885 #ifdef CP_DEMANGLE_DEBUG
3886 if (ret != NULL)
3887 {
3888 int rlen;
3889
3890 rlen = strlen (ret);
3891 if (rlen > 2 * estimate)
3892 printf ("*** Length %d much greater than estimate %d\n",
3893 rlen, estimate);
3894 else if (rlen > estimate)
3895 printf ("*** Length %d greater than estimate %d\n",
3896 rlen, estimate);
3897 else if (rlen < estimate / 2)
3898 printf ("*** Length %d much less than estimate %d\n",
3899 rlen, estimate);
3900 }
3901 #endif
3902 }
3903
3904 return ret;
3905 }
3906
3907 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3908
3909 extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
3910
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.
3914
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.
3920
3921 If LENGTH is non-NULL, the length of the buffer conaining the
3922 demangled name, is placed in *LENGTH.
3923
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.
3927
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.
3933
3934 The demangling is performed using the C++ ABI mangling rules, with
3935 GNU extensions. */
3936
3937 char *
__cxa_demangle(mangled_name,output_buffer,length,status)3938 __cxa_demangle (mangled_name, output_buffer, length, status)
3939 const char *mangled_name;
3940 char *output_buffer;
3941 size_t *length;
3942 int *status;
3943 {
3944 char *demangled;
3945 size_t alc;
3946
3947 if (status == NULL)
3948 return NULL;
3949
3950 if (mangled_name == NULL)
3951 {
3952 *status = -3;
3953 return NULL;
3954 }
3955
3956 if (output_buffer != NULL && length == NULL)
3957 {
3958 *status = -3;
3959 return NULL;
3960 }
3961
3962 demangled = d_demangle (mangled_name, DMGL_TYPES, &alc);
3963
3964 if (demangled == NULL)
3965 {
3966 if (alc == 1)
3967 *status = -1;
3968 else
3969 *status = -2;
3970 return NULL;
3971 }
3972
3973 if (output_buffer == NULL)
3974 {
3975 if (length != NULL)
3976 *length = alc;
3977 }
3978 else
3979 {
3980 if (strlen (demangled) < *length)
3981 {
3982 strcpy (output_buffer, demangled);
3983 free (demangled);
3984 demangled = output_buffer;
3985 }
3986 else
3987 {
3988 free (output_buffer);
3989 *length = alc;
3990 }
3991 }
3992
3993 *status = 0;
3994
3995 return demangled;
3996 }
3997
3998 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
3999
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. */
4003
4004 char *
cplus_demangle_v3(mangled,options)4005 cplus_demangle_v3 (mangled, options)
4006 const char* mangled;
4007 int options;
4008 {
4009 size_t alc;
4010
4011 return d_demangle (mangled, options, &alc);
4012 }
4013
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[]. */
4020
4021 char *
java_demangle_v3(mangled)4022 java_demangle_v3 (mangled)
4023 const char* mangled;
4024 {
4025 size_t alc;
4026 char *demangled;
4027 int nesting;
4028 char *from;
4029 char *to;
4030
4031 demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc);
4032
4033 if (demangled == NULL)
4034 return NULL;
4035
4036 nesting = 0;
4037 from = demangled;
4038 to = from;
4039 while (*from != '\0')
4040 {
4041 if (strncmp (from, "JArray<", 7) == 0)
4042 {
4043 from += 7;
4044 ++nesting;
4045 }
4046 else if (nesting > 0 && *from == '>')
4047 {
4048 while (to > demangled && to[-1] == ' ')
4049 --to;
4050 *to++ = '[';
4051 *to++ = ']';
4052 --nesting;
4053 ++from;
4054 }
4055 else
4056 *to++ = *from++;
4057 }
4058
4059 *to = '\0';
4060
4061 return demangled;
4062 }
4063
4064 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4065
4066 #ifndef IN_GLIBCPP_V3
4067
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. */
4071
4072 static int
is_ctor_or_dtor(mangled,ctor_kind,dtor_kind)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;
4077 {
4078 struct d_info di;
4079 struct demangle_component *dc;
4080 int ret;
4081
4082 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4083 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4084
4085 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4086
4087 {
4088 #ifdef CP_DYNAMIC_ARRAYS
4089 __extension__ struct demangle_component comps[di.num_comps];
4090 __extension__ struct demangle_component *subs[di.num_subs];
4091
4092 di.comps = &comps[0];
4093 di.subs = &subs[0];
4094 #else
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)
4100 {
4101 if (di.comps != NULL)
4102 free (di.comps);
4103 if (di.subs != NULL)
4104 free (di.subs);
4105 return 0;
4106 }
4107 #endif
4108
4109 dc = cplus_demangle_mangled_name (&di, 1);
4110
4111 /* Note that because we did not pass DMGL_PARAMS, we don't expect
4112 to demangle the entire string. */
4113
4114 ret = 0;
4115 while (dc != NULL)
4116 {
4117 switch (dc->type)
4118 {
4119 default:
4120 dc = NULL;
4121 break;
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:
4127 dc = d_left (dc);
4128 break;
4129 case DEMANGLE_COMPONENT_QUAL_NAME:
4130 case DEMANGLE_COMPONENT_LOCAL_NAME:
4131 dc = d_right (dc);
4132 break;
4133 case DEMANGLE_COMPONENT_CTOR:
4134 *ctor_kind = dc->u.s_ctor.kind;
4135 ret = 1;
4136 dc = NULL;
4137 break;
4138 case DEMANGLE_COMPONENT_DTOR:
4139 *dtor_kind = dc->u.s_dtor.kind;
4140 ret = 1;
4141 dc = NULL;
4142 break;
4143 }
4144 }
4145
4146 #ifndef CP_DYNAMIC_ARRAYS
4147 free (di.subs);
4148 free (di.comps);
4149 #endif
4150 }
4151
4152 return ret;
4153 }
4154
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. */
4157
4158 enum gnu_v3_ctor_kinds
is_gnu_v3_mangled_ctor(name)4159 is_gnu_v3_mangled_ctor (name)
4160 const char *name;
4161 {
4162 enum gnu_v3_ctor_kinds ctor_kind;
4163 enum gnu_v3_dtor_kinds dtor_kind;
4164
4165 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4166 return (enum gnu_v3_ctor_kinds) 0;
4167 return ctor_kind;
4168 }
4169
4170
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. */
4173
4174 enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor(name)4175 is_gnu_v3_mangled_dtor (name)
4176 const char *name;
4177 {
4178 enum gnu_v3_ctor_kinds ctor_kind;
4179 enum gnu_v3_dtor_kinds dtor_kind;
4180
4181 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4182 return (enum gnu_v3_dtor_kinds) 0;
4183 return dtor_kind;
4184 }
4185
4186 #endif /* IN_GLIBCPP_V3 */
4187
4188 #ifdef STANDALONE_DEMANGLER
4189
4190 #include "getopt.h"
4191 #include "dyn-string.h"
4192
4193 static void print_usage PARAMS ((FILE* fp, int exit_value));
4194
4195 #define IS_ALPHA(CHAR) \
4196 (((CHAR) >= 'a' && (CHAR) <= 'z') \
4197 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4198
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) == '$')
4203
4204 /* The name of this program, as invoked. */
4205 const char* program_name;
4206
4207 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
4208
4209 static void
print_usage(fp,exit_value)4210 print_usage (fp, exit_value)
4211 FILE* fp;
4212 int exit_value;
4213 {
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");
4220
4221 exit (exit_value);
4222 }
4223
4224 /* Option specification for getopt_long. */
4225 static const struct option long_options[] =
4226 {
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 },
4231 };
4232
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. */
4237
4238 int
main(argc,argv)4239 main (argc, argv)
4240 int argc;
4241 char *argv[];
4242 {
4243 int i;
4244 int opt_char;
4245 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4246
4247 /* Use the program name of this program, as invoked. */
4248 program_name = argv[0];
4249
4250 /* Parse options. */
4251 do
4252 {
4253 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4254 switch (opt_char)
4255 {
4256 case '?': /* Unrecognized option. */
4257 print_usage (stderr, 1);
4258 break;
4259
4260 case 'h':
4261 print_usage (stdout, 0);
4262 break;
4263
4264 case 'p':
4265 options &= ~ DMGL_PARAMS;
4266 break;
4267
4268 case 'v':
4269 options |= DMGL_VERBOSE;
4270 break;
4271 }
4272 }
4273 while (opt_char != -1);
4274
4275 if (optind == argc)
4276 /* No command line arguments were provided. Filter stdin. */
4277 {
4278 dyn_string_t mangled = dyn_string_new (3);
4279 char *s;
4280
4281 /* Read all of input. */
4282 while (!feof (stdin))
4283 {
4284 char c;
4285
4286 /* Pile characters into mangled until we hit one that can't
4287 occur in a mangled name. */
4288 c = getchar ();
4289 while (!feof (stdin) && is_mangled_char (c))
4290 {
4291 dyn_string_append_char (mangled, c);
4292 if (feof (stdin))
4293 break;
4294 c = getchar ();
4295 }
4296
4297 if (dyn_string_length (mangled) > 0)
4298 {
4299 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
4300
4301 if (s != NULL)
4302 {
4303 fputs (s, stdout);
4304 free (s);
4305 }
4306 else
4307 {
4308 /* It might not have been a mangled name. Print the
4309 original text. */
4310 fputs (dyn_string_buf (mangled), stdout);
4311 }
4312
4313 dyn_string_clear (mangled);
4314 }
4315
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. */
4318 if (!feof (stdin))
4319 putchar (c);
4320 }
4321
4322 dyn_string_delete (mangled);
4323 }
4324 else
4325 /* Demangle command line arguments. */
4326 {
4327 /* Loop over command line arguments. */
4328 for (i = optind; i < argc; ++i)
4329 {
4330 char *s;
4331
4332 /* Attempt to demangle. */
4333 s = cplus_demangle_v3 (argv[i], options);
4334
4335 /* If it worked, print the demangled name. */
4336 if (s != NULL)
4337 {
4338 printf ("%s\n", s);
4339 free (s);
4340 }
4341 else
4342 fprintf (stderr, "Failed: %s\n", argv[i]);
4343 }
4344 }
4345
4346 return 0;
4347 }
4348
4349 #endif /* STANDALONE_DEMANGLER */
4350