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