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