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(). */ 2085 2086 pmem = d_cv_qualifiers (di, &mem, 1); 2087 if (pmem == NULL) 2088 return NULL; 2089 *pmem = cplus_demangle_type (di); 2090 2091 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); 2092} 2093 2094/* <template-param> ::= T_ 2095 ::= T <(parameter-2 non-negative) number> _ 2096*/ 2097 2098static struct demangle_component * 2099d_template_param (struct d_info *di) 2100{ 2101 long param; 2102 2103 if (d_next_char (di) != 'T') 2104 return NULL; 2105 2106 if (d_peek_char (di) == '_') 2107 param = 0; 2108 else 2109 { 2110 param = d_number (di); 2111 if (param < 0) 2112 return NULL; 2113 param += 1; 2114 } 2115 2116 if (d_next_char (di) != '_') 2117 return NULL; 2118 2119 ++di->did_subs; 2120 2121 return d_make_template_param (di, param); 2122} 2123 2124/* <template-args> ::= I <template-arg>+ E */ 2125 2126static struct demangle_component * 2127d_template_args (struct d_info *di) 2128{ 2129 struct demangle_component *hold_last_name; 2130 struct demangle_component *al; 2131 struct demangle_component **pal; 2132 2133 /* Preserve the last name we saw--don't let the template arguments 2134 clobber it, as that would give us the wrong name for a subsequent 2135 constructor or destructor. */ 2136 hold_last_name = di->last_name; 2137 2138 if (d_next_char (di) != 'I') 2139 return NULL; 2140 2141 al = NULL; 2142 pal = &al; 2143 while (1) 2144 { 2145 struct demangle_component *a; 2146 2147 a = d_template_arg (di); 2148 if (a == NULL) 2149 return NULL; 2150 2151 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL); 2152 if (*pal == NULL) 2153 return NULL; 2154 pal = &d_right (*pal); 2155 2156 if (d_peek_char (di) == 'E') 2157 { 2158 d_advance (di, 1); 2159 break; 2160 } 2161 } 2162 2163 di->last_name = hold_last_name; 2164 2165 return al; 2166} 2167 2168/* <template-arg> ::= <type> 2169 ::= X <expression> E 2170 ::= <expr-primary> 2171*/ 2172 2173static struct demangle_component * 2174d_template_arg (struct d_info *di) 2175{ 2176 struct demangle_component *ret; 2177 2178 switch (d_peek_char (di)) 2179 { 2180 case 'X': 2181 d_advance (di, 1); 2182 ret = d_expression (di); 2183 if (d_next_char (di) != 'E') 2184 return NULL; 2185 return ret; 2186 2187 case 'L': 2188 return d_expr_primary (di); 2189 2190 default: 2191 return cplus_demangle_type (di); 2192 } 2193} 2194 2195/* <expression> ::= <(unary) operator-name> <expression> 2196 ::= <(binary) operator-name> <expression> <expression> 2197 ::= <(trinary) operator-name> <expression> <expression> <expression> 2198 ::= st <type> 2199 ::= <template-param> 2200 ::= sr <type> <unqualified-name> 2201 ::= sr <type> <unqualified-name> <template-args> 2202 ::= <expr-primary> 2203*/ 2204 2205static struct demangle_component * 2206d_expression (struct d_info *di) 2207{ 2208 char peek; 2209 2210 peek = d_peek_char (di); 2211 if (peek == 'L') 2212 return d_expr_primary (di); 2213 else if (peek == 'T') 2214 return d_template_param (di); 2215 else if (peek == 's' && d_peek_next_char (di) == 'r') 2216 { 2217 struct demangle_component *type; 2218 struct demangle_component *name; 2219 2220 d_advance (di, 2); 2221 type = cplus_demangle_type (di); 2222 name = d_unqualified_name (di); 2223 if (d_peek_char (di) != 'I') 2224 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); 2225 else 2226 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, 2227 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, 2228 d_template_args (di))); 2229 } 2230 else 2231 { 2232 struct demangle_component *op; 2233 int args; 2234 2235 op = d_operator_name (di); 2236 if (op == NULL) 2237 return NULL; 2238 2239 if (op->type == DEMANGLE_COMPONENT_OPERATOR) 2240 di->expansion += op->u.s_operator.op->len - 2; 2241 2242 if (op->type == DEMANGLE_COMPONENT_OPERATOR 2243 && strcmp (op->u.s_operator.op->code, "st") == 0) 2244 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, 2245 cplus_demangle_type (di)); 2246 2247 switch (op->type) 2248 { 2249 default: 2250 return NULL; 2251 case DEMANGLE_COMPONENT_OPERATOR: 2252 args = op->u.s_operator.op->args; 2253 break; 2254 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 2255 args = op->u.s_extended_operator.args; 2256 break; 2257 case DEMANGLE_COMPONENT_CAST: 2258 args = 1; 2259 break; 2260 } 2261 2262 switch (args) 2263 { 2264 case 1: 2265 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, 2266 d_expression (di)); 2267 case 2: 2268 { 2269 struct demangle_component *left; 2270 2271 left = d_expression (di); 2272 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, 2273 d_make_comp (di, 2274 DEMANGLE_COMPONENT_BINARY_ARGS, 2275 left, 2276 d_expression (di))); 2277 } 2278 case 3: 2279 { 2280 struct demangle_component *first; 2281 struct demangle_component *second; 2282 2283 first = d_expression (di); 2284 second = d_expression (di); 2285 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op, 2286 d_make_comp (di, 2287 DEMANGLE_COMPONENT_TRINARY_ARG1, 2288 first, 2289 d_make_comp (di, 2290 DEMANGLE_COMPONENT_TRINARY_ARG2, 2291 second, 2292 d_expression (di)))); 2293 } 2294 default: 2295 return NULL; 2296 } 2297 } 2298} 2299 2300/* <expr-primary> ::= L <type> <(value) number> E 2301 ::= L <type> <(value) float> E 2302 ::= L <mangled-name> E 2303*/ 2304 2305static struct demangle_component * 2306d_expr_primary (struct d_info *di) 2307{ 2308 struct demangle_component *ret; 2309 2310 if (d_next_char (di) != 'L') 2311 return NULL; 2312 if (d_peek_char (di) == '_') 2313 ret = cplus_demangle_mangled_name (di, 0); 2314 else 2315 { 2316 struct demangle_component *type; 2317 enum demangle_component_type t; 2318 const char *s; 2319 2320 type = cplus_demangle_type (di); 2321 if (type == NULL) 2322 return NULL; 2323 2324 /* If we have a type we know how to print, we aren't going to 2325 print the type name itself. */ 2326 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 2327 && type->u.s_builtin.type->print != D_PRINT_DEFAULT) 2328 di->expansion -= type->u.s_builtin.type->len; 2329 2330 /* Rather than try to interpret the literal value, we just 2331 collect it as a string. Note that it's possible to have a 2332 floating point literal here. The ABI specifies that the 2333 format of such literals is machine independent. That's fine, 2334 but what's not fine is that versions of g++ up to 3.2 with 2335 -fabi-version=1 used upper case letters in the hex constant, 2336 and dumped out gcc's internal representation. That makes it 2337 hard to tell where the constant ends, and hard to dump the 2338 constant in any readable form anyhow. We don't attempt to 2339 handle these cases. */ 2340 2341 t = DEMANGLE_COMPONENT_LITERAL; 2342 if (d_peek_char (di) == 'n') 2343 { 2344 t = DEMANGLE_COMPONENT_LITERAL_NEG; 2345 d_advance (di, 1); 2346 } 2347 s = d_str (di); 2348 while (d_peek_char (di) != 'E') 2349 { 2350 if (d_peek_char (di) == '\0') 2351 return NULL; 2352 d_advance (di, 1); 2353 } 2354 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s)); 2355 } 2356 if (d_next_char (di) != 'E') 2357 return NULL; 2358 return ret; 2359} 2360 2361/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>] 2362 ::= Z <(function) encoding> E s [<discriminator>] 2363*/ 2364 2365static struct demangle_component * 2366d_local_name (struct d_info *di) 2367{ 2368 struct demangle_component *function; 2369 2370 if (d_next_char (di) != 'Z') 2371 return NULL; 2372 2373 function = d_encoding (di, 0); 2374 2375 if (d_next_char (di) != 'E') 2376 return NULL; 2377 2378 if (d_peek_char (di) == 's') 2379 { 2380 d_advance (di, 1); 2381 if (! d_discriminator (di)) 2382 return NULL; 2383 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, 2384 d_make_name (di, "string literal", 2385 sizeof "string literal" - 1)); 2386 } 2387 else 2388 { 2389 struct demangle_component *name; 2390 2391 name = d_name (di); 2392 if (! d_discriminator (di)) 2393 return NULL; 2394 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); 2395 } 2396} 2397 2398/* <discriminator> ::= _ <(non-negative) number> 2399 2400 We demangle the discriminator, but we don't print it out. FIXME: 2401 We should print it out in verbose mode. */ 2402 2403static int 2404d_discriminator (struct d_info *di) 2405{ 2406 long discrim; 2407 2408 if (d_peek_char (di) != '_') 2409 return 1; 2410 d_advance (di, 1); 2411 discrim = d_number (di); 2412 if (discrim < 0) 2413 return 0; 2414 return 1; 2415} 2416 2417/* Add a new substitution. */ 2418 2419static int 2420d_add_substitution (struct d_info *di, struct demangle_component *dc) 2421{ 2422 if (dc == NULL) 2423 return 0; 2424 if (di->next_sub >= di->num_subs) 2425 return 0; 2426 di->subs[di->next_sub] = dc; 2427 ++di->next_sub; 2428 return 1; 2429} 2430 2431/* <substitution> ::= S <seq-id> _ 2432 ::= S_ 2433 ::= St 2434 ::= Sa 2435 ::= Sb 2436 ::= Ss 2437 ::= Si 2438 ::= So 2439 ::= Sd 2440 2441 If PREFIX is non-zero, then this type is being used as a prefix in 2442 a qualified name. In this case, for the standard substitutions, we 2443 need to check whether we are being used as a prefix for a 2444 constructor or destructor, and return a full template name. 2445 Otherwise we will get something like std::iostream::~iostream() 2446 which does not correspond particularly well to any function which 2447 actually appears in the source. 2448*/ 2449 2450static const struct d_standard_sub_info standard_subs[] = 2451{ 2452 { 't', NL ("std"), 2453 NL ("std"), 2454 NULL, 0 }, 2455 { 'a', NL ("std::allocator"), 2456 NL ("std::allocator"), 2457 NL ("allocator") }, 2458 { 'b', NL ("std::basic_string"), 2459 NL ("std::basic_string"), 2460 NL ("basic_string") }, 2461 { 's', NL ("std::string"), 2462 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), 2463 NL ("basic_string") }, 2464 { 'i', NL ("std::istream"), 2465 NL ("std::basic_istream<char, std::char_traits<char> >"), 2466 NL ("basic_istream") }, 2467 { 'o', NL ("std::ostream"), 2468 NL ("std::basic_ostream<char, std::char_traits<char> >"), 2469 NL ("basic_ostream") }, 2470 { 'd', NL ("std::iostream"), 2471 NL ("std::basic_iostream<char, std::char_traits<char> >"), 2472 NL ("basic_iostream") } 2473}; 2474 2475static struct demangle_component * 2476d_substitution (struct d_info *di, int prefix) 2477{ 2478 char c; 2479 2480 if (d_next_char (di) != 'S') 2481 return NULL; 2482 2483 c = d_next_char (di); 2484 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) 2485 { 2486 int id; 2487 2488 id = 0; 2489 if (c != '_') 2490 { 2491 do 2492 { 2493 if (IS_DIGIT (c)) 2494 id = id * 36 + c - '0'; 2495 else if (IS_UPPER (c)) 2496 id = id * 36 + c - 'A' + 10; 2497 else 2498 return NULL; 2499 c = d_next_char (di); 2500 } 2501 while (c != '_'); 2502 2503 ++id; 2504 } 2505 2506 if (id >= di->next_sub) 2507 return NULL; 2508 2509 ++di->did_subs; 2510 2511 return di->subs[id]; 2512 } 2513 else 2514 { 2515 int verbose; 2516 const struct d_standard_sub_info *p; 2517 const struct d_standard_sub_info *pend; 2518 2519 verbose = (di->options & DMGL_VERBOSE) != 0; 2520 if (! verbose && prefix) 2521 { 2522 char peek; 2523 2524 peek = d_peek_char (di); 2525 if (peek == 'C' || peek == 'D') 2526 verbose = 1; 2527 } 2528 2529 pend = (&standard_subs[0] 2530 + sizeof standard_subs / sizeof standard_subs[0]); 2531 for (p = &standard_subs[0]; p < pend; ++p) 2532 { 2533 if (c == p->code) 2534 { 2535 const char *s; 2536 int len; 2537 2538 if (p->set_last_name != NULL) 2539 di->last_name = d_make_sub (di, p->set_last_name, 2540 p->set_last_name_len); 2541 if (verbose) 2542 { 2543 s = p->full_expansion; 2544 len = p->full_len; 2545 } 2546 else 2547 { 2548 s = p->simple_expansion; 2549 len = p->simple_len; 2550 } 2551 di->expansion += len; 2552 return d_make_sub (di, s, len); 2553 } 2554 } 2555 2556 return NULL; 2557 } 2558} 2559 2560/* Resize the print buffer. */ 2561 2562static void 2563d_print_resize (struct d_print_info *dpi, size_t add) 2564{ 2565 size_t need; 2566 2567 if (dpi->buf == NULL) 2568 return; 2569 need = dpi->len + add; 2570 while (need > dpi->alc) 2571 { 2572 size_t newalc; 2573 char *newbuf; 2574 2575 newalc = dpi->alc * 2; 2576 newbuf = (char *) realloc (dpi->buf, newalc); 2577 if (newbuf == NULL) 2578 { 2579 free (dpi->buf); 2580 dpi->buf = NULL; 2581 dpi->allocation_failure = 1; 2582 return; 2583 } 2584 dpi->buf = newbuf; 2585 dpi->alc = newalc; 2586 } 2587} 2588 2589/* Append a character to the print buffer. */ 2590 2591static void 2592d_print_append_char (struct d_print_info *dpi, int c) 2593{ 2594 if (dpi->buf != NULL) 2595 { 2596 if (dpi->len >= dpi->alc) 2597 { 2598 d_print_resize (dpi, 1); 2599 if (dpi->buf == NULL) 2600 return; 2601 } 2602 2603 dpi->buf[dpi->len] = c; 2604 ++dpi->len; 2605 } 2606} 2607 2608/* Append a buffer to the print buffer. */ 2609 2610static void 2611d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l) 2612{ 2613 if (dpi->buf != NULL) 2614 { 2615 if (dpi->len + l > dpi->alc) 2616 { 2617 d_print_resize (dpi, l); 2618 if (dpi->buf == NULL) 2619 return; 2620 } 2621 2622 memcpy (dpi->buf + dpi->len, s, l); 2623 dpi->len += l; 2624 } 2625} 2626 2627/* Indicate that an error occurred during printing. */ 2628 2629static void 2630d_print_error (struct d_print_info *dpi) 2631{ 2632 free (dpi->buf); 2633 dpi->buf = NULL; 2634} 2635 2636/* Turn components into a human readable string. OPTIONS is the 2637 options bits passed to the demangler. DC is the tree to print. 2638 ESTIMATE is a guess at the length of the result. This returns a 2639 string allocated by malloc, or NULL on error. On success, this 2640 sets *PALC to the size of the allocated buffer. On failure, this 2641 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation 2642 failure. */ 2643 2644CP_STATIC_IF_GLIBCPP_V3 2645char * 2646cplus_demangle_print (int options, const struct demangle_component *dc, 2647 int estimate, size_t *palc) 2648{ 2649 struct d_print_info dpi; 2650 2651 dpi.options = options; 2652 2653 dpi.alc = estimate + 1; 2654 dpi.buf = (char *) malloc (dpi.alc); 2655 if (dpi.buf == NULL) 2656 { 2657 *palc = 1; 2658 return NULL; 2659 } 2660 2661 dpi.len = 0; 2662 dpi.templates = NULL; 2663 dpi.modifiers = NULL; 2664 2665 dpi.allocation_failure = 0; 2666 2667 d_print_comp (&dpi, dc); 2668 2669 d_append_char (&dpi, '\0'); 2670 2671 if (dpi.buf != NULL) 2672 *palc = dpi.alc; 2673 else 2674 *palc = dpi.allocation_failure; 2675 2676 return dpi.buf; 2677} 2678 2679/* Subroutine to handle components. */ 2680 2681static void 2682d_print_comp (struct d_print_info *dpi, 2683 const struct demangle_component *dc) 2684{ 2685 if (dc == NULL) 2686 { 2687 d_print_error (dpi); 2688 return; 2689 } 2690 if (d_print_saw_error (dpi)) 2691 return; 2692 2693 switch (dc->type) 2694 { 2695 case DEMANGLE_COMPONENT_NAME: 2696 if ((dpi->options & DMGL_JAVA) == 0) 2697 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); 2698 else 2699 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); 2700 return; 2701 2702 case DEMANGLE_COMPONENT_QUAL_NAME: 2703 case DEMANGLE_COMPONENT_LOCAL_NAME: 2704 d_print_comp (dpi, d_left (dc)); 2705 if ((dpi->options & DMGL_JAVA) == 0) 2706 d_append_string_constant (dpi, "::"); 2707 else 2708 d_append_char (dpi, '.'); 2709 d_print_comp (dpi, d_right (dc)); 2710 return; 2711 2712 case DEMANGLE_COMPONENT_TYPED_NAME: 2713 { 2714 struct d_print_mod *hold_modifiers; 2715 struct demangle_component *typed_name; 2716 struct d_print_mod adpm[4]; 2717 unsigned int i; 2718 struct d_print_template dpt; 2719 2720 /* Pass the name down to the type so that it can be printed in 2721 the right place for the type. We also have to pass down 2722 any CV-qualifiers, which apply to the this parameter. */ 2723 hold_modifiers = dpi->modifiers; 2724 i = 0; 2725 typed_name = d_left (dc); 2726 while (typed_name != NULL) 2727 { 2728 if (i >= sizeof adpm / sizeof adpm[0]) 2729 { 2730 d_print_error (dpi); 2731 return; 2732 } 2733 2734 adpm[i].next = dpi->modifiers; 2735 dpi->modifiers = &adpm[i]; 2736 adpm[i].mod = typed_name; 2737 adpm[i].printed = 0; 2738 adpm[i].templates = dpi->templates; 2739 ++i; 2740 2741 if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS 2742 && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS 2743 && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS) 2744 break; 2745 2746 typed_name = d_left (typed_name); 2747 } 2748 2749 /* If typed_name is a template, then it applies to the 2750 function type as well. */ 2751 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 2752 { 2753 dpt.next = dpi->templates; 2754 dpi->templates = &dpt; 2755 dpt.template_decl = typed_name; 2756 } 2757 2758 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then 2759 there may be CV-qualifiers on its right argument which 2760 really apply here; this happens when parsing a class which 2761 is local to a function. */ 2762 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) 2763 { 2764 struct demangle_component *local_name; 2765 2766 local_name = d_right (typed_name); 2767 while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS 2768 || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS 2769 || local_name->type == DEMANGLE_COMPONENT_CONST_THIS) 2770 { 2771 if (i >= sizeof adpm / sizeof adpm[0]) 2772 { 2773 d_print_error (dpi); 2774 return; 2775 } 2776 2777 adpm[i] = adpm[i - 1]; 2778 adpm[i].next = &adpm[i - 1]; 2779 dpi->modifiers = &adpm[i]; 2780 2781 adpm[i - 1].mod = local_name; 2782 adpm[i - 1].printed = 0; 2783 adpm[i - 1].templates = dpi->templates; 2784 ++i; 2785 2786 local_name = d_left (local_name); 2787 } 2788 } 2789 2790 d_print_comp (dpi, d_right (dc)); 2791 2792 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 2793 dpi->templates = dpt.next; 2794 2795 /* If the modifiers didn't get printed by the type, print them 2796 now. */ 2797 while (i > 0) 2798 { 2799 --i; 2800 if (! adpm[i].printed) 2801 { 2802 d_append_char (dpi, ' '); 2803 d_print_mod (dpi, adpm[i].mod); 2804 } 2805 } 2806 2807 dpi->modifiers = hold_modifiers; 2808 2809 return; 2810 } 2811 2812 case DEMANGLE_COMPONENT_TEMPLATE: 2813 { 2814 struct d_print_mod *hold_dpm; 2815 2816 /* Don't push modifiers into a template definition. Doing so 2817 could give the wrong definition for a template argument. 2818 Instead, treat the template essentially as a name. */ 2819 2820 hold_dpm = dpi->modifiers; 2821 dpi->modifiers = NULL; 2822 2823 d_print_comp (dpi, d_left (dc)); 2824 if (d_last_char (dpi) == '<') 2825 d_append_char (dpi, ' '); 2826 d_append_char (dpi, '<'); 2827 d_print_comp (dpi, d_right (dc)); 2828 /* Avoid generating two consecutive '>' characters, to avoid 2829 the C++ syntactic ambiguity. */ 2830 if (d_last_char (dpi) == '>') 2831 d_append_char (dpi, ' '); 2832 d_append_char (dpi, '>'); 2833 2834 dpi->modifiers = hold_dpm; 2835 2836 return; 2837 } 2838 2839 case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 2840 { 2841 long i; 2842 struct demangle_component *a; 2843 struct d_print_template *hold_dpt; 2844 2845 if (dpi->templates == NULL) 2846 { 2847 d_print_error (dpi); 2848 return; 2849 } 2850 i = dc->u.s_number.number; 2851 for (a = d_right (dpi->templates->template_decl); 2852 a != NULL; 2853 a = d_right (a)) 2854 { 2855 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 2856 { 2857 d_print_error (dpi); 2858 return; 2859 } 2860 if (i <= 0) 2861 break; 2862 --i; 2863 } 2864 if (i != 0 || a == NULL) 2865 { 2866 d_print_error (dpi); 2867 return; 2868 } 2869 2870 /* While processing this parameter, we need to pop the list of 2871 templates. This is because the template parameter may 2872 itself be a reference to a parameter of an outer 2873 template. */ 2874 2875 hold_dpt = dpi->templates; 2876 dpi->templates = hold_dpt->next; 2877 2878 d_print_comp (dpi, d_left (a)); 2879 2880 dpi->templates = hold_dpt; 2881 2882 return; 2883 } 2884 2885 case DEMANGLE_COMPONENT_CTOR: 2886 d_print_comp (dpi, dc->u.s_ctor.name); 2887 return; 2888 2889 case DEMANGLE_COMPONENT_DTOR: 2890 d_append_char (dpi, '~'); 2891 d_print_comp (dpi, dc->u.s_dtor.name); 2892 return; 2893 2894 case DEMANGLE_COMPONENT_VTABLE: 2895 d_append_string_constant (dpi, "vtable for "); 2896 d_print_comp (dpi, d_left (dc)); 2897 return; 2898 2899 case DEMANGLE_COMPONENT_VTT: 2900 d_append_string_constant (dpi, "VTT for "); 2901 d_print_comp (dpi, d_left (dc)); 2902 return; 2903 2904 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 2905 d_append_string_constant (dpi, "construction vtable for "); 2906 d_print_comp (dpi, d_left (dc)); 2907 d_append_string_constant (dpi, "-in-"); 2908 d_print_comp (dpi, d_right (dc)); 2909 return; 2910 2911 case DEMANGLE_COMPONENT_TYPEINFO: 2912 d_append_string_constant (dpi, "typeinfo for "); 2913 d_print_comp (dpi, d_left (dc)); 2914 return; 2915 2916 case DEMANGLE_COMPONENT_TYPEINFO_NAME: 2917 d_append_string_constant (dpi, "typeinfo name for "); 2918 d_print_comp (dpi, d_left (dc)); 2919 return; 2920 2921 case DEMANGLE_COMPONENT_TYPEINFO_FN: 2922 d_append_string_constant (dpi, "typeinfo fn for "); 2923 d_print_comp (dpi, d_left (dc)); 2924 return; 2925 2926 case DEMANGLE_COMPONENT_THUNK: 2927 d_append_string_constant (dpi, "non-virtual thunk to "); 2928 d_print_comp (dpi, d_left (dc)); 2929 return; 2930 2931 case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 2932 d_append_string_constant (dpi, "virtual thunk to "); 2933 d_print_comp (dpi, d_left (dc)); 2934 return; 2935 2936 case DEMANGLE_COMPONENT_COVARIANT_THUNK: 2937 d_append_string_constant (dpi, "covariant return thunk to "); 2938 d_print_comp (dpi, d_left (dc)); 2939 return; 2940 2941 case DEMANGLE_COMPONENT_JAVA_CLASS: 2942 d_append_string_constant (dpi, "java Class for "); 2943 d_print_comp (dpi, d_left (dc)); 2944 return; 2945 2946 case DEMANGLE_COMPONENT_GUARD: 2947 d_append_string_constant (dpi, "guard variable for "); 2948 d_print_comp (dpi, d_left (dc)); 2949 return; 2950 2951 case DEMANGLE_COMPONENT_REFTEMP: 2952 d_append_string_constant (dpi, "reference temporary for "); 2953 d_print_comp (dpi, d_left (dc)); 2954 return; 2955 2956 case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 2957 d_append_string_constant (dpi, "hidden alias for "); 2958 d_print_comp (dpi, d_left (dc)); 2959 return; 2960 2961 case DEMANGLE_COMPONENT_SUB_STD: 2962 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); 2963 return; 2964 2965 case DEMANGLE_COMPONENT_RESTRICT: 2966 case DEMANGLE_COMPONENT_VOLATILE: 2967 case DEMANGLE_COMPONENT_CONST: 2968 { 2969 struct d_print_mod *pdpm; 2970 2971 /* When printing arrays, it's possible to have cases where the 2972 same CV-qualifier gets pushed on the stack multiple times. 2973 We only need to print it once. */ 2974 2975 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next) 2976 { 2977 if (! pdpm->printed) 2978 { 2979 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT 2980 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE 2981 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST) 2982 break; 2983 if (pdpm->mod->type == dc->type) 2984 { 2985 d_print_comp (dpi, d_left (dc)); 2986 return; 2987 } 2988 } 2989 } 2990 } 2991 /* Fall through. */ 2992 case DEMANGLE_COMPONENT_RESTRICT_THIS: 2993 case DEMANGLE_COMPONENT_VOLATILE_THIS: 2994 case DEMANGLE_COMPONENT_CONST_THIS: 2995 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 2996 case DEMANGLE_COMPONENT_POINTER: 2997 case DEMANGLE_COMPONENT_REFERENCE: 2998 case DEMANGLE_COMPONENT_COMPLEX: 2999 case DEMANGLE_COMPONENT_IMAGINARY: 3000 { 3001 /* We keep a list of modifiers on the stack. */ 3002 struct d_print_mod dpm; 3003 3004 dpm.next = dpi->modifiers; 3005 dpi->modifiers = &dpm; 3006 dpm.mod = dc; 3007 dpm.printed = 0; 3008 dpm.templates = dpi->templates; 3009 3010 d_print_comp (dpi, d_left (dc)); 3011 3012 /* If the modifier didn't get printed by the type, print it 3013 now. */ 3014 if (! dpm.printed) 3015 d_print_mod (dpi, dc); 3016 3017 dpi->modifiers = dpm.next; 3018 3019 return; 3020 } 3021 3022 case DEMANGLE_COMPONENT_BUILTIN_TYPE: 3023 if ((dpi->options & DMGL_JAVA) == 0) 3024 d_append_buffer (dpi, dc->u.s_builtin.type->name, 3025 dc->u.s_builtin.type->len); 3026 else 3027 d_append_buffer (dpi, dc->u.s_builtin.type->java_name, 3028 dc->u.s_builtin.type->java_len); 3029 return; 3030 3031 case DEMANGLE_COMPONENT_VENDOR_TYPE: 3032 d_print_comp (dpi, d_left (dc)); 3033 return; 3034 3035 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 3036 { 3037 if ((dpi->options & DMGL_RET_POSTFIX) != 0) 3038 d_print_function_type (dpi, dc, dpi->modifiers); 3039 3040 /* Print return type if present */ 3041 if (d_left (dc) != NULL) 3042 { 3043 struct d_print_mod dpm; 3044 3045 /* We must pass this type down as a modifier in order to 3046 print it in the right location. */ 3047 dpm.next = dpi->modifiers; 3048 dpi->modifiers = &dpm; 3049 dpm.mod = dc; 3050 dpm.printed = 0; 3051 dpm.templates = dpi->templates; 3052 3053 d_print_comp (dpi, d_left (dc)); 3054 3055 dpi->modifiers = dpm.next; 3056 3057 if (dpm.printed) 3058 return; 3059 3060 /* In standard prefix notation, there is a space between the 3061 return type and the function signature. */ 3062 if ((dpi->options & DMGL_RET_POSTFIX) == 0) 3063 d_append_char (dpi, ' '); 3064 } 3065 3066 if ((dpi->options & DMGL_RET_POSTFIX) == 0) 3067 d_print_function_type (dpi, dc, dpi->modifiers); 3068 3069 return; 3070 } 3071 3072 case DEMANGLE_COMPONENT_ARRAY_TYPE: 3073 { 3074 struct d_print_mod *hold_modifiers; 3075 struct d_print_mod adpm[4]; 3076 unsigned int i; 3077 struct d_print_mod *pdpm; 3078 3079 /* We must pass this type down as a modifier in order to print 3080 multi-dimensional arrays correctly. If the array itself is 3081 CV-qualified, we act as though the element type were 3082 CV-qualified. We do this by copying the modifiers down 3083 rather than fiddling pointers, so that we don't wind up 3084 with a d_print_mod higher on the stack pointing into our 3085 stack frame after we return. */ 3086 3087 hold_modifiers = dpi->modifiers; 3088 3089 adpm[0].next = hold_modifiers; 3090 dpi->modifiers = &adpm[0]; 3091 adpm[0].mod = dc; 3092 adpm[0].printed = 0; 3093 adpm[0].templates = dpi->templates; 3094 3095 i = 1; 3096 pdpm = hold_modifiers; 3097 while (pdpm != NULL 3098 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT 3099 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE 3100 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST)) 3101 { 3102 if (! pdpm->printed) 3103 { 3104 if (i >= sizeof adpm / sizeof adpm[0]) 3105 { 3106 d_print_error (dpi); 3107 return; 3108 } 3109 3110 adpm[i] = *pdpm; 3111 adpm[i].next = dpi->modifiers; 3112 dpi->modifiers = &adpm[i]; 3113 pdpm->printed = 1; 3114 ++i; 3115 } 3116 3117 pdpm = pdpm->next; 3118 } 3119 3120 d_print_comp (dpi, d_right (dc)); 3121 3122 dpi->modifiers = hold_modifiers; 3123 3124 if (adpm[0].printed) 3125 return; 3126 3127 while (i > 1) 3128 { 3129 --i; 3130 d_print_mod (dpi, adpm[i].mod); 3131 } 3132 3133 d_print_array_type (dpi, dc, dpi->modifiers); 3134 3135 return; 3136 } 3137 3138 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3139 { 3140 struct d_print_mod dpm; 3141 3142 dpm.next = dpi->modifiers; 3143 dpi->modifiers = &dpm; 3144 dpm.mod = dc; 3145 dpm.printed = 0; 3146 dpm.templates = dpi->templates; 3147 3148 d_print_comp (dpi, d_right (dc)); 3149 3150 /* If the modifier didn't get printed by the type, print it 3151 now. */ 3152 if (! dpm.printed) 3153 { 3154 d_append_char (dpi, ' '); 3155 d_print_comp (dpi, d_left (dc)); 3156 d_append_string_constant (dpi, "::*"); 3157 } 3158 3159 dpi->modifiers = dpm.next; 3160 3161 return; 3162 } 3163 3164 case DEMANGLE_COMPONENT_ARGLIST: 3165 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 3166 d_print_comp (dpi, d_left (dc)); 3167 if (d_right (dc) != NULL) 3168 { 3169 d_append_string_constant (dpi, ", "); 3170 d_print_comp (dpi, d_right (dc)); 3171 } 3172 return; 3173 3174 case DEMANGLE_COMPONENT_OPERATOR: 3175 { 3176 char c; 3177 3178 d_append_string_constant (dpi, "operator"); 3179 c = dc->u.s_operator.op->name[0]; 3180 if (IS_LOWER (c)) 3181 d_append_char (dpi, ' '); 3182 d_append_buffer (dpi, dc->u.s_operator.op->name, 3183 dc->u.s_operator.op->len); 3184 return; 3185 } 3186 3187 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 3188 d_append_string_constant (dpi, "operator "); 3189 d_print_comp (dpi, dc->u.s_extended_operator.name); 3190 return; 3191 3192 case DEMANGLE_COMPONENT_CAST: 3193 d_append_string_constant (dpi, "operator "); 3194 d_print_cast (dpi, dc); 3195 return; 3196 3197 case DEMANGLE_COMPONENT_UNARY: 3198 if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST) 3199 d_print_expr_op (dpi, d_left (dc)); 3200 else 3201 { 3202 d_append_char (dpi, '('); 3203 d_print_cast (dpi, d_left (dc)); 3204 d_append_char (dpi, ')'); 3205 } 3206 d_append_char (dpi, '('); 3207 d_print_comp (dpi, d_right (dc)); 3208 d_append_char (dpi, ')'); 3209 return; 3210 3211 case DEMANGLE_COMPONENT_BINARY: 3212 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) 3213 { 3214 d_print_error (dpi); 3215 return; 3216 } 3217 3218 /* We wrap an expression which uses the greater-than operator in 3219 an extra layer of parens so that it does not get confused 3220 with the '>' which ends the template parameters. */ 3221 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 3222 && d_left (dc)->u.s_operator.op->len == 1 3223 && d_left (dc)->u.s_operator.op->name[0] == '>') 3224 d_append_char (dpi, '('); 3225 3226 d_append_char (dpi, '('); 3227 d_print_comp (dpi, d_left (d_right (dc))); 3228 d_append_string_constant (dpi, ") "); 3229 d_print_expr_op (dpi, d_left (dc)); 3230 d_append_string_constant (dpi, " ("); 3231 d_print_comp (dpi, d_right (d_right (dc))); 3232 d_append_char (dpi, ')'); 3233 3234 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 3235 && d_left (dc)->u.s_operator.op->len == 1 3236 && d_left (dc)->u.s_operator.op->name[0] == '>') 3237 d_append_char (dpi, ')'); 3238 3239 return; 3240 3241 case DEMANGLE_COMPONENT_BINARY_ARGS: 3242 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ 3243 d_print_error (dpi); 3244 return; 3245 3246 case DEMANGLE_COMPONENT_TRINARY: 3247 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 3248 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) 3249 { 3250 d_print_error (dpi); 3251 return; 3252 } 3253 d_append_char (dpi, '('); 3254 d_print_comp (dpi, d_left (d_right (dc))); 3255 d_append_string_constant (dpi, ") "); 3256 d_print_expr_op (dpi, d_left (dc)); 3257 d_append_string_constant (dpi, " ("); 3258 d_print_comp (dpi, d_left (d_right (d_right (dc)))); 3259 d_append_string_constant (dpi, ") : ("); 3260 d_print_comp (dpi, d_right (d_right (d_right (dc)))); 3261 d_append_char (dpi, ')'); 3262 return; 3263 3264 case DEMANGLE_COMPONENT_TRINARY_ARG1: 3265 case DEMANGLE_COMPONENT_TRINARY_ARG2: 3266 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */ 3267 d_print_error (dpi); 3268 return; 3269 3270 case DEMANGLE_COMPONENT_LITERAL: 3271 case DEMANGLE_COMPONENT_LITERAL_NEG: 3272 { 3273 enum d_builtin_type_print tp; 3274 3275 /* For some builtin types, produce simpler output. */ 3276 tp = D_PRINT_DEFAULT; 3277 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) 3278 { 3279 tp = d_left (dc)->u.s_builtin.type->print; 3280 switch (tp) 3281 { 3282 case D_PRINT_INT: 3283 case D_PRINT_UNSIGNED: 3284 case D_PRINT_LONG: 3285 case D_PRINT_UNSIGNED_LONG: 3286 case D_PRINT_LONG_LONG: 3287 case D_PRINT_UNSIGNED_LONG_LONG: 3288 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) 3289 { 3290 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 3291 d_append_char (dpi, '-'); 3292 d_print_comp (dpi, d_right (dc)); 3293 switch (tp) 3294 { 3295 default: 3296 break; 3297 case D_PRINT_UNSIGNED: 3298 d_append_char (dpi, 'u'); 3299 break; 3300 case D_PRINT_LONG: 3301 d_append_char (dpi, 'l'); 3302 break; 3303 case D_PRINT_UNSIGNED_LONG: 3304 d_append_string_constant (dpi, "ul"); 3305 break; 3306 case D_PRINT_LONG_LONG: 3307 d_append_string_constant (dpi, "ll"); 3308 break; 3309 case D_PRINT_UNSIGNED_LONG_LONG: 3310 d_append_string_constant (dpi, "ull"); 3311 break; 3312 } 3313 return; 3314 } 3315 break; 3316 3317 case D_PRINT_BOOL: 3318 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME 3319 && d_right (dc)->u.s_name.len == 1 3320 && dc->type == DEMANGLE_COMPONENT_LITERAL) 3321 { 3322 switch (d_right (dc)->u.s_name.s[0]) 3323 { 3324 case '0': 3325 d_append_string_constant (dpi, "false"); 3326 return; 3327 case '1': 3328 d_append_string_constant (dpi, "true"); 3329 return; 3330 default: 3331 break; 3332 } 3333 } 3334 break; 3335 3336 default: 3337 break; 3338 } 3339 } 3340 3341 d_append_char (dpi, '('); 3342 d_print_comp (dpi, d_left (dc)); 3343 d_append_char (dpi, ')'); 3344 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 3345 d_append_char (dpi, '-'); 3346 if (tp == D_PRINT_FLOAT) 3347 d_append_char (dpi, '['); 3348 d_print_comp (dpi, d_right (dc)); 3349 if (tp == D_PRINT_FLOAT) 3350 d_append_char (dpi, ']'); 3351 } 3352 return; 3353 3354 default: 3355 d_print_error (dpi); 3356 return; 3357 } 3358} 3359 3360/* Print a Java dentifier. For Java we try to handle encoded extended 3361 Unicode characters. The C++ ABI doesn't mention Unicode encoding, 3362 so we don't it for C++. Characters are encoded as 3363 __U<hex-char>+_. */ 3364 3365static void 3366d_print_java_identifier (struct d_print_info *dpi, const char *name, int len) 3367{ 3368 const char *p; 3369 const char *end; 3370 3371 end = name + len; 3372 for (p = name; p < end; ++p) 3373 { 3374 if (end - p > 3 3375 && p[0] == '_' 3376 && p[1] == '_' 3377 && p[2] == 'U') 3378 { 3379 unsigned long c; 3380 const char *q; 3381 3382 c = 0; 3383 for (q = p + 3; q < end; ++q) 3384 { 3385 int dig; 3386 3387 if (IS_DIGIT (*q)) 3388 dig = *q - '0'; 3389 else if (*q >= 'A' && *q <= 'F') 3390 dig = *q - 'A' + 10; 3391 else if (*q >= 'a' && *q <= 'f') 3392 dig = *q - 'a' + 10; 3393 else 3394 break; 3395 3396 c = c * 16 + dig; 3397 } 3398 /* If the Unicode character is larger than 256, we don't try 3399 to deal with it here. FIXME. */ 3400 if (q < end && *q == '_' && c < 256) 3401 { 3402 d_append_char (dpi, c); 3403 p = q; 3404 continue; 3405 } 3406 } 3407 3408 d_append_char (dpi, *p); 3409 } 3410} 3411 3412/* Print a list of modifiers. SUFFIX is 1 if we are printing 3413 qualifiers on this after printing a function. */ 3414 3415static void 3416d_print_mod_list (struct d_print_info *dpi, 3417 struct d_print_mod *mods, int suffix) 3418{ 3419 struct d_print_template *hold_dpt; 3420 3421 if (mods == NULL || d_print_saw_error (dpi)) 3422 return; 3423 3424 if (mods->printed 3425 || (! suffix 3426 && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS 3427 || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS 3428 || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS))) 3429 { 3430 d_print_mod_list (dpi, mods->next, suffix); 3431 return; 3432 } 3433 3434 mods->printed = 1; 3435 3436 hold_dpt = dpi->templates; 3437 dpi->templates = mods->templates; 3438 3439 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) 3440 { 3441 d_print_function_type (dpi, mods->mod, mods->next); 3442 dpi->templates = hold_dpt; 3443 return; 3444 } 3445 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 3446 { 3447 d_print_array_type (dpi, mods->mod, mods->next); 3448 dpi->templates = hold_dpt; 3449 return; 3450 } 3451 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) 3452 { 3453 struct d_print_mod *hold_modifiers; 3454 struct demangle_component *dc; 3455 3456 /* When this is on the modifier stack, we have pulled any 3457 qualifiers off the right argument already. Otherwise, we 3458 print it as usual, but don't let the left argument see any 3459 modifiers. */ 3460 3461 hold_modifiers = dpi->modifiers; 3462 dpi->modifiers = NULL; 3463 d_print_comp (dpi, d_left (mods->mod)); 3464 dpi->modifiers = hold_modifiers; 3465 3466 if ((dpi->options & DMGL_JAVA) == 0) 3467 d_append_string_constant (dpi, "::"); 3468 else 3469 d_append_char (dpi, '.'); 3470 3471 dc = d_right (mods->mod); 3472 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS 3473 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS 3474 || dc->type == DEMANGLE_COMPONENT_CONST_THIS) 3475 dc = d_left (dc); 3476 3477 d_print_comp (dpi, dc); 3478 3479 dpi->templates = hold_dpt; 3480 return; 3481 } 3482 3483 d_print_mod (dpi, mods->mod); 3484 3485 dpi->templates = hold_dpt; 3486 3487 d_print_mod_list (dpi, mods->next, suffix); 3488} 3489 3490/* Print a modifier. */ 3491 3492static void 3493d_print_mod (struct d_print_info *dpi, 3494 const struct demangle_component *mod) 3495{ 3496 switch (mod->type) 3497 { 3498 case DEMANGLE_COMPONENT_RESTRICT: 3499 case DEMANGLE_COMPONENT_RESTRICT_THIS: 3500 d_append_string_constant (dpi, " restrict"); 3501 return; 3502 case DEMANGLE_COMPONENT_VOLATILE: 3503 case DEMANGLE_COMPONENT_VOLATILE_THIS: 3504 d_append_string_constant (dpi, " volatile"); 3505 return; 3506 case DEMANGLE_COMPONENT_CONST: 3507 case DEMANGLE_COMPONENT_CONST_THIS: 3508 d_append_string_constant (dpi, " const"); 3509 return; 3510 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 3511 d_append_char (dpi, ' '); 3512 d_print_comp (dpi, d_right (mod)); 3513 return; 3514 case DEMANGLE_COMPONENT_POINTER: 3515 /* There is no pointer symbol in Java. */ 3516 if ((dpi->options & DMGL_JAVA) == 0) 3517 d_append_char (dpi, '*'); 3518 return; 3519 case DEMANGLE_COMPONENT_REFERENCE: 3520 d_append_char (dpi, '&'); 3521 return; 3522 case DEMANGLE_COMPONENT_COMPLEX: 3523 d_append_string_constant (dpi, "complex "); 3524 return; 3525 case DEMANGLE_COMPONENT_IMAGINARY: 3526 d_append_string_constant (dpi, "imaginary "); 3527 return; 3528 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3529 if (d_last_char (dpi) != '(') 3530 d_append_char (dpi, ' '); 3531 d_print_comp (dpi, d_left (mod)); 3532 d_append_string_constant (dpi, "::*"); 3533 return; 3534 case DEMANGLE_COMPONENT_TYPED_NAME: 3535 d_print_comp (dpi, d_left (mod)); 3536 return; 3537 default: 3538 /* Otherwise, we have something that won't go back on the 3539 modifier stack, so we can just print it. */ 3540 d_print_comp (dpi, mod); 3541 return; 3542 } 3543} 3544 3545/* Print a function type, except for the return type. */ 3546 3547static void 3548d_print_function_type (struct d_print_info *dpi, 3549 const struct demangle_component *dc, 3550 struct d_print_mod *mods) 3551{ 3552 int need_paren; 3553 int saw_mod; 3554 int need_space; 3555 struct d_print_mod *p; 3556 struct d_print_mod *hold_modifiers; 3557 3558 need_paren = 0; 3559 saw_mod = 0; 3560 need_space = 0; 3561 for (p = mods; p != NULL; p = p->next) 3562 { 3563 if (p->printed) 3564 break; 3565 3566 saw_mod = 1; 3567 switch (p->mod->type) 3568 { 3569 case DEMANGLE_COMPONENT_POINTER: 3570 case DEMANGLE_COMPONENT_REFERENCE: 3571 need_paren = 1; 3572 break; 3573 case DEMANGLE_COMPONENT_RESTRICT: 3574 case DEMANGLE_COMPONENT_VOLATILE: 3575 case DEMANGLE_COMPONENT_CONST: 3576 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 3577 case DEMANGLE_COMPONENT_COMPLEX: 3578 case DEMANGLE_COMPONENT_IMAGINARY: 3579 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3580 need_space = 1; 3581 need_paren = 1; 3582 break; 3583 case DEMANGLE_COMPONENT_RESTRICT_THIS: 3584 case DEMANGLE_COMPONENT_VOLATILE_THIS: 3585 case DEMANGLE_COMPONENT_CONST_THIS: 3586 break; 3587 default: 3588 break; 3589 } 3590 if (need_paren) 3591 break; 3592 } 3593 3594 if (d_left (dc) != NULL && ! saw_mod) 3595 need_paren = 1; 3596 3597 if (need_paren) 3598 { 3599 if (! need_space) 3600 { 3601 if (d_last_char (dpi) != '(' 3602 && d_last_char (dpi) != '*') 3603 need_space = 1; 3604 } 3605 if (need_space && d_last_char (dpi) != ' ') 3606 d_append_char (dpi, ' '); 3607 d_append_char (dpi, '('); 3608 } 3609 3610 hold_modifiers = dpi->modifiers; 3611 dpi->modifiers = NULL; 3612 3613 d_print_mod_list (dpi, mods, 0); 3614 3615 if (need_paren) 3616 d_append_char (dpi, ')'); 3617 3618 d_append_char (dpi, '('); 3619 3620 if (d_right (dc) != NULL) 3621 d_print_comp (dpi, d_right (dc)); 3622 3623 d_append_char (dpi, ')'); 3624 3625 d_print_mod_list (dpi, mods, 1); 3626 3627 dpi->modifiers = hold_modifiers; 3628} 3629 3630/* Print an array type, except for the element type. */ 3631 3632static void 3633d_print_array_type (struct d_print_info *dpi, 3634 const struct demangle_component *dc, 3635 struct d_print_mod *mods) 3636{ 3637 int need_space; 3638 3639 need_space = 1; 3640 if (mods != NULL) 3641 { 3642 int need_paren; 3643 struct d_print_mod *p; 3644 3645 need_paren = 0; 3646 for (p = mods; p != NULL; p = p->next) 3647 { 3648 if (! p->printed) 3649 { 3650 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 3651 { 3652 need_space = 0; 3653 break; 3654 } 3655 else 3656 { 3657 need_paren = 1; 3658 need_space = 1; 3659 break; 3660 } 3661 } 3662 } 3663 3664 if (need_paren) 3665 d_append_string_constant (dpi, " ("); 3666 3667 d_print_mod_list (dpi, mods, 0); 3668 3669 if (need_paren) 3670 d_append_char (dpi, ')'); 3671 } 3672 3673 if (need_space) 3674 d_append_char (dpi, ' '); 3675 3676 d_append_char (dpi, '['); 3677 3678 if (d_left (dc) != NULL) 3679 d_print_comp (dpi, d_left (dc)); 3680 3681 d_append_char (dpi, ']'); 3682} 3683 3684/* Print an operator in an expression. */ 3685 3686static void 3687d_print_expr_op (struct d_print_info *dpi, 3688 const struct demangle_component *dc) 3689{ 3690 if (dc->type == DEMANGLE_COMPONENT_OPERATOR) 3691 d_append_buffer (dpi, dc->u.s_operator.op->name, 3692 dc->u.s_operator.op->len); 3693 else 3694 d_print_comp (dpi, dc); 3695} 3696 3697/* Print a cast. */ 3698 3699static void 3700d_print_cast (struct d_print_info *dpi, 3701 const struct demangle_component *dc) 3702{ 3703 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) 3704 d_print_comp (dpi, d_left (dc)); 3705 else 3706 { 3707 struct d_print_mod *hold_dpm; 3708 struct d_print_template dpt; 3709 3710 /* It appears that for a templated cast operator, we need to put 3711 the template parameters in scope for the operator name, but 3712 not for the parameters. The effect is that we need to handle 3713 the template printing here. */ 3714 3715 hold_dpm = dpi->modifiers; 3716 dpi->modifiers = NULL; 3717 3718 dpt.next = dpi->templates; 3719 dpi->templates = &dpt; 3720 dpt.template_decl = d_left (dc); 3721 3722 d_print_comp (dpi, d_left (d_left (dc))); 3723 3724 dpi->templates = dpt.next; 3725 3726 if (d_last_char (dpi) == '<') 3727 d_append_char (dpi, ' '); 3728 d_append_char (dpi, '<'); 3729 d_print_comp (dpi, d_right (d_left (dc))); 3730 /* Avoid generating two consecutive '>' characters, to avoid 3731 the C++ syntactic ambiguity. */ 3732 if (d_last_char (dpi) == '>') 3733 d_append_char (dpi, ' '); 3734 d_append_char (dpi, '>'); 3735 3736 dpi->modifiers = hold_dpm; 3737 } 3738} 3739 3740/* Initialize the information structure we use to pass around 3741 information. */ 3742 3743CP_STATIC_IF_GLIBCPP_V3 3744void 3745cplus_demangle_init_info (const char *mangled, int options, size_t len, 3746 struct d_info *di) 3747{ 3748 di->s = mangled; 3749 di->send = mangled + len; 3750 di->options = options; 3751 3752 di->n = mangled; 3753 3754 /* We can not need more components than twice the number of chars in 3755 the mangled string. Most components correspond directly to 3756 chars, but the ARGLIST types are exceptions. */ 3757 di->num_comps = 2 * len; 3758 di->next_comp = 0; 3759 3760 /* Similarly, we can not need more substitutions than there are 3761 chars in the mangled string. */ 3762 di->num_subs = len; 3763 di->next_sub = 0; 3764 di->did_subs = 0; 3765 3766 di->last_name = NULL; 3767 3768 di->expansion = 0; 3769} 3770 3771/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled 3772 name, return a buffer allocated with malloc holding the demangled 3773 name. OPTIONS is the usual libiberty demangler options. On 3774 success, this sets *PALC to the allocated size of the returned 3775 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for 3776 a memory allocation failure. On failure, this returns NULL. */ 3777 3778static char * 3779d_demangle (const char* mangled, int options, size_t *palc) 3780{ 3781 size_t len; 3782 int type; 3783 struct d_info di; 3784 struct demangle_component *dc; 3785 int estimate; 3786 char *ret; 3787 3788 *palc = 0; 3789 3790 len = strlen (mangled); 3791 3792 if (mangled[0] == '_' && mangled[1] == 'Z') 3793 type = 0; 3794 else if (strncmp (mangled, "_GLOBAL_", 8) == 0 3795 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$') 3796 && (mangled[9] == 'D' || mangled[9] == 'I') 3797 && mangled[10] == '_') 3798 { 3799 char *r; 3800 size_t sz = 40 + len - 11; 3801 3802 r = (char *) malloc (sz); 3803 if (r == NULL) 3804 *palc = 1; 3805 else 3806 { 3807 if (mangled[9] == 'I') 3808 strlcpy (r, "global constructors keyed to ", sz); 3809 else 3810 strlcpy (r, "global destructors keyed to ", sz); 3811 strlcat (r, mangled + 11, sz); 3812 } 3813 return r; 3814 } 3815 else 3816 { 3817 if ((options & DMGL_TYPES) == 0) 3818 return NULL; 3819 type = 1; 3820 } 3821 3822 cplus_demangle_init_info (mangled, options, len, &di); 3823 3824 { 3825#ifdef CP_DYNAMIC_ARRAYS 3826 __extension__ struct demangle_component comps[di.num_comps]; 3827 __extension__ struct demangle_component *subs[di.num_subs]; 3828 3829 di.comps = &comps[0]; 3830 di.subs = &subs[0]; 3831#else 3832 di.comps = ((struct demangle_component *) 3833 malloc (di.num_comps * sizeof (struct demangle_component))); 3834 di.subs = ((struct demangle_component **) 3835 malloc (di.num_subs * sizeof (struct demangle_component *))); 3836 if (di.comps == NULL || di.subs == NULL) 3837 { 3838 if (di.comps != NULL) 3839 free (di.comps); 3840 if (di.subs != NULL) 3841 free (di.subs); 3842 *palc = 1; 3843 return NULL; 3844 } 3845#endif 3846 3847 if (! type) 3848 dc = cplus_demangle_mangled_name (&di, 1); 3849 else 3850 dc = cplus_demangle_type (&di); 3851 3852 /* If DMGL_PARAMS is set, then if we didn't consume the entire 3853 mangled string, then we didn't successfully demangle it. If 3854 DMGL_PARAMS is not set, we didn't look at the trailing 3855 parameters. */ 3856 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') 3857 dc = NULL; 3858 3859#ifdef CP_DEMANGLE_DEBUG 3860 if (dc == NULL) 3861 printf ("failed demangling\n"); 3862 else 3863 d_dump (dc, 0); 3864#endif 3865 3866 /* We try to guess the length of the demangled string, to minimize 3867 calls to realloc during demangling. */ 3868 estimate = len + di.expansion + 10 * di.did_subs; 3869 estimate += estimate / 8; 3870 3871 ret = NULL; 3872 if (dc != NULL) 3873 ret = cplus_demangle_print (options, dc, estimate, palc); 3874 3875#ifndef CP_DYNAMIC_ARRAYS 3876 free (di.comps); 3877 free (di.subs); 3878#endif 3879 3880#ifdef CP_DEMANGLE_DEBUG 3881 if (ret != NULL) 3882 { 3883 int rlen; 3884 3885 rlen = strlen (ret); 3886 if (rlen > 2 * estimate) 3887 printf ("*** Length %d much greater than estimate %d\n", 3888 rlen, estimate); 3889 else if (rlen > estimate) 3890 printf ("*** Length %d greater than estimate %d\n", 3891 rlen, estimate); 3892 else if (rlen < estimate / 2) 3893 printf ("*** Length %d much less than estimate %d\n", 3894 rlen, estimate); 3895 } 3896#endif 3897 } 3898 3899 return ret; 3900} 3901 3902#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3) 3903 3904extern char *__cxa_demangle (const char *, char *, size_t *, int *); 3905 3906/* ia64 ABI-mandated entry point in the C++ runtime library for 3907 performing demangling. MANGLED_NAME is a NUL-terminated character 3908 string containing the name to be demangled. 3909 3910 OUTPUT_BUFFER is a region of memory, allocated with malloc, of 3911 *LENGTH bytes, into which the demangled name is stored. If 3912 OUTPUT_BUFFER is not long enough, it is expanded using realloc. 3913 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name 3914 is placed in a region of memory allocated with malloc. 3915 3916 If LENGTH is non-NULL, the length of the buffer containing the 3917 demangled name, is placed in *LENGTH. 3918 3919 The return value is a pointer to the start of the NUL-terminated 3920 demangled name, or NULL if the demangling fails. The caller is 3921 responsible for deallocating this memory using free. 3922 3923 *STATUS is set to one of the following values: 3924 0: The demangling operation succeeded. 3925 -1: A memory allocation failure occurred. 3926 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules. 3927 -3: One of the arguments is invalid. 3928 3929 The demangling is performed using the C++ ABI mangling rules, with 3930 GNU extensions. */ 3931 3932char * 3933__cxa_demangle (const char *mangled_name, char *output_buffer, 3934 size_t *length, int *status) 3935{ 3936 char *demangled; 3937 size_t alc; 3938 3939 if (mangled_name == NULL) 3940 { 3941 if (status != NULL) 3942 *status = -3; 3943 return NULL; 3944 } 3945 3946 if (output_buffer != NULL && length == NULL) 3947 { 3948 if (status != NULL) 3949 *status = -3; 3950 return NULL; 3951 } 3952 3953 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc); 3954 3955 if (demangled == NULL) 3956 { 3957 if (status != NULL) 3958 { 3959 if (alc == 1) 3960 *status = -1; 3961 else 3962 *status = -2; 3963 } 3964 return NULL; 3965 } 3966 3967 if (output_buffer == NULL) 3968 { 3969 if (length != NULL) 3970 *length = alc; 3971 } 3972 else 3973 { 3974 if (strlen (demangled) < *length) 3975 { 3976 strlcpy (output_buffer, demangled, *length); 3977 free (demangled); 3978 demangled = output_buffer; 3979 } 3980 else 3981 { 3982 free (output_buffer); 3983 *length = alc; 3984 } 3985 } 3986 3987 if (status != NULL) 3988 *status = 0; 3989 3990 return demangled; 3991} 3992 3993#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */ 3994 3995/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI 3996 mangled name, return a buffer allocated with malloc holding the 3997 demangled name. Otherwise, return NULL. */ 3998 3999char * 4000cplus_demangle_v3 (const char* mangled, int options) 4001{ 4002 size_t alc; 4003 4004 return d_demangle (mangled, options, &alc); 4005} 4006 4007/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling 4008 conventions, but the output formatting is a little different. 4009 This instructs the C++ demangler not to emit pointer characters ("*"), and 4010 to use Java's namespace separator symbol ("." instead of "::"). It then 4011 does an additional pass over the demangled output to replace instances 4012 of JArray<TYPE> with TYPE[]. */ 4013 4014char * 4015java_demangle_v3 (const char* mangled) 4016{ 4017 size_t alc; 4018 char *demangled; 4019 int nesting; 4020 char *from; 4021 char *to; 4022 4023 demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 4024 &alc); 4025 4026 if (demangled == NULL) 4027 return NULL; 4028 4029 nesting = 0; 4030 from = demangled; 4031 to = from; 4032 while (*from != '\0') 4033 { 4034 if (strncmp (from, "JArray<", 7) == 0) 4035 { 4036 from += 7; 4037 ++nesting; 4038 } 4039 else if (nesting > 0 && *from == '>') 4040 { 4041 while (to > demangled && to[-1] == ' ') 4042 --to; 4043 *to++ = '['; 4044 *to++ = ']'; 4045 --nesting; 4046 ++from; 4047 } 4048 else 4049 *to++ = *from++; 4050 } 4051 4052 *to = '\0'; 4053 4054 return demangled; 4055} 4056 4057#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */ 4058 4059#ifndef IN_GLIBCPP_V3 4060 4061/* Demangle a string in order to find out whether it is a constructor 4062 or destructor. Return non-zero on success. Set *CTOR_KIND and 4063 *DTOR_KIND appropriately. */ 4064 4065static int 4066is_ctor_or_dtor (const char *mangled, 4067 enum gnu_v3_ctor_kinds *ctor_kind, 4068 enum gnu_v3_dtor_kinds *dtor_kind) 4069{ 4070 struct d_info di; 4071 struct demangle_component *dc; 4072 int ret; 4073 4074 *ctor_kind = (enum gnu_v3_ctor_kinds) 0; 4075 *dtor_kind = (enum gnu_v3_dtor_kinds) 0; 4076 4077 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); 4078 4079 { 4080#ifdef CP_DYNAMIC_ARRAYS 4081 __extension__ struct demangle_component comps[di.num_comps]; 4082 __extension__ struct demangle_component *subs[di.num_subs]; 4083 4084 di.comps = &comps[0]; 4085 di.subs = &subs[0]; 4086#else 4087 di.comps = ((struct demangle_component *) 4088 malloc (di.num_comps * sizeof (struct demangle_component))); 4089 di.subs = ((struct demangle_component **) 4090 malloc (di.num_subs * sizeof (struct demangle_component *))); 4091 if (di.comps == NULL || di.subs == NULL) 4092 { 4093 if (di.comps != NULL) 4094 free (di.comps); 4095 if (di.subs != NULL) 4096 free (di.subs); 4097 return 0; 4098 } 4099#endif 4100 4101 dc = cplus_demangle_mangled_name (&di, 1); 4102 4103 /* Note that because we did not pass DMGL_PARAMS, we don't expect 4104 to demangle the entire string. */ 4105 4106 ret = 0; 4107 while (dc != NULL) 4108 { 4109 switch (dc->type) 4110 { 4111 default: 4112 dc = NULL; 4113 break; 4114 case DEMANGLE_COMPONENT_TYPED_NAME: 4115 case DEMANGLE_COMPONENT_TEMPLATE: 4116 case DEMANGLE_COMPONENT_RESTRICT_THIS: 4117 case DEMANGLE_COMPONENT_VOLATILE_THIS: 4118 case DEMANGLE_COMPONENT_CONST_THIS: 4119 dc = d_left (dc); 4120 break; 4121 case DEMANGLE_COMPONENT_QUAL_NAME: 4122 case DEMANGLE_COMPONENT_LOCAL_NAME: 4123 dc = d_right (dc); 4124 break; 4125 case DEMANGLE_COMPONENT_CTOR: 4126 *ctor_kind = dc->u.s_ctor.kind; 4127 ret = 1; 4128 dc = NULL; 4129 break; 4130 case DEMANGLE_COMPONENT_DTOR: 4131 *dtor_kind = dc->u.s_dtor.kind; 4132 ret = 1; 4133 dc = NULL; 4134 break; 4135 } 4136 } 4137 4138#ifndef CP_DYNAMIC_ARRAYS 4139 free (di.subs); 4140 free (di.comps); 4141#endif 4142 } 4143 4144 return ret; 4145} 4146 4147/* Return whether NAME is the mangled form of a g++ V3 ABI constructor 4148 name. A non-zero return indicates the type of constructor. */ 4149 4150enum gnu_v3_ctor_kinds 4151is_gnu_v3_mangled_ctor (const char *name) 4152{ 4153 enum gnu_v3_ctor_kinds ctor_kind; 4154 enum gnu_v3_dtor_kinds dtor_kind; 4155 4156 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 4157 return (enum gnu_v3_ctor_kinds) 0; 4158 return ctor_kind; 4159} 4160 4161 4162/* Return whether NAME is the mangled form of a g++ V3 ABI destructor 4163 name. A non-zero return indicates the type of destructor. */ 4164 4165enum gnu_v3_dtor_kinds 4166is_gnu_v3_mangled_dtor (const char *name) 4167{ 4168 enum gnu_v3_ctor_kinds ctor_kind; 4169 enum gnu_v3_dtor_kinds dtor_kind; 4170 4171 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 4172 return (enum gnu_v3_dtor_kinds) 0; 4173 return dtor_kind; 4174} 4175 4176#endif /* IN_GLIBCPP_V3 */ 4177 4178#ifdef STANDALONE_DEMANGLER 4179 4180#include "getopt.h" 4181#include "dyn-string.h" 4182 4183static void print_usage (FILE* fp, int exit_value); 4184 4185#define IS_ALPHA(CHAR) \ 4186 (((CHAR) >= 'a' && (CHAR) <= 'z') \ 4187 || ((CHAR) >= 'A' && (CHAR) <= 'Z')) 4188 4189/* Non-zero if CHAR is a character than can occur in a mangled name. */ 4190#define is_mangled_char(CHAR) \ 4191 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \ 4192 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$') 4193 4194/* The name of this program, as invoked. */ 4195const char* program_name; 4196 4197/* Prints usage summary to FP and then exits with EXIT_VALUE. */ 4198 4199static void 4200print_usage (FILE* fp, int exit_value) 4201{ 4202 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name); 4203 fprintf (fp, "Options:\n"); 4204 fprintf (fp, " -h,--help Display this message.\n"); 4205 fprintf (fp, " -p,--no-params Don't display function parameters\n"); 4206 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n"); 4207 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n"); 4208 4209 exit (exit_value); 4210} 4211 4212/* Option specification for getopt_long. */ 4213static const struct option long_options[] = 4214{ 4215 { "help", no_argument, NULL, 'h' }, 4216 { "no-params", no_argument, NULL, 'p' }, 4217 { "verbose", no_argument, NULL, 'v' }, 4218 { NULL, no_argument, NULL, 0 }, 4219}; 4220 4221/* Main entry for a demangling filter executable. It will demangle 4222 its command line arguments, if any. If none are provided, it will 4223 filter stdin to stdout, replacing any recognized mangled C++ names 4224 with their demangled equivalents. */ 4225 4226int 4227main (int argc, char *argv[]) 4228{ 4229 int i; 4230 int opt_char; 4231 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 4232 4233 /* Use the program name of this program, as invoked. */ 4234 program_name = argv[0]; 4235 4236 /* Parse options. */ 4237 do 4238 { 4239 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL); 4240 switch (opt_char) 4241 { 4242 case '?': /* Unrecognized option. */ 4243 print_usage (stderr, 1); 4244 break; 4245 4246 case 'h': 4247 print_usage (stdout, 0); 4248 break; 4249 4250 case 'p': 4251 options &= ~ DMGL_PARAMS; 4252 break; 4253 4254 case 'v': 4255 options |= DMGL_VERBOSE; 4256 break; 4257 } 4258 } 4259 while (opt_char != -1); 4260 4261 if (optind == argc) 4262 /* No command line arguments were provided. Filter stdin. */ 4263 { 4264 dyn_string_t mangled = dyn_string_new (3); 4265 char *s; 4266 4267 /* Read all of input. */ 4268 while (!feof (stdin)) 4269 { 4270 char c; 4271 4272 /* Pile characters into mangled until we hit one that can't 4273 occur in a mangled name. */ 4274 c = getchar (); 4275 while (!feof (stdin) && is_mangled_char (c)) 4276 { 4277 dyn_string_append_char (mangled, c); 4278 if (feof (stdin)) 4279 break; 4280 c = getchar (); 4281 } 4282 4283 if (dyn_string_length (mangled) > 0) 4284 { 4285#ifdef IN_GLIBCPP_V3 4286 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL); 4287#else 4288 s = cplus_demangle_v3 (dyn_string_buf (mangled), options); 4289#endif 4290 4291 if (s != NULL) 4292 { 4293 fputs (s, stdout); 4294 free (s); 4295 } 4296 else 4297 { 4298 /* It might not have been a mangled name. Print the 4299 original text. */ 4300 fputs (dyn_string_buf (mangled), stdout); 4301 } 4302 4303 dyn_string_clear (mangled); 4304 } 4305 4306 /* If we haven't hit EOF yet, we've read one character that 4307 can't occur in a mangled name, so print it out. */ 4308 if (!feof (stdin)) 4309 putchar (c); 4310 } 4311 4312 dyn_string_delete (mangled); 4313 } 4314 else 4315 /* Demangle command line arguments. */ 4316 { 4317 /* Loop over command line arguments. */ 4318 for (i = optind; i < argc; ++i) 4319 { 4320 char *s; 4321#ifdef IN_GLIBCPP_V3 4322 int status; 4323#endif 4324 4325 /* Attempt to demangle. */ 4326#ifdef IN_GLIBCPP_V3 4327 s = __cxa_demangle (argv[i], NULL, NULL, &status); 4328#else 4329 s = cplus_demangle_v3 (argv[i], options); 4330#endif 4331 4332 /* If it worked, print the demangled name. */ 4333 if (s != NULL) 4334 { 4335 printf ("%s\n", s); 4336 free (s); 4337 } 4338 else 4339 { 4340#ifdef IN_GLIBCPP_V3 4341 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status); 4342#else 4343 fprintf (stderr, "Failed: %s\n", argv[i]); 4344#endif 4345 } 4346 } 4347 } 4348 4349 return 0; 4350} 4351 4352#endif /* STANDALONE_DEMANGLER */ 4353