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