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