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