1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5
6 This file is part of the libiberty library, which is part of GCC.
7
8 This file is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file. (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combined
20 executable.)
21
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with this program; if not, write to the Free Software
29 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
30 */
31
32 /* This code implements a demangler for the g++ V3 ABI. The ABI is
33 described on this web page:
34 http://www.codesourcery.com/cxx-abi/abi.html#mangling
35
36 This code was written while looking at the demangler written by
37 Alex Samuel <samuel@codesourcery.com>.
38
39 This code first pulls the mangled name apart into a list of
40 components, and then walks the list generating the demangled
41 name.
42
43 This file will normally define the following functions, q.v.:
44 char *cplus_demangle_v3(const char *mangled, int options)
45 char *java_demangle_v3(const char *mangled)
46 int cplus_demangle_v3_callback(const char *mangled, int options,
47 demangle_callbackref callback)
48 int java_demangle_v3_callback(const char *mangled,
49 demangle_callbackref callback)
50 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
51 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52
53 Also, the interface to the component list is public, and defined in
54 demangle.h. The interface consists of these types, which are
55 defined in demangle.h:
56 enum demangle_component_type
57 struct demangle_component
58 demangle_callbackref
59 and these functions defined in this file:
60 cplus_demangle_fill_name
61 cplus_demangle_fill_extended_operator
62 cplus_demangle_fill_ctor
63 cplus_demangle_fill_dtor
64 cplus_demangle_print
65 cplus_demangle_print_callback
66 and other functions defined in the file cp-demint.c.
67
68 This file also defines some other functions and variables which are
69 only to be used by the file cp-demint.c.
70
71 Preprocessor macros you can define while compiling this file:
72
73 IN_LIBGCC2
74 If defined, this file defines the following functions, q.v.:
75 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
76 int *status)
77 int __gcclibcxx_demangle_callback (const char *,
78 void (*)
79 (const char *, size_t, void *),
80 void *)
81 instead of cplus_demangle_v3[_callback]() and
82 java_demangle_v3[_callback]().
83
84 IN_GLIBCPP_V3
85 If defined, this file defines only __cxa_demangle() and
86 __gcclibcxx_demangle_callback(), and no other publically visible
87 functions or variables.
88
89 STANDALONE_DEMANGLER
90 If defined, this file defines a main() function which demangles
91 any arguments, or, if none, demangles stdin.
92
93 CP_DEMANGLE_DEBUG
94 If defined, turns on debugging mode, which prints information on
95 stdout about the mangled string. This is not generally useful.
96 */
97
98 #if defined (_AIX) && !defined (__GNUC__)
99 #pragma alloca
100 #endif
101
102 #ifdef HAVE_CONFIG_H
103 #include "config.h"
104 #endif
105
106 #include <stdio.h>
107
108 #ifdef HAVE_STDLIB_H
109 #include <stdlib.h>
110 #endif
111 #ifdef HAVE_STRING_H
112 #include <string.h>
113 #endif
114
115 #ifdef HAVE_ALLOCA_H
116 # include <alloca.h>
117 #else
118 # ifndef alloca
119 # ifdef __GNUC__
120 # define alloca __builtin_alloca
121 # else
122 extern char *alloca ();
123 # endif /* __GNUC__ */
124 # endif /* alloca */
125 #endif /* HAVE_ALLOCA_H */
126
127 #include "ansidecl.h"
128 #include "libiberty.h"
129 #include "demangle.h"
130 #include "cp-demangle.h"
131
132 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
133 also rename them via #define to avoid compiler errors when the
134 static definition conflicts with the extern declaration in a header
135 file. */
136 #ifdef IN_GLIBCPP_V3
137
138 #define CP_STATIC_IF_GLIBCPP_V3 static
139
140 #define cplus_demangle_fill_name d_fill_name
141 static int d_fill_name (struct demangle_component *, const char *, int);
142
143 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
144 static int
145 d_fill_extended_operator (struct demangle_component *, int,
146 struct demangle_component *);
147
148 #define cplus_demangle_fill_ctor d_fill_ctor
149 static int
150 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
151 struct demangle_component *);
152
153 #define cplus_demangle_fill_dtor d_fill_dtor
154 static int
155 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
156 struct demangle_component *);
157
158 #define cplus_demangle_mangled_name d_mangled_name
159 static struct demangle_component *d_mangled_name (struct d_info *, int);
160
161 #define cplus_demangle_type d_type
162 static struct demangle_component *d_type (struct d_info *);
163
164 #define cplus_demangle_print d_print
165 static char *d_print (int, const struct demangle_component *, int, size_t *);
166
167 #define cplus_demangle_print_callback d_print_callback
168 static int d_print_callback (int, const struct demangle_component *,
169 demangle_callbackref, void *);
170
171 #define cplus_demangle_init_info d_init_info
172 static void d_init_info (const char *, int, size_t, struct d_info *);
173
174 #else /* ! defined(IN_GLIBCPP_V3) */
175 #define CP_STATIC_IF_GLIBCPP_V3
176 #endif /* ! defined(IN_GLIBCPP_V3) */
177
178 /* See if the compiler supports dynamic arrays. */
179
180 #ifdef __GNUC__
181 #define CP_DYNAMIC_ARRAYS
182 #else
183 #ifdef __STDC__
184 #ifdef __STDC_VERSION__
185 #if __STDC_VERSION__ >= 199901L
186 #define CP_DYNAMIC_ARRAYS
187 #endif /* __STDC__VERSION >= 199901L */
188 #endif /* defined (__STDC_VERSION__) */
189 #endif /* defined (__STDC__) */
190 #endif /* ! defined (__GNUC__) */
191
192 /* We avoid pulling in the ctype tables, to prevent pulling in
193 additional unresolved symbols when this code is used in a library.
194 FIXME: Is this really a valid reason? This comes from the original
195 V3 demangler code.
196
197 As of this writing this file has the following undefined references
198 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
199 strcat, strlen. */
200
201 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
202 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
203 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
204
205 /* The prefix prepended by GCC to an identifier represnting the
206 anonymous namespace. */
207 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
208 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
209 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
210
211 /* Information we keep for the standard substitutions. */
212
213 struct d_standard_sub_info
214 {
215 /* The code for this substitution. */
216 char code;
217 /* The simple string it expands to. */
218 const char *simple_expansion;
219 /* The length of the simple expansion. */
220 int simple_len;
221 /* The results of a full, verbose, expansion. This is used when
222 qualifying a constructor/destructor, or when in verbose mode. */
223 const char *full_expansion;
224 /* The length of the full expansion. */
225 int full_len;
226 /* What to set the last_name field of d_info to; NULL if we should
227 not set it. This is only relevant when qualifying a
228 constructor/destructor. */
229 const char *set_last_name;
230 /* The length of set_last_name. */
231 int set_last_name_len;
232 };
233
234 /* Accessors for subtrees of struct demangle_component. */
235
236 #define d_left(dc) ((dc)->u.s_binary.left)
237 #define d_right(dc) ((dc)->u.s_binary.right)
238
239 /* A list of templates. This is used while printing. */
240
241 struct d_print_template
242 {
243 /* Next template on the list. */
244 struct d_print_template *next;
245 /* This template. */
246 const struct demangle_component *template_decl;
247 };
248
249 /* A list of type modifiers. This is used while printing. */
250
251 struct d_print_mod
252 {
253 /* Next modifier on the list. These are in the reverse of the order
254 in which they appeared in the mangled string. */
255 struct d_print_mod *next;
256 /* The modifier. */
257 const struct demangle_component *mod;
258 /* Whether this modifier was printed. */
259 int printed;
260 /* The list of templates which applies to this modifier. */
261 struct d_print_template *templates;
262 };
263
264 /* We use these structures to hold information during printing. */
265
266 struct d_growable_string
267 {
268 /* Buffer holding the result. */
269 char *buf;
270 /* Current length of data in buffer. */
271 size_t len;
272 /* Allocated size of buffer. */
273 size_t alc;
274 /* Set to 1 if we had a memory allocation failure. */
275 int allocation_failure;
276 };
277
278 enum { D_PRINT_BUFFER_LENGTH = 256 };
279 struct d_print_info
280 {
281 /* Fixed-length allocated buffer for demangled data, flushed to the
282 callback with a NUL termination once full. */
283 char buf[D_PRINT_BUFFER_LENGTH];
284 /* Current length of data in buffer. */
285 size_t len;
286 /* The last character printed, saved individually so that it survives
287 any buffer flush. */
288 char last_char;
289 /* Callback function to handle demangled buffer flush. */
290 demangle_callbackref callback;
291 /* Opaque callback argument. */
292 void *opaque;
293 /* The current list of templates, if any. */
294 struct d_print_template *templates;
295 /* The current list of modifiers (e.g., pointer, reference, etc.),
296 if any. */
297 struct d_print_mod *modifiers;
298 /* Set to 1 if we saw a demangling error. */
299 int demangle_failure;
300 /* The current index into any template argument packs we are using
301 for printing. */
302 int pack_index;
303 /* Number of d_print_flush calls so far. */
304 unsigned long int flush_count;
305 };
306
307 #ifdef CP_DEMANGLE_DEBUG
308 static void d_dump (struct demangle_component *, int);
309 #endif
310
311 static struct demangle_component *
312 d_make_empty (struct d_info *);
313
314 static struct demangle_component *
315 d_make_comp (struct d_info *, enum demangle_component_type,
316 struct demangle_component *,
317 struct demangle_component *);
318
319 static struct demangle_component *
320 d_make_name (struct d_info *, const char *, int);
321
322 static struct demangle_component *
323 d_make_demangle_mangled_name (struct d_info *, const char *);
324
325 static struct demangle_component *
326 d_make_builtin_type (struct d_info *,
327 const struct demangle_builtin_type_info *);
328
329 static struct demangle_component *
330 d_make_operator (struct d_info *,
331 const struct demangle_operator_info *);
332
333 static struct demangle_component *
334 d_make_extended_operator (struct d_info *, int,
335 struct demangle_component *);
336
337 static struct demangle_component *
338 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
339 struct demangle_component *);
340
341 static struct demangle_component *
342 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
343 struct demangle_component *);
344
345 static struct demangle_component *
346 d_make_template_param (struct d_info *, long);
347
348 static struct demangle_component *
349 d_make_sub (struct d_info *, const char *, int);
350
351 static int
352 has_return_type (struct demangle_component *);
353
354 static int
355 is_ctor_dtor_or_conversion (struct demangle_component *);
356
357 static struct demangle_component *d_encoding (struct d_info *, int);
358
359 static struct demangle_component *d_name (struct d_info *);
360
361 static struct demangle_component *d_nested_name (struct d_info *);
362
363 static struct demangle_component *d_prefix (struct d_info *);
364
365 static struct demangle_component *d_unqualified_name (struct d_info *);
366
367 static struct demangle_component *d_source_name (struct d_info *);
368
369 static long d_number (struct d_info *);
370
371 static struct demangle_component *d_identifier (struct d_info *, int);
372
373 static struct demangle_component *d_operator_name (struct d_info *);
374
375 static struct demangle_component *d_special_name (struct d_info *);
376
377 static int d_call_offset (struct d_info *, int);
378
379 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
380
381 static struct demangle_component **
382 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
383
384 static struct demangle_component *
385 d_function_type (struct d_info *);
386
387 static struct demangle_component *
388 d_bare_function_type (struct d_info *, int);
389
390 static struct demangle_component *
391 d_class_enum_type (struct d_info *);
392
393 static struct demangle_component *d_array_type (struct d_info *);
394
395 static struct demangle_component *d_vector_type (struct d_info *);
396
397 static struct demangle_component *
398 d_pointer_to_member_type (struct d_info *);
399
400 static struct demangle_component *
401 d_template_param (struct d_info *);
402
403 static struct demangle_component *d_template_args (struct d_info *);
404
405 static struct demangle_component *
406 d_template_arg (struct d_info *);
407
408 static struct demangle_component *d_expression (struct d_info *);
409
410 static struct demangle_component *d_expr_primary (struct d_info *);
411
412 static struct demangle_component *d_local_name (struct d_info *);
413
414 static int d_discriminator (struct d_info *);
415
416 static struct demangle_component *d_lambda (struct d_info *);
417
418 static struct demangle_component *d_unnamed_type (struct d_info *);
419
420 static int
421 d_add_substitution (struct d_info *, struct demangle_component *);
422
423 static struct demangle_component *d_substitution (struct d_info *, int);
424
425 static void d_growable_string_init (struct d_growable_string *, size_t);
426
427 static inline void
428 d_growable_string_resize (struct d_growable_string *, size_t);
429
430 static inline void
431 d_growable_string_append_buffer (struct d_growable_string *,
432 const char *, size_t);
433 static void
434 d_growable_string_callback_adapter (const char *, size_t, void *);
435
436 static void
437 d_print_init (struct d_print_info *, demangle_callbackref, void *);
438
439 static inline void d_print_error (struct d_print_info *);
440
441 static inline int d_print_saw_error (struct d_print_info *);
442
443 static inline void d_print_flush (struct d_print_info *);
444
445 static inline void d_append_char (struct d_print_info *, char);
446
447 static inline void d_append_buffer (struct d_print_info *,
448 const char *, size_t);
449
450 static inline void d_append_string (struct d_print_info *, const char *);
451
452 static inline char d_last_char (struct d_print_info *);
453
454 static void
455 d_print_comp (struct d_print_info *, int, const struct demangle_component *);
456
457 static void
458 d_print_java_identifier (struct d_print_info *, const char *, int);
459
460 static void
461 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
462
463 static void
464 d_print_mod (struct d_print_info *, int, const struct demangle_component *);
465
466 static void
467 d_print_function_type (struct d_print_info *, int,
468 const struct demangle_component *,
469 struct d_print_mod *);
470
471 static void
472 d_print_array_type (struct d_print_info *, int,
473 const struct demangle_component *,
474 struct d_print_mod *);
475
476 static void
477 d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);
478
479 static void
480 d_print_cast (struct d_print_info *, int, const struct demangle_component *);
481
482 static int d_demangle_callback (const char *, int,
483 demangle_callbackref, void *);
484 static char *d_demangle (const char *, int, size_t *);
485
486 #ifdef CP_DEMANGLE_DEBUG
487
488 static void
d_dump(struct demangle_component * dc,int indent)489 d_dump (struct demangle_component *dc, int indent)
490 {
491 int i;
492
493 if (dc == NULL)
494 {
495 if (indent == 0)
496 printf ("failed demangling\n");
497 return;
498 }
499
500 for (i = 0; i < indent; ++i)
501 putchar (' ');
502
503 switch (dc->type)
504 {
505 case DEMANGLE_COMPONENT_NAME:
506 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
507 return;
508 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
509 printf ("template parameter %ld\n", dc->u.s_number.number);
510 return;
511 case DEMANGLE_COMPONENT_CTOR:
512 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
513 d_dump (dc->u.s_ctor.name, indent + 2);
514 return;
515 case DEMANGLE_COMPONENT_DTOR:
516 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
517 d_dump (dc->u.s_dtor.name, indent + 2);
518 return;
519 case DEMANGLE_COMPONENT_SUB_STD:
520 printf ("standard substitution %s\n", dc->u.s_string.string);
521 return;
522 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
523 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
524 return;
525 case DEMANGLE_COMPONENT_OPERATOR:
526 printf ("operator %s\n", dc->u.s_operator.op->name);
527 return;
528 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
529 printf ("extended operator with %d args\n",
530 dc->u.s_extended_operator.args);
531 d_dump (dc->u.s_extended_operator.name, indent + 2);
532 return;
533
534 case DEMANGLE_COMPONENT_QUAL_NAME:
535 printf ("qualified name\n");
536 break;
537 case DEMANGLE_COMPONENT_LOCAL_NAME:
538 printf ("local name\n");
539 break;
540 case DEMANGLE_COMPONENT_TYPED_NAME:
541 printf ("typed name\n");
542 break;
543 case DEMANGLE_COMPONENT_TEMPLATE:
544 printf ("template\n");
545 break;
546 case DEMANGLE_COMPONENT_VTABLE:
547 printf ("vtable\n");
548 break;
549 case DEMANGLE_COMPONENT_VTT:
550 printf ("VTT\n");
551 break;
552 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
553 printf ("construction vtable\n");
554 break;
555 case DEMANGLE_COMPONENT_TYPEINFO:
556 printf ("typeinfo\n");
557 break;
558 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
559 printf ("typeinfo name\n");
560 break;
561 case DEMANGLE_COMPONENT_TYPEINFO_FN:
562 printf ("typeinfo function\n");
563 break;
564 case DEMANGLE_COMPONENT_THUNK:
565 printf ("thunk\n");
566 break;
567 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
568 printf ("virtual thunk\n");
569 break;
570 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
571 printf ("covariant thunk\n");
572 break;
573 case DEMANGLE_COMPONENT_JAVA_CLASS:
574 printf ("java class\n");
575 break;
576 case DEMANGLE_COMPONENT_GUARD:
577 printf ("guard\n");
578 break;
579 case DEMANGLE_COMPONENT_REFTEMP:
580 printf ("reference temporary\n");
581 break;
582 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
583 printf ("hidden alias\n");
584 break;
585 case DEMANGLE_COMPONENT_RESTRICT:
586 printf ("restrict\n");
587 break;
588 case DEMANGLE_COMPONENT_VOLATILE:
589 printf ("volatile\n");
590 break;
591 case DEMANGLE_COMPONENT_CONST:
592 printf ("const\n");
593 break;
594 case DEMANGLE_COMPONENT_RESTRICT_THIS:
595 printf ("restrict this\n");
596 break;
597 case DEMANGLE_COMPONENT_VOLATILE_THIS:
598 printf ("volatile this\n");
599 break;
600 case DEMANGLE_COMPONENT_CONST_THIS:
601 printf ("const this\n");
602 break;
603 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
604 printf ("vendor type qualifier\n");
605 break;
606 case DEMANGLE_COMPONENT_POINTER:
607 printf ("pointer\n");
608 break;
609 case DEMANGLE_COMPONENT_REFERENCE:
610 printf ("reference\n");
611 break;
612 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
613 printf ("rvalue reference\n");
614 break;
615 case DEMANGLE_COMPONENT_COMPLEX:
616 printf ("complex\n");
617 break;
618 case DEMANGLE_COMPONENT_IMAGINARY:
619 printf ("imaginary\n");
620 break;
621 case DEMANGLE_COMPONENT_VENDOR_TYPE:
622 printf ("vendor type\n");
623 break;
624 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
625 printf ("function type\n");
626 break;
627 case DEMANGLE_COMPONENT_ARRAY_TYPE:
628 printf ("array type\n");
629 break;
630 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
631 printf ("pointer to member type\n");
632 break;
633 case DEMANGLE_COMPONENT_FIXED_TYPE:
634 printf ("fixed-point type\n");
635 break;
636 case DEMANGLE_COMPONENT_ARGLIST:
637 printf ("argument list\n");
638 break;
639 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
640 printf ("template argument list\n");
641 break;
642 case DEMANGLE_COMPONENT_CAST:
643 printf ("cast\n");
644 break;
645 case DEMANGLE_COMPONENT_UNARY:
646 printf ("unary operator\n");
647 break;
648 case DEMANGLE_COMPONENT_BINARY:
649 printf ("binary operator\n");
650 break;
651 case DEMANGLE_COMPONENT_BINARY_ARGS:
652 printf ("binary operator arguments\n");
653 break;
654 case DEMANGLE_COMPONENT_TRINARY:
655 printf ("trinary operator\n");
656 break;
657 case DEMANGLE_COMPONENT_TRINARY_ARG1:
658 printf ("trinary operator arguments 1\n");
659 break;
660 case DEMANGLE_COMPONENT_TRINARY_ARG2:
661 printf ("trinary operator arguments 1\n");
662 break;
663 case DEMANGLE_COMPONENT_LITERAL:
664 printf ("literal\n");
665 break;
666 case DEMANGLE_COMPONENT_LITERAL_NEG:
667 printf ("negative literal\n");
668 break;
669 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
670 printf ("java resource\n");
671 break;
672 case DEMANGLE_COMPONENT_COMPOUND_NAME:
673 printf ("compound name\n");
674 break;
675 case DEMANGLE_COMPONENT_CHARACTER:
676 printf ("character '%c'\n", dc->u.s_character.character);
677 return;
678 case DEMANGLE_COMPONENT_DECLTYPE:
679 printf ("decltype\n");
680 break;
681 case DEMANGLE_COMPONENT_PACK_EXPANSION:
682 printf ("pack expansion\n");
683 break;
684 }
685
686 d_dump (d_left (dc), indent + 2);
687 d_dump (d_right (dc), indent + 2);
688 }
689
690 #endif /* CP_DEMANGLE_DEBUG */
691
692 /* Fill in a DEMANGLE_COMPONENT_NAME. */
693
694 CP_STATIC_IF_GLIBCPP_V3
695 int
cplus_demangle_fill_name(struct demangle_component * p,const char * s,int len)696 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
697 {
698 if (p == NULL || s == NULL || len == 0)
699 return 0;
700 p->type = DEMANGLE_COMPONENT_NAME;
701 p->u.s_name.s = s;
702 p->u.s_name.len = len;
703 return 1;
704 }
705
706 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
707
708 CP_STATIC_IF_GLIBCPP_V3
709 int
cplus_demangle_fill_extended_operator(struct demangle_component * p,int args,struct demangle_component * name)710 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
711 struct demangle_component *name)
712 {
713 if (p == NULL || args < 0 || name == NULL)
714 return 0;
715 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
716 p->u.s_extended_operator.args = args;
717 p->u.s_extended_operator.name = name;
718 return 1;
719 }
720
721 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
722
723 CP_STATIC_IF_GLIBCPP_V3
724 int
cplus_demangle_fill_ctor(struct demangle_component * p,enum gnu_v3_ctor_kinds kind,struct demangle_component * name)725 cplus_demangle_fill_ctor (struct demangle_component *p,
726 enum gnu_v3_ctor_kinds kind,
727 struct demangle_component *name)
728 {
729 if (p == NULL
730 || name == NULL
731 || (int) kind < gnu_v3_complete_object_ctor
732 || (int) kind > gnu_v3_complete_object_allocating_ctor)
733 return 0;
734 p->type = DEMANGLE_COMPONENT_CTOR;
735 p->u.s_ctor.kind = kind;
736 p->u.s_ctor.name = name;
737 return 1;
738 }
739
740 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
741
742 CP_STATIC_IF_GLIBCPP_V3
743 int
cplus_demangle_fill_dtor(struct demangle_component * p,enum gnu_v3_dtor_kinds kind,struct demangle_component * name)744 cplus_demangle_fill_dtor (struct demangle_component *p,
745 enum gnu_v3_dtor_kinds kind,
746 struct demangle_component *name)
747 {
748 if (p == NULL
749 || name == NULL
750 || (int) kind < gnu_v3_deleting_dtor
751 || (int) kind > gnu_v3_base_object_dtor)
752 return 0;
753 p->type = DEMANGLE_COMPONENT_DTOR;
754 p->u.s_dtor.kind = kind;
755 p->u.s_dtor.name = name;
756 return 1;
757 }
758
759 /* Add a new component. */
760
761 static struct demangle_component *
d_make_empty(struct d_info * di)762 d_make_empty (struct d_info *di)
763 {
764 struct demangle_component *p;
765
766 if (di->next_comp >= di->num_comps)
767 return NULL;
768 p = &di->comps[di->next_comp];
769 ++di->next_comp;
770 return p;
771 }
772
773 /* Add a new generic component. */
774
775 static struct demangle_component *
d_make_comp(struct d_info * di,enum demangle_component_type type,struct demangle_component * left,struct demangle_component * right)776 d_make_comp (struct d_info *di, enum demangle_component_type type,
777 struct demangle_component *left,
778 struct demangle_component *right)
779 {
780 struct demangle_component *p;
781
782 /* We check for errors here. A typical error would be a NULL return
783 from a subroutine. We catch those here, and return NULL
784 upward. */
785 switch (type)
786 {
787 /* These types require two parameters. */
788 case DEMANGLE_COMPONENT_QUAL_NAME:
789 case DEMANGLE_COMPONENT_LOCAL_NAME:
790 case DEMANGLE_COMPONENT_TYPED_NAME:
791 case DEMANGLE_COMPONENT_TEMPLATE:
792 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
793 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
794 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
795 case DEMANGLE_COMPONENT_UNARY:
796 case DEMANGLE_COMPONENT_BINARY:
797 case DEMANGLE_COMPONENT_BINARY_ARGS:
798 case DEMANGLE_COMPONENT_TRINARY:
799 case DEMANGLE_COMPONENT_TRINARY_ARG1:
800 case DEMANGLE_COMPONENT_TRINARY_ARG2:
801 case DEMANGLE_COMPONENT_LITERAL:
802 case DEMANGLE_COMPONENT_LITERAL_NEG:
803 case DEMANGLE_COMPONENT_COMPOUND_NAME:
804 case DEMANGLE_COMPONENT_VECTOR_TYPE:
805 if (left == NULL || right == NULL)
806 return NULL;
807 break;
808
809 /* These types only require one parameter. */
810 case DEMANGLE_COMPONENT_VTABLE:
811 case DEMANGLE_COMPONENT_VTT:
812 case DEMANGLE_COMPONENT_TYPEINFO:
813 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
814 case DEMANGLE_COMPONENT_TYPEINFO_FN:
815 case DEMANGLE_COMPONENT_THUNK:
816 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
817 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
818 case DEMANGLE_COMPONENT_JAVA_CLASS:
819 case DEMANGLE_COMPONENT_GUARD:
820 case DEMANGLE_COMPONENT_REFTEMP:
821 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
822 case DEMANGLE_COMPONENT_POINTER:
823 case DEMANGLE_COMPONENT_REFERENCE:
824 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
825 case DEMANGLE_COMPONENT_COMPLEX:
826 case DEMANGLE_COMPONENT_IMAGINARY:
827 case DEMANGLE_COMPONENT_VENDOR_TYPE:
828 case DEMANGLE_COMPONENT_CAST:
829 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
830 case DEMANGLE_COMPONENT_DECLTYPE:
831 case DEMANGLE_COMPONENT_PACK_EXPANSION:
832 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
833 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
834 if (left == NULL)
835 return NULL;
836 break;
837
838 /* This needs a right parameter, but the left parameter can be
839 empty. */
840 case DEMANGLE_COMPONENT_ARRAY_TYPE:
841 if (right == NULL)
842 return NULL;
843 break;
844
845 /* These are allowed to have no parameters--in some cases they
846 will be filled in later. */
847 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
848 case DEMANGLE_COMPONENT_RESTRICT:
849 case DEMANGLE_COMPONENT_VOLATILE:
850 case DEMANGLE_COMPONENT_CONST:
851 case DEMANGLE_COMPONENT_RESTRICT_THIS:
852 case DEMANGLE_COMPONENT_VOLATILE_THIS:
853 case DEMANGLE_COMPONENT_CONST_THIS:
854 case DEMANGLE_COMPONENT_ARGLIST:
855 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
856 break;
857
858 /* Other types should not be seen here. */
859 default:
860 return NULL;
861 }
862
863 p = d_make_empty (di);
864 if (p != NULL)
865 {
866 p->type = type;
867 p->u.s_binary.left = left;
868 p->u.s_binary.right = right;
869 }
870 return p;
871 }
872
873 /* Add a new demangle mangled name component. */
874
875 static struct demangle_component *
d_make_demangle_mangled_name(struct d_info * di,const char * s)876 d_make_demangle_mangled_name (struct d_info *di, const char *s)
877 {
878 if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
879 return d_make_name (di, s, strlen (s));
880 d_advance (di, 2);
881 return d_encoding (di, 0);
882 }
883
884 /* Add a new name component. */
885
886 static struct demangle_component *
d_make_name(struct d_info * di,const char * s,int len)887 d_make_name (struct d_info *di, const char *s, int len)
888 {
889 struct demangle_component *p;
890
891 p = d_make_empty (di);
892 if (! cplus_demangle_fill_name (p, s, len))
893 return NULL;
894 return p;
895 }
896
897 /* Add a new builtin type component. */
898
899 static struct demangle_component *
d_make_builtin_type(struct d_info * di,const struct demangle_builtin_type_info * type)900 d_make_builtin_type (struct d_info *di,
901 const struct demangle_builtin_type_info *type)
902 {
903 struct demangle_component *p;
904
905 if (type == NULL)
906 return NULL;
907 p = d_make_empty (di);
908 if (p != NULL)
909 {
910 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
911 p->u.s_builtin.type = type;
912 }
913 return p;
914 }
915
916 /* Add a new operator component. */
917
918 static struct demangle_component *
d_make_operator(struct d_info * di,const struct demangle_operator_info * op)919 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
920 {
921 struct demangle_component *p;
922
923 p = d_make_empty (di);
924 if (p != NULL)
925 {
926 p->type = DEMANGLE_COMPONENT_OPERATOR;
927 p->u.s_operator.op = op;
928 }
929 return p;
930 }
931
932 /* Add a new extended operator component. */
933
934 static struct demangle_component *
d_make_extended_operator(struct d_info * di,int args,struct demangle_component * name)935 d_make_extended_operator (struct d_info *di, int args,
936 struct demangle_component *name)
937 {
938 struct demangle_component *p;
939
940 p = d_make_empty (di);
941 if (! cplus_demangle_fill_extended_operator (p, args, name))
942 return NULL;
943 return p;
944 }
945
946 static struct demangle_component *
d_make_default_arg(struct d_info * di,int num,struct demangle_component * sub)947 d_make_default_arg (struct d_info *di, int num,
948 struct demangle_component *sub)
949 {
950 struct demangle_component *p = d_make_empty (di);
951 if (p)
952 {
953 p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
954 p->u.s_unary_num.num = num;
955 p->u.s_unary_num.sub = sub;
956 }
957 return p;
958 }
959
960 /* Add a new constructor component. */
961
962 static struct demangle_component *
d_make_ctor(struct d_info * di,enum gnu_v3_ctor_kinds kind,struct demangle_component * name)963 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
964 struct demangle_component *name)
965 {
966 struct demangle_component *p;
967
968 p = d_make_empty (di);
969 if (! cplus_demangle_fill_ctor (p, kind, name))
970 return NULL;
971 return p;
972 }
973
974 /* Add a new destructor component. */
975
976 static struct demangle_component *
d_make_dtor(struct d_info * di,enum gnu_v3_dtor_kinds kind,struct demangle_component * name)977 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
978 struct demangle_component *name)
979 {
980 struct demangle_component *p;
981
982 p = d_make_empty (di);
983 if (! cplus_demangle_fill_dtor (p, kind, name))
984 return NULL;
985 return p;
986 }
987
988 /* Add a new template parameter. */
989
990 static struct demangle_component *
d_make_template_param(struct d_info * di,long i)991 d_make_template_param (struct d_info *di, long i)
992 {
993 struct demangle_component *p;
994
995 p = d_make_empty (di);
996 if (p != NULL)
997 {
998 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
999 p->u.s_number.number = i;
1000 }
1001 return p;
1002 }
1003
1004 /* Add a new function parameter. */
1005
1006 static struct demangle_component *
d_make_function_param(struct d_info * di,long i)1007 d_make_function_param (struct d_info *di, long i)
1008 {
1009 struct demangle_component *p;
1010
1011 p = d_make_empty (di);
1012 if (p != NULL)
1013 {
1014 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1015 p->u.s_number.number = i;
1016 }
1017 return p;
1018 }
1019
1020 /* Add a new standard substitution component. */
1021
1022 static struct demangle_component *
d_make_sub(struct d_info * di,const char * name,int len)1023 d_make_sub (struct d_info *di, const char *name, int len)
1024 {
1025 struct demangle_component *p;
1026
1027 p = d_make_empty (di);
1028 if (p != NULL)
1029 {
1030 p->type = DEMANGLE_COMPONENT_SUB_STD;
1031 p->u.s_string.string = name;
1032 p->u.s_string.len = len;
1033 }
1034 return p;
1035 }
1036
1037 /* <mangled-name> ::= _Z <encoding>
1038
1039 TOP_LEVEL is non-zero when called at the top level. */
1040
1041 CP_STATIC_IF_GLIBCPP_V3
1042 struct demangle_component *
cplus_demangle_mangled_name(struct d_info * di,int top_level)1043 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1044 {
1045 if (! d_check_char (di, '_')
1046 /* Allow missing _ if not at toplevel to work around a
1047 bug in G++ abi-version=2 mangling; see the comment in
1048 write_template_arg. */
1049 && top_level)
1050 return NULL;
1051 if (! d_check_char (di, 'Z'))
1052 return NULL;
1053 return d_encoding (di, top_level);
1054 }
1055
1056 /* Return whether a function should have a return type. The argument
1057 is the function name, which may be qualified in various ways. The
1058 rules are that template functions have return types with some
1059 exceptions, function types which are not part of a function name
1060 mangling have return types with some exceptions, and non-template
1061 function names do not have return types. The exceptions are that
1062 constructors, destructors, and conversion operators do not have
1063 return types. */
1064
1065 static int
has_return_type(struct demangle_component * dc)1066 has_return_type (struct demangle_component *dc)
1067 {
1068 if (dc == NULL)
1069 return 0;
1070 switch (dc->type)
1071 {
1072 default:
1073 return 0;
1074 case DEMANGLE_COMPONENT_TEMPLATE:
1075 return ! is_ctor_dtor_or_conversion (d_left (dc));
1076 case DEMANGLE_COMPONENT_RESTRICT_THIS:
1077 case DEMANGLE_COMPONENT_VOLATILE_THIS:
1078 case DEMANGLE_COMPONENT_CONST_THIS:
1079 return has_return_type (d_left (dc));
1080 }
1081 }
1082
1083 /* Return whether a name is a constructor, a destructor, or a
1084 conversion operator. */
1085
1086 static int
is_ctor_dtor_or_conversion(struct demangle_component * dc)1087 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1088 {
1089 if (dc == NULL)
1090 return 0;
1091 switch (dc->type)
1092 {
1093 default:
1094 return 0;
1095 case DEMANGLE_COMPONENT_QUAL_NAME:
1096 case DEMANGLE_COMPONENT_LOCAL_NAME:
1097 return is_ctor_dtor_or_conversion (d_right (dc));
1098 case DEMANGLE_COMPONENT_CTOR:
1099 case DEMANGLE_COMPONENT_DTOR:
1100 case DEMANGLE_COMPONENT_CAST:
1101 return 1;
1102 }
1103 }
1104
1105 /* <encoding> ::= <(function) name> <bare-function-type>
1106 ::= <(data) name>
1107 ::= <special-name>
1108
1109 TOP_LEVEL is non-zero when called at the top level, in which case
1110 if DMGL_PARAMS is not set we do not demangle the function
1111 parameters. We only set this at the top level, because otherwise
1112 we would not correctly demangle names in local scopes. */
1113
1114 static struct demangle_component *
d_encoding(struct d_info * di,int top_level)1115 d_encoding (struct d_info *di, int top_level)
1116 {
1117 char peek = d_peek_char (di);
1118
1119 if (peek == 'G' || peek == 'T')
1120 return d_special_name (di);
1121 else
1122 {
1123 struct demangle_component *dc;
1124
1125 dc = d_name (di);
1126
1127 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1128 {
1129 /* Strip off any initial CV-qualifiers, as they really apply
1130 to the `this' parameter, and they were not output by the
1131 v2 demangler without DMGL_PARAMS. */
1132 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1133 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1134 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1135 dc = d_left (dc);
1136
1137 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1138 there may be CV-qualifiers on its right argument which
1139 really apply here; this happens when parsing a class
1140 which is local to a function. */
1141 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1142 {
1143 struct demangle_component *dcr;
1144
1145 dcr = d_right (dc);
1146 while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1147 || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1148 || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1149 dcr = d_left (dcr);
1150 dc->u.s_binary.right = dcr;
1151 }
1152
1153 return dc;
1154 }
1155
1156 peek = d_peek_char (di);
1157 if (dc == NULL || peek == '\0' || peek == 'E')
1158 return dc;
1159 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1160 d_bare_function_type (di, has_return_type (dc)));
1161 }
1162 }
1163
1164 /* <name> ::= <nested-name>
1165 ::= <unscoped-name>
1166 ::= <unscoped-template-name> <template-args>
1167 ::= <local-name>
1168
1169 <unscoped-name> ::= <unqualified-name>
1170 ::= St <unqualified-name>
1171
1172 <unscoped-template-name> ::= <unscoped-name>
1173 ::= <substitution>
1174 */
1175
1176 static struct demangle_component *
d_name(struct d_info * di)1177 d_name (struct d_info *di)
1178 {
1179 char peek = d_peek_char (di);
1180 struct demangle_component *dc;
1181
1182 switch (peek)
1183 {
1184 case 'N':
1185 return d_nested_name (di);
1186
1187 case 'Z':
1188 return d_local_name (di);
1189
1190 case 'L':
1191 case 'U':
1192 return d_unqualified_name (di);
1193
1194 case 'S':
1195 {
1196 int subst;
1197
1198 if (d_peek_next_char (di) != 't')
1199 {
1200 dc = d_substitution (di, 0);
1201 subst = 1;
1202 }
1203 else
1204 {
1205 d_advance (di, 2);
1206 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1207 d_make_name (di, "std", 3),
1208 d_unqualified_name (di));
1209 di->expansion += 3;
1210 subst = 0;
1211 }
1212
1213 if (d_peek_char (di) != 'I')
1214 {
1215 /* The grammar does not permit this case to occur if we
1216 called d_substitution() above (i.e., subst == 1). We
1217 don't bother to check. */
1218 }
1219 else
1220 {
1221 /* This is <template-args>, which means that we just saw
1222 <unscoped-template-name>, which is a substitution
1223 candidate if we didn't just get it from a
1224 substitution. */
1225 if (! subst)
1226 {
1227 if (! d_add_substitution (di, dc))
1228 return NULL;
1229 }
1230 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1231 d_template_args (di));
1232 }
1233
1234 return dc;
1235 }
1236
1237 default:
1238 dc = d_unqualified_name (di);
1239 if (d_peek_char (di) == 'I')
1240 {
1241 /* This is <template-args>, which means that we just saw
1242 <unscoped-template-name>, which is a substitution
1243 candidate. */
1244 if (! d_add_substitution (di, dc))
1245 return NULL;
1246 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1247 d_template_args (di));
1248 }
1249 return dc;
1250 }
1251 }
1252
1253 /* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1254 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1255 */
1256
1257 static struct demangle_component *
d_nested_name(struct d_info * di)1258 d_nested_name (struct d_info *di)
1259 {
1260 struct demangle_component *ret;
1261 struct demangle_component **pret;
1262
1263 if (! d_check_char (di, 'N'))
1264 return NULL;
1265
1266 pret = d_cv_qualifiers (di, &ret, 1);
1267 if (pret == NULL)
1268 return NULL;
1269
1270 *pret = d_prefix (di);
1271 if (*pret == NULL)
1272 return NULL;
1273
1274 if (! d_check_char (di, 'E'))
1275 return NULL;
1276
1277 return ret;
1278 }
1279
1280 /* <prefix> ::= <prefix> <unqualified-name>
1281 ::= <template-prefix> <template-args>
1282 ::= <template-param>
1283 ::=
1284 ::= <substitution>
1285
1286 <template-prefix> ::= <prefix> <(template) unqualified-name>
1287 ::= <template-param>
1288 ::= <substitution>
1289 */
1290
1291 static struct demangle_component *
d_prefix(struct d_info * di)1292 d_prefix (struct d_info *di)
1293 {
1294 struct demangle_component *ret = NULL;
1295
1296 while (1)
1297 {
1298 char peek;
1299 enum demangle_component_type comb_type;
1300 struct demangle_component *dc;
1301
1302 peek = d_peek_char (di);
1303 if (peek == '\0')
1304 return NULL;
1305
1306 /* The older code accepts a <local-name> here, but I don't see
1307 that in the grammar. The older code does not accept a
1308 <template-param> here. */
1309
1310 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1311 if (IS_DIGIT (peek)
1312 || IS_LOWER (peek)
1313 || peek == 'C'
1314 || peek == 'D'
1315 || peek == 'U'
1316 || peek == 'L')
1317 dc = d_unqualified_name (di);
1318 else if (peek == 'S')
1319 dc = d_substitution (di, 1);
1320 else if (peek == 'I')
1321 {
1322 if (ret == NULL)
1323 return NULL;
1324 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1325 dc = d_template_args (di);
1326 }
1327 else if (peek == 'T')
1328 dc = d_template_param (di);
1329 else if (peek == 'E')
1330 return ret;
1331 else if (peek == 'M')
1332 {
1333 /* Initializer scope for a lambda. We don't need to represent
1334 this; the normal code will just treat the variable as a type
1335 scope, which gives appropriate output. */
1336 if (ret == NULL)
1337 return NULL;
1338 d_advance (di, 1);
1339 continue;
1340 }
1341 else
1342 return NULL;
1343
1344 if (ret == NULL)
1345 ret = dc;
1346 else
1347 ret = d_make_comp (di, comb_type, ret, dc);
1348
1349 if (peek != 'S' && d_peek_char (di) != 'E')
1350 {
1351 if (! d_add_substitution (di, ret))
1352 return NULL;
1353 }
1354 }
1355 }
1356
1357 /* <unqualified-name> ::= <operator-name>
1358 ::= <ctor-dtor-name>
1359 ::= <source-name>
1360 ::= <local-source-name>
1361
1362 <local-source-name> ::= L <source-name> <discriminator>
1363 */
1364
1365 static struct demangle_component *
d_unqualified_name(struct d_info * di)1366 d_unqualified_name (struct d_info *di)
1367 {
1368 char peek;
1369
1370 peek = d_peek_char (di);
1371 if (IS_DIGIT (peek))
1372 return d_source_name (di);
1373 else if (IS_LOWER (peek))
1374 {
1375 struct demangle_component *ret;
1376
1377 ret = d_operator_name (di);
1378 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1379 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1380 return ret;
1381 }
1382 else if (peek == 'C' || peek == 'D')
1383 return d_ctor_dtor_name (di);
1384 else if (peek == 'L')
1385 {
1386 struct demangle_component * ret;
1387
1388 d_advance (di, 1);
1389
1390 ret = d_source_name (di);
1391 if (ret == NULL)
1392 return NULL;
1393 if (! d_discriminator (di))
1394 return NULL;
1395 return ret;
1396 }
1397 else if (peek == 'U')
1398 {
1399 switch (d_peek_next_char (di))
1400 {
1401 case 'l':
1402 return d_lambda (di);
1403 case 't':
1404 return d_unnamed_type (di);
1405 default:
1406 return NULL;
1407 }
1408 }
1409 else
1410 return NULL;
1411 }
1412
1413 /* <source-name> ::= <(positive length) number> <identifier> */
1414
1415 static struct demangle_component *
d_source_name(struct d_info * di)1416 d_source_name (struct d_info *di)
1417 {
1418 long len;
1419 struct demangle_component *ret;
1420
1421 len = d_number (di);
1422 if (len <= 0)
1423 return NULL;
1424 ret = d_identifier (di, len);
1425 di->last_name = ret;
1426 return ret;
1427 }
1428
1429 /* number ::= [n] <(non-negative decimal integer)> */
1430
1431 static long
d_number(struct d_info * di)1432 d_number (struct d_info *di)
1433 {
1434 int negative;
1435 char peek;
1436 long ret;
1437
1438 negative = 0;
1439 peek = d_peek_char (di);
1440 if (peek == 'n')
1441 {
1442 negative = 1;
1443 d_advance (di, 1);
1444 peek = d_peek_char (di);
1445 }
1446
1447 ret = 0;
1448 while (1)
1449 {
1450 if (! IS_DIGIT (peek))
1451 {
1452 if (negative)
1453 ret = - ret;
1454 return ret;
1455 }
1456 ret = ret * 10 + peek - '0';
1457 d_advance (di, 1);
1458 peek = d_peek_char (di);
1459 }
1460 }
1461
1462 /* Like d_number, but returns a demangle_component. */
1463
1464 static struct demangle_component *
d_number_component(struct d_info * di)1465 d_number_component (struct d_info *di)
1466 {
1467 struct demangle_component *ret = d_make_empty (di);
1468 if (ret)
1469 {
1470 ret->type = DEMANGLE_COMPONENT_NUMBER;
1471 ret->u.s_number.number = d_number (di);
1472 }
1473 return ret;
1474 }
1475
1476 /* identifier ::= <(unqualified source code identifier)> */
1477
1478 static struct demangle_component *
d_identifier(struct d_info * di,int len)1479 d_identifier (struct d_info *di, int len)
1480 {
1481 const char *name;
1482
1483 name = d_str (di);
1484
1485 if (di->send - name < len)
1486 return NULL;
1487
1488 d_advance (di, len);
1489
1490 /* A Java mangled name may have a trailing '$' if it is a C++
1491 keyword. This '$' is not included in the length count. We just
1492 ignore the '$'. */
1493 if ((di->options & DMGL_JAVA) != 0
1494 && d_peek_char (di) == '$')
1495 d_advance (di, 1);
1496
1497 /* Look for something which looks like a gcc encoding of an
1498 anonymous namespace, and replace it with a more user friendly
1499 name. */
1500 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1501 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1502 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1503 {
1504 const char *s;
1505
1506 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1507 if ((*s == '.' || *s == '_' || *s == '$')
1508 && s[1] == 'N')
1509 {
1510 di->expansion -= len - sizeof "(anonymous namespace)";
1511 return d_make_name (di, "(anonymous namespace)",
1512 sizeof "(anonymous namespace)" - 1);
1513 }
1514 }
1515
1516 return d_make_name (di, name, len);
1517 }
1518
1519 /* operator_name ::= many different two character encodings.
1520 ::= cv <type>
1521 ::= v <digit> <source-name>
1522 */
1523
1524 #define NL(s) s, (sizeof s) - 1
1525
1526 CP_STATIC_IF_GLIBCPP_V3
1527 const struct demangle_operator_info cplus_demangle_operators[] =
1528 {
1529 { "aN", NL ("&="), 2 },
1530 { "aS", NL ("="), 2 },
1531 { "aa", NL ("&&"), 2 },
1532 { "ad", NL ("&"), 1 },
1533 { "an", NL ("&"), 2 },
1534 { "cl", NL ("()"), 2 },
1535 { "cm", NL (","), 2 },
1536 { "co", NL ("~"), 1 },
1537 { "dV", NL ("/="), 2 },
1538 { "da", NL ("delete[]"), 1 },
1539 { "de", NL ("*"), 1 },
1540 { "dl", NL ("delete"), 1 },
1541 { "dt", NL ("."), 2 },
1542 { "dv", NL ("/"), 2 },
1543 { "eO", NL ("^="), 2 },
1544 { "eo", NL ("^"), 2 },
1545 { "eq", NL ("=="), 2 },
1546 { "ge", NL (">="), 2 },
1547 { "gt", NL (">"), 2 },
1548 { "ix", NL ("[]"), 2 },
1549 { "lS", NL ("<<="), 2 },
1550 { "le", NL ("<="), 2 },
1551 { "ls", NL ("<<"), 2 },
1552 { "lt", NL ("<"), 2 },
1553 { "mI", NL ("-="), 2 },
1554 { "mL", NL ("*="), 2 },
1555 { "mi", NL ("-"), 2 },
1556 { "ml", NL ("*"), 2 },
1557 { "mm", NL ("--"), 1 },
1558 { "na", NL ("new[]"), 1 },
1559 { "ne", NL ("!="), 2 },
1560 { "ng", NL ("-"), 1 },
1561 { "nt", NL ("!"), 1 },
1562 { "nw", NL ("new"), 1 },
1563 { "oR", NL ("|="), 2 },
1564 { "oo", NL ("||"), 2 },
1565 { "or", NL ("|"), 2 },
1566 { "pL", NL ("+="), 2 },
1567 { "pl", NL ("+"), 2 },
1568 { "pm", NL ("->*"), 2 },
1569 { "pp", NL ("++"), 1 },
1570 { "ps", NL ("+"), 1 },
1571 { "pt", NL ("->"), 2 },
1572 { "qu", NL ("?"), 3 },
1573 { "rM", NL ("%="), 2 },
1574 { "rS", NL (">>="), 2 },
1575 { "rm", NL ("%"), 2 },
1576 { "rs", NL (">>"), 2 },
1577 { "st", NL ("sizeof "), 1 },
1578 { "sz", NL ("sizeof "), 1 },
1579 { "at", NL ("alignof "), 1 },
1580 { "az", NL ("alignof "), 1 },
1581 { NULL, NULL, 0, 0 }
1582 };
1583
1584 static struct demangle_component *
d_operator_name(struct d_info * di)1585 d_operator_name (struct d_info *di)
1586 {
1587 char c1;
1588 char c2;
1589
1590 c1 = d_next_char (di);
1591 c2 = d_next_char (di);
1592 if (c1 == 'v' && IS_DIGIT (c2))
1593 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1594 else if (c1 == 'c' && c2 == 'v')
1595 return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1596 cplus_demangle_type (di), NULL);
1597 else
1598 {
1599 /* LOW is the inclusive lower bound. */
1600 int low = 0;
1601 /* HIGH is the exclusive upper bound. We subtract one to ignore
1602 the sentinel at the end of the array. */
1603 int high = ((sizeof (cplus_demangle_operators)
1604 / sizeof (cplus_demangle_operators[0]))
1605 - 1);
1606
1607 while (1)
1608 {
1609 int i;
1610 const struct demangle_operator_info *p;
1611
1612 i = low + (high - low) / 2;
1613 p = cplus_demangle_operators + i;
1614
1615 if (c1 == p->code[0] && c2 == p->code[1])
1616 return d_make_operator (di, p);
1617
1618 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1619 high = i;
1620 else
1621 low = i + 1;
1622 if (low == high)
1623 return NULL;
1624 }
1625 }
1626 }
1627
1628 static struct demangle_component *
d_make_character(struct d_info * di,int c)1629 d_make_character (struct d_info *di, int c)
1630 {
1631 struct demangle_component *p;
1632 p = d_make_empty (di);
1633 if (p != NULL)
1634 {
1635 p->type = DEMANGLE_COMPONENT_CHARACTER;
1636 p->u.s_character.character = c;
1637 }
1638 return p;
1639 }
1640
1641 static struct demangle_component *
d_java_resource(struct d_info * di)1642 d_java_resource (struct d_info *di)
1643 {
1644 struct demangle_component *p = NULL;
1645 struct demangle_component *next = NULL;
1646 long len, i;
1647 char c;
1648 const char *str;
1649
1650 len = d_number (di);
1651 if (len <= 1)
1652 return NULL;
1653
1654 /* Eat the leading '_'. */
1655 if (d_next_char (di) != '_')
1656 return NULL;
1657 len--;
1658
1659 str = d_str (di);
1660 i = 0;
1661
1662 while (len > 0)
1663 {
1664 c = str[i];
1665 if (!c)
1666 return NULL;
1667
1668 /* Each chunk is either a '$' escape... */
1669 if (c == '$')
1670 {
1671 i++;
1672 switch (str[i++])
1673 {
1674 case 'S':
1675 c = '/';
1676 break;
1677 case '_':
1678 c = '.';
1679 break;
1680 case '$':
1681 c = '$';
1682 break;
1683 default:
1684 return NULL;
1685 }
1686 next = d_make_character (di, c);
1687 d_advance (di, i);
1688 str = d_str (di);
1689 len -= i;
1690 i = 0;
1691 if (next == NULL)
1692 return NULL;
1693 }
1694 /* ... or a sequence of characters. */
1695 else
1696 {
1697 while (i < len && str[i] && str[i] != '$')
1698 i++;
1699
1700 next = d_make_name (di, str, i);
1701 d_advance (di, i);
1702 str = d_str (di);
1703 len -= i;
1704 i = 0;
1705 if (next == NULL)
1706 return NULL;
1707 }
1708
1709 if (p == NULL)
1710 p = next;
1711 else
1712 {
1713 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1714 if (p == NULL)
1715 return NULL;
1716 }
1717 }
1718
1719 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1720
1721 return p;
1722 }
1723
1724 /* <special-name> ::= TV <type>
1725 ::= TT <type>
1726 ::= TI <type>
1727 ::= TS <type>
1728 ::= GV <(object) name>
1729 ::= T <call-offset> <(base) encoding>
1730 ::= Tc <call-offset> <call-offset> <(base) encoding>
1731 Also g++ extensions:
1732 ::= TC <type> <(offset) number> _ <(base) type>
1733 ::= TF <type>
1734 ::= TJ <type>
1735 ::= GR <name>
1736 ::= GA <encoding>
1737 ::= Gr <resource name>
1738 */
1739
1740 static struct demangle_component *
d_special_name(struct d_info * di)1741 d_special_name (struct d_info *di)
1742 {
1743 di->expansion += 20;
1744 if (d_check_char (di, 'T'))
1745 {
1746 switch (d_next_char (di))
1747 {
1748 case 'V':
1749 di->expansion -= 5;
1750 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1751 cplus_demangle_type (di), NULL);
1752 case 'T':
1753 di->expansion -= 10;
1754 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1755 cplus_demangle_type (di), NULL);
1756 case 'I':
1757 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1758 cplus_demangle_type (di), NULL);
1759 case 'S':
1760 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1761 cplus_demangle_type (di), NULL);
1762
1763 case 'h':
1764 if (! d_call_offset (di, 'h'))
1765 return NULL;
1766 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1767 d_encoding (di, 0), NULL);
1768
1769 case 'v':
1770 if (! d_call_offset (di, 'v'))
1771 return NULL;
1772 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1773 d_encoding (di, 0), NULL);
1774
1775 case 'c':
1776 if (! d_call_offset (di, '\0'))
1777 return NULL;
1778 if (! d_call_offset (di, '\0'))
1779 return NULL;
1780 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1781 d_encoding (di, 0), NULL);
1782
1783 case 'C':
1784 {
1785 struct demangle_component *derived_type;
1786 long offset;
1787 struct demangle_component *base_type;
1788
1789 derived_type = cplus_demangle_type (di);
1790 offset = d_number (di);
1791 if (offset < 0)
1792 return NULL;
1793 if (! d_check_char (di, '_'))
1794 return NULL;
1795 base_type = cplus_demangle_type (di);
1796 /* We don't display the offset. FIXME: We should display
1797 it in verbose mode. */
1798 di->expansion += 5;
1799 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1800 base_type, derived_type);
1801 }
1802
1803 case 'F':
1804 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1805 cplus_demangle_type (di), NULL);
1806 case 'J':
1807 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1808 cplus_demangle_type (di), NULL);
1809
1810 default:
1811 return NULL;
1812 }
1813 }
1814 else if (d_check_char (di, 'G'))
1815 {
1816 switch (d_next_char (di))
1817 {
1818 case 'V':
1819 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1820
1821 case 'R':
1822 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1823 NULL);
1824
1825 case 'A':
1826 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1827 d_encoding (di, 0), NULL);
1828
1829 case 'r':
1830 return d_java_resource (di);
1831
1832 default:
1833 return NULL;
1834 }
1835 }
1836 else
1837 return NULL;
1838 }
1839
1840 /* <call-offset> ::= h <nv-offset> _
1841 ::= v <v-offset> _
1842
1843 <nv-offset> ::= <(offset) number>
1844
1845 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1846
1847 The C parameter, if not '\0', is a character we just read which is
1848 the start of the <call-offset>.
1849
1850 We don't display the offset information anywhere. FIXME: We should
1851 display it in verbose mode. */
1852
1853 static int
d_call_offset(struct d_info * di,int c)1854 d_call_offset (struct d_info *di, int c)
1855 {
1856 if (c == '\0')
1857 c = d_next_char (di);
1858
1859 if (c == 'h')
1860 d_number (di);
1861 else if (c == 'v')
1862 {
1863 d_number (di);
1864 if (! d_check_char (di, '_'))
1865 return 0;
1866 d_number (di);
1867 }
1868 else
1869 return 0;
1870
1871 if (! d_check_char (di, '_'))
1872 return 0;
1873
1874 return 1;
1875 }
1876
1877 /* <ctor-dtor-name> ::= C1
1878 ::= C2
1879 ::= C3
1880 ::= D0
1881 ::= D1
1882 ::= D2
1883 */
1884
1885 static struct demangle_component *
d_ctor_dtor_name(struct d_info * di)1886 d_ctor_dtor_name (struct d_info *di)
1887 {
1888 if (di->last_name != NULL)
1889 {
1890 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
1891 di->expansion += di->last_name->u.s_name.len;
1892 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
1893 di->expansion += di->last_name->u.s_string.len;
1894 }
1895 switch (d_peek_char (di))
1896 {
1897 case 'C':
1898 {
1899 enum gnu_v3_ctor_kinds kind;
1900
1901 switch (d_peek_next_char (di))
1902 {
1903 case '1':
1904 kind = gnu_v3_complete_object_ctor;
1905 break;
1906 case '2':
1907 kind = gnu_v3_base_object_ctor;
1908 break;
1909 case '3':
1910 kind = gnu_v3_complete_object_allocating_ctor;
1911 break;
1912 default:
1913 return NULL;
1914 }
1915 d_advance (di, 2);
1916 return d_make_ctor (di, kind, di->last_name);
1917 }
1918
1919 case 'D':
1920 {
1921 enum gnu_v3_dtor_kinds kind;
1922
1923 switch (d_peek_next_char (di))
1924 {
1925 case '0':
1926 kind = gnu_v3_deleting_dtor;
1927 break;
1928 case '1':
1929 kind = gnu_v3_complete_object_dtor;
1930 break;
1931 case '2':
1932 kind = gnu_v3_base_object_dtor;
1933 break;
1934 default:
1935 return NULL;
1936 }
1937 d_advance (di, 2);
1938 return d_make_dtor (di, kind, di->last_name);
1939 }
1940
1941 default:
1942 return NULL;
1943 }
1944 }
1945
1946 /* <type> ::= <builtin-type>
1947 ::= <function-type>
1948 ::= <class-enum-type>
1949 ::= <array-type>
1950 ::= <pointer-to-member-type>
1951 ::= <template-param>
1952 ::= <template-template-param> <template-args>
1953 ::= <substitution>
1954 ::= <CV-qualifiers> <type>
1955 ::= P <type>
1956 ::= R <type>
1957 ::= O <type> (C++0x)
1958 ::= C <type>
1959 ::= G <type>
1960 ::= U <source-name> <type>
1961
1962 <builtin-type> ::= various one letter codes
1963 ::= u <source-name>
1964 */
1965
1966 CP_STATIC_IF_GLIBCPP_V3
1967 const struct demangle_builtin_type_info
1968 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1969 {
1970 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
1971 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
1972 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
1973 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
1974 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
1975 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
1976 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
1977 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
1978 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
1979 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
1980 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1981 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
1982 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
1983 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
1984 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1985 D_PRINT_DEFAULT },
1986 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1987 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1988 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1989 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
1990 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1991 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
1992 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
1993 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
1994 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
1995 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1996 D_PRINT_UNSIGNED_LONG_LONG },
1997 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
1998 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
1999 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2000 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2001 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2002 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2003 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2004 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2005 D_PRINT_DEFAULT },
2006 };
2007
2008 CP_STATIC_IF_GLIBCPP_V3
2009 struct demangle_component *
cplus_demangle_type(struct d_info * di)2010 cplus_demangle_type (struct d_info *di)
2011 {
2012 char peek;
2013 struct demangle_component *ret;
2014 int can_subst;
2015
2016 /* The ABI specifies that when CV-qualifiers are used, the base type
2017 is substitutable, and the fully qualified type is substitutable,
2018 but the base type with a strict subset of the CV-qualifiers is
2019 not substitutable. The natural recursive implementation of the
2020 CV-qualifiers would cause subsets to be substitutable, so instead
2021 we pull them all off now.
2022
2023 FIXME: The ABI says that order-insensitive vendor qualifiers
2024 should be handled in the same way, but we have no way to tell
2025 which vendor qualifiers are order-insensitive and which are
2026 order-sensitive. So we just assume that they are all
2027 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2028 __vector, and it treats it as order-sensitive when mangling
2029 names. */
2030
2031 peek = d_peek_char (di);
2032 if (peek == 'r' || peek == 'V' || peek == 'K')
2033 {
2034 struct demangle_component **pret;
2035
2036 pret = d_cv_qualifiers (di, &ret, 0);
2037 if (pret == NULL)
2038 return NULL;
2039 *pret = cplus_demangle_type (di);
2040 if (! *pret || ! d_add_substitution (di, ret))
2041 return NULL;
2042 return ret;
2043 }
2044
2045 can_subst = 1;
2046
2047 switch (peek)
2048 {
2049 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2050 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2051 case 'o': case 's': case 't':
2052 case 'v': case 'w': case 'x': case 'y': case 'z':
2053 ret = d_make_builtin_type (di,
2054 &cplus_demangle_builtin_types[peek - 'a']);
2055 di->expansion += ret->u.s_builtin.type->len;
2056 can_subst = 0;
2057 d_advance (di, 1);
2058 break;
2059
2060 case 'u':
2061 d_advance (di, 1);
2062 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2063 d_source_name (di), NULL);
2064 break;
2065
2066 case 'F':
2067 ret = d_function_type (di);
2068 break;
2069
2070 case '0': case '1': case '2': case '3': case '4':
2071 case '5': case '6': case '7': case '8': case '9':
2072 case 'N':
2073 case 'Z':
2074 ret = d_class_enum_type (di);
2075 break;
2076
2077 case 'A':
2078 ret = d_array_type (di);
2079 break;
2080
2081 case 'M':
2082 ret = d_pointer_to_member_type (di);
2083 break;
2084
2085 case 'T':
2086 ret = d_template_param (di);
2087 if (d_peek_char (di) == 'I')
2088 {
2089 /* This is <template-template-param> <template-args>. The
2090 <template-template-param> part is a substitution
2091 candidate. */
2092 if (! d_add_substitution (di, ret))
2093 return NULL;
2094 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2095 d_template_args (di));
2096 }
2097 break;
2098
2099 case 'S':
2100 /* If this is a special substitution, then it is the start of
2101 <class-enum-type>. */
2102 {
2103 char peek_next;
2104
2105 peek_next = d_peek_next_char (di);
2106 if (IS_DIGIT (peek_next)
2107 || peek_next == '_'
2108 || IS_UPPER (peek_next))
2109 {
2110 ret = d_substitution (di, 0);
2111 /* The substituted name may have been a template name and
2112 may be followed by tepmlate args. */
2113 if (d_peek_char (di) == 'I')
2114 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2115 d_template_args (di));
2116 else
2117 can_subst = 0;
2118 }
2119 else
2120 {
2121 ret = d_class_enum_type (di);
2122 /* If the substitution was a complete type, then it is not
2123 a new substitution candidate. However, if the
2124 substitution was followed by template arguments, then
2125 the whole thing is a substitution candidate. */
2126 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2127 can_subst = 0;
2128 }
2129 }
2130 break;
2131
2132 case 'O':
2133 d_advance (di, 1);
2134 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2135 cplus_demangle_type (di), NULL);
2136 break;
2137
2138 case 'P':
2139 d_advance (di, 1);
2140 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2141 cplus_demangle_type (di), NULL);
2142 break;
2143
2144 case 'R':
2145 d_advance (di, 1);
2146 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2147 cplus_demangle_type (di), NULL);
2148 break;
2149
2150 case 'C':
2151 d_advance (di, 1);
2152 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2153 cplus_demangle_type (di), NULL);
2154 break;
2155
2156 case 'G':
2157 d_advance (di, 1);
2158 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2159 cplus_demangle_type (di), NULL);
2160 break;
2161
2162 case 'U':
2163 d_advance (di, 1);
2164 ret = d_source_name (di);
2165 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2166 cplus_demangle_type (di), ret);
2167 break;
2168
2169 case 'D':
2170 can_subst = 0;
2171 d_advance (di, 1);
2172 peek = d_next_char (di);
2173 switch (peek)
2174 {
2175 case 'T':
2176 case 't':
2177 /* decltype (expression) */
2178 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2179 d_expression (di), NULL);
2180 if (ret && d_next_char (di) != 'E')
2181 ret = NULL;
2182 break;
2183
2184 case 'p':
2185 /* Pack expansion. */
2186 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2187 cplus_demangle_type (di), NULL);
2188 break;
2189
2190 case 'f':
2191 /* 32-bit decimal floating point */
2192 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2193 di->expansion += ret->u.s_builtin.type->len;
2194 break;
2195 case 'd':
2196 /* 64-bit DFP */
2197 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2198 di->expansion += ret->u.s_builtin.type->len;
2199 break;
2200 case 'e':
2201 /* 128-bit DFP */
2202 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2203 di->expansion += ret->u.s_builtin.type->len;
2204 break;
2205 case 'h':
2206 /* 16-bit half-precision FP */
2207 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2208 di->expansion += ret->u.s_builtin.type->len;
2209 break;
2210 case 's':
2211 /* char16_t */
2212 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2213 di->expansion += ret->u.s_builtin.type->len;
2214 break;
2215 case 'i':
2216 /* char32_t */
2217 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2218 di->expansion += ret->u.s_builtin.type->len;
2219 break;
2220
2221 case 'F':
2222 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2223 ret = d_make_empty (di);
2224 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2225 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2226 /* For demangling we don't care about the bits. */
2227 d_number (di);
2228 ret->u.s_fixed.length = cplus_demangle_type (di);
2229 if (ret->u.s_fixed.length == NULL)
2230 return NULL;
2231 d_number (di);
2232 peek = d_next_char (di);
2233 ret->u.s_fixed.sat = (peek == 's');
2234 break;
2235
2236 case 'v':
2237 ret = d_vector_type (di);
2238 break;
2239
2240 case 'n':
2241 /* decltype(nullptr) */
2242 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2243 di->expansion += ret->u.s_builtin.type->len;
2244 break;
2245
2246 default:
2247 return NULL;
2248 }
2249 break;
2250
2251 default:
2252 return NULL;
2253 }
2254
2255 if (can_subst)
2256 {
2257 if (! d_add_substitution (di, ret))
2258 return NULL;
2259 }
2260
2261 return ret;
2262 }
2263
2264 /* <CV-qualifiers> ::= [r] [V] [K] */
2265
2266 static struct demangle_component **
d_cv_qualifiers(struct d_info * di,struct demangle_component ** pret,int member_fn)2267 d_cv_qualifiers (struct d_info *di,
2268 struct demangle_component **pret, int member_fn)
2269 {
2270 char peek;
2271
2272 peek = d_peek_char (di);
2273 while (peek == 'r' || peek == 'V' || peek == 'K')
2274 {
2275 enum demangle_component_type t;
2276
2277 d_advance (di, 1);
2278 if (peek == 'r')
2279 {
2280 t = (member_fn
2281 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2282 : DEMANGLE_COMPONENT_RESTRICT);
2283 di->expansion += sizeof "restrict";
2284 }
2285 else if (peek == 'V')
2286 {
2287 t = (member_fn
2288 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2289 : DEMANGLE_COMPONENT_VOLATILE);
2290 di->expansion += sizeof "volatile";
2291 }
2292 else
2293 {
2294 t = (member_fn
2295 ? DEMANGLE_COMPONENT_CONST_THIS
2296 : DEMANGLE_COMPONENT_CONST);
2297 di->expansion += sizeof "const";
2298 }
2299
2300 *pret = d_make_comp (di, t, NULL, NULL);
2301 if (*pret == NULL)
2302 return NULL;
2303 pret = &d_left (*pret);
2304
2305 peek = d_peek_char (di);
2306 }
2307
2308 return pret;
2309 }
2310
2311 /* <function-type> ::= F [Y] <bare-function-type> E */
2312
2313 static struct demangle_component *
d_function_type(struct d_info * di)2314 d_function_type (struct d_info *di)
2315 {
2316 struct demangle_component *ret;
2317
2318 if (! d_check_char (di, 'F'))
2319 return NULL;
2320 if (d_peek_char (di) == 'Y')
2321 {
2322 /* Function has C linkage. We don't print this information.
2323 FIXME: We should print it in verbose mode. */
2324 d_advance (di, 1);
2325 }
2326 ret = d_bare_function_type (di, 1);
2327 if (! d_check_char (di, 'E'))
2328 return NULL;
2329 return ret;
2330 }
2331
2332 /* <type>+ */
2333
2334 static struct demangle_component *
d_parmlist(struct d_info * di)2335 d_parmlist (struct d_info *di)
2336 {
2337 struct demangle_component *tl;
2338 struct demangle_component **ptl;
2339
2340 tl = NULL;
2341 ptl = &tl;
2342 while (1)
2343 {
2344 struct demangle_component *type;
2345
2346 char peek = d_peek_char (di);
2347 if (peek == '\0' || peek == 'E')
2348 break;
2349 type = cplus_demangle_type (di);
2350 if (type == NULL)
2351 return NULL;
2352 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2353 if (*ptl == NULL)
2354 return NULL;
2355 ptl = &d_right (*ptl);
2356 }
2357
2358 /* There should be at least one parameter type besides the optional
2359 return type. A function which takes no arguments will have a
2360 single parameter type void. */
2361 if (tl == NULL)
2362 return NULL;
2363
2364 /* If we have a single parameter type void, omit it. */
2365 if (d_right (tl) == NULL
2366 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2367 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2368 {
2369 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2370 d_left (tl) = NULL;
2371 }
2372
2373 return tl;
2374 }
2375
2376 /* <bare-function-type> ::= [J]<type>+ */
2377
2378 static struct demangle_component *
d_bare_function_type(struct d_info * di,int has_return_type)2379 d_bare_function_type (struct d_info *di, int has_return_type)
2380 {
2381 struct demangle_component *return_type;
2382 struct demangle_component *tl;
2383 char peek;
2384
2385 /* Detect special qualifier indicating that the first argument
2386 is the return type. */
2387 peek = d_peek_char (di);
2388 if (peek == 'J')
2389 {
2390 d_advance (di, 1);
2391 has_return_type = 1;
2392 }
2393
2394 if (has_return_type)
2395 {
2396 return_type = cplus_demangle_type (di);
2397 if (return_type == NULL)
2398 return NULL;
2399 }
2400 else
2401 return_type = NULL;
2402
2403 tl = d_parmlist (di);
2404 if (tl == NULL)
2405 return NULL;
2406
2407 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2408 return_type, tl);
2409 }
2410
2411 /* <class-enum-type> ::= <name> */
2412
2413 static struct demangle_component *
d_class_enum_type(struct d_info * di)2414 d_class_enum_type (struct d_info *di)
2415 {
2416 return d_name (di);
2417 }
2418
2419 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2420 ::= A [<(dimension) expression>] _ <(element) type>
2421 */
2422
2423 static struct demangle_component *
d_array_type(struct d_info * di)2424 d_array_type (struct d_info *di)
2425 {
2426 char peek;
2427 struct demangle_component *dim;
2428
2429 if (! d_check_char (di, 'A'))
2430 return NULL;
2431
2432 peek = d_peek_char (di);
2433 if (peek == '_')
2434 dim = NULL;
2435 else if (IS_DIGIT (peek))
2436 {
2437 const char *s;
2438
2439 s = d_str (di);
2440 do
2441 {
2442 d_advance (di, 1);
2443 peek = d_peek_char (di);
2444 }
2445 while (IS_DIGIT (peek));
2446 dim = d_make_name (di, s, d_str (di) - s);
2447 if (dim == NULL)
2448 return NULL;
2449 }
2450 else
2451 {
2452 dim = d_expression (di);
2453 if (dim == NULL)
2454 return NULL;
2455 }
2456
2457 if (! d_check_char (di, '_'))
2458 return NULL;
2459
2460 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2461 cplus_demangle_type (di));
2462 }
2463
2464 /* <vector-type> ::= Dv <number> _ <type>
2465 ::= Dv _ <expression> _ <type> */
2466
2467 static struct demangle_component *
d_vector_type(struct d_info * di)2468 d_vector_type (struct d_info *di)
2469 {
2470 char peek;
2471 struct demangle_component *dim;
2472
2473 peek = d_peek_char (di);
2474 if (peek == '_')
2475 {
2476 d_advance (di, 1);
2477 dim = d_expression (di);
2478 }
2479 else
2480 dim = d_number_component (di);
2481
2482 if (dim == NULL)
2483 return NULL;
2484
2485 if (! d_check_char (di, '_'))
2486 return NULL;
2487
2488 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
2489 cplus_demangle_type (di));
2490 }
2491
2492 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
2493
2494 static struct demangle_component *
d_pointer_to_member_type(struct d_info * di)2495 d_pointer_to_member_type (struct d_info *di)
2496 {
2497 struct demangle_component *cl;
2498 struct demangle_component *mem;
2499 struct demangle_component **pmem;
2500
2501 if (! d_check_char (di, 'M'))
2502 return NULL;
2503
2504 cl = cplus_demangle_type (di);
2505
2506 /* The ABI specifies that any type can be a substitution source, and
2507 that M is followed by two types, and that when a CV-qualified
2508 type is seen both the base type and the CV-qualified types are
2509 substitution sources. The ABI also specifies that for a pointer
2510 to a CV-qualified member function, the qualifiers are attached to
2511 the second type. Given the grammar, a plain reading of the ABI
2512 suggests that both the CV-qualified member function and the
2513 non-qualified member function are substitution sources. However,
2514 g++ does not work that way. g++ treats only the CV-qualified
2515 member function as a substitution source. FIXME. So to work
2516 with g++, we need to pull off the CV-qualifiers here, in order to
2517 avoid calling add_substitution() in cplus_demangle_type(). But
2518 for a CV-qualified member which is not a function, g++ does
2519 follow the ABI, so we need to handle that case here by calling
2520 d_add_substitution ourselves. */
2521
2522 pmem = d_cv_qualifiers (di, &mem, 1);
2523 if (pmem == NULL)
2524 return NULL;
2525 *pmem = cplus_demangle_type (di);
2526 if (*pmem == NULL)
2527 return NULL;
2528
2529 if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2530 {
2531 if (! d_add_substitution (di, mem))
2532 return NULL;
2533 }
2534
2535 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2536 }
2537
2538 /* <non-negative number> _ */
2539
2540 static long
d_compact_number(struct d_info * di)2541 d_compact_number (struct d_info *di)
2542 {
2543 long num;
2544 if (d_peek_char (di) == '_')
2545 num = 0;
2546 else if (d_peek_char (di) == 'n')
2547 return -1;
2548 else
2549 num = d_number (di) + 1;
2550
2551 if (! d_check_char (di, '_'))
2552 return -1;
2553 return num;
2554 }
2555
2556 /* <template-param> ::= T_
2557 ::= T <(parameter-2 non-negative) number> _
2558 */
2559
2560 static struct demangle_component *
d_template_param(struct d_info * di)2561 d_template_param (struct d_info *di)
2562 {
2563 long param;
2564
2565 if (! d_check_char (di, 'T'))
2566 return NULL;
2567
2568 param = d_compact_number (di);
2569 if (param < 0)
2570 return NULL;
2571
2572 ++di->did_subs;
2573
2574 return d_make_template_param (di, param);
2575 }
2576
2577 /* <template-args> ::= I <template-arg>+ E */
2578
2579 static struct demangle_component *
d_template_args(struct d_info * di)2580 d_template_args (struct d_info *di)
2581 {
2582 struct demangle_component *hold_last_name;
2583 struct demangle_component *al;
2584 struct demangle_component **pal;
2585
2586 /* Preserve the last name we saw--don't let the template arguments
2587 clobber it, as that would give us the wrong name for a subsequent
2588 constructor or destructor. */
2589 hold_last_name = di->last_name;
2590
2591 if (! d_check_char (di, 'I'))
2592 return NULL;
2593
2594 if (d_peek_char (di) == 'E')
2595 {
2596 /* An argument pack can be empty. */
2597 d_advance (di, 1);
2598 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
2599 }
2600
2601 al = NULL;
2602 pal = &al;
2603 while (1)
2604 {
2605 struct demangle_component *a;
2606
2607 a = d_template_arg (di);
2608 if (a == NULL)
2609 return NULL;
2610
2611 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2612 if (*pal == NULL)
2613 return NULL;
2614 pal = &d_right (*pal);
2615
2616 if (d_peek_char (di) == 'E')
2617 {
2618 d_advance (di, 1);
2619 break;
2620 }
2621 }
2622
2623 di->last_name = hold_last_name;
2624
2625 return al;
2626 }
2627
2628 /* <template-arg> ::= <type>
2629 ::= X <expression> E
2630 ::= <expr-primary>
2631 */
2632
2633 static struct demangle_component *
d_template_arg(struct d_info * di)2634 d_template_arg (struct d_info *di)
2635 {
2636 struct demangle_component *ret;
2637
2638 switch (d_peek_char (di))
2639 {
2640 case 'X':
2641 d_advance (di, 1);
2642 ret = d_expression (di);
2643 if (! d_check_char (di, 'E'))
2644 return NULL;
2645 return ret;
2646
2647 case 'L':
2648 return d_expr_primary (di);
2649
2650 case 'I':
2651 /* An argument pack. */
2652 return d_template_args (di);
2653
2654 default:
2655 return cplus_demangle_type (di);
2656 }
2657 }
2658
2659 /* Subroutine of <expression> ::= cl <expression>+ E */
2660
2661 static struct demangle_component *
d_exprlist(struct d_info * di)2662 d_exprlist (struct d_info *di)
2663 {
2664 struct demangle_component *list = NULL;
2665 struct demangle_component **p = &list;
2666
2667 if (d_peek_char (di) == 'E')
2668 {
2669 d_advance (di, 1);
2670 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
2671 }
2672
2673 while (1)
2674 {
2675 struct demangle_component *arg = d_expression (di);
2676 if (arg == NULL)
2677 return NULL;
2678
2679 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
2680 if (*p == NULL)
2681 return NULL;
2682 p = &d_right (*p);
2683
2684 if (d_peek_char (di) == 'E')
2685 {
2686 d_advance (di, 1);
2687 break;
2688 }
2689 }
2690
2691 return list;
2692 }
2693
2694 /* <expression> ::= <(unary) operator-name> <expression>
2695 ::= <(binary) operator-name> <expression> <expression>
2696 ::= <(trinary) operator-name> <expression> <expression> <expression>
2697 ::= cl <expression>+ E
2698 ::= st <type>
2699 ::= <template-param>
2700 ::= sr <type> <unqualified-name>
2701 ::= sr <type> <unqualified-name> <template-args>
2702 ::= <expr-primary>
2703 */
2704
2705 static struct demangle_component *
d_expression(struct d_info * di)2706 d_expression (struct d_info *di)
2707 {
2708 char peek;
2709
2710 peek = d_peek_char (di);
2711 if (peek == 'L')
2712 return d_expr_primary (di);
2713 else if (peek == 'T')
2714 return d_template_param (di);
2715 else if (peek == 's' && d_peek_next_char (di) == 'r')
2716 {
2717 struct demangle_component *type;
2718 struct demangle_component *name;
2719
2720 d_advance (di, 2);
2721 type = cplus_demangle_type (di);
2722 name = d_unqualified_name (di);
2723 if (d_peek_char (di) != 'I')
2724 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2725 else
2726 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2727 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2728 d_template_args (di)));
2729 }
2730 else if (peek == 's' && d_peek_next_char (di) == 'p')
2731 {
2732 d_advance (di, 2);
2733 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2734 d_expression (di), NULL);
2735 }
2736 else if (peek == 'f' && d_peek_next_char (di) == 'p')
2737 {
2738 /* Function parameter used in a late-specified return type. */
2739 int index;
2740 d_advance (di, 2);
2741 index = d_compact_number (di);
2742 if (index < 0)
2743 return NULL;
2744
2745 return d_make_function_param (di, index);
2746 }
2747 else if (IS_DIGIT (peek)
2748 || (peek == 'o' && d_peek_next_char (di) == 'n'))
2749 {
2750 /* We can get an unqualified name as an expression in the case of
2751 a dependent function call, i.e. decltype(f(t)). */
2752 struct demangle_component *name;
2753
2754 if (peek == 'o')
2755 /* operator-function-id, i.e. operator+(t). */
2756 d_advance (di, 2);
2757
2758 name = d_unqualified_name (di);
2759 if (name == NULL)
2760 return NULL;
2761 if (d_peek_char (di) == 'I')
2762 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2763 d_template_args (di));
2764 else
2765 return name;
2766 }
2767 else
2768 {
2769 struct demangle_component *op;
2770 int args;
2771
2772 op = d_operator_name (di);
2773 if (op == NULL)
2774 return NULL;
2775
2776 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2777 di->expansion += op->u.s_operator.op->len - 2;
2778
2779 if (op->type == DEMANGLE_COMPONENT_OPERATOR
2780 && strcmp (op->u.s_operator.op->code, "st") == 0)
2781 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2782 cplus_demangle_type (di));
2783
2784 switch (op->type)
2785 {
2786 default:
2787 return NULL;
2788 case DEMANGLE_COMPONENT_OPERATOR:
2789 args = op->u.s_operator.op->args;
2790 break;
2791 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2792 args = op->u.s_extended_operator.args;
2793 break;
2794 case DEMANGLE_COMPONENT_CAST:
2795 args = 1;
2796 break;
2797 }
2798
2799 switch (args)
2800 {
2801 case 1:
2802 {
2803 struct demangle_component *operand;
2804 if (op->type == DEMANGLE_COMPONENT_CAST
2805 && d_check_char (di, '_'))
2806 operand = d_exprlist (di);
2807 else
2808 operand = d_expression (di);
2809 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2810 operand);
2811 }
2812 case 2:
2813 {
2814 struct demangle_component *left;
2815 struct demangle_component *right;
2816 const char *code = op->u.s_operator.op->code;
2817
2818 left = d_expression (di);
2819 if (!strcmp (code, "cl"))
2820 right = d_exprlist (di);
2821 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
2822 {
2823 right = d_unqualified_name (di);
2824 if (d_peek_char (di) == 'I')
2825 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
2826 right, d_template_args (di));
2827 }
2828 else
2829 right = d_expression (di);
2830
2831 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2832 d_make_comp (di,
2833 DEMANGLE_COMPONENT_BINARY_ARGS,
2834 left, right));
2835 }
2836 case 3:
2837 {
2838 struct demangle_component *first;
2839 struct demangle_component *second;
2840
2841 first = d_expression (di);
2842 second = d_expression (di);
2843 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2844 d_make_comp (di,
2845 DEMANGLE_COMPONENT_TRINARY_ARG1,
2846 first,
2847 d_make_comp (di,
2848 DEMANGLE_COMPONENT_TRINARY_ARG2,
2849 second,
2850 d_expression (di))));
2851 }
2852 default:
2853 return NULL;
2854 }
2855 }
2856 }
2857
2858 /* <expr-primary> ::= L <type> <(value) number> E
2859 ::= L <type> <(value) float> E
2860 ::= L <mangled-name> E
2861 */
2862
2863 static struct demangle_component *
d_expr_primary(struct d_info * di)2864 d_expr_primary (struct d_info *di)
2865 {
2866 struct demangle_component *ret;
2867
2868 if (! d_check_char (di, 'L'))
2869 return NULL;
2870 if (d_peek_char (di) == '_'
2871 /* Workaround for G++ bug; see comment in write_template_arg. */
2872 || d_peek_char (di) == 'Z')
2873 ret = cplus_demangle_mangled_name (di, 0);
2874 else
2875 {
2876 struct demangle_component *type;
2877 enum demangle_component_type t;
2878 const char *s;
2879
2880 type = cplus_demangle_type (di);
2881 if (type == NULL)
2882 return NULL;
2883
2884 /* If we have a type we know how to print, we aren't going to
2885 print the type name itself. */
2886 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2887 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2888 di->expansion -= type->u.s_builtin.type->len;
2889
2890 /* Rather than try to interpret the literal value, we just
2891 collect it as a string. Note that it's possible to have a
2892 floating point literal here. The ABI specifies that the
2893 format of such literals is machine independent. That's fine,
2894 but what's not fine is that versions of g++ up to 3.2 with
2895 -fabi-version=1 used upper case letters in the hex constant,
2896 and dumped out gcc's internal representation. That makes it
2897 hard to tell where the constant ends, and hard to dump the
2898 constant in any readable form anyhow. We don't attempt to
2899 handle these cases. */
2900
2901 t = DEMANGLE_COMPONENT_LITERAL;
2902 if (d_peek_char (di) == 'n')
2903 {
2904 t = DEMANGLE_COMPONENT_LITERAL_NEG;
2905 d_advance (di, 1);
2906 }
2907 s = d_str (di);
2908 while (d_peek_char (di) != 'E')
2909 {
2910 if (d_peek_char (di) == '\0')
2911 return NULL;
2912 d_advance (di, 1);
2913 }
2914 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2915 }
2916 if (! d_check_char (di, 'E'))
2917 return NULL;
2918 return ret;
2919 }
2920
2921 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2922 ::= Z <(function) encoding> E s [<discriminator>]
2923 */
2924
2925 static struct demangle_component *
d_local_name(struct d_info * di)2926 d_local_name (struct d_info *di)
2927 {
2928 struct demangle_component *function;
2929
2930 if (! d_check_char (di, 'Z'))
2931 return NULL;
2932
2933 function = d_encoding (di, 0);
2934
2935 if (! d_check_char (di, 'E'))
2936 return NULL;
2937
2938 if (d_peek_char (di) == 's')
2939 {
2940 d_advance (di, 1);
2941 if (! d_discriminator (di))
2942 return NULL;
2943 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2944 d_make_name (di, "string literal",
2945 sizeof "string literal" - 1));
2946 }
2947 else
2948 {
2949 struct demangle_component *name;
2950 int num = -1;
2951
2952 if (d_peek_char (di) == 'd')
2953 {
2954 /* Default argument scope: d <number> _. */
2955 d_advance (di, 1);
2956 num = d_compact_number (di);
2957 if (num < 0)
2958 return NULL;
2959 }
2960
2961 name = d_name (di);
2962 if (name)
2963 switch (name->type)
2964 {
2965 /* Lambdas and unnamed types have internal discriminators. */
2966 case DEMANGLE_COMPONENT_LAMBDA:
2967 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
2968 break;
2969 default:
2970 if (! d_discriminator (di))
2971 return NULL;
2972 }
2973 if (num >= 0)
2974 name = d_make_default_arg (di, num, name);
2975 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2976 }
2977 }
2978
2979 /* <discriminator> ::= _ <(non-negative) number>
2980
2981 We demangle the discriminator, but we don't print it out. FIXME:
2982 We should print it out in verbose mode. */
2983
2984 static int
d_discriminator(struct d_info * di)2985 d_discriminator (struct d_info *di)
2986 {
2987 long discrim;
2988
2989 if (d_peek_char (di) != '_')
2990 return 1;
2991 d_advance (di, 1);
2992 discrim = d_number (di);
2993 if (discrim < 0)
2994 return 0;
2995 return 1;
2996 }
2997
2998 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
2999
3000 static struct demangle_component *
d_lambda(struct d_info * di)3001 d_lambda (struct d_info *di)
3002 {
3003 struct demangle_component *tl;
3004 struct demangle_component *ret;
3005 int num;
3006
3007 if (! d_check_char (di, 'U'))
3008 return NULL;
3009 if (! d_check_char (di, 'l'))
3010 return NULL;
3011
3012 tl = d_parmlist (di);
3013 if (tl == NULL)
3014 return NULL;
3015
3016 if (! d_check_char (di, 'E'))
3017 return NULL;
3018
3019 num = d_compact_number (di);
3020 if (num < 0)
3021 return NULL;
3022
3023 ret = d_make_empty (di);
3024 if (ret)
3025 {
3026 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3027 ret->u.s_unary_num.sub = tl;
3028 ret->u.s_unary_num.num = num;
3029 }
3030
3031 if (! d_add_substitution (di, ret))
3032 return NULL;
3033
3034 return ret;
3035 }
3036
3037 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3038
3039 static struct demangle_component *
d_unnamed_type(struct d_info * di)3040 d_unnamed_type (struct d_info *di)
3041 {
3042 struct demangle_component *ret;
3043 long num;
3044
3045 if (! d_check_char (di, 'U'))
3046 return NULL;
3047 if (! d_check_char (di, 't'))
3048 return NULL;
3049
3050 num = d_compact_number (di);
3051 if (num < 0)
3052 return NULL;
3053
3054 ret = d_make_empty (di);
3055 if (ret)
3056 {
3057 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3058 ret->u.s_number.number = num;
3059 }
3060
3061 if (! d_add_substitution (di, ret))
3062 return NULL;
3063
3064 return ret;
3065 }
3066
3067 /* Add a new substitution. */
3068
3069 static int
d_add_substitution(struct d_info * di,struct demangle_component * dc)3070 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3071 {
3072 if (dc == NULL)
3073 return 0;
3074 if (di->next_sub >= di->num_subs)
3075 return 0;
3076 di->subs[di->next_sub] = dc;
3077 ++di->next_sub;
3078 return 1;
3079 }
3080
3081 /* <substitution> ::= S <seq-id> _
3082 ::= S_
3083 ::= St
3084 ::= Sa
3085 ::= Sb
3086 ::= Ss
3087 ::= Si
3088 ::= So
3089 ::= Sd
3090
3091 If PREFIX is non-zero, then this type is being used as a prefix in
3092 a qualified name. In this case, for the standard substitutions, we
3093 need to check whether we are being used as a prefix for a
3094 constructor or destructor, and return a full template name.
3095 Otherwise we will get something like std::iostream::~iostream()
3096 which does not correspond particularly well to any function which
3097 actually appears in the source.
3098 */
3099
3100 static const struct d_standard_sub_info standard_subs[] =
3101 {
3102 { 't', NL ("std"),
3103 NL ("std"),
3104 NULL, 0 },
3105 { 'a', NL ("std::allocator"),
3106 NL ("std::allocator"),
3107 NL ("allocator") },
3108 { 'b', NL ("std::basic_string"),
3109 NL ("std::basic_string"),
3110 NL ("basic_string") },
3111 { 's', NL ("std::string"),
3112 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3113 NL ("basic_string") },
3114 { 'i', NL ("std::istream"),
3115 NL ("std::basic_istream<char, std::char_traits<char> >"),
3116 NL ("basic_istream") },
3117 { 'o', NL ("std::ostream"),
3118 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3119 NL ("basic_ostream") },
3120 { 'd', NL ("std::iostream"),
3121 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3122 NL ("basic_iostream") }
3123 };
3124
3125 static struct demangle_component *
d_substitution(struct d_info * di,int prefix)3126 d_substitution (struct d_info *di, int prefix)
3127 {
3128 char c;
3129
3130 if (! d_check_char (di, 'S'))
3131 return NULL;
3132
3133 c = d_next_char (di);
3134 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3135 {
3136 unsigned int id;
3137
3138 id = 0;
3139 if (c != '_')
3140 {
3141 do
3142 {
3143 unsigned int new_id;
3144
3145 if (IS_DIGIT (c))
3146 new_id = id * 36 + c - '0';
3147 else if (IS_UPPER (c))
3148 new_id = id * 36 + c - 'A' + 10;
3149 else
3150 return NULL;
3151 if (new_id < id)
3152 return NULL;
3153 id = new_id;
3154 c = d_next_char (di);
3155 }
3156 while (c != '_');
3157
3158 ++id;
3159 }
3160
3161 if (id >= (unsigned int) di->next_sub)
3162 return NULL;
3163
3164 ++di->did_subs;
3165
3166 return di->subs[id];
3167 }
3168 else
3169 {
3170 int verbose;
3171 const struct d_standard_sub_info *p;
3172 const struct d_standard_sub_info *pend;
3173
3174 verbose = (di->options & DMGL_VERBOSE) != 0;
3175 if (! verbose && prefix)
3176 {
3177 char peek;
3178
3179 peek = d_peek_char (di);
3180 if (peek == 'C' || peek == 'D')
3181 verbose = 1;
3182 }
3183
3184 pend = (&standard_subs[0]
3185 + sizeof standard_subs / sizeof standard_subs[0]);
3186 for (p = &standard_subs[0]; p < pend; ++p)
3187 {
3188 if (c == p->code)
3189 {
3190 const char *s;
3191 int len;
3192
3193 if (p->set_last_name != NULL)
3194 di->last_name = d_make_sub (di, p->set_last_name,
3195 p->set_last_name_len);
3196 if (verbose)
3197 {
3198 s = p->full_expansion;
3199 len = p->full_len;
3200 }
3201 else
3202 {
3203 s = p->simple_expansion;
3204 len = p->simple_len;
3205 }
3206 di->expansion += len;
3207 return d_make_sub (di, s, len);
3208 }
3209 }
3210
3211 return NULL;
3212 }
3213 }
3214
3215 /* Initialize a growable string. */
3216
3217 static void
d_growable_string_init(struct d_growable_string * dgs,size_t estimate)3218 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3219 {
3220 dgs->buf = NULL;
3221 dgs->len = 0;
3222 dgs->alc = 0;
3223 dgs->allocation_failure = 0;
3224
3225 if (estimate > 0)
3226 d_growable_string_resize (dgs, estimate);
3227 }
3228
3229 /* Grow a growable string to a given size. */
3230
3231 static inline void
d_growable_string_resize(struct d_growable_string * dgs,size_t need)3232 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3233 {
3234 size_t newalc;
3235 char *newbuf;
3236
3237 if (dgs->allocation_failure)
3238 return;
3239
3240 /* Start allocation at two bytes to avoid any possibility of confusion
3241 with the special value of 1 used as a return in *palc to indicate
3242 allocation failures. */
3243 newalc = dgs->alc > 0 ? dgs->alc : 2;
3244 while (newalc < need)
3245 newalc <<= 1;
3246
3247 newbuf = (char *) realloc (dgs->buf, newalc);
3248 if (newbuf == NULL)
3249 {
3250 free (dgs->buf);
3251 dgs->buf = NULL;
3252 dgs->len = 0;
3253 dgs->alc = 0;
3254 dgs->allocation_failure = 1;
3255 return;
3256 }
3257 dgs->buf = newbuf;
3258 dgs->alc = newalc;
3259 }
3260
3261 /* Append a buffer to a growable string. */
3262
3263 static inline void
d_growable_string_append_buffer(struct d_growable_string * dgs,const char * s,size_t l)3264 d_growable_string_append_buffer (struct d_growable_string *dgs,
3265 const char *s, size_t l)
3266 {
3267 size_t need;
3268
3269 need = dgs->len + l + 1;
3270 if (need > dgs->alc)
3271 d_growable_string_resize (dgs, need);
3272
3273 if (dgs->allocation_failure)
3274 return;
3275
3276 memcpy (dgs->buf + dgs->len, s, l);
3277 dgs->buf[dgs->len + l] = '\0';
3278 dgs->len += l;
3279 }
3280
3281 /* Bridge growable strings to the callback mechanism. */
3282
3283 static void
d_growable_string_callback_adapter(const char * s,size_t l,void * opaque)3284 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
3285 {
3286 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
3287
3288 d_growable_string_append_buffer (dgs, s, l);
3289 }
3290
3291 /* Initialize a print information structure. */
3292
3293 static void
d_print_init(struct d_print_info * dpi,demangle_callbackref callback,void * opaque)3294 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
3295 void *opaque)
3296 {
3297 dpi->len = 0;
3298 dpi->last_char = '\0';
3299 dpi->templates = NULL;
3300 dpi->modifiers = NULL;
3301 dpi->flush_count = 0;
3302
3303 dpi->callback = callback;
3304 dpi->opaque = opaque;
3305
3306 dpi->demangle_failure = 0;
3307 }
3308
3309 /* Indicate that an error occurred during printing, and test for error. */
3310
3311 static inline void
d_print_error(struct d_print_info * dpi)3312 d_print_error (struct d_print_info *dpi)
3313 {
3314 dpi->demangle_failure = 1;
3315 }
3316
3317 static inline int
d_print_saw_error(struct d_print_info * dpi)3318 d_print_saw_error (struct d_print_info *dpi)
3319 {
3320 return dpi->demangle_failure != 0;
3321 }
3322
3323 /* Flush buffered characters to the callback. */
3324
3325 static inline void
d_print_flush(struct d_print_info * dpi)3326 d_print_flush (struct d_print_info *dpi)
3327 {
3328 dpi->buf[dpi->len] = '\0';
3329 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
3330 dpi->len = 0;
3331 dpi->flush_count++;
3332 }
3333
3334 /* Append characters and buffers for printing. */
3335
3336 static inline void
d_append_char(struct d_print_info * dpi,char c)3337 d_append_char (struct d_print_info *dpi, char c)
3338 {
3339 if (dpi->len == sizeof (dpi->buf) - 1)
3340 d_print_flush (dpi);
3341
3342 dpi->buf[dpi->len++] = c;
3343 dpi->last_char = c;
3344 }
3345
3346 static inline void
d_append_buffer(struct d_print_info * dpi,const char * s,size_t l)3347 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
3348 {
3349 size_t i;
3350
3351 for (i = 0; i < l; i++)
3352 d_append_char (dpi, s[i]);
3353 }
3354
3355 static inline void
d_append_string(struct d_print_info * dpi,const char * s)3356 d_append_string (struct d_print_info *dpi, const char *s)
3357 {
3358 d_append_buffer (dpi, s, strlen (s));
3359 }
3360
3361 static inline void
d_append_num(struct d_print_info * dpi,long l)3362 d_append_num (struct d_print_info *dpi, long l)
3363 {
3364 char buf[25];
3365 sprintf (buf,"%ld", l);
3366 d_append_string (dpi, buf);
3367 }
3368
3369 static inline char
d_last_char(struct d_print_info * dpi)3370 d_last_char (struct d_print_info *dpi)
3371 {
3372 return dpi->last_char;
3373 }
3374
3375 /* Turn components into a human readable string. OPTIONS is the
3376 options bits passed to the demangler. DC is the tree to print.
3377 CALLBACK is a function to call to flush demangled string segments
3378 as they fill the intermediate buffer, and OPAQUE is a generalized
3379 callback argument. On success, this returns 1. On failure,
3380 it returns 0, indicating a bad parse. It does not use heap
3381 memory to build an output string, so cannot encounter memory
3382 allocation failure. */
3383
3384 CP_STATIC_IF_GLIBCPP_V3
3385 int
cplus_demangle_print_callback(int options,const struct demangle_component * dc,demangle_callbackref callback,void * opaque)3386 cplus_demangle_print_callback (int options,
3387 const struct demangle_component *dc,
3388 demangle_callbackref callback, void *opaque)
3389 {
3390 struct d_print_info dpi;
3391
3392 d_print_init (&dpi, callback, opaque);
3393
3394 d_print_comp (&dpi, options, dc);
3395
3396 d_print_flush (&dpi);
3397
3398 return ! d_print_saw_error (&dpi);
3399 }
3400
3401 /* Turn components into a human readable string. OPTIONS is the
3402 options bits passed to the demangler. DC is the tree to print.
3403 ESTIMATE is a guess at the length of the result. This returns a
3404 string allocated by malloc, or NULL on error. On success, this
3405 sets *PALC to the size of the allocated buffer. On failure, this
3406 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
3407 failure. */
3408
3409 CP_STATIC_IF_GLIBCPP_V3
3410 char *
cplus_demangle_print(int options,const struct demangle_component * dc,int estimate,size_t * palc)3411 cplus_demangle_print (int options, const struct demangle_component *dc,
3412 int estimate, size_t *palc)
3413 {
3414 struct d_growable_string dgs;
3415
3416 d_growable_string_init (&dgs, estimate);
3417
3418 if (! cplus_demangle_print_callback (options, dc,
3419 d_growable_string_callback_adapter,
3420 &dgs))
3421 {
3422 free (dgs.buf);
3423 *palc = 0;
3424 return NULL;
3425 }
3426
3427 *palc = dgs.allocation_failure ? 1 : dgs.alc;
3428 return dgs.buf;
3429 }
3430
3431 /* Returns the I'th element of the template arglist ARGS, or NULL on
3432 failure. */
3433
3434 static struct demangle_component *
d_index_template_argument(struct demangle_component * args,int i)3435 d_index_template_argument (struct demangle_component *args, int i)
3436 {
3437 struct demangle_component *a;
3438
3439 for (a = args;
3440 a != NULL;
3441 a = d_right (a))
3442 {
3443 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3444 return NULL;
3445 if (i <= 0)
3446 break;
3447 --i;
3448 }
3449 if (i != 0 || a == NULL)
3450 return NULL;
3451
3452 return d_left (a);
3453 }
3454
3455 /* Returns the template argument from the current context indicated by DC,
3456 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
3457
3458 static struct demangle_component *
d_lookup_template_argument(struct d_print_info * dpi,const struct demangle_component * dc)3459 d_lookup_template_argument (struct d_print_info *dpi,
3460 const struct demangle_component *dc)
3461 {
3462 if (dpi->templates == NULL)
3463 {
3464 d_print_error (dpi);
3465 return NULL;
3466 }
3467
3468 return d_index_template_argument
3469 (d_right (dpi->templates->template_decl),
3470 dc->u.s_number.number);
3471 }
3472
3473 /* Returns a template argument pack used in DC (any will do), or NULL. */
3474
3475 static struct demangle_component *
d_find_pack(struct d_print_info * dpi,const struct demangle_component * dc)3476 d_find_pack (struct d_print_info *dpi,
3477 const struct demangle_component *dc)
3478 {
3479 struct demangle_component *a;
3480 if (dc == NULL)
3481 return NULL;
3482
3483 switch (dc->type)
3484 {
3485 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3486 a = d_lookup_template_argument (dpi, dc);
3487 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3488 return a;
3489 return NULL;
3490
3491 case DEMANGLE_COMPONENT_PACK_EXPANSION:
3492 return NULL;
3493
3494 case DEMANGLE_COMPONENT_LAMBDA:
3495 case DEMANGLE_COMPONENT_NAME:
3496 case DEMANGLE_COMPONENT_OPERATOR:
3497 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3498 case DEMANGLE_COMPONENT_SUB_STD:
3499 case DEMANGLE_COMPONENT_CHARACTER:
3500 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
3501 return NULL;
3502
3503 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3504 return d_find_pack (dpi, dc->u.s_extended_operator.name);
3505 case DEMANGLE_COMPONENT_CTOR:
3506 return d_find_pack (dpi, dc->u.s_ctor.name);
3507 case DEMANGLE_COMPONENT_DTOR:
3508 return d_find_pack (dpi, dc->u.s_dtor.name);
3509
3510 default:
3511 a = d_find_pack (dpi, d_left (dc));
3512 if (a)
3513 return a;
3514 return d_find_pack (dpi, d_right (dc));
3515 }
3516 }
3517
3518 /* Returns the length of the template argument pack DC. */
3519
3520 static int
d_pack_length(const struct demangle_component * dc)3521 d_pack_length (const struct demangle_component *dc)
3522 {
3523 int count = 0;
3524 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
3525 && d_left (dc) != NULL)
3526 {
3527 ++count;
3528 dc = d_right (dc);
3529 }
3530 return count;
3531 }
3532
3533 /* DC is a component of a mangled expression. Print it, wrapped in parens
3534 if needed. */
3535
3536 static void
d_print_subexpr(struct d_print_info * dpi,int options,const struct demangle_component * dc)3537 d_print_subexpr (struct d_print_info *dpi, int options,
3538 const struct demangle_component *dc)
3539 {
3540 int simple = 0;
3541 if (dc->type == DEMANGLE_COMPONENT_NAME
3542 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
3543 simple = 1;
3544 if (!simple)
3545 d_append_char (dpi, '(');
3546 d_print_comp (dpi, options, dc);
3547 if (!simple)
3548 d_append_char (dpi, ')');
3549 }
3550
3551 /* Subroutine to handle components. */
3552
3553 static void
d_print_comp(struct d_print_info * dpi,int options,const struct demangle_component * dc)3554 d_print_comp (struct d_print_info *dpi, int options,
3555 const struct demangle_component *dc)
3556 {
3557 if (dc == NULL)
3558 {
3559 d_print_error (dpi);
3560 return;
3561 }
3562 if (d_print_saw_error (dpi))
3563 return;
3564
3565 switch (dc->type)
3566 {
3567 case DEMANGLE_COMPONENT_NAME:
3568 if ((options & DMGL_JAVA) == 0)
3569 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
3570 else
3571 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
3572 return;
3573
3574 case DEMANGLE_COMPONENT_QUAL_NAME:
3575 case DEMANGLE_COMPONENT_LOCAL_NAME:
3576 d_print_comp (dpi, options, d_left (dc));
3577 if ((options & DMGL_JAVA) == 0)
3578 d_append_string (dpi, "::");
3579 else
3580 d_append_char (dpi, '.');
3581 d_print_comp (dpi, options, d_right (dc));
3582 return;
3583
3584 case DEMANGLE_COMPONENT_TYPED_NAME:
3585 {
3586 struct d_print_mod *hold_modifiers;
3587 struct demangle_component *typed_name;
3588 struct d_print_mod adpm[4];
3589 unsigned int i;
3590 struct d_print_template dpt;
3591
3592 /* Pass the name down to the type so that it can be printed in
3593 the right place for the type. We also have to pass down
3594 any CV-qualifiers, which apply to the this parameter. */
3595 hold_modifiers = dpi->modifiers;
3596 dpi->modifiers = 0;
3597 i = 0;
3598 typed_name = d_left (dc);
3599 while (typed_name != NULL)
3600 {
3601 if (i >= sizeof adpm / sizeof adpm[0])
3602 {
3603 d_print_error (dpi);
3604 return;
3605 }
3606
3607 adpm[i].next = dpi->modifiers;
3608 dpi->modifiers = &adpm[i];
3609 adpm[i].mod = typed_name;
3610 adpm[i].printed = 0;
3611 adpm[i].templates = dpi->templates;
3612 ++i;
3613
3614 if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
3615 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
3616 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
3617 break;
3618
3619 typed_name = d_left (typed_name);
3620 }
3621
3622 if (typed_name == NULL)
3623 {
3624 d_print_error (dpi);
3625 return;
3626 }
3627
3628 /* If typed_name is a template, then it applies to the
3629 function type as well. */
3630 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3631 {
3632 dpt.next = dpi->templates;
3633 dpi->templates = &dpt;
3634 dpt.template_decl = typed_name;
3635 }
3636
3637 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
3638 there may be CV-qualifiers on its right argument which
3639 really apply here; this happens when parsing a class which
3640 is local to a function. */
3641 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3642 {
3643 struct demangle_component *local_name;
3644
3645 local_name = d_right (typed_name);
3646 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
3647 local_name = local_name->u.s_unary_num.sub;
3648 while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3649 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3650 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
3651 {
3652 if (i >= sizeof adpm / sizeof adpm[0])
3653 {
3654 d_print_error (dpi);
3655 return;
3656 }
3657
3658 adpm[i] = adpm[i - 1];
3659 adpm[i].next = &adpm[i - 1];
3660 dpi->modifiers = &adpm[i];
3661
3662 adpm[i - 1].mod = local_name;
3663 adpm[i - 1].printed = 0;
3664 adpm[i - 1].templates = dpi->templates;
3665 ++i;
3666
3667 local_name = d_left (local_name);
3668 }
3669 }
3670
3671 d_print_comp (dpi, options, d_right (dc));
3672
3673 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
3674 dpi->templates = dpt.next;
3675
3676 /* If the modifiers didn't get printed by the type, print them
3677 now. */
3678 while (i > 0)
3679 {
3680 --i;
3681 if (! adpm[i].printed)
3682 {
3683 d_append_char (dpi, ' ');
3684 d_print_mod (dpi, options, adpm[i].mod);
3685 }
3686 }
3687
3688 dpi->modifiers = hold_modifiers;
3689
3690 return;
3691 }
3692
3693 case DEMANGLE_COMPONENT_TEMPLATE:
3694 {
3695 struct d_print_mod *hold_dpm;
3696 struct demangle_component *dcl;
3697
3698 /* Don't push modifiers into a template definition. Doing so
3699 could give the wrong definition for a template argument.
3700 Instead, treat the template essentially as a name. */
3701
3702 hold_dpm = dpi->modifiers;
3703 dpi->modifiers = NULL;
3704
3705 dcl = d_left (dc);
3706
3707 if ((options & DMGL_JAVA) != 0
3708 && dcl->type == DEMANGLE_COMPONENT_NAME
3709 && dcl->u.s_name.len == 6
3710 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
3711 {
3712 /* Special-case Java arrays, so that JArray<TYPE> appears
3713 instead as TYPE[]. */
3714
3715 d_print_comp (dpi, options, d_right (dc));
3716 d_append_string (dpi, "[]");
3717 }
3718 else
3719 {
3720 d_print_comp (dpi, options, dcl);
3721 if (d_last_char (dpi) == '<')
3722 d_append_char (dpi, ' ');
3723 d_append_char (dpi, '<');
3724 d_print_comp (dpi, options, d_right (dc));
3725 /* Avoid generating two consecutive '>' characters, to avoid
3726 the C++ syntactic ambiguity. */
3727 if (d_last_char (dpi) == '>')
3728 d_append_char (dpi, ' ');
3729 d_append_char (dpi, '>');
3730 }
3731
3732 dpi->modifiers = hold_dpm;
3733
3734 return;
3735 }
3736
3737 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
3738 {
3739 struct d_print_template *hold_dpt;
3740 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
3741
3742 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
3743 a = d_index_template_argument (a, dpi->pack_index);
3744
3745 if (a == NULL)
3746 {
3747 d_print_error (dpi);
3748 return;
3749 }
3750
3751 /* While processing this parameter, we need to pop the list of
3752 templates. This is because the template parameter may
3753 itself be a reference to a parameter of an outer
3754 template. */
3755
3756 hold_dpt = dpi->templates;
3757 dpi->templates = hold_dpt->next;
3758
3759 d_print_comp (dpi, options, a);
3760
3761 dpi->templates = hold_dpt;
3762
3763 return;
3764 }
3765
3766 case DEMANGLE_COMPONENT_CTOR:
3767 d_print_comp (dpi, options, dc->u.s_ctor.name);
3768 return;
3769
3770 case DEMANGLE_COMPONENT_DTOR:
3771 d_append_char (dpi, '~');
3772 d_print_comp (dpi, options, dc->u.s_dtor.name);
3773 return;
3774
3775 case DEMANGLE_COMPONENT_VTABLE:
3776 d_append_string (dpi, "vtable for ");
3777 d_print_comp (dpi, options, d_left (dc));
3778 return;
3779
3780 case DEMANGLE_COMPONENT_VTT:
3781 d_append_string (dpi, "VTT for ");
3782 d_print_comp (dpi, options, d_left (dc));
3783 return;
3784
3785 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
3786 d_append_string (dpi, "construction vtable for ");
3787 d_print_comp (dpi, options, d_left (dc));
3788 d_append_string (dpi, "-in-");
3789 d_print_comp (dpi, options, d_right (dc));
3790 return;
3791
3792 case DEMANGLE_COMPONENT_TYPEINFO:
3793 d_append_string (dpi, "typeinfo for ");
3794 d_print_comp (dpi, options, d_left (dc));
3795 return;
3796
3797 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
3798 d_append_string (dpi, "typeinfo name for ");
3799 d_print_comp (dpi, options, d_left (dc));
3800 return;
3801
3802 case DEMANGLE_COMPONENT_TYPEINFO_FN:
3803 d_append_string (dpi, "typeinfo fn for ");
3804 d_print_comp (dpi, options, d_left (dc));
3805 return;
3806
3807 case DEMANGLE_COMPONENT_THUNK:
3808 d_append_string (dpi, "non-virtual thunk to ");
3809 d_print_comp (dpi, options, d_left (dc));
3810 return;
3811
3812 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
3813 d_append_string (dpi, "virtual thunk to ");
3814 d_print_comp (dpi, options, d_left (dc));
3815 return;
3816
3817 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
3818 d_append_string (dpi, "covariant return thunk to ");
3819 d_print_comp (dpi, options, d_left (dc));
3820 return;
3821
3822 case DEMANGLE_COMPONENT_JAVA_CLASS:
3823 d_append_string (dpi, "java Class for ");
3824 d_print_comp (dpi, options, d_left (dc));
3825 return;
3826
3827 case DEMANGLE_COMPONENT_GUARD:
3828 d_append_string (dpi, "guard variable for ");
3829 d_print_comp (dpi, options, d_left (dc));
3830 return;
3831
3832 case DEMANGLE_COMPONENT_REFTEMP:
3833 d_append_string (dpi, "reference temporary for ");
3834 d_print_comp (dpi, options, d_left (dc));
3835 return;
3836
3837 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
3838 d_append_string (dpi, "hidden alias for ");
3839 d_print_comp (dpi, options, d_left (dc));
3840 return;
3841
3842 case DEMANGLE_COMPONENT_SUB_STD:
3843 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
3844 return;
3845
3846 case DEMANGLE_COMPONENT_RESTRICT:
3847 case DEMANGLE_COMPONENT_VOLATILE:
3848 case DEMANGLE_COMPONENT_CONST:
3849 {
3850 struct d_print_mod *pdpm;
3851
3852 /* When printing arrays, it's possible to have cases where the
3853 same CV-qualifier gets pushed on the stack multiple times.
3854 We only need to print it once. */
3855
3856 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
3857 {
3858 if (! pdpm->printed)
3859 {
3860 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
3861 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
3862 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
3863 break;
3864 if (pdpm->mod->type == dc->type)
3865 {
3866 d_print_comp (dpi, options, d_left (dc));
3867 return;
3868 }
3869 }
3870 }
3871 }
3872 /* Fall through. */
3873 case DEMANGLE_COMPONENT_RESTRICT_THIS:
3874 case DEMANGLE_COMPONENT_VOLATILE_THIS:
3875 case DEMANGLE_COMPONENT_CONST_THIS:
3876 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3877 case DEMANGLE_COMPONENT_POINTER:
3878 case DEMANGLE_COMPONENT_REFERENCE:
3879 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
3880 case DEMANGLE_COMPONENT_COMPLEX:
3881 case DEMANGLE_COMPONENT_IMAGINARY:
3882 {
3883 /* We keep a list of modifiers on the stack. */
3884 struct d_print_mod dpm;
3885
3886 dpm.next = dpi->modifiers;
3887 dpi->modifiers = &dpm;
3888 dpm.mod = dc;
3889 dpm.printed = 0;
3890 dpm.templates = dpi->templates;
3891
3892 d_print_comp (dpi, options, d_left (dc));
3893
3894 /* If the modifier didn't get printed by the type, print it
3895 now. */
3896 if (! dpm.printed)
3897 d_print_mod (dpi, options, dc);
3898
3899 dpi->modifiers = dpm.next;
3900
3901 return;
3902 }
3903
3904 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3905 if ((options & DMGL_JAVA) == 0)
3906 d_append_buffer (dpi, dc->u.s_builtin.type->name,
3907 dc->u.s_builtin.type->len);
3908 else
3909 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3910 dc->u.s_builtin.type->java_len);
3911 return;
3912
3913 case DEMANGLE_COMPONENT_VENDOR_TYPE:
3914 d_print_comp (dpi, options, d_left (dc));
3915 return;
3916
3917 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3918 {
3919 if ((options & DMGL_RET_POSTFIX) != 0)
3920 d_print_function_type (dpi,
3921 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3922 dc, dpi->modifiers);
3923
3924 /* Print return type if present */
3925 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
3926 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3927 d_left (dc));
3928 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
3929 {
3930 struct d_print_mod dpm;
3931
3932 /* We must pass this type down as a modifier in order to
3933 print it in the right location. */
3934 dpm.next = dpi->modifiers;
3935 dpi->modifiers = &dpm;
3936 dpm.mod = dc;
3937 dpm.printed = 0;
3938 dpm.templates = dpi->templates;
3939
3940 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3941 d_left (dc));
3942
3943 dpi->modifiers = dpm.next;
3944
3945 if (dpm.printed)
3946 return;
3947
3948 /* In standard prefix notation, there is a space between the
3949 return type and the function signature. */
3950 if ((options & DMGL_RET_POSTFIX) == 0)
3951 d_append_char (dpi, ' ');
3952 }
3953
3954 if ((options & DMGL_RET_POSTFIX) == 0)
3955 d_print_function_type (dpi,
3956 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
3957 dc, dpi->modifiers);
3958
3959 return;
3960 }
3961
3962 case DEMANGLE_COMPONENT_ARRAY_TYPE:
3963 {
3964 struct d_print_mod *hold_modifiers;
3965 struct d_print_mod adpm[4];
3966 unsigned int i;
3967 struct d_print_mod *pdpm;
3968
3969 /* We must pass this type down as a modifier in order to print
3970 multi-dimensional arrays correctly. If the array itself is
3971 CV-qualified, we act as though the element type were
3972 CV-qualified. We do this by copying the modifiers down
3973 rather than fiddling pointers, so that we don't wind up
3974 with a d_print_mod higher on the stack pointing into our
3975 stack frame after we return. */
3976
3977 hold_modifiers = dpi->modifiers;
3978
3979 adpm[0].next = hold_modifiers;
3980 dpi->modifiers = &adpm[0];
3981 adpm[0].mod = dc;
3982 adpm[0].printed = 0;
3983 adpm[0].templates = dpi->templates;
3984
3985 i = 1;
3986 pdpm = hold_modifiers;
3987 while (pdpm != NULL
3988 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3989 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3990 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3991 {
3992 if (! pdpm->printed)
3993 {
3994 if (i >= sizeof adpm / sizeof adpm[0])
3995 {
3996 d_print_error (dpi);
3997 return;
3998 }
3999
4000 adpm[i] = *pdpm;
4001 adpm[i].next = dpi->modifiers;
4002 dpi->modifiers = &adpm[i];
4003 pdpm->printed = 1;
4004 ++i;
4005 }
4006
4007 pdpm = pdpm->next;
4008 }
4009
4010 d_print_comp (dpi, options, d_right (dc));
4011
4012 dpi->modifiers = hold_modifiers;
4013
4014 if (adpm[0].printed)
4015 return;
4016
4017 while (i > 1)
4018 {
4019 --i;
4020 d_print_mod (dpi, options, adpm[i].mod);
4021 }
4022
4023 d_print_array_type (dpi, options, dc, dpi->modifiers);
4024
4025 return;
4026 }
4027
4028 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4029 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4030 {
4031 struct d_print_mod dpm;
4032
4033 dpm.next = dpi->modifiers;
4034 dpi->modifiers = &dpm;
4035 dpm.mod = dc;
4036 dpm.printed = 0;
4037 dpm.templates = dpi->templates;
4038
4039 d_print_comp (dpi, options, d_right (dc));
4040
4041 /* If the modifier didn't get printed by the type, print it
4042 now. */
4043 if (! dpm.printed)
4044 d_print_mod (dpi, options, dc);
4045
4046 dpi->modifiers = dpm.next;
4047
4048 return;
4049 }
4050
4051 case DEMANGLE_COMPONENT_FIXED_TYPE:
4052 if (dc->u.s_fixed.sat)
4053 d_append_string (dpi, "_Sat ");
4054 /* Don't print "int _Accum". */
4055 if (dc->u.s_fixed.length->u.s_builtin.type
4056 != &cplus_demangle_builtin_types['i'-'a'])
4057 {
4058 d_print_comp (dpi, options, dc->u.s_fixed.length);
4059 d_append_char (dpi, ' ');
4060 }
4061 if (dc->u.s_fixed.accum)
4062 d_append_string (dpi, "_Accum");
4063 else
4064 d_append_string (dpi, "_Fract");
4065 return;
4066
4067 case DEMANGLE_COMPONENT_ARGLIST:
4068 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4069 if (d_left (dc) != NULL)
4070 d_print_comp (dpi, options, d_left (dc));
4071 if (d_right (dc) != NULL)
4072 {
4073 size_t len;
4074 unsigned long int flush_count;
4075 /* Make sure ", " isn't flushed by d_append_string, otherwise
4076 dpi->len -= 2 wouldn't work. */
4077 if (dpi->len >= sizeof (dpi->buf) - 2)
4078 d_print_flush (dpi);
4079 d_append_string (dpi, ", ");
4080 len = dpi->len;
4081 flush_count = dpi->flush_count;
4082 d_print_comp (dpi, options, d_right (dc));
4083 /* If that didn't print anything (which can happen with empty
4084 template argument packs), remove the comma and space. */
4085 if (dpi->flush_count == flush_count && dpi->len == len)
4086 dpi->len -= 2;
4087 }
4088 return;
4089
4090 case DEMANGLE_COMPONENT_OPERATOR:
4091 {
4092 char c;
4093
4094 d_append_string (dpi, "operator");
4095 c = dc->u.s_operator.op->name[0];
4096 if (IS_LOWER (c))
4097 d_append_char (dpi, ' ');
4098 d_append_buffer (dpi, dc->u.s_operator.op->name,
4099 dc->u.s_operator.op->len);
4100 return;
4101 }
4102
4103 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4104 d_append_string (dpi, "operator ");
4105 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
4106 return;
4107
4108 case DEMANGLE_COMPONENT_CAST:
4109 d_append_string (dpi, "operator ");
4110 d_print_cast (dpi, options, dc);
4111 return;
4112
4113 case DEMANGLE_COMPONENT_UNARY:
4114 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4115 && d_left (dc)->u.s_operator.op->len == 1
4116 && d_left (dc)->u.s_operator.op->name[0] == '&'
4117 && d_right (dc)->type == DEMANGLE_COMPONENT_TYPED_NAME
4118 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_QUAL_NAME
4119 && d_right (d_right (dc))->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4120 {
4121 /* Address of a function (therefore in an expression context) must
4122 have its argument list suppressed.
4123
4124 unary operator ... dc
4125 operator & ... d_left (dc)
4126 typed name ... d_right (dc)
4127 qualified name ... d_left (d_right (dc))
4128 <names>
4129 function type ... d_right (d_right (dc))
4130 argument list
4131 <arguments> */
4132
4133 d_print_expr_op (dpi, options, d_left (dc));
4134 d_print_comp (dpi, options, d_left (d_right (dc)));
4135 return;
4136 }
4137 else if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4138 && d_left (dc)->u.s_operator.op->len == 1
4139 && d_left (dc)->u.s_operator.op->name[0] == '&'
4140 && d_right (dc)->type == DEMANGLE_COMPONENT_QUAL_NAME)
4141 {
4142 /* Keep also already processed variant without the argument list.
4143
4144 unary operator ... dc
4145 operator & ... d_left (dc)
4146 qualified name ... d_right (dc)
4147 <names> */
4148
4149 d_print_expr_op (dpi, options, d_left (dc));
4150 d_print_comp (dpi, options, d_right (dc));
4151 return;
4152 }
4153 else if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
4154 d_print_expr_op (dpi, options, d_left (dc));
4155 else
4156 {
4157 d_append_char (dpi, '(');
4158 d_print_cast (dpi, options, d_left (dc));
4159 d_append_char (dpi, ')');
4160 }
4161 d_print_subexpr (dpi, options, d_right (dc));
4162 return;
4163
4164 case DEMANGLE_COMPONENT_BINARY:
4165 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
4166 {
4167 d_print_error (dpi);
4168 return;
4169 }
4170
4171 /* We wrap an expression which uses the greater-than operator in
4172 an extra layer of parens so that it does not get confused
4173 with the '>' which ends the template parameters. */
4174 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4175 && d_left (dc)->u.s_operator.op->len == 1
4176 && d_left (dc)->u.s_operator.op->name[0] == '>')
4177 d_append_char (dpi, '(');
4178
4179 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
4180 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
4181 {
4182 /* Function call used in an expression should not have printed types
4183 of the function arguments. Values of the function arguments still
4184 get printed below. */
4185
4186 const struct demangle_component *func = d_left (d_right (dc));
4187
4188 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
4189 d_print_error (dpi);
4190 d_print_subexpr (dpi, options, d_left (func));
4191 }
4192 else
4193 d_print_subexpr (dpi, options, d_left (d_right (dc)));
4194 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
4195 {
4196 d_append_char (dpi, '[');
4197 d_print_comp (dpi, options, d_right (d_right (dc)));
4198 d_append_char (dpi, ']');
4199 }
4200 else
4201 {
4202 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
4203 d_print_expr_op (dpi, options, d_left (dc));
4204 d_print_subexpr (dpi, options, d_right (d_right (dc)));
4205 }
4206
4207 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
4208 && d_left (dc)->u.s_operator.op->len == 1
4209 && d_left (dc)->u.s_operator.op->name[0] == '>')
4210 d_append_char (dpi, ')');
4211
4212 return;
4213
4214 case DEMANGLE_COMPONENT_BINARY_ARGS:
4215 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
4216 d_print_error (dpi);
4217 return;
4218
4219 case DEMANGLE_COMPONENT_TRINARY:
4220 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
4221 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
4222 {
4223 d_print_error (dpi);
4224 return;
4225 }
4226 d_print_subexpr (dpi, options, d_left (d_right (dc)));
4227 d_print_expr_op (dpi, options, d_left (dc));
4228 d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
4229 d_append_string (dpi, " : ");
4230 d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
4231 return;
4232
4233 case DEMANGLE_COMPONENT_TRINARY_ARG1:
4234 case DEMANGLE_COMPONENT_TRINARY_ARG2:
4235 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
4236 d_print_error (dpi);
4237 return;
4238
4239 case DEMANGLE_COMPONENT_LITERAL:
4240 case DEMANGLE_COMPONENT_LITERAL_NEG:
4241 {
4242 enum d_builtin_type_print tp;
4243
4244 /* For some builtin types, produce simpler output. */
4245 tp = D_PRINT_DEFAULT;
4246 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
4247 {
4248 tp = d_left (dc)->u.s_builtin.type->print;
4249 switch (tp)
4250 {
4251 case D_PRINT_INT:
4252 case D_PRINT_UNSIGNED:
4253 case D_PRINT_LONG:
4254 case D_PRINT_UNSIGNED_LONG:
4255 case D_PRINT_LONG_LONG:
4256 case D_PRINT_UNSIGNED_LONG_LONG:
4257 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
4258 {
4259 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4260 d_append_char (dpi, '-');
4261 d_print_comp (dpi, options, d_right (dc));
4262 switch (tp)
4263 {
4264 default:
4265 break;
4266 case D_PRINT_UNSIGNED:
4267 d_append_char (dpi, 'u');
4268 break;
4269 case D_PRINT_LONG:
4270 d_append_char (dpi, 'l');
4271 break;
4272 case D_PRINT_UNSIGNED_LONG:
4273 d_append_string (dpi, "ul");
4274 break;
4275 case D_PRINT_LONG_LONG:
4276 d_append_string (dpi, "ll");
4277 break;
4278 case D_PRINT_UNSIGNED_LONG_LONG:
4279 d_append_string (dpi, "ull");
4280 break;
4281 }
4282 return;
4283 }
4284 break;
4285
4286 case D_PRINT_BOOL:
4287 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
4288 && d_right (dc)->u.s_name.len == 1
4289 && dc->type == DEMANGLE_COMPONENT_LITERAL)
4290 {
4291 switch (d_right (dc)->u.s_name.s[0])
4292 {
4293 case '0':
4294 d_append_string (dpi, "false");
4295 return;
4296 case '1':
4297 d_append_string (dpi, "true");
4298 return;
4299 default:
4300 break;
4301 }
4302 }
4303 break;
4304
4305 default:
4306 break;
4307 }
4308 }
4309
4310 d_append_char (dpi, '(');
4311 d_print_comp (dpi, options, d_left (dc));
4312 d_append_char (dpi, ')');
4313 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
4314 d_append_char (dpi, '-');
4315 if (tp == D_PRINT_FLOAT)
4316 d_append_char (dpi, '[');
4317 d_print_comp (dpi, options, d_right (dc));
4318 if (tp == D_PRINT_FLOAT)
4319 d_append_char (dpi, ']');
4320 }
4321 return;
4322
4323 case DEMANGLE_COMPONENT_NUMBER:
4324 d_append_num (dpi, dc->u.s_number.number);
4325 return;
4326
4327 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4328 d_append_string (dpi, "java resource ");
4329 d_print_comp (dpi, options, d_left (dc));
4330 return;
4331
4332 case DEMANGLE_COMPONENT_COMPOUND_NAME:
4333 d_print_comp (dpi, options, d_left (dc));
4334 d_print_comp (dpi, options, d_right (dc));
4335 return;
4336
4337 case DEMANGLE_COMPONENT_CHARACTER:
4338 d_append_char (dpi, dc->u.s_character.character);
4339 return;
4340
4341 case DEMANGLE_COMPONENT_DECLTYPE:
4342 d_append_string (dpi, "decltype (");
4343 d_print_comp (dpi, options, d_left (dc));
4344 d_append_char (dpi, ')');
4345 return;
4346
4347 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4348 {
4349 int len;
4350 int i;
4351 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
4352 if (a == NULL)
4353 {
4354 /* d_find_pack won't find anything if the only packs involved
4355 in this expansion are function parameter packs; in that
4356 case, just print the pattern and "...". */
4357 d_print_subexpr (dpi, options, d_left (dc));
4358 d_append_string (dpi, "...");
4359 return;
4360 }
4361
4362 len = d_pack_length (a);
4363 dc = d_left (dc);
4364 for (i = 0; i < len; ++i)
4365 {
4366 dpi->pack_index = i;
4367 d_print_comp (dpi, options, dc);
4368 if (i < len-1)
4369 d_append_string (dpi, ", ");
4370 }
4371 }
4372 return;
4373
4374 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4375 d_append_string (dpi, "{parm#");
4376 d_append_num (dpi, dc->u.s_number.number + 1);
4377 d_append_char (dpi, '}');
4378 return;
4379
4380 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4381 d_append_string (dpi, "global constructors keyed to ");
4382 d_print_comp (dpi, options, dc->u.s_binary.left);
4383 return;
4384
4385 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4386 d_append_string (dpi, "global destructors keyed to ");
4387 d_print_comp (dpi, options, dc->u.s_binary.left);
4388 return;
4389
4390 case DEMANGLE_COMPONENT_LAMBDA:
4391 d_append_string (dpi, "{lambda(");
4392 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
4393 d_append_string (dpi, ")#");
4394 d_append_num (dpi, dc->u.s_unary_num.num + 1);
4395 d_append_char (dpi, '}');
4396 return;
4397
4398 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4399 d_append_string (dpi, "{unnamed type#");
4400 d_append_num (dpi, dc->u.s_number.number + 1);
4401 d_append_char (dpi, '}');
4402 return;
4403
4404 default:
4405 d_print_error (dpi);
4406 return;
4407 }
4408 }
4409
4410 /* Print a Java dentifier. For Java we try to handle encoded extended
4411 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
4412 so we don't it for C++. Characters are encoded as
4413 __U<hex-char>+_. */
4414
4415 static void
d_print_java_identifier(struct d_print_info * dpi,const char * name,int len)4416 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
4417 {
4418 const char *p;
4419 const char *end;
4420
4421 end = name + len;
4422 for (p = name; p < end; ++p)
4423 {
4424 if (end - p > 3
4425 && p[0] == '_'
4426 && p[1] == '_'
4427 && p[2] == 'U')
4428 {
4429 unsigned long c;
4430 const char *q;
4431
4432 c = 0;
4433 for (q = p + 3; q < end; ++q)
4434 {
4435 int dig;
4436
4437 if (IS_DIGIT (*q))
4438 dig = *q - '0';
4439 else if (*q >= 'A' && *q <= 'F')
4440 dig = *q - 'A' + 10;
4441 else if (*q >= 'a' && *q <= 'f')
4442 dig = *q - 'a' + 10;
4443 else
4444 break;
4445
4446 c = c * 16 + dig;
4447 }
4448 /* If the Unicode character is larger than 256, we don't try
4449 to deal with it here. FIXME. */
4450 if (q < end && *q == '_' && c < 256)
4451 {
4452 d_append_char (dpi, c);
4453 p = q;
4454 continue;
4455 }
4456 }
4457
4458 d_append_char (dpi, *p);
4459 }
4460 }
4461
4462 /* Print a list of modifiers. SUFFIX is 1 if we are printing
4463 qualifiers on this after printing a function. */
4464
4465 static void
d_print_mod_list(struct d_print_info * dpi,int options,struct d_print_mod * mods,int suffix)4466 d_print_mod_list (struct d_print_info *dpi, int options,
4467 struct d_print_mod *mods, int suffix)
4468 {
4469 struct d_print_template *hold_dpt;
4470
4471 if (mods == NULL || d_print_saw_error (dpi))
4472 return;
4473
4474 if (mods->printed
4475 || (! suffix
4476 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4477 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4478 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
4479 {
4480 d_print_mod_list (dpi, options, mods->next, suffix);
4481 return;
4482 }
4483
4484 mods->printed = 1;
4485
4486 hold_dpt = dpi->templates;
4487 dpi->templates = mods->templates;
4488
4489 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
4490 {
4491 d_print_function_type (dpi, options, mods->mod, mods->next);
4492 dpi->templates = hold_dpt;
4493 return;
4494 }
4495 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4496 {
4497 d_print_array_type (dpi, options, mods->mod, mods->next);
4498 dpi->templates = hold_dpt;
4499 return;
4500 }
4501 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4502 {
4503 struct d_print_mod *hold_modifiers;
4504 struct demangle_component *dc;
4505
4506 /* When this is on the modifier stack, we have pulled any
4507 qualifiers off the right argument already. Otherwise, we
4508 print it as usual, but don't let the left argument see any
4509 modifiers. */
4510
4511 hold_modifiers = dpi->modifiers;
4512 dpi->modifiers = NULL;
4513 d_print_comp (dpi, options, d_left (mods->mod));
4514 dpi->modifiers = hold_modifiers;
4515
4516 if ((options & DMGL_JAVA) == 0)
4517 d_append_string (dpi, "::");
4518 else
4519 d_append_char (dpi, '.');
4520
4521 dc = d_right (mods->mod);
4522
4523 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4524 {
4525 d_append_string (dpi, "{default arg#");
4526 d_append_num (dpi, dc->u.s_unary_num.num + 1);
4527 d_append_string (dpi, "}::");
4528 dc = dc->u.s_unary_num.sub;
4529 }
4530
4531 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
4532 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
4533 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
4534 dc = d_left (dc);
4535
4536 d_print_comp (dpi, options, dc);
4537
4538 dpi->templates = hold_dpt;
4539 return;
4540 }
4541
4542 d_print_mod (dpi, options, mods->mod);
4543
4544 dpi->templates = hold_dpt;
4545
4546 d_print_mod_list (dpi, options, mods->next, suffix);
4547 }
4548
4549 /* Print a modifier. */
4550
4551 static void
d_print_mod(struct d_print_info * dpi,int options,const struct demangle_component * mod)4552 d_print_mod (struct d_print_info *dpi, int options,
4553 const struct demangle_component *mod)
4554 {
4555 switch (mod->type)
4556 {
4557 case DEMANGLE_COMPONENT_RESTRICT:
4558 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4559 d_append_string (dpi, " restrict");
4560 return;
4561 case DEMANGLE_COMPONENT_VOLATILE:
4562 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4563 d_append_string (dpi, " volatile");
4564 return;
4565 case DEMANGLE_COMPONENT_CONST:
4566 case DEMANGLE_COMPONENT_CONST_THIS:
4567 d_append_string (dpi, " const");
4568 return;
4569 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4570 d_append_char (dpi, ' ');
4571 d_print_comp (dpi, options, d_right (mod));
4572 return;
4573 case DEMANGLE_COMPONENT_POINTER:
4574 /* There is no pointer symbol in Java. */
4575 if ((options & DMGL_JAVA) == 0)
4576 d_append_char (dpi, '*');
4577 return;
4578 case DEMANGLE_COMPONENT_REFERENCE:
4579 d_append_char (dpi, '&');
4580 return;
4581 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4582 d_append_string (dpi, "&&");
4583 return;
4584 case DEMANGLE_COMPONENT_COMPLEX:
4585 d_append_string (dpi, "complex ");
4586 return;
4587 case DEMANGLE_COMPONENT_IMAGINARY:
4588 d_append_string (dpi, "imaginary ");
4589 return;
4590 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4591 if (d_last_char (dpi) != '(')
4592 d_append_char (dpi, ' ');
4593 d_print_comp (dpi, options, d_left (mod));
4594 d_append_string (dpi, "::*");
4595 return;
4596 case DEMANGLE_COMPONENT_TYPED_NAME:
4597 d_print_comp (dpi, options, d_left (mod));
4598 return;
4599 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4600 d_append_string (dpi, " __vector(");
4601 d_print_comp (dpi, options, d_left (mod));
4602 d_append_char (dpi, ')');
4603 return;
4604
4605 default:
4606 /* Otherwise, we have something that won't go back on the
4607 modifier stack, so we can just print it. */
4608 d_print_comp (dpi, options, mod);
4609 return;
4610 }
4611 }
4612
4613 /* Print a function type, except for the return type. */
4614
4615 static void
d_print_function_type(struct d_print_info * dpi,int options,const struct demangle_component * dc,struct d_print_mod * mods)4616 d_print_function_type (struct d_print_info *dpi, int options,
4617 const struct demangle_component *dc,
4618 struct d_print_mod *mods)
4619 {
4620 int need_paren;
4621 int need_space;
4622 struct d_print_mod *p;
4623 struct d_print_mod *hold_modifiers;
4624
4625 need_paren = 0;
4626 need_space = 0;
4627 for (p = mods; p != NULL; p = p->next)
4628 {
4629 if (p->printed)
4630 break;
4631
4632 switch (p->mod->type)
4633 {
4634 case DEMANGLE_COMPONENT_POINTER:
4635 case DEMANGLE_COMPONENT_REFERENCE:
4636 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4637 need_paren = 1;
4638 break;
4639 case DEMANGLE_COMPONENT_RESTRICT:
4640 case DEMANGLE_COMPONENT_VOLATILE:
4641 case DEMANGLE_COMPONENT_CONST:
4642 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4643 case DEMANGLE_COMPONENT_COMPLEX:
4644 case DEMANGLE_COMPONENT_IMAGINARY:
4645 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4646 need_space = 1;
4647 need_paren = 1;
4648 break;
4649 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4650 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4651 case DEMANGLE_COMPONENT_CONST_THIS:
4652 break;
4653 default:
4654 break;
4655 }
4656 if (need_paren)
4657 break;
4658 }
4659
4660 if (need_paren)
4661 {
4662 if (! need_space)
4663 {
4664 if (d_last_char (dpi) != '('
4665 && d_last_char (dpi) != '*')
4666 need_space = 1;
4667 }
4668 if (need_space && d_last_char (dpi) != ' ')
4669 d_append_char (dpi, ' ');
4670 d_append_char (dpi, '(');
4671 }
4672
4673 hold_modifiers = dpi->modifiers;
4674 dpi->modifiers = NULL;
4675
4676 d_print_mod_list (dpi, options, mods, 0);
4677
4678 if (need_paren)
4679 d_append_char (dpi, ')');
4680
4681 d_append_char (dpi, '(');
4682
4683 if (d_right (dc) != NULL)
4684 d_print_comp (dpi, options, d_right (dc));
4685
4686 d_append_char (dpi, ')');
4687
4688 d_print_mod_list (dpi, options, mods, 1);
4689
4690 dpi->modifiers = hold_modifiers;
4691 }
4692
4693 /* Print an array type, except for the element type. */
4694
4695 static void
d_print_array_type(struct d_print_info * dpi,int options,const struct demangle_component * dc,struct d_print_mod * mods)4696 d_print_array_type (struct d_print_info *dpi, int options,
4697 const struct demangle_component *dc,
4698 struct d_print_mod *mods)
4699 {
4700 int need_space;
4701
4702 need_space = 1;
4703 if (mods != NULL)
4704 {
4705 int need_paren;
4706 struct d_print_mod *p;
4707
4708 need_paren = 0;
4709 for (p = mods; p != NULL; p = p->next)
4710 {
4711 if (! p->printed)
4712 {
4713 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
4714 {
4715 need_space = 0;
4716 break;
4717 }
4718 else
4719 {
4720 need_paren = 1;
4721 need_space = 1;
4722 break;
4723 }
4724 }
4725 }
4726
4727 if (need_paren)
4728 d_append_string (dpi, " (");
4729
4730 d_print_mod_list (dpi, options, mods, 0);
4731
4732 if (need_paren)
4733 d_append_char (dpi, ')');
4734 }
4735
4736 if (need_space)
4737 d_append_char (dpi, ' ');
4738
4739 d_append_char (dpi, '[');
4740
4741 if (d_left (dc) != NULL)
4742 d_print_comp (dpi, options, d_left (dc));
4743
4744 d_append_char (dpi, ']');
4745 }
4746
4747 /* Print an operator in an expression. */
4748
4749 static void
d_print_expr_op(struct d_print_info * dpi,int options,const struct demangle_component * dc)4750 d_print_expr_op (struct d_print_info *dpi, int options,
4751 const struct demangle_component *dc)
4752 {
4753 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
4754 d_append_buffer (dpi, dc->u.s_operator.op->name,
4755 dc->u.s_operator.op->len);
4756 else
4757 d_print_comp (dpi, options, dc);
4758 }
4759
4760 /* Print a cast. */
4761
4762 static void
d_print_cast(struct d_print_info * dpi,int options,const struct demangle_component * dc)4763 d_print_cast (struct d_print_info *dpi, int options,
4764 const struct demangle_component *dc)
4765 {
4766 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
4767 d_print_comp (dpi, options, d_left (dc));
4768 else
4769 {
4770 struct d_print_mod *hold_dpm;
4771 struct d_print_template dpt;
4772
4773 /* It appears that for a templated cast operator, we need to put
4774 the template parameters in scope for the operator name, but
4775 not for the parameters. The effect is that we need to handle
4776 the template printing here. */
4777
4778 hold_dpm = dpi->modifiers;
4779 dpi->modifiers = NULL;
4780
4781 dpt.next = dpi->templates;
4782 dpi->templates = &dpt;
4783 dpt.template_decl = d_left (dc);
4784
4785 d_print_comp (dpi, options, d_left (d_left (dc)));
4786
4787 dpi->templates = dpt.next;
4788
4789 if (d_last_char (dpi) == '<')
4790 d_append_char (dpi, ' ');
4791 d_append_char (dpi, '<');
4792 d_print_comp (dpi, options, d_right (d_left (dc)));
4793 /* Avoid generating two consecutive '>' characters, to avoid
4794 the C++ syntactic ambiguity. */
4795 if (d_last_char (dpi) == '>')
4796 d_append_char (dpi, ' ');
4797 d_append_char (dpi, '>');
4798
4799 dpi->modifiers = hold_dpm;
4800 }
4801 }
4802
4803 /* Initialize the information structure we use to pass around
4804 information. */
4805
4806 CP_STATIC_IF_GLIBCPP_V3
4807 void
cplus_demangle_init_info(const char * mangled,int options,size_t len,struct d_info * di)4808 cplus_demangle_init_info (const char *mangled, int options, size_t len,
4809 struct d_info *di)
4810 {
4811 di->s = mangled;
4812 di->send = mangled + len;
4813 di->options = options;
4814
4815 di->n = mangled;
4816
4817 /* We can not need more components than twice the number of chars in
4818 the mangled string. Most components correspond directly to
4819 chars, but the ARGLIST types are exceptions. */
4820 di->num_comps = 2 * len;
4821 di->next_comp = 0;
4822
4823 /* Similarly, we can not need more substitutions than there are
4824 chars in the mangled string. */
4825 di->num_subs = len;
4826 di->next_sub = 0;
4827 di->did_subs = 0;
4828
4829 di->last_name = NULL;
4830
4831 di->expansion = 0;
4832 }
4833
4834 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
4835 mangled name, return strings in repeated callback giving the demangled
4836 name. OPTIONS is the usual libiberty demangler options. On success,
4837 this returns 1. On failure, returns 0. */
4838
4839 static int
d_demangle_callback(const char * mangled,int options,demangle_callbackref callback,void * opaque)4840 d_demangle_callback (const char *mangled, int options,
4841 demangle_callbackref callback, void *opaque)
4842 {
4843 enum
4844 {
4845 DCT_TYPE,
4846 DCT_MANGLED,
4847 DCT_GLOBAL_CTORS,
4848 DCT_GLOBAL_DTORS
4849 }
4850 type;
4851 struct d_info di;
4852 struct demangle_component *dc;
4853 int status;
4854
4855 if (mangled[0] == '_' && mangled[1] == 'Z')
4856 type = DCT_MANGLED;
4857 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
4858 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
4859 && (mangled[9] == 'D' || mangled[9] == 'I')
4860 && mangled[10] == '_')
4861 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
4862 else
4863 {
4864 if ((options & DMGL_TYPES) == 0)
4865 return 0;
4866 type = DCT_TYPE;
4867 }
4868
4869 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
4870
4871 {
4872 #ifdef CP_DYNAMIC_ARRAYS
4873 __extension__ struct demangle_component comps[di.num_comps];
4874 __extension__ struct demangle_component *subs[di.num_subs];
4875
4876 di.comps = comps;
4877 di.subs = subs;
4878 #else
4879 di.comps = alloca (di.num_comps * sizeof (*di.comps));
4880 di.subs = alloca (di.num_subs * sizeof (*di.subs));
4881 #endif
4882
4883 switch (type)
4884 {
4885 case DCT_TYPE:
4886 dc = cplus_demangle_type (&di);
4887 break;
4888 case DCT_MANGLED:
4889 dc = cplus_demangle_mangled_name (&di, 1);
4890 break;
4891 case DCT_GLOBAL_CTORS:
4892 case DCT_GLOBAL_DTORS:
4893 d_advance (&di, 11);
4894 dc = d_make_comp (&di,
4895 (type == DCT_GLOBAL_CTORS
4896 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
4897 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
4898 d_make_demangle_mangled_name (&di, d_str (&di)),
4899 NULL);
4900 d_advance (&di, strlen (d_str (&di)));
4901 break;
4902 }
4903
4904 /* If DMGL_PARAMS is set, then if we didn't consume the entire
4905 mangled string, then we didn't successfully demangle it. If
4906 DMGL_PARAMS is not set, we didn't look at the trailing
4907 parameters. */
4908 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
4909 dc = NULL;
4910
4911 #ifdef CP_DEMANGLE_DEBUG
4912 d_dump (dc, 0);
4913 #endif
4914
4915 status = (dc != NULL)
4916 ? cplus_demangle_print_callback (options, dc, callback, opaque)
4917 : 0;
4918 }
4919
4920 return status;
4921 }
4922
4923 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
4924 name, return a buffer allocated with malloc holding the demangled
4925 name. OPTIONS is the usual libiberty demangler options. On
4926 success, this sets *PALC to the allocated size of the returned
4927 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
4928 a memory allocation failure, and returns NULL. */
4929
4930 static char *
d_demangle(const char * mangled,int options,size_t * palc)4931 d_demangle (const char *mangled, int options, size_t *palc)
4932 {
4933 struct d_growable_string dgs;
4934 int status;
4935
4936 d_growable_string_init (&dgs, 0);
4937
4938 status = d_demangle_callback (mangled, options,
4939 d_growable_string_callback_adapter, &dgs);
4940 if (status == 0)
4941 {
4942 free (dgs.buf);
4943 *palc = 0;
4944 return NULL;
4945 }
4946
4947 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4948 return dgs.buf;
4949 }
4950
4951 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
4952
4953 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
4954
4955 /* ia64 ABI-mandated entry point in the C++ runtime library for
4956 performing demangling. MANGLED_NAME is a NUL-terminated character
4957 string containing the name to be demangled.
4958
4959 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
4960 *LENGTH bytes, into which the demangled name is stored. If
4961 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
4962 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
4963 is placed in a region of memory allocated with malloc.
4964
4965 If LENGTH is non-NULL, the length of the buffer containing the
4966 demangled name, is placed in *LENGTH.
4967
4968 The return value is a pointer to the start of the NUL-terminated
4969 demangled name, or NULL if the demangling fails. The caller is
4970 responsible for deallocating this memory using free.
4971
4972 *STATUS is set to one of the following values:
4973 0: The demangling operation succeeded.
4974 -1: A memory allocation failure occurred.
4975 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
4976 -3: One of the arguments is invalid.
4977
4978 The demangling is performed using the C++ ABI mangling rules, with
4979 GNU extensions. */
4980
4981 char *
__cxa_demangle(const char * mangled_name,char * output_buffer,size_t * length,int * status)4982 __cxa_demangle (const char *mangled_name, char *output_buffer,
4983 size_t *length, int *status)
4984 {
4985 char *demangled;
4986 size_t alc;
4987
4988 if (mangled_name == NULL)
4989 {
4990 if (status != NULL)
4991 *status = -3;
4992 return NULL;
4993 }
4994
4995 if (output_buffer != NULL && length == NULL)
4996 {
4997 if (status != NULL)
4998 *status = -3;
4999 return NULL;
5000 }
5001
5002 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
5003
5004 if (demangled == NULL)
5005 {
5006 if (status != NULL)
5007 {
5008 if (alc == 1)
5009 *status = -1;
5010 else
5011 *status = -2;
5012 }
5013 return NULL;
5014 }
5015
5016 if (output_buffer == NULL)
5017 {
5018 if (length != NULL)
5019 *length = alc;
5020 }
5021 else
5022 {
5023 if (strlen (demangled) < *length)
5024 {
5025 strcpy (output_buffer, demangled);
5026 free (demangled);
5027 demangled = output_buffer;
5028 }
5029 else
5030 {
5031 free (output_buffer);
5032 *length = alc;
5033 }
5034 }
5035
5036 if (status != NULL)
5037 *status = 0;
5038
5039 return demangled;
5040 }
5041
5042 extern int __gcclibcxx_demangle_callback (const char *,
5043 void (*)
5044 (const char *, size_t, void *),
5045 void *);
5046
5047 /* Alternative, allocationless entry point in the C++ runtime library
5048 for performing demangling. MANGLED_NAME is a NUL-terminated character
5049 string containing the name to be demangled.
5050
5051 CALLBACK is a callback function, called with demangled string
5052 segments as demangling progresses; it is called at least once,
5053 but may be called more than once. OPAQUE is a generalized pointer
5054 used as a callback argument.
5055
5056 The return code is one of the following values, equivalent to
5057 the STATUS values of __cxa_demangle() (excluding -1, since this
5058 function performs no memory allocations):
5059 0: The demangling operation succeeded.
5060 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
5061 -3: One of the arguments is invalid.
5062
5063 The demangling is performed using the C++ ABI mangling rules, with
5064 GNU extensions. */
5065
5066 int
__gcclibcxx_demangle_callback(const char * mangled_name,void (* callback)(const char *,size_t,void *),void * opaque)5067 __gcclibcxx_demangle_callback (const char *mangled_name,
5068 void (*callback) (const char *, size_t, void *),
5069 void *opaque)
5070 {
5071 int status;
5072
5073 if (mangled_name == NULL || callback == NULL)
5074 return -3;
5075
5076 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
5077 callback, opaque);
5078 if (status == 0)
5079 return -2;
5080
5081 return 0;
5082 }
5083
5084 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
5085
5086 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
5087 mangled name, return a buffer allocated with malloc holding the
5088 demangled name. Otherwise, return NULL. */
5089
5090 char *
cplus_demangle_v3(const char * mangled,int options)5091 cplus_demangle_v3 (const char *mangled, int options)
5092 {
5093 size_t alc;
5094
5095 return d_demangle (mangled, options, &alc);
5096 }
5097
5098 int
cplus_demangle_v3_callback(const char * mangled,int options,demangle_callbackref callback,void * opaque)5099 cplus_demangle_v3_callback (const char *mangled, int options,
5100 demangle_callbackref callback, void *opaque)
5101 {
5102 return d_demangle_callback (mangled, options, callback, opaque);
5103 }
5104
5105 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
5106 conventions, but the output formatting is a little different.
5107 This instructs the C++ demangler not to emit pointer characters ("*"), to
5108 use Java's namespace separator symbol ("." instead of "::"), and to output
5109 JArray<TYPE> as TYPE[]. */
5110
5111 char *
java_demangle_v3(const char * mangled)5112 java_demangle_v3 (const char *mangled)
5113 {
5114 size_t alc;
5115
5116 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
5117 }
5118
5119 int
java_demangle_v3_callback(const char * mangled,demangle_callbackref callback,void * opaque)5120 java_demangle_v3_callback (const char *mangled,
5121 demangle_callbackref callback, void *opaque)
5122 {
5123 return d_demangle_callback (mangled,
5124 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
5125 callback, opaque);
5126 }
5127
5128 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
5129
5130 #ifndef IN_GLIBCPP_V3
5131
5132 /* Demangle a string in order to find out whether it is a constructor
5133 or destructor. Return non-zero on success. Set *CTOR_KIND and
5134 *DTOR_KIND appropriately. */
5135
5136 static int
is_ctor_or_dtor(const char * mangled,enum gnu_v3_ctor_kinds * ctor_kind,enum gnu_v3_dtor_kinds * dtor_kind)5137 is_ctor_or_dtor (const char *mangled,
5138 enum gnu_v3_ctor_kinds *ctor_kind,
5139 enum gnu_v3_dtor_kinds *dtor_kind)
5140 {
5141 struct d_info di;
5142 struct demangle_component *dc;
5143 int ret;
5144
5145 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
5146 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
5147
5148 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
5149
5150 {
5151 #ifdef CP_DYNAMIC_ARRAYS
5152 __extension__ struct demangle_component comps[di.num_comps];
5153 __extension__ struct demangle_component *subs[di.num_subs];
5154
5155 di.comps = comps;
5156 di.subs = subs;
5157 #else
5158 di.comps = alloca (di.num_comps * sizeof (*di.comps));
5159 di.subs = alloca (di.num_subs * sizeof (*di.subs));
5160 #endif
5161
5162 dc = cplus_demangle_mangled_name (&di, 1);
5163
5164 /* Note that because we did not pass DMGL_PARAMS, we don't expect
5165 to demangle the entire string. */
5166
5167 ret = 0;
5168 while (dc != NULL)
5169 {
5170 switch (dc->type)
5171 {
5172 default:
5173 dc = NULL;
5174 break;
5175 case DEMANGLE_COMPONENT_TYPED_NAME:
5176 case DEMANGLE_COMPONENT_TEMPLATE:
5177 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5178 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5179 case DEMANGLE_COMPONENT_CONST_THIS:
5180 dc = d_left (dc);
5181 break;
5182 case DEMANGLE_COMPONENT_QUAL_NAME:
5183 case DEMANGLE_COMPONENT_LOCAL_NAME:
5184 dc = d_right (dc);
5185 break;
5186 case DEMANGLE_COMPONENT_CTOR:
5187 *ctor_kind = dc->u.s_ctor.kind;
5188 ret = 1;
5189 dc = NULL;
5190 break;
5191 case DEMANGLE_COMPONENT_DTOR:
5192 *dtor_kind = dc->u.s_dtor.kind;
5193 ret = 1;
5194 dc = NULL;
5195 break;
5196 }
5197 }
5198 }
5199
5200 return ret;
5201 }
5202
5203 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
5204 name. A non-zero return indicates the type of constructor. */
5205
5206 enum gnu_v3_ctor_kinds
is_gnu_v3_mangled_ctor(const char * name)5207 is_gnu_v3_mangled_ctor (const char *name)
5208 {
5209 enum gnu_v3_ctor_kinds ctor_kind;
5210 enum gnu_v3_dtor_kinds dtor_kind;
5211
5212 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5213 return (enum gnu_v3_ctor_kinds) 0;
5214 return ctor_kind;
5215 }
5216
5217
5218 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
5219 name. A non-zero return indicates the type of destructor. */
5220
5221 enum gnu_v3_dtor_kinds
is_gnu_v3_mangled_dtor(const char * name)5222 is_gnu_v3_mangled_dtor (const char *name)
5223 {
5224 enum gnu_v3_ctor_kinds ctor_kind;
5225 enum gnu_v3_dtor_kinds dtor_kind;
5226
5227 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
5228 return (enum gnu_v3_dtor_kinds) 0;
5229 return dtor_kind;
5230 }
5231
5232 #endif /* IN_GLIBCPP_V3 */
5233
5234 #ifdef STANDALONE_DEMANGLER
5235
5236 #include "getopt.h"
5237 #include "dyn-string.h"
5238
5239 static void print_usage (FILE* fp, int exit_value);
5240
5241 #define IS_ALPHA(CHAR) \
5242 (((CHAR) >= 'a' && (CHAR) <= 'z') \
5243 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
5244
5245 /* Non-zero if CHAR is a character than can occur in a mangled name. */
5246 #define is_mangled_char(CHAR) \
5247 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
5248 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
5249
5250 /* The name of this program, as invoked. */
5251 const char* program_name;
5252
5253 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
5254
5255 static void
print_usage(FILE * fp,int exit_value)5256 print_usage (FILE* fp, int exit_value)
5257 {
5258 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
5259 fprintf (fp, "Options:\n");
5260 fprintf (fp, " -h,--help Display this message.\n");
5261 fprintf (fp, " -p,--no-params Don't display function parameters\n");
5262 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
5263 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
5264
5265 exit (exit_value);
5266 }
5267
5268 /* Option specification for getopt_long. */
5269 static const struct option long_options[] =
5270 {
5271 { "help", no_argument, NULL, 'h' },
5272 { "no-params", no_argument, NULL, 'p' },
5273 { "verbose", no_argument, NULL, 'v' },
5274 { NULL, no_argument, NULL, 0 },
5275 };
5276
5277 /* Main entry for a demangling filter executable. It will demangle
5278 its command line arguments, if any. If none are provided, it will
5279 filter stdin to stdout, replacing any recognized mangled C++ names
5280 with their demangled equivalents. */
5281
5282 int
main(int argc,char * argv[])5283 main (int argc, char *argv[])
5284 {
5285 int i;
5286 int opt_char;
5287 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
5288
5289 /* Use the program name of this program, as invoked. */
5290 program_name = argv[0];
5291
5292 /* Parse options. */
5293 do
5294 {
5295 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
5296 switch (opt_char)
5297 {
5298 case '?': /* Unrecognized option. */
5299 print_usage (stderr, 1);
5300 break;
5301
5302 case 'h':
5303 print_usage (stdout, 0);
5304 break;
5305
5306 case 'p':
5307 options &= ~ DMGL_PARAMS;
5308 break;
5309
5310 case 'v':
5311 options |= DMGL_VERBOSE;
5312 break;
5313 }
5314 }
5315 while (opt_char != -1);
5316
5317 if (optind == argc)
5318 /* No command line arguments were provided. Filter stdin. */
5319 {
5320 dyn_string_t mangled = dyn_string_new (3);
5321 char *s;
5322
5323 /* Read all of input. */
5324 while (!feof (stdin))
5325 {
5326 char c;
5327
5328 /* Pile characters into mangled until we hit one that can't
5329 occur in a mangled name. */
5330 c = getchar ();
5331 while (!feof (stdin) && is_mangled_char (c))
5332 {
5333 dyn_string_append_char (mangled, c);
5334 if (feof (stdin))
5335 break;
5336 c = getchar ();
5337 }
5338
5339 if (dyn_string_length (mangled) > 0)
5340 {
5341 #ifdef IN_GLIBCPP_V3
5342 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
5343 #else
5344 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
5345 #endif
5346
5347 if (s != NULL)
5348 {
5349 fputs (s, stdout);
5350 free (s);
5351 }
5352 else
5353 {
5354 /* It might not have been a mangled name. Print the
5355 original text. */
5356 fputs (dyn_string_buf (mangled), stdout);
5357 }
5358
5359 dyn_string_clear (mangled);
5360 }
5361
5362 /* If we haven't hit EOF yet, we've read one character that
5363 can't occur in a mangled name, so print it out. */
5364 if (!feof (stdin))
5365 putchar (c);
5366 }
5367
5368 dyn_string_delete (mangled);
5369 }
5370 else
5371 /* Demangle command line arguments. */
5372 {
5373 /* Loop over command line arguments. */
5374 for (i = optind; i < argc; ++i)
5375 {
5376 char *s;
5377 #ifdef IN_GLIBCPP_V3
5378 int status;
5379 #endif
5380
5381 /* Attempt to demangle. */
5382 #ifdef IN_GLIBCPP_V3
5383 s = __cxa_demangle (argv[i], NULL, NULL, &status);
5384 #else
5385 s = cplus_demangle_v3 (argv[i], options);
5386 #endif
5387
5388 /* If it worked, print the demangled name. */
5389 if (s != NULL)
5390 {
5391 printf ("%s\n", s);
5392 free (s);
5393 }
5394 else
5395 {
5396 #ifdef IN_GLIBCPP_V3
5397 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
5398 #else
5399 fprintf (stderr, "Failed: %s\n", argv[i]);
5400 #endif
5401 }
5402 }
5403 }
5404
5405 return 0;
5406 }
5407
5408 #endif /* STANDALONE_DEMANGLER */
5409