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