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