1169695Skan/* Demangler for g++ V3 ABI. 2169695Skan Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc. 3169695Skan Written by Ian Lance Taylor <ian@wasabisystems.com>. 4169695Skan 5169695Skan This file is part of the libiberty library, which is part of GCC. 6169695Skan 7169695Skan This file is free software; you can redistribute it and/or modify 8169695Skan it under the terms of the GNU General Public License as published by 9169695Skan the Free Software Foundation; either version 2 of the License, or 10169695Skan (at your option) any later version. 11169695Skan 12169695Skan In addition to the permissions in the GNU General Public License, the 13169695Skan Free Software Foundation gives you unlimited permission to link the 14169695Skan compiled version of this file into combinations with other programs, 15169695Skan and to distribute those combinations without any restriction coming 16169695Skan from the use of this file. (The General Public License restrictions 17169695Skan do apply in other respects; for example, they cover modification of 18169695Skan the file, and distribution when not linked into a combined 19169695Skan executable.) 20169695Skan 21169695Skan This program is distributed in the hope that it will be useful, 22169695Skan but WITHOUT ANY WARRANTY; without even the implied warranty of 23169695Skan MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24169695Skan GNU General Public License for more details. 25169695Skan 26169695Skan You should have received a copy of the GNU General Public License 27169695Skan along with this program; if not, write to the Free Software 28169695Skan Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. 29169695Skan*/ 30169695Skan 31169695Skan/* This code implements a demangler for the g++ V3 ABI. The ABI is 32169695Skan described on this web page: 33169695Skan http://www.codesourcery.com/cxx-abi/abi.html#mangling 34169695Skan 35169695Skan This code was written while looking at the demangler written by 36169695Skan Alex Samuel <samuel@codesourcery.com>. 37169695Skan 38169695Skan This code first pulls the mangled name apart into a list of 39169695Skan components, and then walks the list generating the demangled 40169695Skan name. 41169695Skan 42169695Skan This file will normally define the following functions, q.v.: 43169695Skan char *cplus_demangle_v3(const char *mangled, int options) 44169695Skan char *java_demangle_v3(const char *mangled) 45169695Skan enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name) 46169695Skan enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name) 47169695Skan 48169695Skan Also, the interface to the component list is public, and defined in 49169695Skan demangle.h. The interface consists of these types, which are 50169695Skan defined in demangle.h: 51169695Skan enum demangle_component_type 52169695Skan struct demangle_component 53169695Skan and these functions defined in this file: 54169695Skan cplus_demangle_fill_name 55169695Skan cplus_demangle_fill_extended_operator 56169695Skan cplus_demangle_fill_ctor 57169695Skan cplus_demangle_fill_dtor 58169695Skan cplus_demangle_print 59169695Skan and other functions defined in the file cp-demint.c. 60169695Skan 61169695Skan This file also defines some other functions and variables which are 62169695Skan only to be used by the file cp-demint.c. 63169695Skan 64169695Skan Preprocessor macros you can define while compiling this file: 65169695Skan 66169695Skan IN_LIBGCC2 67169695Skan If defined, this file defines the following function, q.v.: 68169695Skan char *__cxa_demangle (const char *mangled, char *buf, size_t *len, 69169695Skan int *status) 70169695Skan instead of cplus_demangle_v3() and java_demangle_v3(). 71169695Skan 72169695Skan IN_GLIBCPP_V3 73169695Skan If defined, this file defines only __cxa_demangle(), and no other 74169695Skan publically visible functions or variables. 75169695Skan 76169695Skan STANDALONE_DEMANGLER 77169695Skan If defined, this file defines a main() function which demangles 78169695Skan any arguments, or, if none, demangles stdin. 79169695Skan 80169695Skan CP_DEMANGLE_DEBUG 81169695Skan If defined, turns on debugging mode, which prints information on 82169695Skan stdout about the mangled string. This is not generally useful. 83169695Skan*/ 84169695Skan 85169695Skan#ifdef HAVE_CONFIG_H 86169695Skan#include "config.h" 87169695Skan#endif 88169695Skan 89169695Skan#include <stdio.h> 90169695Skan 91169695Skan#ifdef HAVE_STDLIB_H 92169695Skan#include <stdlib.h> 93169695Skan#endif 94169695Skan#ifdef HAVE_STRING_H 95169695Skan#include <string.h> 96169695Skan#endif 97169695Skan 98169695Skan#include "ansidecl.h" 99169695Skan#include "libiberty.h" 100169695Skan#include "demangle.h" 101169695Skan#include "cp-demangle.h" 102169695Skan 103169695Skan/* If IN_GLIBCPP_V3 is defined, some functions are made static. We 104169695Skan also rename them via #define to avoid compiler errors when the 105169695Skan static definition conflicts with the extern declaration in a header 106169695Skan file. */ 107169695Skan#ifdef IN_GLIBCPP_V3 108169695Skan 109169695Skan#define CP_STATIC_IF_GLIBCPP_V3 static 110169695Skan 111169695Skan#define cplus_demangle_fill_name d_fill_name 112169695Skanstatic int d_fill_name (struct demangle_component *, const char *, int); 113169695Skan 114169695Skan#define cplus_demangle_fill_extended_operator d_fill_extended_operator 115169695Skanstatic int 116169695Skand_fill_extended_operator (struct demangle_component *, int, 117169695Skan struct demangle_component *); 118169695Skan 119169695Skan#define cplus_demangle_fill_ctor d_fill_ctor 120169695Skanstatic int 121169695Skand_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds, 122169695Skan struct demangle_component *); 123169695Skan 124169695Skan#define cplus_demangle_fill_dtor d_fill_dtor 125169695Skanstatic int 126169695Skand_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds, 127169695Skan struct demangle_component *); 128169695Skan 129169695Skan#define cplus_demangle_mangled_name d_mangled_name 130169695Skanstatic struct demangle_component *d_mangled_name (struct d_info *, int); 131169695Skan 132169695Skan#define cplus_demangle_type d_type 133169695Skanstatic struct demangle_component *d_type (struct d_info *); 134169695Skan 135169695Skan#define cplus_demangle_print d_print 136169695Skanstatic char *d_print (int, const struct demangle_component *, int, size_t *); 137169695Skan 138169695Skan#define cplus_demangle_init_info d_init_info 139169695Skanstatic void d_init_info (const char *, int, size_t, struct d_info *); 140169695Skan 141169695Skan#else /* ! defined(IN_GLIBCPP_V3) */ 142169695Skan#define CP_STATIC_IF_GLIBCPP_V3 143169695Skan#endif /* ! defined(IN_GLIBCPP_V3) */ 144169695Skan 145169695Skan/* See if the compiler supports dynamic arrays. */ 146169695Skan 147169695Skan#ifdef __GNUC__ 148169695Skan#define CP_DYNAMIC_ARRAYS 149169695Skan#else 150169695Skan#ifdef __STDC__ 151169695Skan#ifdef __STDC_VERSION__ 152169695Skan#if __STDC_VERSION__ >= 199901L 153169695Skan#define CP_DYNAMIC_ARRAYS 154169695Skan#endif /* __STDC__VERSION >= 199901L */ 155169695Skan#endif /* defined (__STDC_VERSION__) */ 156169695Skan#endif /* defined (__STDC__) */ 157169695Skan#endif /* ! defined (__GNUC__) */ 158169695Skan 159169695Skan/* We avoid pulling in the ctype tables, to prevent pulling in 160169695Skan additional unresolved symbols when this code is used in a library. 161169695Skan FIXME: Is this really a valid reason? This comes from the original 162169695Skan V3 demangler code. 163169695Skan 164169695Skan As of this writing this file has the following undefined references 165169695Skan when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy, 166169695Skan strcpy, strcat, strlen. */ 167169695Skan 168169695Skan#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9') 169169695Skan#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z') 170169695Skan#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z') 171169695Skan 172169695Skan/* The prefix prepended by GCC to an identifier represnting the 173169695Skan anonymous namespace. */ 174169695Skan#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_" 175169695Skan#define ANONYMOUS_NAMESPACE_PREFIX_LEN \ 176169695Skan (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1) 177169695Skan 178169695Skan/* Information we keep for the standard substitutions. */ 179169695Skan 180169695Skanstruct d_standard_sub_info 181169695Skan{ 182169695Skan /* The code for this substitution. */ 183169695Skan char code; 184169695Skan /* The simple string it expands to. */ 185169695Skan const char *simple_expansion; 186169695Skan /* The length of the simple expansion. */ 187169695Skan int simple_len; 188169695Skan /* The results of a full, verbose, expansion. This is used when 189169695Skan qualifying a constructor/destructor, or when in verbose mode. */ 190169695Skan const char *full_expansion; 191169695Skan /* The length of the full expansion. */ 192169695Skan int full_len; 193169695Skan /* What to set the last_name field of d_info to; NULL if we should 194169695Skan not set it. This is only relevant when qualifying a 195169695Skan constructor/destructor. */ 196169695Skan const char *set_last_name; 197169695Skan /* The length of set_last_name. */ 198169695Skan int set_last_name_len; 199169695Skan}; 200169695Skan 201169695Skan/* Accessors for subtrees of struct demangle_component. */ 202169695Skan 203169695Skan#define d_left(dc) ((dc)->u.s_binary.left) 204169695Skan#define d_right(dc) ((dc)->u.s_binary.right) 205169695Skan 206169695Skan/* A list of templates. This is used while printing. */ 207169695Skan 208169695Skanstruct d_print_template 209169695Skan{ 210169695Skan /* Next template on the list. */ 211169695Skan struct d_print_template *next; 212169695Skan /* This template. */ 213169695Skan const struct demangle_component *template_decl; 214169695Skan}; 215169695Skan 216169695Skan/* A list of type modifiers. This is used while printing. */ 217169695Skan 218169695Skanstruct d_print_mod 219169695Skan{ 220169695Skan /* Next modifier on the list. These are in the reverse of the order 221169695Skan in which they appeared in the mangled string. */ 222169695Skan struct d_print_mod *next; 223169695Skan /* The modifier. */ 224169695Skan const struct demangle_component *mod; 225169695Skan /* Whether this modifier was printed. */ 226169695Skan int printed; 227169695Skan /* The list of templates which applies to this modifier. */ 228169695Skan struct d_print_template *templates; 229169695Skan}; 230169695Skan 231169695Skan/* We use this structure to hold information during printing. */ 232169695Skan 233169695Skanstruct d_print_info 234169695Skan{ 235169695Skan /* The options passed to the demangler. */ 236169695Skan int options; 237169695Skan /* Buffer holding the result. */ 238169695Skan char *buf; 239169695Skan /* Current length of data in buffer. */ 240169695Skan size_t len; 241169695Skan /* Allocated size of buffer. */ 242169695Skan size_t alc; 243169695Skan /* The current list of templates, if any. */ 244169695Skan struct d_print_template *templates; 245169695Skan /* The current list of modifiers (e.g., pointer, reference, etc.), 246169695Skan if any. */ 247169695Skan struct d_print_mod *modifiers; 248169695Skan /* Set to 1 if we had a memory allocation failure. */ 249169695Skan int allocation_failure; 250169695Skan}; 251169695Skan 252169695Skan#define d_print_saw_error(dpi) ((dpi)->buf == NULL) 253169695Skan 254169695Skan#define d_append_char(dpi, c) \ 255169695Skan do \ 256169695Skan { \ 257169695Skan if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \ 258169695Skan (dpi)->buf[(dpi)->len++] = (c); \ 259169695Skan else \ 260169695Skan d_print_append_char ((dpi), (c)); \ 261169695Skan } \ 262169695Skan while (0) 263169695Skan 264169695Skan#define d_append_buffer(dpi, s, l) \ 265169695Skan do \ 266169695Skan { \ 267169695Skan if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \ 268169695Skan { \ 269169695Skan memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \ 270169695Skan (dpi)->len += l; \ 271169695Skan } \ 272169695Skan else \ 273169695Skan d_print_append_buffer ((dpi), (s), (l)); \ 274169695Skan } \ 275169695Skan while (0) 276169695Skan 277169695Skan#define d_append_string_constant(dpi, s) \ 278169695Skan d_append_buffer (dpi, (s), sizeof (s) - 1) 279169695Skan 280169695Skan#define d_last_char(dpi) \ 281169695Skan ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1]) 282169695Skan 283169695Skan#ifdef CP_DEMANGLE_DEBUG 284169695Skanstatic void d_dump (struct demangle_component *, int); 285169695Skan#endif 286169695Skan 287169695Skanstatic struct demangle_component * 288169695Skand_make_empty (struct d_info *); 289169695Skan 290169695Skanstatic struct demangle_component * 291169695Skand_make_comp (struct d_info *, enum demangle_component_type, 292169695Skan struct demangle_component *, 293169695Skan struct demangle_component *); 294169695Skan 295169695Skanstatic struct demangle_component * 296169695Skand_make_name (struct d_info *, const char *, int); 297169695Skan 298169695Skanstatic struct demangle_component * 299169695Skand_make_builtin_type (struct d_info *, 300169695Skan const struct demangle_builtin_type_info *); 301169695Skan 302169695Skanstatic struct demangle_component * 303169695Skand_make_operator (struct d_info *, 304169695Skan const struct demangle_operator_info *); 305169695Skan 306169695Skanstatic struct demangle_component * 307169695Skand_make_extended_operator (struct d_info *, int, 308169695Skan struct demangle_component *); 309169695Skan 310169695Skanstatic struct demangle_component * 311169695Skand_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds, 312169695Skan struct demangle_component *); 313169695Skan 314169695Skanstatic struct demangle_component * 315169695Skand_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds, 316169695Skan struct demangle_component *); 317169695Skan 318169695Skanstatic struct demangle_component * 319169695Skand_make_template_param (struct d_info *, long); 320169695Skan 321169695Skanstatic struct demangle_component * 322169695Skand_make_sub (struct d_info *, const char *, int); 323169695Skan 324169695Skanstatic int 325169695Skanhas_return_type (struct demangle_component *); 326169695Skan 327169695Skanstatic int 328169695Skanis_ctor_dtor_or_conversion (struct demangle_component *); 329169695Skan 330169695Skanstatic struct demangle_component *d_encoding (struct d_info *, int); 331169695Skan 332169695Skanstatic struct demangle_component *d_name (struct d_info *); 333169695Skan 334169695Skanstatic struct demangle_component *d_nested_name (struct d_info *); 335169695Skan 336169695Skanstatic struct demangle_component *d_prefix (struct d_info *); 337169695Skan 338169695Skanstatic struct demangle_component *d_unqualified_name (struct d_info *); 339169695Skan 340169695Skanstatic struct demangle_component *d_source_name (struct d_info *); 341169695Skan 342169695Skanstatic long d_number (struct d_info *); 343169695Skan 344169695Skanstatic struct demangle_component *d_identifier (struct d_info *, int); 345169695Skan 346169695Skanstatic struct demangle_component *d_operator_name (struct d_info *); 347169695Skan 348169695Skanstatic struct demangle_component *d_special_name (struct d_info *); 349169695Skan 350169695Skanstatic int d_call_offset (struct d_info *, int); 351169695Skan 352169695Skanstatic struct demangle_component *d_ctor_dtor_name (struct d_info *); 353169695Skan 354169695Skanstatic struct demangle_component ** 355169695Skand_cv_qualifiers (struct d_info *, struct demangle_component **, int); 356169695Skan 357169695Skanstatic struct demangle_component * 358169695Skand_function_type (struct d_info *); 359169695Skan 360169695Skanstatic struct demangle_component * 361169695Skand_bare_function_type (struct d_info *, int); 362169695Skan 363169695Skanstatic struct demangle_component * 364169695Skand_class_enum_type (struct d_info *); 365169695Skan 366169695Skanstatic struct demangle_component *d_array_type (struct d_info *); 367169695Skan 368169695Skanstatic struct demangle_component * 369169695Skand_pointer_to_member_type (struct d_info *); 370169695Skan 371169695Skanstatic struct demangle_component * 372169695Skand_template_param (struct d_info *); 373169695Skan 374169695Skanstatic struct demangle_component *d_template_args (struct d_info *); 375169695Skan 376169695Skanstatic struct demangle_component * 377169695Skand_template_arg (struct d_info *); 378169695Skan 379169695Skanstatic struct demangle_component *d_expression (struct d_info *); 380169695Skan 381169695Skanstatic struct demangle_component *d_expr_primary (struct d_info *); 382169695Skan 383169695Skanstatic struct demangle_component *d_local_name (struct d_info *); 384169695Skan 385169695Skanstatic int d_discriminator (struct d_info *); 386169695Skan 387169695Skanstatic int 388169695Skand_add_substitution (struct d_info *, struct demangle_component *); 389169695Skan 390169695Skanstatic struct demangle_component *d_substitution (struct d_info *, int); 391169695Skan 392169695Skanstatic void d_print_resize (struct d_print_info *, size_t); 393169695Skan 394169695Skanstatic void d_print_append_char (struct d_print_info *, int); 395169695Skan 396169695Skanstatic void 397169695Skand_print_append_buffer (struct d_print_info *, const char *, size_t); 398169695Skan 399169695Skanstatic void d_print_error (struct d_print_info *); 400169695Skan 401169695Skanstatic void 402169695Skand_print_comp (struct d_print_info *, const struct demangle_component *); 403169695Skan 404169695Skanstatic void 405169695Skand_print_java_identifier (struct d_print_info *, const char *, int); 406169695Skan 407169695Skanstatic void 408169695Skand_print_mod_list (struct d_print_info *, struct d_print_mod *, int); 409169695Skan 410169695Skanstatic void 411169695Skand_print_mod (struct d_print_info *, const struct demangle_component *); 412169695Skan 413169695Skanstatic void 414169695Skand_print_function_type (struct d_print_info *, 415169695Skan const struct demangle_component *, 416169695Skan struct d_print_mod *); 417169695Skan 418169695Skanstatic void 419169695Skand_print_array_type (struct d_print_info *, 420169695Skan const struct demangle_component *, 421169695Skan struct d_print_mod *); 422169695Skan 423169695Skanstatic void 424169695Skand_print_expr_op (struct d_print_info *, const struct demangle_component *); 425169695Skan 426169695Skanstatic void 427169695Skand_print_cast (struct d_print_info *, const struct demangle_component *); 428169695Skan 429169695Skanstatic char *d_demangle (const char *, int, size_t *); 430169695Skan 431169695Skan#ifdef CP_DEMANGLE_DEBUG 432169695Skan 433169695Skanstatic void 434169695Skand_dump (struct demangle_component *dc, int indent) 435169695Skan{ 436169695Skan int i; 437169695Skan 438169695Skan if (dc == NULL) 439169695Skan return; 440169695Skan 441169695Skan for (i = 0; i < indent; ++i) 442169695Skan putchar (' '); 443169695Skan 444169695Skan switch (dc->type) 445169695Skan { 446169695Skan case DEMANGLE_COMPONENT_NAME: 447169695Skan printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s); 448169695Skan return; 449169695Skan case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 450169695Skan printf ("template parameter %ld\n", dc->u.s_number.number); 451169695Skan return; 452169695Skan case DEMANGLE_COMPONENT_CTOR: 453169695Skan printf ("constructor %d\n", (int) dc->u.s_ctor.kind); 454169695Skan d_dump (dc->u.s_ctor.name, indent + 2); 455169695Skan return; 456169695Skan case DEMANGLE_COMPONENT_DTOR: 457169695Skan printf ("destructor %d\n", (int) dc->u.s_dtor.kind); 458169695Skan d_dump (dc->u.s_dtor.name, indent + 2); 459169695Skan return; 460169695Skan case DEMANGLE_COMPONENT_SUB_STD: 461169695Skan printf ("standard substitution %s\n", dc->u.s_string.string); 462169695Skan return; 463169695Skan case DEMANGLE_COMPONENT_BUILTIN_TYPE: 464169695Skan printf ("builtin type %s\n", dc->u.s_builtin.type->name); 465169695Skan return; 466169695Skan case DEMANGLE_COMPONENT_OPERATOR: 467169695Skan printf ("operator %s\n", dc->u.s_operator.op->name); 468169695Skan return; 469169695Skan case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 470169695Skan printf ("extended operator with %d args\n", 471169695Skan dc->u.s_extended_operator.args); 472169695Skan d_dump (dc->u.s_extended_operator.name, indent + 2); 473169695Skan return; 474169695Skan 475169695Skan case DEMANGLE_COMPONENT_QUAL_NAME: 476169695Skan printf ("qualified name\n"); 477169695Skan break; 478169695Skan case DEMANGLE_COMPONENT_LOCAL_NAME: 479169695Skan printf ("local name\n"); 480169695Skan break; 481169695Skan case DEMANGLE_COMPONENT_TYPED_NAME: 482169695Skan printf ("typed name\n"); 483169695Skan break; 484169695Skan case DEMANGLE_COMPONENT_TEMPLATE: 485169695Skan printf ("template\n"); 486169695Skan break; 487169695Skan case DEMANGLE_COMPONENT_VTABLE: 488169695Skan printf ("vtable\n"); 489169695Skan break; 490169695Skan case DEMANGLE_COMPONENT_VTT: 491169695Skan printf ("VTT\n"); 492169695Skan break; 493169695Skan case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 494169695Skan printf ("construction vtable\n"); 495169695Skan break; 496169695Skan case DEMANGLE_COMPONENT_TYPEINFO: 497169695Skan printf ("typeinfo\n"); 498169695Skan break; 499169695Skan case DEMANGLE_COMPONENT_TYPEINFO_NAME: 500169695Skan printf ("typeinfo name\n"); 501169695Skan break; 502169695Skan case DEMANGLE_COMPONENT_TYPEINFO_FN: 503169695Skan printf ("typeinfo function\n"); 504169695Skan break; 505169695Skan case DEMANGLE_COMPONENT_THUNK: 506169695Skan printf ("thunk\n"); 507169695Skan break; 508169695Skan case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 509169695Skan printf ("virtual thunk\n"); 510169695Skan break; 511169695Skan case DEMANGLE_COMPONENT_COVARIANT_THUNK: 512169695Skan printf ("covariant thunk\n"); 513169695Skan break; 514169695Skan case DEMANGLE_COMPONENT_JAVA_CLASS: 515169695Skan printf ("java class\n"); 516169695Skan break; 517169695Skan case DEMANGLE_COMPONENT_GUARD: 518169695Skan printf ("guard\n"); 519169695Skan break; 520169695Skan case DEMANGLE_COMPONENT_REFTEMP: 521169695Skan printf ("reference temporary\n"); 522169695Skan break; 523169695Skan case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 524169695Skan printf ("hidden alias\n"); 525169695Skan break; 526169695Skan case DEMANGLE_COMPONENT_RESTRICT: 527169695Skan printf ("restrict\n"); 528169695Skan break; 529169695Skan case DEMANGLE_COMPONENT_VOLATILE: 530169695Skan printf ("volatile\n"); 531169695Skan break; 532169695Skan case DEMANGLE_COMPONENT_CONST: 533169695Skan printf ("const\n"); 534169695Skan break; 535169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 536169695Skan printf ("restrict this\n"); 537169695Skan break; 538169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 539169695Skan printf ("volatile this\n"); 540169695Skan break; 541169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 542169695Skan printf ("const this\n"); 543169695Skan break; 544169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 545169695Skan printf ("vendor type qualifier\n"); 546169695Skan break; 547169695Skan case DEMANGLE_COMPONENT_POINTER: 548169695Skan printf ("pointer\n"); 549169695Skan break; 550169695Skan case DEMANGLE_COMPONENT_REFERENCE: 551169695Skan printf ("reference\n"); 552169695Skan break; 553169695Skan case DEMANGLE_COMPONENT_COMPLEX: 554169695Skan printf ("complex\n"); 555169695Skan break; 556169695Skan case DEMANGLE_COMPONENT_IMAGINARY: 557169695Skan printf ("imaginary\n"); 558169695Skan break; 559169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE: 560169695Skan printf ("vendor type\n"); 561169695Skan break; 562169695Skan case DEMANGLE_COMPONENT_FUNCTION_TYPE: 563169695Skan printf ("function type\n"); 564169695Skan break; 565169695Skan case DEMANGLE_COMPONENT_ARRAY_TYPE: 566169695Skan printf ("array type\n"); 567169695Skan break; 568169695Skan case DEMANGLE_COMPONENT_PTRMEM_TYPE: 569169695Skan printf ("pointer to member type\n"); 570169695Skan break; 571169695Skan case DEMANGLE_COMPONENT_ARGLIST: 572169695Skan printf ("argument list\n"); 573169695Skan break; 574169695Skan case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 575169695Skan printf ("template argument list\n"); 576169695Skan break; 577169695Skan case DEMANGLE_COMPONENT_CAST: 578169695Skan printf ("cast\n"); 579169695Skan break; 580169695Skan case DEMANGLE_COMPONENT_UNARY: 581169695Skan printf ("unary operator\n"); 582169695Skan break; 583169695Skan case DEMANGLE_COMPONENT_BINARY: 584169695Skan printf ("binary operator\n"); 585169695Skan break; 586169695Skan case DEMANGLE_COMPONENT_BINARY_ARGS: 587169695Skan printf ("binary operator arguments\n"); 588169695Skan break; 589169695Skan case DEMANGLE_COMPONENT_TRINARY: 590169695Skan printf ("trinary operator\n"); 591169695Skan break; 592169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG1: 593169695Skan printf ("trinary operator arguments 1\n"); 594169695Skan break; 595169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG2: 596169695Skan printf ("trinary operator arguments 1\n"); 597169695Skan break; 598169695Skan case DEMANGLE_COMPONENT_LITERAL: 599169695Skan printf ("literal\n"); 600169695Skan break; 601169695Skan case DEMANGLE_COMPONENT_LITERAL_NEG: 602169695Skan printf ("negative literal\n"); 603169695Skan break; 604169695Skan } 605169695Skan 606169695Skan d_dump (d_left (dc), indent + 2); 607169695Skan d_dump (d_right (dc), indent + 2); 608169695Skan} 609169695Skan 610169695Skan#endif /* CP_DEMANGLE_DEBUG */ 611169695Skan 612169695Skan/* Fill in a DEMANGLE_COMPONENT_NAME. */ 613169695Skan 614169695SkanCP_STATIC_IF_GLIBCPP_V3 615169695Skanint 616169695Skancplus_demangle_fill_name (struct demangle_component *p, const char *s, int len) 617169695Skan{ 618169695Skan if (p == NULL || s == NULL || len == 0) 619169695Skan return 0; 620169695Skan p->type = DEMANGLE_COMPONENT_NAME; 621169695Skan p->u.s_name.s = s; 622169695Skan p->u.s_name.len = len; 623169695Skan return 1; 624169695Skan} 625169695Skan 626169695Skan/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */ 627169695Skan 628169695SkanCP_STATIC_IF_GLIBCPP_V3 629169695Skanint 630169695Skancplus_demangle_fill_extended_operator (struct demangle_component *p, int args, 631169695Skan struct demangle_component *name) 632169695Skan{ 633169695Skan if (p == NULL || args < 0 || name == NULL) 634169695Skan return 0; 635169695Skan p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR; 636169695Skan p->u.s_extended_operator.args = args; 637169695Skan p->u.s_extended_operator.name = name; 638169695Skan return 1; 639169695Skan} 640169695Skan 641169695Skan/* Fill in a DEMANGLE_COMPONENT_CTOR. */ 642169695Skan 643169695SkanCP_STATIC_IF_GLIBCPP_V3 644169695Skanint 645169695Skancplus_demangle_fill_ctor (struct demangle_component *p, 646169695Skan enum gnu_v3_ctor_kinds kind, 647169695Skan struct demangle_component *name) 648169695Skan{ 649169695Skan if (p == NULL 650169695Skan || name == NULL 651169695Skan || (kind < gnu_v3_complete_object_ctor 652169695Skan && kind > gnu_v3_complete_object_allocating_ctor)) 653169695Skan return 0; 654169695Skan p->type = DEMANGLE_COMPONENT_CTOR; 655169695Skan p->u.s_ctor.kind = kind; 656169695Skan p->u.s_ctor.name = name; 657169695Skan return 1; 658169695Skan} 659169695Skan 660169695Skan/* Fill in a DEMANGLE_COMPONENT_DTOR. */ 661169695Skan 662169695SkanCP_STATIC_IF_GLIBCPP_V3 663169695Skanint 664169695Skancplus_demangle_fill_dtor (struct demangle_component *p, 665169695Skan enum gnu_v3_dtor_kinds kind, 666169695Skan struct demangle_component *name) 667169695Skan{ 668169695Skan if (p == NULL 669169695Skan || name == NULL 670169695Skan || (kind < gnu_v3_deleting_dtor 671169695Skan && kind > gnu_v3_base_object_dtor)) 672169695Skan return 0; 673169695Skan p->type = DEMANGLE_COMPONENT_DTOR; 674169695Skan p->u.s_dtor.kind = kind; 675169695Skan p->u.s_dtor.name = name; 676169695Skan return 1; 677169695Skan} 678169695Skan 679169695Skan/* Add a new component. */ 680169695Skan 681169695Skanstatic struct demangle_component * 682169695Skand_make_empty (struct d_info *di) 683169695Skan{ 684169695Skan struct demangle_component *p; 685169695Skan 686169695Skan if (di->next_comp >= di->num_comps) 687169695Skan return NULL; 688169695Skan p = &di->comps[di->next_comp]; 689169695Skan ++di->next_comp; 690169695Skan return p; 691169695Skan} 692169695Skan 693169695Skan/* Add a new generic component. */ 694169695Skan 695169695Skanstatic struct demangle_component * 696169695Skand_make_comp (struct d_info *di, enum demangle_component_type type, 697169695Skan struct demangle_component *left, 698169695Skan struct demangle_component *right) 699169695Skan{ 700169695Skan struct demangle_component *p; 701169695Skan 702169695Skan /* We check for errors here. A typical error would be a NULL return 703169695Skan from a subroutine. We catch those here, and return NULL 704169695Skan upward. */ 705169695Skan switch (type) 706169695Skan { 707169695Skan /* These types require two parameters. */ 708169695Skan case DEMANGLE_COMPONENT_QUAL_NAME: 709169695Skan case DEMANGLE_COMPONENT_LOCAL_NAME: 710169695Skan case DEMANGLE_COMPONENT_TYPED_NAME: 711169695Skan case DEMANGLE_COMPONENT_TEMPLATE: 712169695Skan case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 713169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 714169695Skan case DEMANGLE_COMPONENT_PTRMEM_TYPE: 715169695Skan case DEMANGLE_COMPONENT_UNARY: 716169695Skan case DEMANGLE_COMPONENT_BINARY: 717169695Skan case DEMANGLE_COMPONENT_BINARY_ARGS: 718169695Skan case DEMANGLE_COMPONENT_TRINARY: 719169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG1: 720169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG2: 721169695Skan case DEMANGLE_COMPONENT_LITERAL: 722169695Skan case DEMANGLE_COMPONENT_LITERAL_NEG: 723169695Skan if (left == NULL || right == NULL) 724169695Skan return NULL; 725169695Skan break; 726169695Skan 727169695Skan /* These types only require one parameter. */ 728169695Skan case DEMANGLE_COMPONENT_VTABLE: 729169695Skan case DEMANGLE_COMPONENT_VTT: 730169695Skan case DEMANGLE_COMPONENT_TYPEINFO: 731169695Skan case DEMANGLE_COMPONENT_TYPEINFO_NAME: 732169695Skan case DEMANGLE_COMPONENT_TYPEINFO_FN: 733169695Skan case DEMANGLE_COMPONENT_THUNK: 734169695Skan case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 735169695Skan case DEMANGLE_COMPONENT_COVARIANT_THUNK: 736169695Skan case DEMANGLE_COMPONENT_JAVA_CLASS: 737169695Skan case DEMANGLE_COMPONENT_GUARD: 738169695Skan case DEMANGLE_COMPONENT_REFTEMP: 739169695Skan case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 740169695Skan case DEMANGLE_COMPONENT_POINTER: 741169695Skan case DEMANGLE_COMPONENT_REFERENCE: 742169695Skan case DEMANGLE_COMPONENT_COMPLEX: 743169695Skan case DEMANGLE_COMPONENT_IMAGINARY: 744169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE: 745169695Skan case DEMANGLE_COMPONENT_ARGLIST: 746169695Skan case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 747169695Skan case DEMANGLE_COMPONENT_CAST: 748169695Skan if (left == NULL) 749169695Skan return NULL; 750169695Skan break; 751169695Skan 752169695Skan /* This needs a right parameter, but the left parameter can be 753169695Skan empty. */ 754169695Skan case DEMANGLE_COMPONENT_ARRAY_TYPE: 755169695Skan if (right == NULL) 756169695Skan return NULL; 757169695Skan break; 758169695Skan 759169695Skan /* These are allowed to have no parameters--in some cases they 760169695Skan will be filled in later. */ 761169695Skan case DEMANGLE_COMPONENT_FUNCTION_TYPE: 762169695Skan case DEMANGLE_COMPONENT_RESTRICT: 763169695Skan case DEMANGLE_COMPONENT_VOLATILE: 764169695Skan case DEMANGLE_COMPONENT_CONST: 765169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 766169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 767169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 768169695Skan break; 769169695Skan 770169695Skan /* Other types should not be seen here. */ 771169695Skan default: 772169695Skan return NULL; 773169695Skan } 774169695Skan 775169695Skan p = d_make_empty (di); 776169695Skan if (p != NULL) 777169695Skan { 778169695Skan p->type = type; 779169695Skan p->u.s_binary.left = left; 780169695Skan p->u.s_binary.right = right; 781169695Skan } 782169695Skan return p; 783169695Skan} 784169695Skan 785169695Skan/* Add a new name component. */ 786169695Skan 787169695Skanstatic struct demangle_component * 788169695Skand_make_name (struct d_info *di, const char *s, int len) 789169695Skan{ 790169695Skan struct demangle_component *p; 791169695Skan 792169695Skan p = d_make_empty (di); 793169695Skan if (! cplus_demangle_fill_name (p, s, len)) 794169695Skan return NULL; 795169695Skan return p; 796169695Skan} 797169695Skan 798169695Skan/* Add a new builtin type component. */ 799169695Skan 800169695Skanstatic struct demangle_component * 801169695Skand_make_builtin_type (struct d_info *di, 802169695Skan const struct demangle_builtin_type_info *type) 803169695Skan{ 804169695Skan struct demangle_component *p; 805169695Skan 806169695Skan if (type == NULL) 807169695Skan return NULL; 808169695Skan p = d_make_empty (di); 809169695Skan if (p != NULL) 810169695Skan { 811169695Skan p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE; 812169695Skan p->u.s_builtin.type = type; 813169695Skan } 814169695Skan return p; 815169695Skan} 816169695Skan 817169695Skan/* Add a new operator component. */ 818169695Skan 819169695Skanstatic struct demangle_component * 820169695Skand_make_operator (struct d_info *di, const struct demangle_operator_info *op) 821169695Skan{ 822169695Skan struct demangle_component *p; 823169695Skan 824169695Skan p = d_make_empty (di); 825169695Skan if (p != NULL) 826169695Skan { 827169695Skan p->type = DEMANGLE_COMPONENT_OPERATOR; 828169695Skan p->u.s_operator.op = op; 829169695Skan } 830169695Skan return p; 831169695Skan} 832169695Skan 833169695Skan/* Add a new extended operator component. */ 834169695Skan 835169695Skanstatic struct demangle_component * 836169695Skand_make_extended_operator (struct d_info *di, int args, 837169695Skan struct demangle_component *name) 838169695Skan{ 839169695Skan struct demangle_component *p; 840169695Skan 841169695Skan p = d_make_empty (di); 842169695Skan if (! cplus_demangle_fill_extended_operator (p, args, name)) 843169695Skan return NULL; 844169695Skan return p; 845169695Skan} 846169695Skan 847169695Skan/* Add a new constructor component. */ 848169695Skan 849169695Skanstatic struct demangle_component * 850169695Skand_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind, 851169695Skan struct demangle_component *name) 852169695Skan{ 853169695Skan struct demangle_component *p; 854169695Skan 855169695Skan p = d_make_empty (di); 856169695Skan if (! cplus_demangle_fill_ctor (p, kind, name)) 857169695Skan return NULL; 858169695Skan return p; 859169695Skan} 860169695Skan 861169695Skan/* Add a new destructor component. */ 862169695Skan 863169695Skanstatic struct demangle_component * 864169695Skand_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind, 865169695Skan struct demangle_component *name) 866169695Skan{ 867169695Skan struct demangle_component *p; 868169695Skan 869169695Skan p = d_make_empty (di); 870169695Skan if (! cplus_demangle_fill_dtor (p, kind, name)) 871169695Skan return NULL; 872169695Skan return p; 873169695Skan} 874169695Skan 875169695Skan/* Add a new template parameter. */ 876169695Skan 877169695Skanstatic struct demangle_component * 878169695Skand_make_template_param (struct d_info *di, long i) 879169695Skan{ 880169695Skan struct demangle_component *p; 881169695Skan 882169695Skan p = d_make_empty (di); 883169695Skan if (p != NULL) 884169695Skan { 885169695Skan p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM; 886169695Skan p->u.s_number.number = i; 887169695Skan } 888169695Skan return p; 889169695Skan} 890169695Skan 891169695Skan/* Add a new standard substitution component. */ 892169695Skan 893169695Skanstatic struct demangle_component * 894169695Skand_make_sub (struct d_info *di, const char *name, int len) 895169695Skan{ 896169695Skan struct demangle_component *p; 897169695Skan 898169695Skan p = d_make_empty (di); 899169695Skan if (p != NULL) 900169695Skan { 901169695Skan p->type = DEMANGLE_COMPONENT_SUB_STD; 902169695Skan p->u.s_string.string = name; 903169695Skan p->u.s_string.len = len; 904169695Skan } 905169695Skan return p; 906169695Skan} 907169695Skan 908169695Skan/* <mangled-name> ::= _Z <encoding> 909169695Skan 910169695Skan TOP_LEVEL is non-zero when called at the top level. */ 911169695Skan 912169695SkanCP_STATIC_IF_GLIBCPP_V3 913169695Skanstruct demangle_component * 914169695Skancplus_demangle_mangled_name (struct d_info *di, int top_level) 915169695Skan{ 916258817Spfg if (! d_check_char (di, '_')) 917169695Skan return NULL; 918258817Spfg if (! d_check_char (di, 'Z')) 919169695Skan return NULL; 920169695Skan return d_encoding (di, top_level); 921169695Skan} 922169695Skan 923169695Skan/* Return whether a function should have a return type. The argument 924169695Skan is the function name, which may be qualified in various ways. The 925169695Skan rules are that template functions have return types with some 926169695Skan exceptions, function types which are not part of a function name 927169695Skan mangling have return types with some exceptions, and non-template 928169695Skan function names do not have return types. The exceptions are that 929169695Skan constructors, destructors, and conversion operators do not have 930169695Skan return types. */ 931169695Skan 932169695Skanstatic int 933169695Skanhas_return_type (struct demangle_component *dc) 934169695Skan{ 935169695Skan if (dc == NULL) 936169695Skan return 0; 937169695Skan switch (dc->type) 938169695Skan { 939169695Skan default: 940169695Skan return 0; 941169695Skan case DEMANGLE_COMPONENT_TEMPLATE: 942169695Skan return ! is_ctor_dtor_or_conversion (d_left (dc)); 943169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 944169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 945169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 946169695Skan return has_return_type (d_left (dc)); 947169695Skan } 948169695Skan} 949169695Skan 950169695Skan/* Return whether a name is a constructor, a destructor, or a 951169695Skan conversion operator. */ 952169695Skan 953169695Skanstatic int 954169695Skanis_ctor_dtor_or_conversion (struct demangle_component *dc) 955169695Skan{ 956169695Skan if (dc == NULL) 957169695Skan return 0; 958169695Skan switch (dc->type) 959169695Skan { 960169695Skan default: 961169695Skan return 0; 962169695Skan case DEMANGLE_COMPONENT_QUAL_NAME: 963169695Skan case DEMANGLE_COMPONENT_LOCAL_NAME: 964169695Skan return is_ctor_dtor_or_conversion (d_right (dc)); 965169695Skan case DEMANGLE_COMPONENT_CTOR: 966169695Skan case DEMANGLE_COMPONENT_DTOR: 967169695Skan case DEMANGLE_COMPONENT_CAST: 968169695Skan return 1; 969169695Skan } 970169695Skan} 971169695Skan 972169695Skan/* <encoding> ::= <(function) name> <bare-function-type> 973169695Skan ::= <(data) name> 974169695Skan ::= <special-name> 975169695Skan 976169695Skan TOP_LEVEL is non-zero when called at the top level, in which case 977169695Skan if DMGL_PARAMS is not set we do not demangle the function 978169695Skan parameters. We only set this at the top level, because otherwise 979169695Skan we would not correctly demangle names in local scopes. */ 980169695Skan 981169695Skanstatic struct demangle_component * 982169695Skand_encoding (struct d_info *di, int top_level) 983169695Skan{ 984169695Skan char peek = d_peek_char (di); 985169695Skan 986169695Skan if (peek == 'G' || peek == 'T') 987169695Skan return d_special_name (di); 988169695Skan else 989169695Skan { 990169695Skan struct demangle_component *dc; 991169695Skan 992169695Skan dc = d_name (di); 993169695Skan 994169695Skan if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0) 995169695Skan { 996169695Skan /* Strip off any initial CV-qualifiers, as they really apply 997169695Skan to the `this' parameter, and they were not output by the 998169695Skan v2 demangler without DMGL_PARAMS. */ 999169695Skan while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS 1000169695Skan || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS 1001169695Skan || dc->type == DEMANGLE_COMPONENT_CONST_THIS) 1002169695Skan dc = d_left (dc); 1003169695Skan 1004169695Skan /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then 1005169695Skan there may be CV-qualifiers on its right argument which 1006169695Skan really apply here; this happens when parsing a class 1007169695Skan which is local to a function. */ 1008169695Skan if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME) 1009169695Skan { 1010169695Skan struct demangle_component *dcr; 1011169695Skan 1012169695Skan dcr = d_right (dc); 1013169695Skan while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS 1014169695Skan || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS 1015169695Skan || dcr->type == DEMANGLE_COMPONENT_CONST_THIS) 1016169695Skan dcr = d_left (dcr); 1017169695Skan dc->u.s_binary.right = dcr; 1018169695Skan } 1019169695Skan 1020169695Skan return dc; 1021169695Skan } 1022169695Skan 1023169695Skan peek = d_peek_char (di); 1024258817Spfg if (dc == NULL || peek == '\0' || peek == 'E') 1025169695Skan return dc; 1026169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc, 1027169695Skan d_bare_function_type (di, has_return_type (dc))); 1028169695Skan } 1029169695Skan} 1030169695Skan 1031169695Skan/* <name> ::= <nested-name> 1032169695Skan ::= <unscoped-name> 1033169695Skan ::= <unscoped-template-name> <template-args> 1034169695Skan ::= <local-name> 1035169695Skan 1036169695Skan <unscoped-name> ::= <unqualified-name> 1037169695Skan ::= St <unqualified-name> 1038169695Skan 1039169695Skan <unscoped-template-name> ::= <unscoped-name> 1040169695Skan ::= <substitution> 1041169695Skan*/ 1042169695Skan 1043169695Skanstatic struct demangle_component * 1044169695Skand_name (struct d_info *di) 1045169695Skan{ 1046169695Skan char peek = d_peek_char (di); 1047169695Skan struct demangle_component *dc; 1048169695Skan 1049169695Skan switch (peek) 1050169695Skan { 1051169695Skan case 'N': 1052169695Skan return d_nested_name (di); 1053169695Skan 1054169695Skan case 'Z': 1055169695Skan return d_local_name (di); 1056169695Skan 1057258017Spfg case 'L': 1058258017Spfg return d_unqualified_name (di); 1059258017Spfg 1060169695Skan case 'S': 1061169695Skan { 1062169695Skan int subst; 1063169695Skan 1064169695Skan if (d_peek_next_char (di) != 't') 1065169695Skan { 1066169695Skan dc = d_substitution (di, 0); 1067169695Skan subst = 1; 1068169695Skan } 1069169695Skan else 1070169695Skan { 1071169695Skan d_advance (di, 2); 1072169695Skan dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, 1073169695Skan d_make_name (di, "std", 3), 1074169695Skan d_unqualified_name (di)); 1075169695Skan di->expansion += 3; 1076169695Skan subst = 0; 1077169695Skan } 1078169695Skan 1079169695Skan if (d_peek_char (di) != 'I') 1080169695Skan { 1081169695Skan /* The grammar does not permit this case to occur if we 1082169695Skan called d_substitution() above (i.e., subst == 1). We 1083169695Skan don't bother to check. */ 1084169695Skan } 1085169695Skan else 1086169695Skan { 1087169695Skan /* This is <template-args>, which means that we just saw 1088169695Skan <unscoped-template-name>, which is a substitution 1089169695Skan candidate if we didn't just get it from a 1090169695Skan substitution. */ 1091169695Skan if (! subst) 1092169695Skan { 1093169695Skan if (! d_add_substitution (di, dc)) 1094169695Skan return NULL; 1095169695Skan } 1096169695Skan dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, 1097169695Skan d_template_args (di)); 1098169695Skan } 1099169695Skan 1100169695Skan return dc; 1101169695Skan } 1102169695Skan 1103169695Skan default: 1104169695Skan dc = d_unqualified_name (di); 1105169695Skan if (d_peek_char (di) == 'I') 1106169695Skan { 1107169695Skan /* This is <template-args>, which means that we just saw 1108169695Skan <unscoped-template-name>, which is a substitution 1109169695Skan candidate. */ 1110169695Skan if (! d_add_substitution (di, dc)) 1111169695Skan return NULL; 1112169695Skan dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc, 1113169695Skan d_template_args (di)); 1114169695Skan } 1115169695Skan return dc; 1116169695Skan } 1117169695Skan} 1118169695Skan 1119169695Skan/* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E 1120169695Skan ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 1121169695Skan*/ 1122169695Skan 1123169695Skanstatic struct demangle_component * 1124169695Skand_nested_name (struct d_info *di) 1125169695Skan{ 1126169695Skan struct demangle_component *ret; 1127169695Skan struct demangle_component **pret; 1128169695Skan 1129258817Spfg if (! d_check_char (di, 'N')) 1130169695Skan return NULL; 1131169695Skan 1132169695Skan pret = d_cv_qualifiers (di, &ret, 1); 1133169695Skan if (pret == NULL) 1134169695Skan return NULL; 1135169695Skan 1136169695Skan *pret = d_prefix (di); 1137169695Skan if (*pret == NULL) 1138169695Skan return NULL; 1139169695Skan 1140258817Spfg if (! d_check_char (di, 'E')) 1141169695Skan return NULL; 1142169695Skan 1143169695Skan return ret; 1144169695Skan} 1145169695Skan 1146169695Skan/* <prefix> ::= <prefix> <unqualified-name> 1147169695Skan ::= <template-prefix> <template-args> 1148169695Skan ::= <template-param> 1149169695Skan ::= 1150169695Skan ::= <substitution> 1151169695Skan 1152169695Skan <template-prefix> ::= <prefix> <(template) unqualified-name> 1153169695Skan ::= <template-param> 1154169695Skan ::= <substitution> 1155169695Skan*/ 1156169695Skan 1157169695Skanstatic struct demangle_component * 1158169695Skand_prefix (struct d_info *di) 1159169695Skan{ 1160169695Skan struct demangle_component *ret = NULL; 1161169695Skan 1162169695Skan while (1) 1163169695Skan { 1164169695Skan char peek; 1165169695Skan enum demangle_component_type comb_type; 1166169695Skan struct demangle_component *dc; 1167169695Skan 1168169695Skan peek = d_peek_char (di); 1169169695Skan if (peek == '\0') 1170169695Skan return NULL; 1171169695Skan 1172169695Skan /* The older code accepts a <local-name> here, but I don't see 1173169695Skan that in the grammar. The older code does not accept a 1174169695Skan <template-param> here. */ 1175169695Skan 1176169695Skan comb_type = DEMANGLE_COMPONENT_QUAL_NAME; 1177169695Skan if (IS_DIGIT (peek) 1178169695Skan || IS_LOWER (peek) 1179169695Skan || peek == 'C' 1180258017Spfg || peek == 'D' 1181258017Spfg || peek == 'L') 1182169695Skan dc = d_unqualified_name (di); 1183169695Skan else if (peek == 'S') 1184169695Skan dc = d_substitution (di, 1); 1185169695Skan else if (peek == 'I') 1186169695Skan { 1187169695Skan if (ret == NULL) 1188169695Skan return NULL; 1189169695Skan comb_type = DEMANGLE_COMPONENT_TEMPLATE; 1190169695Skan dc = d_template_args (di); 1191169695Skan } 1192169695Skan else if (peek == 'T') 1193169695Skan dc = d_template_param (di); 1194169695Skan else if (peek == 'E') 1195169695Skan return ret; 1196169695Skan else 1197169695Skan return NULL; 1198169695Skan 1199169695Skan if (ret == NULL) 1200169695Skan ret = dc; 1201169695Skan else 1202169695Skan ret = d_make_comp (di, comb_type, ret, dc); 1203169695Skan 1204169695Skan if (peek != 'S' && d_peek_char (di) != 'E') 1205169695Skan { 1206169695Skan if (! d_add_substitution (di, ret)) 1207169695Skan return NULL; 1208169695Skan } 1209169695Skan } 1210169695Skan} 1211169695Skan 1212169695Skan/* <unqualified-name> ::= <operator-name> 1213169695Skan ::= <ctor-dtor-name> 1214169695Skan ::= <source-name> 1215258017Spfg ::= <local-source-name> 1216258017Spfg 1217258017Spfg <local-source-name> ::= L <source-name> <discriminator> 1218169695Skan*/ 1219169695Skan 1220169695Skanstatic struct demangle_component * 1221169695Skand_unqualified_name (struct d_info *di) 1222169695Skan{ 1223169695Skan char peek; 1224169695Skan 1225169695Skan peek = d_peek_char (di); 1226169695Skan if (IS_DIGIT (peek)) 1227169695Skan return d_source_name (di); 1228169695Skan else if (IS_LOWER (peek)) 1229169695Skan { 1230169695Skan struct demangle_component *ret; 1231169695Skan 1232169695Skan ret = d_operator_name (di); 1233169695Skan if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) 1234169695Skan di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2; 1235169695Skan return ret; 1236169695Skan } 1237169695Skan else if (peek == 'C' || peek == 'D') 1238169695Skan return d_ctor_dtor_name (di); 1239258017Spfg else if (peek == 'L') 1240258017Spfg { 1241258017Spfg struct demangle_component * ret; 1242258017Spfg 1243258017Spfg d_advance (di, 1); 1244258017Spfg 1245258017Spfg ret = d_source_name (di); 1246258017Spfg if (ret == NULL) 1247258017Spfg return NULL; 1248258017Spfg if (! d_discriminator (di)) 1249258017Spfg return NULL; 1250258017Spfg return ret; 1251258017Spfg } 1252169695Skan else 1253169695Skan return NULL; 1254169695Skan} 1255169695Skan 1256169695Skan/* <source-name> ::= <(positive length) number> <identifier> */ 1257169695Skan 1258169695Skanstatic struct demangle_component * 1259169695Skand_source_name (struct d_info *di) 1260169695Skan{ 1261169695Skan long len; 1262169695Skan struct demangle_component *ret; 1263169695Skan 1264169695Skan len = d_number (di); 1265169695Skan if (len <= 0) 1266169695Skan return NULL; 1267169695Skan ret = d_identifier (di, len); 1268169695Skan di->last_name = ret; 1269169695Skan return ret; 1270169695Skan} 1271169695Skan 1272169695Skan/* number ::= [n] <(non-negative decimal integer)> */ 1273169695Skan 1274169695Skanstatic long 1275169695Skand_number (struct d_info *di) 1276169695Skan{ 1277169695Skan int negative; 1278169695Skan char peek; 1279169695Skan long ret; 1280169695Skan 1281169695Skan negative = 0; 1282169695Skan peek = d_peek_char (di); 1283169695Skan if (peek == 'n') 1284169695Skan { 1285169695Skan negative = 1; 1286169695Skan d_advance (di, 1); 1287169695Skan peek = d_peek_char (di); 1288169695Skan } 1289169695Skan 1290169695Skan ret = 0; 1291169695Skan while (1) 1292169695Skan { 1293169695Skan if (! IS_DIGIT (peek)) 1294169695Skan { 1295169695Skan if (negative) 1296169695Skan ret = - ret; 1297169695Skan return ret; 1298169695Skan } 1299169695Skan ret = ret * 10 + peek - '0'; 1300169695Skan d_advance (di, 1); 1301169695Skan peek = d_peek_char (di); 1302169695Skan } 1303169695Skan} 1304169695Skan 1305169695Skan/* identifier ::= <(unqualified source code identifier)> */ 1306169695Skan 1307169695Skanstatic struct demangle_component * 1308169695Skand_identifier (struct d_info *di, int len) 1309169695Skan{ 1310169695Skan const char *name; 1311169695Skan 1312169695Skan name = d_str (di); 1313169695Skan 1314169695Skan if (di->send - name < len) 1315169695Skan return NULL; 1316169695Skan 1317169695Skan d_advance (di, len); 1318169695Skan 1319169695Skan /* A Java mangled name may have a trailing '$' if it is a C++ 1320169695Skan keyword. This '$' is not included in the length count. We just 1321169695Skan ignore the '$'. */ 1322169695Skan if ((di->options & DMGL_JAVA) != 0 1323169695Skan && d_peek_char (di) == '$') 1324169695Skan d_advance (di, 1); 1325169695Skan 1326169695Skan /* Look for something which looks like a gcc encoding of an 1327169695Skan anonymous namespace, and replace it with a more user friendly 1328169695Skan name. */ 1329169695Skan if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2 1330169695Skan && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX, 1331169695Skan ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0) 1332169695Skan { 1333169695Skan const char *s; 1334169695Skan 1335169695Skan s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN; 1336169695Skan if ((*s == '.' || *s == '_' || *s == '$') 1337169695Skan && s[1] == 'N') 1338169695Skan { 1339169695Skan di->expansion -= len - sizeof "(anonymous namespace)"; 1340169695Skan return d_make_name (di, "(anonymous namespace)", 1341169695Skan sizeof "(anonymous namespace)" - 1); 1342169695Skan } 1343169695Skan } 1344169695Skan 1345169695Skan return d_make_name (di, name, len); 1346169695Skan} 1347169695Skan 1348169695Skan/* operator_name ::= many different two character encodings. 1349169695Skan ::= cv <type> 1350169695Skan ::= v <digit> <source-name> 1351169695Skan*/ 1352169695Skan 1353169695Skan#define NL(s) s, (sizeof s) - 1 1354169695Skan 1355169695SkanCP_STATIC_IF_GLIBCPP_V3 1356169695Skanconst struct demangle_operator_info cplus_demangle_operators[] = 1357169695Skan{ 1358169695Skan { "aN", NL ("&="), 2 }, 1359169695Skan { "aS", NL ("="), 2 }, 1360169695Skan { "aa", NL ("&&"), 2 }, 1361169695Skan { "ad", NL ("&"), 1 }, 1362169695Skan { "an", NL ("&"), 2 }, 1363169695Skan { "cl", NL ("()"), 0 }, 1364169695Skan { "cm", NL (","), 2 }, 1365169695Skan { "co", NL ("~"), 1 }, 1366169695Skan { "dV", NL ("/="), 2 }, 1367169695Skan { "da", NL ("delete[]"), 1 }, 1368169695Skan { "de", NL ("*"), 1 }, 1369169695Skan { "dl", NL ("delete"), 1 }, 1370169695Skan { "dv", NL ("/"), 2 }, 1371169695Skan { "eO", NL ("^="), 2 }, 1372169695Skan { "eo", NL ("^"), 2 }, 1373169695Skan { "eq", NL ("=="), 2 }, 1374169695Skan { "ge", NL (">="), 2 }, 1375169695Skan { "gt", NL (">"), 2 }, 1376169695Skan { "ix", NL ("[]"), 2 }, 1377169695Skan { "lS", NL ("<<="), 2 }, 1378169695Skan { "le", NL ("<="), 2 }, 1379169695Skan { "ls", NL ("<<"), 2 }, 1380169695Skan { "lt", NL ("<"), 2 }, 1381169695Skan { "mI", NL ("-="), 2 }, 1382169695Skan { "mL", NL ("*="), 2 }, 1383169695Skan { "mi", NL ("-"), 2 }, 1384169695Skan { "ml", NL ("*"), 2 }, 1385169695Skan { "mm", NL ("--"), 1 }, 1386169695Skan { "na", NL ("new[]"), 1 }, 1387169695Skan { "ne", NL ("!="), 2 }, 1388169695Skan { "ng", NL ("-"), 1 }, 1389169695Skan { "nt", NL ("!"), 1 }, 1390169695Skan { "nw", NL ("new"), 1 }, 1391169695Skan { "oR", NL ("|="), 2 }, 1392169695Skan { "oo", NL ("||"), 2 }, 1393169695Skan { "or", NL ("|"), 2 }, 1394169695Skan { "pL", NL ("+="), 2 }, 1395169695Skan { "pl", NL ("+"), 2 }, 1396169695Skan { "pm", NL ("->*"), 2 }, 1397169695Skan { "pp", NL ("++"), 1 }, 1398169695Skan { "ps", NL ("+"), 1 }, 1399169695Skan { "pt", NL ("->"), 2 }, 1400169695Skan { "qu", NL ("?"), 3 }, 1401169695Skan { "rM", NL ("%="), 2 }, 1402169695Skan { "rS", NL (">>="), 2 }, 1403169695Skan { "rm", NL ("%"), 2 }, 1404169695Skan { "rs", NL (">>"), 2 }, 1405169695Skan { "st", NL ("sizeof "), 1 }, 1406169695Skan { "sz", NL ("sizeof "), 1 }, 1407169695Skan { NULL, NULL, 0, 0 } 1408169695Skan}; 1409169695Skan 1410169695Skanstatic struct demangle_component * 1411169695Skand_operator_name (struct d_info *di) 1412169695Skan{ 1413169695Skan char c1; 1414169695Skan char c2; 1415169695Skan 1416169695Skan c1 = d_next_char (di); 1417169695Skan c2 = d_next_char (di); 1418169695Skan if (c1 == 'v' && IS_DIGIT (c2)) 1419169695Skan return d_make_extended_operator (di, c2 - '0', d_source_name (di)); 1420169695Skan else if (c1 == 'c' && c2 == 'v') 1421169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_CAST, 1422169695Skan cplus_demangle_type (di), NULL); 1423169695Skan else 1424169695Skan { 1425169695Skan /* LOW is the inclusive lower bound. */ 1426169695Skan int low = 0; 1427169695Skan /* HIGH is the exclusive upper bound. We subtract one to ignore 1428169695Skan the sentinel at the end of the array. */ 1429169695Skan int high = ((sizeof (cplus_demangle_operators) 1430169695Skan / sizeof (cplus_demangle_operators[0])) 1431169695Skan - 1); 1432169695Skan 1433169695Skan while (1) 1434169695Skan { 1435169695Skan int i; 1436169695Skan const struct demangle_operator_info *p; 1437169695Skan 1438169695Skan i = low + (high - low) / 2; 1439169695Skan p = cplus_demangle_operators + i; 1440169695Skan 1441169695Skan if (c1 == p->code[0] && c2 == p->code[1]) 1442169695Skan return d_make_operator (di, p); 1443169695Skan 1444169695Skan if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1])) 1445169695Skan high = i; 1446169695Skan else 1447169695Skan low = i + 1; 1448169695Skan if (low == high) 1449169695Skan return NULL; 1450169695Skan } 1451169695Skan } 1452169695Skan} 1453169695Skan 1454169695Skan/* <special-name> ::= TV <type> 1455169695Skan ::= TT <type> 1456169695Skan ::= TI <type> 1457169695Skan ::= TS <type> 1458169695Skan ::= GV <(object) name> 1459169695Skan ::= T <call-offset> <(base) encoding> 1460169695Skan ::= Tc <call-offset> <call-offset> <(base) encoding> 1461169695Skan Also g++ extensions: 1462169695Skan ::= TC <type> <(offset) number> _ <(base) type> 1463169695Skan ::= TF <type> 1464169695Skan ::= TJ <type> 1465169695Skan ::= GR <name> 1466169695Skan ::= GA <encoding> 1467169695Skan*/ 1468169695Skan 1469169695Skanstatic struct demangle_component * 1470169695Skand_special_name (struct d_info *di) 1471169695Skan{ 1472169695Skan di->expansion += 20; 1473258817Spfg if (d_check_char (di, 'T')) 1474169695Skan { 1475169695Skan switch (d_next_char (di)) 1476169695Skan { 1477169695Skan case 'V': 1478169695Skan di->expansion -= 5; 1479169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE, 1480169695Skan cplus_demangle_type (di), NULL); 1481169695Skan case 'T': 1482169695Skan di->expansion -= 10; 1483169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_VTT, 1484169695Skan cplus_demangle_type (di), NULL); 1485169695Skan case 'I': 1486169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO, 1487169695Skan cplus_demangle_type (di), NULL); 1488169695Skan case 'S': 1489169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME, 1490169695Skan cplus_demangle_type (di), NULL); 1491169695Skan 1492169695Skan case 'h': 1493169695Skan if (! d_call_offset (di, 'h')) 1494169695Skan return NULL; 1495169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_THUNK, 1496169695Skan d_encoding (di, 0), NULL); 1497169695Skan 1498169695Skan case 'v': 1499169695Skan if (! d_call_offset (di, 'v')) 1500169695Skan return NULL; 1501169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK, 1502169695Skan d_encoding (di, 0), NULL); 1503169695Skan 1504169695Skan case 'c': 1505169695Skan if (! d_call_offset (di, '\0')) 1506169695Skan return NULL; 1507169695Skan if (! d_call_offset (di, '\0')) 1508169695Skan return NULL; 1509169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK, 1510169695Skan d_encoding (di, 0), NULL); 1511169695Skan 1512169695Skan case 'C': 1513169695Skan { 1514169695Skan struct demangle_component *derived_type; 1515169695Skan long offset; 1516169695Skan struct demangle_component *base_type; 1517169695Skan 1518169695Skan derived_type = cplus_demangle_type (di); 1519169695Skan offset = d_number (di); 1520169695Skan if (offset < 0) 1521169695Skan return NULL; 1522258817Spfg if (! d_check_char (di, '_')) 1523169695Skan return NULL; 1524169695Skan base_type = cplus_demangle_type (di); 1525169695Skan /* We don't display the offset. FIXME: We should display 1526169695Skan it in verbose mode. */ 1527169695Skan di->expansion += 5; 1528169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, 1529169695Skan base_type, derived_type); 1530169695Skan } 1531169695Skan 1532169695Skan case 'F': 1533169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN, 1534169695Skan cplus_demangle_type (di), NULL); 1535169695Skan case 'J': 1536169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS, 1537169695Skan cplus_demangle_type (di), NULL); 1538169695Skan 1539169695Skan default: 1540169695Skan return NULL; 1541169695Skan } 1542169695Skan } 1543258817Spfg else if (d_check_char (di, 'G')) 1544169695Skan { 1545169695Skan switch (d_next_char (di)) 1546169695Skan { 1547169695Skan case 'V': 1548169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL); 1549169695Skan 1550169695Skan case 'R': 1551169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di), 1552169695Skan NULL); 1553169695Skan 1554169695Skan case 'A': 1555169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS, 1556169695Skan d_encoding (di, 0), NULL); 1557169695Skan 1558169695Skan default: 1559169695Skan return NULL; 1560169695Skan } 1561169695Skan } 1562169695Skan else 1563169695Skan return NULL; 1564169695Skan} 1565169695Skan 1566169695Skan/* <call-offset> ::= h <nv-offset> _ 1567169695Skan ::= v <v-offset> _ 1568169695Skan 1569169695Skan <nv-offset> ::= <(offset) number> 1570169695Skan 1571169695Skan <v-offset> ::= <(offset) number> _ <(virtual offset) number> 1572169695Skan 1573169695Skan The C parameter, if not '\0', is a character we just read which is 1574169695Skan the start of the <call-offset>. 1575169695Skan 1576169695Skan We don't display the offset information anywhere. FIXME: We should 1577169695Skan display it in verbose mode. */ 1578169695Skan 1579169695Skanstatic int 1580169695Skand_call_offset (struct d_info *di, int c) 1581169695Skan{ 1582169695Skan if (c == '\0') 1583169695Skan c = d_next_char (di); 1584169695Skan 1585169695Skan if (c == 'h') 1586169695Skan d_number (di); 1587169695Skan else if (c == 'v') 1588169695Skan { 1589169695Skan d_number (di); 1590258817Spfg if (! d_check_char (di, '_')) 1591169695Skan return 0; 1592169695Skan d_number (di); 1593169695Skan } 1594169695Skan else 1595169695Skan return 0; 1596169695Skan 1597258817Spfg if (! d_check_char (di, '_')) 1598169695Skan return 0; 1599169695Skan 1600169695Skan return 1; 1601169695Skan} 1602169695Skan 1603169695Skan/* <ctor-dtor-name> ::= C1 1604169695Skan ::= C2 1605169695Skan ::= C3 1606169695Skan ::= D0 1607169695Skan ::= D1 1608169695Skan ::= D2 1609169695Skan*/ 1610169695Skan 1611169695Skanstatic struct demangle_component * 1612169695Skand_ctor_dtor_name (struct d_info *di) 1613169695Skan{ 1614169695Skan if (di->last_name != NULL) 1615169695Skan { 1616169695Skan if (di->last_name->type == DEMANGLE_COMPONENT_NAME) 1617169695Skan di->expansion += di->last_name->u.s_name.len; 1618169695Skan else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD) 1619169695Skan di->expansion += di->last_name->u.s_string.len; 1620169695Skan } 1621258817Spfg switch (d_peek_char (di)) 1622169695Skan { 1623169695Skan case 'C': 1624169695Skan { 1625169695Skan enum gnu_v3_ctor_kinds kind; 1626169695Skan 1627258817Spfg switch (d_peek_next_char (di)) 1628169695Skan { 1629169695Skan case '1': 1630169695Skan kind = gnu_v3_complete_object_ctor; 1631169695Skan break; 1632169695Skan case '2': 1633169695Skan kind = gnu_v3_base_object_ctor; 1634169695Skan break; 1635169695Skan case '3': 1636169695Skan kind = gnu_v3_complete_object_allocating_ctor; 1637169695Skan break; 1638169695Skan default: 1639169695Skan return NULL; 1640169695Skan } 1641258817Spfg d_advance (di, 2); 1642169695Skan return d_make_ctor (di, kind, di->last_name); 1643169695Skan } 1644169695Skan 1645169695Skan case 'D': 1646169695Skan { 1647169695Skan enum gnu_v3_dtor_kinds kind; 1648169695Skan 1649258817Spfg switch (d_peek_next_char (di)) 1650169695Skan { 1651169695Skan case '0': 1652169695Skan kind = gnu_v3_deleting_dtor; 1653169695Skan break; 1654169695Skan case '1': 1655169695Skan kind = gnu_v3_complete_object_dtor; 1656169695Skan break; 1657169695Skan case '2': 1658169695Skan kind = gnu_v3_base_object_dtor; 1659169695Skan break; 1660169695Skan default: 1661169695Skan return NULL; 1662169695Skan } 1663258817Spfg d_advance (di, 2); 1664169695Skan return d_make_dtor (di, kind, di->last_name); 1665169695Skan } 1666169695Skan 1667169695Skan default: 1668169695Skan return NULL; 1669169695Skan } 1670169695Skan} 1671169695Skan 1672169695Skan/* <type> ::= <builtin-type> 1673169695Skan ::= <function-type> 1674169695Skan ::= <class-enum-type> 1675169695Skan ::= <array-type> 1676169695Skan ::= <pointer-to-member-type> 1677169695Skan ::= <template-param> 1678169695Skan ::= <template-template-param> <template-args> 1679169695Skan ::= <substitution> 1680169695Skan ::= <CV-qualifiers> <type> 1681169695Skan ::= P <type> 1682169695Skan ::= R <type> 1683169695Skan ::= C <type> 1684169695Skan ::= G <type> 1685169695Skan ::= U <source-name> <type> 1686169695Skan 1687169695Skan <builtin-type> ::= various one letter codes 1688169695Skan ::= u <source-name> 1689169695Skan*/ 1690169695Skan 1691169695SkanCP_STATIC_IF_GLIBCPP_V3 1692169695Skanconst struct demangle_builtin_type_info 1693169695Skancplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] = 1694169695Skan{ 1695169695Skan /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT }, 1696169695Skan /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL }, 1697169695Skan /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT }, 1698169695Skan /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT }, 1699169695Skan /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT }, 1700169695Skan /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT }, 1701169695Skan /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT }, 1702169695Skan /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT }, 1703169695Skan /* i */ { NL ("int"), NL ("int"), D_PRINT_INT }, 1704169695Skan /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED }, 1705169695Skan /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 1706169695Skan /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG }, 1707169695Skan /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG }, 1708169695Skan /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT }, 1709169695Skan /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"), 1710169695Skan D_PRINT_DEFAULT }, 1711169695Skan /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 1712169695Skan /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 1713169695Skan /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 1714169695Skan /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT }, 1715169695Skan /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT }, 1716169695Skan /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT }, 1717169695Skan /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID }, 1718169695Skan /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT }, 1719169695Skan /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG }, 1720169695Skan /* y */ { NL ("unsigned long long"), NL ("unsigned long long"), 1721169695Skan D_PRINT_UNSIGNED_LONG_LONG }, 1722169695Skan /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT }, 1723169695Skan}; 1724169695Skan 1725169695SkanCP_STATIC_IF_GLIBCPP_V3 1726169695Skanstruct demangle_component * 1727169695Skancplus_demangle_type (struct d_info *di) 1728169695Skan{ 1729169695Skan char peek; 1730169695Skan struct demangle_component *ret; 1731169695Skan int can_subst; 1732169695Skan 1733169695Skan /* The ABI specifies that when CV-qualifiers are used, the base type 1734169695Skan is substitutable, and the fully qualified type is substitutable, 1735169695Skan but the base type with a strict subset of the CV-qualifiers is 1736169695Skan not substitutable. The natural recursive implementation of the 1737169695Skan CV-qualifiers would cause subsets to be substitutable, so instead 1738169695Skan we pull them all off now. 1739169695Skan 1740169695Skan FIXME: The ABI says that order-insensitive vendor qualifiers 1741169695Skan should be handled in the same way, but we have no way to tell 1742169695Skan which vendor qualifiers are order-insensitive and which are 1743169695Skan order-sensitive. So we just assume that they are all 1744169695Skan order-sensitive. g++ 3.4 supports only one vendor qualifier, 1745169695Skan __vector, and it treats it as order-sensitive when mangling 1746169695Skan names. */ 1747169695Skan 1748169695Skan peek = d_peek_char (di); 1749169695Skan if (peek == 'r' || peek == 'V' || peek == 'K') 1750169695Skan { 1751169695Skan struct demangle_component **pret; 1752169695Skan 1753169695Skan pret = d_cv_qualifiers (di, &ret, 0); 1754169695Skan if (pret == NULL) 1755169695Skan return NULL; 1756169695Skan *pret = cplus_demangle_type (di); 1757258817Spfg if (! *pret || ! d_add_substitution (di, ret)) 1758169695Skan return NULL; 1759169695Skan return ret; 1760169695Skan } 1761169695Skan 1762169695Skan can_subst = 1; 1763169695Skan 1764169695Skan switch (peek) 1765169695Skan { 1766169695Skan case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': 1767169695Skan case 'h': case 'i': case 'j': case 'l': case 'm': case 'n': 1768169695Skan case 'o': case 's': case 't': 1769169695Skan case 'v': case 'w': case 'x': case 'y': case 'z': 1770169695Skan ret = d_make_builtin_type (di, 1771169695Skan &cplus_demangle_builtin_types[peek - 'a']); 1772169695Skan di->expansion += ret->u.s_builtin.type->len; 1773169695Skan can_subst = 0; 1774169695Skan d_advance (di, 1); 1775169695Skan break; 1776169695Skan 1777169695Skan case 'u': 1778169695Skan d_advance (di, 1); 1779169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE, 1780169695Skan d_source_name (di), NULL); 1781169695Skan break; 1782169695Skan 1783169695Skan case 'F': 1784169695Skan ret = d_function_type (di); 1785169695Skan break; 1786169695Skan 1787169695Skan case '0': case '1': case '2': case '3': case '4': 1788169695Skan case '5': case '6': case '7': case '8': case '9': 1789169695Skan case 'N': 1790169695Skan case 'Z': 1791169695Skan ret = d_class_enum_type (di); 1792169695Skan break; 1793169695Skan 1794169695Skan case 'A': 1795169695Skan ret = d_array_type (di); 1796169695Skan break; 1797169695Skan 1798169695Skan case 'M': 1799169695Skan ret = d_pointer_to_member_type (di); 1800169695Skan break; 1801169695Skan 1802169695Skan case 'T': 1803169695Skan ret = d_template_param (di); 1804169695Skan if (d_peek_char (di) == 'I') 1805169695Skan { 1806169695Skan /* This is <template-template-param> <template-args>. The 1807169695Skan <template-template-param> part is a substitution 1808169695Skan candidate. */ 1809169695Skan if (! d_add_substitution (di, ret)) 1810169695Skan return NULL; 1811169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 1812169695Skan d_template_args (di)); 1813169695Skan } 1814169695Skan break; 1815169695Skan 1816169695Skan case 'S': 1817169695Skan /* If this is a special substitution, then it is the start of 1818169695Skan <class-enum-type>. */ 1819169695Skan { 1820169695Skan char peek_next; 1821169695Skan 1822169695Skan peek_next = d_peek_next_char (di); 1823169695Skan if (IS_DIGIT (peek_next) 1824169695Skan || peek_next == '_' 1825169695Skan || IS_UPPER (peek_next)) 1826169695Skan { 1827169695Skan ret = d_substitution (di, 0); 1828169695Skan /* The substituted name may have been a template name and 1829169695Skan may be followed by tepmlate args. */ 1830169695Skan if (d_peek_char (di) == 'I') 1831169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret, 1832169695Skan d_template_args (di)); 1833169695Skan else 1834169695Skan can_subst = 0; 1835169695Skan } 1836169695Skan else 1837169695Skan { 1838169695Skan ret = d_class_enum_type (di); 1839169695Skan /* If the substitution was a complete type, then it is not 1840169695Skan a new substitution candidate. However, if the 1841169695Skan substitution was followed by template arguments, then 1842169695Skan the whole thing is a substitution candidate. */ 1843169695Skan if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD) 1844169695Skan can_subst = 0; 1845169695Skan } 1846169695Skan } 1847169695Skan break; 1848169695Skan 1849169695Skan case 'P': 1850169695Skan d_advance (di, 1); 1851169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER, 1852169695Skan cplus_demangle_type (di), NULL); 1853169695Skan break; 1854169695Skan 1855169695Skan case 'R': 1856169695Skan d_advance (di, 1); 1857169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE, 1858169695Skan cplus_demangle_type (di), NULL); 1859169695Skan break; 1860169695Skan 1861169695Skan case 'C': 1862169695Skan d_advance (di, 1); 1863169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX, 1864169695Skan cplus_demangle_type (di), NULL); 1865169695Skan break; 1866169695Skan 1867169695Skan case 'G': 1868169695Skan d_advance (di, 1); 1869169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY, 1870169695Skan cplus_demangle_type (di), NULL); 1871169695Skan break; 1872169695Skan 1873169695Skan case 'U': 1874169695Skan d_advance (di, 1); 1875169695Skan ret = d_source_name (di); 1876169695Skan ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, 1877169695Skan cplus_demangle_type (di), ret); 1878169695Skan break; 1879169695Skan 1880169695Skan default: 1881169695Skan return NULL; 1882169695Skan } 1883169695Skan 1884169695Skan if (can_subst) 1885169695Skan { 1886169695Skan if (! d_add_substitution (di, ret)) 1887169695Skan return NULL; 1888169695Skan } 1889169695Skan 1890169695Skan return ret; 1891169695Skan} 1892169695Skan 1893169695Skan/* <CV-qualifiers> ::= [r] [V] [K] */ 1894169695Skan 1895169695Skanstatic struct demangle_component ** 1896169695Skand_cv_qualifiers (struct d_info *di, 1897169695Skan struct demangle_component **pret, int member_fn) 1898169695Skan{ 1899169695Skan char peek; 1900169695Skan 1901169695Skan peek = d_peek_char (di); 1902169695Skan while (peek == 'r' || peek == 'V' || peek == 'K') 1903169695Skan { 1904169695Skan enum demangle_component_type t; 1905169695Skan 1906169695Skan d_advance (di, 1); 1907169695Skan if (peek == 'r') 1908169695Skan { 1909169695Skan t = (member_fn 1910169695Skan ? DEMANGLE_COMPONENT_RESTRICT_THIS 1911169695Skan : DEMANGLE_COMPONENT_RESTRICT); 1912169695Skan di->expansion += sizeof "restrict"; 1913169695Skan } 1914169695Skan else if (peek == 'V') 1915169695Skan { 1916169695Skan t = (member_fn 1917169695Skan ? DEMANGLE_COMPONENT_VOLATILE_THIS 1918169695Skan : DEMANGLE_COMPONENT_VOLATILE); 1919169695Skan di->expansion += sizeof "volatile"; 1920169695Skan } 1921169695Skan else 1922169695Skan { 1923169695Skan t = (member_fn 1924169695Skan ? DEMANGLE_COMPONENT_CONST_THIS 1925169695Skan : DEMANGLE_COMPONENT_CONST); 1926169695Skan di->expansion += sizeof "const"; 1927169695Skan } 1928169695Skan 1929169695Skan *pret = d_make_comp (di, t, NULL, NULL); 1930169695Skan if (*pret == NULL) 1931169695Skan return NULL; 1932169695Skan pret = &d_left (*pret); 1933169695Skan 1934169695Skan peek = d_peek_char (di); 1935169695Skan } 1936169695Skan 1937169695Skan return pret; 1938169695Skan} 1939169695Skan 1940169695Skan/* <function-type> ::= F [Y] <bare-function-type> E */ 1941169695Skan 1942169695Skanstatic struct demangle_component * 1943169695Skand_function_type (struct d_info *di) 1944169695Skan{ 1945169695Skan struct demangle_component *ret; 1946169695Skan 1947258817Spfg if (! d_check_char (di, 'F')) 1948169695Skan return NULL; 1949169695Skan if (d_peek_char (di) == 'Y') 1950169695Skan { 1951169695Skan /* Function has C linkage. We don't print this information. 1952169695Skan FIXME: We should print it in verbose mode. */ 1953169695Skan d_advance (di, 1); 1954169695Skan } 1955169695Skan ret = d_bare_function_type (di, 1); 1956258817Spfg if (! d_check_char (di, 'E')) 1957169695Skan return NULL; 1958169695Skan return ret; 1959169695Skan} 1960169695Skan 1961169695Skan/* <bare-function-type> ::= [J]<type>+ */ 1962169695Skan 1963169695Skanstatic struct demangle_component * 1964169695Skand_bare_function_type (struct d_info *di, int has_return_type) 1965169695Skan{ 1966169695Skan struct demangle_component *return_type; 1967169695Skan struct demangle_component *tl; 1968169695Skan struct demangle_component **ptl; 1969169695Skan char peek; 1970169695Skan 1971169695Skan /* Detect special qualifier indicating that the first argument 1972169695Skan is the return type. */ 1973169695Skan peek = d_peek_char (di); 1974169695Skan if (peek == 'J') 1975169695Skan { 1976169695Skan d_advance (di, 1); 1977169695Skan has_return_type = 1; 1978169695Skan } 1979169695Skan 1980169695Skan return_type = NULL; 1981169695Skan tl = NULL; 1982169695Skan ptl = &tl; 1983169695Skan while (1) 1984169695Skan { 1985169695Skan struct demangle_component *type; 1986169695Skan 1987169695Skan peek = d_peek_char (di); 1988169695Skan if (peek == '\0' || peek == 'E') 1989169695Skan break; 1990169695Skan type = cplus_demangle_type (di); 1991169695Skan if (type == NULL) 1992169695Skan return NULL; 1993169695Skan if (has_return_type) 1994169695Skan { 1995169695Skan return_type = type; 1996169695Skan has_return_type = 0; 1997169695Skan } 1998169695Skan else 1999169695Skan { 2000169695Skan *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL); 2001169695Skan if (*ptl == NULL) 2002169695Skan return NULL; 2003169695Skan ptl = &d_right (*ptl); 2004169695Skan } 2005169695Skan } 2006169695Skan 2007169695Skan /* There should be at least one parameter type besides the optional 2008169695Skan return type. A function which takes no arguments will have a 2009169695Skan single parameter type void. */ 2010169695Skan if (tl == NULL) 2011169695Skan return NULL; 2012169695Skan 2013169695Skan /* If we have a single parameter type void, omit it. */ 2014169695Skan if (d_right (tl) == NULL 2015169695Skan && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 2016169695Skan && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID) 2017169695Skan { 2018169695Skan di->expansion -= d_left (tl)->u.s_builtin.type->len; 2019169695Skan tl = NULL; 2020169695Skan } 2021169695Skan 2022169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl); 2023169695Skan} 2024169695Skan 2025169695Skan/* <class-enum-type> ::= <name> */ 2026169695Skan 2027169695Skanstatic struct demangle_component * 2028169695Skand_class_enum_type (struct d_info *di) 2029169695Skan{ 2030169695Skan return d_name (di); 2031169695Skan} 2032169695Skan 2033169695Skan/* <array-type> ::= A <(positive dimension) number> _ <(element) type> 2034169695Skan ::= A [<(dimension) expression>] _ <(element) type> 2035169695Skan*/ 2036169695Skan 2037169695Skanstatic struct demangle_component * 2038169695Skand_array_type (struct d_info *di) 2039169695Skan{ 2040169695Skan char peek; 2041169695Skan struct demangle_component *dim; 2042169695Skan 2043258817Spfg if (! d_check_char (di, 'A')) 2044169695Skan return NULL; 2045169695Skan 2046169695Skan peek = d_peek_char (di); 2047169695Skan if (peek == '_') 2048169695Skan dim = NULL; 2049169695Skan else if (IS_DIGIT (peek)) 2050169695Skan { 2051169695Skan const char *s; 2052169695Skan 2053169695Skan s = d_str (di); 2054169695Skan do 2055169695Skan { 2056169695Skan d_advance (di, 1); 2057169695Skan peek = d_peek_char (di); 2058169695Skan } 2059169695Skan while (IS_DIGIT (peek)); 2060169695Skan dim = d_make_name (di, s, d_str (di) - s); 2061169695Skan if (dim == NULL) 2062169695Skan return NULL; 2063169695Skan } 2064169695Skan else 2065169695Skan { 2066169695Skan dim = d_expression (di); 2067169695Skan if (dim == NULL) 2068169695Skan return NULL; 2069169695Skan } 2070169695Skan 2071258817Spfg if (! d_check_char (di, '_')) 2072169695Skan return NULL; 2073169695Skan 2074169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim, 2075169695Skan cplus_demangle_type (di)); 2076169695Skan} 2077169695Skan 2078169695Skan/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */ 2079169695Skan 2080169695Skanstatic struct demangle_component * 2081169695Skand_pointer_to_member_type (struct d_info *di) 2082169695Skan{ 2083169695Skan struct demangle_component *cl; 2084169695Skan struct demangle_component *mem; 2085169695Skan struct demangle_component **pmem; 2086169695Skan 2087258817Spfg if (! d_check_char (di, 'M')) 2088169695Skan return NULL; 2089169695Skan 2090169695Skan cl = cplus_demangle_type (di); 2091169695Skan 2092169695Skan /* The ABI specifies that any type can be a substitution source, and 2093169695Skan that M is followed by two types, and that when a CV-qualified 2094169695Skan type is seen both the base type and the CV-qualified types are 2095169695Skan substitution sources. The ABI also specifies that for a pointer 2096169695Skan to a CV-qualified member function, the qualifiers are attached to 2097169695Skan the second type. Given the grammar, a plain reading of the ABI 2098169695Skan suggests that both the CV-qualified member function and the 2099169695Skan non-qualified member function are substitution sources. However, 2100169695Skan g++ does not work that way. g++ treats only the CV-qualified 2101169695Skan member function as a substitution source. FIXME. So to work 2102169695Skan with g++, we need to pull off the CV-qualifiers here, in order to 2103169695Skan avoid calling add_substitution() in cplus_demangle_type(). But 2104169695Skan for a CV-qualified member which is not a function, g++ does 2105169695Skan follow the ABI, so we need to handle that case here by calling 2106169695Skan d_add_substitution ourselves. */ 2107169695Skan 2108169695Skan pmem = d_cv_qualifiers (di, &mem, 1); 2109169695Skan if (pmem == NULL) 2110169695Skan return NULL; 2111169695Skan *pmem = cplus_demangle_type (di); 2112258817Spfg if (*pmem == NULL) 2113258817Spfg return NULL; 2114169695Skan 2115169695Skan if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) 2116169695Skan { 2117169695Skan if (! d_add_substitution (di, mem)) 2118169695Skan return NULL; 2119169695Skan } 2120169695Skan 2121169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem); 2122169695Skan} 2123169695Skan 2124169695Skan/* <template-param> ::= T_ 2125169695Skan ::= T <(parameter-2 non-negative) number> _ 2126169695Skan*/ 2127169695Skan 2128169695Skanstatic struct demangle_component * 2129169695Skand_template_param (struct d_info *di) 2130169695Skan{ 2131169695Skan long param; 2132169695Skan 2133258817Spfg if (! d_check_char (di, 'T')) 2134169695Skan return NULL; 2135169695Skan 2136169695Skan if (d_peek_char (di) == '_') 2137169695Skan param = 0; 2138169695Skan else 2139169695Skan { 2140169695Skan param = d_number (di); 2141169695Skan if (param < 0) 2142169695Skan return NULL; 2143169695Skan param += 1; 2144169695Skan } 2145169695Skan 2146258817Spfg if (! d_check_char (di, '_')) 2147169695Skan return NULL; 2148169695Skan 2149169695Skan ++di->did_subs; 2150169695Skan 2151169695Skan return d_make_template_param (di, param); 2152169695Skan} 2153169695Skan 2154169695Skan/* <template-args> ::= I <template-arg>+ E */ 2155169695Skan 2156169695Skanstatic struct demangle_component * 2157169695Skand_template_args (struct d_info *di) 2158169695Skan{ 2159169695Skan struct demangle_component *hold_last_name; 2160169695Skan struct demangle_component *al; 2161169695Skan struct demangle_component **pal; 2162169695Skan 2163169695Skan /* Preserve the last name we saw--don't let the template arguments 2164169695Skan clobber it, as that would give us the wrong name for a subsequent 2165169695Skan constructor or destructor. */ 2166169695Skan hold_last_name = di->last_name; 2167169695Skan 2168258817Spfg if (! d_check_char (di, 'I')) 2169169695Skan return NULL; 2170169695Skan 2171169695Skan al = NULL; 2172169695Skan pal = &al; 2173169695Skan while (1) 2174169695Skan { 2175169695Skan struct demangle_component *a; 2176169695Skan 2177169695Skan a = d_template_arg (di); 2178169695Skan if (a == NULL) 2179169695Skan return NULL; 2180169695Skan 2181169695Skan *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL); 2182169695Skan if (*pal == NULL) 2183169695Skan return NULL; 2184169695Skan pal = &d_right (*pal); 2185169695Skan 2186169695Skan if (d_peek_char (di) == 'E') 2187169695Skan { 2188169695Skan d_advance (di, 1); 2189169695Skan break; 2190169695Skan } 2191169695Skan } 2192169695Skan 2193169695Skan di->last_name = hold_last_name; 2194169695Skan 2195169695Skan return al; 2196169695Skan} 2197169695Skan 2198169695Skan/* <template-arg> ::= <type> 2199169695Skan ::= X <expression> E 2200169695Skan ::= <expr-primary> 2201169695Skan*/ 2202169695Skan 2203169695Skanstatic struct demangle_component * 2204169695Skand_template_arg (struct d_info *di) 2205169695Skan{ 2206169695Skan struct demangle_component *ret; 2207169695Skan 2208169695Skan switch (d_peek_char (di)) 2209169695Skan { 2210169695Skan case 'X': 2211169695Skan d_advance (di, 1); 2212169695Skan ret = d_expression (di); 2213258817Spfg if (! d_check_char (di, 'E')) 2214169695Skan return NULL; 2215169695Skan return ret; 2216169695Skan 2217169695Skan case 'L': 2218169695Skan return d_expr_primary (di); 2219169695Skan 2220169695Skan default: 2221169695Skan return cplus_demangle_type (di); 2222169695Skan } 2223169695Skan} 2224169695Skan 2225169695Skan/* <expression> ::= <(unary) operator-name> <expression> 2226169695Skan ::= <(binary) operator-name> <expression> <expression> 2227169695Skan ::= <(trinary) operator-name> <expression> <expression> <expression> 2228169695Skan ::= st <type> 2229169695Skan ::= <template-param> 2230169695Skan ::= sr <type> <unqualified-name> 2231169695Skan ::= sr <type> <unqualified-name> <template-args> 2232169695Skan ::= <expr-primary> 2233169695Skan*/ 2234169695Skan 2235169695Skanstatic struct demangle_component * 2236169695Skand_expression (struct d_info *di) 2237169695Skan{ 2238169695Skan char peek; 2239169695Skan 2240169695Skan peek = d_peek_char (di); 2241169695Skan if (peek == 'L') 2242169695Skan return d_expr_primary (di); 2243169695Skan else if (peek == 'T') 2244169695Skan return d_template_param (di); 2245169695Skan else if (peek == 's' && d_peek_next_char (di) == 'r') 2246169695Skan { 2247169695Skan struct demangle_component *type; 2248169695Skan struct demangle_component *name; 2249169695Skan 2250169695Skan d_advance (di, 2); 2251169695Skan type = cplus_demangle_type (di); 2252169695Skan name = d_unqualified_name (di); 2253169695Skan if (d_peek_char (di) != 'I') 2254169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name); 2255169695Skan else 2256169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, 2257169695Skan d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name, 2258169695Skan d_template_args (di))); 2259169695Skan } 2260169695Skan else 2261169695Skan { 2262169695Skan struct demangle_component *op; 2263169695Skan int args; 2264169695Skan 2265169695Skan op = d_operator_name (di); 2266169695Skan if (op == NULL) 2267169695Skan return NULL; 2268169695Skan 2269169695Skan if (op->type == DEMANGLE_COMPONENT_OPERATOR) 2270169695Skan di->expansion += op->u.s_operator.op->len - 2; 2271169695Skan 2272169695Skan if (op->type == DEMANGLE_COMPONENT_OPERATOR 2273169695Skan && strcmp (op->u.s_operator.op->code, "st") == 0) 2274169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, 2275169695Skan cplus_demangle_type (di)); 2276169695Skan 2277169695Skan switch (op->type) 2278169695Skan { 2279169695Skan default: 2280169695Skan return NULL; 2281169695Skan case DEMANGLE_COMPONENT_OPERATOR: 2282169695Skan args = op->u.s_operator.op->args; 2283169695Skan break; 2284169695Skan case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 2285169695Skan args = op->u.s_extended_operator.args; 2286169695Skan break; 2287169695Skan case DEMANGLE_COMPONENT_CAST: 2288169695Skan args = 1; 2289169695Skan break; 2290169695Skan } 2291169695Skan 2292169695Skan switch (args) 2293169695Skan { 2294169695Skan case 1: 2295169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, 2296169695Skan d_expression (di)); 2297169695Skan case 2: 2298169695Skan { 2299169695Skan struct demangle_component *left; 2300169695Skan 2301169695Skan left = d_expression (di); 2302169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op, 2303169695Skan d_make_comp (di, 2304169695Skan DEMANGLE_COMPONENT_BINARY_ARGS, 2305169695Skan left, 2306169695Skan d_expression (di))); 2307169695Skan } 2308169695Skan case 3: 2309169695Skan { 2310169695Skan struct demangle_component *first; 2311169695Skan struct demangle_component *second; 2312169695Skan 2313169695Skan first = d_expression (di); 2314169695Skan second = d_expression (di); 2315169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op, 2316169695Skan d_make_comp (di, 2317169695Skan DEMANGLE_COMPONENT_TRINARY_ARG1, 2318169695Skan first, 2319169695Skan d_make_comp (di, 2320169695Skan DEMANGLE_COMPONENT_TRINARY_ARG2, 2321169695Skan second, 2322169695Skan d_expression (di)))); 2323169695Skan } 2324169695Skan default: 2325169695Skan return NULL; 2326169695Skan } 2327169695Skan } 2328169695Skan} 2329169695Skan 2330169695Skan/* <expr-primary> ::= L <type> <(value) number> E 2331169695Skan ::= L <type> <(value) float> E 2332169695Skan ::= L <mangled-name> E 2333169695Skan*/ 2334169695Skan 2335169695Skanstatic struct demangle_component * 2336169695Skand_expr_primary (struct d_info *di) 2337169695Skan{ 2338169695Skan struct demangle_component *ret; 2339169695Skan 2340258817Spfg if (! d_check_char (di, 'L')) 2341169695Skan return NULL; 2342169695Skan if (d_peek_char (di) == '_') 2343169695Skan ret = cplus_demangle_mangled_name (di, 0); 2344169695Skan else 2345169695Skan { 2346169695Skan struct demangle_component *type; 2347169695Skan enum demangle_component_type t; 2348169695Skan const char *s; 2349169695Skan 2350169695Skan type = cplus_demangle_type (di); 2351169695Skan if (type == NULL) 2352169695Skan return NULL; 2353169695Skan 2354169695Skan /* If we have a type we know how to print, we aren't going to 2355169695Skan print the type name itself. */ 2356169695Skan if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE 2357169695Skan && type->u.s_builtin.type->print != D_PRINT_DEFAULT) 2358169695Skan di->expansion -= type->u.s_builtin.type->len; 2359169695Skan 2360169695Skan /* Rather than try to interpret the literal value, we just 2361169695Skan collect it as a string. Note that it's possible to have a 2362169695Skan floating point literal here. The ABI specifies that the 2363169695Skan format of such literals is machine independent. That's fine, 2364169695Skan but what's not fine is that versions of g++ up to 3.2 with 2365169695Skan -fabi-version=1 used upper case letters in the hex constant, 2366169695Skan and dumped out gcc's internal representation. That makes it 2367169695Skan hard to tell where the constant ends, and hard to dump the 2368169695Skan constant in any readable form anyhow. We don't attempt to 2369169695Skan handle these cases. */ 2370169695Skan 2371169695Skan t = DEMANGLE_COMPONENT_LITERAL; 2372169695Skan if (d_peek_char (di) == 'n') 2373169695Skan { 2374169695Skan t = DEMANGLE_COMPONENT_LITERAL_NEG; 2375169695Skan d_advance (di, 1); 2376169695Skan } 2377169695Skan s = d_str (di); 2378169695Skan while (d_peek_char (di) != 'E') 2379169695Skan { 2380169695Skan if (d_peek_char (di) == '\0') 2381169695Skan return NULL; 2382169695Skan d_advance (di, 1); 2383169695Skan } 2384169695Skan ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s)); 2385169695Skan } 2386258817Spfg if (! d_check_char (di, 'E')) 2387169695Skan return NULL; 2388169695Skan return ret; 2389169695Skan} 2390169695Skan 2391169695Skan/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>] 2392169695Skan ::= Z <(function) encoding> E s [<discriminator>] 2393169695Skan*/ 2394169695Skan 2395169695Skanstatic struct demangle_component * 2396169695Skand_local_name (struct d_info *di) 2397169695Skan{ 2398169695Skan struct demangle_component *function; 2399169695Skan 2400258817Spfg if (! d_check_char (di, 'Z')) 2401169695Skan return NULL; 2402169695Skan 2403169695Skan function = d_encoding (di, 0); 2404169695Skan 2405258817Spfg if (! d_check_char (di, 'E')) 2406169695Skan return NULL; 2407169695Skan 2408169695Skan if (d_peek_char (di) == 's') 2409169695Skan { 2410169695Skan d_advance (di, 1); 2411169695Skan if (! d_discriminator (di)) 2412169695Skan return NULL; 2413169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, 2414169695Skan d_make_name (di, "string literal", 2415169695Skan sizeof "string literal" - 1)); 2416169695Skan } 2417169695Skan else 2418169695Skan { 2419169695Skan struct demangle_component *name; 2420169695Skan 2421169695Skan name = d_name (di); 2422169695Skan if (! d_discriminator (di)) 2423169695Skan return NULL; 2424169695Skan return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name); 2425169695Skan } 2426169695Skan} 2427169695Skan 2428169695Skan/* <discriminator> ::= _ <(non-negative) number> 2429169695Skan 2430169695Skan We demangle the discriminator, but we don't print it out. FIXME: 2431169695Skan We should print it out in verbose mode. */ 2432169695Skan 2433169695Skanstatic int 2434169695Skand_discriminator (struct d_info *di) 2435169695Skan{ 2436169695Skan long discrim; 2437169695Skan 2438169695Skan if (d_peek_char (di) != '_') 2439169695Skan return 1; 2440169695Skan d_advance (di, 1); 2441169695Skan discrim = d_number (di); 2442169695Skan if (discrim < 0) 2443169695Skan return 0; 2444169695Skan return 1; 2445169695Skan} 2446169695Skan 2447169695Skan/* Add a new substitution. */ 2448169695Skan 2449169695Skanstatic int 2450169695Skand_add_substitution (struct d_info *di, struct demangle_component *dc) 2451169695Skan{ 2452169695Skan if (dc == NULL) 2453169695Skan return 0; 2454169695Skan if (di->next_sub >= di->num_subs) 2455169695Skan return 0; 2456169695Skan di->subs[di->next_sub] = dc; 2457169695Skan ++di->next_sub; 2458169695Skan return 1; 2459169695Skan} 2460169695Skan 2461169695Skan/* <substitution> ::= S <seq-id> _ 2462169695Skan ::= S_ 2463169695Skan ::= St 2464169695Skan ::= Sa 2465169695Skan ::= Sb 2466169695Skan ::= Ss 2467169695Skan ::= Si 2468169695Skan ::= So 2469169695Skan ::= Sd 2470169695Skan 2471169695Skan If PREFIX is non-zero, then this type is being used as a prefix in 2472169695Skan a qualified name. In this case, for the standard substitutions, we 2473169695Skan need to check whether we are being used as a prefix for a 2474169695Skan constructor or destructor, and return a full template name. 2475169695Skan Otherwise we will get something like std::iostream::~iostream() 2476169695Skan which does not correspond particularly well to any function which 2477169695Skan actually appears in the source. 2478169695Skan*/ 2479169695Skan 2480169695Skanstatic const struct d_standard_sub_info standard_subs[] = 2481169695Skan{ 2482169695Skan { 't', NL ("std"), 2483169695Skan NL ("std"), 2484169695Skan NULL, 0 }, 2485169695Skan { 'a', NL ("std::allocator"), 2486169695Skan NL ("std::allocator"), 2487169695Skan NL ("allocator") }, 2488169695Skan { 'b', NL ("std::basic_string"), 2489169695Skan NL ("std::basic_string"), 2490169695Skan NL ("basic_string") }, 2491169695Skan { 's', NL ("std::string"), 2492169695Skan NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), 2493169695Skan NL ("basic_string") }, 2494169695Skan { 'i', NL ("std::istream"), 2495169695Skan NL ("std::basic_istream<char, std::char_traits<char> >"), 2496169695Skan NL ("basic_istream") }, 2497169695Skan { 'o', NL ("std::ostream"), 2498169695Skan NL ("std::basic_ostream<char, std::char_traits<char> >"), 2499169695Skan NL ("basic_ostream") }, 2500169695Skan { 'd', NL ("std::iostream"), 2501169695Skan NL ("std::basic_iostream<char, std::char_traits<char> >"), 2502169695Skan NL ("basic_iostream") } 2503169695Skan}; 2504169695Skan 2505169695Skanstatic struct demangle_component * 2506169695Skand_substitution (struct d_info *di, int prefix) 2507169695Skan{ 2508169695Skan char c; 2509169695Skan 2510258817Spfg if (! d_check_char (di, 'S')) 2511169695Skan return NULL; 2512169695Skan 2513169695Skan c = d_next_char (di); 2514169695Skan if (c == '_' || IS_DIGIT (c) || IS_UPPER (c)) 2515169695Skan { 2516169695Skan int id; 2517169695Skan 2518169695Skan id = 0; 2519169695Skan if (c != '_') 2520169695Skan { 2521169695Skan do 2522169695Skan { 2523169695Skan if (IS_DIGIT (c)) 2524169695Skan id = id * 36 + c - '0'; 2525169695Skan else if (IS_UPPER (c)) 2526169695Skan id = id * 36 + c - 'A' + 10; 2527169695Skan else 2528169695Skan return NULL; 2529169695Skan if (id < 0) 2530169695Skan return NULL; 2531169695Skan c = d_next_char (di); 2532169695Skan } 2533169695Skan while (c != '_'); 2534169695Skan 2535169695Skan ++id; 2536169695Skan } 2537169695Skan 2538169695Skan if (id >= di->next_sub) 2539169695Skan return NULL; 2540169695Skan 2541169695Skan ++di->did_subs; 2542169695Skan 2543169695Skan return di->subs[id]; 2544169695Skan } 2545169695Skan else 2546169695Skan { 2547169695Skan int verbose; 2548169695Skan const struct d_standard_sub_info *p; 2549169695Skan const struct d_standard_sub_info *pend; 2550169695Skan 2551169695Skan verbose = (di->options & DMGL_VERBOSE) != 0; 2552169695Skan if (! verbose && prefix) 2553169695Skan { 2554169695Skan char peek; 2555169695Skan 2556169695Skan peek = d_peek_char (di); 2557169695Skan if (peek == 'C' || peek == 'D') 2558169695Skan verbose = 1; 2559169695Skan } 2560169695Skan 2561169695Skan pend = (&standard_subs[0] 2562169695Skan + sizeof standard_subs / sizeof standard_subs[0]); 2563169695Skan for (p = &standard_subs[0]; p < pend; ++p) 2564169695Skan { 2565169695Skan if (c == p->code) 2566169695Skan { 2567169695Skan const char *s; 2568169695Skan int len; 2569169695Skan 2570169695Skan if (p->set_last_name != NULL) 2571169695Skan di->last_name = d_make_sub (di, p->set_last_name, 2572169695Skan p->set_last_name_len); 2573169695Skan if (verbose) 2574169695Skan { 2575169695Skan s = p->full_expansion; 2576169695Skan len = p->full_len; 2577169695Skan } 2578169695Skan else 2579169695Skan { 2580169695Skan s = p->simple_expansion; 2581169695Skan len = p->simple_len; 2582169695Skan } 2583169695Skan di->expansion += len; 2584169695Skan return d_make_sub (di, s, len); 2585169695Skan } 2586169695Skan } 2587169695Skan 2588169695Skan return NULL; 2589169695Skan } 2590169695Skan} 2591169695Skan 2592169695Skan/* Resize the print buffer. */ 2593169695Skan 2594169695Skanstatic void 2595169695Skand_print_resize (struct d_print_info *dpi, size_t add) 2596169695Skan{ 2597169695Skan size_t need; 2598169695Skan 2599169695Skan if (dpi->buf == NULL) 2600169695Skan return; 2601169695Skan need = dpi->len + add; 2602169695Skan while (need > dpi->alc) 2603169695Skan { 2604169695Skan size_t newalc; 2605169695Skan char *newbuf; 2606169695Skan 2607169695Skan newalc = dpi->alc * 2; 2608169695Skan newbuf = (char *) realloc (dpi->buf, newalc); 2609169695Skan if (newbuf == NULL) 2610169695Skan { 2611169695Skan free (dpi->buf); 2612169695Skan dpi->buf = NULL; 2613169695Skan dpi->allocation_failure = 1; 2614169695Skan return; 2615169695Skan } 2616169695Skan dpi->buf = newbuf; 2617169695Skan dpi->alc = newalc; 2618169695Skan } 2619169695Skan} 2620169695Skan 2621169695Skan/* Append a character to the print buffer. */ 2622169695Skan 2623169695Skanstatic void 2624169695Skand_print_append_char (struct d_print_info *dpi, int c) 2625169695Skan{ 2626169695Skan if (dpi->buf != NULL) 2627169695Skan { 2628169695Skan if (dpi->len >= dpi->alc) 2629169695Skan { 2630169695Skan d_print_resize (dpi, 1); 2631169695Skan if (dpi->buf == NULL) 2632169695Skan return; 2633169695Skan } 2634169695Skan 2635169695Skan dpi->buf[dpi->len] = c; 2636169695Skan ++dpi->len; 2637169695Skan } 2638169695Skan} 2639169695Skan 2640169695Skan/* Append a buffer to the print buffer. */ 2641169695Skan 2642169695Skanstatic void 2643169695Skand_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l) 2644169695Skan{ 2645169695Skan if (dpi->buf != NULL) 2646169695Skan { 2647169695Skan if (dpi->len + l > dpi->alc) 2648169695Skan { 2649169695Skan d_print_resize (dpi, l); 2650169695Skan if (dpi->buf == NULL) 2651169695Skan return; 2652169695Skan } 2653169695Skan 2654169695Skan memcpy (dpi->buf + dpi->len, s, l); 2655169695Skan dpi->len += l; 2656169695Skan } 2657169695Skan} 2658169695Skan 2659169695Skan/* Indicate that an error occurred during printing. */ 2660169695Skan 2661169695Skanstatic void 2662169695Skand_print_error (struct d_print_info *dpi) 2663169695Skan{ 2664169695Skan free (dpi->buf); 2665169695Skan dpi->buf = NULL; 2666169695Skan} 2667169695Skan 2668169695Skan/* Turn components into a human readable string. OPTIONS is the 2669169695Skan options bits passed to the demangler. DC is the tree to print. 2670169695Skan ESTIMATE is a guess at the length of the result. This returns a 2671169695Skan string allocated by malloc, or NULL on error. On success, this 2672169695Skan sets *PALC to the size of the allocated buffer. On failure, this 2673169695Skan sets *PALC to 0 for a bad parse, or to 1 for a memory allocation 2674169695Skan failure. */ 2675169695Skan 2676169695SkanCP_STATIC_IF_GLIBCPP_V3 2677169695Skanchar * 2678169695Skancplus_demangle_print (int options, const struct demangle_component *dc, 2679169695Skan int estimate, size_t *palc) 2680169695Skan{ 2681169695Skan struct d_print_info dpi; 2682169695Skan 2683169695Skan dpi.options = options; 2684169695Skan 2685169695Skan dpi.alc = estimate + 1; 2686169695Skan dpi.buf = (char *) malloc (dpi.alc); 2687169695Skan if (dpi.buf == NULL) 2688169695Skan { 2689169695Skan *palc = 1; 2690169695Skan return NULL; 2691169695Skan } 2692169695Skan 2693169695Skan dpi.len = 0; 2694169695Skan dpi.templates = NULL; 2695169695Skan dpi.modifiers = NULL; 2696169695Skan 2697169695Skan dpi.allocation_failure = 0; 2698169695Skan 2699169695Skan d_print_comp (&dpi, dc); 2700169695Skan 2701169695Skan d_append_char (&dpi, '\0'); 2702169695Skan 2703169695Skan if (dpi.buf != NULL) 2704169695Skan *palc = dpi.alc; 2705169695Skan else 2706169695Skan *palc = dpi.allocation_failure; 2707169695Skan 2708169695Skan return dpi.buf; 2709169695Skan} 2710169695Skan 2711169695Skan/* Subroutine to handle components. */ 2712169695Skan 2713169695Skanstatic void 2714169695Skand_print_comp (struct d_print_info *dpi, 2715169695Skan const struct demangle_component *dc) 2716169695Skan{ 2717169695Skan if (dc == NULL) 2718169695Skan { 2719169695Skan d_print_error (dpi); 2720169695Skan return; 2721169695Skan } 2722169695Skan if (d_print_saw_error (dpi)) 2723169695Skan return; 2724169695Skan 2725169695Skan switch (dc->type) 2726169695Skan { 2727169695Skan case DEMANGLE_COMPONENT_NAME: 2728169695Skan if ((dpi->options & DMGL_JAVA) == 0) 2729169695Skan d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len); 2730169695Skan else 2731169695Skan d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len); 2732169695Skan return; 2733169695Skan 2734169695Skan case DEMANGLE_COMPONENT_QUAL_NAME: 2735169695Skan case DEMANGLE_COMPONENT_LOCAL_NAME: 2736169695Skan d_print_comp (dpi, d_left (dc)); 2737169695Skan if ((dpi->options & DMGL_JAVA) == 0) 2738169695Skan d_append_string_constant (dpi, "::"); 2739169695Skan else 2740169695Skan d_append_char (dpi, '.'); 2741169695Skan d_print_comp (dpi, d_right (dc)); 2742169695Skan return; 2743169695Skan 2744169695Skan case DEMANGLE_COMPONENT_TYPED_NAME: 2745169695Skan { 2746169695Skan struct d_print_mod *hold_modifiers; 2747169695Skan struct demangle_component *typed_name; 2748169695Skan struct d_print_mod adpm[4]; 2749169695Skan unsigned int i; 2750169695Skan struct d_print_template dpt; 2751169695Skan 2752169695Skan /* Pass the name down to the type so that it can be printed in 2753169695Skan the right place for the type. We also have to pass down 2754169695Skan any CV-qualifiers, which apply to the this parameter. */ 2755169695Skan hold_modifiers = dpi->modifiers; 2756169695Skan i = 0; 2757169695Skan typed_name = d_left (dc); 2758169695Skan while (typed_name != NULL) 2759169695Skan { 2760169695Skan if (i >= sizeof adpm / sizeof adpm[0]) 2761169695Skan { 2762169695Skan d_print_error (dpi); 2763169695Skan return; 2764169695Skan } 2765169695Skan 2766169695Skan adpm[i].next = dpi->modifiers; 2767169695Skan dpi->modifiers = &adpm[i]; 2768169695Skan adpm[i].mod = typed_name; 2769169695Skan adpm[i].printed = 0; 2770169695Skan adpm[i].templates = dpi->templates; 2771169695Skan ++i; 2772169695Skan 2773169695Skan if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS 2774169695Skan && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS 2775169695Skan && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS) 2776169695Skan break; 2777169695Skan 2778169695Skan typed_name = d_left (typed_name); 2779169695Skan } 2780169695Skan 2781169695Skan /* If typed_name is a template, then it applies to the 2782169695Skan function type as well. */ 2783169695Skan if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 2784169695Skan { 2785169695Skan dpt.next = dpi->templates; 2786169695Skan dpi->templates = &dpt; 2787169695Skan dpt.template_decl = typed_name; 2788169695Skan } 2789169695Skan 2790169695Skan /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then 2791169695Skan there may be CV-qualifiers on its right argument which 2792169695Skan really apply here; this happens when parsing a class which 2793169695Skan is local to a function. */ 2794169695Skan if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) 2795169695Skan { 2796169695Skan struct demangle_component *local_name; 2797169695Skan 2798169695Skan local_name = d_right (typed_name); 2799169695Skan while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS 2800169695Skan || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS 2801169695Skan || local_name->type == DEMANGLE_COMPONENT_CONST_THIS) 2802169695Skan { 2803169695Skan if (i >= sizeof adpm / sizeof adpm[0]) 2804169695Skan { 2805169695Skan d_print_error (dpi); 2806169695Skan return; 2807169695Skan } 2808169695Skan 2809169695Skan adpm[i] = adpm[i - 1]; 2810169695Skan adpm[i].next = &adpm[i - 1]; 2811169695Skan dpi->modifiers = &adpm[i]; 2812169695Skan 2813169695Skan adpm[i - 1].mod = local_name; 2814169695Skan adpm[i - 1].printed = 0; 2815169695Skan adpm[i - 1].templates = dpi->templates; 2816169695Skan ++i; 2817169695Skan 2818169695Skan local_name = d_left (local_name); 2819169695Skan } 2820169695Skan } 2821169695Skan 2822169695Skan d_print_comp (dpi, d_right (dc)); 2823169695Skan 2824169695Skan if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) 2825169695Skan dpi->templates = dpt.next; 2826169695Skan 2827169695Skan /* If the modifiers didn't get printed by the type, print them 2828169695Skan now. */ 2829169695Skan while (i > 0) 2830169695Skan { 2831169695Skan --i; 2832169695Skan if (! adpm[i].printed) 2833169695Skan { 2834169695Skan d_append_char (dpi, ' '); 2835169695Skan d_print_mod (dpi, adpm[i].mod); 2836169695Skan } 2837169695Skan } 2838169695Skan 2839169695Skan dpi->modifiers = hold_modifiers; 2840169695Skan 2841169695Skan return; 2842169695Skan } 2843169695Skan 2844169695Skan case DEMANGLE_COMPONENT_TEMPLATE: 2845169695Skan { 2846169695Skan struct d_print_mod *hold_dpm; 2847169695Skan 2848169695Skan /* Don't push modifiers into a template definition. Doing so 2849169695Skan could give the wrong definition for a template argument. 2850169695Skan Instead, treat the template essentially as a name. */ 2851169695Skan 2852169695Skan hold_dpm = dpi->modifiers; 2853169695Skan dpi->modifiers = NULL; 2854169695Skan 2855169695Skan d_print_comp (dpi, d_left (dc)); 2856169695Skan if (d_last_char (dpi) == '<') 2857169695Skan d_append_char (dpi, ' '); 2858169695Skan d_append_char (dpi, '<'); 2859169695Skan d_print_comp (dpi, d_right (dc)); 2860169695Skan /* Avoid generating two consecutive '>' characters, to avoid 2861169695Skan the C++ syntactic ambiguity. */ 2862169695Skan if (d_last_char (dpi) == '>') 2863169695Skan d_append_char (dpi, ' '); 2864169695Skan d_append_char (dpi, '>'); 2865169695Skan 2866169695Skan dpi->modifiers = hold_dpm; 2867169695Skan 2868169695Skan return; 2869169695Skan } 2870169695Skan 2871169695Skan case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 2872169695Skan { 2873169695Skan long i; 2874169695Skan struct demangle_component *a; 2875169695Skan struct d_print_template *hold_dpt; 2876169695Skan 2877169695Skan if (dpi->templates == NULL) 2878169695Skan { 2879169695Skan d_print_error (dpi); 2880169695Skan return; 2881169695Skan } 2882169695Skan i = dc->u.s_number.number; 2883169695Skan for (a = d_right (dpi->templates->template_decl); 2884169695Skan a != NULL; 2885169695Skan a = d_right (a)) 2886169695Skan { 2887169695Skan if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST) 2888169695Skan { 2889169695Skan d_print_error (dpi); 2890169695Skan return; 2891169695Skan } 2892169695Skan if (i <= 0) 2893169695Skan break; 2894169695Skan --i; 2895169695Skan } 2896169695Skan if (i != 0 || a == NULL) 2897169695Skan { 2898169695Skan d_print_error (dpi); 2899169695Skan return; 2900169695Skan } 2901169695Skan 2902169695Skan /* While processing this parameter, we need to pop the list of 2903169695Skan templates. This is because the template parameter may 2904169695Skan itself be a reference to a parameter of an outer 2905169695Skan template. */ 2906169695Skan 2907169695Skan hold_dpt = dpi->templates; 2908169695Skan dpi->templates = hold_dpt->next; 2909169695Skan 2910169695Skan d_print_comp (dpi, d_left (a)); 2911169695Skan 2912169695Skan dpi->templates = hold_dpt; 2913169695Skan 2914169695Skan return; 2915169695Skan } 2916169695Skan 2917169695Skan case DEMANGLE_COMPONENT_CTOR: 2918169695Skan d_print_comp (dpi, dc->u.s_ctor.name); 2919169695Skan return; 2920169695Skan 2921169695Skan case DEMANGLE_COMPONENT_DTOR: 2922169695Skan d_append_char (dpi, '~'); 2923169695Skan d_print_comp (dpi, dc->u.s_dtor.name); 2924169695Skan return; 2925169695Skan 2926169695Skan case DEMANGLE_COMPONENT_VTABLE: 2927169695Skan d_append_string_constant (dpi, "vtable for "); 2928169695Skan d_print_comp (dpi, d_left (dc)); 2929169695Skan return; 2930169695Skan 2931169695Skan case DEMANGLE_COMPONENT_VTT: 2932169695Skan d_append_string_constant (dpi, "VTT for "); 2933169695Skan d_print_comp (dpi, d_left (dc)); 2934169695Skan return; 2935169695Skan 2936169695Skan case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE: 2937169695Skan d_append_string_constant (dpi, "construction vtable for "); 2938169695Skan d_print_comp (dpi, d_left (dc)); 2939169695Skan d_append_string_constant (dpi, "-in-"); 2940169695Skan d_print_comp (dpi, d_right (dc)); 2941169695Skan return; 2942169695Skan 2943169695Skan case DEMANGLE_COMPONENT_TYPEINFO: 2944169695Skan d_append_string_constant (dpi, "typeinfo for "); 2945169695Skan d_print_comp (dpi, d_left (dc)); 2946169695Skan return; 2947169695Skan 2948169695Skan case DEMANGLE_COMPONENT_TYPEINFO_NAME: 2949169695Skan d_append_string_constant (dpi, "typeinfo name for "); 2950169695Skan d_print_comp (dpi, d_left (dc)); 2951169695Skan return; 2952169695Skan 2953169695Skan case DEMANGLE_COMPONENT_TYPEINFO_FN: 2954169695Skan d_append_string_constant (dpi, "typeinfo fn for "); 2955169695Skan d_print_comp (dpi, d_left (dc)); 2956169695Skan return; 2957169695Skan 2958169695Skan case DEMANGLE_COMPONENT_THUNK: 2959169695Skan d_append_string_constant (dpi, "non-virtual thunk to "); 2960169695Skan d_print_comp (dpi, d_left (dc)); 2961169695Skan return; 2962169695Skan 2963169695Skan case DEMANGLE_COMPONENT_VIRTUAL_THUNK: 2964169695Skan d_append_string_constant (dpi, "virtual thunk to "); 2965169695Skan d_print_comp (dpi, d_left (dc)); 2966169695Skan return; 2967169695Skan 2968169695Skan case DEMANGLE_COMPONENT_COVARIANT_THUNK: 2969169695Skan d_append_string_constant (dpi, "covariant return thunk to "); 2970169695Skan d_print_comp (dpi, d_left (dc)); 2971169695Skan return; 2972169695Skan 2973169695Skan case DEMANGLE_COMPONENT_JAVA_CLASS: 2974169695Skan d_append_string_constant (dpi, "java Class for "); 2975169695Skan d_print_comp (dpi, d_left (dc)); 2976169695Skan return; 2977169695Skan 2978169695Skan case DEMANGLE_COMPONENT_GUARD: 2979169695Skan d_append_string_constant (dpi, "guard variable for "); 2980169695Skan d_print_comp (dpi, d_left (dc)); 2981169695Skan return; 2982169695Skan 2983169695Skan case DEMANGLE_COMPONENT_REFTEMP: 2984169695Skan d_append_string_constant (dpi, "reference temporary for "); 2985169695Skan d_print_comp (dpi, d_left (dc)); 2986169695Skan return; 2987169695Skan 2988169695Skan case DEMANGLE_COMPONENT_HIDDEN_ALIAS: 2989169695Skan d_append_string_constant (dpi, "hidden alias for "); 2990169695Skan d_print_comp (dpi, d_left (dc)); 2991169695Skan return; 2992169695Skan 2993169695Skan case DEMANGLE_COMPONENT_SUB_STD: 2994169695Skan d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len); 2995169695Skan return; 2996169695Skan 2997169695Skan case DEMANGLE_COMPONENT_RESTRICT: 2998169695Skan case DEMANGLE_COMPONENT_VOLATILE: 2999169695Skan case DEMANGLE_COMPONENT_CONST: 3000169695Skan { 3001169695Skan struct d_print_mod *pdpm; 3002169695Skan 3003169695Skan /* When printing arrays, it's possible to have cases where the 3004169695Skan same CV-qualifier gets pushed on the stack multiple times. 3005169695Skan We only need to print it once. */ 3006169695Skan 3007169695Skan for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next) 3008169695Skan { 3009169695Skan if (! pdpm->printed) 3010169695Skan { 3011169695Skan if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT 3012169695Skan && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE 3013169695Skan && pdpm->mod->type != DEMANGLE_COMPONENT_CONST) 3014169695Skan break; 3015169695Skan if (pdpm->mod->type == dc->type) 3016169695Skan { 3017169695Skan d_print_comp (dpi, d_left (dc)); 3018169695Skan return; 3019169695Skan } 3020169695Skan } 3021169695Skan } 3022169695Skan } 3023169695Skan /* Fall through. */ 3024169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 3025169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 3026169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 3027169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 3028169695Skan case DEMANGLE_COMPONENT_POINTER: 3029169695Skan case DEMANGLE_COMPONENT_REFERENCE: 3030169695Skan case DEMANGLE_COMPONENT_COMPLEX: 3031169695Skan case DEMANGLE_COMPONENT_IMAGINARY: 3032169695Skan { 3033169695Skan /* We keep a list of modifiers on the stack. */ 3034169695Skan struct d_print_mod dpm; 3035169695Skan 3036169695Skan dpm.next = dpi->modifiers; 3037169695Skan dpi->modifiers = &dpm; 3038169695Skan dpm.mod = dc; 3039169695Skan dpm.printed = 0; 3040169695Skan dpm.templates = dpi->templates; 3041169695Skan 3042169695Skan d_print_comp (dpi, d_left (dc)); 3043169695Skan 3044169695Skan /* If the modifier didn't get printed by the type, print it 3045169695Skan now. */ 3046169695Skan if (! dpm.printed) 3047169695Skan d_print_mod (dpi, dc); 3048169695Skan 3049169695Skan dpi->modifiers = dpm.next; 3050169695Skan 3051169695Skan return; 3052169695Skan } 3053169695Skan 3054169695Skan case DEMANGLE_COMPONENT_BUILTIN_TYPE: 3055169695Skan if ((dpi->options & DMGL_JAVA) == 0) 3056169695Skan d_append_buffer (dpi, dc->u.s_builtin.type->name, 3057169695Skan dc->u.s_builtin.type->len); 3058169695Skan else 3059169695Skan d_append_buffer (dpi, dc->u.s_builtin.type->java_name, 3060169695Skan dc->u.s_builtin.type->java_len); 3061169695Skan return; 3062169695Skan 3063169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE: 3064169695Skan d_print_comp (dpi, d_left (dc)); 3065169695Skan return; 3066169695Skan 3067169695Skan case DEMANGLE_COMPONENT_FUNCTION_TYPE: 3068169695Skan { 3069169695Skan if ((dpi->options & DMGL_RET_POSTFIX) != 0) 3070169695Skan d_print_function_type (dpi, dc, dpi->modifiers); 3071169695Skan 3072169695Skan /* Print return type if present */ 3073169695Skan if (d_left (dc) != NULL) 3074169695Skan { 3075169695Skan struct d_print_mod dpm; 3076169695Skan 3077169695Skan /* We must pass this type down as a modifier in order to 3078169695Skan print it in the right location. */ 3079169695Skan dpm.next = dpi->modifiers; 3080169695Skan dpi->modifiers = &dpm; 3081169695Skan dpm.mod = dc; 3082169695Skan dpm.printed = 0; 3083169695Skan dpm.templates = dpi->templates; 3084169695Skan 3085169695Skan d_print_comp (dpi, d_left (dc)); 3086169695Skan 3087169695Skan dpi->modifiers = dpm.next; 3088169695Skan 3089169695Skan if (dpm.printed) 3090169695Skan return; 3091169695Skan 3092169695Skan /* In standard prefix notation, there is a space between the 3093169695Skan return type and the function signature. */ 3094169695Skan if ((dpi->options & DMGL_RET_POSTFIX) == 0) 3095169695Skan d_append_char (dpi, ' '); 3096169695Skan } 3097169695Skan 3098169695Skan if ((dpi->options & DMGL_RET_POSTFIX) == 0) 3099169695Skan d_print_function_type (dpi, dc, dpi->modifiers); 3100169695Skan 3101169695Skan return; 3102169695Skan } 3103169695Skan 3104169695Skan case DEMANGLE_COMPONENT_ARRAY_TYPE: 3105169695Skan { 3106169695Skan struct d_print_mod *hold_modifiers; 3107169695Skan struct d_print_mod adpm[4]; 3108169695Skan unsigned int i; 3109169695Skan struct d_print_mod *pdpm; 3110169695Skan 3111169695Skan /* We must pass this type down as a modifier in order to print 3112169695Skan multi-dimensional arrays correctly. If the array itself is 3113169695Skan CV-qualified, we act as though the element type were 3114169695Skan CV-qualified. We do this by copying the modifiers down 3115169695Skan rather than fiddling pointers, so that we don't wind up 3116169695Skan with a d_print_mod higher on the stack pointing into our 3117169695Skan stack frame after we return. */ 3118169695Skan 3119169695Skan hold_modifiers = dpi->modifiers; 3120169695Skan 3121169695Skan adpm[0].next = hold_modifiers; 3122169695Skan dpi->modifiers = &adpm[0]; 3123169695Skan adpm[0].mod = dc; 3124169695Skan adpm[0].printed = 0; 3125169695Skan adpm[0].templates = dpi->templates; 3126169695Skan 3127169695Skan i = 1; 3128169695Skan pdpm = hold_modifiers; 3129169695Skan while (pdpm != NULL 3130169695Skan && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT 3131169695Skan || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE 3132169695Skan || pdpm->mod->type == DEMANGLE_COMPONENT_CONST)) 3133169695Skan { 3134169695Skan if (! pdpm->printed) 3135169695Skan { 3136169695Skan if (i >= sizeof adpm / sizeof adpm[0]) 3137169695Skan { 3138169695Skan d_print_error (dpi); 3139169695Skan return; 3140169695Skan } 3141169695Skan 3142169695Skan adpm[i] = *pdpm; 3143169695Skan adpm[i].next = dpi->modifiers; 3144169695Skan dpi->modifiers = &adpm[i]; 3145169695Skan pdpm->printed = 1; 3146169695Skan ++i; 3147169695Skan } 3148169695Skan 3149169695Skan pdpm = pdpm->next; 3150169695Skan } 3151169695Skan 3152169695Skan d_print_comp (dpi, d_right (dc)); 3153169695Skan 3154169695Skan dpi->modifiers = hold_modifiers; 3155169695Skan 3156169695Skan if (adpm[0].printed) 3157169695Skan return; 3158169695Skan 3159169695Skan while (i > 1) 3160169695Skan { 3161169695Skan --i; 3162169695Skan d_print_mod (dpi, adpm[i].mod); 3163169695Skan } 3164169695Skan 3165169695Skan d_print_array_type (dpi, dc, dpi->modifiers); 3166169695Skan 3167169695Skan return; 3168169695Skan } 3169169695Skan 3170169695Skan case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3171169695Skan { 3172169695Skan struct d_print_mod dpm; 3173169695Skan 3174169695Skan dpm.next = dpi->modifiers; 3175169695Skan dpi->modifiers = &dpm; 3176169695Skan dpm.mod = dc; 3177169695Skan dpm.printed = 0; 3178169695Skan dpm.templates = dpi->templates; 3179169695Skan 3180169695Skan d_print_comp (dpi, d_right (dc)); 3181169695Skan 3182169695Skan /* If the modifier didn't get printed by the type, print it 3183169695Skan now. */ 3184169695Skan if (! dpm.printed) 3185169695Skan { 3186169695Skan d_append_char (dpi, ' '); 3187169695Skan d_print_comp (dpi, d_left (dc)); 3188169695Skan d_append_string_constant (dpi, "::*"); 3189169695Skan } 3190169695Skan 3191169695Skan dpi->modifiers = dpm.next; 3192169695Skan 3193169695Skan return; 3194169695Skan } 3195169695Skan 3196169695Skan case DEMANGLE_COMPONENT_ARGLIST: 3197169695Skan case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST: 3198169695Skan d_print_comp (dpi, d_left (dc)); 3199169695Skan if (d_right (dc) != NULL) 3200169695Skan { 3201169695Skan d_append_string_constant (dpi, ", "); 3202169695Skan d_print_comp (dpi, d_right (dc)); 3203169695Skan } 3204169695Skan return; 3205169695Skan 3206169695Skan case DEMANGLE_COMPONENT_OPERATOR: 3207169695Skan { 3208169695Skan char c; 3209169695Skan 3210169695Skan d_append_string_constant (dpi, "operator"); 3211169695Skan c = dc->u.s_operator.op->name[0]; 3212169695Skan if (IS_LOWER (c)) 3213169695Skan d_append_char (dpi, ' '); 3214169695Skan d_append_buffer (dpi, dc->u.s_operator.op->name, 3215169695Skan dc->u.s_operator.op->len); 3216169695Skan return; 3217169695Skan } 3218169695Skan 3219169695Skan case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: 3220169695Skan d_append_string_constant (dpi, "operator "); 3221169695Skan d_print_comp (dpi, dc->u.s_extended_operator.name); 3222169695Skan return; 3223169695Skan 3224169695Skan case DEMANGLE_COMPONENT_CAST: 3225169695Skan d_append_string_constant (dpi, "operator "); 3226169695Skan d_print_cast (dpi, dc); 3227169695Skan return; 3228169695Skan 3229169695Skan case DEMANGLE_COMPONENT_UNARY: 3230169695Skan if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST) 3231169695Skan d_print_expr_op (dpi, d_left (dc)); 3232169695Skan else 3233169695Skan { 3234169695Skan d_append_char (dpi, '('); 3235169695Skan d_print_cast (dpi, d_left (dc)); 3236169695Skan d_append_char (dpi, ')'); 3237169695Skan } 3238169695Skan d_append_char (dpi, '('); 3239169695Skan d_print_comp (dpi, d_right (dc)); 3240169695Skan d_append_char (dpi, ')'); 3241169695Skan return; 3242169695Skan 3243169695Skan case DEMANGLE_COMPONENT_BINARY: 3244169695Skan if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) 3245169695Skan { 3246169695Skan d_print_error (dpi); 3247169695Skan return; 3248169695Skan } 3249169695Skan 3250169695Skan /* We wrap an expression which uses the greater-than operator in 3251169695Skan an extra layer of parens so that it does not get confused 3252169695Skan with the '>' which ends the template parameters. */ 3253169695Skan if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 3254169695Skan && d_left (dc)->u.s_operator.op->len == 1 3255169695Skan && d_left (dc)->u.s_operator.op->name[0] == '>') 3256169695Skan d_append_char (dpi, '('); 3257169695Skan 3258169695Skan d_append_char (dpi, '('); 3259169695Skan d_print_comp (dpi, d_left (d_right (dc))); 3260169695Skan d_append_string_constant (dpi, ") "); 3261169695Skan d_print_expr_op (dpi, d_left (dc)); 3262169695Skan d_append_string_constant (dpi, " ("); 3263169695Skan d_print_comp (dpi, d_right (d_right (dc))); 3264169695Skan d_append_char (dpi, ')'); 3265169695Skan 3266169695Skan if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR 3267169695Skan && d_left (dc)->u.s_operator.op->len == 1 3268169695Skan && d_left (dc)->u.s_operator.op->name[0] == '>') 3269169695Skan d_append_char (dpi, ')'); 3270169695Skan 3271169695Skan return; 3272169695Skan 3273169695Skan case DEMANGLE_COMPONENT_BINARY_ARGS: 3274169695Skan /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */ 3275169695Skan d_print_error (dpi); 3276169695Skan return; 3277169695Skan 3278169695Skan case DEMANGLE_COMPONENT_TRINARY: 3279169695Skan if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 3280169695Skan || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) 3281169695Skan { 3282169695Skan d_print_error (dpi); 3283169695Skan return; 3284169695Skan } 3285169695Skan d_append_char (dpi, '('); 3286169695Skan d_print_comp (dpi, d_left (d_right (dc))); 3287169695Skan d_append_string_constant (dpi, ") "); 3288169695Skan d_print_expr_op (dpi, d_left (dc)); 3289169695Skan d_append_string_constant (dpi, " ("); 3290169695Skan d_print_comp (dpi, d_left (d_right (d_right (dc)))); 3291169695Skan d_append_string_constant (dpi, ") : ("); 3292169695Skan d_print_comp (dpi, d_right (d_right (d_right (dc)))); 3293169695Skan d_append_char (dpi, ')'); 3294169695Skan return; 3295169695Skan 3296169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG1: 3297169695Skan case DEMANGLE_COMPONENT_TRINARY_ARG2: 3298169695Skan /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */ 3299169695Skan d_print_error (dpi); 3300169695Skan return; 3301169695Skan 3302169695Skan case DEMANGLE_COMPONENT_LITERAL: 3303169695Skan case DEMANGLE_COMPONENT_LITERAL_NEG: 3304169695Skan { 3305169695Skan enum d_builtin_type_print tp; 3306169695Skan 3307169695Skan /* For some builtin types, produce simpler output. */ 3308169695Skan tp = D_PRINT_DEFAULT; 3309169695Skan if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) 3310169695Skan { 3311169695Skan tp = d_left (dc)->u.s_builtin.type->print; 3312169695Skan switch (tp) 3313169695Skan { 3314169695Skan case D_PRINT_INT: 3315169695Skan case D_PRINT_UNSIGNED: 3316169695Skan case D_PRINT_LONG: 3317169695Skan case D_PRINT_UNSIGNED_LONG: 3318169695Skan case D_PRINT_LONG_LONG: 3319169695Skan case D_PRINT_UNSIGNED_LONG_LONG: 3320169695Skan if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME) 3321169695Skan { 3322169695Skan if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 3323169695Skan d_append_char (dpi, '-'); 3324169695Skan d_print_comp (dpi, d_right (dc)); 3325169695Skan switch (tp) 3326169695Skan { 3327169695Skan default: 3328169695Skan break; 3329169695Skan case D_PRINT_UNSIGNED: 3330169695Skan d_append_char (dpi, 'u'); 3331169695Skan break; 3332169695Skan case D_PRINT_LONG: 3333169695Skan d_append_char (dpi, 'l'); 3334169695Skan break; 3335169695Skan case D_PRINT_UNSIGNED_LONG: 3336169695Skan d_append_string_constant (dpi, "ul"); 3337169695Skan break; 3338169695Skan case D_PRINT_LONG_LONG: 3339169695Skan d_append_string_constant (dpi, "ll"); 3340169695Skan break; 3341169695Skan case D_PRINT_UNSIGNED_LONG_LONG: 3342169695Skan d_append_string_constant (dpi, "ull"); 3343169695Skan break; 3344169695Skan } 3345169695Skan return; 3346169695Skan } 3347169695Skan break; 3348169695Skan 3349169695Skan case D_PRINT_BOOL: 3350169695Skan if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME 3351169695Skan && d_right (dc)->u.s_name.len == 1 3352169695Skan && dc->type == DEMANGLE_COMPONENT_LITERAL) 3353169695Skan { 3354169695Skan switch (d_right (dc)->u.s_name.s[0]) 3355169695Skan { 3356169695Skan case '0': 3357169695Skan d_append_string_constant (dpi, "false"); 3358169695Skan return; 3359169695Skan case '1': 3360169695Skan d_append_string_constant (dpi, "true"); 3361169695Skan return; 3362169695Skan default: 3363169695Skan break; 3364169695Skan } 3365169695Skan } 3366169695Skan break; 3367169695Skan 3368169695Skan default: 3369169695Skan break; 3370169695Skan } 3371169695Skan } 3372169695Skan 3373169695Skan d_append_char (dpi, '('); 3374169695Skan d_print_comp (dpi, d_left (dc)); 3375169695Skan d_append_char (dpi, ')'); 3376169695Skan if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG) 3377169695Skan d_append_char (dpi, '-'); 3378169695Skan if (tp == D_PRINT_FLOAT) 3379169695Skan d_append_char (dpi, '['); 3380169695Skan d_print_comp (dpi, d_right (dc)); 3381169695Skan if (tp == D_PRINT_FLOAT) 3382169695Skan d_append_char (dpi, ']'); 3383169695Skan } 3384169695Skan return; 3385169695Skan 3386169695Skan default: 3387169695Skan d_print_error (dpi); 3388169695Skan return; 3389169695Skan } 3390169695Skan} 3391169695Skan 3392169695Skan/* Print a Java dentifier. For Java we try to handle encoded extended 3393169695Skan Unicode characters. The C++ ABI doesn't mention Unicode encoding, 3394169695Skan so we don't it for C++. Characters are encoded as 3395169695Skan __U<hex-char>+_. */ 3396169695Skan 3397169695Skanstatic void 3398169695Skand_print_java_identifier (struct d_print_info *dpi, const char *name, int len) 3399169695Skan{ 3400169695Skan const char *p; 3401169695Skan const char *end; 3402169695Skan 3403169695Skan end = name + len; 3404169695Skan for (p = name; p < end; ++p) 3405169695Skan { 3406169695Skan if (end - p > 3 3407169695Skan && p[0] == '_' 3408169695Skan && p[1] == '_' 3409169695Skan && p[2] == 'U') 3410169695Skan { 3411169695Skan unsigned long c; 3412169695Skan const char *q; 3413169695Skan 3414169695Skan c = 0; 3415169695Skan for (q = p + 3; q < end; ++q) 3416169695Skan { 3417169695Skan int dig; 3418169695Skan 3419169695Skan if (IS_DIGIT (*q)) 3420169695Skan dig = *q - '0'; 3421169695Skan else if (*q >= 'A' && *q <= 'F') 3422169695Skan dig = *q - 'A' + 10; 3423169695Skan else if (*q >= 'a' && *q <= 'f') 3424169695Skan dig = *q - 'a' + 10; 3425169695Skan else 3426169695Skan break; 3427169695Skan 3428169695Skan c = c * 16 + dig; 3429169695Skan } 3430169695Skan /* If the Unicode character is larger than 256, we don't try 3431169695Skan to deal with it here. FIXME. */ 3432169695Skan if (q < end && *q == '_' && c < 256) 3433169695Skan { 3434169695Skan d_append_char (dpi, c); 3435169695Skan p = q; 3436169695Skan continue; 3437169695Skan } 3438169695Skan } 3439169695Skan 3440169695Skan d_append_char (dpi, *p); 3441169695Skan } 3442169695Skan} 3443169695Skan 3444169695Skan/* Print a list of modifiers. SUFFIX is 1 if we are printing 3445169695Skan qualifiers on this after printing a function. */ 3446169695Skan 3447169695Skanstatic void 3448169695Skand_print_mod_list (struct d_print_info *dpi, 3449169695Skan struct d_print_mod *mods, int suffix) 3450169695Skan{ 3451169695Skan struct d_print_template *hold_dpt; 3452169695Skan 3453169695Skan if (mods == NULL || d_print_saw_error (dpi)) 3454169695Skan return; 3455169695Skan 3456169695Skan if (mods->printed 3457169695Skan || (! suffix 3458169695Skan && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS 3459169695Skan || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS 3460169695Skan || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS))) 3461169695Skan { 3462169695Skan d_print_mod_list (dpi, mods->next, suffix); 3463169695Skan return; 3464169695Skan } 3465169695Skan 3466169695Skan mods->printed = 1; 3467169695Skan 3468169695Skan hold_dpt = dpi->templates; 3469169695Skan dpi->templates = mods->templates; 3470169695Skan 3471169695Skan if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) 3472169695Skan { 3473169695Skan d_print_function_type (dpi, mods->mod, mods->next); 3474169695Skan dpi->templates = hold_dpt; 3475169695Skan return; 3476169695Skan } 3477169695Skan else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 3478169695Skan { 3479169695Skan d_print_array_type (dpi, mods->mod, mods->next); 3480169695Skan dpi->templates = hold_dpt; 3481169695Skan return; 3482169695Skan } 3483169695Skan else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) 3484169695Skan { 3485169695Skan struct d_print_mod *hold_modifiers; 3486169695Skan struct demangle_component *dc; 3487169695Skan 3488169695Skan /* When this is on the modifier stack, we have pulled any 3489169695Skan qualifiers off the right argument already. Otherwise, we 3490169695Skan print it as usual, but don't let the left argument see any 3491169695Skan modifiers. */ 3492169695Skan 3493169695Skan hold_modifiers = dpi->modifiers; 3494169695Skan dpi->modifiers = NULL; 3495169695Skan d_print_comp (dpi, d_left (mods->mod)); 3496169695Skan dpi->modifiers = hold_modifiers; 3497169695Skan 3498169695Skan if ((dpi->options & DMGL_JAVA) == 0) 3499169695Skan d_append_string_constant (dpi, "::"); 3500169695Skan else 3501169695Skan d_append_char (dpi, '.'); 3502169695Skan 3503169695Skan dc = d_right (mods->mod); 3504169695Skan while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS 3505169695Skan || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS 3506169695Skan || dc->type == DEMANGLE_COMPONENT_CONST_THIS) 3507169695Skan dc = d_left (dc); 3508169695Skan 3509169695Skan d_print_comp (dpi, dc); 3510169695Skan 3511169695Skan dpi->templates = hold_dpt; 3512169695Skan return; 3513169695Skan } 3514169695Skan 3515169695Skan d_print_mod (dpi, mods->mod); 3516169695Skan 3517169695Skan dpi->templates = hold_dpt; 3518169695Skan 3519169695Skan d_print_mod_list (dpi, mods->next, suffix); 3520169695Skan} 3521169695Skan 3522169695Skan/* Print a modifier. */ 3523169695Skan 3524169695Skanstatic void 3525169695Skand_print_mod (struct d_print_info *dpi, 3526169695Skan const struct demangle_component *mod) 3527169695Skan{ 3528169695Skan switch (mod->type) 3529169695Skan { 3530169695Skan case DEMANGLE_COMPONENT_RESTRICT: 3531169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 3532169695Skan d_append_string_constant (dpi, " restrict"); 3533169695Skan return; 3534169695Skan case DEMANGLE_COMPONENT_VOLATILE: 3535169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 3536169695Skan d_append_string_constant (dpi, " volatile"); 3537169695Skan return; 3538169695Skan case DEMANGLE_COMPONENT_CONST: 3539169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 3540169695Skan d_append_string_constant (dpi, " const"); 3541169695Skan return; 3542169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 3543169695Skan d_append_char (dpi, ' '); 3544169695Skan d_print_comp (dpi, d_right (mod)); 3545169695Skan return; 3546169695Skan case DEMANGLE_COMPONENT_POINTER: 3547169695Skan /* There is no pointer symbol in Java. */ 3548169695Skan if ((dpi->options & DMGL_JAVA) == 0) 3549169695Skan d_append_char (dpi, '*'); 3550169695Skan return; 3551169695Skan case DEMANGLE_COMPONENT_REFERENCE: 3552169695Skan d_append_char (dpi, '&'); 3553169695Skan return; 3554169695Skan case DEMANGLE_COMPONENT_COMPLEX: 3555169695Skan d_append_string_constant (dpi, "complex "); 3556169695Skan return; 3557169695Skan case DEMANGLE_COMPONENT_IMAGINARY: 3558169695Skan d_append_string_constant (dpi, "imaginary "); 3559169695Skan return; 3560169695Skan case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3561169695Skan if (d_last_char (dpi) != '(') 3562169695Skan d_append_char (dpi, ' '); 3563169695Skan d_print_comp (dpi, d_left (mod)); 3564169695Skan d_append_string_constant (dpi, "::*"); 3565169695Skan return; 3566169695Skan case DEMANGLE_COMPONENT_TYPED_NAME: 3567169695Skan d_print_comp (dpi, d_left (mod)); 3568169695Skan return; 3569169695Skan default: 3570169695Skan /* Otherwise, we have something that won't go back on the 3571169695Skan modifier stack, so we can just print it. */ 3572169695Skan d_print_comp (dpi, mod); 3573169695Skan return; 3574169695Skan } 3575169695Skan} 3576169695Skan 3577169695Skan/* Print a function type, except for the return type. */ 3578169695Skan 3579169695Skanstatic void 3580169695Skand_print_function_type (struct d_print_info *dpi, 3581169695Skan const struct demangle_component *dc, 3582169695Skan struct d_print_mod *mods) 3583169695Skan{ 3584169695Skan int need_paren; 3585169695Skan int saw_mod; 3586169695Skan int need_space; 3587169695Skan struct d_print_mod *p; 3588169695Skan struct d_print_mod *hold_modifiers; 3589169695Skan 3590169695Skan need_paren = 0; 3591169695Skan saw_mod = 0; 3592169695Skan need_space = 0; 3593169695Skan for (p = mods; p != NULL; p = p->next) 3594169695Skan { 3595169695Skan if (p->printed) 3596169695Skan break; 3597169695Skan 3598169695Skan saw_mod = 1; 3599169695Skan switch (p->mod->type) 3600169695Skan { 3601169695Skan case DEMANGLE_COMPONENT_POINTER: 3602169695Skan case DEMANGLE_COMPONENT_REFERENCE: 3603169695Skan need_paren = 1; 3604169695Skan break; 3605169695Skan case DEMANGLE_COMPONENT_RESTRICT: 3606169695Skan case DEMANGLE_COMPONENT_VOLATILE: 3607169695Skan case DEMANGLE_COMPONENT_CONST: 3608169695Skan case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 3609169695Skan case DEMANGLE_COMPONENT_COMPLEX: 3610169695Skan case DEMANGLE_COMPONENT_IMAGINARY: 3611169695Skan case DEMANGLE_COMPONENT_PTRMEM_TYPE: 3612169695Skan need_space = 1; 3613169695Skan need_paren = 1; 3614169695Skan break; 3615169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 3616169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 3617169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 3618169695Skan break; 3619169695Skan default: 3620169695Skan break; 3621169695Skan } 3622169695Skan if (need_paren) 3623169695Skan break; 3624169695Skan } 3625169695Skan 3626169695Skan if (d_left (dc) != NULL && ! saw_mod) 3627169695Skan need_paren = 1; 3628169695Skan 3629169695Skan if (need_paren) 3630169695Skan { 3631169695Skan if (! need_space) 3632169695Skan { 3633169695Skan if (d_last_char (dpi) != '(' 3634169695Skan && d_last_char (dpi) != '*') 3635169695Skan need_space = 1; 3636169695Skan } 3637169695Skan if (need_space && d_last_char (dpi) != ' ') 3638169695Skan d_append_char (dpi, ' '); 3639169695Skan d_append_char (dpi, '('); 3640169695Skan } 3641169695Skan 3642169695Skan hold_modifiers = dpi->modifiers; 3643169695Skan dpi->modifiers = NULL; 3644169695Skan 3645169695Skan d_print_mod_list (dpi, mods, 0); 3646169695Skan 3647169695Skan if (need_paren) 3648169695Skan d_append_char (dpi, ')'); 3649169695Skan 3650169695Skan d_append_char (dpi, '('); 3651169695Skan 3652169695Skan if (d_right (dc) != NULL) 3653169695Skan d_print_comp (dpi, d_right (dc)); 3654169695Skan 3655169695Skan d_append_char (dpi, ')'); 3656169695Skan 3657169695Skan d_print_mod_list (dpi, mods, 1); 3658169695Skan 3659169695Skan dpi->modifiers = hold_modifiers; 3660169695Skan} 3661169695Skan 3662169695Skan/* Print an array type, except for the element type. */ 3663169695Skan 3664169695Skanstatic void 3665169695Skand_print_array_type (struct d_print_info *dpi, 3666169695Skan const struct demangle_component *dc, 3667169695Skan struct d_print_mod *mods) 3668169695Skan{ 3669169695Skan int need_space; 3670169695Skan 3671169695Skan need_space = 1; 3672169695Skan if (mods != NULL) 3673169695Skan { 3674169695Skan int need_paren; 3675169695Skan struct d_print_mod *p; 3676169695Skan 3677169695Skan need_paren = 0; 3678169695Skan for (p = mods; p != NULL; p = p->next) 3679169695Skan { 3680169695Skan if (! p->printed) 3681169695Skan { 3682169695Skan if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) 3683169695Skan { 3684169695Skan need_space = 0; 3685169695Skan break; 3686169695Skan } 3687169695Skan else 3688169695Skan { 3689169695Skan need_paren = 1; 3690169695Skan need_space = 1; 3691169695Skan break; 3692169695Skan } 3693169695Skan } 3694169695Skan } 3695169695Skan 3696169695Skan if (need_paren) 3697169695Skan d_append_string_constant (dpi, " ("); 3698169695Skan 3699169695Skan d_print_mod_list (dpi, mods, 0); 3700169695Skan 3701169695Skan if (need_paren) 3702169695Skan d_append_char (dpi, ')'); 3703169695Skan } 3704169695Skan 3705169695Skan if (need_space) 3706169695Skan d_append_char (dpi, ' '); 3707169695Skan 3708169695Skan d_append_char (dpi, '['); 3709169695Skan 3710169695Skan if (d_left (dc) != NULL) 3711169695Skan d_print_comp (dpi, d_left (dc)); 3712169695Skan 3713169695Skan d_append_char (dpi, ']'); 3714169695Skan} 3715169695Skan 3716169695Skan/* Print an operator in an expression. */ 3717169695Skan 3718169695Skanstatic void 3719169695Skand_print_expr_op (struct d_print_info *dpi, 3720169695Skan const struct demangle_component *dc) 3721169695Skan{ 3722169695Skan if (dc->type == DEMANGLE_COMPONENT_OPERATOR) 3723169695Skan d_append_buffer (dpi, dc->u.s_operator.op->name, 3724169695Skan dc->u.s_operator.op->len); 3725169695Skan else 3726169695Skan d_print_comp (dpi, dc); 3727169695Skan} 3728169695Skan 3729169695Skan/* Print a cast. */ 3730169695Skan 3731169695Skanstatic void 3732169695Skand_print_cast (struct d_print_info *dpi, 3733169695Skan const struct demangle_component *dc) 3734169695Skan{ 3735169695Skan if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE) 3736169695Skan d_print_comp (dpi, d_left (dc)); 3737169695Skan else 3738169695Skan { 3739169695Skan struct d_print_mod *hold_dpm; 3740169695Skan struct d_print_template dpt; 3741169695Skan 3742169695Skan /* It appears that for a templated cast operator, we need to put 3743169695Skan the template parameters in scope for the operator name, but 3744169695Skan not for the parameters. The effect is that we need to handle 3745169695Skan the template printing here. */ 3746169695Skan 3747169695Skan hold_dpm = dpi->modifiers; 3748169695Skan dpi->modifiers = NULL; 3749169695Skan 3750169695Skan dpt.next = dpi->templates; 3751169695Skan dpi->templates = &dpt; 3752169695Skan dpt.template_decl = d_left (dc); 3753169695Skan 3754169695Skan d_print_comp (dpi, d_left (d_left (dc))); 3755169695Skan 3756169695Skan dpi->templates = dpt.next; 3757169695Skan 3758169695Skan if (d_last_char (dpi) == '<') 3759169695Skan d_append_char (dpi, ' '); 3760169695Skan d_append_char (dpi, '<'); 3761169695Skan d_print_comp (dpi, d_right (d_left (dc))); 3762169695Skan /* Avoid generating two consecutive '>' characters, to avoid 3763169695Skan the C++ syntactic ambiguity. */ 3764169695Skan if (d_last_char (dpi) == '>') 3765169695Skan d_append_char (dpi, ' '); 3766169695Skan d_append_char (dpi, '>'); 3767169695Skan 3768169695Skan dpi->modifiers = hold_dpm; 3769169695Skan } 3770169695Skan} 3771169695Skan 3772169695Skan/* Initialize the information structure we use to pass around 3773169695Skan information. */ 3774169695Skan 3775169695SkanCP_STATIC_IF_GLIBCPP_V3 3776169695Skanvoid 3777169695Skancplus_demangle_init_info (const char *mangled, int options, size_t len, 3778169695Skan struct d_info *di) 3779169695Skan{ 3780169695Skan di->s = mangled; 3781169695Skan di->send = mangled + len; 3782169695Skan di->options = options; 3783169695Skan 3784169695Skan di->n = mangled; 3785169695Skan 3786169695Skan /* We can not need more components than twice the number of chars in 3787169695Skan the mangled string. Most components correspond directly to 3788169695Skan chars, but the ARGLIST types are exceptions. */ 3789169695Skan di->num_comps = 2 * len; 3790169695Skan di->next_comp = 0; 3791169695Skan 3792169695Skan /* Similarly, we can not need more substitutions than there are 3793169695Skan chars in the mangled string. */ 3794169695Skan di->num_subs = len; 3795169695Skan di->next_sub = 0; 3796169695Skan di->did_subs = 0; 3797169695Skan 3798169695Skan di->last_name = NULL; 3799169695Skan 3800169695Skan di->expansion = 0; 3801169695Skan} 3802169695Skan 3803169695Skan/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled 3804169695Skan name, return a buffer allocated with malloc holding the demangled 3805169695Skan name. OPTIONS is the usual libiberty demangler options. On 3806169695Skan success, this sets *PALC to the allocated size of the returned 3807169695Skan buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for 3808169695Skan a memory allocation failure. On failure, this returns NULL. */ 3809169695Skan 3810169695Skanstatic char * 3811169695Skand_demangle (const char* mangled, int options, size_t *palc) 3812169695Skan{ 3813169695Skan size_t len; 3814169695Skan int type; 3815169695Skan struct d_info di; 3816169695Skan struct demangle_component *dc; 3817169695Skan int estimate; 3818169695Skan char *ret; 3819169695Skan 3820169695Skan *palc = 0; 3821169695Skan 3822169695Skan len = strlen (mangled); 3823169695Skan 3824169695Skan if (mangled[0] == '_' && mangled[1] == 'Z') 3825169695Skan type = 0; 3826169695Skan else if (strncmp (mangled, "_GLOBAL_", 8) == 0 3827169695Skan && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$') 3828169695Skan && (mangled[9] == 'D' || mangled[9] == 'I') 3829169695Skan && mangled[10] == '_') 3830169695Skan { 3831169695Skan char *r; 3832169695Skan 3833169695Skan r = (char *) malloc (40 + len - 11); 3834169695Skan if (r == NULL) 3835169695Skan *palc = 1; 3836169695Skan else 3837169695Skan { 3838169695Skan if (mangled[9] == 'I') 3839169695Skan strcpy (r, "global constructors keyed to "); 3840169695Skan else 3841169695Skan strcpy (r, "global destructors keyed to "); 3842169695Skan strcat (r, mangled + 11); 3843169695Skan } 3844169695Skan return r; 3845169695Skan } 3846169695Skan else 3847169695Skan { 3848169695Skan if ((options & DMGL_TYPES) == 0) 3849169695Skan return NULL; 3850169695Skan type = 1; 3851169695Skan } 3852169695Skan 3853169695Skan cplus_demangle_init_info (mangled, options, len, &di); 3854169695Skan 3855169695Skan { 3856169695Skan#ifdef CP_DYNAMIC_ARRAYS 3857169695Skan __extension__ struct demangle_component comps[di.num_comps]; 3858169695Skan __extension__ struct demangle_component *subs[di.num_subs]; 3859169695Skan 3860169695Skan di.comps = &comps[0]; 3861169695Skan di.subs = &subs[0]; 3862169695Skan#else 3863169695Skan di.comps = ((struct demangle_component *) 3864169695Skan malloc (di.num_comps * sizeof (struct demangle_component))); 3865169695Skan di.subs = ((struct demangle_component **) 3866169695Skan malloc (di.num_subs * sizeof (struct demangle_component *))); 3867169695Skan if (di.comps == NULL || di.subs == NULL) 3868169695Skan { 3869169695Skan if (di.comps != NULL) 3870169695Skan free (di.comps); 3871169695Skan if (di.subs != NULL) 3872169695Skan free (di.subs); 3873169695Skan *palc = 1; 3874169695Skan return NULL; 3875169695Skan } 3876169695Skan#endif 3877169695Skan 3878169695Skan if (! type) 3879169695Skan dc = cplus_demangle_mangled_name (&di, 1); 3880169695Skan else 3881169695Skan dc = cplus_demangle_type (&di); 3882169695Skan 3883169695Skan /* If DMGL_PARAMS is set, then if we didn't consume the entire 3884169695Skan mangled string, then we didn't successfully demangle it. If 3885169695Skan DMGL_PARAMS is not set, we didn't look at the trailing 3886169695Skan parameters. */ 3887169695Skan if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0') 3888169695Skan dc = NULL; 3889169695Skan 3890169695Skan#ifdef CP_DEMANGLE_DEBUG 3891169695Skan if (dc == NULL) 3892169695Skan printf ("failed demangling\n"); 3893169695Skan else 3894169695Skan d_dump (dc, 0); 3895169695Skan#endif 3896169695Skan 3897169695Skan /* We try to guess the length of the demangled string, to minimize 3898169695Skan calls to realloc during demangling. */ 3899169695Skan estimate = len + di.expansion + 10 * di.did_subs; 3900169695Skan estimate += estimate / 8; 3901169695Skan 3902169695Skan ret = NULL; 3903169695Skan if (dc != NULL) 3904169695Skan ret = cplus_demangle_print (options, dc, estimate, palc); 3905169695Skan 3906169695Skan#ifndef CP_DYNAMIC_ARRAYS 3907169695Skan free (di.comps); 3908169695Skan free (di.subs); 3909169695Skan#endif 3910169695Skan 3911169695Skan#ifdef CP_DEMANGLE_DEBUG 3912169695Skan if (ret != NULL) 3913169695Skan { 3914169695Skan int rlen; 3915169695Skan 3916169695Skan rlen = strlen (ret); 3917169695Skan if (rlen > 2 * estimate) 3918169695Skan printf ("*** Length %d much greater than estimate %d\n", 3919169695Skan rlen, estimate); 3920169695Skan else if (rlen > estimate) 3921169695Skan printf ("*** Length %d greater than estimate %d\n", 3922169695Skan rlen, estimate); 3923169695Skan else if (rlen < estimate / 2) 3924169695Skan printf ("*** Length %d much less than estimate %d\n", 3925169695Skan rlen, estimate); 3926169695Skan } 3927169695Skan#endif 3928169695Skan } 3929169695Skan 3930169695Skan return ret; 3931169695Skan} 3932169695Skan 3933169695Skan#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3) 3934169695Skan 3935169695Skanextern char *__cxa_demangle (const char *, char *, size_t *, int *); 3936169695Skan 3937169695Skan/* ia64 ABI-mandated entry point in the C++ runtime library for 3938169695Skan performing demangling. MANGLED_NAME is a NUL-terminated character 3939169695Skan string containing the name to be demangled. 3940169695Skan 3941169695Skan OUTPUT_BUFFER is a region of memory, allocated with malloc, of 3942169695Skan *LENGTH bytes, into which the demangled name is stored. If 3943169695Skan OUTPUT_BUFFER is not long enough, it is expanded using realloc. 3944169695Skan OUTPUT_BUFFER may instead be NULL; in that case, the demangled name 3945169695Skan is placed in a region of memory allocated with malloc. 3946169695Skan 3947169695Skan If LENGTH is non-NULL, the length of the buffer conaining the 3948169695Skan demangled name, is placed in *LENGTH. 3949169695Skan 3950169695Skan The return value is a pointer to the start of the NUL-terminated 3951169695Skan demangled name, or NULL if the demangling fails. The caller is 3952169695Skan responsible for deallocating this memory using free. 3953169695Skan 3954169695Skan *STATUS is set to one of the following values: 3955169695Skan 0: The demangling operation succeeded. 3956169695Skan -1: A memory allocation failure occurred. 3957169695Skan -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules. 3958169695Skan -3: One of the arguments is invalid. 3959169695Skan 3960169695Skan The demangling is performed using the C++ ABI mangling rules, with 3961169695Skan GNU extensions. */ 3962169695Skan 3963169695Skanchar * 3964169695Skan__cxa_demangle (const char *mangled_name, char *output_buffer, 3965169695Skan size_t *length, int *status) 3966169695Skan{ 3967169695Skan char *demangled; 3968169695Skan size_t alc; 3969169695Skan 3970169695Skan if (mangled_name == NULL) 3971169695Skan { 3972169695Skan if (status != NULL) 3973169695Skan *status = -3; 3974169695Skan return NULL; 3975169695Skan } 3976169695Skan 3977169695Skan if (output_buffer != NULL && length == NULL) 3978169695Skan { 3979169695Skan if (status != NULL) 3980169695Skan *status = -3; 3981169695Skan return NULL; 3982169695Skan } 3983169695Skan 3984169695Skan demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc); 3985169695Skan 3986169695Skan if (demangled == NULL) 3987169695Skan { 3988169695Skan if (status != NULL) 3989169695Skan { 3990169695Skan if (alc == 1) 3991169695Skan *status = -1; 3992169695Skan else 3993169695Skan *status = -2; 3994169695Skan } 3995169695Skan return NULL; 3996169695Skan } 3997169695Skan 3998169695Skan if (output_buffer == NULL) 3999169695Skan { 4000169695Skan if (length != NULL) 4001169695Skan *length = alc; 4002169695Skan } 4003169695Skan else 4004169695Skan { 4005169695Skan if (strlen (demangled) < *length) 4006169695Skan { 4007169695Skan strcpy (output_buffer, demangled); 4008169695Skan free (demangled); 4009169695Skan demangled = output_buffer; 4010169695Skan } 4011169695Skan else 4012169695Skan { 4013169695Skan free (output_buffer); 4014169695Skan *length = alc; 4015169695Skan } 4016169695Skan } 4017169695Skan 4018169695Skan if (status != NULL) 4019169695Skan *status = 0; 4020169695Skan 4021169695Skan return demangled; 4022169695Skan} 4023169695Skan 4024169695Skan#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */ 4025169695Skan 4026169695Skan/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI 4027169695Skan mangled name, return a buffer allocated with malloc holding the 4028169695Skan demangled name. Otherwise, return NULL. */ 4029169695Skan 4030169695Skanchar * 4031169695Skancplus_demangle_v3 (const char* mangled, int options) 4032169695Skan{ 4033169695Skan size_t alc; 4034169695Skan 4035169695Skan return d_demangle (mangled, options, &alc); 4036169695Skan} 4037169695Skan 4038169695Skan/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling 4039169695Skan conventions, but the output formatting is a little different. 4040169695Skan This instructs the C++ demangler not to emit pointer characters ("*"), and 4041169695Skan to use Java's namespace separator symbol ("." instead of "::"). It then 4042169695Skan does an additional pass over the demangled output to replace instances 4043169695Skan of JArray<TYPE> with TYPE[]. */ 4044169695Skan 4045169695Skanchar * 4046169695Skanjava_demangle_v3 (const char* mangled) 4047169695Skan{ 4048169695Skan size_t alc; 4049169695Skan char *demangled; 4050169695Skan int nesting; 4051169695Skan char *from; 4052169695Skan char *to; 4053169695Skan 4054169695Skan demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 4055169695Skan &alc); 4056169695Skan 4057169695Skan if (demangled == NULL) 4058169695Skan return NULL; 4059169695Skan 4060169695Skan nesting = 0; 4061169695Skan from = demangled; 4062169695Skan to = from; 4063169695Skan while (*from != '\0') 4064169695Skan { 4065169695Skan if (strncmp (from, "JArray<", 7) == 0) 4066169695Skan { 4067169695Skan from += 7; 4068169695Skan ++nesting; 4069169695Skan } 4070169695Skan else if (nesting > 0 && *from == '>') 4071169695Skan { 4072169695Skan while (to > demangled && to[-1] == ' ') 4073169695Skan --to; 4074169695Skan *to++ = '['; 4075169695Skan *to++ = ']'; 4076169695Skan --nesting; 4077169695Skan ++from; 4078169695Skan } 4079169695Skan else 4080169695Skan *to++ = *from++; 4081169695Skan } 4082169695Skan 4083169695Skan *to = '\0'; 4084169695Skan 4085169695Skan return demangled; 4086169695Skan} 4087169695Skan 4088169695Skan#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */ 4089169695Skan 4090169695Skan#ifndef IN_GLIBCPP_V3 4091169695Skan 4092169695Skan/* Demangle a string in order to find out whether it is a constructor 4093169695Skan or destructor. Return non-zero on success. Set *CTOR_KIND and 4094169695Skan *DTOR_KIND appropriately. */ 4095169695Skan 4096169695Skanstatic int 4097169695Skanis_ctor_or_dtor (const char *mangled, 4098169695Skan enum gnu_v3_ctor_kinds *ctor_kind, 4099169695Skan enum gnu_v3_dtor_kinds *dtor_kind) 4100169695Skan{ 4101169695Skan struct d_info di; 4102169695Skan struct demangle_component *dc; 4103169695Skan int ret; 4104169695Skan 4105169695Skan *ctor_kind = (enum gnu_v3_ctor_kinds) 0; 4106169695Skan *dtor_kind = (enum gnu_v3_dtor_kinds) 0; 4107169695Skan 4108169695Skan cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di); 4109169695Skan 4110169695Skan { 4111169695Skan#ifdef CP_DYNAMIC_ARRAYS 4112169695Skan __extension__ struct demangle_component comps[di.num_comps]; 4113169695Skan __extension__ struct demangle_component *subs[di.num_subs]; 4114169695Skan 4115169695Skan di.comps = &comps[0]; 4116169695Skan di.subs = &subs[0]; 4117169695Skan#else 4118169695Skan di.comps = ((struct demangle_component *) 4119169695Skan malloc (di.num_comps * sizeof (struct demangle_component))); 4120169695Skan di.subs = ((struct demangle_component **) 4121169695Skan malloc (di.num_subs * sizeof (struct demangle_component *))); 4122169695Skan if (di.comps == NULL || di.subs == NULL) 4123169695Skan { 4124169695Skan if (di.comps != NULL) 4125169695Skan free (di.comps); 4126169695Skan if (di.subs != NULL) 4127169695Skan free (di.subs); 4128169695Skan return 0; 4129169695Skan } 4130169695Skan#endif 4131169695Skan 4132169695Skan dc = cplus_demangle_mangled_name (&di, 1); 4133169695Skan 4134169695Skan /* Note that because we did not pass DMGL_PARAMS, we don't expect 4135169695Skan to demangle the entire string. */ 4136169695Skan 4137169695Skan ret = 0; 4138169695Skan while (dc != NULL) 4139169695Skan { 4140169695Skan switch (dc->type) 4141169695Skan { 4142169695Skan default: 4143169695Skan dc = NULL; 4144169695Skan break; 4145169695Skan case DEMANGLE_COMPONENT_TYPED_NAME: 4146169695Skan case DEMANGLE_COMPONENT_TEMPLATE: 4147169695Skan case DEMANGLE_COMPONENT_RESTRICT_THIS: 4148169695Skan case DEMANGLE_COMPONENT_VOLATILE_THIS: 4149169695Skan case DEMANGLE_COMPONENT_CONST_THIS: 4150169695Skan dc = d_left (dc); 4151169695Skan break; 4152169695Skan case DEMANGLE_COMPONENT_QUAL_NAME: 4153169695Skan case DEMANGLE_COMPONENT_LOCAL_NAME: 4154169695Skan dc = d_right (dc); 4155169695Skan break; 4156169695Skan case DEMANGLE_COMPONENT_CTOR: 4157169695Skan *ctor_kind = dc->u.s_ctor.kind; 4158169695Skan ret = 1; 4159169695Skan dc = NULL; 4160169695Skan break; 4161169695Skan case DEMANGLE_COMPONENT_DTOR: 4162169695Skan *dtor_kind = dc->u.s_dtor.kind; 4163169695Skan ret = 1; 4164169695Skan dc = NULL; 4165169695Skan break; 4166169695Skan } 4167169695Skan } 4168169695Skan 4169169695Skan#ifndef CP_DYNAMIC_ARRAYS 4170169695Skan free (di.subs); 4171169695Skan free (di.comps); 4172169695Skan#endif 4173169695Skan } 4174169695Skan 4175169695Skan return ret; 4176169695Skan} 4177169695Skan 4178169695Skan/* Return whether NAME is the mangled form of a g++ V3 ABI constructor 4179169695Skan name. A non-zero return indicates the type of constructor. */ 4180169695Skan 4181169695Skanenum gnu_v3_ctor_kinds 4182169695Skanis_gnu_v3_mangled_ctor (const char *name) 4183169695Skan{ 4184169695Skan enum gnu_v3_ctor_kinds ctor_kind; 4185169695Skan enum gnu_v3_dtor_kinds dtor_kind; 4186169695Skan 4187169695Skan if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 4188169695Skan return (enum gnu_v3_ctor_kinds) 0; 4189169695Skan return ctor_kind; 4190169695Skan} 4191169695Skan 4192169695Skan 4193169695Skan/* Return whether NAME is the mangled form of a g++ V3 ABI destructor 4194169695Skan name. A non-zero return indicates the type of destructor. */ 4195169695Skan 4196169695Skanenum gnu_v3_dtor_kinds 4197169695Skanis_gnu_v3_mangled_dtor (const char *name) 4198169695Skan{ 4199169695Skan enum gnu_v3_ctor_kinds ctor_kind; 4200169695Skan enum gnu_v3_dtor_kinds dtor_kind; 4201169695Skan 4202169695Skan if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind)) 4203169695Skan return (enum gnu_v3_dtor_kinds) 0; 4204169695Skan return dtor_kind; 4205169695Skan} 4206169695Skan 4207169695Skan#endif /* IN_GLIBCPP_V3 */ 4208169695Skan 4209169695Skan#ifdef STANDALONE_DEMANGLER 4210169695Skan 4211169695Skan#include "getopt.h" 4212169695Skan#include "dyn-string.h" 4213169695Skan 4214169695Skanstatic void print_usage (FILE* fp, int exit_value); 4215169695Skan 4216169695Skan#define IS_ALPHA(CHAR) \ 4217169695Skan (((CHAR) >= 'a' && (CHAR) <= 'z') \ 4218169695Skan || ((CHAR) >= 'A' && (CHAR) <= 'Z')) 4219169695Skan 4220169695Skan/* Non-zero if CHAR is a character than can occur in a mangled name. */ 4221169695Skan#define is_mangled_char(CHAR) \ 4222169695Skan (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \ 4223169695Skan || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$') 4224169695Skan 4225169695Skan/* The name of this program, as invoked. */ 4226169695Skanconst char* program_name; 4227169695Skan 4228169695Skan/* Prints usage summary to FP and then exits with EXIT_VALUE. */ 4229169695Skan 4230169695Skanstatic void 4231169695Skanprint_usage (FILE* fp, int exit_value) 4232169695Skan{ 4233169695Skan fprintf (fp, "Usage: %s [options] [names ...]\n", program_name); 4234169695Skan fprintf (fp, "Options:\n"); 4235169695Skan fprintf (fp, " -h,--help Display this message.\n"); 4236169695Skan fprintf (fp, " -p,--no-params Don't display function parameters\n"); 4237169695Skan fprintf (fp, " -v,--verbose Produce verbose demanglings.\n"); 4238169695Skan fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n"); 4239169695Skan 4240169695Skan exit (exit_value); 4241169695Skan} 4242169695Skan 4243169695Skan/* Option specification for getopt_long. */ 4244169695Skanstatic const struct option long_options[] = 4245169695Skan{ 4246169695Skan { "help", no_argument, NULL, 'h' }, 4247169695Skan { "no-params", no_argument, NULL, 'p' }, 4248169695Skan { "verbose", no_argument, NULL, 'v' }, 4249169695Skan { NULL, no_argument, NULL, 0 }, 4250169695Skan}; 4251169695Skan 4252169695Skan/* Main entry for a demangling filter executable. It will demangle 4253169695Skan its command line arguments, if any. If none are provided, it will 4254169695Skan filter stdin to stdout, replacing any recognized mangled C++ names 4255169695Skan with their demangled equivalents. */ 4256169695Skan 4257169695Skanint 4258169695Skanmain (int argc, char *argv[]) 4259169695Skan{ 4260169695Skan int i; 4261169695Skan int opt_char; 4262169695Skan int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES; 4263169695Skan 4264169695Skan /* Use the program name of this program, as invoked. */ 4265169695Skan program_name = argv[0]; 4266169695Skan 4267169695Skan /* Parse options. */ 4268169695Skan do 4269169695Skan { 4270169695Skan opt_char = getopt_long (argc, argv, "hpv", long_options, NULL); 4271169695Skan switch (opt_char) 4272169695Skan { 4273169695Skan case '?': /* Unrecognized option. */ 4274169695Skan print_usage (stderr, 1); 4275169695Skan break; 4276169695Skan 4277169695Skan case 'h': 4278169695Skan print_usage (stdout, 0); 4279169695Skan break; 4280169695Skan 4281169695Skan case 'p': 4282169695Skan options &= ~ DMGL_PARAMS; 4283169695Skan break; 4284169695Skan 4285169695Skan case 'v': 4286169695Skan options |= DMGL_VERBOSE; 4287169695Skan break; 4288169695Skan } 4289169695Skan } 4290169695Skan while (opt_char != -1); 4291169695Skan 4292169695Skan if (optind == argc) 4293169695Skan /* No command line arguments were provided. Filter stdin. */ 4294169695Skan { 4295169695Skan dyn_string_t mangled = dyn_string_new (3); 4296169695Skan char *s; 4297169695Skan 4298169695Skan /* Read all of input. */ 4299169695Skan while (!feof (stdin)) 4300169695Skan { 4301169695Skan char c; 4302169695Skan 4303169695Skan /* Pile characters into mangled until we hit one that can't 4304169695Skan occur in a mangled name. */ 4305169695Skan c = getchar (); 4306169695Skan while (!feof (stdin) && is_mangled_char (c)) 4307169695Skan { 4308169695Skan dyn_string_append_char (mangled, c); 4309169695Skan if (feof (stdin)) 4310169695Skan break; 4311169695Skan c = getchar (); 4312169695Skan } 4313169695Skan 4314169695Skan if (dyn_string_length (mangled) > 0) 4315169695Skan { 4316169695Skan#ifdef IN_GLIBCPP_V3 4317169695Skan s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL); 4318169695Skan#else 4319169695Skan s = cplus_demangle_v3 (dyn_string_buf (mangled), options); 4320169695Skan#endif 4321169695Skan 4322169695Skan if (s != NULL) 4323169695Skan { 4324169695Skan fputs (s, stdout); 4325169695Skan free (s); 4326169695Skan } 4327169695Skan else 4328169695Skan { 4329169695Skan /* It might not have been a mangled name. Print the 4330169695Skan original text. */ 4331169695Skan fputs (dyn_string_buf (mangled), stdout); 4332169695Skan } 4333169695Skan 4334169695Skan dyn_string_clear (mangled); 4335169695Skan } 4336169695Skan 4337169695Skan /* If we haven't hit EOF yet, we've read one character that 4338169695Skan can't occur in a mangled name, so print it out. */ 4339169695Skan if (!feof (stdin)) 4340169695Skan putchar (c); 4341169695Skan } 4342169695Skan 4343169695Skan dyn_string_delete (mangled); 4344169695Skan } 4345169695Skan else 4346169695Skan /* Demangle command line arguments. */ 4347169695Skan { 4348169695Skan /* Loop over command line arguments. */ 4349169695Skan for (i = optind; i < argc; ++i) 4350169695Skan { 4351169695Skan char *s; 4352169695Skan#ifdef IN_GLIBCPP_V3 4353169695Skan int status; 4354169695Skan#endif 4355169695Skan 4356169695Skan /* Attempt to demangle. */ 4357169695Skan#ifdef IN_GLIBCPP_V3 4358169695Skan s = __cxa_demangle (argv[i], NULL, NULL, &status); 4359169695Skan#else 4360169695Skan s = cplus_demangle_v3 (argv[i], options); 4361169695Skan#endif 4362169695Skan 4363169695Skan /* If it worked, print the demangled name. */ 4364169695Skan if (s != NULL) 4365169695Skan { 4366169695Skan printf ("%s\n", s); 4367169695Skan free (s); 4368169695Skan } 4369169695Skan else 4370169695Skan { 4371169695Skan#ifdef IN_GLIBCPP_V3 4372169695Skan fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status); 4373169695Skan#else 4374169695Skan fprintf (stderr, "Failed: %s\n", argv[i]); 4375169695Skan#endif 4376169695Skan } 4377169695Skan } 4378169695Skan } 4379169695Skan 4380169695Skan return 0; 4381169695Skan} 4382169695Skan 4383169695Skan#endif /* STANDALONE_DEMANGLER */ 4384