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