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