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