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