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