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