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