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