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 # if defined(__GNUC__) || defined(__lint__) 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 { "aw", NL ("co_await "), 1 }, 1806 { "az", NL ("alignof "), 1 }, 1807 { "cc", NL ("const_cast"), 2 }, 1808 { "cl", NL ("()"), 2 }, 1809 { "cm", NL (","), 2 }, 1810 { "co", NL ("~"), 1 }, 1811 { "dV", NL ("/="), 2 }, 1812 { "da", NL ("delete[] "), 1 }, 1813 { "dc", NL ("dynamic_cast"), 2 }, 1814 { "de", NL ("*"), 1 }, 1815 { "dl", NL ("delete "), 1 }, 1816 { "ds", NL (".*"), 2 }, 1817 { "dt", NL ("."), 2 }, 1818 { "dv", NL ("/"), 2 }, 1819 { "eO", NL ("^="), 2 }, 1820 { "eo", NL ("^"), 2 }, 1821 { "eq", NL ("=="), 2 }, 1822 { "fL", NL ("..."), 3 }, 1823 { "fR", NL ("..."), 3 }, 1824 { "fl", NL ("..."), 2 }, 1825 { "fr", NL ("..."), 2 }, 1826 { "ge", NL (">="), 2 }, 1827 { "gs", NL ("::"), 1 }, 1828 { "gt", NL (">"), 2 }, 1829 { "ix", NL ("[]"), 2 }, 1830 { "lS", NL ("<<="), 2 }, 1831 { "le", NL ("<="), 2 }, 1832 { "li", NL ("operator\"\" "), 1 }, 1833 { "ls", NL ("<<"), 2 }, 1834 { "lt", NL ("<"), 2 }, 1835 { "mI", NL ("-="), 2 }, 1836 { "mL", NL ("*="), 2 }, 1837 { "mi", NL ("-"), 2 }, 1838 { "ml", NL ("*"), 2 }, 1839 { "mm", NL ("--"), 1 }, 1840 { "na", NL ("new[]"), 3 }, 1841 { "ne", NL ("!="), 2 }, 1842 { "ng", NL ("-"), 1 }, 1843 { "nt", NL ("!"), 1 }, 1844 { "nw", NL ("new"), 3 }, 1845 { "oR", NL ("|="), 2 }, 1846 { "oo", NL ("||"), 2 }, 1847 { "or", NL ("|"), 2 }, 1848 { "pL", NL ("+="), 2 }, 1849 { "pl", NL ("+"), 2 }, 1850 { "pm", NL ("->*"), 2 }, 1851 { "pp", NL ("++"), 1 }, 1852 { "ps", NL ("+"), 1 }, 1853 { "pt", NL ("->"), 2 }, 1854 { "qu", NL ("?"), 3 }, 1855 { "rM", NL ("%="), 2 }, 1856 { "rS", NL (">>="), 2 }, 1857 { "rc", NL ("reinterpret_cast"), 2 }, 1858 { "rm", NL ("%"), 2 }, 1859 { "rs", NL (">>"), 2 }, 1860 { "sP", NL ("sizeof..."), 1 }, 1861 { "sZ", NL ("sizeof..."), 1 }, 1862 { "sc", NL ("static_cast"), 2 }, 1863 { "ss", NL ("<=>"), 2 }, 1864 { "st", NL ("sizeof "), 1 }, 1865 { "sz", NL ("sizeof "), 1 }, 1866 { "tr", NL ("throw"), 0 }, 1867 { "tw", NL ("throw "), 1 }, 1868 { NULL, NULL, 0, 0 } 1869 }; 1870 1871 static struct demangle_component * 1872 d_operator_name (struct d_info *di) 1873 { 1874 char c1; 1875 char c2; 1876 1877 c1 = d_next_char (di); 1878 c2 = d_next_char (di); 1879 if (c1 == 'v' && IS_DIGIT (c2)) 1880 return d_make_extended_operator (di, c2 - '0', d_source_name (di)); 1881 else if (c1 == 'c' && c2 == 'v') 1882 { 1883 struct demangle_component *type; 1884 int was_conversion = di->is_conversion; 1885 struct demangle_component *res; 1886 1887 di->is_conversion = ! di->is_expression; 1888 type = cplus_demangle_type (di); 1889 if (di->is_conversion) 1890 res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL); 1891 else 1892 res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL); 1893 di->is_conversion = was_conversion; 1894 return res; 1895 } 1896 else 1897 { 1898 /* LOW is the inclusive lower bound. */ 1899 int low = 0; 1900 /* HIGH is the exclusive upper bound. We subtract one to ignore 1901 the sentinel at the end of the array. */ 1902 int high = ((sizeof (cplus_demangle_operators) 1903 / sizeof (cplus_demangle_operators[0])) 1904 - 1); 1905 1906 while (1) 1907 { 1908 int i; 1909 const struct demangle_operator_info *p; 1910 1911 i = low + (high - low) / 2; 1912 p = cplus_demangle_operators + i; 1913 1914 if (c1 == p->code[0] && c2 == p->code[1]) 1915 return d_make_operator (di, p); 1916 1917 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1])) 1918 high = i; 1919 else 1920 low = i + 1; 1921 if (low == high) 1922 return NULL; 1923 } 1924 } 1925 } 1926 1927 static struct demangle_component * 1928 d_make_character (struct d_info *di, int c) 1929 { 1930 struct demangle_component *p; 1931 p = d_make_empty (di); 1932 if (p != NULL) 1933 { 1934 p->type = DEMANGLE_COMPONENT_CHARACTER; 1935 p->u.s_character.character = c; 1936 } 1937 return p; 1938 } 1939 1940 static struct demangle_component * 1941 d_java_resource (struct d_info *di) 1942 { 1943 struct demangle_component *p = NULL; 1944 struct demangle_component *next = NULL; 1945 int len, i; 1946 char c; 1947 const char *str; 1948 1949 len = d_number (di); 1950 if (len <= 1) 1951 return NULL; 1952 1953 /* Eat the leading '_'. */ 1954 if (d_next_char (di) != '_') 1955 return NULL; 1956 len--; 1957 1958 str = d_str (di); 1959 i = 0; 1960 1961 while (len > 0) 1962 { 1963 c = str[i]; 1964 if (!c) 1965 return NULL; 1966 1967 /* Each chunk is either a '$' escape... */ 1968 if (c == '$') 1969 { 1970 i++; 1971 switch (str[i++]) 1972 { 1973 case 'S': 1974 c = '/'; 1975 break; 1976 case '_': 1977 c = '.'; 1978 break; 1979 case '$': 1980 c = '$'; 1981 break; 1982 default: 1983 return NULL; 1984 } 1985 next = d_make_character (di, c); 1986 d_advance (di, i); 1987 str = d_str (di); 1988 len -= i; 1989 i = 0; 1990 if (next == NULL) 1991 return NULL; 1992 } 1993 /* ... or a sequence of characters. */ 1994 else 1995 { 1996 while (i < len && str[i] && str[i] != '$') 1997 i++; 1998 1999 next = d_make_name (di, str, i); 2000 d_advance (di, i); 2001 str = d_str (di); 2002 len -= i; 2003 i = 0; 2004 if (next == NULL) 2005 return NULL; 2006 } 2007 2008 if (p == NULL) 2009 p = next; 2010 else 2011 { 2012 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next); 2013 if (p == NULL) 2014 return NULL; 2015 } 2016 } 2017 2018 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL); 2019 2020 return p; 2021 } 2022 2023 /* <special-name> ::= TV <type> 2024 ::= TT <type> 2025 ::= TI <type> 2026 ::= TS <type> 2027 ::= TA <template-arg> 2028 ::= GV <(object) name> 2029 ::= T <call-offset> <(base) encoding> 2030 ::= Tc <call-offset> <call-offset> <(base) encoding> 2031 Also g++ extensions: 2032 ::= TC <type> <(offset) number> _ <(base) type> 2033 ::= TF <type> 2034 ::= TJ <type> 2035 ::= GR <name> 2036 ::= GA <encoding> 2037 ::= Gr <resource name> 2038 ::= GTt <encoding> 2039 ::= GTn <encoding> 2040 */ 2041 2042 static struct demangle_component * 2043 d_special_name (struct d_info *di) 2044 { 2045 di->expansion += 20; 2046 if (d_check_char (di, 'T')) 2047 { 2048 switch (d_next_char (di)) 2049 { 2050 case 'V': 2051 di->expansion -= 5; 2052 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, 2053 cplus_demangle_type (di), NULL); 2054 case 'T': 2055 di->expansion -= 10; 2056 return d_make_comp (di, DEMANGLE_COMPONENT_VTT, 2057 cplus_demangle_type (di), NULL); 2058 case 'I': 2059 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO, 2060 cplus_demangle_type (di), NULL); 2061 case 'S': 2062 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME, 2063 cplus_demangle_type (di), NULL); 2064 2065 case 'h': 2066 if (! d_call_offset (di, 'h')) 2067 return NULL; 2068 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK, 2069 d_encoding (di, 0), NULL); 2070 2071 case 'v': 2072 if (! d_call_offset (di, 'v')) 2073 return NULL; 2074 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK, 2075 d_encoding (di, 0), NULL); 2076 2077 case 'c': 2078 if (! d_call_offset (di, '\0')) 2079 return NULL; 2080 if (! d_call_offset (di, '\0')) 2081 return NULL; 2082 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK, 2083 d_encoding (di, 0), NULL); 2084 2085 case 'C': 2086 { 2087 struct demangle_component *derived_type; 2088 int offset; 2089 struct demangle_component *base_type; 2090 2091 derived_type = cplus_demangle_type (di); 2092 offset = d_number (di); 2093 if (offset < 0) 2094 return NULL; 2095 if (! d_check_char (di, '_')) 2096 return NULL; 2097 base_type = cplus_demangle_type (di); 2098 /* We don't display the offset. FIXME: We should display 2099 it in verbose mode. */ 2100 di->expansion += 5; 2101 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, 2102 base_type, derived_type); 2103 } 2104 2105 case 'F': 2106 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN, 2107 cplus_demangle_type (di), NULL); 2108 case 'J': 2109 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS, 2110 cplus_demangle_type (di), NULL); 2111 2112 case 'H': 2113 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT, 2114 d_name (di), NULL); 2115 2116 case 'W': 2117 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER, 2118 d_name (di), NULL); 2119 2120 case 'A': 2121 return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ, 2122 d_template_arg (di), NULL); 2123 2124 default: 2125 return NULL; 2126 } 2127 } 2128 else if (d_check_char (di, 'G')) 2129 { 2130 switch (d_next_char (di)) 2131 { 2132 case 'V': 2133 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, 2134 d_name (di), NULL); 2135 2136 case 'R': 2137 { 2138 struct demangle_component *name = d_name (di); 2139 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name, 2140 d_number_component (di)); 2141 } 2142 2143 case 'A': 2144 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, 2145 d_encoding (di, 0), NULL); 2146 2147 case 'T': 2148 switch (d_next_char (di)) 2149 { 2150 case 'n': 2151 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE, 2152 d_encoding (di, 0), NULL); 2153 default: 2154 /* ??? The proposal is that other letters (such as 'h') stand 2155 for different variants of transaction cloning, such as 2156 compiling directly for hardware transaction support. But 2157 they still should all be transactional clones of some sort 2158 so go ahead and call them that. */ 2159 case 't': 2160 return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE, 2161 d_encoding (di, 0), NULL); 2162 } 2163 2164 case 'r': 2165 return d_java_resource (di); 2166 2167 default: 2168 return NULL; 2169 } 2170 } 2171 else 2172 return NULL; 2173 } 2174 2175 /* <call-offset> ::= h <nv-offset> _ 2176 ::= v <v-offset> _ 2177 2178 <nv-offset> ::= <(offset) number> 2179 2180 <v-offset> ::= <(offset) number> _ <(virtual offset) number> 2181 2182 The C parameter, if not '\0', is a character we just read which is 2183 the start of the <call-offset>. 2184 2185 We don't display the offset information anywhere. FIXME: We should 2186 display it in verbose mode. */ 2187 2188 static int 2189 d_call_offset (struct d_info *di, int c) 2190 { 2191 if (c == '\0') 2192 c = d_next_char (di); 2193 2194 if (c == 'h') 2195 d_number (di); 2196 else if (c == 'v') 2197 { 2198 d_number (di); 2199 if (! d_check_char (di, '_')) 2200 return 0; 2201 d_number (di); 2202 } 2203 else 2204 return 0; 2205 2206 if (! d_check_char (di, '_')) 2207 return 0; 2208 2209 return 1; 2210 } 2211 2212 /* <ctor-dtor-name> ::= C1 2213 ::= C2 2214 ::= C3 2215 ::= D0 2216 ::= D1 2217 ::= D2 2218 */ 2219 2220 static struct demangle_component * 2221 d_ctor_dtor_name (struct d_info *di) 2222 { 2223 if (di->last_name != NULL) 2224 { 2225 if (di->last_name->type == DEMANGLE_COMPONENT_NAME) 2226 di->expansion += di->last_name->u.s_name.len; 2227 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) 2228 di->expansion += di->last_name->u.s_string.len; 2229 } 2230 switch (d_peek_char (di)) 2231 { 2232 case 'C': 2233 { 2234 enum gnu_v3_ctor_kinds kind; 2235 int inheriting = 0; 2236 2237 if (d_peek_next_char (di) == 'I') 2238 { 2239 inheriting = 1; 2240 d_advance (di, 1); 2241 } 2242 2243 switch (d_peek_next_char (di)) 2244 { 2245 case '1': 2246 kind = gnu_v3_complete_object_ctor; 2247 break; 2248 case '2': 2249 kind = gnu_v3_base_object_ctor; 2250 break; 2251 case '3': 2252 kind = gnu_v3_complete_object_allocating_ctor; 2253 break; 2254 case '4': 2255 kind = gnu_v3_unified_ctor; 2256 break; 2257 case '5': 2258 kind = gnu_v3_object_ctor_group; 2259 break; 2260 default: 2261 return NULL; 2262 } 2263 2264 d_advance (di, 2); 2265 2266 if (inheriting) 2267 cplus_demangle_type (di); 2268 2269 return d_make_ctor (di, kind, di->last_name); 2270 } 2271 2272 case 'D': 2273 { 2274 enum gnu_v3_dtor_kinds kind; 2275 2276 switch (d_peek_next_char (di)) 2277 { 2278 case '0': 2279 kind = gnu_v3_deleting_dtor; 2280 break; 2281 case '1': 2282 kind = gnu_v3_complete_object_dtor; 2283 break; 2284 case '2': 2285 kind = gnu_v3_base_object_dtor; 2286 break; 2287 /* digit '3' is not used */ 2288 case '4': 2289 kind = gnu_v3_unified_dtor; 2290 break; 2291 case '5': 2292 kind = gnu_v3_object_dtor_group; 2293 break; 2294 default: 2295 return NULL; 2296 } 2297 d_advance (di, 2); 2298 return d_make_dtor (di, kind, di->last_name); 2299 } 2300 2301 default: 2302 return NULL; 2303 } 2304 } 2305 2306 /* True iff we're looking at an order-insensitive type-qualifier, including 2307 function-type-qualifiers. */ 2308 2309 static int 2310 next_is_type_qual (struct d_info *di) 2311 { 2312 char peek = d_peek_char (di); 2313 if (peek == 'r' || peek == 'V' || peek == 'K') 2314 return 1; 2315 if (peek == 'D') 2316 { 2317 peek = d_peek_next_char (di); 2318 if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w') 2319 return 1; 2320 } 2321 return 0; 2322 } 2323 2324 /* <type> ::= <builtin-type> 2325 ::= <function-type> 2326 ::= <class-enum-type> 2327 ::= <array-type> 2328 ::= <pointer-to-member-type> 2329 ::= <template-param> 2330 ::= <template-template-param> <template-args> 2331 ::= <substitution> 2332 ::= <CV-qualifiers> <type> 2333 ::= P <type> 2334 ::= R <type> 2335 ::= O <type> (C++0x) 2336 ::= C <type> 2337 ::= G <type> 2338 ::= U <source-name> <type> 2339 2340 <builtin-type> ::= various one letter codes 2341 ::= u <source-name> 2342 */ 2343 2344 CP_STATIC_IF_GLIBCPP_V3 2345 const struct demangle_builtin_type_info 2346 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = 2347 { 2348 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT }, 2349 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, 2350 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT }, 2351 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT }, 2352 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT }, 2353 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT }, 2354 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT }, 2355 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT }, 2356 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, 2357 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED }, 2358 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 2359 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG }, 2360 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG }, 2361 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT }, 2362 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), 2363 D_PRINT_DEFAULT }, 2364 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 2365 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 2366 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 2367 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT }, 2368 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT }, 2369 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 2370 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID }, 2371 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT }, 2372 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG }, 2373 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), 2374 D_PRINT_UNSIGNED_LONG_LONG }, 2375 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, 2376 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT }, 2377 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT }, 2378 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT }, 2379 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT }, 2380 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT }, 2381 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT }, 2382 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT }, 2383 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"), 2384 D_PRINT_DEFAULT }, 2385 }; 2386 2387 CP_STATIC_IF_GLIBCPP_V3 2388 struct demangle_component * 2389 cplus_demangle_type (struct d_info *di) 2390 { 2391 char peek; 2392 struct demangle_component *ret; 2393 int can_subst; 2394 2395 /* The ABI specifies that when CV-qualifiers are used, the base type 2396 is substitutable, and the fully qualified type is substitutable, 2397 but the base type with a strict subset of the CV-qualifiers is 2398 not substitutable. The natural recursive implementation of the 2399 CV-qualifiers would cause subsets to be substitutable, so instead 2400 we pull them all off now. 2401 2402 FIXME: The ABI says that order-insensitive vendor qualifiers 2403 should be handled in the same way, but we have no way to tell 2404 which vendor qualifiers are order-insensitive and which are 2405 order-sensitive. So we just assume that they are all 2406 order-sensitive. g++ 3.4 supports only one vendor qualifier, 2407 __vector, and it treats it as order-sensitive when mangling 2408 names. */ 2409 2410 if (next_is_type_qual (di)) 2411 { 2412 struct demangle_component **pret; 2413 2414 pret = d_cv_qualifiers (di, &ret, 0); 2415 if (pret == NULL) 2416 return NULL; 2417 if (d_peek_char (di) == 'F') 2418 { 2419 /* cv-qualifiers before a function type apply to 'this', 2420 so avoid adding the unqualified function type to 2421 the substitution list. */ 2422 *pret = d_function_type (di); 2423 } 2424 else 2425 *pret = cplus_demangle_type (di); 2426 if (!*pret) 2427 return NULL; 2428 if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS 2429 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS) 2430 { 2431 /* Move the ref-qualifier outside the cv-qualifiers so that 2432 they are printed in the right order. */ 2433 struct demangle_component *fn = d_left (*pret); 2434 d_left (*pret) = ret; 2435 ret = *pret; 2436 *pret = fn; 2437 } 2438 if (! d_add_substitution (di, ret)) 2439 return NULL; 2440 return ret; 2441 } 2442 2443 can_subst = 1; 2444 2445 peek = d_peek_char (di); 2446 switch (peek) 2447 { 2448 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': 2449 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': 2450 case 'o': case 's': case 't': 2451 case 'v': case 'w': case 'x': case 'y': case 'z': 2452 ret = d_make_builtin_type (di, 2453 &cplus_demangle_builtin_types[peek - 'a']); 2454 di->expansion += ret->u.s_builtin.type->len; 2455 can_subst = 0; 2456 d_advance (di, 1); 2457 break; 2458 2459 case 'u': 2460 d_advance (di, 1); 2461 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE, 2462 d_source_name (di), NULL); 2463 break; 2464 2465 case 'F': 2466 ret = d_function_type (di); 2467 break; 2468 2469 case '0': case '1': case '2': case '3': case '4': 2470 case '5': case '6': case '7': case '8': case '9': 2471 case 'N': 2472 case 'Z': 2473 ret = d_class_enum_type (di); 2474 break; 2475 2476 case 'A': 2477 ret = d_array_type (di); 2478 break; 2479 2480 case 'M': 2481 ret = d_pointer_to_member_type (di); 2482 break; 2483 2484 case 'T': 2485 ret = d_template_param (di); 2486 if (d_peek_char (di) == 'I') 2487 { 2488 /* This may be <template-template-param> <template-args>. 2489 If this is the type for a conversion operator, we can 2490 have a <template-template-param> here only by following 2491 a derivation like this: 2492 2493 <nested-name> 2494 -> <template-prefix> <template-args> 2495 -> <prefix> <template-unqualified-name> <template-args> 2496 -> <unqualified-name> <template-unqualified-name> <template-args> 2497 -> <source-name> <template-unqualified-name> <template-args> 2498 -> <source-name> <operator-name> <template-args> 2499 -> <source-name> cv <type> <template-args> 2500 -> <source-name> cv <template-template-param> <template-args> <template-args> 2501 2502 where the <template-args> is followed by another. 2503 Otherwise, we must have a derivation like this: 2504 2505 <nested-name> 2506 -> <template-prefix> <template-args> 2507 -> <prefix> <template-unqualified-name> <template-args> 2508 -> <unqualified-name> <template-unqualified-name> <template-args> 2509 -> <source-name> <template-unqualified-name> <template-args> 2510 -> <source-name> <operator-name> <template-args> 2511 -> <source-name> cv <type> <template-args> 2512 -> <source-name> cv <template-param> <template-args> 2513 2514 where we need to leave the <template-args> to be processed 2515 by d_prefix (following the <template-prefix>). 2516 2517 The <template-template-param> part is a substitution 2518 candidate. */ 2519 if (! di->is_conversion) 2520 { 2521 if (! d_add_substitution (di, ret)) 2522 return NULL; 2523 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 2524 d_template_args (di)); 2525 } 2526 else 2527 { 2528 struct demangle_component *args; 2529 struct d_info_checkpoint checkpoint; 2530 2531 d_checkpoint (di, &checkpoint); 2532 args = d_template_args (di); 2533 if (d_peek_char (di) == 'I') 2534 { 2535 if (! d_add_substitution (di, ret)) 2536 return NULL; 2537 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 2538 args); 2539 } 2540 else 2541 d_backtrack (di, &checkpoint); 2542 } 2543 } 2544 break; 2545 2546 case 'S': 2547 /* If this is a special substitution, then it is the start of 2548 <class-enum-type>. */ 2549 { 2550 char peek_next; 2551 2552 peek_next = d_peek_next_char (di); 2553 if (IS_DIGIT (peek_next) 2554 || peek_next == '_' 2555 || IS_UPPER (peek_next)) 2556 { 2557 ret = d_substitution (di, 0); 2558 /* The substituted name may have been a template name and 2559 may be followed by tepmlate args. */ 2560 if (d_peek_char (di) == 'I') 2561 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 2562 d_template_args (di)); 2563 else 2564 can_subst = 0; 2565 } 2566 else 2567 { 2568 ret = d_class_enum_type (di); 2569 /* If the substitution was a complete type, then it is not 2570 a new substitution candidate. However, if the 2571 substitution was followed by template arguments, then 2572 the whole thing is a substitution candidate. */ 2573 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD) 2574 can_subst = 0; 2575 } 2576 } 2577 break; 2578 2579 case 'O': 2580 d_advance (di, 1); 2581 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE, 2582 cplus_demangle_type (di), NULL); 2583 break; 2584 2585 case 'P': 2586 d_advance (di, 1); 2587 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER, 2588 cplus_demangle_type (di), NULL); 2589 break; 2590 2591 case 'R': 2592 d_advance (di, 1); 2593 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, 2594 cplus_demangle_type (di), NULL); 2595 break; 2596 2597 case 'C': 2598 d_advance (di, 1); 2599 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX, 2600 cplus_demangle_type (di), NULL); 2601 break; 2602 2603 case 'G': 2604 d_advance (di, 1); 2605 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY, 2606 cplus_demangle_type (di), NULL); 2607 break; 2608 2609 case 'U': 2610 d_advance (di, 1); 2611 ret = d_source_name (di); 2612 if (d_peek_char (di) == 'I') 2613 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 2614 d_template_args (di)); 2615 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, 2616 cplus_demangle_type (di), ret); 2617 break; 2618 2619 case 'D': 2620 can_subst = 0; 2621 d_advance (di, 1); 2622 peek = d_next_char (di); 2623 switch (peek) 2624 { 2625 case 'T': 2626 case 't': 2627 /* decltype (expression) */ 2628 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE, 2629 d_expression (di), NULL); 2630 if (ret && d_next_char (di) != 'E') 2631 ret = NULL; 2632 can_subst = 1; 2633 break; 2634 2635 case 'p': 2636 /* Pack expansion. */ 2637 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, 2638 cplus_demangle_type (di), NULL); 2639 can_subst = 1; 2640 break; 2641 2642 case 'a': 2643 /* auto */ 2644 ret = d_make_name (di, "auto", 4); 2645 break; 2646 case 'c': 2647 /* decltype(auto) */ 2648 ret = d_make_name (di, "decltype(auto)", 14); 2649 break; 2650 2651 case 'f': 2652 /* 32-bit decimal floating point */ 2653 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]); 2654 di->expansion += ret->u.s_builtin.type->len; 2655 break; 2656 case 'd': 2657 /* 64-bit DFP */ 2658 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]); 2659 di->expansion += ret->u.s_builtin.type->len; 2660 break; 2661 case 'e': 2662 /* 128-bit DFP */ 2663 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]); 2664 di->expansion += ret->u.s_builtin.type->len; 2665 break; 2666 case 'h': 2667 /* 16-bit half-precision FP */ 2668 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]); 2669 di->expansion += ret->u.s_builtin.type->len; 2670 break; 2671 case 'u': 2672 /* char8_t */ 2673 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]); 2674 di->expansion += ret->u.s_builtin.type->len; 2675 break; 2676 case 's': 2677 /* char16_t */ 2678 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]); 2679 di->expansion += ret->u.s_builtin.type->len; 2680 break; 2681 case 'i': 2682 /* char32_t */ 2683 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]); 2684 di->expansion += ret->u.s_builtin.type->len; 2685 break; 2686 2687 case 'F': 2688 /* Fixed point types. DF<int bits><length><fract bits><sat> */ 2689 ret = d_make_empty (di); 2690 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE; 2691 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di)))) 2692 /* For demangling we don't care about the bits. */ 2693 d_number (di); 2694 ret->u.s_fixed.length = cplus_demangle_type (di); 2695 if (ret->u.s_fixed.length == NULL) 2696 return NULL; 2697 d_number (di); 2698 peek = d_next_char (di); 2699 ret->u.s_fixed.sat = (peek == 's'); 2700 break; 2701 2702 case 'v': 2703 ret = d_vector_type (di); 2704 can_subst = 1; 2705 break; 2706 2707 case 'n': 2708 /* decltype(nullptr) */ 2709 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]); 2710 di->expansion += ret->u.s_builtin.type->len; 2711 break; 2712 2713 default: 2714 return NULL; 2715 } 2716 break; 2717 2718 default: 2719 return NULL; 2720 } 2721 2722 if (can_subst) 2723 { 2724 if (! d_add_substitution (di, ret)) 2725 return NULL; 2726 } 2727 2728 return ret; 2729 } 2730 2731 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */ 2732 2733 static struct demangle_component ** 2734 d_cv_qualifiers (struct d_info *di, 2735 struct demangle_component **pret, int member_fn) 2736 { 2737 struct demangle_component **pstart; 2738 char peek; 2739 2740 pstart = pret; 2741 peek = d_peek_char (di); 2742 while (next_is_type_qual (di)) 2743 { 2744 enum demangle_component_type t; 2745 struct demangle_component *right = NULL; 2746 2747 d_advance (di, 1); 2748 if (peek == 'r') 2749 { 2750 t = (member_fn 2751 ? DEMANGLE_COMPONENT_RESTRICT_THIS 2752 : DEMANGLE_COMPONENT_RESTRICT); 2753 di->expansion += sizeof "restrict"; 2754 } 2755 else if (peek == 'V') 2756 { 2757 t = (member_fn 2758 ? DEMANGLE_COMPONENT_VOLATILE_THIS 2759 : DEMANGLE_COMPONENT_VOLATILE); 2760 di->expansion += sizeof "volatile"; 2761 } 2762 else if (peek == 'K') 2763 { 2764 t = (member_fn 2765 ? DEMANGLE_COMPONENT_CONST_THIS 2766 : DEMANGLE_COMPONENT_CONST); 2767 di->expansion += sizeof "const"; 2768 } 2769 else 2770 { 2771 peek = d_next_char (di); 2772 if (peek == 'x') 2773 { 2774 t = DEMANGLE_COMPONENT_TRANSACTION_SAFE; 2775 di->expansion += sizeof "transaction_safe"; 2776 } 2777 else if (peek == 'o' 2778 || peek == 'O') 2779 { 2780 t = DEMANGLE_COMPONENT_NOEXCEPT; 2781 di->expansion += sizeof "noexcept"; 2782 if (peek == 'O') 2783 { 2784 right = d_expression (di); 2785 if (right == NULL) 2786 return NULL; 2787 if (! d_check_char (di, 'E')) 2788 return NULL; 2789 } 2790 } 2791 else if (peek == 'w') 2792 { 2793 t = DEMANGLE_COMPONENT_THROW_SPEC; 2794 di->expansion += sizeof "throw"; 2795 right = d_parmlist (di); 2796 if (right == NULL) 2797 return NULL; 2798 if (! d_check_char (di, 'E')) 2799 return NULL; 2800 } 2801 else 2802 return NULL; 2803 } 2804 2805 *pret = d_make_comp (di, t, NULL, right); 2806 if (*pret == NULL) 2807 return NULL; 2808 pret = &d_left (*pret); 2809 2810 peek = d_peek_char (di); 2811 } 2812 2813 if (!member_fn && peek == 'F') 2814 { 2815 while (pstart != pret) 2816 { 2817 switch ((*pstart)->type) 2818 { 2819 case DEMANGLE_COMPONENT_RESTRICT: 2820 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS; 2821 break; 2822 case DEMANGLE_COMPONENT_VOLATILE: 2823 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS; 2824 break; 2825 case DEMANGLE_COMPONENT_CONST: 2826 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS; 2827 break; 2828 default: 2829 break; 2830 } 2831 pstart = &d_left (*pstart); 2832 } 2833 } 2834 2835 return pret; 2836 } 2837 2838 /* <ref-qualifier> ::= R 2839 ::= O */ 2840 2841 static struct demangle_component * 2842 d_ref_qualifier (struct d_info *di, struct demangle_component *sub) 2843 { 2844 struct demangle_component *ret = sub; 2845 char peek; 2846 2847 peek = d_peek_char (di); 2848 if (peek == 'R' || peek == 'O') 2849 { 2850 enum demangle_component_type t; 2851 if (peek == 'R') 2852 { 2853 t = DEMANGLE_COMPONENT_REFERENCE_THIS; 2854 di->expansion += sizeof "&"; 2855 } 2856 else 2857 { 2858 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS; 2859 di->expansion += sizeof "&&"; 2860 } 2861 d_advance (di, 1); 2862 2863 ret = d_make_comp (di, t, ret, NULL); 2864 } 2865 2866 return ret; 2867 } 2868 2869 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */ 2870 2871 static struct demangle_component * 2872 d_function_type (struct d_info *di) 2873 { 2874 struct demangle_component *ret = NULL; 2875 2876 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) 2877 { 2878 if (di->recursion_level > DEMANGLE_RECURSION_LIMIT) 2879 /* FIXME: There ought to be a way to report 2880 that the recursion limit has been reached. */ 2881 return NULL; 2882 2883 di->recursion_level ++; 2884 } 2885 2886 if (d_check_char (di, 'F')) 2887 { 2888 if (d_peek_char (di) == 'Y') 2889 { 2890 /* Function has C linkage. We don't print this information. 2891 FIXME: We should print it in verbose mode. */ 2892 d_advance (di, 1); 2893 } 2894 ret = d_bare_function_type (di, 1); 2895 ret = d_ref_qualifier (di, ret); 2896 2897 if (! d_check_char (di, 'E')) 2898 ret = NULL; 2899 } 2900 2901 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0) 2902 di->recursion_level --; 2903 return ret; 2904 } 2905 2906 /* <type>+ */ 2907 2908 static struct demangle_component * 2909 d_parmlist (struct d_info *di) 2910 { 2911 struct demangle_component *tl; 2912 struct demangle_component **ptl; 2913 2914 tl = NULL; 2915 ptl = &tl; 2916 while (1) 2917 { 2918 struct demangle_component *type; 2919 2920 char peek = d_peek_char (di); 2921 if (peek == '\0' || peek == 'E' || peek == '.') 2922 break; 2923 if ((peek == 'R' || peek == 'O') 2924 && d_peek_next_char (di) == 'E') 2925 /* Function ref-qualifier, not a ref prefix for a parameter type. */ 2926 break; 2927 type = cplus_demangle_type (di); 2928 if (type == NULL) 2929 return NULL; 2930 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL); 2931 if (*ptl == NULL) 2932 return NULL; 2933 ptl = &d_right (*ptl); 2934 } 2935 2936 /* There should be at least one parameter type besides the optional 2937 return type. A function which takes no arguments will have a 2938 single parameter type void. */ 2939 if (tl == NULL) 2940 return NULL; 2941 2942 /* If we have a single parameter type void, omit it. */ 2943 if (d_right (tl) == NULL 2944 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 2945 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID) 2946 { 2947 di->expansion -= d_left (tl)->u.s_builtin.type->len; 2948 d_left (tl) = NULL; 2949 } 2950 2951 return tl; 2952 } 2953 2954 /* <bare-function-type> ::= [J]<type>+ */ 2955 2956 static struct demangle_component * 2957 d_bare_function_type (struct d_info *di, int has_return_type) 2958 { 2959 struct demangle_component *return_type; 2960 struct demangle_component *tl; 2961 char peek; 2962 2963 /* Detect special qualifier indicating that the first argument 2964 is the return type. */ 2965 peek = d_peek_char (di); 2966 if (peek == 'J') 2967 { 2968 d_advance (di, 1); 2969 has_return_type = 1; 2970 } 2971 2972 if (has_return_type) 2973 { 2974 return_type = cplus_demangle_type (di); 2975 if (return_type == NULL) 2976 return NULL; 2977 } 2978 else 2979 return_type = NULL; 2980 2981 tl = d_parmlist (di); 2982 if (tl == NULL) 2983 return NULL; 2984 2985 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, 2986 return_type, tl); 2987 } 2988 2989 /* <class-enum-type> ::= <name> */ 2990 2991 static struct demangle_component * 2992 d_class_enum_type (struct d_info *di) 2993 { 2994 return d_name (di); 2995 } 2996 2997 /* <array-type> ::= A <(positive dimension) number> _ <(element) type> 2998 ::= A [<(dimension) expression>] _ <(element) type> 2999 */ 3000 3001 static struct demangle_component * 3002 d_array_type (struct d_info *di) 3003 { 3004 char peek; 3005 struct demangle_component *dim; 3006 3007 if (! d_check_char (di, 'A')) 3008 return NULL; 3009 3010 peek = d_peek_char (di); 3011 if (peek == '_') 3012 dim = NULL; 3013 else if (IS_DIGIT (peek)) 3014 { 3015 const char *s; 3016 3017 s = d_str (di); 3018 do 3019 { 3020 d_advance (di, 1); 3021 peek = d_peek_char (di); 3022 } 3023 while (IS_DIGIT (peek)); 3024 dim = d_make_name (di, s, d_str (di) - s); 3025 if (dim == NULL) 3026 return NULL; 3027 } 3028 else 3029 { 3030 dim = d_expression (di); 3031 if (dim == NULL) 3032 return NULL; 3033 } 3034 3035 if (! d_check_char (di, '_')) 3036 return NULL; 3037 3038 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim, 3039 cplus_demangle_type (di)); 3040 } 3041 3042 /* <vector-type> ::= Dv <number> _ <type> 3043 ::= Dv _ <expression> _ <type> */ 3044 3045 static struct demangle_component * 3046 d_vector_type (struct d_info *di) 3047 { 3048 char peek; 3049 struct demangle_component *dim; 3050 3051 peek = d_peek_char (di); 3052 if (peek == '_') 3053 { 3054 d_advance (di, 1); 3055 dim = d_expression (di); 3056 } 3057 else 3058 dim = d_number_component (di); 3059 3060 if (dim == NULL) 3061 return NULL; 3062 3063 if (! d_check_char (di, '_')) 3064 return NULL; 3065 3066 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim, 3067 cplus_demangle_type (di)); 3068 } 3069 3070 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */ 3071 3072 static struct demangle_component * 3073 d_pointer_to_member_type (struct d_info *di) 3074 { 3075 struct demangle_component *cl; 3076 struct demangle_component *mem; 3077 3078 if (! d_check_char (di, 'M')) 3079 return NULL; 3080 3081 cl = cplus_demangle_type (di); 3082 if (cl == NULL) 3083 return NULL; 3084 3085 /* The ABI says, "The type of a non-static member function is considered 3086 to be different, for the purposes of substitution, from the type of a 3087 namespace-scope or static member function whose type appears 3088 similar. The types of two non-static member functions are considered 3089 to be different, for the purposes of substitution, if the functions 3090 are members of different classes. In other words, for the purposes of 3091 substitution, the class of which the function is a member is 3092 considered part of the type of function." 3093 3094 For a pointer to member function, this call to cplus_demangle_type 3095 will end up adding a (possibly qualified) non-member function type to 3096 the substitution table, which is not correct; however, the member 3097 function type will never be used in a substitution, so putting the 3098 wrong type in the substitution table is harmless. */ 3099 3100 mem = cplus_demangle_type (di); 3101 if (mem == NULL) 3102 return NULL; 3103 3104 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); 3105 } 3106 3107 /* <non-negative number> _ */ 3108 3109 static int 3110 d_compact_number (struct d_info *di) 3111 { 3112 int num; 3113 if (d_peek_char (di) == '_') 3114 num = 0; 3115 else if (d_peek_char (di) == 'n') 3116 return -1; 3117 else 3118 num = d_number (di) + 1; 3119 3120 if (num < 0 || ! d_check_char (di, '_')) 3121 return -1; 3122 return num; 3123 } 3124 3125 /* <template-param> ::= T_ 3126 ::= T <(parameter-2 non-negative) number> _ 3127 */ 3128 3129 static struct demangle_component * 3130 d_template_param (struct d_info *di) 3131 { 3132 int param; 3133 3134 if (! d_check_char (di, 'T')) 3135 return NULL; 3136 3137 param = d_compact_number (di); 3138 if (param < 0) 3139 return NULL; 3140 3141 return d_make_template_param (di, param); 3142 } 3143 3144 /* <template-args> ::= I <template-arg>+ E */ 3145 3146 static struct demangle_component * 3147 d_template_args (struct d_info *di) 3148 { 3149 if (d_peek_char (di) != 'I' 3150 && d_peek_char (di) != 'J') 3151 return NULL; 3152 d_advance (di, 1); 3153 3154 return d_template_args_1 (di); 3155 } 3156 3157 /* <template-arg>* E */ 3158 3159 static struct demangle_component * 3160 d_template_args_1 (struct d_info *di) 3161 { 3162 struct demangle_component *hold_last_name; 3163 struct demangle_component *al; 3164 struct demangle_component **pal; 3165 3166 /* Preserve the last name we saw--don't let the template arguments 3167 clobber it, as that would give us the wrong name for a subsequent 3168 constructor or destructor. */ 3169 hold_last_name = di->last_name; 3170 3171 if (d_peek_char (di) == 'E') 3172 { 3173 /* An argument pack can be empty. */ 3174 d_advance (di, 1); 3175 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL); 3176 } 3177 3178 al = NULL; 3179 pal = &al; 3180 while (1) 3181 { 3182 struct demangle_component *a; 3183 3184 a = d_template_arg (di); 3185 if (a == NULL) 3186 return NULL; 3187 3188 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL); 3189 if (*pal == NULL) 3190 return NULL; 3191 pal = &d_right (*pal); 3192 3193 if (d_peek_char (di) == 'E') 3194 { 3195 d_advance (di, 1); 3196 break; 3197 } 3198 } 3199 3200 di->last_name = hold_last_name; 3201 3202 return al; 3203 } 3204 3205 /* <template-arg> ::= <type> 3206 ::= X <expression> E 3207 ::= <expr-primary> 3208 */ 3209 3210 static struct demangle_component * 3211 d_template_arg (struct d_info *di) 3212 { 3213 struct demangle_component *ret; 3214 3215 switch (d_peek_char (di)) 3216 { 3217 case 'X': 3218 d_advance (di, 1); 3219 ret = d_expression (di); 3220 if (! d_check_char (di, 'E')) 3221 return NULL; 3222 return ret; 3223 3224 case 'L': 3225 return d_expr_primary (di); 3226 3227 case 'I': 3228 case 'J': 3229 /* An argument pack. */ 3230 return d_template_args (di); 3231 3232 default: 3233 return cplus_demangle_type (di); 3234 } 3235 } 3236 3237 /* Parse a sequence of expressions until we hit the terminator 3238 character. */ 3239 3240 static struct demangle_component * 3241 d_exprlist (struct d_info *di, char terminator) 3242 { 3243 struct demangle_component *list = NULL; 3244 struct demangle_component **p = &list; 3245 3246 if (d_peek_char (di) == terminator) 3247 { 3248 d_advance (di, 1); 3249 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL); 3250 } 3251 3252 while (1) 3253 { 3254 struct demangle_component *arg = d_expression (di); 3255 if (arg == NULL) 3256 return NULL; 3257 3258 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL); 3259 if (*p == NULL) 3260 return NULL; 3261 p = &d_right (*p); 3262 3263 if (d_peek_char (di) == terminator) 3264 { 3265 d_advance (di, 1); 3266 break; 3267 } 3268 } 3269 3270 return list; 3271 } 3272 3273 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast, 3274 dynamic_cast, static_cast or reinterpret_cast. */ 3275 3276 static int 3277 op_is_new_cast (struct demangle_component *op) 3278 { 3279 const char *code = op->u.s_operator.op->code; 3280 return (code[1] == 'c' 3281 && (code[0] == 's' || code[0] == 'd' 3282 || code[0] == 'c' || code[0] == 'r')); 3283 } 3284 3285 /* <expression> ::= <(unary) operator-name> <expression> 3286 ::= <(binary) operator-name> <expression> <expression> 3287 ::= <(trinary) operator-name> <expression> <expression> <expression> 3288 ::= cl <expression>+ E 3289 ::= st <type> 3290 ::= <template-param> 3291 ::= sr <type> <unqualified-name> 3292 ::= sr <type> <unqualified-name> <template-args> 3293 ::= <expr-primary> 3294 */ 3295 3296 static inline struct demangle_component * 3297 d_expression_1 (struct d_info *di) 3298 { 3299 char peek; 3300 3301 peek = d_peek_char (di); 3302 if (peek == 'L') 3303 return d_expr_primary (di); 3304 else if (peek == 'T') 3305 return d_template_param (di); 3306 else if (peek == 's' && d_peek_next_char (di) == 'r') 3307 { 3308 struct demangle_component *type; 3309 struct demangle_component *name; 3310 3311 d_advance (di, 2); 3312 type = cplus_demangle_type (di); 3313 name = d_unqualified_name (di); 3314 if (d_peek_char (di) != 'I') 3315 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); 3316 else 3317 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, 3318 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, 3319 d_template_args (di))); 3320 } 3321 else if (peek == 's' && d_peek_next_char (di) == 'p') 3322 { 3323 d_advance (di, 2); 3324 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION, 3325 d_expression_1 (di), NULL); 3326 } 3327 else if (peek == 'f' && d_peek_next_char (di) == 'p') 3328 { 3329 /* Function parameter used in a late-specified return type. */ 3330 int index; 3331 d_advance (di, 2); 3332 if (d_peek_char (di) == 'T') 3333 { 3334 /* 'this' parameter. */ 3335 d_advance (di, 1); 3336 index = 0; 3337 } 3338 else 3339 { 3340 index = d_compact_number (di); 3341 if (index == INT_MAX || index == -1) 3342 return NULL; 3343 index++; 3344 } 3345 return d_make_function_param (di, index); 3346 } 3347 else if (IS_DIGIT (peek) 3348 || (peek == 'o' && d_peek_next_char (di) == 'n')) 3349 { 3350 /* We can get an unqualified name as an expression in the case of 3351 a dependent function call, i.e. decltype(f(t)). */ 3352 struct demangle_component *name; 3353 3354 if (peek == 'o') 3355 /* operator-function-id, i.e. operator+(t). */ 3356 d_advance (di, 2); 3357 3358 name = d_unqualified_name (di); 3359 if (name == NULL) 3360 return NULL; 3361 if (d_peek_char (di) == 'I') 3362 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, 3363 d_template_args (di)); 3364 else 3365 return name; 3366 } 3367 else if ((peek == 'i' || peek == 't') 3368 && d_peek_next_char (di) == 'l') 3369 { 3370 /* Brace-enclosed initializer list, untyped or typed. */ 3371 struct demangle_component *type = NULL; 3372 d_advance (di, 2); 3373 if (peek == 't') 3374 type = cplus_demangle_type (di); 3375 if (!d_peek_char (di) || !d_peek_next_char (di)) 3376 return NULL; 3377 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST, 3378 type, d_exprlist (di, 'E')); 3379 } 3380 else 3381 { 3382 struct demangle_component *op; 3383 const char *code = NULL; 3384 int args; 3385 3386 op = d_operator_name (di); 3387 if (op == NULL) 3388 return NULL; 3389 3390 if (op->type == DEMANGLE_COMPONENT_OPERATOR) 3391 { 3392 code = op->u.s_operator.op->code; 3393 di->expansion += op->u.s_operator.op->len - 2; 3394 if (strcmp (code, "st") == 0) 3395 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, 3396 cplus_demangle_type (di)); 3397 } 3398 3399 switch (op->type) 3400 { 3401 default: 3402 return NULL; 3403 case DEMANGLE_COMPONENT_OPERATOR: 3404 args = op->u.s_operator.op->args; 3405 break; 3406 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 3407 args = op->u.s_extended_operator.args; 3408 break; 3409 case DEMANGLE_COMPONENT_CAST: 3410 args = 1; 3411 break; 3412 } 3413 3414 switch (args) 3415 { 3416 case 0: 3417 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL); 3418 3419 case 1: 3420 { 3421 struct demangle_component *operand; 3422 int suffix = 0; 3423 3424 if (code && (code[0] == 'p' || code[0] == 'm') 3425 && code[1] == code[0]) 3426 /* pp_ and mm_ are the prefix variants. */ 3427 suffix = !d_check_char (di, '_'); 3428 3429 if (op->type == DEMANGLE_COMPONENT_CAST 3430 && d_check_char (di, '_')) 3431 operand = d_exprlist (di, 'E'); 3432 else if (code && !strcmp (code, "sP")) 3433 operand = d_template_args_1 (di); 3434 else 3435 operand = d_expression_1 (di); 3436 3437 if (suffix) 3438 /* Indicate the suffix variant for d_print_comp. */ 3439 operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS, 3440 operand, operand); 3441 3442 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand); 3443 } 3444 case 2: 3445 { 3446 struct demangle_component *left; 3447 struct demangle_component *right; 3448 3449 if (code == NULL) 3450 return NULL; 3451 if (op_is_new_cast (op)) 3452 left = cplus_demangle_type (di); 3453 else if (code[0] == 'f') 3454 /* fold-expression. */ 3455 left = d_operator_name (di); 3456 else 3457 left = d_expression_1 (di); 3458 if (!strcmp (code, "cl")) 3459 right = d_exprlist (di, 'E'); 3460 else if (!strcmp (code, "dt") || !strcmp (code, "pt")) 3461 { 3462 right = d_unqualified_name (di); 3463 if (d_peek_char (di) == 'I') 3464 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, 3465 right, d_template_args (di)); 3466 } 3467 else 3468 right = d_expression_1 (di); 3469 3470 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, 3471 d_make_comp (di, 3472 DEMANGLE_COMPONENT_BINARY_ARGS, 3473 left, right)); 3474 } 3475 case 3: 3476 { 3477 struct demangle_component *first; 3478 struct demangle_component *second; 3479 struct demangle_component *third; 3480 3481 if (code == NULL) 3482 return NULL; 3483 else if (!strcmp (code, "qu")) 3484 { 3485 /* ?: expression. */ 3486 first = d_expression_1 (di); 3487 second = d_expression_1 (di); 3488 third = d_expression_1 (di); 3489 if (third == NULL) 3490 return NULL; 3491 } 3492 else if (code[0] == 'f') 3493 { 3494 /* fold-expression. */ 3495 first = d_operator_name (di); 3496 second = d_expression_1 (di); 3497 third = d_expression_1 (di); 3498 if (third == NULL) 3499 return NULL; 3500 } 3501 else if (code[0] == 'n') 3502 { 3503 /* new-expression. */ 3504 if (code[1] != 'w' && code[1] != 'a') 3505 return NULL; 3506 first = d_exprlist (di, '_'); 3507 second = cplus_demangle_type (di); 3508 if (d_peek_char (di) == 'E') 3509 { 3510 d_advance (di, 1); 3511 third = NULL; 3512 } 3513 else if (d_peek_char (di) == 'p' 3514 && d_peek_next_char (di) == 'i') 3515 { 3516 /* Parenthesized initializer. */ 3517 d_advance (di, 2); 3518 third = d_exprlist (di, 'E'); 3519 } 3520 else if (d_peek_char (di) == 'i' 3521 && d_peek_next_char (di) == 'l') 3522 /* initializer-list. */ 3523 third = d_expression_1 (di); 3524 else 3525 return NULL; 3526 } 3527 else 3528 return NULL; 3529 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op, 3530 d_make_comp (di, 3531 DEMANGLE_COMPONENT_TRINARY_ARG1, 3532 first, 3533 d_make_comp (di, 3534 DEMANGLE_COMPONENT_TRINARY_ARG2, 3535 second, third))); 3536 } 3537 default: 3538 return NULL; 3539 } 3540 } 3541 } 3542 3543 static struct demangle_component * 3544 d_expression (struct d_info *di) 3545 { 3546 struct demangle_component *ret; 3547 int was_expression = di->is_expression; 3548 3549 di->is_expression = 1; 3550 ret = d_expression_1 (di); 3551 di->is_expression = was_expression; 3552 return ret; 3553 } 3554 3555 /* <expr-primary> ::= L <type> <(value) number> E 3556 ::= L <type> <(value) float> E 3557 ::= L <mangled-name> E 3558 */ 3559 3560 static struct demangle_component * 3561 d_expr_primary (struct d_info *di) 3562 { 3563 struct demangle_component *ret; 3564 3565 if (! d_check_char (di, 'L')) 3566 return NULL; 3567 if (d_peek_char (di) == '_' 3568 /* Workaround for G++ bug; see comment in write_template_arg. */ 3569 || d_peek_char (di) == 'Z') 3570 ret = cplus_demangle_mangled_name (di, 0); 3571 else 3572 { 3573 struct demangle_component *type; 3574 enum demangle_component_type t; 3575 const char *s; 3576 3577 type = cplus_demangle_type (di); 3578 if (type == NULL) 3579 return NULL; 3580 3581 /* If we have a type we know how to print, we aren't going to 3582 print the type name itself. */ 3583 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 3584 && type->u.s_builtin.type->print != D_PRINT_DEFAULT) 3585 di->expansion -= type->u.s_builtin.type->len; 3586 3587 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 3588 && strcmp (type->u.s_builtin.type->name, 3589 cplus_demangle_builtin_types[33].name) == 0) 3590 { 3591 if (d_peek_char (di) == 'E') 3592 { 3593 d_advance (di, 1); 3594 return type; 3595 } 3596 } 3597 3598 /* Rather than try to interpret the literal value, we just 3599 collect it as a string. Note that it's possible to have a 3600 floating point literal here. The ABI specifies that the 3601 format of such literals is machine independent. That's fine, 3602 but what's not fine is that versions of g++ up to 3.2 with 3603 -fabi-version=1 used upper case letters in the hex constant, 3604 and dumped out gcc's internal representation. That makes it 3605 hard to tell where the constant ends, and hard to dump the 3606 constant in any readable form anyhow. We don't attempt to 3607 handle these cases. */ 3608 3609 t = DEMANGLE_COMPONENT_LITERAL; 3610 if (d_peek_char (di) == 'n') 3611 { 3612 t = DEMANGLE_COMPONENT_LITERAL_NEG; 3613 d_advance (di, 1); 3614 } 3615 s = d_str (di); 3616 while (d_peek_char (di) != 'E') 3617 { 3618 if (d_peek_char (di) == '\0') 3619 return NULL; 3620 d_advance (di, 1); 3621 } 3622 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s)); 3623 } 3624 if (! d_check_char (di, 'E')) 3625 return NULL; 3626 return ret; 3627 } 3628 3629 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>] 3630 ::= Z <(function) encoding> E s [<discriminator>] 3631 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name> 3632 */ 3633 3634 static struct demangle_component * 3635 d_local_name (struct d_info *di) 3636 { 3637 struct demangle_component *function; 3638 struct demangle_component *name; 3639 3640 if (! d_check_char (di, 'Z')) 3641 return NULL; 3642 3643 function = d_encoding (di, 0); 3644 if (!function) 3645 return NULL; 3646 3647 if (! d_check_char (di, 'E')) 3648 return NULL; 3649 3650 if (d_peek_char (di) == 's') 3651 { 3652 d_advance (di, 1); 3653 if (! d_discriminator (di)) 3654 return NULL; 3655 name = d_make_name (di, "string literal", sizeof "string literal" - 1); 3656 } 3657 else 3658 { 3659 int num = -1; 3660 3661 if (d_peek_char (di) == 'd') 3662 { 3663 /* Default argument scope: d <number> _. */ 3664 d_advance (di, 1); 3665 num = d_compact_number (di); 3666 if (num < 0) 3667 return NULL; 3668 } 3669 3670 name = d_name (di); 3671 3672 if (name 3673 /* Lambdas and unnamed types have internal discriminators 3674 and are not functions. */ 3675 && name->type != DEMANGLE_COMPONENT_LAMBDA 3676 && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE) 3677 { 3678 /* Read and ignore an optional discriminator. */ 3679 if (! d_discriminator (di)) 3680 return NULL; 3681 } 3682 3683 if (num >= 0) 3684 name = d_make_default_arg (di, num, name); 3685 } 3686 3687 /* Elide the return type of the containing function so as to not 3688 confuse the user thinking it is the return type of whatever local 3689 function we might be containing. */ 3690 if (function->type == DEMANGLE_COMPONENT_TYPED_NAME 3691 && d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) 3692 d_left (d_right (function)) = NULL; 3693 3694 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); 3695 } 3696 3697 /* <discriminator> ::= _ <number> # when number < 10 3698 ::= __ <number> _ # when number >= 10 3699 3700 <discriminator> ::= _ <number> # when number >=10 3701 is also accepted to support gcc versions that wrongly mangled that way. 3702 3703 We demangle the discriminator, but we don't print it out. FIXME: 3704 We should print it out in verbose mode. */ 3705 3706 static int 3707 d_discriminator (struct d_info *di) 3708 { 3709 int discrim, num_underscores = 1; 3710 3711 if (d_peek_char (di) != '_') 3712 return 1; 3713 d_advance (di, 1); 3714 if (d_peek_char (di) == '_') 3715 { 3716 ++num_underscores; 3717 d_advance (di, 1); 3718 } 3719 3720 discrim = d_number (di); 3721 if (discrim < 0) 3722 return 0; 3723 if (num_underscores > 1 && discrim >= 10) 3724 { 3725 if (d_peek_char (di) == '_') 3726 d_advance (di, 1); 3727 else 3728 return 0; 3729 } 3730 3731 return 1; 3732 } 3733 3734 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */ 3735 3736 static struct demangle_component * 3737 d_lambda (struct d_info *di) 3738 { 3739 struct demangle_component *tl; 3740 struct demangle_component *ret; 3741 int num; 3742 3743 if (! d_check_char (di, 'U')) 3744 return NULL; 3745 if (! d_check_char (di, 'l')) 3746 return NULL; 3747 3748 tl = d_parmlist (di); 3749 if (tl == NULL) 3750 return NULL; 3751 3752 if (! d_check_char (di, 'E')) 3753 return NULL; 3754 3755 num = d_compact_number (di); 3756 if (num < 0) 3757 return NULL; 3758 3759 ret = d_make_empty (di); 3760 if (ret) 3761 { 3762 ret->type = DEMANGLE_COMPONENT_LAMBDA; 3763 ret->u.s_unary_num.sub = tl; 3764 ret->u.s_unary_num.num = num; 3765 } 3766 3767 if (! d_add_substitution (di, ret)) 3768 return NULL; 3769 3770 return ret; 3771 } 3772 3773 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */ 3774 3775 static struct demangle_component * 3776 d_unnamed_type (struct d_info *di) 3777 { 3778 struct demangle_component *ret; 3779 int num; 3780 3781 if (! d_check_char (di, 'U')) 3782 return NULL; 3783 if (! d_check_char (di, 't')) 3784 return NULL; 3785 3786 num = d_compact_number (di); 3787 if (num < 0) 3788 return NULL; 3789 3790 ret = d_make_empty (di); 3791 if (ret) 3792 { 3793 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE; 3794 ret->u.s_number.number = num; 3795 } 3796 3797 if (! d_add_substitution (di, ret)) 3798 return NULL; 3799 3800 return ret; 3801 } 3802 3803 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]* 3804 */ 3805 3806 static struct demangle_component * 3807 d_clone_suffix (struct d_info *di, struct demangle_component *encoding) 3808 { 3809 const char *suffix = d_str (di); 3810 const char *pend = suffix; 3811 struct demangle_component *n; 3812 3813 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_')) 3814 { 3815 pend += 2; 3816 while (IS_LOWER (*pend) || *pend == '_') 3817 ++pend; 3818 } 3819 while (*pend == '.' && IS_DIGIT (pend[1])) 3820 { 3821 pend += 2; 3822 while (IS_DIGIT (*pend)) 3823 ++pend; 3824 } 3825 d_advance (di, pend - suffix); 3826 n = d_make_name (di, suffix, pend - suffix); 3827 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n); 3828 } 3829 3830 /* Add a new substitution. */ 3831 3832 static int 3833 d_add_substitution (struct d_info *di, struct demangle_component *dc) 3834 { 3835 if (dc == NULL) 3836 return 0; 3837 if (di->next_sub >= di->num_subs) 3838 return 0; 3839 di->subs[di->next_sub] = dc; 3840 ++di->next_sub; 3841 return 1; 3842 } 3843 3844 /* <substitution> ::= S <seq-id> _ 3845 ::= S_ 3846 ::= St 3847 ::= Sa 3848 ::= Sb 3849 ::= Ss 3850 ::= Si 3851 ::= So 3852 ::= Sd 3853 3854 If PREFIX is non-zero, then this type is being used as a prefix in 3855 a qualified name. In this case, for the standard substitutions, we 3856 need to check whether we are being used as a prefix for a 3857 constructor or destructor, and return a full template name. 3858 Otherwise we will get something like std::iostream::~iostream() 3859 which does not correspond particularly well to any function which 3860 actually appears in the source. 3861 */ 3862 3863 static const struct d_standard_sub_info standard_subs[] = 3864 { 3865 { 't', NL ("std"), 3866 NL ("std"), 3867 NULL, 0 }, 3868 { 'a', NL ("std::allocator"), 3869 NL ("std::allocator"), 3870 NL ("allocator") }, 3871 { 'b', NL ("std::basic_string"), 3872 NL ("std::basic_string"), 3873 NL ("basic_string") }, 3874 { 's', NL ("std::string"), 3875 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), 3876 NL ("basic_string") }, 3877 { 'i', NL ("std::istream"), 3878 NL ("std::basic_istream<char, std::char_traits<char> >"), 3879 NL ("basic_istream") }, 3880 { 'o', NL ("std::ostream"), 3881 NL ("std::basic_ostream<char, std::char_traits<char> >"), 3882 NL ("basic_ostream") }, 3883 { 'd', NL ("std::iostream"), 3884 NL ("std::basic_iostream<char, std::char_traits<char> >"), 3885 NL ("basic_iostream") } 3886 }; 3887 3888 static struct demangle_component * 3889 d_substitution (struct d_info *di, int prefix) 3890 { 3891 char c; 3892 3893 if (! d_check_char (di, 'S')) 3894 return NULL; 3895 3896 c = d_next_char (di); 3897 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) 3898 { 3899 unsigned int id; 3900 3901 id = 0; 3902 if (c != '_') 3903 { 3904 do 3905 { 3906 unsigned int new_id; 3907 3908 if (IS_DIGIT (c)) 3909 new_id = id * 36 + c - '0'; 3910 else if (IS_UPPER (c)) 3911 new_id = id * 36 + c - 'A' + 10; 3912 else 3913 return NULL; 3914 if (new_id < id) 3915 return NULL; 3916 id = new_id; 3917 c = d_next_char (di); 3918 } 3919 while (c != '_'); 3920 3921 ++id; 3922 } 3923 3924 if (id >= (unsigned int) di->next_sub) 3925 return NULL; 3926 3927 return di->subs[id]; 3928 } 3929 else 3930 { 3931 int verbose; 3932 const struct d_standard_sub_info *p; 3933 const struct d_standard_sub_info *pend; 3934 3935 verbose = (di->options & DMGL_VERBOSE) != 0; 3936 if (! verbose && prefix) 3937 { 3938 char peek; 3939 3940 peek = d_peek_char (di); 3941 if (peek == 'C' || peek == 'D') 3942 verbose = 1; 3943 } 3944 3945 pend = (&standard_subs[0] 3946 + sizeof standard_subs / sizeof standard_subs[0]); 3947 for (p = &standard_subs[0]; p < pend; ++p) 3948 { 3949 if (c == p->code) 3950 { 3951 const char *s; 3952 int len; 3953 struct demangle_component *dc; 3954 3955 if (p->set_last_name != NULL) 3956 di->last_name = d_make_sub (di, p->set_last_name, 3957 p->set_last_name_len); 3958 if (verbose) 3959 { 3960 s = p->full_expansion; 3961 len = p->full_len; 3962 } 3963 else 3964 { 3965 s = p->simple_expansion; 3966 len = p->simple_len; 3967 } 3968 di->expansion += len; 3969 dc = d_make_sub (di, s, len); 3970 if (d_peek_char (di) == 'B') 3971 { 3972 /* If there are ABI tags on the abbreviation, it becomes 3973 a substitution candidate. */ 3974 dc = d_abi_tags (di, dc); 3975 if (! d_add_substitution (di, dc)) 3976 return NULL; 3977 } 3978 return dc; 3979 } 3980 } 3981 3982 return NULL; 3983 } 3984 } 3985 3986 static void 3987 d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint) 3988 { 3989 checkpoint->n = di->n; 3990 checkpoint->next_comp = di->next_comp; 3991 checkpoint->next_sub = di->next_sub; 3992 checkpoint->expansion = di->expansion; 3993 } 3994 3995 static void 3996 d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint) 3997 { 3998 di->n = checkpoint->n; 3999 di->next_comp = checkpoint->next_comp; 4000 di->next_sub = checkpoint->next_sub; 4001 di->expansion = checkpoint->expansion; 4002 } 4003 4004 /* Initialize a growable string. */ 4005 4006 static void 4007 d_growable_string_init (struct d_growable_string *dgs, size_t estimate) 4008 { 4009 dgs->buf = NULL; 4010 dgs->len = 0; 4011 dgs->alc = 0; 4012 dgs->allocation_failure = 0; 4013 4014 if (estimate > 0) 4015 d_growable_string_resize (dgs, estimate); 4016 } 4017 4018 /* Grow a growable string to a given size. */ 4019 4020 static inline void 4021 d_growable_string_resize (struct d_growable_string *dgs, size_t need) 4022 { 4023 size_t newalc; 4024 char *newbuf; 4025 4026 if (dgs->allocation_failure) 4027 return; 4028 4029 /* Start allocation at two bytes to avoid any possibility of confusion 4030 with the special value of 1 used as a return in *palc to indicate 4031 allocation failures. */ 4032 newalc = dgs->alc > 0 ? dgs->alc : 2; 4033 while (newalc < need) 4034 newalc <<= 1; 4035 4036 newbuf = (char *) realloc (dgs->buf, newalc); 4037 if (newbuf == NULL) 4038 { 4039 free (dgs->buf); 4040 dgs->buf = NULL; 4041 dgs->len = 0; 4042 dgs->alc = 0; 4043 dgs->allocation_failure = 1; 4044 return; 4045 } 4046 dgs->buf = newbuf; 4047 dgs->alc = newalc; 4048 } 4049 4050 /* Append a buffer to a growable string. */ 4051 4052 static inline void 4053 d_growable_string_append_buffer (struct d_growable_string *dgs, 4054 const char *s, size_t l) 4055 { 4056 size_t need; 4057 4058 need = dgs->len + l + 1; 4059 if (need > dgs->alc) 4060 d_growable_string_resize (dgs, need); 4061 4062 if (dgs->allocation_failure) 4063 return; 4064 4065 memcpy (dgs->buf + dgs->len, s, l); 4066 dgs->buf[dgs->len + l] = '\0'; 4067 dgs->len += l; 4068 } 4069 4070 /* Bridge growable strings to the callback mechanism. */ 4071 4072 static void 4073 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque) 4074 { 4075 struct d_growable_string *dgs = (struct d_growable_string*) opaque; 4076 4077 d_growable_string_append_buffer (dgs, s, l); 4078 } 4079 4080 /* Walk the tree, counting the number of templates encountered, and 4081 the number of times a scope might be saved. These counts will be 4082 used to allocate data structures for d_print_comp, so the logic 4083 here must mirror the logic d_print_comp will use. It is not 4084 important that the resulting numbers are exact, so long as they 4085 are larger than the actual numbers encountered. */ 4086 4087 static void 4088 d_count_templates_scopes (struct d_print_info *dpi, 4089 struct demangle_component *dc) 4090 { 4091 if (dc == NULL || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT) 4092 return; 4093 4094 ++ dc->d_counting; 4095 4096 switch (dc->type) 4097 { 4098 case DEMANGLE_COMPONENT_NAME: 4099 case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 4100 case DEMANGLE_COMPONENT_FUNCTION_PARAM: 4101 case DEMANGLE_COMPONENT_SUB_STD: 4102 case DEMANGLE_COMPONENT_BUILTIN_TYPE: 4103 case DEMANGLE_COMPONENT_OPERATOR: 4104 case DEMANGLE_COMPONENT_CHARACTER: 4105 case DEMANGLE_COMPONENT_NUMBER: 4106 case DEMANGLE_COMPONENT_UNNAMED_TYPE: 4107 break; 4108 4109 case DEMANGLE_COMPONENT_TEMPLATE: 4110 dpi->num_copy_templates++; 4111 goto recurse_left_right; 4112 4113 case DEMANGLE_COMPONENT_REFERENCE: 4114 case DEMANGLE_COMPONENT_RVALUE_REFERENCE: 4115 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) 4116 dpi->num_saved_scopes++; 4117 goto recurse_left_right; 4118 4119 case DEMANGLE_COMPONENT_QUAL_NAME: 4120 case DEMANGLE_COMPONENT_LOCAL_NAME: 4121 case DEMANGLE_COMPONENT_TYPED_NAME: 4122 case DEMANGLE_COMPONENT_VTABLE: 4123 case DEMANGLE_COMPONENT_VTT: 4124 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 4125 case DEMANGLE_COMPONENT_TYPEINFO: 4126 case DEMANGLE_COMPONENT_TYPEINFO_NAME: 4127 case DEMANGLE_COMPONENT_TYPEINFO_FN: 4128 case DEMANGLE_COMPONENT_THUNK: 4129 case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 4130 case DEMANGLE_COMPONENT_COVARIANT_THUNK: 4131 case DEMANGLE_COMPONENT_JAVA_CLASS: 4132 case DEMANGLE_COMPONENT_GUARD: 4133 case DEMANGLE_COMPONENT_TLS_INIT: 4134 case DEMANGLE_COMPONENT_TLS_WRAPPER: 4135 case DEMANGLE_COMPONENT_REFTEMP: 4136 case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 4137 case DEMANGLE_COMPONENT_RESTRICT: 4138 case DEMANGLE_COMPONENT_VOLATILE: 4139 case DEMANGLE_COMPONENT_CONST: 4140 case DEMANGLE_COMPONENT_RESTRICT_THIS: 4141 case DEMANGLE_COMPONENT_VOLATILE_THIS: 4142 case DEMANGLE_COMPONENT_CONST_THIS: 4143 case DEMANGLE_COMPONENT_REFERENCE_THIS: 4144 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: 4145 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: 4146 case DEMANGLE_COMPONENT_NOEXCEPT: 4147 case DEMANGLE_COMPONENT_THROW_SPEC: 4148 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 4149 case DEMANGLE_COMPONENT_POINTER: 4150 case DEMANGLE_COMPONENT_COMPLEX: 4151 case DEMANGLE_COMPONENT_IMAGINARY: 4152 case DEMANGLE_COMPONENT_VENDOR_TYPE: 4153 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 4154 case DEMANGLE_COMPONENT_ARRAY_TYPE: 4155 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 4156 case DEMANGLE_COMPONENT_VECTOR_TYPE: 4157 case DEMANGLE_COMPONENT_ARGLIST: 4158 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 4159 case DEMANGLE_COMPONENT_TPARM_OBJ: 4160 case DEMANGLE_COMPONENT_INITIALIZER_LIST: 4161 case DEMANGLE_COMPONENT_CAST: 4162 case DEMANGLE_COMPONENT_CONVERSION: 4163 case DEMANGLE_COMPONENT_NULLARY: 4164 case DEMANGLE_COMPONENT_UNARY: 4165 case DEMANGLE_COMPONENT_BINARY: 4166 case DEMANGLE_COMPONENT_BINARY_ARGS: 4167 case DEMANGLE_COMPONENT_TRINARY: 4168 case DEMANGLE_COMPONENT_TRINARY_ARG1: 4169 case DEMANGLE_COMPONENT_TRINARY_ARG2: 4170 case DEMANGLE_COMPONENT_LITERAL: 4171 case DEMANGLE_COMPONENT_LITERAL_NEG: 4172 case DEMANGLE_COMPONENT_JAVA_RESOURCE: 4173 case DEMANGLE_COMPONENT_COMPOUND_NAME: 4174 case DEMANGLE_COMPONENT_DECLTYPE: 4175 case DEMANGLE_COMPONENT_TRANSACTION_CLONE: 4176 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: 4177 case DEMANGLE_COMPONENT_PACK_EXPANSION: 4178 case DEMANGLE_COMPONENT_TAGGED_NAME: 4179 case DEMANGLE_COMPONENT_CLONE: 4180 recurse_left_right: 4181 /* PR 89394 - Check for too much recursion. */ 4182 if (dpi->recursion > DEMANGLE_RECURSION_LIMIT) 4183 /* FIXME: There ought to be a way to report to the 4184 user that the recursion limit has been reached. */ 4185 return; 4186 4187 ++ dpi->recursion; 4188 d_count_templates_scopes (dpi, d_left (dc)); 4189 d_count_templates_scopes (dpi, d_right (dc)); 4190 -- dpi->recursion; 4191 break; 4192 4193 case DEMANGLE_COMPONENT_CTOR: 4194 d_count_templates_scopes (dpi, dc->u.s_ctor.name); 4195 break; 4196 4197 case DEMANGLE_COMPONENT_DTOR: 4198 d_count_templates_scopes (dpi, dc->u.s_dtor.name); 4199 break; 4200 4201 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 4202 d_count_templates_scopes (dpi, dc->u.s_extended_operator.name); 4203 break; 4204 4205 case DEMANGLE_COMPONENT_FIXED_TYPE: 4206 d_count_templates_scopes (dpi, dc->u.s_fixed.length); 4207 break; 4208 4209 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: 4210 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: 4211 d_count_templates_scopes (dpi, d_left (dc)); 4212 break; 4213 4214 case DEMANGLE_COMPONENT_LAMBDA: 4215 case DEMANGLE_COMPONENT_DEFAULT_ARG: 4216 d_count_templates_scopes (dpi, dc->u.s_unary_num.sub); 4217 break; 4218 } 4219 } 4220 4221 /* Initialize a print information structure. */ 4222 4223 static void 4224 d_print_init (struct d_print_info *dpi, demangle_callbackref callback, 4225 void *opaque, struct demangle_component *dc) 4226 { 4227 dpi->len = 0; 4228 dpi->last_char = '\0'; 4229 dpi->templates = NULL; 4230 dpi->modifiers = NULL; 4231 dpi->pack_index = 0; 4232 dpi->flush_count = 0; 4233 4234 dpi->callback = callback; 4235 dpi->opaque = opaque; 4236 4237 dpi->demangle_failure = 0; 4238 dpi->recursion = 0; 4239 dpi->is_lambda_arg = 0; 4240 4241 dpi->component_stack = NULL; 4242 4243 dpi->saved_scopes = NULL; 4244 dpi->next_saved_scope = 0; 4245 dpi->num_saved_scopes = 0; 4246 4247 dpi->copy_templates = NULL; 4248 dpi->next_copy_template = 0; 4249 dpi->num_copy_templates = 0; 4250 4251 d_count_templates_scopes (dpi, dc); 4252 /* If we did not reach the recursion limit, then reset the 4253 current recursion value back to 0, so that we can print 4254 the templates. */ 4255 if (dpi->recursion < DEMANGLE_RECURSION_LIMIT) 4256 dpi->recursion = 0; 4257 dpi->num_copy_templates *= dpi->num_saved_scopes; 4258 4259 dpi->current_template = NULL; 4260 } 4261 4262 /* Indicate that an error occurred during printing, and test for error. */ 4263 4264 static inline void 4265 d_print_error (struct d_print_info *dpi) 4266 { 4267 dpi->demangle_failure = 1; 4268 } 4269 4270 static inline int 4271 d_print_saw_error (struct d_print_info *dpi) 4272 { 4273 return dpi->demangle_failure != 0; 4274 } 4275 4276 /* Flush buffered characters to the callback. */ 4277 4278 static inline void 4279 d_print_flush (struct d_print_info *dpi) 4280 { 4281 dpi->buf[dpi->len] = '\0'; 4282 dpi->callback (dpi->buf, dpi->len, dpi->opaque); 4283 dpi->len = 0; 4284 dpi->flush_count++; 4285 } 4286 4287 /* Append characters and buffers for printing. */ 4288 4289 static inline void 4290 d_append_char (struct d_print_info *dpi, char c) 4291 { 4292 if (dpi->len == sizeof (dpi->buf) - 1) 4293 d_print_flush (dpi); 4294 4295 dpi->buf[dpi->len++] = c; 4296 dpi->last_char = c; 4297 } 4298 4299 static inline void 4300 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l) 4301 { 4302 size_t i; 4303 4304 for (i = 0; i < l; i++) 4305 d_append_char (dpi, s[i]); 4306 } 4307 4308 static inline void 4309 d_append_string (struct d_print_info *dpi, const char *s) 4310 { 4311 d_append_buffer (dpi, s, strlen (s)); 4312 } 4313 4314 static inline void 4315 d_append_num (struct d_print_info *dpi, int l) 4316 { 4317 char buf[25]; 4318 sprintf (buf,"%d", l); 4319 d_append_string (dpi, buf); 4320 } 4321 4322 static inline char 4323 d_last_char (struct d_print_info *dpi) 4324 { 4325 return dpi->last_char; 4326 } 4327 4328 /* Turn components into a human readable string. OPTIONS is the 4329 options bits passed to the demangler. DC is the tree to print. 4330 CALLBACK is a function to call to flush demangled string segments 4331 as they fill the intermediate buffer, and OPAQUE is a generalized 4332 callback argument. On success, this returns 1. On failure, 4333 it returns 0, indicating a bad parse. It does not use heap 4334 memory to build an output string, so cannot encounter memory 4335 allocation failure. */ 4336 4337 CP_STATIC_IF_GLIBCPP_V3 4338 int 4339 cplus_demangle_print_callback (int options, 4340 struct demangle_component *dc, 4341 demangle_callbackref callback, void *opaque) 4342 { 4343 struct d_print_info dpi; 4344 4345 d_print_init (&dpi, callback, opaque, dc); 4346 4347 { 4348 #ifdef CP_DYNAMIC_ARRAYS 4349 /* Avoid zero-length VLAs, which are prohibited by the C99 standard 4350 and flagged as errors by Address Sanitizer. */ 4351 __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0) 4352 ? dpi.num_saved_scopes : 1]; 4353 __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0) 4354 ? dpi.num_copy_templates : 1]; 4355 4356 dpi.saved_scopes = scopes; 4357 dpi.copy_templates = temps; 4358 #else 4359 dpi.saved_scopes = alloca (dpi.num_saved_scopes 4360 * sizeof (*dpi.saved_scopes)); 4361 dpi.copy_templates = alloca (dpi.num_copy_templates 4362 * sizeof (*dpi.copy_templates)); 4363 #endif 4364 4365 d_print_comp (&dpi, options, dc); 4366 } 4367 4368 d_print_flush (&dpi); 4369 4370 return ! d_print_saw_error (&dpi); 4371 } 4372 4373 /* Turn components into a human readable string. OPTIONS is the 4374 options bits passed to the demangler. DC is the tree to print. 4375 ESTIMATE is a guess at the length of the result. This returns a 4376 string allocated by malloc, or NULL on error. On success, this 4377 sets *PALC to the size of the allocated buffer. On failure, this 4378 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation 4379 failure. */ 4380 4381 CP_STATIC_IF_GLIBCPP_V3 4382 char * 4383 cplus_demangle_print (int options, struct demangle_component *dc, 4384 int estimate, size_t *palc) 4385 { 4386 struct d_growable_string dgs; 4387 4388 d_growable_string_init (&dgs, estimate); 4389 4390 if (! cplus_demangle_print_callback (options, dc, 4391 d_growable_string_callback_adapter, 4392 &dgs)) 4393 { 4394 free (dgs.buf); 4395 *palc = 0; 4396 return NULL; 4397 } 4398 4399 *palc = dgs.allocation_failure ? 1 : dgs.alc; 4400 return dgs.buf; 4401 } 4402 4403 /* Returns the I'th element of the template arglist ARGS, or NULL on 4404 failure. If I is negative, return the entire arglist. */ 4405 4406 static struct demangle_component * 4407 d_index_template_argument (struct demangle_component *args, int i) 4408 { 4409 struct demangle_component *a; 4410 4411 if (i < 0) 4412 /* Print the whole argument pack. */ 4413 return args; 4414 4415 for (a = args; 4416 a != NULL; 4417 a = d_right (a)) 4418 { 4419 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 4420 return NULL; 4421 if (i <= 0) 4422 break; 4423 --i; 4424 } 4425 if (i != 0 || a == NULL) 4426 return NULL; 4427 4428 return d_left (a); 4429 } 4430 4431 /* Returns the template argument from the current context indicated by DC, 4432 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */ 4433 4434 static struct demangle_component * 4435 d_lookup_template_argument (struct d_print_info *dpi, 4436 const struct demangle_component *dc) 4437 { 4438 if (dpi->templates == NULL) 4439 { 4440 d_print_error (dpi); 4441 return NULL; 4442 } 4443 4444 return d_index_template_argument 4445 (d_right (dpi->templates->template_decl), 4446 dc->u.s_number.number); 4447 } 4448 4449 /* Returns a template argument pack used in DC (any will do), or NULL. */ 4450 4451 static struct demangle_component * 4452 d_find_pack (struct d_print_info *dpi, 4453 const struct demangle_component *dc) 4454 { 4455 struct demangle_component *a; 4456 if (dc == NULL) 4457 return NULL; 4458 4459 switch (dc->type) 4460 { 4461 case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 4462 a = d_lookup_template_argument (dpi, dc); 4463 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 4464 return a; 4465 return NULL; 4466 4467 case DEMANGLE_COMPONENT_PACK_EXPANSION: 4468 return NULL; 4469 4470 case DEMANGLE_COMPONENT_LAMBDA: 4471 case DEMANGLE_COMPONENT_NAME: 4472 case DEMANGLE_COMPONENT_TAGGED_NAME: 4473 case DEMANGLE_COMPONENT_OPERATOR: 4474 case DEMANGLE_COMPONENT_BUILTIN_TYPE: 4475 case DEMANGLE_COMPONENT_SUB_STD: 4476 case DEMANGLE_COMPONENT_CHARACTER: 4477 case DEMANGLE_COMPONENT_FUNCTION_PARAM: 4478 case DEMANGLE_COMPONENT_UNNAMED_TYPE: 4479 case DEMANGLE_COMPONENT_FIXED_TYPE: 4480 case DEMANGLE_COMPONENT_DEFAULT_ARG: 4481 case DEMANGLE_COMPONENT_NUMBER: 4482 return NULL; 4483 4484 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 4485 return d_find_pack (dpi, dc->u.s_extended_operator.name); 4486 case DEMANGLE_COMPONENT_CTOR: 4487 return d_find_pack (dpi, dc->u.s_ctor.name); 4488 case DEMANGLE_COMPONENT_DTOR: 4489 return d_find_pack (dpi, dc->u.s_dtor.name); 4490 4491 default: 4492 a = d_find_pack (dpi, d_left (dc)); 4493 if (a) 4494 return a; 4495 return d_find_pack (dpi, d_right (dc)); 4496 } 4497 } 4498 4499 /* Returns the length of the template argument pack DC. */ 4500 4501 static int 4502 d_pack_length (const struct demangle_component *dc) 4503 { 4504 int count = 0; 4505 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST 4506 && d_left (dc) != NULL) 4507 { 4508 ++count; 4509 dc = d_right (dc); 4510 } 4511 return count; 4512 } 4513 4514 /* Returns the number of template args in DC, expanding any pack expansions 4515 found there. */ 4516 4517 static int 4518 d_args_length (struct d_print_info *dpi, const struct demangle_component *dc) 4519 { 4520 int count = 0; 4521 for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST; 4522 dc = d_right (dc)) 4523 { 4524 struct demangle_component *elt = d_left (dc); 4525 if (elt == NULL) 4526 break; 4527 if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION) 4528 { 4529 struct demangle_component *a = d_find_pack (dpi, d_left (elt)); 4530 count += d_pack_length (a); 4531 } 4532 else 4533 ++count; 4534 } 4535 return count; 4536 } 4537 4538 /* DC is a component of a mangled expression. Print it, wrapped in parens 4539 if needed. */ 4540 4541 static void 4542 d_print_subexpr (struct d_print_info *dpi, int options, 4543 struct demangle_component *dc) 4544 { 4545 int simple = 0; 4546 if (dc->type == DEMANGLE_COMPONENT_NAME 4547 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME 4548 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST 4549 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM) 4550 simple = 1; 4551 if (!simple) 4552 d_append_char (dpi, '('); 4553 d_print_comp (dpi, options, dc); 4554 if (!simple) 4555 d_append_char (dpi, ')'); 4556 } 4557 4558 /* Save the current scope. */ 4559 4560 static void 4561 d_save_scope (struct d_print_info *dpi, 4562 const struct demangle_component *container) 4563 { 4564 struct d_saved_scope *scope; 4565 struct d_print_template *src, **link; 4566 4567 if (dpi->next_saved_scope >= dpi->num_saved_scopes) 4568 { 4569 d_print_error (dpi); 4570 return; 4571 } 4572 scope = &dpi->saved_scopes[dpi->next_saved_scope]; 4573 dpi->next_saved_scope++; 4574 4575 scope->container = container; 4576 link = &scope->templates; 4577 4578 for (src = dpi->templates; src != NULL; src = src->next) 4579 { 4580 struct d_print_template *dst; 4581 4582 if (dpi->next_copy_template >= dpi->num_copy_templates) 4583 { 4584 d_print_error (dpi); 4585 return; 4586 } 4587 dst = &dpi->copy_templates[dpi->next_copy_template]; 4588 dpi->next_copy_template++; 4589 4590 dst->template_decl = src->template_decl; 4591 *link = dst; 4592 link = &dst->next; 4593 } 4594 4595 *link = NULL; 4596 } 4597 4598 /* Attempt to locate a previously saved scope. Returns NULL if no 4599 corresponding saved scope was found. */ 4600 4601 static struct d_saved_scope * 4602 d_get_saved_scope (struct d_print_info *dpi, 4603 const struct demangle_component *container) 4604 { 4605 int i; 4606 4607 for (i = 0; i < dpi->next_saved_scope; i++) 4608 if (dpi->saved_scopes[i].container == container) 4609 return &dpi->saved_scopes[i]; 4610 4611 return NULL; 4612 } 4613 4614 /* If DC is a C++17 fold-expression, print it and return true; otherwise 4615 return false. */ 4616 4617 static int 4618 d_maybe_print_fold_expression (struct d_print_info *dpi, int options, 4619 struct demangle_component *dc) 4620 { 4621 struct demangle_component *ops, *operator_, *op1, *op2; 4622 int save_idx; 4623 4624 const char *fold_code = d_left (dc)->u.s_operator.op->code; 4625 if (fold_code[0] != 'f') 4626 return 0; 4627 4628 ops = d_right (dc); 4629 operator_ = d_left (ops); 4630 op1 = d_right (ops); 4631 op2 = 0; 4632 if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2) 4633 { 4634 op2 = d_right (op1); 4635 op1 = d_left (op1); 4636 } 4637 4638 /* Print the whole pack. */ 4639 save_idx = dpi->pack_index; 4640 dpi->pack_index = -1; 4641 4642 switch (fold_code[1]) 4643 { 4644 /* Unary left fold, (... + X). */ 4645 case 'l': 4646 d_append_string (dpi, "(..."); 4647 d_print_expr_op (dpi, options, operator_); 4648 d_print_subexpr (dpi, options, op1); 4649 d_append_char (dpi, ')'); 4650 break; 4651 4652 /* Unary right fold, (X + ...). */ 4653 case 'r': 4654 d_append_char (dpi, '('); 4655 d_print_subexpr (dpi, options, op1); 4656 d_print_expr_op (dpi, options, operator_); 4657 d_append_string (dpi, "...)"); 4658 break; 4659 4660 /* Binary left fold, (42 + ... + X). */ 4661 case 'L': 4662 /* Binary right fold, (X + ... + 42). */ 4663 case 'R': 4664 d_append_char (dpi, '('); 4665 d_print_subexpr (dpi, options, op1); 4666 d_print_expr_op (dpi, options, operator_); 4667 d_append_string (dpi, "..."); 4668 d_print_expr_op (dpi, options, operator_); 4669 d_print_subexpr (dpi, options, op2); 4670 d_append_char (dpi, ')'); 4671 break; 4672 } 4673 4674 dpi->pack_index = save_idx; 4675 return 1; 4676 } 4677 4678 /* Subroutine to handle components. */ 4679 4680 static void 4681 d_print_comp_inner (struct d_print_info *dpi, int options, 4682 struct demangle_component *dc) 4683 { 4684 /* Magic variable to let reference smashing skip over the next modifier 4685 without needing to modify *dc. */ 4686 struct demangle_component *mod_inner = NULL; 4687 4688 /* Variable used to store the current templates while a previously 4689 captured scope is used. */ 4690 struct d_print_template *saved_templates; 4691 4692 /* Nonzero if templates have been stored in the above variable. */ 4693 int need_template_restore = 0; 4694 4695 if (dc == NULL) 4696 { 4697 d_print_error (dpi); 4698 return; 4699 } 4700 if (d_print_saw_error (dpi)) 4701 return; 4702 4703 switch (dc->type) 4704 { 4705 case DEMANGLE_COMPONENT_NAME: 4706 if ((options & DMGL_JAVA) == 0) 4707 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); 4708 else 4709 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); 4710 return; 4711 4712 case DEMANGLE_COMPONENT_TAGGED_NAME: 4713 d_print_comp (dpi, options, d_left (dc)); 4714 d_append_string (dpi, "[abi:"); 4715 d_print_comp (dpi, options, d_right (dc)); 4716 d_append_char (dpi, ']'); 4717 return; 4718 4719 case DEMANGLE_COMPONENT_QUAL_NAME: 4720 case DEMANGLE_COMPONENT_LOCAL_NAME: 4721 d_print_comp (dpi, options, d_left (dc)); 4722 if ((options & DMGL_JAVA) == 0) 4723 d_append_string (dpi, "::"); 4724 else 4725 d_append_char (dpi, '.'); 4726 { 4727 struct demangle_component *local_name = d_right (dc); 4728 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) 4729 { 4730 d_append_string (dpi, "{default arg#"); 4731 d_append_num (dpi, local_name->u.s_unary_num.num + 1); 4732 d_append_string (dpi, "}::"); 4733 local_name = local_name->u.s_unary_num.sub; 4734 } 4735 d_print_comp (dpi, options, local_name); 4736 } 4737 return; 4738 4739 case DEMANGLE_COMPONENT_TYPED_NAME: 4740 { 4741 struct d_print_mod *hold_modifiers; 4742 struct demangle_component *typed_name; 4743 struct d_print_mod adpm[4]; 4744 unsigned int i; 4745 struct d_print_template dpt; 4746 4747 /* Pass the name down to the type so that it can be printed in 4748 the right place for the type. We also have to pass down 4749 any CV-qualifiers, which apply to the this parameter. */ 4750 hold_modifiers = dpi->modifiers; 4751 dpi->modifiers = 0; 4752 i = 0; 4753 typed_name = d_left (dc); 4754 while (typed_name != NULL) 4755 { 4756 if (i >= sizeof adpm / sizeof adpm[0]) 4757 { 4758 d_print_error (dpi); 4759 return; 4760 } 4761 4762 adpm[i].next = dpi->modifiers; 4763 dpi->modifiers = &adpm[i]; 4764 adpm[i].mod = typed_name; 4765 adpm[i].printed = 0; 4766 adpm[i].templates = dpi->templates; 4767 ++i; 4768 4769 if (!is_fnqual_component_type (typed_name->type)) 4770 break; 4771 4772 typed_name = d_left (typed_name); 4773 } 4774 4775 if (typed_name == NULL) 4776 { 4777 d_print_error (dpi); 4778 return; 4779 } 4780 4781 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then 4782 there may be CV-qualifiers on its right argument which 4783 really apply here; this happens when parsing a class that 4784 is local to a function. */ 4785 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) 4786 { 4787 typed_name = d_right (typed_name); 4788 if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) 4789 typed_name = typed_name->u.s_unary_num.sub; 4790 while (typed_name != NULL 4791 && is_fnqual_component_type (typed_name->type)) 4792 { 4793 if (i >= sizeof adpm / sizeof adpm[0]) 4794 { 4795 d_print_error (dpi); 4796 return; 4797 } 4798 4799 adpm[i] = adpm[i - 1]; 4800 adpm[i].next = &adpm[i - 1]; 4801 dpi->modifiers = &adpm[i]; 4802 4803 adpm[i - 1].mod = typed_name; 4804 adpm[i - 1].printed = 0; 4805 adpm[i - 1].templates = dpi->templates; 4806 ++i; 4807 4808 typed_name = d_left (typed_name); 4809 } 4810 if (typed_name == NULL) 4811 { 4812 d_print_error (dpi); 4813 return; 4814 } 4815 } 4816 4817 /* If typed_name is a template, then it applies to the 4818 function type as well. */ 4819 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 4820 { 4821 dpt.next = dpi->templates; 4822 dpi->templates = &dpt; 4823 dpt.template_decl = typed_name; 4824 } 4825 4826 d_print_comp (dpi, options, d_right (dc)); 4827 4828 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 4829 dpi->templates = dpt.next; 4830 4831 /* If the modifiers didn't get printed by the type, print them 4832 now. */ 4833 while (i > 0) 4834 { 4835 --i; 4836 if (! adpm[i].printed) 4837 { 4838 d_append_char (dpi, ' '); 4839 d_print_mod (dpi, options, adpm[i].mod); 4840 } 4841 } 4842 4843 dpi->modifiers = hold_modifiers; 4844 4845 return; 4846 } 4847 4848 case DEMANGLE_COMPONENT_TEMPLATE: 4849 { 4850 struct d_print_mod *hold_dpm; 4851 struct demangle_component *dcl; 4852 const struct demangle_component *hold_current; 4853 4854 /* This template may need to be referenced by a cast operator 4855 contained in its subtree. */ 4856 hold_current = dpi->current_template; 4857 dpi->current_template = dc; 4858 4859 /* Don't push modifiers into a template definition. Doing so 4860 could give the wrong definition for a template argument. 4861 Instead, treat the template essentially as a name. */ 4862 4863 hold_dpm = dpi->modifiers; 4864 dpi->modifiers = NULL; 4865 4866 dcl = d_left (dc); 4867 4868 if ((options & DMGL_JAVA) != 0 4869 && dcl->type == DEMANGLE_COMPONENT_NAME 4870 && dcl->u.s_name.len == 6 4871 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0) 4872 { 4873 /* Special-case Java arrays, so that JArray<TYPE> appears 4874 instead as TYPE[]. */ 4875 4876 d_print_comp (dpi, options, d_right (dc)); 4877 d_append_string (dpi, "[]"); 4878 } 4879 else 4880 { 4881 d_print_comp (dpi, options, dcl); 4882 if (d_last_char (dpi) == '<') 4883 d_append_char (dpi, ' '); 4884 d_append_char (dpi, '<'); 4885 d_print_comp (dpi, options, d_right (dc)); 4886 /* Avoid generating two consecutive '>' characters, to avoid 4887 the C++ syntactic ambiguity. */ 4888 if (d_last_char (dpi) == '>') 4889 d_append_char (dpi, ' '); 4890 d_append_char (dpi, '>'); 4891 } 4892 4893 dpi->modifiers = hold_dpm; 4894 dpi->current_template = hold_current; 4895 4896 return; 4897 } 4898 4899 case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 4900 if (dpi->is_lambda_arg) 4901 { 4902 /* Show the template parm index, as that's how g++ displays 4903 these, and future proofs us against potential 4904 '[]<typename T> (T *a, T *b) {...}'. */ 4905 d_append_buffer (dpi, "auto:", 5); 4906 d_append_num (dpi, dc->u.s_number.number + 1); 4907 } 4908 else 4909 { 4910 struct d_print_template *hold_dpt; 4911 struct demangle_component *a = d_lookup_template_argument (dpi, dc); 4912 4913 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 4914 a = d_index_template_argument (a, dpi->pack_index); 4915 4916 if (a == NULL) 4917 { 4918 d_print_error (dpi); 4919 return; 4920 } 4921 4922 /* While processing this parameter, we need to pop the list 4923 of templates. This is because the template parameter may 4924 itself be a reference to a parameter of an outer 4925 template. */ 4926 4927 hold_dpt = dpi->templates; 4928 dpi->templates = hold_dpt->next; 4929 4930 d_print_comp (dpi, options, a); 4931 4932 dpi->templates = hold_dpt; 4933 } 4934 return; 4935 4936 case DEMANGLE_COMPONENT_TPARM_OBJ: 4937 d_append_string (dpi, "template parameter object for "); 4938 d_print_comp (dpi, options, d_left (dc)); 4939 return; 4940 4941 case DEMANGLE_COMPONENT_CTOR: 4942 d_print_comp (dpi, options, dc->u.s_ctor.name); 4943 return; 4944 4945 case DEMANGLE_COMPONENT_DTOR: 4946 d_append_char (dpi, '~'); 4947 d_print_comp (dpi, options, dc->u.s_dtor.name); 4948 return; 4949 4950 case DEMANGLE_COMPONENT_VTABLE: 4951 d_append_string (dpi, "vtable for "); 4952 d_print_comp (dpi, options, d_left (dc)); 4953 return; 4954 4955 case DEMANGLE_COMPONENT_VTT: 4956 d_append_string (dpi, "VTT for "); 4957 d_print_comp (dpi, options, d_left (dc)); 4958 return; 4959 4960 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 4961 d_append_string (dpi, "construction vtable for "); 4962 d_print_comp (dpi, options, d_left (dc)); 4963 d_append_string (dpi, "-in-"); 4964 d_print_comp (dpi, options, d_right (dc)); 4965 return; 4966 4967 case DEMANGLE_COMPONENT_TYPEINFO: 4968 d_append_string (dpi, "typeinfo for "); 4969 d_print_comp (dpi, options, d_left (dc)); 4970 return; 4971 4972 case DEMANGLE_COMPONENT_TYPEINFO_NAME: 4973 d_append_string (dpi, "typeinfo name for "); 4974 d_print_comp (dpi, options, d_left (dc)); 4975 return; 4976 4977 case DEMANGLE_COMPONENT_TYPEINFO_FN: 4978 d_append_string (dpi, "typeinfo fn for "); 4979 d_print_comp (dpi, options, d_left (dc)); 4980 return; 4981 4982 case DEMANGLE_COMPONENT_THUNK: 4983 d_append_string (dpi, "non-virtual thunk to "); 4984 d_print_comp (dpi, options, d_left (dc)); 4985 return; 4986 4987 case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 4988 d_append_string (dpi, "virtual thunk to "); 4989 d_print_comp (dpi, options, d_left (dc)); 4990 return; 4991 4992 case DEMANGLE_COMPONENT_COVARIANT_THUNK: 4993 d_append_string (dpi, "covariant return thunk to "); 4994 d_print_comp (dpi, options, d_left (dc)); 4995 return; 4996 4997 case DEMANGLE_COMPONENT_JAVA_CLASS: 4998 d_append_string (dpi, "java Class for "); 4999 d_print_comp (dpi, options, d_left (dc)); 5000 return; 5001 5002 case DEMANGLE_COMPONENT_GUARD: 5003 d_append_string (dpi, "guard variable for "); 5004 d_print_comp (dpi, options, d_left (dc)); 5005 return; 5006 5007 case DEMANGLE_COMPONENT_TLS_INIT: 5008 d_append_string (dpi, "TLS init function for "); 5009 d_print_comp (dpi, options, d_left (dc)); 5010 return; 5011 5012 case DEMANGLE_COMPONENT_TLS_WRAPPER: 5013 d_append_string (dpi, "TLS wrapper function for "); 5014 d_print_comp (dpi, options, d_left (dc)); 5015 return; 5016 5017 case DEMANGLE_COMPONENT_REFTEMP: 5018 d_append_string (dpi, "reference temporary #"); 5019 d_print_comp (dpi, options, d_right (dc)); 5020 d_append_string (dpi, " for "); 5021 d_print_comp (dpi, options, d_left (dc)); 5022 return; 5023 5024 case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 5025 d_append_string (dpi, "hidden alias for "); 5026 d_print_comp (dpi, options, d_left (dc)); 5027 return; 5028 5029 case DEMANGLE_COMPONENT_TRANSACTION_CLONE: 5030 d_append_string (dpi, "transaction clone for "); 5031 d_print_comp (dpi, options, d_left (dc)); 5032 return; 5033 5034 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE: 5035 d_append_string (dpi, "non-transaction clone for "); 5036 d_print_comp (dpi, options, d_left (dc)); 5037 return; 5038 5039 case DEMANGLE_COMPONENT_SUB_STD: 5040 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); 5041 return; 5042 5043 case DEMANGLE_COMPONENT_RESTRICT: 5044 case DEMANGLE_COMPONENT_VOLATILE: 5045 case DEMANGLE_COMPONENT_CONST: 5046 { 5047 struct d_print_mod *pdpm; 5048 5049 /* When printing arrays, it's possible to have cases where the 5050 same CV-qualifier gets pushed on the stack multiple times. 5051 We only need to print it once. */ 5052 5053 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next) 5054 { 5055 if (! pdpm->printed) 5056 { 5057 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT 5058 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE 5059 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST) 5060 break; 5061 if (pdpm->mod->type == dc->type) 5062 { 5063 d_print_comp (dpi, options, d_left (dc)); 5064 return; 5065 } 5066 } 5067 } 5068 } 5069 goto modifier; 5070 5071 case DEMANGLE_COMPONENT_REFERENCE: 5072 case DEMANGLE_COMPONENT_RVALUE_REFERENCE: 5073 { 5074 /* Handle reference smashing: & + && = &. */ 5075 struct demangle_component *sub = d_left (dc); 5076 if (!dpi->is_lambda_arg 5077 && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) 5078 { 5079 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub); 5080 struct demangle_component *a; 5081 5082 if (scope == NULL) 5083 { 5084 /* This is the first time SUB has been traversed. 5085 We need to capture the current templates so 5086 they can be restored if SUB is reentered as a 5087 substitution. */ 5088 d_save_scope (dpi, sub); 5089 if (d_print_saw_error (dpi)) 5090 return; 5091 } 5092 else 5093 { 5094 const struct d_component_stack *dcse; 5095 int found_self_or_parent = 0; 5096 5097 /* This traversal is reentering SUB as a substition. 5098 If we are not beneath SUB or DC in the tree then we 5099 need to restore SUB's template stack temporarily. */ 5100 for (dcse = dpi->component_stack; dcse != NULL; 5101 dcse = dcse->parent) 5102 { 5103 if (dcse->dc == sub 5104 || (dcse->dc == dc 5105 && dcse != dpi->component_stack)) 5106 { 5107 found_self_or_parent = 1; 5108 break; 5109 } 5110 } 5111 5112 if (!found_self_or_parent) 5113 { 5114 saved_templates = dpi->templates; 5115 dpi->templates = scope->templates; 5116 need_template_restore = 1; 5117 } 5118 } 5119 5120 a = d_lookup_template_argument (dpi, sub); 5121 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 5122 a = d_index_template_argument (a, dpi->pack_index); 5123 5124 if (a == NULL) 5125 { 5126 if (need_template_restore) 5127 dpi->templates = saved_templates; 5128 5129 d_print_error (dpi); 5130 return; 5131 } 5132 5133 sub = a; 5134 } 5135 5136 if (sub->type == DEMANGLE_COMPONENT_REFERENCE 5137 || sub->type == dc->type) 5138 dc = sub; 5139 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE) 5140 mod_inner = d_left (sub); 5141 } 5142 /* Fall through. */ 5143 5144 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 5145 case DEMANGLE_COMPONENT_POINTER: 5146 case DEMANGLE_COMPONENT_COMPLEX: 5147 case DEMANGLE_COMPONENT_IMAGINARY: 5148 FNQUAL_COMPONENT_CASE: 5149 modifier: 5150 { 5151 /* We keep a list of modifiers on the stack. */ 5152 struct d_print_mod dpm; 5153 5154 dpm.next = dpi->modifiers; 5155 dpi->modifiers = &dpm; 5156 dpm.mod = dc; 5157 dpm.printed = 0; 5158 dpm.templates = dpi->templates; 5159 5160 if (!mod_inner) 5161 mod_inner = d_left (dc); 5162 5163 d_print_comp (dpi, options, mod_inner); 5164 5165 /* If the modifier didn't get printed by the type, print it 5166 now. */ 5167 if (! dpm.printed) 5168 d_print_mod (dpi, options, dc); 5169 5170 dpi->modifiers = dpm.next; 5171 5172 if (need_template_restore) 5173 dpi->templates = saved_templates; 5174 5175 return; 5176 } 5177 5178 case DEMANGLE_COMPONENT_BUILTIN_TYPE: 5179 if ((options & DMGL_JAVA) == 0) 5180 d_append_buffer (dpi, dc->u.s_builtin.type->name, 5181 dc->u.s_builtin.type->len); 5182 else 5183 d_append_buffer (dpi, dc->u.s_builtin.type->java_name, 5184 dc->u.s_builtin.type->java_len); 5185 return; 5186 5187 case DEMANGLE_COMPONENT_VENDOR_TYPE: 5188 d_print_comp (dpi, options, d_left (dc)); 5189 return; 5190 5191 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 5192 { 5193 if ((options & DMGL_RET_POSTFIX) != 0) 5194 d_print_function_type (dpi, 5195 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), 5196 dc, dpi->modifiers); 5197 5198 /* Print return type if present */ 5199 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0) 5200 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), 5201 d_left (dc)); 5202 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0) 5203 { 5204 struct d_print_mod dpm; 5205 5206 /* We must pass this type down as a modifier in order to 5207 print it in the right location. */ 5208 dpm.next = dpi->modifiers; 5209 dpi->modifiers = &dpm; 5210 dpm.mod = dc; 5211 dpm.printed = 0; 5212 dpm.templates = dpi->templates; 5213 5214 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), 5215 d_left (dc)); 5216 5217 dpi->modifiers = dpm.next; 5218 5219 if (dpm.printed) 5220 return; 5221 5222 /* In standard prefix notation, there is a space between the 5223 return type and the function signature. */ 5224 if ((options & DMGL_RET_POSTFIX) == 0) 5225 d_append_char (dpi, ' '); 5226 } 5227 5228 if ((options & DMGL_RET_POSTFIX) == 0) 5229 d_print_function_type (dpi, 5230 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP), 5231 dc, dpi->modifiers); 5232 5233 return; 5234 } 5235 5236 case DEMANGLE_COMPONENT_ARRAY_TYPE: 5237 { 5238 struct d_print_mod *hold_modifiers; 5239 struct d_print_mod adpm[4]; 5240 unsigned int i; 5241 struct d_print_mod *pdpm; 5242 5243 /* We must pass this type down as a modifier in order to print 5244 multi-dimensional arrays correctly. If the array itself is 5245 CV-qualified, we act as though the element type were 5246 CV-qualified. We do this by copying the modifiers down 5247 rather than fiddling pointers, so that we don't wind up 5248 with a d_print_mod higher on the stack pointing into our 5249 stack frame after we return. */ 5250 5251 hold_modifiers = dpi->modifiers; 5252 5253 adpm[0].next = hold_modifiers; 5254 dpi->modifiers = &adpm[0]; 5255 adpm[0].mod = dc; 5256 adpm[0].printed = 0; 5257 adpm[0].templates = dpi->templates; 5258 5259 i = 1; 5260 pdpm = hold_modifiers; 5261 while (pdpm != NULL 5262 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT 5263 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE 5264 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST)) 5265 { 5266 if (! pdpm->printed) 5267 { 5268 if (i >= sizeof adpm / sizeof adpm[0]) 5269 { 5270 d_print_error (dpi); 5271 return; 5272 } 5273 5274 adpm[i] = *pdpm; 5275 adpm[i].next = dpi->modifiers; 5276 dpi->modifiers = &adpm[i]; 5277 pdpm->printed = 1; 5278 ++i; 5279 } 5280 5281 pdpm = pdpm->next; 5282 } 5283 5284 d_print_comp (dpi, options, d_right (dc)); 5285 5286 dpi->modifiers = hold_modifiers; 5287 5288 if (adpm[0].printed) 5289 return; 5290 5291 while (i > 1) 5292 { 5293 --i; 5294 d_print_mod (dpi, options, adpm[i].mod); 5295 } 5296 5297 d_print_array_type (dpi, options, dc, dpi->modifiers); 5298 5299 return; 5300 } 5301 5302 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 5303 case DEMANGLE_COMPONENT_VECTOR_TYPE: 5304 { 5305 struct d_print_mod dpm; 5306 5307 dpm.next = dpi->modifiers; 5308 dpi->modifiers = &dpm; 5309 dpm.mod = dc; 5310 dpm.printed = 0; 5311 dpm.templates = dpi->templates; 5312 5313 d_print_comp (dpi, options, d_right (dc)); 5314 5315 /* If the modifier didn't get printed by the type, print it 5316 now. */ 5317 if (! dpm.printed) 5318 d_print_mod (dpi, options, dc); 5319 5320 dpi->modifiers = dpm.next; 5321 5322 return; 5323 } 5324 5325 case DEMANGLE_COMPONENT_FIXED_TYPE: 5326 if (dc->u.s_fixed.sat) 5327 d_append_string (dpi, "_Sat "); 5328 /* Don't print "int _Accum". */ 5329 if (dc->u.s_fixed.length->u.s_builtin.type 5330 != &cplus_demangle_builtin_types['i'-'a']) 5331 { 5332 d_print_comp (dpi, options, dc->u.s_fixed.length); 5333 d_append_char (dpi, ' '); 5334 } 5335 if (dc->u.s_fixed.accum) 5336 d_append_string (dpi, "_Accum"); 5337 else 5338 d_append_string (dpi, "_Fract"); 5339 return; 5340 5341 case DEMANGLE_COMPONENT_ARGLIST: 5342 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 5343 if (d_left (dc) != NULL) 5344 d_print_comp (dpi, options, d_left (dc)); 5345 if (d_right (dc) != NULL) 5346 { 5347 size_t len; 5348 unsigned long int flush_count; 5349 /* Make sure ", " isn't flushed by d_append_string, otherwise 5350 dpi->len -= 2 wouldn't work. */ 5351 if (dpi->len >= sizeof (dpi->buf) - 2) 5352 d_print_flush (dpi); 5353 d_append_string (dpi, ", "); 5354 len = dpi->len; 5355 flush_count = dpi->flush_count; 5356 d_print_comp (dpi, options, d_right (dc)); 5357 /* If that didn't print anything (which can happen with empty 5358 template argument packs), remove the comma and space. */ 5359 if (dpi->flush_count == flush_count && dpi->len == len) 5360 dpi->len -= 2; 5361 } 5362 return; 5363 5364 case DEMANGLE_COMPONENT_INITIALIZER_LIST: 5365 { 5366 struct demangle_component *type = d_left (dc); 5367 struct demangle_component *list = d_right (dc); 5368 5369 if (type) 5370 d_print_comp (dpi, options, type); 5371 d_append_char (dpi, '{'); 5372 d_print_comp (dpi, options, list); 5373 d_append_char (dpi, '}'); 5374 } 5375 return; 5376 5377 case DEMANGLE_COMPONENT_OPERATOR: 5378 { 5379 const struct demangle_operator_info *op = dc->u.s_operator.op; 5380 int len = op->len; 5381 5382 d_append_string (dpi, "operator"); 5383 /* Add a space before new/delete. */ 5384 if (IS_LOWER (op->name[0])) 5385 d_append_char (dpi, ' '); 5386 /* Omit a trailing space. */ 5387 if (op->name[len-1] == ' ') 5388 --len; 5389 d_append_buffer (dpi, op->name, len); 5390 return; 5391 } 5392 5393 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 5394 d_append_string (dpi, "operator "); 5395 d_print_comp (dpi, options, dc->u.s_extended_operator.name); 5396 return; 5397 5398 case DEMANGLE_COMPONENT_CONVERSION: 5399 d_append_string (dpi, "operator "); 5400 d_print_conversion (dpi, options, dc); 5401 return; 5402 5403 case DEMANGLE_COMPONENT_NULLARY: 5404 d_print_expr_op (dpi, options, d_left (dc)); 5405 return; 5406 5407 case DEMANGLE_COMPONENT_UNARY: 5408 { 5409 struct demangle_component *op = d_left (dc); 5410 struct demangle_component *operand = d_right (dc); 5411 const char *code = NULL; 5412 5413 if (op->type == DEMANGLE_COMPONENT_OPERATOR) 5414 { 5415 code = op->u.s_operator.op->code; 5416 if (!strcmp (code, "ad")) 5417 { 5418 /* Don't print the argument list for the address of a 5419 function. */ 5420 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME 5421 && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME 5422 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) 5423 operand = d_left (operand); 5424 } 5425 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS) 5426 { 5427 /* This indicates a suffix operator. */ 5428 operand = d_left (operand); 5429 d_print_subexpr (dpi, options, operand); 5430 d_print_expr_op (dpi, options, op); 5431 return; 5432 } 5433 } 5434 5435 /* For sizeof..., just print the pack length. */ 5436 if (code && !strcmp (code, "sZ")) 5437 { 5438 struct demangle_component *a = d_find_pack (dpi, operand); 5439 int len = d_pack_length (a); 5440 d_append_num (dpi, len); 5441 return; 5442 } 5443 else if (code && !strcmp (code, "sP")) 5444 { 5445 int len = d_args_length (dpi, operand); 5446 d_append_num (dpi, len); 5447 return; 5448 } 5449 5450 if (op->type != DEMANGLE_COMPONENT_CAST) 5451 d_print_expr_op (dpi, options, op); 5452 else 5453 { 5454 d_append_char (dpi, '('); 5455 d_print_cast (dpi, options, op); 5456 d_append_char (dpi, ')'); 5457 } 5458 if (code && !strcmp (code, "gs")) 5459 /* Avoid parens after '::'. */ 5460 d_print_comp (dpi, options, operand); 5461 else if (code && !strcmp (code, "st")) 5462 /* Always print parens for sizeof (type). */ 5463 { 5464 d_append_char (dpi, '('); 5465 d_print_comp (dpi, options, operand); 5466 d_append_char (dpi, ')'); 5467 } 5468 else 5469 d_print_subexpr (dpi, options, operand); 5470 } 5471 return; 5472 5473 case DEMANGLE_COMPONENT_BINARY: 5474 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) 5475 { 5476 d_print_error (dpi); 5477 return; 5478 } 5479 5480 if (op_is_new_cast (d_left (dc))) 5481 { 5482 d_print_expr_op (dpi, options, d_left (dc)); 5483 d_append_char (dpi, '<'); 5484 d_print_comp (dpi, options, d_left (d_right (dc))); 5485 d_append_string (dpi, ">("); 5486 d_print_comp (dpi, options, d_right (d_right (dc))); 5487 d_append_char (dpi, ')'); 5488 return; 5489 } 5490 5491 if (d_maybe_print_fold_expression (dpi, options, dc)) 5492 return; 5493 5494 /* We wrap an expression which uses the greater-than operator in 5495 an extra layer of parens so that it does not get confused 5496 with the '>' which ends the template parameters. */ 5497 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 5498 && d_left (dc)->u.s_operator.op->len == 1 5499 && d_left (dc)->u.s_operator.op->name[0] == '>') 5500 d_append_char (dpi, '('); 5501 5502 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0 5503 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME) 5504 { 5505 /* Function call used in an expression should not have printed types 5506 of the function arguments. Values of the function arguments still 5507 get printed below. */ 5508 5509 const struct demangle_component *func = d_left (d_right (dc)); 5510 5511 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) 5512 d_print_error (dpi); 5513 d_print_subexpr (dpi, options, d_left (func)); 5514 } 5515 else 5516 d_print_subexpr (dpi, options, d_left (d_right (dc))); 5517 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0) 5518 { 5519 d_append_char (dpi, '['); 5520 d_print_comp (dpi, options, d_right (d_right (dc))); 5521 d_append_char (dpi, ']'); 5522 } 5523 else 5524 { 5525 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0) 5526 d_print_expr_op (dpi, options, d_left (dc)); 5527 d_print_subexpr (dpi, options, d_right (d_right (dc))); 5528 } 5529 5530 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 5531 && d_left (dc)->u.s_operator.op->len == 1 5532 && d_left (dc)->u.s_operator.op->name[0] == '>') 5533 d_append_char (dpi, ')'); 5534 5535 return; 5536 5537 case DEMANGLE_COMPONENT_BINARY_ARGS: 5538 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ 5539 d_print_error (dpi); 5540 return; 5541 5542 case DEMANGLE_COMPONENT_TRINARY: 5543 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 5544 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) 5545 { 5546 d_print_error (dpi); 5547 return; 5548 } 5549 if (d_maybe_print_fold_expression (dpi, options, dc)) 5550 return; 5551 { 5552 struct demangle_component *op = d_left (dc); 5553 struct demangle_component *first = d_left (d_right (dc)); 5554 struct demangle_component *second = d_left (d_right (d_right (dc))); 5555 struct demangle_component *third = d_right (d_right (d_right (dc))); 5556 5557 if (!strcmp (op->u.s_operator.op->code, "qu")) 5558 { 5559 d_print_subexpr (dpi, options, first); 5560 d_print_expr_op (dpi, options, op); 5561 d_print_subexpr (dpi, options, second); 5562 d_append_string (dpi, " : "); 5563 d_print_subexpr (dpi, options, third); 5564 } 5565 else 5566 { 5567 d_append_string (dpi, "new "); 5568 if (d_left (first) != NULL) 5569 { 5570 d_print_subexpr (dpi, options, first); 5571 d_append_char (dpi, ' '); 5572 } 5573 d_print_comp (dpi, options, second); 5574 if (third) 5575 d_print_subexpr (dpi, options, third); 5576 } 5577 } 5578 return; 5579 5580 case DEMANGLE_COMPONENT_TRINARY_ARG1: 5581 case DEMANGLE_COMPONENT_TRINARY_ARG2: 5582 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */ 5583 d_print_error (dpi); 5584 return; 5585 5586 case DEMANGLE_COMPONENT_LITERAL: 5587 case DEMANGLE_COMPONENT_LITERAL_NEG: 5588 { 5589 enum d_builtin_type_print tp; 5590 5591 /* For some builtin types, produce simpler output. */ 5592 tp = D_PRINT_DEFAULT; 5593 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) 5594 { 5595 tp = d_left (dc)->u.s_builtin.type->print; 5596 switch (tp) 5597 { 5598 case D_PRINT_INT: 5599 case D_PRINT_UNSIGNED: 5600 case D_PRINT_LONG: 5601 case D_PRINT_UNSIGNED_LONG: 5602 case D_PRINT_LONG_LONG: 5603 case D_PRINT_UNSIGNED_LONG_LONG: 5604 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) 5605 { 5606 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 5607 d_append_char (dpi, '-'); 5608 d_print_comp (dpi, options, d_right (dc)); 5609 switch (tp) 5610 { 5611 default: 5612 break; 5613 case D_PRINT_UNSIGNED: 5614 d_append_char (dpi, 'u'); 5615 break; 5616 case D_PRINT_LONG: 5617 d_append_char (dpi, 'l'); 5618 break; 5619 case D_PRINT_UNSIGNED_LONG: 5620 d_append_string (dpi, "ul"); 5621 break; 5622 case D_PRINT_LONG_LONG: 5623 d_append_string (dpi, "ll"); 5624 break; 5625 case D_PRINT_UNSIGNED_LONG_LONG: 5626 d_append_string (dpi, "ull"); 5627 break; 5628 } 5629 return; 5630 } 5631 break; 5632 5633 case D_PRINT_BOOL: 5634 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME 5635 && d_right (dc)->u.s_name.len == 1 5636 && dc->type == DEMANGLE_COMPONENT_LITERAL) 5637 { 5638 switch (d_right (dc)->u.s_name.s[0]) 5639 { 5640 case '0': 5641 d_append_string (dpi, "false"); 5642 return; 5643 case '1': 5644 d_append_string (dpi, "true"); 5645 return; 5646 default: 5647 break; 5648 } 5649 } 5650 break; 5651 5652 default: 5653 break; 5654 } 5655 } 5656 5657 d_append_char (dpi, '('); 5658 d_print_comp (dpi, options, d_left (dc)); 5659 d_append_char (dpi, ')'); 5660 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 5661 d_append_char (dpi, '-'); 5662 if (tp == D_PRINT_FLOAT) 5663 d_append_char (dpi, '['); 5664 d_print_comp (dpi, options, d_right (dc)); 5665 if (tp == D_PRINT_FLOAT) 5666 d_append_char (dpi, ']'); 5667 } 5668 return; 5669 5670 case DEMANGLE_COMPONENT_NUMBER: 5671 d_append_num (dpi, dc->u.s_number.number); 5672 return; 5673 5674 case DEMANGLE_COMPONENT_JAVA_RESOURCE: 5675 d_append_string (dpi, "java resource "); 5676 d_print_comp (dpi, options, d_left (dc)); 5677 return; 5678 5679 case DEMANGLE_COMPONENT_COMPOUND_NAME: 5680 d_print_comp (dpi, options, d_left (dc)); 5681 d_print_comp (dpi, options, d_right (dc)); 5682 return; 5683 5684 case DEMANGLE_COMPONENT_CHARACTER: 5685 d_append_char (dpi, dc->u.s_character.character); 5686 return; 5687 5688 case DEMANGLE_COMPONENT_DECLTYPE: 5689 d_append_string (dpi, "decltype ("); 5690 d_print_comp (dpi, options, d_left (dc)); 5691 d_append_char (dpi, ')'); 5692 return; 5693 5694 case DEMANGLE_COMPONENT_PACK_EXPANSION: 5695 { 5696 int len; 5697 int i; 5698 struct demangle_component *a = d_find_pack (dpi, d_left (dc)); 5699 if (a == NULL) 5700 { 5701 /* d_find_pack won't find anything if the only packs involved 5702 in this expansion are function parameter packs; in that 5703 case, just print the pattern and "...". */ 5704 d_print_subexpr (dpi, options, d_left (dc)); 5705 d_append_string (dpi, "..."); 5706 return; 5707 } 5708 5709 len = d_pack_length (a); 5710 dc = d_left (dc); 5711 for (i = 0; i < len; ++i) 5712 { 5713 dpi->pack_index = i; 5714 d_print_comp (dpi, options, dc); 5715 if (i < len-1) 5716 d_append_string (dpi, ", "); 5717 } 5718 } 5719 return; 5720 5721 case DEMANGLE_COMPONENT_FUNCTION_PARAM: 5722 { 5723 long num = dc->u.s_number.number; 5724 if (num == 0) 5725 d_append_string (dpi, "this"); 5726 else 5727 { 5728 d_append_string (dpi, "{parm#"); 5729 d_append_num (dpi, num); 5730 d_append_char (dpi, '}'); 5731 } 5732 } 5733 return; 5734 5735 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS: 5736 d_append_string (dpi, "global constructors keyed to "); 5737 d_print_comp (dpi, options, dc->u.s_binary.left); 5738 return; 5739 5740 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS: 5741 d_append_string (dpi, "global destructors keyed to "); 5742 d_print_comp (dpi, options, dc->u.s_binary.left); 5743 return; 5744 5745 case DEMANGLE_COMPONENT_LAMBDA: 5746 d_append_string (dpi, "{lambda("); 5747 /* Generic lambda auto parms are mangled as the template type 5748 parm they are. */ 5749 dpi->is_lambda_arg++; 5750 d_print_comp (dpi, options, dc->u.s_unary_num.sub); 5751 dpi->is_lambda_arg--; 5752 d_append_string (dpi, ")#"); 5753 d_append_num (dpi, dc->u.s_unary_num.num + 1); 5754 d_append_char (dpi, '}'); 5755 return; 5756 5757 case DEMANGLE_COMPONENT_UNNAMED_TYPE: 5758 d_append_string (dpi, "{unnamed type#"); 5759 d_append_num (dpi, dc->u.s_number.number + 1); 5760 d_append_char (dpi, '}'); 5761 return; 5762 5763 case DEMANGLE_COMPONENT_CLONE: 5764 d_print_comp (dpi, options, d_left (dc)); 5765 d_append_string (dpi, " [clone "); 5766 d_print_comp (dpi, options, d_right (dc)); 5767 d_append_char (dpi, ']'); 5768 return; 5769 5770 default: 5771 d_print_error (dpi); 5772 return; 5773 } 5774 } 5775 5776 static void 5777 d_print_comp (struct d_print_info *dpi, int options, 5778 struct demangle_component *dc) 5779 { 5780 struct d_component_stack self; 5781 if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT) 5782 { 5783 d_print_error (dpi); 5784 return; 5785 } 5786 5787 dc->d_printing++; 5788 dpi->recursion++; 5789 5790 self.dc = dc; 5791 self.parent = dpi->component_stack; 5792 dpi->component_stack = &self; 5793 5794 d_print_comp_inner (dpi, options, dc); 5795 5796 dpi->component_stack = self.parent; 5797 dc->d_printing--; 5798 dpi->recursion--; 5799 } 5800 5801 /* Print a Java dentifier. For Java we try to handle encoded extended 5802 Unicode characters. The C++ ABI doesn't mention Unicode encoding, 5803 so we don't it for C++. Characters are encoded as 5804 __U<hex-char>+_. */ 5805 5806 static void 5807 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len) 5808 { 5809 const char *p; 5810 const char *end; 5811 5812 end = name + len; 5813 for (p = name; p < end; ++p) 5814 { 5815 if (end - p > 3 5816 && p[0] == '_' 5817 && p[1] == '_' 5818 && p[2] == 'U') 5819 { 5820 unsigned long c; 5821 const char *q; 5822 5823 c = 0; 5824 for (q = p + 3; q < end; ++q) 5825 { 5826 int dig; 5827 5828 if (IS_DIGIT (*q)) 5829 dig = *q - '0'; 5830 else if (*q >= 'A' && *q <= 'F') 5831 dig = *q - 'A' + 10; 5832 else if (*q >= 'a' && *q <= 'f') 5833 dig = *q - 'a' + 10; 5834 else 5835 break; 5836 5837 c = c * 16 + dig; 5838 } 5839 /* If the Unicode character is larger than 256, we don't try 5840 to deal with it here. FIXME. */ 5841 if (q < end && *q == '_' && c < 256) 5842 { 5843 d_append_char (dpi, c); 5844 p = q; 5845 continue; 5846 } 5847 } 5848 5849 d_append_char (dpi, *p); 5850 } 5851 } 5852 5853 /* Print a list of modifiers. SUFFIX is 1 if we are printing 5854 qualifiers on this after printing a function. */ 5855 5856 static void 5857 d_print_mod_list (struct d_print_info *dpi, int options, 5858 struct d_print_mod *mods, int suffix) 5859 { 5860 struct d_print_template *hold_dpt; 5861 5862 if (mods == NULL || d_print_saw_error (dpi)) 5863 return; 5864 5865 if (mods->printed 5866 || (! suffix 5867 && (is_fnqual_component_type (mods->mod->type)))) 5868 { 5869 d_print_mod_list (dpi, options, mods->next, suffix); 5870 return; 5871 } 5872 5873 mods->printed = 1; 5874 5875 hold_dpt = dpi->templates; 5876 dpi->templates = mods->templates; 5877 5878 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) 5879 { 5880 d_print_function_type (dpi, options, mods->mod, mods->next); 5881 dpi->templates = hold_dpt; 5882 return; 5883 } 5884 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 5885 { 5886 d_print_array_type (dpi, options, mods->mod, mods->next); 5887 dpi->templates = hold_dpt; 5888 return; 5889 } 5890 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) 5891 { 5892 struct d_print_mod *hold_modifiers; 5893 struct demangle_component *dc; 5894 5895 /* When this is on the modifier stack, we have pulled any 5896 qualifiers off the right argument already. Otherwise, we 5897 print it as usual, but don't let the left argument see any 5898 modifiers. */ 5899 5900 hold_modifiers = dpi->modifiers; 5901 dpi->modifiers = NULL; 5902 d_print_comp (dpi, options, d_left (mods->mod)); 5903 dpi->modifiers = hold_modifiers; 5904 5905 if ((options & DMGL_JAVA) == 0) 5906 d_append_string (dpi, "::"); 5907 else 5908 d_append_char (dpi, '.'); 5909 5910 dc = d_right (mods->mod); 5911 5912 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG) 5913 { 5914 d_append_string (dpi, "{default arg#"); 5915 d_append_num (dpi, dc->u.s_unary_num.num + 1); 5916 d_append_string (dpi, "}::"); 5917 dc = dc->u.s_unary_num.sub; 5918 } 5919 5920 while (is_fnqual_component_type (dc->type)) 5921 dc = d_left (dc); 5922 5923 d_print_comp (dpi, options, dc); 5924 5925 dpi->templates = hold_dpt; 5926 return; 5927 } 5928 5929 d_print_mod (dpi, options, mods->mod); 5930 5931 dpi->templates = hold_dpt; 5932 5933 d_print_mod_list (dpi, options, mods->next, suffix); 5934 } 5935 5936 /* Print a modifier. */ 5937 5938 static void 5939 d_print_mod (struct d_print_info *dpi, int options, 5940 struct demangle_component *mod) 5941 { 5942 switch (mod->type) 5943 { 5944 case DEMANGLE_COMPONENT_RESTRICT: 5945 case DEMANGLE_COMPONENT_RESTRICT_THIS: 5946 d_append_string (dpi, " restrict"); 5947 return; 5948 case DEMANGLE_COMPONENT_VOLATILE: 5949 case DEMANGLE_COMPONENT_VOLATILE_THIS: 5950 d_append_string (dpi, " volatile"); 5951 return; 5952 case DEMANGLE_COMPONENT_CONST: 5953 case DEMANGLE_COMPONENT_CONST_THIS: 5954 d_append_string (dpi, " const"); 5955 return; 5956 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: 5957 d_append_string (dpi, " transaction_safe"); 5958 return; 5959 case DEMANGLE_COMPONENT_NOEXCEPT: 5960 d_append_string (dpi, " noexcept"); 5961 if (d_right (mod)) 5962 { 5963 d_append_char (dpi, '('); 5964 d_print_comp (dpi, options, d_right (mod)); 5965 d_append_char (dpi, ')'); 5966 } 5967 return; 5968 case DEMANGLE_COMPONENT_THROW_SPEC: 5969 d_append_string (dpi, " throw"); 5970 if (d_right (mod)) 5971 { 5972 d_append_char (dpi, '('); 5973 d_print_comp (dpi, options, d_right (mod)); 5974 d_append_char (dpi, ')'); 5975 } 5976 return; 5977 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 5978 d_append_char (dpi, ' '); 5979 d_print_comp (dpi, options, d_right (mod)); 5980 return; 5981 case DEMANGLE_COMPONENT_POINTER: 5982 /* There is no pointer symbol in Java. */ 5983 if ((options & DMGL_JAVA) == 0) 5984 d_append_char (dpi, '*'); 5985 return; 5986 case DEMANGLE_COMPONENT_REFERENCE_THIS: 5987 /* For the ref-qualifier, put a space before the &. */ 5988 d_append_char (dpi, ' '); 5989 /* FALLTHRU */ 5990 case DEMANGLE_COMPONENT_REFERENCE: 5991 d_append_char (dpi, '&'); 5992 return; 5993 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: 5994 d_append_char (dpi, ' '); 5995 /* FALLTHRU */ 5996 case DEMANGLE_COMPONENT_RVALUE_REFERENCE: 5997 d_append_string (dpi, "&&"); 5998 return; 5999 case DEMANGLE_COMPONENT_COMPLEX: 6000 d_append_string (dpi, " _Complex"); 6001 return; 6002 case DEMANGLE_COMPONENT_IMAGINARY: 6003 d_append_string (dpi, " _Imaginary"); 6004 return; 6005 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 6006 if (d_last_char (dpi) != '(') 6007 d_append_char (dpi, ' '); 6008 d_print_comp (dpi, options, d_left (mod)); 6009 d_append_string (dpi, "::*"); 6010 return; 6011 case DEMANGLE_COMPONENT_TYPED_NAME: 6012 d_print_comp (dpi, options, d_left (mod)); 6013 return; 6014 case DEMANGLE_COMPONENT_VECTOR_TYPE: 6015 d_append_string (dpi, " __vector("); 6016 d_print_comp (dpi, options, d_left (mod)); 6017 d_append_char (dpi, ')'); 6018 return; 6019 6020 default: 6021 /* Otherwise, we have something that won't go back on the 6022 modifier stack, so we can just print it. */ 6023 d_print_comp (dpi, options, mod); 6024 return; 6025 } 6026 } 6027 6028 /* Print a function type, except for the return type. */ 6029 6030 static void 6031 d_print_function_type (struct d_print_info *dpi, int options, 6032 struct demangle_component *dc, 6033 struct d_print_mod *mods) 6034 { 6035 int need_paren; 6036 int need_space; 6037 struct d_print_mod *p; 6038 struct d_print_mod *hold_modifiers; 6039 6040 need_paren = 0; 6041 need_space = 0; 6042 for (p = mods; p != NULL; p = p->next) 6043 { 6044 if (p->printed) 6045 break; 6046 6047 switch (p->mod->type) 6048 { 6049 case DEMANGLE_COMPONENT_POINTER: 6050 case DEMANGLE_COMPONENT_REFERENCE: 6051 case DEMANGLE_COMPONENT_RVALUE_REFERENCE: 6052 need_paren = 1; 6053 break; 6054 case DEMANGLE_COMPONENT_RESTRICT: 6055 case DEMANGLE_COMPONENT_VOLATILE: 6056 case DEMANGLE_COMPONENT_CONST: 6057 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 6058 case DEMANGLE_COMPONENT_COMPLEX: 6059 case DEMANGLE_COMPONENT_IMAGINARY: 6060 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 6061 need_space = 1; 6062 need_paren = 1; 6063 break; 6064 FNQUAL_COMPONENT_CASE: 6065 break; 6066 default: 6067 break; 6068 } 6069 if (need_paren) 6070 break; 6071 } 6072 6073 if (need_paren) 6074 { 6075 if (! need_space) 6076 { 6077 if (d_last_char (dpi) != '(' 6078 && d_last_char (dpi) != '*') 6079 need_space = 1; 6080 } 6081 if (need_space && d_last_char (dpi) != ' ') 6082 d_append_char (dpi, ' '); 6083 d_append_char (dpi, '('); 6084 } 6085 6086 hold_modifiers = dpi->modifiers; 6087 dpi->modifiers = NULL; 6088 6089 d_print_mod_list (dpi, options, mods, 0); 6090 6091 if (need_paren) 6092 d_append_char (dpi, ')'); 6093 6094 d_append_char (dpi, '('); 6095 6096 if (d_right (dc) != NULL) 6097 d_print_comp (dpi, options, d_right (dc)); 6098 6099 d_append_char (dpi, ')'); 6100 6101 d_print_mod_list (dpi, options, mods, 1); 6102 6103 dpi->modifiers = hold_modifiers; 6104 } 6105 6106 /* Print an array type, except for the element type. */ 6107 6108 static void 6109 d_print_array_type (struct d_print_info *dpi, int options, 6110 struct demangle_component *dc, 6111 struct d_print_mod *mods) 6112 { 6113 int need_space; 6114 6115 need_space = 1; 6116 if (mods != NULL) 6117 { 6118 int need_paren; 6119 struct d_print_mod *p; 6120 6121 need_paren = 0; 6122 for (p = mods; p != NULL; p = p->next) 6123 { 6124 if (! p->printed) 6125 { 6126 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 6127 { 6128 need_space = 0; 6129 break; 6130 } 6131 else 6132 { 6133 need_paren = 1; 6134 need_space = 1; 6135 break; 6136 } 6137 } 6138 } 6139 6140 if (need_paren) 6141 d_append_string (dpi, " ("); 6142 6143 d_print_mod_list (dpi, options, mods, 0); 6144 6145 if (need_paren) 6146 d_append_char (dpi, ')'); 6147 } 6148 6149 if (need_space) 6150 d_append_char (dpi, ' '); 6151 6152 d_append_char (dpi, '['); 6153 6154 if (d_left (dc) != NULL) 6155 d_print_comp (dpi, options, d_left (dc)); 6156 6157 d_append_char (dpi, ']'); 6158 } 6159 6160 /* Print an operator in an expression. */ 6161 6162 static void 6163 d_print_expr_op (struct d_print_info *dpi, int options, 6164 struct demangle_component *dc) 6165 { 6166 if (dc->type == DEMANGLE_COMPONENT_OPERATOR) 6167 d_append_buffer (dpi, dc->u.s_operator.op->name, 6168 dc->u.s_operator.op->len); 6169 else 6170 d_print_comp (dpi, options, dc); 6171 } 6172 6173 /* Print a cast. */ 6174 6175 static void 6176 d_print_cast (struct d_print_info *dpi, int options, 6177 struct demangle_component *dc) 6178 { 6179 d_print_comp (dpi, options, d_left (dc)); 6180 } 6181 6182 /* Print a conversion operator. */ 6183 6184 static void 6185 d_print_conversion (struct d_print_info *dpi, int options, 6186 struct demangle_component *dc) 6187 { 6188 struct d_print_template dpt; 6189 6190 /* For a conversion operator, we need the template parameters from 6191 the enclosing template in scope for processing the type. */ 6192 if (dpi->current_template != NULL) 6193 { 6194 dpt.next = dpi->templates; 6195 dpi->templates = &dpt; 6196 dpt.template_decl = dpi->current_template; 6197 } 6198 6199 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) 6200 { 6201 d_print_comp (dpi, options, d_left (dc)); 6202 if (dpi->current_template != NULL) 6203 dpi->templates = dpt.next; 6204 } 6205 else 6206 { 6207 d_print_comp (dpi, options, d_left (d_left (dc))); 6208 6209 /* For a templated cast operator, we need to remove the template 6210 parameters from scope after printing the operator name, 6211 so we need to handle the template printing here. */ 6212 if (dpi->current_template != NULL) 6213 dpi->templates = dpt.next; 6214 6215 if (d_last_char (dpi) == '<') 6216 d_append_char (dpi, ' '); 6217 d_append_char (dpi, '<'); 6218 d_print_comp (dpi, options, d_right (d_left (dc))); 6219 /* Avoid generating two consecutive '>' characters, to avoid 6220 the C++ syntactic ambiguity. */ 6221 if (d_last_char (dpi) == '>') 6222 d_append_char (dpi, ' '); 6223 d_append_char (dpi, '>'); 6224 } 6225 } 6226 6227 /* Initialize the information structure we use to pass around 6228 information. */ 6229 6230 CP_STATIC_IF_GLIBCPP_V3 6231 void 6232 cplus_demangle_init_info (const char *mangled, int options, size_t len, 6233 struct d_info *di) 6234 { 6235 di->s = mangled; 6236 di->send = mangled + len; 6237 di->options = options; 6238 6239 di->n = mangled; 6240 6241 /* We cannot need more components than twice the number of chars in 6242 the mangled string. Most components correspond directly to 6243 chars, but the ARGLIST types are exceptions. */ 6244 di->num_comps = 2 * len; 6245 di->next_comp = 0; 6246 6247 /* Similarly, we cannot need more substitutions than there are 6248 chars in the mangled string. */ 6249 di->num_subs = len; 6250 di->next_sub = 0; 6251 6252 di->last_name = NULL; 6253 6254 di->expansion = 0; 6255 di->is_expression = 0; 6256 di->is_conversion = 0; 6257 di->recursion_level = 0; 6258 } 6259 6260 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI 6261 mangled name, return strings in repeated callback giving the demangled 6262 name. OPTIONS is the usual libiberty demangler options. On success, 6263 this returns 1. On failure, returns 0. */ 6264 6265 static int 6266 d_demangle_callback (const char *mangled, int options, 6267 demangle_callbackref callback, void *opaque) 6268 { 6269 enum 6270 { 6271 DCT_TYPE, 6272 DCT_MANGLED, 6273 DCT_GLOBAL_CTORS, 6274 DCT_GLOBAL_DTORS 6275 } 6276 type; 6277 struct d_info di; 6278 struct demangle_component *dc; 6279 int status; 6280 6281 if (mangled[0] == '_' && mangled[1] == 'Z') 6282 type = DCT_MANGLED; 6283 else if (strncmp (mangled, "_GLOBAL_", 8) == 0 6284 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$') 6285 && (mangled[9] == 'D' || mangled[9] == 'I') 6286 && mangled[10] == '_') 6287 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS; 6288 else 6289 { 6290 if ((options & DMGL_TYPES) == 0) 6291 return 0; 6292 type = DCT_TYPE; 6293 } 6294 6295 cplus_demangle_init_info (mangled, options, strlen (mangled), &di); 6296 6297 /* PR 87675 - Check for a mangled string that is so long 6298 that we do not have enough stack space to demangle it. */ 6299 if (((options & DMGL_NO_RECURSE_LIMIT) == 0) 6300 /* This check is a bit arbitrary, since what we really want to do is to 6301 compare the sizes of the di.comps and di.subs arrays against the 6302 amount of stack space remaining. But there is no portable way to do 6303 this, so instead we use the recursion limit as a guide to the maximum 6304 size of the arrays. */ 6305 && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT) 6306 { 6307 /* FIXME: We need a way to indicate that a stack limit has been reached. */ 6308 return 0; 6309 } 6310 6311 { 6312 #ifdef CP_DYNAMIC_ARRAYS 6313 __extension__ struct demangle_component comps[di.num_comps]; 6314 __extension__ struct demangle_component *subs[di.num_subs]; 6315 6316 di.comps = comps; 6317 di.subs = subs; 6318 #else 6319 di.comps = alloca (di.num_comps * sizeof (*di.comps)); 6320 di.subs = alloca (di.num_subs * sizeof (*di.subs)); 6321 #endif 6322 6323 switch (type) 6324 { 6325 case DCT_TYPE: 6326 dc = cplus_demangle_type (&di); 6327 break; 6328 case DCT_MANGLED: 6329 dc = cplus_demangle_mangled_name (&di, 1); 6330 break; 6331 case DCT_GLOBAL_CTORS: 6332 case DCT_GLOBAL_DTORS: 6333 d_advance (&di, 11); 6334 dc = d_make_comp (&di, 6335 (type == DCT_GLOBAL_CTORS 6336 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS 6337 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS), 6338 d_make_demangle_mangled_name (&di, d_str (&di)), 6339 NULL); 6340 d_advance (&di, strlen (d_str (&di))); 6341 break; 6342 default: 6343 abort (); /* We have listed all the cases. */ 6344 } 6345 6346 /* If DMGL_PARAMS is set, then if we didn't consume the entire 6347 mangled string, then we didn't successfully demangle it. If 6348 DMGL_PARAMS is not set, we didn't look at the trailing 6349 parameters. */ 6350 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') 6351 dc = NULL; 6352 6353 #ifdef CP_DEMANGLE_DEBUG 6354 d_dump (dc, 0); 6355 #endif 6356 6357 status = (dc != NULL) 6358 ? cplus_demangle_print_callback (options, dc, callback, opaque) 6359 : 0; 6360 } 6361 6362 return status; 6363 } 6364 6365 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled 6366 name, return a buffer allocated with malloc holding the demangled 6367 name. OPTIONS is the usual libiberty demangler options. On 6368 success, this sets *PALC to the allocated size of the returned 6369 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for 6370 a memory allocation failure, and returns NULL. */ 6371 6372 static char * 6373 d_demangle (const char *mangled, int options, size_t *palc) 6374 { 6375 struct d_growable_string dgs; 6376 int status; 6377 6378 d_growable_string_init (&dgs, 0); 6379 6380 status = d_demangle_callback (mangled, options, 6381 d_growable_string_callback_adapter, &dgs); 6382 if (status == 0) 6383 { 6384 free (dgs.buf); 6385 *palc = 0; 6386 return NULL; 6387 } 6388 6389 *palc = dgs.allocation_failure ? 1 : dgs.alc; 6390 return dgs.buf; 6391 } 6392 6393 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3) 6394 6395 extern char *__cxa_demangle (const char *, char *, size_t *, int *); 6396 6397 /* ia64 ABI-mandated entry point in the C++ runtime library for 6398 performing demangling. MANGLED_NAME is a NUL-terminated character 6399 string containing the name to be demangled. 6400 6401 OUTPUT_BUFFER is a region of memory, allocated with malloc, of 6402 *LENGTH bytes, into which the demangled name is stored. If 6403 OUTPUT_BUFFER is not long enough, it is expanded using realloc. 6404 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name 6405 is placed in a region of memory allocated with malloc. 6406 6407 If LENGTH is non-NULL, the length of the buffer containing the 6408 demangled name, is placed in *LENGTH. 6409 6410 The return value is a pointer to the start of the NUL-terminated 6411 demangled name, or NULL if the demangling fails. The caller is 6412 responsible for deallocating this memory using free. 6413 6414 *STATUS is set to one of the following values: 6415 0: The demangling operation succeeded. 6416 -1: A memory allocation failure occurred. 6417 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules. 6418 -3: One of the arguments is invalid. 6419 6420 The demangling is performed using the C++ ABI mangling rules, with 6421 GNU extensions. */ 6422 6423 char * 6424 __cxa_demangle (const char *mangled_name, char *output_buffer, 6425 size_t *length, int *status) 6426 { 6427 char *demangled; 6428 size_t alc; 6429 6430 if (mangled_name == NULL) 6431 { 6432 if (status != NULL) 6433 *status = -3; 6434 return NULL; 6435 } 6436 6437 if (output_buffer != NULL && length == NULL) 6438 { 6439 if (status != NULL) 6440 *status = -3; 6441 return NULL; 6442 } 6443 6444 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc); 6445 6446 if (demangled == NULL) 6447 { 6448 if (status != NULL) 6449 { 6450 if (alc == 1) 6451 *status = -1; 6452 else 6453 *status = -2; 6454 } 6455 return NULL; 6456 } 6457 6458 if (output_buffer == NULL) 6459 { 6460 if (length != NULL) 6461 *length = alc; 6462 } 6463 else 6464 { 6465 if (strlen (demangled) < *length) 6466 { 6467 strcpy (output_buffer, demangled); 6468 free (demangled); 6469 demangled = output_buffer; 6470 } 6471 else 6472 { 6473 free (output_buffer); 6474 *length = alc; 6475 } 6476 } 6477 6478 if (status != NULL) 6479 *status = 0; 6480 6481 return demangled; 6482 } 6483 6484 extern int __gcclibcxx_demangle_callback (const char *, 6485 void (*) 6486 (const char *, size_t, void *), 6487 void *); 6488 6489 /* Alternative, allocationless entry point in the C++ runtime library 6490 for performing demangling. MANGLED_NAME is a NUL-terminated character 6491 string containing the name to be demangled. 6492 6493 CALLBACK is a callback function, called with demangled string 6494 segments as demangling progresses; it is called at least once, 6495 but may be called more than once. OPAQUE is a generalized pointer 6496 used as a callback argument. 6497 6498 The return code is one of the following values, equivalent to 6499 the STATUS values of __cxa_demangle() (excluding -1, since this 6500 function performs no memory allocations): 6501 0: The demangling operation succeeded. 6502 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules. 6503 -3: One of the arguments is invalid. 6504 6505 The demangling is performed using the C++ ABI mangling rules, with 6506 GNU extensions. */ 6507 6508 int 6509 __gcclibcxx_demangle_callback (const char *mangled_name, 6510 void (*callback) (const char *, size_t, void *), 6511 void *opaque) 6512 { 6513 int status; 6514 6515 if (mangled_name == NULL || callback == NULL) 6516 return -3; 6517 6518 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES, 6519 callback, opaque); 6520 if (status == 0) 6521 return -2; 6522 6523 return 0; 6524 } 6525 6526 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */ 6527 6528 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI 6529 mangled name, return a buffer allocated with malloc holding the 6530 demangled name. Otherwise, return NULL. */ 6531 6532 char * 6533 cplus_demangle_v3 (const char *mangled, int options) 6534 { 6535 size_t alc; 6536 6537 return d_demangle (mangled, options, &alc); 6538 } 6539 6540 int 6541 cplus_demangle_v3_callback (const char *mangled, int options, 6542 demangle_callbackref callback, void *opaque) 6543 { 6544 return d_demangle_callback (mangled, options, callback, opaque); 6545 } 6546 6547 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling 6548 conventions, but the output formatting is a little different. 6549 This instructs the C++ demangler not to emit pointer characters ("*"), to 6550 use Java's namespace separator symbol ("." instead of "::"), and to output 6551 JArray<TYPE> as TYPE[]. */ 6552 6553 char * 6554 java_demangle_v3 (const char *mangled) 6555 { 6556 size_t alc; 6557 6558 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc); 6559 } 6560 6561 int 6562 java_demangle_v3_callback (const char *mangled, 6563 demangle_callbackref callback, void *opaque) 6564 { 6565 return d_demangle_callback (mangled, 6566 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 6567 callback, opaque); 6568 } 6569 6570 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */ 6571 6572 #ifndef IN_GLIBCPP_V3 6573 6574 /* Demangle a string in order to find out whether it is a constructor 6575 or destructor. Return non-zero on success. Set *CTOR_KIND and 6576 *DTOR_KIND appropriately. */ 6577 6578 static int 6579 is_ctor_or_dtor (const char *mangled, 6580 enum gnu_v3_ctor_kinds *ctor_kind, 6581 enum gnu_v3_dtor_kinds *dtor_kind) 6582 { 6583 struct d_info di; 6584 struct demangle_component *dc; 6585 int ret; 6586 6587 *ctor_kind = (enum gnu_v3_ctor_kinds) 0; 6588 *dtor_kind = (enum gnu_v3_dtor_kinds) 0; 6589 6590 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); 6591 6592 { 6593 #ifdef CP_DYNAMIC_ARRAYS 6594 __extension__ struct demangle_component comps[di.num_comps]; 6595 __extension__ struct demangle_component *subs[di.num_subs]; 6596 6597 di.comps = comps; 6598 di.subs = subs; 6599 #else 6600 di.comps = alloca (di.num_comps * sizeof (*di.comps)); 6601 di.subs = alloca (di.num_subs * sizeof (*di.subs)); 6602 #endif 6603 6604 dc = cplus_demangle_mangled_name (&di, 1); 6605 6606 /* Note that because we did not pass DMGL_PARAMS, we don't expect 6607 to demangle the entire string. */ 6608 6609 ret = 0; 6610 while (dc != NULL) 6611 { 6612 switch (dc->type) 6613 { 6614 /* These cannot appear on a constructor or destructor. */ 6615 case DEMANGLE_COMPONENT_RESTRICT_THIS: 6616 case DEMANGLE_COMPONENT_VOLATILE_THIS: 6617 case DEMANGLE_COMPONENT_CONST_THIS: 6618 case DEMANGLE_COMPONENT_REFERENCE_THIS: 6619 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: 6620 default: 6621 dc = NULL; 6622 break; 6623 case DEMANGLE_COMPONENT_TYPED_NAME: 6624 case DEMANGLE_COMPONENT_TEMPLATE: 6625 dc = d_left (dc); 6626 break; 6627 case DEMANGLE_COMPONENT_QUAL_NAME: 6628 case DEMANGLE_COMPONENT_LOCAL_NAME: 6629 dc = d_right (dc); 6630 break; 6631 case DEMANGLE_COMPONENT_CTOR: 6632 *ctor_kind = dc->u.s_ctor.kind; 6633 ret = 1; 6634 dc = NULL; 6635 break; 6636 case DEMANGLE_COMPONENT_DTOR: 6637 *dtor_kind = dc->u.s_dtor.kind; 6638 ret = 1; 6639 dc = NULL; 6640 break; 6641 } 6642 } 6643 } 6644 6645 return ret; 6646 } 6647 6648 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor 6649 name. A non-zero return indicates the type of constructor. */ 6650 6651 enum gnu_v3_ctor_kinds 6652 is_gnu_v3_mangled_ctor (const char *name) 6653 { 6654 enum gnu_v3_ctor_kinds ctor_kind; 6655 enum gnu_v3_dtor_kinds dtor_kind; 6656 6657 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 6658 return (enum gnu_v3_ctor_kinds) 0; 6659 return ctor_kind; 6660 } 6661 6662 6663 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor 6664 name. A non-zero return indicates the type of destructor. */ 6665 6666 enum gnu_v3_dtor_kinds 6667 is_gnu_v3_mangled_dtor (const char *name) 6668 { 6669 enum gnu_v3_ctor_kinds ctor_kind; 6670 enum gnu_v3_dtor_kinds dtor_kind; 6671 6672 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 6673 return (enum gnu_v3_dtor_kinds) 0; 6674 return dtor_kind; 6675 } 6676 6677 #endif /* IN_GLIBCPP_V3 */ 6678 6679 #ifdef STANDALONE_DEMANGLER 6680 6681 #include "getopt.h" 6682 #include "dyn-string.h" 6683 6684 static void print_usage (FILE* fp, int exit_value); 6685 6686 #define IS_ALPHA(CHAR) \ 6687 (((CHAR) >= 'a' && (CHAR) <= 'z') \ 6688 || ((CHAR) >= 'A' && (CHAR) <= 'Z')) 6689 6690 /* Non-zero if CHAR is a character than can occur in a mangled name. */ 6691 #define is_mangled_char(CHAR) \ 6692 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \ 6693 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$') 6694 6695 /* The name of this program, as invoked. */ 6696 const char* program_name; 6697 6698 /* Prints usage summary to FP and then exits with EXIT_VALUE. */ 6699 6700 static void 6701 print_usage (FILE* fp, int exit_value) 6702 { 6703 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name); 6704 fprintf (fp, "Options:\n"); 6705 fprintf (fp, " -h,--help Display this message.\n"); 6706 fprintf (fp, " -p,--no-params Don't display function parameters\n"); 6707 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n"); 6708 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n"); 6709 6710 exit (exit_value); 6711 } 6712 6713 /* Option specification for getopt_long. */ 6714 static const struct option long_options[] = 6715 { 6716 { "help", no_argument, NULL, 'h' }, 6717 { "no-params", no_argument, NULL, 'p' }, 6718 { "verbose", no_argument, NULL, 'v' }, 6719 { NULL, no_argument, NULL, 0 }, 6720 }; 6721 6722 /* Main entry for a demangling filter executable. It will demangle 6723 its command line arguments, if any. If none are provided, it will 6724 filter stdin to stdout, replacing any recognized mangled C++ names 6725 with their demangled equivalents. */ 6726 6727 int 6728 main (int argc, char *argv[]) 6729 { 6730 int i; 6731 int opt_char; 6732 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 6733 6734 /* Use the program name of this program, as invoked. */ 6735 program_name = argv[0]; 6736 6737 /* Parse options. */ 6738 do 6739 { 6740 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL); 6741 switch (opt_char) 6742 { 6743 case '?': /* Unrecognized option. */ 6744 print_usage (stderr, 1); 6745 break; 6746 6747 case 'h': 6748 print_usage (stdout, 0); 6749 break; 6750 6751 case 'p': 6752 options &= ~ DMGL_PARAMS; 6753 break; 6754 6755 case 'v': 6756 options |= DMGL_VERBOSE; 6757 break; 6758 } 6759 } 6760 while (opt_char != -1); 6761 6762 if (optind == argc) 6763 /* No command line arguments were provided. Filter stdin. */ 6764 { 6765 dyn_string_t mangled = dyn_string_new (3); 6766 char *s; 6767 6768 /* Read all of input. */ 6769 while (!feof (stdin)) 6770 { 6771 char c; 6772 6773 /* Pile characters into mangled until we hit one that can't 6774 occur in a mangled name. */ 6775 c = getchar (); 6776 while (!feof (stdin) && is_mangled_char (c)) 6777 { 6778 dyn_string_append_char (mangled, c); 6779 if (feof (stdin)) 6780 break; 6781 c = getchar (); 6782 } 6783 6784 if (dyn_string_length (mangled) > 0) 6785 { 6786 #ifdef IN_GLIBCPP_V3 6787 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL); 6788 #else 6789 s = cplus_demangle_v3 (dyn_string_buf (mangled), options); 6790 #endif 6791 6792 if (s != NULL) 6793 { 6794 fputs (s, stdout); 6795 free (s); 6796 } 6797 else 6798 { 6799 /* It might not have been a mangled name. Print the 6800 original text. */ 6801 fputs (dyn_string_buf (mangled), stdout); 6802 } 6803 6804 dyn_string_clear (mangled); 6805 } 6806 6807 /* If we haven't hit EOF yet, we've read one character that 6808 can't occur in a mangled name, so print it out. */ 6809 if (!feof (stdin)) 6810 putchar (c); 6811 } 6812 6813 dyn_string_delete (mangled); 6814 } 6815 else 6816 /* Demangle command line arguments. */ 6817 { 6818 /* Loop over command line arguments. */ 6819 for (i = optind; i < argc; ++i) 6820 { 6821 char *s; 6822 #ifdef IN_GLIBCPP_V3 6823 int status; 6824 #endif 6825 6826 /* Attempt to demangle. */ 6827 #ifdef IN_GLIBCPP_V3 6828 s = __cxa_demangle (argv[i], NULL, NULL, &status); 6829 #else 6830 s = cplus_demangle_v3 (argv[i], options); 6831 #endif 6832 6833 /* If it worked, print the demangled name. */ 6834 if (s != NULL) 6835 { 6836 printf ("%s\n", s); 6837 free (s); 6838 } 6839 else 6840 { 6841 #ifdef IN_GLIBCPP_V3 6842 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status); 6843 #else 6844 fprintf (stderr, "Failed: %s\n", argv[i]); 6845 #endif 6846 } 6847 } 6848 } 6849 6850 return 0; 6851 } 6852 6853 #endif /* STANDALONE_DEMANGLER */ 6854