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