1/* Name mangling for the 3.0 -*- C++ -*- ABI. 2 Copyright (C) 2000-2022 Free Software Foundation, Inc. 3 Written by Alex Samuel <samuel@codesourcery.com> 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify it 8 under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, but 13 WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21/* This file implements mangling of C++ names according to the IA64 22 C++ ABI specification. A mangled name encodes a function or 23 variable's name, scope, type, and/or template arguments into a text 24 identifier. This identifier is used as the function's or 25 variable's linkage name, to preserve compatibility between C++'s 26 language features (templates, scoping, and overloading) and C 27 linkers. 28 29 Additionally, g++ uses mangled names internally. To support this, 30 mangling of types is allowed, even though the mangled name of a 31 type should not appear by itself as an exported name. Ditto for 32 uninstantiated templates. 33 34 The primary entry point for this module is mangle_decl, which 35 returns an identifier containing the mangled name for a decl. 36 Additional entry points are provided to build mangled names of 37 particular constructs when the appropriate decl for that construct 38 is not available. These are: 39 40 mangle_typeinfo_for_type: typeinfo data 41 mangle_typeinfo_string_for_type: typeinfo type name 42 mangle_vtbl_for_type: virtual table data 43 mangle_vtt_for_type: VTT data 44 mangle_ctor_vtbl_for_type: `C-in-B' constructor virtual table data 45 mangle_thunk: thunk function or entry */ 46 47#include "config.h" 48#include "system.h" 49#include "coretypes.h" 50#include "target.h" 51#include "vtable-verify.h" 52#include "cp-tree.h" 53#include "stringpool.h" 54#include "cgraph.h" 55#include "stor-layout.h" 56#include "flags.h" 57#include "attribs.h" 58 59/* Debugging support. */ 60 61/* Define DEBUG_MANGLE to enable very verbose trace messages. */ 62#ifndef DEBUG_MANGLE 63#define DEBUG_MANGLE 0 64#endif 65 66/* Macros for tracing the write_* functions. */ 67#if DEBUG_MANGLE 68# define MANGLE_TRACE(FN, INPUT) \ 69 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT)) 70# define MANGLE_TRACE_TREE(FN, NODE) \ 71 fprintf (stderr, " %-24s: %-24s (%p)\n", \ 72 (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE)) 73#else 74# define MANGLE_TRACE(FN, INPUT) 75# define MANGLE_TRACE_TREE(FN, NODE) 76#endif 77 78/* Nonzero if NODE is a class template-id. We can't rely on 79 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser 80 that hard to distinguish A<T> from A, where A<T> is the type as 81 instantiated outside of the template, and A is the type used 82 without parameters inside the template. */ 83#define CLASSTYPE_TEMPLATE_ID_P(NODE) \ 84 (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ 85 || (CLASS_TYPE_P (NODE) \ 86 && CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \ 87 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))) 88 89/* For deciding whether to set G.need_abi_warning, we need to consider both 90 warn_abi_version and flag_abi_compat_version. */ 91#define abi_warn_or_compat_version_crosses(N) \ 92 (abi_version_crosses (N) || abi_compat_version_crosses (N)) 93 94/* And sometimes we can simplify the code path if we don't need to worry about 95 previous ABIs. */ 96#define abi_flag_at_least(flag,N) (flag == 0 || flag >= N) 97#define any_abi_below(N) \ 98 (!abi_version_at_least (N) \ 99 || !abi_flag_at_least (warn_abi_version, (N)) \ 100 || !abi_flag_at_least (flag_abi_compat_version, (N))) 101 102/* Things we only need one of. This module is not reentrant. */ 103struct GTY(()) globals { 104 /* An array of the current substitution candidates, in the order 105 we've seen them. Contains NULLS, which correspond to module 106 substitutions. */ 107 vec<tree, va_gc> *substitutions; 108 109 /* The entity that is being mangled. */ 110 tree GTY ((skip)) entity; 111 112 /* How many parameter scopes we are inside. */ 113 int parm_depth; 114 115 /* True if the mangling will be different in a future version of the 116 ABI. */ 117 bool need_abi_warning; 118 119 /* True if the mangling will be different in C++17 mode. */ 120 bool need_cxx17_warning; 121 122 /* True if we mangled a module name. */ 123 bool mod; 124}; 125 126static GTY (()) globals G; 127 128/* The obstack on which we build mangled names. */ 129static struct obstack *mangle_obstack; 130 131/* The obstack on which we build mangled names that are not going to 132 be IDENTIFIER_NODEs. */ 133static struct obstack name_obstack; 134 135/* The first object on the name_obstack; we use this to free memory 136 allocated on the name_obstack. */ 137static void *name_base; 138 139/* Indices into subst_identifiers. These are identifiers used in 140 special substitution rules. */ 141typedef enum 142{ 143 SUBID_ALLOCATOR, 144 SUBID_BASIC_STRING, 145 SUBID_CHAR_TRAITS, 146 SUBID_BASIC_ISTREAM, 147 SUBID_BASIC_OSTREAM, 148 SUBID_BASIC_IOSTREAM, 149 SUBID_MAX 150} 151substitution_identifier_index_t; 152 153/* For quick substitution checks, look up these common identifiers 154 once only. */ 155static GTY(()) tree subst_identifiers[SUBID_MAX]; 156 157/* Single-letter codes for builtin integer types, defined in 158 <builtin-type>. These are indexed by integer_type_kind values. */ 159static const char 160integer_type_codes[itk_none] = 161{ 162 'c', /* itk_char */ 163 'a', /* itk_signed_char */ 164 'h', /* itk_unsigned_char */ 165 's', /* itk_short */ 166 't', /* itk_unsigned_short */ 167 'i', /* itk_int */ 168 'j', /* itk_unsigned_int */ 169 'l', /* itk_long */ 170 'm', /* itk_unsigned_long */ 171 'x', /* itk_long_long */ 172 'y', /* itk_unsigned_long_long */ 173 /* __intN types are handled separately */ 174 '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0' 175}; 176 177static tree maybe_template_info (const tree); 178 179/* Functions for handling substitutions. */ 180 181static inline tree canonicalize_for_substitution (tree); 182static void add_substitution (tree); 183static inline bool is_std_substitution (const tree, 184 const substitution_identifier_index_t); 185static inline bool is_std_substitution_char (const tree, 186 const substitution_identifier_index_t); 187static int find_substitution (tree); 188static void mangle_call_offset (const tree, const tree); 189 190/* Functions for emitting mangled representations of things. */ 191 192static void write_mangled_name (const tree, bool); 193static void write_encoding (const tree); 194static void write_name (tree, const int); 195static void write_abi_tags (tree); 196static void write_unscoped_name (const tree); 197static void write_unscoped_template_name (const tree); 198static void write_nested_name (const tree); 199static void write_prefix (const tree); 200static void write_template_prefix (const tree); 201static void write_unqualified_name (tree); 202static void write_conversion_operator_name (const tree); 203static void write_source_name (tree); 204static void write_literal_operator_name (tree); 205static void write_unnamed_type_name (const tree); 206static void write_closure_type_name (const tree); 207static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *, 208 const unsigned int); 209static void write_number (unsigned HOST_WIDE_INT, const int, 210 const unsigned int); 211static void write_compact_number (int num); 212static void write_integer_cst (const tree); 213static void write_real_cst (const tree); 214static void write_identifier (const char *); 215static void write_special_name_constructor (const tree); 216static void write_special_name_destructor (const tree); 217static void write_type (tree); 218static int write_CV_qualifiers_for_type (const tree); 219static void write_builtin_type (tree); 220static void write_function_type (const tree); 221static void write_bare_function_type (const tree, const int, const tree); 222static void write_method_parms (tree, const int, const tree); 223static void write_class_enum_type (const tree); 224static void write_template_args (tree); 225static void write_expression (tree); 226static void write_template_arg_literal (const tree); 227static void write_template_arg (tree); 228static void write_template_template_arg (const tree); 229static void write_array_type (const tree); 230static void write_pointer_to_member_type (const tree); 231static void write_template_param (const tree); 232static void write_template_template_param (const tree); 233static void write_substitution (const int); 234static int discriminator_for_local_entity (tree); 235static int discriminator_for_string_literal (tree, tree); 236static void write_discriminator (const int); 237static void write_local_name (tree, const tree, const tree); 238static void dump_substitution_candidates (void); 239static tree mangle_decl_string (const tree); 240static void maybe_check_abi_tags (tree, tree = NULL_TREE, int = 10); 241static bool equal_abi_tags (tree, tree); 242 243/* Control functions. */ 244 245static inline void start_mangling (const tree); 246static tree mangle_special_for_type (const tree, const char *); 247 248/* Append a single character to the end of the mangled 249 representation. */ 250#define write_char(CHAR) \ 251 obstack_1grow (mangle_obstack, (CHAR)) 252 253/* Append a sized buffer to the end of the mangled representation. */ 254#define write_chars(CHAR, LEN) \ 255 obstack_grow (mangle_obstack, (CHAR), (LEN)) 256 257/* Append a NUL-terminated string to the end of the mangled 258 representation. */ 259#define write_string(STRING) \ 260 obstack_grow (mangle_obstack, (STRING), strlen (STRING)) 261 262/* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the 263 same purpose (context, which may be a type) and value (template 264 decl). See write_template_prefix for more information on what this 265 is used for. */ 266#define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \ 267 (TREE_CODE (NODE1) == TREE_LIST \ 268 && TREE_CODE (NODE2) == TREE_LIST \ 269 && ((TYPE_P (TREE_PURPOSE (NODE1)) \ 270 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \ 271 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \ 272 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2)) 273 274/* Write out an unsigned quantity in base 10. */ 275#define write_unsigned_number(NUMBER) \ 276 write_number ((NUMBER), /*unsigned_p=*/1, 10) 277 278/* If DECL is a template instance (including the uninstantiated template 279 itself), return its TEMPLATE_INFO. Otherwise return NULL. */ 280 281static tree 282maybe_template_info (const tree decl) 283{ 284 if (TREE_CODE (decl) == TYPE_DECL) 285 { 286 /* TYPE_DECLs are handled specially. Look at its type to decide 287 if this is a template instantiation. */ 288 const tree type = TREE_TYPE (decl); 289 290 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type)) 291 return TYPE_TEMPLATE_INFO (type); 292 } 293 else 294 { 295 /* Check if the template is a primary template. */ 296 if (DECL_LANG_SPECIFIC (decl) != NULL 297 && VAR_OR_FUNCTION_DECL_P (decl) 298 && DECL_TEMPLATE_INFO (decl) 299 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl))) 300 return DECL_TEMPLATE_INFO (decl); 301 } 302 303 /* It's not a template id. */ 304 return NULL_TREE; 305} 306 307/* Produce debugging output of current substitution candidates. */ 308 309static void 310dump_substitution_candidates (void) 311{ 312 unsigned i; 313 tree el; 314 315 fprintf (stderr, " ++ substitutions "); 316 FOR_EACH_VEC_ELT (*G.substitutions, i, el) 317 { 318 const char *name = "???"; 319 320 if (i > 0) 321 fprintf (stderr, " "); 322 if (!el) 323 name = "module"; 324 else if (DECL_P (el)) 325 name = IDENTIFIER_POINTER (DECL_NAME (el)); 326 else if (TREE_CODE (el) == TREE_LIST) 327 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el))); 328 else if (TYPE_NAME (el)) 329 name = TYPE_NAME_STRING (el); 330 fprintf (stderr, " S%d_ = ", i - 1); 331 if (el) 332 { 333 if (TYPE_P (el) && 334 (CP_TYPE_RESTRICT_P (el) 335 || CP_TYPE_VOLATILE_P (el) 336 || CP_TYPE_CONST_P (el))) 337 fprintf (stderr, "CV-"); 338 fprintf (stderr, "%s (%s at %p)", 339 name, get_tree_code_name (TREE_CODE (el)), (void *) el); 340 } 341 fprintf (stderr, "\n"); 342 } 343} 344 345/* <exception-spec> ::= 346 Do -- non-throwing exception specification 347 DO <expression> E -- computed (instantiation-dependent) noexcept 348 Dw <type>* E -- throw (types) */ 349 350static void 351write_exception_spec (tree spec) 352{ 353 354 if (!spec || spec == noexcept_false_spec) 355 /* Nothing. */ 356 return; 357 358 if (!flag_noexcept_type) 359 { 360 G.need_cxx17_warning = true; 361 return; 362 } 363 364 if (spec == noexcept_true_spec || spec == empty_except_spec) 365 write_string ("Do"); 366 else if (tree expr = TREE_PURPOSE (spec)) 367 { 368 /* noexcept (expr) */ 369 gcc_assert (uses_template_parms (expr)); 370 write_string ("DO"); 371 write_expression (expr); 372 write_char ('E'); 373 } 374 else 375 { 376 /* throw (type-list) */ 377 write_string ("Dw"); 378 for (tree t = spec; t; t = TREE_CHAIN (t)) 379 write_type (TREE_VALUE (t)); 380 write_char ('E'); 381 } 382} 383 384/* Both decls and types can be substitution candidates, but sometimes 385 they refer to the same thing. For instance, a TYPE_DECL and 386 RECORD_TYPE for the same class refer to the same thing, and should 387 be treated accordingly in substitutions. This function returns a 388 canonicalized tree node representing NODE that is used when adding 389 and substitution candidates and finding matches. */ 390 391static inline tree 392canonicalize_for_substitution (tree node) 393{ 394 /* For a TYPE_DECL, use the type instead. */ 395 if (TREE_CODE (node) == TYPE_DECL) 396 node = TREE_TYPE (node); 397 if (TYPE_P (node) 398 && TYPE_CANONICAL (node) != node 399 && TYPE_MAIN_VARIANT (node) != node) 400 { 401 tree orig = node; 402 /* Here we want to strip the topmost typedef only. 403 We need to do that so is_std_substitution can do proper 404 name matching. */ 405 if (TREE_CODE (node) == FUNCTION_TYPE) 406 /* Use build_qualified_type and TYPE_QUALS here to preserve 407 the old buggy mangling of attribute noreturn with abi<5. */ 408 node = build_qualified_type (TYPE_MAIN_VARIANT (node), 409 TYPE_QUALS (node)); 410 else 411 node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node), 412 cp_type_quals (node)); 413 if (FUNC_OR_METHOD_TYPE_P (node)) 414 { 415 node = build_ref_qualified_type (node, type_memfn_rqual (orig)); 416 tree r = canonical_eh_spec (TYPE_RAISES_EXCEPTIONS (orig)); 417 if (flag_noexcept_type) 418 node = build_exception_variant (node, r); 419 else 420 /* Set the warning flag if appropriate. */ 421 write_exception_spec (r); 422 } 423 } 424 return node; 425} 426 427/* Add NODE as a substitution candidate. NODE must not already be on 428 the list of candidates. */ 429 430static void 431add_substitution (tree node) 432{ 433 tree c; 434 435 if (DEBUG_MANGLE) 436 fprintf (stderr, " ++ add_substitution (%s at %10p)\n", 437 get_tree_code_name (TREE_CODE (node)), (void *) node); 438 439 /* Get the canonicalized substitution candidate for NODE. */ 440 c = canonicalize_for_substitution (node); 441 if (DEBUG_MANGLE && c != node) 442 fprintf (stderr, " ++ using candidate (%s at %10p)\n", 443 get_tree_code_name (TREE_CODE (node)), (void *) node); 444 node = c; 445 446 /* Make sure NODE isn't already a candidate. */ 447 if (flag_checking) 448 { 449 int i; 450 tree candidate; 451 452 FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate) 453 if (candidate) 454 { 455 gcc_assert (!(DECL_P (node) && node == candidate)); 456 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate) 457 && same_type_p (node, candidate))); 458 } 459 } 460 461 /* Put the decl onto the varray of substitution candidates. */ 462 vec_safe_push (G.substitutions, node); 463 464 if (DEBUG_MANGLE) 465 dump_substitution_candidates (); 466} 467 468/* Helper function for find_substitution. Returns nonzero if NODE, 469 which may be a decl or a CLASS_TYPE, is a template-id with template 470 name of substitution_index[INDEX] in the ::std namespace, with 471 global module attachment. */ 472 473static bool 474is_std_substitution (const tree node, 475 const substitution_identifier_index_t index) 476{ 477 tree type = NULL; 478 tree decl = NULL; 479 480 if (DECL_P (node)) 481 { 482 type = TREE_TYPE (node); 483 decl = node; 484 } 485 else if (CLASS_TYPE_P (node)) 486 { 487 type = node; 488 decl = TYPE_NAME (node); 489 } 490 else 491 /* These are not the droids you're looking for. */ 492 return false; 493 494 if (!DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl))) 495 return false; 496 497 if (!(TYPE_LANG_SPECIFIC (type) && TYPE_TEMPLATE_INFO (type))) 498 return false; 499 500 tree tmpl = TYPE_TI_TEMPLATE (type); 501 if (DECL_NAME (tmpl) != subst_identifiers[index]) 502 return false; 503 504 if (modules_p () && get_originating_module (tmpl, true) >= 0) 505 return false; 506 507 return true; 508} 509 510/* Return the ABI tags (the TREE_VALUE of the "abi_tag" attribute entry) for T, 511 which can be a decl or type. */ 512 513static tree 514get_abi_tags (tree t) 515{ 516 if (!t || TREE_CODE (t) == NAMESPACE_DECL) 517 return NULL_TREE; 518 519 if (DECL_P (t) && DECL_DECLARES_TYPE_P (t)) 520 t = TREE_TYPE (t); 521 522 tree attrs; 523 if (TYPE_P (t)) 524 attrs = TYPE_ATTRIBUTES (t); 525 else 526 attrs = DECL_ATTRIBUTES (t); 527 528 tree tags = lookup_attribute ("abi_tag", attrs); 529 if (tags) 530 tags = TREE_VALUE (tags); 531 return tags; 532} 533 534/* Helper function for find_substitution. Returns nonzero if NODE, 535 which may be a decl or a CLASS_TYPE, is the template-id 536 ::std::identifier<char>, where identifier is 537 substitution_index[INDEX]. */ 538 539static bool 540is_std_substitution_char (const tree node, 541 const substitution_identifier_index_t index) 542{ 543 tree args; 544 /* Check NODE's name is ::std::identifier. */ 545 if (!is_std_substitution (node, index)) 546 return 0; 547 /* Figure out its template args. */ 548 if (DECL_P (node)) 549 args = DECL_TI_ARGS (node); 550 else if (CLASS_TYPE_P (node)) 551 args = CLASSTYPE_TI_ARGS (node); 552 else 553 /* Oops, not a template. */ 554 return 0; 555 /* NODE's template arg list should be <char>. */ 556 return 557 TREE_VEC_LENGTH (args) == 1 558 && TREE_VEC_ELT (args, 0) == char_type_node; 559} 560 561/* Check whether a substitution should be used to represent NODE in 562 the mangling. 563 564 First, check standard special-case substitutions. 565 566 <substitution> ::= St 567 # ::std 568 569 ::= Sa 570 # ::std::allocator 571 572 ::= Sb 573 # ::std::basic_string 574 575 ::= Ss 576 # ::std::basic_string<char, 577 ::std::char_traits<char>, 578 ::std::allocator<char> > 579 580 ::= Si 581 # ::std::basic_istream<char, ::std::char_traits<char> > 582 583 ::= So 584 # ::std::basic_ostream<char, ::std::char_traits<char> > 585 586 ::= Sd 587 # ::std::basic_iostream<char, ::std::char_traits<char> > 588 589 Then examine the stack of currently available substitution 590 candidates for entities appearing earlier in the same mangling 591 592 If a substitution is found, write its mangled representation and 593 return nonzero. If none is found, just return zero. */ 594 595static int 596find_substitution (tree node) 597{ 598 int i; 599 const int size = vec_safe_length (G.substitutions); 600 tree decl; 601 tree type; 602 const char *abbr = NULL; 603 604 if (DEBUG_MANGLE) 605 fprintf (stderr, " ++ find_substitution (%s at %p)\n", 606 get_tree_code_name (TREE_CODE (node)), (void *) node); 607 608 /* Obtain the canonicalized substitution representation for NODE. 609 This is what we'll compare against. */ 610 node = canonicalize_for_substitution (node); 611 612 /* Check for builtin substitutions. */ 613 614 decl = TYPE_P (node) ? TYPE_NAME (node) : node; 615 type = TYPE_P (node) ? node : TREE_TYPE (node); 616 617 /* Check for std::allocator. */ 618 if (decl 619 && is_std_substitution (decl, SUBID_ALLOCATOR) 620 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl))) 621 abbr = "Sa"; 622 623 /* Check for std::basic_string. */ 624 else if (decl && is_std_substitution (decl, SUBID_BASIC_STRING)) 625 { 626 if (TYPE_P (node)) 627 { 628 /* If this is a type (i.e. a fully-qualified template-id), 629 check for 630 std::basic_string <char, 631 std::char_traits<char>, 632 std::allocator<char> > . */ 633 if (cp_type_quals (type) == TYPE_UNQUALIFIED 634 && CLASSTYPE_USE_TEMPLATE (type)) 635 { 636 tree args = CLASSTYPE_TI_ARGS (type); 637 if (TREE_VEC_LENGTH (args) == 3 638 && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node) 639 && is_std_substitution_char (TREE_VEC_ELT (args, 1), 640 SUBID_CHAR_TRAITS) 641 && is_std_substitution_char (TREE_VEC_ELT (args, 2), 642 SUBID_ALLOCATOR)) 643 abbr = "Ss"; 644 } 645 } 646 else 647 /* Substitute for the template name only if this isn't a type. */ 648 abbr = "Sb"; 649 } 650 651 /* Check for basic_{i,o,io}stream. */ 652 else if (TYPE_P (node) 653 && cp_type_quals (type) == TYPE_UNQUALIFIED 654 && CLASS_TYPE_P (type) 655 && CLASSTYPE_USE_TEMPLATE (type) 656 && CLASSTYPE_TEMPLATE_INFO (type) != NULL) 657 { 658 /* First, check for the template 659 args <char, std::char_traits<char> > . */ 660 tree args = CLASSTYPE_TI_ARGS (type); 661 if (TREE_VEC_LENGTH (args) == 2 662 && template_args_equal (TREE_VEC_ELT (args, 0), char_type_node) 663 && is_std_substitution_char (TREE_VEC_ELT (args, 1), 664 SUBID_CHAR_TRAITS)) 665 { 666 /* Got them. Is this basic_istream? */ 667 if (is_std_substitution (decl, SUBID_BASIC_ISTREAM)) 668 abbr = "Si"; 669 /* Or basic_ostream? */ 670 else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM)) 671 abbr = "So"; 672 /* Or basic_iostream? */ 673 else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM)) 674 abbr = "Sd"; 675 } 676 } 677 678 /* Check for namespace std. */ 679 else if (decl && DECL_NAMESPACE_STD_P (decl)) 680 { 681 write_string ("St"); 682 return 1; 683 } 684 685 tree tags = NULL_TREE; 686 if (OVERLOAD_TYPE_P (node) || DECL_CLASS_TEMPLATE_P (node)) 687 tags = get_abi_tags (type); 688 /* Now check the list of available substitutions for this mangling 689 operation. */ 690 if (!abbr || tags) 691 for (i = 0; i < size; ++i) 692 if (tree candidate = (*G.substitutions)[i]) 693 { 694 /* NODE is a matched to a candidate if it's the same decl node or 695 if it's the same type. */ 696 if (decl == candidate 697 || (TYPE_P (candidate) && type && TYPE_P (node) 698 && same_type_p (type, candidate)) 699 || NESTED_TEMPLATE_MATCH (node, candidate)) 700 { 701 write_substitution (i); 702 return 1; 703 } 704 } 705 706 if (!abbr) 707 /* No substitution found. */ 708 return 0; 709 710 write_string (abbr); 711 if (tags) 712 { 713 /* If there are ABI tags on the abbreviation, it becomes 714 a substitution candidate. */ 715 write_abi_tags (tags); 716 add_substitution (node); 717 } 718 return 1; 719} 720 721/* Returns whether DECL's symbol name should be the plain unqualified-id 722 rather than a more complicated mangled name. */ 723 724static bool 725unmangled_name_p (const tree decl) 726{ 727 if (TREE_CODE (decl) == FUNCTION_DECL) 728 { 729 /* The names of `extern "C"' functions are not mangled. */ 730 return (DECL_EXTERN_C_FUNCTION_P (decl) 731 /* But overloaded operator names *are* mangled. */ 732 && !DECL_OVERLOADED_OPERATOR_P (decl)); 733 } 734 else if (VAR_P (decl)) 735 { 736 /* static variables are mangled. */ 737 if (!DECL_EXTERNAL_LINKAGE_P (decl)) 738 return false; 739 740 /* extern "C" declarations aren't mangled. */ 741 if (DECL_EXTERN_C_P (decl)) 742 return true; 743 744 /* Other variables at non-global scope are mangled. */ 745 if (CP_DECL_CONTEXT (decl) != global_namespace) 746 return false; 747 748 /* Variable template instantiations are mangled. */ 749 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) 750 && variable_template_p (DECL_TI_TEMPLATE (decl))) 751 return false; 752 753 /* Declarations with ABI tags are mangled. */ 754 if (get_abi_tags (decl)) 755 return false; 756 757 // Declarations attached to a named module are mangled 758 if (modules_p () && get_originating_module (decl, true) >= 0) 759 return false; 760 761 /* The names of non-static global variables aren't mangled. */ 762 return true; 763 } 764 765 return false; 766} 767 768/* TOP_LEVEL is true, if this is being called at outermost level of 769 mangling. It should be false when mangling a decl appearing in an 770 expression within some other mangling. 771 772 <mangled-name> ::= _Z <encoding> */ 773 774static void 775write_mangled_name (const tree decl, bool top_level) 776{ 777 MANGLE_TRACE_TREE ("mangled-name", decl); 778 779 check_abi_tags (decl); 780 781 if (unmangled_name_p (decl)) 782 { 783 if (top_level) 784 write_string (IDENTIFIER_POINTER (DECL_NAME (decl))); 785 else 786 { 787 /* The standard notes: "The <encoding> of an extern "C" 788 function is treated like global-scope data, i.e. as its 789 <source-name> without a type." We cannot write 790 overloaded operators that way though, because it contains 791 characters invalid in assembler. */ 792 write_string ("_Z"); 793 write_source_name (DECL_NAME (decl)); 794 } 795 } 796 else 797 { 798 write_string ("_Z"); 799 write_encoding (decl); 800 } 801} 802 803/* Returns true if the return type of DECL is part of its signature, and 804 therefore its mangling. */ 805 806bool 807mangle_return_type_p (tree decl) 808{ 809 return (!DECL_CONSTRUCTOR_P (decl) 810 && !DECL_DESTRUCTOR_P (decl) 811 && !DECL_CONV_FN_P (decl) 812 && maybe_template_info (decl)); 813} 814 815/* <encoding> ::= <function name> <bare-function-type> 816 ::= <data name> */ 817 818static void 819write_encoding (const tree decl) 820{ 821 MANGLE_TRACE_TREE ("encoding", decl); 822 823 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl)) 824 { 825 /* For overloaded operators write just the mangled name 826 without arguments. */ 827 if (DECL_OVERLOADED_OPERATOR_P (decl)) 828 write_name (decl, /*ignore_local_scope=*/0); 829 else 830 write_source_name (DECL_NAME (decl)); 831 return; 832 } 833 834 write_name (decl, /*ignore_local_scope=*/0); 835 if (TREE_CODE (decl) == FUNCTION_DECL) 836 { 837 tree fn_type; 838 tree d; 839 840 if (maybe_template_info (decl)) 841 { 842 fn_type = get_mostly_instantiated_function_type (decl); 843 /* FN_TYPE will not have parameter types for in-charge or 844 VTT parameters. Therefore, we pass NULL_TREE to 845 write_bare_function_type -- otherwise, it will get 846 confused about which artificial parameters to skip. */ 847 d = NULL_TREE; 848 } 849 else 850 { 851 fn_type = TREE_TYPE (decl); 852 d = decl; 853 } 854 855 write_bare_function_type (fn_type, 856 mangle_return_type_p (decl), 857 d); 858 859 /* If this is a coroutine helper, then append an appropriate string to 860 identify which. */ 861 if (tree ramp = DECL_RAMP_FN (decl)) 862 { 863 if (DECL_ACTOR_FN (ramp) == decl) 864 write_string (JOIN_STR "actor"); 865 else if (DECL_DESTROY_FN (ramp) == decl) 866 write_string (JOIN_STR "destroy"); 867 else 868 gcc_unreachable (); 869 } 870 } 871} 872 873/* Interface to substitution and identifier mangling, used by the 874 module name mangler. */ 875 876void 877mangle_module_substitution (int v) 878{ 879 write_substitution (v - 1); 880} 881 882int 883mangle_module_component (tree comp, bool partition_p) 884{ 885 write_char ('W'); 886 if (partition_p) 887 write_char ('P'); 888 write_source_name (comp); 889 890 // Module substitutions use the same number-space as entity 891 // substitutions, but are orthogonal. 892 vec_safe_push (G.substitutions, NULL_TREE); 893 return G.substitutions->length (); 894} 895 896/* If the outermost non-namespace context (including DECL itself) is 897 a module-linkage decl, mangle the module information. For module 898 global initializers we need to include the partition part. 899 900 <module-name> ::= <module-sub> 901 || <subst> 902 || <module-name> <module-sub> 903 <module-sub> :: W [P] <unqualified-name> 904*/ 905 906static void 907write_module (int m, bool include_partition) 908{ 909 G.mod = true; 910 mangle_module (m, include_partition); 911} 912 913static void 914maybe_write_module (tree decl) 915{ 916 if (!DECL_NAMESPACE_SCOPE_P (decl)) 917 return; 918 919 if (TREE_CODE (decl) == NAMESPACE_DECL && DECL_NAME (decl)) 920 return; 921 922 int m = get_originating_module (decl, true); 923 if (m >= 0) 924 write_module (m, false); 925} 926 927/* Lambdas can have a bit more context for mangling, specifically VAR_DECL 928 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */ 929 930static tree 931decl_mangling_context (tree decl) 932{ 933 tree tcontext = targetm.cxx.decl_mangling_context (decl); 934 935 if (tcontext != NULL_TREE) 936 return tcontext; 937 938 if (TREE_CODE (decl) == TEMPLATE_DECL 939 && DECL_TEMPLATE_RESULT (decl)) 940 decl = DECL_TEMPLATE_RESULT (decl); 941 942 if (TREE_CODE (decl) == TYPE_DECL 943 && LAMBDA_TYPE_P (TREE_TYPE (decl))) 944 { 945 tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl)); 946 if (extra) 947 return extra; 948 } 949 else if (template_type_parameter_p (decl)) 950 /* template type parms have no mangling context. */ 951 return NULL_TREE; 952 953 tcontext = CP_DECL_CONTEXT (decl); 954 955 /* Ignore the artificial declare reduction functions. */ 956 if (tcontext 957 && TREE_CODE (tcontext) == FUNCTION_DECL 958 && DECL_OMP_DECLARE_REDUCTION_P (tcontext)) 959 return decl_mangling_context (tcontext); 960 961 return tcontext; 962} 963 964/* <name> ::= <unscoped-name> 965 ::= <unscoped-template-name> <template-args> 966 ::= <nested-name> 967 ::= <local-name> 968 969 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is 970 called from <local-name>, which mangles the enclosing scope 971 elsewhere and then uses this function to mangle just the part 972 underneath the function scope. So don't use the <local-name> 973 production, to avoid an infinite recursion. */ 974 975static void 976write_name (tree decl, const int ignore_local_scope) 977{ 978 tree context; 979 980 MANGLE_TRACE_TREE ("name", decl); 981 982 if (TREE_CODE (decl) == TYPE_DECL) 983 { 984 /* In case this is a typedef, fish out the corresponding 985 TYPE_DECL for the main variant. */ 986 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))); 987 } 988 989 context = decl_mangling_context (decl); 990 991 gcc_assert (context != NULL_TREE); 992 993 if (abi_warn_or_compat_version_crosses (7) 994 && ignore_local_scope 995 && TREE_CODE (context) == PARM_DECL) 996 G.need_abi_warning = 1; 997 998 /* A decl in :: or ::std scope is treated specially. The former is 999 mangled using <unscoped-name> or <unscoped-template-name>, the 1000 latter with a special substitution. Also, a name that is 1001 directly in a local function scope is also mangled with 1002 <unscoped-name> rather than a full <nested-name>. */ 1003 if (context == global_namespace 1004 || DECL_NAMESPACE_STD_P (context) 1005 || (ignore_local_scope 1006 && (TREE_CODE (context) == FUNCTION_DECL 1007 || (abi_version_at_least (7) 1008 && TREE_CODE (context) == PARM_DECL)))) 1009 { 1010 /* Is this a template instance? */ 1011 if (tree info = maybe_template_info (decl)) 1012 { 1013 /* Yes: use <unscoped-template-name>. */ 1014 write_unscoped_template_name (TI_TEMPLATE (info)); 1015 write_template_args (TI_ARGS (info)); 1016 } 1017 else 1018 /* Everything else gets an <unqualified-name>. */ 1019 write_unscoped_name (decl); 1020 } 1021 else 1022 { 1023 /* Handle local names, unless we asked not to (that is, invoked 1024 under <local-name>, to handle only the part of the name under 1025 the local scope). */ 1026 if (!ignore_local_scope) 1027 { 1028 /* Scan up the list of scope context, looking for a 1029 function. If we find one, this entity is in local 1030 function scope. local_entity tracks context one scope 1031 level down, so it will contain the element that's 1032 directly in that function's scope, either decl or one of 1033 its enclosing scopes. */ 1034 tree local_entity = decl; 1035 while (context != global_namespace) 1036 { 1037 /* Make sure we're always dealing with decls. */ 1038 if (TYPE_P (context)) 1039 context = TYPE_NAME (context); 1040 /* Is this a function? */ 1041 if (TREE_CODE (context) == FUNCTION_DECL 1042 || TREE_CODE (context) == PARM_DECL) 1043 { 1044 /* Yes, we have local scope. Use the <local-name> 1045 production for the innermost function scope. */ 1046 write_local_name (context, local_entity, decl); 1047 return; 1048 } 1049 /* Up one scope level. */ 1050 local_entity = context; 1051 context = decl_mangling_context (context); 1052 } 1053 1054 /* No local scope found? Fall through to <nested-name>. */ 1055 } 1056 1057 /* Other decls get a <nested-name> to encode their scope. */ 1058 write_nested_name (decl); 1059 } 1060} 1061 1062/* <unscoped-name> ::= <unqualified-name> 1063 ::= St <unqualified-name> # ::std:: */ 1064 1065static void 1066write_unscoped_name (const tree decl) 1067{ 1068 tree context = decl_mangling_context (decl); 1069 1070 MANGLE_TRACE_TREE ("unscoped-name", decl); 1071 1072 /* Is DECL in ::std? */ 1073 if (DECL_NAMESPACE_STD_P (context)) 1074 { 1075 write_string ("St"); 1076 write_unqualified_name (decl); 1077 } 1078 else 1079 { 1080 /* If not, it should be either in the global namespace, or directly 1081 in a local function scope. A lambda can also be mangled in the 1082 scope of a default argument. */ 1083 gcc_assert (context == global_namespace 1084 || TREE_CODE (context) == PARM_DECL 1085 || TREE_CODE (context) == FUNCTION_DECL); 1086 1087 write_unqualified_name (decl); 1088 } 1089} 1090 1091/* <unscoped-template-name> ::= <unscoped-name> 1092 ::= <substitution> */ 1093 1094static void 1095write_unscoped_template_name (const tree decl) 1096{ 1097 MANGLE_TRACE_TREE ("unscoped-template-name", decl); 1098 1099 if (find_substitution (decl)) 1100 return; 1101 write_unscoped_name (decl); 1102 add_substitution (decl); 1103} 1104 1105/* Write the nested name, including CV-qualifiers, of DECL. 1106 1107 <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E 1108 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E 1109 1110 <ref-qualifier> ::= R # & ref-qualifier 1111 ::= O # && ref-qualifier 1112 <CV-qualifiers> ::= [r] [V] [K] */ 1113 1114static void 1115write_nested_name (const tree decl) 1116{ 1117 MANGLE_TRACE_TREE ("nested-name", decl); 1118 1119 write_char ('N'); 1120 1121 /* Write CV-qualifiers, if this is a member function. */ 1122 if (TREE_CODE (decl) == FUNCTION_DECL 1123 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 1124 { 1125 if (DECL_VOLATILE_MEMFUNC_P (decl)) 1126 write_char ('V'); 1127 if (DECL_CONST_MEMFUNC_P (decl)) 1128 write_char ('K'); 1129 if (FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))) 1130 { 1131 if (FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl))) 1132 write_char ('O'); 1133 else 1134 write_char ('R'); 1135 } 1136 } 1137 1138 /* Is this a template instance? */ 1139 if (tree info = maybe_template_info (decl)) 1140 { 1141 /* Yes, use <template-prefix>. */ 1142 write_template_prefix (decl); 1143 write_template_args (TI_ARGS (info)); 1144 } 1145 else if ((!abi_version_at_least (10) || TREE_CODE (decl) == TYPE_DECL) 1146 && TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE) 1147 { 1148 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl)); 1149 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 1150 { 1151 write_template_prefix (decl); 1152 write_template_args (TREE_OPERAND (name, 1)); 1153 } 1154 else 1155 { 1156 write_prefix (decl_mangling_context (decl)); 1157 write_unqualified_name (decl); 1158 } 1159 } 1160 else 1161 { 1162 /* No, just use <prefix> */ 1163 write_prefix (decl_mangling_context (decl)); 1164 write_unqualified_name (decl); 1165 } 1166 write_char ('E'); 1167} 1168 1169/* <prefix> ::= <prefix> <unqualified-name> 1170 ::= <template-param> 1171 ::= <template-prefix> <template-args> 1172 ::= <decltype> 1173 ::= # empty 1174 ::= <substitution> */ 1175 1176static void 1177write_prefix (const tree node) 1178{ 1179 tree decl; 1180 1181 if (node == NULL 1182 || node == global_namespace) 1183 return; 1184 1185 MANGLE_TRACE_TREE ("prefix", node); 1186 1187 if (TREE_CODE (node) == DECLTYPE_TYPE) 1188 { 1189 write_type (node); 1190 return; 1191 } 1192 1193 if (find_substitution (node)) 1194 return; 1195 1196 tree template_info = NULL_TREE; 1197 if (DECL_P (node)) 1198 { 1199 /* If this is a function or parm decl, that means we've hit function 1200 scope, so this prefix must be for a local name. In this 1201 case, we're under the <local-name> production, which encodes 1202 the enclosing function scope elsewhere. So don't continue 1203 here. */ 1204 if (TREE_CODE (node) == FUNCTION_DECL 1205 || TREE_CODE (node) == PARM_DECL) 1206 return; 1207 1208 decl = node; 1209 template_info = maybe_template_info (decl); 1210 } 1211 else 1212 { 1213 /* Node is a type. */ 1214 decl = TYPE_NAME (node); 1215 /* The DECL might not point at the node. */ 1216 if (CLASSTYPE_TEMPLATE_ID_P (node)) 1217 template_info = TYPE_TEMPLATE_INFO (node); 1218 } 1219 1220 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM) 1221 write_template_param (node); 1222 else if (template_info) 1223 /* Templated. */ 1224 { 1225 write_template_prefix (decl); 1226 write_template_args (TI_ARGS (template_info)); 1227 } 1228 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE) 1229 { 1230 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl)); 1231 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 1232 { 1233 write_template_prefix (decl); 1234 write_template_args (TREE_OPERAND (name, 1)); 1235 } 1236 else 1237 { 1238 write_prefix (decl_mangling_context (decl)); 1239 write_unqualified_name (decl); 1240 } 1241 } 1242 else 1243 /* Not templated. */ 1244 { 1245 write_prefix (decl_mangling_context (decl)); 1246 write_unqualified_name (decl); 1247 if (VAR_P (decl) 1248 || TREE_CODE (decl) == FIELD_DECL) 1249 { 1250 /* <data-member-prefix> := <member source-name> M */ 1251 write_char ('M'); 1252 return; 1253 } 1254 } 1255 1256 add_substitution (node); 1257} 1258 1259/* <template-prefix> ::= <prefix> <template component> 1260 ::= <template-param> 1261 ::= <substitution> */ 1262 1263static void 1264write_template_prefix (const tree node) 1265{ 1266 tree decl = DECL_P (node) ? node : TYPE_NAME (node); 1267 tree type = DECL_P (node) ? TREE_TYPE (node) : node; 1268 tree context = decl_mangling_context (decl); 1269 tree templ; 1270 tree substitution; 1271 1272 MANGLE_TRACE_TREE ("template-prefix", node); 1273 1274 /* Find the template decl. */ 1275 if (tree info = maybe_template_info (decl)) 1276 templ = TI_TEMPLATE (info); 1277 else if (TREE_CODE (type) == TYPENAME_TYPE) 1278 /* For a typename type, all we have is the name. */ 1279 templ = DECL_NAME (decl); 1280 else 1281 { 1282 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type)); 1283 1284 templ = TYPE_TI_TEMPLATE (type); 1285 } 1286 1287 /* For a member template, though, the template name for the 1288 innermost name must have all the outer template levels 1289 instantiated. For instance, consider 1290 1291 template<typename T> struct Outer { 1292 template<typename U> struct Inner {}; 1293 }; 1294 1295 The template name for `Inner' in `Outer<int>::Inner<float>' is 1296 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template 1297 levels separately, so there's no TEMPLATE_DECL available for this 1298 (there's only `Outer<T>::Inner<U>'). 1299 1300 In order to get the substitutions right, we create a special 1301 TREE_LIST to represent the substitution candidate for a nested 1302 template. The TREE_PURPOSE is the template's context, fully 1303 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner 1304 template. 1305 1306 So, for the example above, `Outer<int>::Inner' is represented as a 1307 substitution candidate by a TREE_LIST whose purpose is `Outer<int>' 1308 and whose value is `Outer<T>::Inner<U>'. */ 1309 if (context && TYPE_P (context)) 1310 substitution = build_tree_list (context, templ); 1311 else 1312 substitution = templ; 1313 1314 if (find_substitution (substitution)) 1315 return; 1316 1317 if (TREE_TYPE (templ) 1318 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM) 1319 write_template_param (TREE_TYPE (templ)); 1320 else 1321 { 1322 write_prefix (context); 1323 write_unqualified_name (decl); 1324 } 1325 1326 add_substitution (substitution); 1327} 1328 1329/* As the list of identifiers for the structured binding declaration 1330 DECL is likely gone, try to recover the DC <source-name>+ E portion 1331 from its mangled name. Return pointer to the DC and set len to 1332 the length up to and including the terminating E. On failure 1333 return NULL. */ 1334 1335static const char * 1336find_decomp_unqualified_name (tree decl, size_t *len) 1337{ 1338 const char *p = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 1339 const char *end = p + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)); 1340 bool nested = false; 1341 if (!startswith (p, "_Z")) 1342 return NULL; 1343 p += 2; 1344 if (startswith (p, "St")) 1345 p += 2; 1346 else if (*p == 'N') 1347 { 1348 nested = true; 1349 ++p; 1350 while (ISDIGIT (p[0])) 1351 { 1352 char *e; 1353 long num = strtol (p, &e, 10); 1354 if (num >= 1 && num < end - e) 1355 p = e + num; 1356 else 1357 break; 1358 } 1359 } 1360 if (!startswith (p, "DC")) 1361 return NULL; 1362 if (nested) 1363 { 1364 if (end[-1] != 'E') 1365 return NULL; 1366 --end; 1367 } 1368 if (end[-1] != 'E') 1369 return NULL; 1370 *len = end - p; 1371 return p; 1372} 1373 1374/* "For the purposes of mangling, the name of an anonymous union is considered 1375 to be the name of the first named data member found by a pre-order, 1376 depth-first, declaration-order walk of the data members of the anonymous 1377 union. If there is no such data member (i.e., if all of the data members in 1378 the union are unnamed), then there is no way for a program to refer to the 1379 anonymous union, and there is therefore no need to mangle its name." */ 1380 1381static tree 1382anon_aggr_naming_decl (tree type) 1383{ 1384 tree field = next_initializable_field (TYPE_FIELDS (type)); 1385 for (; field; field = next_initializable_field (DECL_CHAIN (field))) 1386 { 1387 if (DECL_NAME (field)) 1388 return field; 1389 if (ANON_AGGR_TYPE_P (TREE_TYPE (field))) 1390 if (tree sub = anon_aggr_naming_decl (TREE_TYPE (field))) 1391 return sub; 1392 } 1393 return NULL_TREE; 1394} 1395 1396/* We don't need to handle thunks, vtables, or VTTs here. Those are 1397 mangled through special entry points. 1398 1399 <unqualified-name> ::= [<module-name>] <operator-name> 1400 ::= <special-name> 1401 ::= [<module-name>] <source-name> 1402 ::= [<module-name>] <unnamed-type-name> 1403 ::= <local-source-name> 1404 1405 <local-source-name> ::= L <source-name> <discriminator> */ 1406 1407static void 1408write_unqualified_id (tree identifier) 1409{ 1410 if (IDENTIFIER_CONV_OP_P (identifier)) 1411 write_conversion_operator_name (TREE_TYPE (identifier)); 1412 else if (IDENTIFIER_OVL_OP_P (identifier)) 1413 { 1414 const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (identifier); 1415 write_string (ovl_op->mangled_name); 1416 } 1417 else if (UDLIT_OPER_P (identifier)) 1418 write_literal_operator_name (identifier); 1419 else 1420 write_source_name (identifier); 1421} 1422 1423static void 1424write_unqualified_name (tree decl) 1425{ 1426 MANGLE_TRACE_TREE ("unqualified-name", decl); 1427 1428 if (modules_p ()) 1429 maybe_write_module (decl); 1430 1431 if (identifier_p (decl)) 1432 { 1433 write_unqualified_id (decl); 1434 return; 1435 } 1436 1437 bool found = false; 1438 1439 if (DECL_NAME (decl) == NULL_TREE 1440 && ANON_AGGR_TYPE_P (TREE_TYPE (decl))) 1441 decl = anon_aggr_naming_decl (TREE_TYPE (decl)); 1442 else if (DECL_NAME (decl) == NULL_TREE) 1443 { 1444 found = true; 1445 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl)); 1446 const char *decomp_str = NULL; 1447 size_t decomp_len = 0; 1448 if (VAR_P (decl) 1449 && DECL_DECOMPOSITION_P (decl) 1450 && DECL_NAME (decl) == NULL_TREE 1451 && DECL_NAMESPACE_SCOPE_P (decl)) 1452 decomp_str = find_decomp_unqualified_name (decl, &decomp_len); 1453 if (decomp_str) 1454 write_chars (decomp_str, decomp_len); 1455 else 1456 write_source_name (DECL_ASSEMBLER_NAME (decl)); 1457 } 1458 else if (DECL_DECLARES_FUNCTION_P (decl)) 1459 { 1460 found = true; 1461 if (DECL_CONSTRUCTOR_P (decl)) 1462 write_special_name_constructor (decl); 1463 else if (DECL_DESTRUCTOR_P (decl)) 1464 write_special_name_destructor (decl); 1465 else if (DECL_CONV_FN_P (decl)) 1466 { 1467 /* Conversion operator. Handle it right here. 1468 <operator> ::= cv <type> */ 1469 tree type; 1470 if (maybe_template_info (decl)) 1471 { 1472 tree fn_type; 1473 fn_type = get_mostly_instantiated_function_type (decl); 1474 type = TREE_TYPE (fn_type); 1475 } 1476 else if (FNDECL_USED_AUTO (decl)) 1477 type = DECL_SAVED_AUTO_RETURN_TYPE (decl); 1478 else 1479 type = DECL_CONV_FN_TYPE (decl); 1480 write_conversion_operator_name (type); 1481 } 1482 else if (DECL_OVERLOADED_OPERATOR_P (decl)) 1483 { 1484 tree t; 1485 if (!(t = DECL_RAMP_FN (decl))) 1486 t = decl; 1487 const char *mangled_name 1488 = (ovl_op_info[DECL_ASSIGNMENT_OPERATOR_P (t)] 1489 [DECL_OVERLOADED_OPERATOR_CODE_RAW (t)].mangled_name); 1490 write_string (mangled_name); 1491 } 1492 else if (UDLIT_OPER_P (DECL_NAME (decl))) 1493 write_literal_operator_name (DECL_NAME (decl)); 1494 else 1495 found = false; 1496 } 1497 1498 if (found) 1499 /* OK */; 1500 else if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl) 1501 && DECL_NAMESPACE_SCOPE_P (decl) 1502 && decl_linkage (decl) == lk_internal) 1503 { 1504 MANGLE_TRACE_TREE ("local-source-name", decl); 1505 write_char ('L'); 1506 write_source_name (DECL_NAME (decl)); 1507 /* The default discriminator is 1, and that's all we ever use, 1508 so there's no code to output one here. */ 1509 } 1510 else 1511 { 1512 tree type = TREE_TYPE (decl); 1513 1514 if (TREE_CODE (decl) == TYPE_DECL 1515 && TYPE_UNNAMED_P (type)) 1516 write_unnamed_type_name (type); 1517 else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (type)) 1518 write_closure_type_name (type); 1519 else 1520 write_source_name (DECL_NAME (decl)); 1521 } 1522 1523 /* We use the ABI tags from the primary class template, ignoring tags on any 1524 specializations. This is necessary because C++ doesn't require a 1525 specialization to be declared before it is used unless the use requires a 1526 complete type, but we need to get the tags right on incomplete types as 1527 well. */ 1528 if (tree tmpl = most_general_template (decl)) 1529 { 1530 tree res = DECL_TEMPLATE_RESULT (tmpl); 1531 if (res == NULL_TREE) 1532 /* UNBOUND_CLASS_TEMPLATE. */; 1533 else if (DECL_DECLARES_TYPE_P (decl)) 1534 decl = res; 1535 else if (any_abi_below (11)) 1536 { 1537 /* ABI v10 implicit tags on the template. */ 1538 tree mtags = missing_abi_tags (res); 1539 /* Explicit tags on the template. */ 1540 tree ttags = get_abi_tags (res); 1541 /* Tags on the instantiation. */ 1542 tree dtags = get_abi_tags (decl); 1543 1544 if (mtags && abi_warn_or_compat_version_crosses (10)) 1545 G.need_abi_warning = 1; 1546 1547 /* Add the v10 tags to the explicit tags now. */ 1548 mtags = chainon (mtags, ttags); 1549 1550 if (!G.need_abi_warning 1551 && abi_warn_or_compat_version_crosses (11) 1552 && !equal_abi_tags (dtags, mtags)) 1553 G.need_abi_warning = 1; 1554 1555 if (!abi_version_at_least (10)) 1556 /* In abi <10, we only got the explicit tags. */ 1557 decl = res; 1558 else if (flag_abi_version == 10) 1559 { 1560 /* In ABI 10, we want explict and implicit tags. */ 1561 write_abi_tags (mtags); 1562 return; 1563 } 1564 } 1565 } 1566 1567 tree tags = get_abi_tags (decl); 1568 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_CONV_FN_P (decl) 1569 && any_abi_below (11)) 1570 if (tree mtags = missing_abi_tags (decl)) 1571 { 1572 if (abi_warn_or_compat_version_crosses (11)) 1573 G.need_abi_warning = true; 1574 if (!abi_version_at_least (11)) 1575 tags = chainon (mtags, tags); 1576 } 1577 write_abi_tags (tags); 1578} 1579 1580/* Write the unqualified-name for a conversion operator to TYPE. */ 1581 1582static void 1583write_conversion_operator_name (const tree type) 1584{ 1585 write_string ("cv"); 1586 write_type (type); 1587} 1588 1589/* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE. 1590 1591 <source-name> ::= </length/ number> <identifier> */ 1592 1593static void 1594write_source_name (tree identifier) 1595{ 1596 MANGLE_TRACE_TREE ("source-name", identifier); 1597 1598 write_unsigned_number (IDENTIFIER_LENGTH (identifier)); 1599 write_identifier (IDENTIFIER_POINTER (identifier)); 1600} 1601 1602/* Compare two TREE_STRINGs like strcmp. */ 1603 1604int 1605tree_string_cmp (const void *p1, const void *p2) 1606{ 1607 if (p1 == p2) 1608 return 0; 1609 tree s1 = *(const tree*)p1; 1610 tree s2 = *(const tree*)p2; 1611 return strcmp (TREE_STRING_POINTER (s1), 1612 TREE_STRING_POINTER (s2)); 1613} 1614 1615/* Return the TREE_LIST of TAGS as a sorted VEC. */ 1616 1617static vec<tree, va_gc> * 1618sorted_abi_tags (tree tags) 1619{ 1620 vec<tree, va_gc> * vec = make_tree_vector(); 1621 1622 for (tree t = tags; t; t = TREE_CHAIN (t)) 1623 { 1624 if (ABI_TAG_IMPLICIT (t)) 1625 continue; 1626 tree str = TREE_VALUE (t); 1627 vec_safe_push (vec, str); 1628 } 1629 1630 vec->qsort (tree_string_cmp); 1631 1632 return vec; 1633} 1634 1635/* ID is the name of a function or type with abi_tags attribute TAGS. 1636 Write out the name, suitably decorated. */ 1637 1638static void 1639write_abi_tags (tree tags) 1640{ 1641 if (tags == NULL_TREE) 1642 return; 1643 1644 vec<tree, va_gc> * vec = sorted_abi_tags (tags); 1645 1646 unsigned i; tree str; 1647 FOR_EACH_VEC_ELT (*vec, i, str) 1648 { 1649 write_string ("B"); 1650 write_unsigned_number (TREE_STRING_LENGTH (str) - 1); 1651 write_identifier (TREE_STRING_POINTER (str)); 1652 } 1653 1654 release_tree_vector (vec); 1655} 1656 1657/* True iff the TREE_LISTS T1 and T2 of ABI tags are equivalent. */ 1658 1659static bool 1660equal_abi_tags (tree t1, tree t2) 1661{ 1662 releasing_vec v1 = sorted_abi_tags (t1); 1663 releasing_vec v2 = sorted_abi_tags (t2); 1664 1665 unsigned len1 = v1->length(); 1666 if (len1 != v2->length()) 1667 return false; 1668 for (unsigned i = 0; i < len1; ++i) 1669 if (tree_string_cmp (v1[i], v2[i]) != 0) 1670 return false; 1671 return true; 1672} 1673 1674/* Write a user-defined literal operator. 1675 ::= li <source-name> # "" <source-name> 1676 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */ 1677 1678static void 1679write_literal_operator_name (tree identifier) 1680{ 1681 const char* suffix = UDLIT_OP_SUFFIX (identifier); 1682 write_identifier (UDLIT_OP_MANGLED_PREFIX); 1683 write_unsigned_number (strlen (suffix)); 1684 write_identifier (suffix); 1685} 1686 1687/* Encode 0 as _, and 1+ as n-1_. */ 1688 1689static void 1690write_compact_number (int num) 1691{ 1692 gcc_checking_assert (num >= 0); 1693 if (num > 0) 1694 write_unsigned_number (num - 1); 1695 write_char ('_'); 1696} 1697 1698/* Return how many unnamed types precede TYPE in its enclosing class. */ 1699 1700static int 1701nested_anon_class_index (tree type) 1702{ 1703 int index = 0; 1704 tree member = TYPE_FIELDS (TYPE_CONTEXT (type)); 1705 for (; member; member = DECL_CHAIN (member)) 1706 if (DECL_IMPLICIT_TYPEDEF_P (member)) 1707 { 1708 tree memtype = TREE_TYPE (member); 1709 if (memtype == type) 1710 return index; 1711 else if (TYPE_UNNAMED_P (memtype)) 1712 ++index; 1713 } 1714 1715 if (seen_error ()) 1716 return -1; 1717 1718 gcc_unreachable (); 1719} 1720 1721/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */ 1722 1723static void 1724write_unnamed_type_name (const tree type) 1725{ 1726 int discriminator; 1727 MANGLE_TRACE_TREE ("unnamed-type-name", type); 1728 1729 if (TYPE_FUNCTION_SCOPE_P (type)) 1730 discriminator = discriminator_for_local_entity (TYPE_NAME (type)); 1731 else if (TYPE_CLASS_SCOPE_P (type)) 1732 discriminator = nested_anon_class_index (type); 1733 else 1734 { 1735 gcc_assert (no_linkage_check (type, /*relaxed_p=*/true)); 1736 /* Just use the old mangling at namespace scope. */ 1737 write_source_name (TYPE_IDENTIFIER (type)); 1738 return; 1739 } 1740 1741 write_string ("Ut"); 1742 write_compact_number (discriminator); 1743} 1744 1745/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 1746 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */ 1747 1748static void 1749write_closure_type_name (const tree type) 1750{ 1751 tree fn = lambda_function (type); 1752 tree lambda = CLASSTYPE_LAMBDA_EXPR (type); 1753 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 1754 1755 MANGLE_TRACE_TREE ("closure-type-name", type); 1756 1757 write_string ("Ul"); 1758 write_method_parms (parms, /*method_p=*/1, fn); 1759 write_char ('E'); 1760 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda)); 1761} 1762 1763/* Convert NUMBER to ascii using base BASE and generating at least 1764 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer 1765 into which to store the characters. Returns the number of 1766 characters generated (these will be laid out in advance of where 1767 BUFFER points). */ 1768 1769static int 1770hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base, 1771 char *buffer, const unsigned int min_digits) 1772{ 1773 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 1774 unsigned digits = 0; 1775 1776 while (number) 1777 { 1778 unsigned HOST_WIDE_INT d = number / base; 1779 1780 *--buffer = base_digits[number - d * base]; 1781 digits++; 1782 number = d; 1783 } 1784 while (digits < min_digits) 1785 { 1786 *--buffer = base_digits[0]; 1787 digits++; 1788 } 1789 return digits; 1790} 1791 1792/* Non-terminal <number>. 1793 1794 <number> ::= [n] </decimal integer/> */ 1795 1796static void 1797write_number (unsigned HOST_WIDE_INT number, const int unsigned_p, 1798 const unsigned int base) 1799{ 1800 char buffer[sizeof (HOST_WIDE_INT) * 8]; 1801 unsigned count = 0; 1802 1803 if (!unsigned_p && (HOST_WIDE_INT) number < 0) 1804 { 1805 write_char ('n'); 1806 number = -((HOST_WIDE_INT) number); 1807 } 1808 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1); 1809 write_chars (buffer + sizeof (buffer) - count, count); 1810} 1811 1812/* Write out an integral CST in decimal. Most numbers are small, and 1813 representable in a HOST_WIDE_INT. Occasionally we'll have numbers 1814 bigger than that, which we must deal with. */ 1815 1816static inline void 1817write_integer_cst (const tree cst) 1818{ 1819 int sign = tree_int_cst_sgn (cst); 1820 widest_int abs_value = wi::abs (wi::to_widest (cst)); 1821 if (!wi::fits_uhwi_p (abs_value)) 1822 { 1823 /* A bignum. We do this in chunks, each of which fits in a 1824 HOST_WIDE_INT. */ 1825 char buffer[sizeof (HOST_WIDE_INT) * 8 * 2]; 1826 unsigned HOST_WIDE_INT chunk; 1827 unsigned chunk_digits; 1828 char *ptr = buffer + sizeof (buffer); 1829 unsigned count = 0; 1830 tree n, base, type; 1831 int done; 1832 1833 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is 1834 representable. */ 1835 chunk = 1000000000; 1836 chunk_digits = 9; 1837 1838 if (sizeof (HOST_WIDE_INT) >= 8) 1839 { 1840 /* It is at least 64 bits, so 10^18 is representable. */ 1841 chunk_digits = 18; 1842 chunk *= chunk; 1843 } 1844 1845 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst)); 1846 base = build_int_cstu (type, chunk); 1847 n = wide_int_to_tree (type, wi::to_wide (cst)); 1848 1849 if (sign < 0) 1850 { 1851 write_char ('n'); 1852 n = fold_build1_loc (input_location, NEGATE_EXPR, type, n); 1853 } 1854 do 1855 { 1856 tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base); 1857 tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base); 1858 unsigned c; 1859 1860 done = integer_zerop (d); 1861 tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp); 1862 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr, 1863 done ? 1 : chunk_digits); 1864 ptr -= c; 1865 count += c; 1866 n = d; 1867 } 1868 while (!done); 1869 write_chars (ptr, count); 1870 } 1871 else 1872 { 1873 /* A small num. */ 1874 if (sign < 0) 1875 write_char ('n'); 1876 write_unsigned_number (abs_value.to_uhwi ()); 1877 } 1878} 1879 1880/* Write out a floating-point literal. 1881 1882 "Floating-point literals are encoded using the bit pattern of the 1883 target processor's internal representation of that number, as a 1884 fixed-length lowercase hexadecimal string, high-order bytes first 1885 (even if the target processor would store low-order bytes first). 1886 The "n" prefix is not used for floating-point literals; the sign 1887 bit is encoded with the rest of the number. 1888 1889 Here are some examples, assuming the IEEE standard representation 1890 for floating point numbers. (Spaces are for readability, not 1891 part of the encoding.) 1892 1893 1.0f Lf 3f80 0000 E 1894 -1.0f Lf bf80 0000 E 1895 1.17549435e-38f Lf 0080 0000 E 1896 1.40129846e-45f Lf 0000 0001 E 1897 0.0f Lf 0000 0000 E" 1898 1899 Caller is responsible for the Lx and the E. */ 1900static void 1901write_real_cst (const tree value) 1902{ 1903 long target_real[4]; /* largest supported float */ 1904 /* Buffer for eight hex digits in a 32-bit number but big enough 1905 even for 64-bit long to avoid warnings. */ 1906 char buffer[17]; 1907 int i, limit, dir; 1908 1909 tree type = TREE_TYPE (value); 1910 int words = GET_MODE_BITSIZE (SCALAR_FLOAT_TYPE_MODE (type)) / 32; 1911 1912 real_to_target (target_real, &TREE_REAL_CST (value), 1913 TYPE_MODE (type)); 1914 1915 /* The value in target_real is in the target word order, 1916 so we must write it out backward if that happens to be 1917 little-endian. write_number cannot be used, it will 1918 produce uppercase. */ 1919 if (FLOAT_WORDS_BIG_ENDIAN) 1920 i = 0, limit = words, dir = 1; 1921 else 1922 i = words - 1, limit = -1, dir = -1; 1923 1924 for (; i != limit; i += dir) 1925 { 1926 sprintf (buffer, "%08lx", (unsigned long) target_real[i]); 1927 write_chars (buffer, 8); 1928 } 1929} 1930 1931/* Non-terminal <identifier>. 1932 1933 <identifier> ::= </unqualified source code identifier> */ 1934 1935static void 1936write_identifier (const char *identifier) 1937{ 1938 MANGLE_TRACE ("identifier", identifier); 1939 write_string (identifier); 1940} 1941 1942/* Handle constructor productions of non-terminal <special-name>. 1943 CTOR is a constructor FUNCTION_DECL. 1944 1945 <special-name> ::= C1 # complete object constructor 1946 ::= C2 # base object constructor 1947 ::= C3 # complete object allocating constructor 1948 1949 Currently, allocating constructors are never used. */ 1950 1951static void 1952write_special_name_constructor (const tree ctor) 1953{ 1954 write_char ('C'); 1955 bool new_inh = (flag_new_inheriting_ctors 1956 && DECL_INHERITED_CTOR (ctor)); 1957 if (new_inh) 1958 write_char ('I'); 1959 if (DECL_BASE_CONSTRUCTOR_P (ctor)) 1960 write_char ('2'); 1961 /* This is the old-style "[unified]" constructor. 1962 In some cases, we may emit this function and call 1963 it from the clones in order to share code and save space. */ 1964 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor)) 1965 write_char ('4'); 1966 else 1967 { 1968 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor)); 1969 write_char ('1'); 1970 } 1971 if (new_inh) 1972 write_type (DECL_INHERITED_CTOR_BASE (ctor)); 1973} 1974 1975/* Handle destructor productions of non-terminal <special-name>. 1976 DTOR is a destructor FUNCTION_DECL. 1977 1978 <special-name> ::= D0 # deleting (in-charge) destructor 1979 ::= D1 # complete object (in-charge) destructor 1980 ::= D2 # base object (not-in-charge) destructor */ 1981 1982static void 1983write_special_name_destructor (const tree dtor) 1984{ 1985 if (DECL_DELETING_DESTRUCTOR_P (dtor)) 1986 write_string ("D0"); 1987 else if (DECL_BASE_DESTRUCTOR_P (dtor)) 1988 write_string ("D2"); 1989 else if (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor)) 1990 /* This is the old-style "[unified]" destructor. 1991 In some cases, we may emit this function and call 1992 it from the clones in order to share code and save space. */ 1993 write_string ("D4"); 1994 else 1995 { 1996 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor)); 1997 write_string ("D1"); 1998 } 1999} 2000 2001/* Return the discriminator for ENTITY appearing inside 2002 FUNCTION. The discriminator is the lexical ordinal of VAR or TYPE among 2003 entities with the same name and kind in the same FUNCTION. */ 2004 2005static int 2006discriminator_for_local_entity (tree entity) 2007{ 2008 if (!DECL_LANG_SPECIFIC (entity)) 2009 { 2010 /* Some decls, like __FUNCTION__, don't need a discriminator. */ 2011 gcc_checking_assert (DECL_ARTIFICIAL (entity)); 2012 return 0; 2013 } 2014 else if (tree disc = DECL_DISCRIMINATOR (entity)) 2015 return TREE_INT_CST_LOW (disc); 2016 else 2017 /* The first entity with a particular name doesn't get 2018 DECL_DISCRIMINATOR set up. */ 2019 return 0; 2020} 2021 2022/* Return the discriminator for STRING, a string literal used inside 2023 FUNCTION. The discriminator is the lexical ordinal of STRING among 2024 string literals used in FUNCTION. */ 2025 2026static int 2027discriminator_for_string_literal (tree /*function*/, 2028 tree /*string*/) 2029{ 2030 /* For now, we don't discriminate amongst string literals. */ 2031 return 0; 2032} 2033 2034/* <discriminator> := _ <number> # when number < 10 2035 := __ <number> _ # when number >= 10 2036 2037 The discriminator is used only for the second and later occurrences 2038 of the same name within a single function. In this case <number> is 2039 n - 2, if this is the nth occurrence, in lexical order. */ 2040 2041static void 2042write_discriminator (const int discriminator) 2043{ 2044 /* If discriminator is zero, don't write anything. Otherwise... */ 2045 if (discriminator > 0) 2046 { 2047 write_char ('_'); 2048 if (discriminator - 1 >= 10) 2049 { 2050 if (abi_warn_or_compat_version_crosses (11)) 2051 G.need_abi_warning = 1; 2052 if (abi_version_at_least (11)) 2053 write_char ('_'); 2054 } 2055 write_unsigned_number (discriminator - 1); 2056 if (abi_version_at_least (11) && discriminator - 1 >= 10) 2057 write_char ('_'); 2058 } 2059} 2060 2061/* Mangle the name of a function-scope entity. FUNCTION is the 2062 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in 2063 default argument scope. ENTITY is the decl for the entity itself. 2064 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL, 2065 either ENTITY itself or an enclosing scope of ENTITY. 2066 2067 <local-name> := Z <function encoding> E <entity name> [<discriminator>] 2068 := Z <function encoding> E s [<discriminator>] 2069 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */ 2070 2071static void 2072write_local_name (tree function, const tree local_entity, 2073 const tree entity) 2074{ 2075 tree parm = NULL_TREE; 2076 2077 MANGLE_TRACE_TREE ("local-name", entity); 2078 2079 if (TREE_CODE (function) == PARM_DECL) 2080 { 2081 parm = function; 2082 function = DECL_CONTEXT (parm); 2083 } 2084 2085 write_char ('Z'); 2086 write_encoding (function); 2087 write_char ('E'); 2088 2089 /* For this purpose, parameters are numbered from right-to-left. */ 2090 if (parm) 2091 { 2092 int i = list_length (parm); 2093 write_char ('d'); 2094 write_compact_number (i - 1); 2095 } 2096 2097 if (TREE_CODE (entity) == STRING_CST) 2098 { 2099 write_char ('s'); 2100 write_discriminator (discriminator_for_string_literal (function, 2101 entity)); 2102 } 2103 else 2104 { 2105 /* Now the <entity name>. Let write_name know its being called 2106 from <local-name>, so it doesn't try to process the enclosing 2107 function scope again. */ 2108 write_name (entity, /*ignore_local_scope=*/1); 2109 if (DECL_DISCRIMINATOR_P (local_entity) 2110 && !(TREE_CODE (local_entity) == TYPE_DECL 2111 && TYPE_ANON_P (TREE_TYPE (local_entity)))) 2112 write_discriminator (discriminator_for_local_entity (local_entity)); 2113 } 2114} 2115 2116/* Non-terminals <type> and <CV-qualifier>. 2117 2118 <type> ::= <builtin-type> 2119 ::= <function-type> 2120 ::= <class-enum-type> 2121 ::= <array-type> 2122 ::= <pointer-to-member-type> 2123 ::= <template-param> 2124 ::= <substitution> 2125 ::= <CV-qualifier> 2126 ::= P <type> # pointer-to 2127 ::= R <type> # reference-to 2128 ::= C <type> # complex pair (C 2000) 2129 ::= G <type> # imaginary (C 2000) [not supported] 2130 ::= U <source-name> <type> # vendor extended type qualifier 2131 2132 C++0x extensions 2133 2134 <type> ::= RR <type> # rvalue reference-to 2135 <type> ::= Dt <expression> # decltype of an id-expression or 2136 # class member access 2137 <type> ::= DT <expression> # decltype of an expression 2138 <type> ::= Dn # decltype of nullptr 2139 2140 TYPE is a type node. */ 2141 2142static void 2143write_type (tree type) 2144{ 2145 /* This gets set to nonzero if TYPE turns out to be a (possibly 2146 CV-qualified) builtin type. */ 2147 int is_builtin_type = 0; 2148 2149 MANGLE_TRACE_TREE ("type", type); 2150 2151 if (type == error_mark_node) 2152 return; 2153 2154 type = canonicalize_for_substitution (type); 2155 if (find_substitution (type)) 2156 return; 2157 2158 2159 if (write_CV_qualifiers_for_type (type) > 0) 2160 /* If TYPE was CV-qualified, we just wrote the qualifiers; now 2161 mangle the unqualified type. The recursive call is needed here 2162 since both the qualified and unqualified types are substitution 2163 candidates. */ 2164 { 2165 tree t = TYPE_MAIN_VARIANT (type); 2166 if (TYPE_ATTRIBUTES (t) && !OVERLOAD_TYPE_P (t)) 2167 { 2168 tree attrs = NULL_TREE; 2169 if (tx_safe_fn_type_p (type)) 2170 attrs = tree_cons (get_identifier ("transaction_safe"), 2171 NULL_TREE, attrs); 2172 t = cp_build_type_attribute_variant (t, attrs); 2173 } 2174 gcc_assert (t != type); 2175 if (FUNC_OR_METHOD_TYPE_P (t)) 2176 { 2177 t = build_ref_qualified_type (t, type_memfn_rqual (type)); 2178 if (flag_noexcept_type) 2179 { 2180 tree r = TYPE_RAISES_EXCEPTIONS (type); 2181 t = build_exception_variant (t, r); 2182 } 2183 if (abi_version_at_least (8) 2184 || type == TYPE_MAIN_VARIANT (type)) 2185 /* Avoid adding the unqualified function type as a substitution. */ 2186 write_function_type (t); 2187 else 2188 write_type (t); 2189 if (abi_warn_or_compat_version_crosses (8)) 2190 G.need_abi_warning = 1; 2191 } 2192 else 2193 write_type (t); 2194 } 2195 else if (TREE_CODE (type) == ARRAY_TYPE) 2196 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here 2197 so that the cv-qualification of the element type is available 2198 in write_array_type. */ 2199 write_array_type (type); 2200 else 2201 { 2202 tree type_orig = type; 2203 2204 /* See through any typedefs. */ 2205 type = TYPE_MAIN_VARIANT (type); 2206 if (FUNC_OR_METHOD_TYPE_P (type)) 2207 type = cxx_copy_lang_qualifiers (type, type_orig); 2208 2209 /* According to the C++ ABI, some library classes are passed the 2210 same as the scalar type of their single member and use the same 2211 mangling. */ 2212 if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type)) 2213 type = TREE_TYPE (first_field (type)); 2214 2215 if (TYPE_PTRDATAMEM_P (type)) 2216 write_pointer_to_member_type (type); 2217 else 2218 { 2219 /* Handle any target-specific fundamental types. */ 2220 const char *target_mangling 2221 = targetm.mangle_type (type_orig); 2222 2223 if (target_mangling) 2224 { 2225 write_string (target_mangling); 2226 /* Add substitutions for types other than fundamental 2227 types. */ 2228 if (!VOID_TYPE_P (type) 2229 && TREE_CODE (type) != INTEGER_TYPE 2230 && TREE_CODE (type) != REAL_TYPE 2231 && TREE_CODE (type) != BOOLEAN_TYPE) 2232 add_substitution (type); 2233 return; 2234 } 2235 2236 switch (TREE_CODE (type)) 2237 { 2238 case VOID_TYPE: 2239 case BOOLEAN_TYPE: 2240 case INTEGER_TYPE: /* Includes wchar_t. */ 2241 case REAL_TYPE: 2242 case FIXED_POINT_TYPE: 2243 { 2244 /* If this is a typedef, TYPE may not be one of 2245 the standard builtin type nodes, but an alias of one. Use 2246 TYPE_MAIN_VARIANT to get to the underlying builtin type. */ 2247 write_builtin_type (TYPE_MAIN_VARIANT (type)); 2248 ++is_builtin_type; 2249 } 2250 break; 2251 2252 case COMPLEX_TYPE: 2253 write_char ('C'); 2254 write_type (TREE_TYPE (type)); 2255 break; 2256 2257 case FUNCTION_TYPE: 2258 case METHOD_TYPE: 2259 write_function_type (type); 2260 break; 2261 2262 case UNION_TYPE: 2263 case RECORD_TYPE: 2264 case ENUMERAL_TYPE: 2265 /* A pointer-to-member function is represented as a special 2266 RECORD_TYPE, so check for this first. */ 2267 if (TYPE_PTRMEMFUNC_P (type)) 2268 write_pointer_to_member_type (type); 2269 else 2270 write_class_enum_type (type); 2271 break; 2272 2273 case TYPENAME_TYPE: 2274 case UNBOUND_CLASS_TEMPLATE: 2275 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like 2276 ordinary nested names. */ 2277 write_nested_name (TYPE_STUB_DECL (type)); 2278 break; 2279 2280 case POINTER_TYPE: 2281 case REFERENCE_TYPE: 2282 if (TYPE_PTR_P (type)) 2283 write_char ('P'); 2284 else if (TYPE_REF_IS_RVALUE (type)) 2285 write_char ('O'); 2286 else 2287 write_char ('R'); 2288 { 2289 tree target = TREE_TYPE (type); 2290 /* Attribute const/noreturn are not reflected in mangling. 2291 We strip them here rather than at a lower level because 2292 a typedef or template argument can have function type 2293 with function-cv-quals (that use the same representation), 2294 but you can't have a pointer/reference to such a type. */ 2295 if (TREE_CODE (target) == FUNCTION_TYPE) 2296 { 2297 if (abi_warn_or_compat_version_crosses (5) 2298 && TYPE_QUALS (target) != TYPE_UNQUALIFIED) 2299 G.need_abi_warning = 1; 2300 if (abi_version_at_least (5)) 2301 target = build_qualified_type (target, TYPE_UNQUALIFIED); 2302 } 2303 write_type (target); 2304 } 2305 break; 2306 2307 case TEMPLATE_TYPE_PARM: 2308 if (is_auto (type)) 2309 { 2310 if (AUTO_IS_DECLTYPE (type)) 2311 write_identifier ("Dc"); 2312 else 2313 write_identifier ("Da"); 2314 ++is_builtin_type; 2315 break; 2316 } 2317 /* fall through. */ 2318 case TEMPLATE_PARM_INDEX: 2319 write_template_param (type); 2320 break; 2321 2322 case TEMPLATE_TEMPLATE_PARM: 2323 write_template_template_param (type); 2324 break; 2325 2326 case BOUND_TEMPLATE_TEMPLATE_PARM: 2327 write_template_template_param (type); 2328 write_template_args 2329 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type))); 2330 break; 2331 2332 case VECTOR_TYPE: 2333 if (abi_version_at_least (4)) 2334 { 2335 write_string ("Dv"); 2336 /* Non-constant vector size would be encoded with 2337 _ expression, but we don't support that yet. */ 2338 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type) 2339 .to_constant ()); 2340 write_char ('_'); 2341 } 2342 else 2343 write_string ("U8__vector"); 2344 if (abi_warn_or_compat_version_crosses (4)) 2345 G.need_abi_warning = 1; 2346 write_type (TREE_TYPE (type)); 2347 break; 2348 2349 case TYPE_PACK_EXPANSION: 2350 write_string ("Dp"); 2351 write_type (PACK_EXPANSION_PATTERN (type)); 2352 break; 2353 2354 case DECLTYPE_TYPE: 2355 /* These shouldn't make it into mangling. */ 2356 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type) 2357 && !DECLTYPE_FOR_LAMBDA_PROXY (type)); 2358 2359 /* In ABI <5, we stripped decltype of a plain decl. */ 2360 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)) 2361 { 2362 tree expr = DECLTYPE_TYPE_EXPR (type); 2363 tree etype = NULL_TREE; 2364 switch (TREE_CODE (expr)) 2365 { 2366 case VAR_DECL: 2367 case PARM_DECL: 2368 case RESULT_DECL: 2369 case FUNCTION_DECL: 2370 case CONST_DECL: 2371 case TEMPLATE_PARM_INDEX: 2372 etype = TREE_TYPE (expr); 2373 break; 2374 2375 default: 2376 break; 2377 } 2378 2379 if (etype && !type_uses_auto (etype)) 2380 { 2381 if (abi_warn_or_compat_version_crosses (5)) 2382 G.need_abi_warning = 1; 2383 if (!abi_version_at_least (5)) 2384 { 2385 write_type (etype); 2386 return; 2387 } 2388 } 2389 } 2390 2391 write_char ('D'); 2392 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)) 2393 write_char ('t'); 2394 else 2395 write_char ('T'); 2396 ++cp_unevaluated_operand; 2397 write_expression (DECLTYPE_TYPE_EXPR (type)); 2398 --cp_unevaluated_operand; 2399 write_char ('E'); 2400 break; 2401 2402 case NULLPTR_TYPE: 2403 write_string ("Dn"); 2404 if (abi_version_at_least (7)) 2405 ++is_builtin_type; 2406 if (abi_warn_or_compat_version_crosses (7)) 2407 G.need_abi_warning = 1; 2408 break; 2409 2410 case TYPEOF_TYPE: 2411 sorry ("mangling %<typeof%>, use %<decltype%> instead"); 2412 break; 2413 2414 case UNDERLYING_TYPE: 2415 sorry ("mangling %<__underlying_type%>"); 2416 break; 2417 2418 case LANG_TYPE: 2419 /* fall through. */ 2420 2421 default: 2422 gcc_unreachable (); 2423 } 2424 } 2425 } 2426 2427 /* Types other than builtin types are substitution candidates. */ 2428 if (!is_builtin_type) 2429 add_substitution (type); 2430} 2431 2432/* qsort callback for sorting a vector of attribute entries. */ 2433 2434static int 2435attr_strcmp (const void *p1, const void *p2) 2436{ 2437 tree a1 = *(const tree*)p1; 2438 tree a2 = *(const tree*)p2; 2439 2440 const attribute_spec *as1 = lookup_attribute_spec (get_attribute_name (a1)); 2441 const attribute_spec *as2 = lookup_attribute_spec (get_attribute_name (a2)); 2442 2443 return strcmp (as1->name, as2->name); 2444} 2445 2446/* Return true if we should mangle a type attribute with name NAME. */ 2447 2448static bool 2449mangle_type_attribute_p (tree name) 2450{ 2451 const attribute_spec *as = lookup_attribute_spec (name); 2452 if (!as || !as->affects_type_identity) 2453 return false; 2454 2455 /* Skip internal-only attributes, which are distinguished from others 2456 by having a space. At present, all internal-only attributes that 2457 affect type identity are target-specific and are handled by 2458 targetm.mangle_type instead. 2459 2460 Another reason to do this is that a space isn't a valid identifier 2461 character for most file formats. */ 2462 if (strchr (IDENTIFIER_POINTER (name), ' ')) 2463 return false; 2464 2465 /* The following attributes are mangled specially. */ 2466 if (is_attribute_p ("transaction_safe", name)) 2467 return false; 2468 if (is_attribute_p ("abi_tag", name)) 2469 return false; 2470 2471 return true; 2472} 2473 2474/* Non-terminal <CV-qualifiers> for type nodes. Returns the number of 2475 CV-qualifiers written for TYPE. 2476 2477 <CV-qualifiers> ::= [r] [V] [K] */ 2478 2479static int 2480write_CV_qualifiers_for_type (const tree type) 2481{ 2482 int num_qualifiers = 0; 2483 2484 /* The order is specified by: 2485 2486 "In cases where multiple order-insensitive qualifiers are 2487 present, they should be ordered 'K' (closest to the base type), 2488 'V', 'r', and 'U' (farthest from the base type) ..." */ 2489 2490 /* Mangle attributes that affect type identity as extended qualifiers. 2491 2492 We don't do this with classes and enums because their attributes 2493 are part of their definitions, not something added on. */ 2494 2495 if (!OVERLOAD_TYPE_P (type)) 2496 { 2497 auto_vec<tree> vec; 2498 for (tree a = TYPE_ATTRIBUTES (type); a; a = TREE_CHAIN (a)) 2499 if (mangle_type_attribute_p (get_attribute_name (a))) 2500 vec.safe_push (a); 2501 if (abi_warn_or_compat_version_crosses (10) && !vec.is_empty ()) 2502 G.need_abi_warning = true; 2503 if (abi_version_at_least (10)) 2504 { 2505 vec.qsort (attr_strcmp); 2506 while (!vec.is_empty()) 2507 { 2508 tree a = vec.pop(); 2509 const attribute_spec *as 2510 = lookup_attribute_spec (get_attribute_name (a)); 2511 2512 write_char ('U'); 2513 write_unsigned_number (strlen (as->name)); 2514 write_string (as->name); 2515 if (TREE_VALUE (a)) 2516 { 2517 write_char ('I'); 2518 for (tree args = TREE_VALUE (a); args; 2519 args = TREE_CHAIN (args)) 2520 { 2521 tree arg = TREE_VALUE (args); 2522 write_template_arg (arg); 2523 } 2524 write_char ('E'); 2525 } 2526 2527 ++num_qualifiers; 2528 } 2529 } 2530 } 2531 2532 /* Note that we do not use cp_type_quals below; given "const 2533 int[3]", the "const" is emitted with the "int", not with the 2534 array. */ 2535 cp_cv_quals quals = TYPE_QUALS (type); 2536 2537 if (quals & TYPE_QUAL_RESTRICT) 2538 { 2539 write_char ('r'); 2540 ++num_qualifiers; 2541 } 2542 if (quals & TYPE_QUAL_VOLATILE) 2543 { 2544 write_char ('V'); 2545 ++num_qualifiers; 2546 } 2547 if (quals & TYPE_QUAL_CONST) 2548 { 2549 write_char ('K'); 2550 ++num_qualifiers; 2551 } 2552 2553 return num_qualifiers; 2554} 2555 2556/* Non-terminal <builtin-type>. 2557 2558 <builtin-type> ::= v # void 2559 ::= b # bool 2560 ::= w # wchar_t 2561 ::= c # char 2562 ::= a # signed char 2563 ::= h # unsigned char 2564 ::= s # short 2565 ::= t # unsigned short 2566 ::= i # int 2567 ::= j # unsigned int 2568 ::= l # long 2569 ::= m # unsigned long 2570 ::= x # long long, __int64 2571 ::= y # unsigned long long, __int64 2572 ::= n # __int128 2573 ::= o # unsigned __int128 2574 ::= f # float 2575 ::= d # double 2576 ::= e # long double, __float80 2577 ::= g # __float128 [not supported] 2578 ::= u <source-name> # vendor extended type */ 2579 2580static void 2581write_builtin_type (tree type) 2582{ 2583 if (TYPE_CANONICAL (type)) 2584 type = TYPE_CANONICAL (type); 2585 2586 switch (TREE_CODE (type)) 2587 { 2588 case VOID_TYPE: 2589 write_char ('v'); 2590 break; 2591 2592 case BOOLEAN_TYPE: 2593 write_char ('b'); 2594 break; 2595 2596 case INTEGER_TYPE: 2597 /* TYPE may still be wchar_t, char8_t, char16_t, or char32_t, since that 2598 isn't in integer_type_nodes. */ 2599 if (type == wchar_type_node) 2600 write_char ('w'); 2601 else if (type == char8_type_node) 2602 write_string ("Du"); 2603 else if (type == char16_type_node) 2604 write_string ("Ds"); 2605 else if (type == char32_type_node) 2606 write_string ("Di"); 2607 else 2608 { 2609 size_t itk; 2610 /* Assume TYPE is one of the shared integer type nodes. Find 2611 it in the array of these nodes. */ 2612 iagain: 2613 for (itk = 0; itk < itk_none; ++itk) 2614 if (integer_types[itk] != NULL_TREE 2615 && integer_type_codes[itk] != '\0' 2616 && type == integer_types[itk]) 2617 { 2618 /* Print the corresponding single-letter code. */ 2619 write_char (integer_type_codes[itk]); 2620 break; 2621 } 2622 2623 if (itk == itk_none) 2624 { 2625 tree t = c_common_type_for_mode (TYPE_MODE (type), 2626 TYPE_UNSIGNED (type)); 2627 if (type != t) 2628 { 2629 type = t; 2630 goto iagain; 2631 } 2632 2633 if (TYPE_PRECISION (type) == 128) 2634 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n'); 2635 else 2636 { 2637 /* Allow for cases where TYPE is not one of the shared 2638 integer type nodes and write a "vendor extended builtin 2639 type" with a name the form intN or uintN, respectively. 2640 Situations like this can happen if you have an 2641 __attribute__((__mode__(__SI__))) type and use exotic 2642 switches like '-mint8' on AVR. Of course, this is 2643 undefined by the C++ ABI (and '-mint8' is not even 2644 Standard C conforming), but when using such special 2645 options you're pretty much in nowhere land anyway. */ 2646 const char *prefix; 2647 char prec[11]; /* up to ten digits for an unsigned */ 2648 2649 prefix = TYPE_UNSIGNED (type) ? "uint" : "int"; 2650 sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type)); 2651 write_char ('u'); /* "vendor extended builtin type" */ 2652 write_unsigned_number (strlen (prefix) + strlen (prec)); 2653 write_string (prefix); 2654 write_string (prec); 2655 } 2656 } 2657 } 2658 break; 2659 2660 case REAL_TYPE: 2661 if (type == float_type_node) 2662 write_char ('f'); 2663 else if (type == double_type_node) 2664 write_char ('d'); 2665 else if (type == long_double_type_node) 2666 write_char ('e'); 2667 else if (type == dfloat32_type_node || type == fallback_dfloat32_type) 2668 write_string ("Df"); 2669 else if (type == dfloat64_type_node || type == fallback_dfloat64_type) 2670 write_string ("Dd"); 2671 else if (type == dfloat128_type_node || type == fallback_dfloat128_type) 2672 write_string ("De"); 2673 else 2674 gcc_unreachable (); 2675 break; 2676 2677 case FIXED_POINT_TYPE: 2678 write_string ("DF"); 2679 if (GET_MODE_IBIT (TYPE_MODE (type)) > 0) 2680 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type))); 2681 if (type == fract_type_node 2682 || type == sat_fract_type_node 2683 || type == accum_type_node 2684 || type == sat_accum_type_node) 2685 write_char ('i'); 2686 else if (type == unsigned_fract_type_node 2687 || type == sat_unsigned_fract_type_node 2688 || type == unsigned_accum_type_node 2689 || type == sat_unsigned_accum_type_node) 2690 write_char ('j'); 2691 else if (type == short_fract_type_node 2692 || type == sat_short_fract_type_node 2693 || type == short_accum_type_node 2694 || type == sat_short_accum_type_node) 2695 write_char ('s'); 2696 else if (type == unsigned_short_fract_type_node 2697 || type == sat_unsigned_short_fract_type_node 2698 || type == unsigned_short_accum_type_node 2699 || type == sat_unsigned_short_accum_type_node) 2700 write_char ('t'); 2701 else if (type == long_fract_type_node 2702 || type == sat_long_fract_type_node 2703 || type == long_accum_type_node 2704 || type == sat_long_accum_type_node) 2705 write_char ('l'); 2706 else if (type == unsigned_long_fract_type_node 2707 || type == sat_unsigned_long_fract_type_node 2708 || type == unsigned_long_accum_type_node 2709 || type == sat_unsigned_long_accum_type_node) 2710 write_char ('m'); 2711 else if (type == long_long_fract_type_node 2712 || type == sat_long_long_fract_type_node 2713 || type == long_long_accum_type_node 2714 || type == sat_long_long_accum_type_node) 2715 write_char ('x'); 2716 else if (type == unsigned_long_long_fract_type_node 2717 || type == sat_unsigned_long_long_fract_type_node 2718 || type == unsigned_long_long_accum_type_node 2719 || type == sat_unsigned_long_long_accum_type_node) 2720 write_char ('y'); 2721 else 2722 sorry ("mangling unknown fixed point type"); 2723 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type))); 2724 if (TYPE_SATURATING (type)) 2725 write_char ('s'); 2726 else 2727 write_char ('n'); 2728 break; 2729 2730 default: 2731 gcc_unreachable (); 2732 } 2733} 2734 2735/* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or 2736 METHOD_TYPE. The return type is mangled before the parameter 2737 types. 2738 2739 <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E */ 2740 2741static void 2742write_function_type (const tree type) 2743{ 2744 MANGLE_TRACE_TREE ("function-type", type); 2745 2746 /* For a pointer to member function, the function type may have 2747 cv-qualifiers, indicating the quals for the artificial 'this' 2748 parameter. */ 2749 if (TREE_CODE (type) == METHOD_TYPE) 2750 { 2751 /* The first parameter must be a POINTER_TYPE pointing to the 2752 `this' parameter. */ 2753 tree this_type = class_of_this_parm (type); 2754 write_CV_qualifiers_for_type (this_type); 2755 } 2756 2757 write_exception_spec (TYPE_RAISES_EXCEPTIONS (type)); 2758 2759 if (tx_safe_fn_type_p (type)) 2760 write_string ("Dx"); 2761 2762 write_char ('F'); 2763 /* We don't track whether or not a type is `extern "C"'. Note that 2764 you can have an `extern "C"' function that does not have 2765 `extern "C"' type, and vice versa: 2766 2767 extern "C" typedef void function_t(); 2768 function_t f; // f has C++ linkage, but its type is 2769 // `extern "C"' 2770 2771 typedef void function_t(); 2772 extern "C" function_t f; // Vice versa. 2773 2774 See [dcl.link]. */ 2775 write_bare_function_type (type, /*include_return_type_p=*/1, 2776 /*decl=*/NULL); 2777 if (FUNCTION_REF_QUALIFIED (type)) 2778 { 2779 if (FUNCTION_RVALUE_QUALIFIED (type)) 2780 write_char ('O'); 2781 else 2782 write_char ('R'); 2783 } 2784 write_char ('E'); 2785} 2786 2787/* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or 2788 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value 2789 is mangled before the parameter types. If non-NULL, DECL is 2790 FUNCTION_DECL for the function whose type is being emitted. */ 2791 2792static void 2793write_bare_function_type (const tree type, const int include_return_type_p, 2794 const tree decl) 2795{ 2796 MANGLE_TRACE_TREE ("bare-function-type", type); 2797 2798 /* Mangle the return type, if requested. */ 2799 if (include_return_type_p) 2800 write_type (TREE_TYPE (type)); 2801 2802 /* Now mangle the types of the arguments. */ 2803 ++G.parm_depth; 2804 write_method_parms (TYPE_ARG_TYPES (type), 2805 TREE_CODE (type) == METHOD_TYPE, 2806 decl); 2807 --G.parm_depth; 2808} 2809 2810/* Write the mangled representation of a method parameter list of 2811 types given in PARM_TYPES. If METHOD_P is nonzero, the function is 2812 considered a non-static method, and the this parameter is omitted. 2813 If non-NULL, DECL is the FUNCTION_DECL for the function whose 2814 parameters are being emitted. */ 2815 2816static void 2817write_method_parms (tree parm_types, const int method_p, const tree decl) 2818{ 2819 tree first_parm_type; 2820 tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE; 2821 2822 /* Assume this parameter type list is variable-length. If it ends 2823 with a void type, then it's not. */ 2824 int varargs_p = 1; 2825 2826 /* If this is a member function, skip the first arg, which is the 2827 this pointer. 2828 "Member functions do not encode the type of their implicit this 2829 parameter." 2830 2831 Similarly, there's no need to mangle artificial parameters, like 2832 the VTT parameters for constructors and destructors. */ 2833 if (method_p) 2834 { 2835 parm_types = TREE_CHAIN (parm_types); 2836 parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE; 2837 2838 while (parm_decl && DECL_ARTIFICIAL (parm_decl)) 2839 { 2840 parm_types = TREE_CHAIN (parm_types); 2841 parm_decl = DECL_CHAIN (parm_decl); 2842 } 2843 2844 if (decl && ctor_omit_inherited_parms (decl)) 2845 /* Bring back parameters omitted from an inherited ctor. */ 2846 parm_types = FUNCTION_FIRST_USER_PARMTYPE (DECL_ORIGIN (decl)); 2847 } 2848 2849 for (first_parm_type = parm_types; 2850 parm_types; 2851 parm_types = TREE_CHAIN (parm_types)) 2852 { 2853 tree parm = TREE_VALUE (parm_types); 2854 if (parm == void_type_node) 2855 { 2856 /* "Empty parameter lists, whether declared as () or 2857 conventionally as (void), are encoded with a void parameter 2858 (v)." */ 2859 if (parm_types == first_parm_type) 2860 write_type (parm); 2861 /* If the parm list is terminated with a void type, it's 2862 fixed-length. */ 2863 varargs_p = 0; 2864 /* A void type better be the last one. */ 2865 gcc_assert (TREE_CHAIN (parm_types) == NULL); 2866 } 2867 else 2868 write_type (parm); 2869 } 2870 2871 if (varargs_p) 2872 /* <builtin-type> ::= z # ellipsis */ 2873 write_char ('z'); 2874} 2875 2876/* <class-enum-type> ::= <name> */ 2877 2878static void 2879write_class_enum_type (const tree type) 2880{ 2881 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0); 2882} 2883 2884/* Non-terminal <template-args>. ARGS is a TREE_VEC of template 2885 arguments. 2886 2887 <template-args> ::= I <template-arg>* E */ 2888 2889static void 2890write_template_args (tree args) 2891{ 2892 int i; 2893 int length = 0; 2894 2895 MANGLE_TRACE_TREE ("template-args", args); 2896 2897 write_char ('I'); 2898 2899 if (args) 2900 length = TREE_VEC_LENGTH (args); 2901 2902 if (args && length && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC) 2903 { 2904 /* We have nested template args. We want the innermost template 2905 argument list. */ 2906 args = TREE_VEC_ELT (args, length - 1); 2907 length = TREE_VEC_LENGTH (args); 2908 } 2909 for (i = 0; i < length; ++i) 2910 write_template_arg (TREE_VEC_ELT (args, i)); 2911 2912 write_char ('E'); 2913} 2914 2915/* Write out the 2916 <unqualified-name> 2917 <unqualified-name> <template-args> 2918 part of SCOPE_REF or COMPONENT_REF mangling. */ 2919 2920static void 2921write_member_name (tree member) 2922{ 2923 if (identifier_p (member)) 2924 { 2925 if (IDENTIFIER_ANY_OP_P (member)) 2926 { 2927 if (abi_version_at_least (11)) 2928 write_string ("on"); 2929 if (abi_warn_or_compat_version_crosses (11)) 2930 G.need_abi_warning = 1; 2931 } 2932 write_unqualified_id (member); 2933 } 2934 else if (DECL_P (member)) 2935 { 2936 gcc_assert (!DECL_OVERLOADED_OPERATOR_P (member)); 2937 write_unqualified_name (member); 2938 } 2939 else if (TREE_CODE (member) == TEMPLATE_ID_EXPR) 2940 { 2941 tree name = TREE_OPERAND (member, 0); 2942 name = OVL_FIRST (name); 2943 write_member_name (name); 2944 write_template_args (TREE_OPERAND (member, 1)); 2945 } 2946 else 2947 write_expression (member); 2948} 2949 2950/* EXPR is a base COMPONENT_REF; write the minimized base conversion path for 2951 converting to BASE, or just the conversion of EXPR if BASE is null. 2952 2953 "Given a fully explicit base path P := C_n -> ... -> C_0, the minimized base 2954 path Min(P) is defined as follows: let C_i be the last element for which the 2955 conversion to C_0 is unambiguous; if that element is C_n, the minimized path 2956 is C_n -> C_0; otherwise, the minimized path is Min(C_n -> ... -> C_i) -> 2957 C_0." 2958 2959 We mangle the conversion to C_i if it's different from C_n. */ 2960 2961static bool 2962write_base_ref (tree expr, tree base = NULL_TREE) 2963{ 2964 if (TREE_CODE (expr) != COMPONENT_REF) 2965 return false; 2966 2967 tree field = TREE_OPERAND (expr, 1); 2968 2969 if (TREE_CODE (field) != FIELD_DECL || !DECL_FIELD_IS_BASE (field)) 2970 return false; 2971 2972 tree object = TREE_OPERAND (expr, 0); 2973 2974 tree binfo = NULL_TREE; 2975 if (base) 2976 { 2977 tree cur = TREE_TYPE (object); 2978 binfo = lookup_base (cur, base, ba_unique, NULL, tf_none); 2979 } 2980 else 2981 /* We're at the end of the base conversion chain, so it can't be 2982 ambiguous. */ 2983 base = TREE_TYPE (field); 2984 2985 if (binfo == error_mark_node) 2986 { 2987 /* cur->base is ambiguous, so make the conversion to 2988 last explicit, expressed as a cast (last&)object. */ 2989 tree last = TREE_TYPE (expr); 2990 write_string (OVL_OP_INFO (false, CAST_EXPR)->mangled_name); 2991 write_type (build_reference_type (last)); 2992 write_expression (object); 2993 } 2994 else if (write_base_ref (object, base)) 2995 /* cur->base is unambiguous, but we had another base conversion 2996 underneath and wrote it out. */; 2997 else 2998 /* No more base conversions, just write out the object. */ 2999 write_expression (object); 3000 3001 return true; 3002} 3003 3004/* The number of elements spanned by a RANGE_EXPR. */ 3005 3006unsigned HOST_WIDE_INT 3007range_expr_nelts (tree expr) 3008{ 3009 tree lo = TREE_OPERAND (expr, 0); 3010 tree hi = TREE_OPERAND (expr, 1); 3011 return tree_to_uhwi (hi) - tree_to_uhwi (lo) + 1; 3012} 3013 3014/* <expression> ::= <unary operator-name> <expression> 3015 ::= <binary operator-name> <expression> <expression> 3016 ::= <expr-primary> 3017 3018 <expr-primary> ::= <template-param> 3019 ::= L <type> <value number> E # literal 3020 ::= L <mangled-name> E # external name 3021 ::= st <type> # sizeof 3022 ::= sr <type> <unqualified-name> # dependent name 3023 ::= sr <type> <unqualified-name> <template-args> */ 3024 3025static void 3026write_expression (tree expr) 3027{ 3028 enum tree_code code = TREE_CODE (expr); 3029 3030 if (TREE_CODE (expr) == TARGET_EXPR) 3031 { 3032 expr = TARGET_EXPR_INITIAL (expr); 3033 code = TREE_CODE (expr); 3034 } 3035 3036 /* Skip NOP_EXPR and CONVERT_EXPR. They can occur when (say) a pointer 3037 argument is converted (via qualification conversions) to another type. */ 3038 while (CONVERT_EXPR_CODE_P (code) 3039 || code == IMPLICIT_CONV_EXPR 3040 || location_wrapper_p (expr) 3041 /* Parentheses aren't mangled. */ 3042 || code == PAREN_EXPR 3043 || code == NON_LVALUE_EXPR 3044 || (code == VIEW_CONVERT_EXPR 3045 && TREE_CODE (TREE_OPERAND (expr, 0)) == TEMPLATE_PARM_INDEX)) 3046 { 3047 expr = TREE_OPERAND (expr, 0); 3048 code = TREE_CODE (expr); 3049 } 3050 3051 if (code == BASELINK 3052 && (!type_unknown_p (expr) 3053 || !BASELINK_QUALIFIED_P (expr))) 3054 { 3055 expr = BASELINK_FUNCTIONS (expr); 3056 code = TREE_CODE (expr); 3057 } 3058 3059 /* Handle pointers-to-members by making them look like expression 3060 nodes. */ 3061 if (code == PTRMEM_CST) 3062 { 3063 expr = build_nt (ADDR_EXPR, 3064 build_qualified_name (/*type=*/NULL_TREE, 3065 PTRMEM_CST_CLASS (expr), 3066 PTRMEM_CST_MEMBER (expr), 3067 /*template_p=*/false)); 3068 code = TREE_CODE (expr); 3069 } 3070 3071 /* Handle template parameters. */ 3072 if (code == TEMPLATE_TYPE_PARM 3073 || code == TEMPLATE_TEMPLATE_PARM 3074 || code == BOUND_TEMPLATE_TEMPLATE_PARM 3075 || code == TEMPLATE_PARM_INDEX) 3076 write_template_param (expr); 3077 /* Handle literals. */ 3078 else if (TREE_CODE_CLASS (code) == tcc_constant 3079 || code == CONST_DECL) 3080 write_template_arg_literal (expr); 3081 else if (code == PARM_DECL && DECL_ARTIFICIAL (expr)) 3082 { 3083 gcc_assert (id_equal (DECL_NAME (expr), "this")); 3084 write_string ("fpT"); 3085 } 3086 else if (code == PARM_DECL) 3087 { 3088 /* A function parameter used in a late-specified return type. */ 3089 int index = DECL_PARM_INDEX (expr); 3090 int level = DECL_PARM_LEVEL (expr); 3091 int delta = G.parm_depth - level + 1; 3092 gcc_assert (index >= 1); 3093 write_char ('f'); 3094 if (delta != 0) 3095 { 3096 if (abi_version_at_least (5)) 3097 { 3098 /* Let L be the number of function prototype scopes from the 3099 innermost one (in which the parameter reference occurs) up 3100 to (and including) the one containing the declaration of 3101 the referenced parameter. If the parameter declaration 3102 clause of the innermost function prototype scope has been 3103 completely seen, it is not counted (in that case -- which 3104 is perhaps the most common -- L can be zero). */ 3105 write_char ('L'); 3106 write_unsigned_number (delta - 1); 3107 } 3108 if (abi_warn_or_compat_version_crosses (5)) 3109 G.need_abi_warning = true; 3110 } 3111 write_char ('p'); 3112 write_compact_number (index - 1); 3113 } 3114 else if (DECL_P (expr)) 3115 { 3116 write_char ('L'); 3117 write_mangled_name (expr, false); 3118 write_char ('E'); 3119 } 3120 else if (TREE_CODE (expr) == SIZEOF_EXPR) 3121 { 3122 tree op = TREE_OPERAND (expr, 0); 3123 3124 if (PACK_EXPANSION_P (op)) 3125 { 3126 if (abi_warn_or_compat_version_crosses (11)) 3127 G.need_abi_warning = true; 3128 if (abi_version_at_least (11)) 3129 { 3130 /* sZ rather than szDp. */ 3131 write_string ("sZ"); 3132 write_expression (PACK_EXPANSION_PATTERN (op)); 3133 return; 3134 } 3135 } 3136 3137 if (SIZEOF_EXPR_TYPE_P (expr)) 3138 { 3139 write_string ("st"); 3140 write_type (TREE_TYPE (op)); 3141 } 3142 else if (ARGUMENT_PACK_P (op)) 3143 { 3144 tree args = ARGUMENT_PACK_ARGS (op); 3145 int length = TREE_VEC_LENGTH (args); 3146 if (abi_warn_or_compat_version_crosses (10)) 3147 G.need_abi_warning = true; 3148 if (abi_version_at_least (10)) 3149 { 3150 /* sP <template-arg>* E # sizeof...(T), size of a captured 3151 template parameter pack from an alias template */ 3152 write_string ("sP"); 3153 for (int i = 0; i < length; ++i) 3154 write_template_arg (TREE_VEC_ELT (args, i)); 3155 write_char ('E'); 3156 } 3157 else 3158 { 3159 /* In GCC 5 we represented this sizeof wrong, with the effect 3160 that we mangled it as the last element of the pack. */ 3161 tree arg = TREE_VEC_ELT (args, length-1); 3162 if (TYPE_P (op)) 3163 { 3164 write_string ("st"); 3165 write_type (arg); 3166 } 3167 else 3168 { 3169 write_string ("sz"); 3170 write_expression (arg); 3171 } 3172 } 3173 } 3174 else if (TYPE_P (TREE_OPERAND (expr, 0))) 3175 { 3176 write_string ("st"); 3177 write_type (TREE_OPERAND (expr, 0)); 3178 } 3179 else 3180 goto normal_expr; 3181 } 3182 else if (TREE_CODE (expr) == ALIGNOF_EXPR) 3183 { 3184 if (!ALIGNOF_EXPR_STD_P (expr)) 3185 { 3186 if (abi_warn_or_compat_version_crosses (16)) 3187 G.need_abi_warning = true; 3188 if (abi_version_at_least (16)) 3189 { 3190 /* We used to mangle __alignof__ like alignof. */ 3191 write_string ("u11__alignof__"); 3192 write_template_arg (TREE_OPERAND (expr, 0)); 3193 write_char ('E'); 3194 return; 3195 } 3196 } 3197 if (TYPE_P (TREE_OPERAND (expr, 0))) 3198 { 3199 write_string ("at"); 3200 write_type (TREE_OPERAND (expr, 0)); 3201 } 3202 else 3203 goto normal_expr; 3204 } 3205 else if (code == SCOPE_REF 3206 || code == BASELINK) 3207 { 3208 tree scope, member; 3209 if (code == SCOPE_REF) 3210 { 3211 scope = TREE_OPERAND (expr, 0); 3212 member = TREE_OPERAND (expr, 1); 3213 if (BASELINK_P (member)) 3214 member = BASELINK_FUNCTIONS (member); 3215 } 3216 else 3217 { 3218 scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr)); 3219 member = BASELINK_FUNCTIONS (expr); 3220 } 3221 3222 /* If the MEMBER is a real declaration, then the qualifying 3223 scope was not dependent. Ideally, we would not have a 3224 SCOPE_REF in those cases, but sometimes we do. If the second 3225 argument is a DECL, then the name must not have been 3226 dependent. */ 3227 if (DECL_P (member)) 3228 write_expression (member); 3229 else 3230 { 3231 gcc_assert (code != BASELINK || BASELINK_QUALIFIED_P (expr)); 3232 write_string ("sr"); 3233 write_type (scope); 3234 write_member_name (member); 3235 } 3236 } 3237 else if (INDIRECT_REF_P (expr) 3238 && TREE_TYPE (TREE_OPERAND (expr, 0)) 3239 && TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0)))) 3240 { 3241 write_expression (TREE_OPERAND (expr, 0)); 3242 } 3243 else if (identifier_p (expr)) 3244 { 3245 /* An operator name appearing as a dependent name needs to be 3246 specially marked to disambiguate between a use of the operator 3247 name and a use of the operator in an expression. */ 3248 if (IDENTIFIER_ANY_OP_P (expr)) 3249 write_string ("on"); 3250 write_unqualified_id (expr); 3251 } 3252 else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR) 3253 { 3254 tree fn = TREE_OPERAND (expr, 0); 3255 fn = OVL_NAME (fn); 3256 if (IDENTIFIER_ANY_OP_P (fn)) 3257 write_string ("on"); 3258 write_unqualified_id (fn); 3259 write_template_args (TREE_OPERAND (expr, 1)); 3260 } 3261 else if (TREE_CODE (expr) == MODOP_EXPR) 3262 { 3263 enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1)); 3264 const char *name = OVL_OP_INFO (true, subop)->mangled_name; 3265 3266 write_string (name); 3267 write_expression (TREE_OPERAND (expr, 0)); 3268 write_expression (TREE_OPERAND (expr, 2)); 3269 } 3270 else if (code == NEW_EXPR || code == VEC_NEW_EXPR) 3271 { 3272 /* ::= [gs] nw <expression>* _ <type> E 3273 ::= [gs] nw <expression>* _ <type> <initializer> 3274 ::= [gs] na <expression>* _ <type> E 3275 ::= [gs] na <expression>* _ <type> <initializer> 3276 <initializer> ::= pi <expression>* E */ 3277 tree placement = TREE_OPERAND (expr, 0); 3278 tree type = TREE_OPERAND (expr, 1); 3279 tree nelts = TREE_OPERAND (expr, 2); 3280 tree init = TREE_OPERAND (expr, 3); 3281 tree t; 3282 3283 gcc_assert (code == NEW_EXPR); 3284 if (TREE_OPERAND (expr, 2)) 3285 code = VEC_NEW_EXPR; 3286 3287 if (NEW_EXPR_USE_GLOBAL (expr)) 3288 write_string ("gs"); 3289 3290 write_string (OVL_OP_INFO (false, code)->mangled_name); 3291 3292 for (t = placement; t; t = TREE_CHAIN (t)) 3293 write_expression (TREE_VALUE (t)); 3294 3295 write_char ('_'); 3296 3297 if (nelts) 3298 { 3299 tree domain; 3300 ++processing_template_decl; 3301 domain = compute_array_index_type (NULL_TREE, nelts, 3302 tf_warning_or_error); 3303 type = build_cplus_array_type (type, domain); 3304 --processing_template_decl; 3305 } 3306 write_type (type); 3307 3308 if (init && TREE_CODE (init) == TREE_LIST 3309 && DIRECT_LIST_INIT_P (TREE_VALUE (init))) 3310 write_expression (TREE_VALUE (init)); 3311 else 3312 { 3313 if (init) 3314 write_string ("pi"); 3315 if (init && init != void_node) 3316 for (t = init; t; t = TREE_CHAIN (t)) 3317 write_expression (TREE_VALUE (t)); 3318 write_char ('E'); 3319 } 3320 } 3321 else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR) 3322 { 3323 gcc_assert (code == DELETE_EXPR); 3324 if (DELETE_EXPR_USE_VEC (expr)) 3325 code = VEC_DELETE_EXPR; 3326 3327 if (DELETE_EXPR_USE_GLOBAL (expr)) 3328 write_string ("gs"); 3329 3330 write_string (OVL_OP_INFO (false, code)->mangled_name); 3331 3332 write_expression (TREE_OPERAND (expr, 0)); 3333 } 3334 else if (code == THROW_EXPR) 3335 { 3336 tree op = TREE_OPERAND (expr, 0); 3337 if (op) 3338 { 3339 write_string ("tw"); 3340 write_expression (op); 3341 } 3342 else 3343 write_string ("tr"); 3344 } 3345 else if (code == CONSTRUCTOR) 3346 { 3347 bool braced_init = BRACE_ENCLOSED_INITIALIZER_P (expr); 3348 tree etype = TREE_TYPE (expr); 3349 3350 if (braced_init) 3351 write_string ("il"); 3352 else 3353 { 3354 write_string ("tl"); 3355 write_type (etype); 3356 } 3357 3358 /* If this is an undigested initializer, mangle it as written. 3359 COMPOUND_LITERAL_P doesn't actually distinguish between digested and 3360 undigested braced casts, but it should work to use it to distinguish 3361 between braced casts in a template signature (undigested) and template 3362 parm object values (digested), and all CONSTRUCTORS that get here 3363 should be one of those two cases. */ 3364 bool undigested = braced_init || COMPOUND_LITERAL_P (expr); 3365 if (undigested || !zero_init_expr_p (expr)) 3366 { 3367 /* Convert braced initializer lists to STRING_CSTs so that 3368 A<"Foo"> mangles the same as A<{'F', 'o', 'o', 0}> while 3369 still using the latter mangling for strings that 3370 originated as braced initializer lists. */ 3371 expr = braced_lists_to_strings (etype, expr); 3372 3373 if (TREE_CODE (expr) == CONSTRUCTOR) 3374 { 3375 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (expr); 3376 unsigned last_nonzero = UINT_MAX; 3377 constructor_elt *ce; 3378 3379 if (!undigested) 3380 for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i) 3381 if ((TREE_CODE (etype) == UNION_TYPE 3382 && ce->index != first_field (etype)) 3383 || !zero_init_expr_p (ce->value)) 3384 last_nonzero = i; 3385 3386 if (undigested || last_nonzero != UINT_MAX) 3387 for (HOST_WIDE_INT i = 0; vec_safe_iterate (elts, i, &ce); ++i) 3388 { 3389 if (i > last_nonzero) 3390 break; 3391 if (!undigested && TREE_CODE (etype) == UNION_TYPE) 3392 { 3393 /* Express the active member as a designator. */ 3394 write_string ("di"); 3395 write_unqualified_name (ce->index); 3396 } 3397 unsigned reps = 1; 3398 if (ce->index && TREE_CODE (ce->index) == RANGE_EXPR) 3399 reps = range_expr_nelts (ce->index); 3400 for (unsigned j = 0; j < reps; ++j) 3401 write_expression (ce->value); 3402 } 3403 } 3404 else 3405 { 3406 gcc_assert (TREE_CODE (expr) == STRING_CST); 3407 write_expression (expr); 3408 } 3409 } 3410 write_char ('E'); 3411 } 3412 else if (code == LAMBDA_EXPR) 3413 { 3414 /* [temp.over.link] Two lambda-expressions are never considered 3415 equivalent. 3416 3417 So just use the closure type mangling. */ 3418 write_string ("tl"); 3419 write_type (LAMBDA_EXPR_CLOSURE (expr)); 3420 write_char ('E'); 3421 } 3422 else if (dependent_name (expr)) 3423 { 3424 tree name = dependent_name (expr); 3425 if (IDENTIFIER_ANY_OP_P (name)) 3426 { 3427 if (abi_version_at_least (16)) 3428 write_string ("on"); 3429 if (abi_warn_or_compat_version_crosses (16)) 3430 G.need_abi_warning = 1; 3431 } 3432 write_unqualified_id (name); 3433 } 3434 else 3435 { 3436 normal_expr: 3437 int i, len; 3438 const char *name; 3439 3440 /* When we bind a variable or function to a non-type template 3441 argument with reference type, we create an ADDR_EXPR to show 3442 the fact that the entity's address has been taken. But, we 3443 don't actually want to output a mangling code for the `&'. */ 3444 if (TREE_CODE (expr) == ADDR_EXPR 3445 && TREE_TYPE (expr) 3446 && TYPE_REF_P (TREE_TYPE (expr))) 3447 { 3448 expr = TREE_OPERAND (expr, 0); 3449 if (DECL_P (expr)) 3450 { 3451 write_expression (expr); 3452 return; 3453 } 3454 3455 code = TREE_CODE (expr); 3456 } 3457 3458 if (code == COMPONENT_REF) 3459 { 3460 tree ob = TREE_OPERAND (expr, 0); 3461 3462 if (TREE_CODE (ob) == ARROW_EXPR) 3463 { 3464 write_string (OVL_OP_INFO (false, code)->mangled_name); 3465 ob = TREE_OPERAND (ob, 0); 3466 write_expression (ob); 3467 } 3468 else if (write_base_ref (expr)) 3469 return; 3470 else if (!is_dummy_object (ob)) 3471 { 3472 write_string ("dt"); 3473 write_expression (ob); 3474 } 3475 /* else, for a non-static data member with no associated object (in 3476 unevaluated context), use the unresolved-name mangling. */ 3477 3478 write_member_name (TREE_OPERAND (expr, 1)); 3479 return; 3480 } 3481 3482 /* If it wasn't any of those, recursively expand the expression. */ 3483 name = OVL_OP_INFO (false, code)->mangled_name; 3484 3485 /* We used to mangle const_cast and static_cast like a C cast. */ 3486 if (code == CONST_CAST_EXPR 3487 || code == STATIC_CAST_EXPR) 3488 { 3489 if (abi_warn_or_compat_version_crosses (6)) 3490 G.need_abi_warning = 1; 3491 if (!abi_version_at_least (6)) 3492 name = OVL_OP_INFO (false, CAST_EXPR)->mangled_name; 3493 } 3494 3495 if (name == NULL) 3496 { 3497 switch (code) 3498 { 3499 case TRAIT_EXPR: 3500 error ("use of built-in trait %qE in function signature; " 3501 "use library traits instead", expr); 3502 break; 3503 3504 default: 3505 sorry ("mangling %C", code); 3506 break; 3507 } 3508 return; 3509 } 3510 else 3511 write_string (name); 3512 3513 switch (code) 3514 { 3515 case CALL_EXPR: 3516 { 3517 tree fn = CALL_EXPR_FN (expr); 3518 3519 if (TREE_CODE (fn) == ADDR_EXPR) 3520 fn = TREE_OPERAND (fn, 0); 3521 3522 /* Mangle a dependent name as the name, not whatever happens to 3523 be the first function in the overload set. */ 3524 if (OVL_P (fn) 3525 && type_dependent_expression_p_push (expr)) 3526 fn = OVL_NAME (fn); 3527 3528 write_expression (fn); 3529 } 3530 3531 for (i = 0; i < call_expr_nargs (expr); ++i) 3532 write_expression (CALL_EXPR_ARG (expr, i)); 3533 write_char ('E'); 3534 break; 3535 3536 case CAST_EXPR: 3537 write_type (TREE_TYPE (expr)); 3538 if (list_length (TREE_OPERAND (expr, 0)) == 1) 3539 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0))); 3540 else 3541 { 3542 tree args = TREE_OPERAND (expr, 0); 3543 write_char ('_'); 3544 for (; args; args = TREE_CHAIN (args)) 3545 write_expression (TREE_VALUE (args)); 3546 write_char ('E'); 3547 } 3548 break; 3549 3550 case DYNAMIC_CAST_EXPR: 3551 case REINTERPRET_CAST_EXPR: 3552 case STATIC_CAST_EXPR: 3553 case CONST_CAST_EXPR: 3554 write_type (TREE_TYPE (expr)); 3555 write_expression (TREE_OPERAND (expr, 0)); 3556 break; 3557 3558 case PREINCREMENT_EXPR: 3559 case PREDECREMENT_EXPR: 3560 if (abi_version_at_least (6)) 3561 write_char ('_'); 3562 if (abi_warn_or_compat_version_crosses (6)) 3563 G.need_abi_warning = 1; 3564 /* Fall through. */ 3565 3566 default: 3567 /* In the middle-end, some expressions have more operands than 3568 they do in templates (and mangling). */ 3569 len = cp_tree_operand_length (expr); 3570 3571 for (i = 0; i < len; ++i) 3572 { 3573 tree operand = TREE_OPERAND (expr, i); 3574 /* As a GNU extension, the middle operand of a 3575 conditional may be omitted. Since expression 3576 manglings are supposed to represent the input token 3577 stream, there's no good way to mangle such an 3578 expression without extending the C++ ABI. */ 3579 if (code == COND_EXPR && i == 1 && !operand) 3580 { 3581 error ("omitted middle operand to %<?:%> operand " 3582 "cannot be mangled"); 3583 continue; 3584 } 3585 else if (FOLD_EXPR_P (expr)) 3586 { 3587 /* The first 'operand' of a fold-expression is the operator 3588 that it folds over. */ 3589 if (i == 0) 3590 { 3591 int fcode = TREE_INT_CST_LOW (operand); 3592 write_string (OVL_OP_INFO (false, fcode)->mangled_name); 3593 continue; 3594 } 3595 else if (code == BINARY_LEFT_FOLD_EXPR) 3596 { 3597 /* The order of operands of the binary left and right 3598 folds is the same, but we want to mangle them in 3599 lexical order, i.e. non-pack first. */ 3600 if (i == 1) 3601 operand = FOLD_EXPR_INIT (expr); 3602 else 3603 operand = FOLD_EXPR_PACK (expr); 3604 } 3605 if (PACK_EXPANSION_P (operand)) 3606 operand = PACK_EXPANSION_PATTERN (operand); 3607 } 3608 write_expression (operand); 3609 } 3610 } 3611 } 3612} 3613 3614/* Literal subcase of non-terminal <template-arg>. 3615 3616 "Literal arguments, e.g. "A<42L>", are encoded with their type 3617 and value. Negative integer values are preceded with "n"; for 3618 example, "A<-42L>" becomes "1AILln42EE". The bool value false is 3619 encoded as 0, true as 1." */ 3620 3621static void 3622write_template_arg_literal (const tree value) 3623{ 3624 if (TREE_CODE (value) == STRING_CST) 3625 /* Temporarily mangle strings as braced initializer lists. */ 3626 write_string ("tl"); 3627 else 3628 write_char ('L'); 3629 3630 tree valtype = TREE_TYPE (value); 3631 write_type (valtype); 3632 3633 /* Write a null member pointer value as (type)0, regardless of its 3634 real representation. */ 3635 if (null_member_pointer_value_p (value)) 3636 write_integer_cst (integer_zero_node); 3637 else 3638 switch (TREE_CODE (value)) 3639 { 3640 case CONST_DECL: 3641 write_integer_cst (DECL_INITIAL (value)); 3642 break; 3643 3644 case INTEGER_CST: 3645 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node) 3646 || integer_zerop (value) || integer_onep (value)); 3647 if (!(abi_version_at_least (14) 3648 && NULLPTR_TYPE_P (TREE_TYPE (value)))) 3649 write_integer_cst (value); 3650 break; 3651 3652 case REAL_CST: 3653 write_real_cst (value); 3654 break; 3655 3656 case COMPLEX_CST: 3657 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST 3658 && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST) 3659 { 3660 write_integer_cst (TREE_REALPART (value)); 3661 write_char ('_'); 3662 write_integer_cst (TREE_IMAGPART (value)); 3663 } 3664 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST 3665 && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST) 3666 { 3667 write_real_cst (TREE_REALPART (value)); 3668 write_char ('_'); 3669 write_real_cst (TREE_IMAGPART (value)); 3670 } 3671 else 3672 gcc_unreachable (); 3673 break; 3674 3675 case STRING_CST: 3676 { 3677 /* Mangle strings the same as braced initializer lists. */ 3678 unsigned n = TREE_STRING_LENGTH (value); 3679 const char *str = TREE_STRING_POINTER (value); 3680 3681 /* Count the number of trailing nuls and subtract them from 3682 STRSIZE because they don't need to be mangled. */ 3683 for (const char *p = str + n - 1; ; --p) 3684 { 3685 if (*p || p == str) 3686 { 3687 n -= str + n - !!*p - p; 3688 break; 3689 } 3690 } 3691 tree eltype = TREE_TYPE (valtype); 3692 for (const char *p = str; n--; ++p) 3693 { 3694 write_char ('L'); 3695 write_type (eltype); 3696 write_unsigned_number (*(const unsigned char*)p); 3697 write_string ("E"); 3698 } 3699 break; 3700 } 3701 3702 default: 3703 gcc_unreachable (); 3704 } 3705 3706 write_char ('E'); 3707} 3708 3709/* Non-terminal <template-arg>. 3710 3711 <template-arg> ::= <type> # type 3712 ::= L <type> </value/ number> E # literal 3713 ::= LZ <name> E # external name 3714 ::= X <expression> E # expression */ 3715 3716static void 3717write_template_arg (tree node) 3718{ 3719 enum tree_code code = TREE_CODE (node); 3720 3721 MANGLE_TRACE_TREE ("template-arg", node); 3722 3723 /* A template template parameter's argument list contains TREE_LIST 3724 nodes of which the value field is the actual argument. */ 3725 if (code == TREE_LIST) 3726 { 3727 node = TREE_VALUE (node); 3728 /* If it's a decl, deal with its type instead. */ 3729 if (DECL_P (node)) 3730 { 3731 node = TREE_TYPE (node); 3732 code = TREE_CODE (node); 3733 } 3734 } 3735 3736 if (template_parm_object_p (node)) 3737 /* We want to mangle the argument, not the var we stored it in. */ 3738 node = tparm_object_argument (node); 3739 3740 /* Strip a conversion added by convert_nontype_argument. */ 3741 if (TREE_CODE (node) == IMPLICIT_CONV_EXPR) 3742 node = TREE_OPERAND (node, 0); 3743 if (REFERENCE_REF_P (node)) 3744 node = TREE_OPERAND (node, 0); 3745 if (TREE_CODE (node) == NOP_EXPR 3746 && TYPE_REF_P (TREE_TYPE (node))) 3747 { 3748 /* Template parameters can be of reference type. To maintain 3749 internal consistency, such arguments use a conversion from 3750 address of object to reference type. */ 3751 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR); 3752 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0); 3753 } 3754 3755 if (TREE_CODE (node) == BASELINK 3756 && !type_unknown_p (node)) 3757 { 3758 if (abi_version_at_least (6)) 3759 node = BASELINK_FUNCTIONS (node); 3760 if (abi_warn_or_compat_version_crosses (6)) 3761 /* We wrongly wrapped a class-scope function in X/E. */ 3762 G.need_abi_warning = 1; 3763 } 3764 3765 if (ARGUMENT_PACK_P (node)) 3766 { 3767 /* Expand the template argument pack. */ 3768 tree args = ARGUMENT_PACK_ARGS (node); 3769 int i, length = TREE_VEC_LENGTH (args); 3770 if (abi_version_at_least (6)) 3771 write_char ('J'); 3772 else 3773 write_char ('I'); 3774 if (abi_warn_or_compat_version_crosses (6)) 3775 G.need_abi_warning = 1; 3776 for (i = 0; i < length; ++i) 3777 write_template_arg (TREE_VEC_ELT (args, i)); 3778 write_char ('E'); 3779 } 3780 else if (TYPE_P (node)) 3781 write_type (node); 3782 else if (code == TEMPLATE_DECL) 3783 /* A template appearing as a template arg is a template template arg. */ 3784 write_template_template_arg (node); 3785 else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST) 3786 || code == CONST_DECL 3787 || null_member_pointer_value_p (node)) 3788 write_template_arg_literal (node); 3789 else if (DECL_P (node)) 3790 { 3791 write_char ('L'); 3792 /* Until ABI version 3, the underscore before the mangled name 3793 was incorrectly omitted. */ 3794 if (!abi_version_at_least (3)) 3795 write_char ('Z'); 3796 else 3797 write_string ("_Z"); 3798 if (abi_warn_or_compat_version_crosses (3)) 3799 G.need_abi_warning = 1; 3800 write_encoding (node); 3801 write_char ('E'); 3802 } 3803 else 3804 { 3805 /* Template arguments may be expressions. */ 3806 write_char ('X'); 3807 write_expression (node); 3808 write_char ('E'); 3809 } 3810} 3811 3812/* <template-template-arg> 3813 ::= <name> 3814 ::= <substitution> */ 3815 3816static void 3817write_template_template_arg (const tree decl) 3818{ 3819 MANGLE_TRACE_TREE ("template-template-arg", decl); 3820 3821 if (find_substitution (decl)) 3822 return; 3823 write_name (decl, /*ignore_local_scope=*/0); 3824 add_substitution (decl); 3825} 3826 3827 3828/* Non-terminal <array-type>. TYPE is an ARRAY_TYPE. 3829 3830 <array-type> ::= A [</dimension/ number>] _ </element/ type> 3831 ::= A <expression> _ </element/ type> 3832 3833 "Array types encode the dimension (number of elements) and the 3834 element type. For variable length arrays, the dimension (but not 3835 the '_' separator) is omitted." 3836 Note that for flexible array members, like for other arrays of 3837 unspecified size, the dimension is also omitted. */ 3838 3839static void 3840write_array_type (const tree type) 3841{ 3842 write_char ('A'); 3843 if (TYPE_DOMAIN (type)) 3844 { 3845 tree index_type; 3846 3847 index_type = TYPE_DOMAIN (type); 3848 /* The INDEX_TYPE gives the upper and lower bounds of the array. 3849 It's null for flexible array members which have no upper bound 3850 (this is a change from GCC 5 and prior where such members were 3851 incorrectly mangled as zero-length arrays). */ 3852 if (tree max = TYPE_MAX_VALUE (index_type)) 3853 { 3854 if (TREE_CODE (max) == INTEGER_CST) 3855 { 3856 /* The ABI specifies that we should mangle the number of 3857 elements in the array, not the largest allowed index. */ 3858 offset_int wmax = wi::to_offset (max) + 1; 3859 /* Truncate the result - this will mangle [0, SIZE_INT_MAX] 3860 number of elements as zero. */ 3861 wmax = wi::zext (wmax, TYPE_PRECISION (TREE_TYPE (max))); 3862 gcc_assert (wi::fits_uhwi_p (wmax)); 3863 write_unsigned_number (wmax.to_uhwi ()); 3864 } 3865 else 3866 { 3867 max = TREE_OPERAND (max, 0); 3868 write_expression (max); 3869 } 3870 } 3871 } 3872 write_char ('_'); 3873 write_type (TREE_TYPE (type)); 3874} 3875 3876/* Non-terminal <pointer-to-member-type> for pointer-to-member 3877 variables. TYPE is a pointer-to-member POINTER_TYPE. 3878 3879 <pointer-to-member-type> ::= M </class/ type> </member/ type> */ 3880 3881static void 3882write_pointer_to_member_type (const tree type) 3883{ 3884 write_char ('M'); 3885 write_type (TYPE_PTRMEM_CLASS_TYPE (type)); 3886 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type)); 3887} 3888 3889/* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM, 3890 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a 3891 TEMPLATE_PARM_INDEX. 3892 3893 <template-param> ::= T </parameter/ number> _ */ 3894 3895static void 3896write_template_param (const tree parm) 3897{ 3898 int parm_index; 3899 3900 MANGLE_TRACE_TREE ("template-parm", parm); 3901 3902 switch (TREE_CODE (parm)) 3903 { 3904 case TEMPLATE_TYPE_PARM: 3905 case TEMPLATE_TEMPLATE_PARM: 3906 case BOUND_TEMPLATE_TEMPLATE_PARM: 3907 parm_index = TEMPLATE_TYPE_IDX (parm); 3908 break; 3909 3910 case TEMPLATE_PARM_INDEX: 3911 parm_index = TEMPLATE_PARM_IDX (parm); 3912 break; 3913 3914 default: 3915 gcc_unreachable (); 3916 } 3917 3918 write_char ('T'); 3919 /* NUMBER as it appears in the mangling is (-1)-indexed, with the 3920 earliest template param denoted by `_'. */ 3921 write_compact_number (parm_index); 3922} 3923 3924/* <template-template-param> 3925 ::= <template-param> 3926 ::= <substitution> */ 3927 3928static void 3929write_template_template_param (const tree parm) 3930{ 3931 tree templ = NULL_TREE; 3932 3933 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the 3934 template template parameter. The substitution candidate here is 3935 only the template. */ 3936 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) 3937 { 3938 templ 3939 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)); 3940 if (find_substitution (templ)) 3941 return; 3942 } 3943 3944 /* <template-param> encodes only the template parameter position, 3945 not its template arguments, which is fine here. */ 3946 write_template_param (parm); 3947 if (templ) 3948 add_substitution (templ); 3949} 3950 3951/* Non-terminal <substitution>. 3952 3953 <substitution> ::= S <seq-id> _ 3954 ::= S_ */ 3955 3956static void 3957write_substitution (const int seq_id) 3958{ 3959 MANGLE_TRACE ("substitution", ""); 3960 3961 write_char ('S'); 3962 if (seq_id > 0) 3963 write_number (seq_id - 1, /*unsigned=*/1, 36); 3964 write_char ('_'); 3965} 3966 3967/* Start mangling ENTITY. */ 3968 3969static inline void 3970start_mangling (const tree entity) 3971{ 3972 G.entity = entity; 3973 G.need_abi_warning = false; 3974 G.need_cxx17_warning = false; 3975 G.mod = false; 3976 obstack_free (&name_obstack, name_base); 3977 mangle_obstack = &name_obstack; 3978 name_base = obstack_alloc (&name_obstack, 0); 3979} 3980 3981/* Done with mangling. Release the data. */ 3982 3983static void 3984finish_mangling_internal (void) 3985{ 3986 /* Clear all the substitutions. */ 3987 vec_safe_truncate (G.substitutions, 0); 3988 3989 if (G.mod) 3990 mangle_module_fini (); 3991 3992 /* Null-terminate the string. */ 3993 write_char ('\0'); 3994} 3995 3996 3997/* Like finish_mangling_internal, but return the mangled string. */ 3998 3999static inline const char * 4000finish_mangling (void) 4001{ 4002 finish_mangling_internal (); 4003 return (const char *) obstack_finish (mangle_obstack); 4004} 4005 4006/* Like finish_mangling_internal, but return an identifier. */ 4007 4008static tree 4009finish_mangling_get_identifier (void) 4010{ 4011 finish_mangling_internal (); 4012 /* Don't obstack_finish here, and the next start_mangling will 4013 remove the identifier. */ 4014 return get_identifier ((const char *) obstack_base (mangle_obstack)); 4015} 4016 4017/* Initialize data structures for mangling. */ 4018 4019void 4020init_mangle (void) 4021{ 4022 gcc_obstack_init (&name_obstack); 4023 name_base = obstack_alloc (&name_obstack, 0); 4024 vec_alloc (G.substitutions, 0); 4025 4026 /* Cache these identifiers for quick comparison when checking for 4027 standard substitutions. */ 4028 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator"); 4029 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string"); 4030 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits"); 4031 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream"); 4032 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream"); 4033 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream"); 4034} 4035 4036/* Generate a mangling for MODULE's global initializer fn. */ 4037 4038tree 4039mangle_module_global_init (int module) 4040{ 4041 start_mangling (NULL_TREE); 4042 4043 write_string ("_ZGI"); 4044 write_module (module, true); 4045 4046 return finish_mangling_get_identifier (); 4047} 4048 4049/* Generate the mangled name of DECL. */ 4050 4051static tree 4052mangle_decl_string (const tree decl) 4053{ 4054 tree result; 4055 tree saved_fn = NULL_TREE; 4056 bool template_p = false; 4057 4058 /* We shouldn't be trying to mangle an uninstantiated template. */ 4059 gcc_assert (!type_dependent_expression_p (decl)); 4060 4061 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) 4062 { 4063 struct tinst_level *tl = current_instantiation (); 4064 if ((!tl || tl->maybe_get_node () != decl) 4065 && push_tinst_level (decl)) 4066 { 4067 template_p = true; 4068 saved_fn = current_function_decl; 4069 current_function_decl = NULL_TREE; 4070 } 4071 } 4072 iloc_sentinel ils (DECL_SOURCE_LOCATION (decl)); 4073 4074 start_mangling (decl); 4075 4076 if (TREE_CODE (decl) == TYPE_DECL) 4077 write_type (TREE_TYPE (decl)); 4078 else 4079 write_mangled_name (decl, true); 4080 4081 result = finish_mangling_get_identifier (); 4082 if (DEBUG_MANGLE) 4083 fprintf (stderr, "mangle_decl_string = '%s'\n\n", 4084 IDENTIFIER_POINTER (result)); 4085 4086 if (template_p) 4087 { 4088 pop_tinst_level (); 4089 current_function_decl = saved_fn; 4090 } 4091 4092 return result; 4093} 4094 4095/* Return an identifier for the external mangled name of DECL. */ 4096 4097static tree 4098get_mangled_id (tree decl) 4099{ 4100 tree id = mangle_decl_string (decl); 4101 return targetm.mangle_decl_assembler_name (decl, id); 4102} 4103 4104/* Create an identifier for the external mangled name of DECL. */ 4105 4106void 4107mangle_decl (const tree decl) 4108{ 4109 tree id; 4110 bool dep; 4111 4112 /* Don't bother mangling uninstantiated templates. */ 4113 ++processing_template_decl; 4114 if (TREE_CODE (decl) == TYPE_DECL) 4115 dep = dependent_type_p (TREE_TYPE (decl)); 4116 else 4117 dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) 4118 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl))); 4119 --processing_template_decl; 4120 if (dep) 4121 return; 4122 4123 /* During LTO we keep mangled names of TYPE_DECLs for ODR type merging. 4124 It is not needed to assign names to anonymous namespace, but we use the 4125 "<anon>" marker to be able to tell if type is C++ ODR type or type 4126 produced by other language. */ 4127 if (TREE_CODE (decl) == TYPE_DECL 4128 && TYPE_STUB_DECL (TREE_TYPE (decl)) 4129 && !TREE_PUBLIC (TYPE_STUB_DECL (TREE_TYPE (decl)))) 4130 id = get_identifier ("<anon>"); 4131 else 4132 { 4133 gcc_assert (TREE_CODE (decl) != TYPE_DECL 4134 || !no_linkage_check (TREE_TYPE (decl), true)); 4135 if (abi_version_at_least (10)) 4136 if (tree fn = decl_function_context (decl)) 4137 maybe_check_abi_tags (fn, decl); 4138 id = get_mangled_id (decl); 4139 } 4140 SET_DECL_ASSEMBLER_NAME (decl, id); 4141 4142 if (G.need_cxx17_warning 4143 && (TREE_PUBLIC (decl) || DECL_REALLY_EXTERN (decl))) 4144 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wnoexcept_type, 4145 "mangled name for %qD will change in C++17 because the " 4146 "exception specification is part of a function type", 4147 decl); 4148 4149 if (id != DECL_NAME (decl) 4150 /* Don't do this for a fake symbol we aren't going to emit anyway. */ 4151 && TREE_CODE (decl) != TYPE_DECL 4152 && !DECL_MAYBE_IN_CHARGE_CDTOR_P (decl)) 4153 { 4154 int save_ver = flag_abi_version; 4155 tree id2 = NULL_TREE; 4156 4157 if (!DECL_REALLY_EXTERN (decl)) 4158 { 4159 record_mangling (decl, G.need_abi_warning); 4160 4161 if (!G.need_abi_warning) 4162 return; 4163 4164 flag_abi_version = flag_abi_compat_version; 4165 id2 = mangle_decl_string (decl); 4166 id2 = targetm.mangle_decl_assembler_name (decl, id2); 4167 flag_abi_version = save_ver; 4168 4169 if (id2 != id) 4170 note_mangling_alias (decl, id2); 4171 } 4172 4173 if (warn_abi) 4174 { 4175 const char fabi_version[] = "-fabi-version"; 4176 4177 if (flag_abi_compat_version != warn_abi_version 4178 || id2 == NULL_TREE) 4179 { 4180 flag_abi_version = warn_abi_version; 4181 id2 = mangle_decl_string (decl); 4182 id2 = targetm.mangle_decl_assembler_name (decl, id2); 4183 } 4184 flag_abi_version = save_ver; 4185 4186 if (id2 == id) 4187 /* OK. */; 4188 else if (warn_abi_version != 0 4189 && abi_version_at_least (warn_abi_version)) 4190 warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi, 4191 "the mangled name of %qD changed between " 4192 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)", 4193 G.entity, fabi_version, warn_abi_version, id2, 4194 fabi_version, save_ver, id); 4195 else 4196 warning_at (DECL_SOURCE_LOCATION (G.entity), OPT_Wabi, 4197 "the mangled name of %qD changes between " 4198 "%<%s=%d%> (%qD) and %<%s=%d%> (%qD)", 4199 G.entity, fabi_version, save_ver, id, 4200 fabi_version, warn_abi_version, id2); 4201 } 4202 4203 flag_abi_version = save_ver; 4204 } 4205} 4206 4207/* Generate the mangled representation of TYPE. */ 4208 4209const char * 4210mangle_type_string (const tree type) 4211{ 4212 const char *result; 4213 4214 start_mangling (type); 4215 write_type (type); 4216 result = finish_mangling (); 4217 if (DEBUG_MANGLE) 4218 fprintf (stderr, "mangle_type_string = '%s'\n\n", result); 4219 return result; 4220} 4221 4222/* Create an identifier for the mangled name of a special component 4223 for belonging to TYPE. CODE is the ABI-specified code for this 4224 component. */ 4225 4226static tree 4227mangle_special_for_type (const tree type, const char *code) 4228{ 4229 tree result; 4230 4231 /* We don't have an actual decl here for the special component, so 4232 we can't just process the <encoded-name>. Instead, fake it. */ 4233 start_mangling (type); 4234 4235 /* Start the mangling. */ 4236 write_string ("_Z"); 4237 write_string (code); 4238 4239 /* Add the type. */ 4240 write_type (type); 4241 result = finish_mangling_get_identifier (); 4242 4243 if (DEBUG_MANGLE) 4244 fprintf (stderr, "mangle_special_for_type = %s\n\n", 4245 IDENTIFIER_POINTER (result)); 4246 4247 return result; 4248} 4249 4250/* Create an identifier for the mangled representation of the typeinfo 4251 structure for TYPE. */ 4252 4253tree 4254mangle_typeinfo_for_type (const tree type) 4255{ 4256 return mangle_special_for_type (type, "TI"); 4257} 4258 4259/* Create an identifier for the mangled name of the NTBS containing 4260 the mangled name of TYPE. */ 4261 4262tree 4263mangle_typeinfo_string_for_type (const tree type) 4264{ 4265 return mangle_special_for_type (type, "TS"); 4266} 4267 4268/* Create an identifier for the mangled name of the vtable for TYPE. */ 4269 4270tree 4271mangle_vtbl_for_type (const tree type) 4272{ 4273 return mangle_special_for_type (type, "TV"); 4274} 4275 4276/* Returns an identifier for the mangled name of the VTT for TYPE. */ 4277 4278tree 4279mangle_vtt_for_type (const tree type) 4280{ 4281 return mangle_special_for_type (type, "TT"); 4282} 4283 4284/* Returns an identifier for the mangled name of the decomposition 4285 artificial variable DECL. DECLS is the vector of the VAR_DECLs 4286 for the identifier-list. */ 4287 4288tree 4289mangle_decomp (const tree decl, vec<tree> &decls) 4290{ 4291 gcc_assert (!type_dependent_expression_p (decl)); 4292 4293 location_t saved_loc = input_location; 4294 input_location = DECL_SOURCE_LOCATION (decl); 4295 4296 start_mangling (decl); 4297 write_string ("_Z"); 4298 4299 tree context = decl_mangling_context (decl); 4300 gcc_assert (context != NULL_TREE); 4301 4302 bool nested = false; 4303 if (DECL_NAMESPACE_STD_P (context)) 4304 write_string ("St"); 4305 else if (context != global_namespace) 4306 { 4307 nested = true; 4308 write_char ('N'); 4309 write_prefix (decl_mangling_context (decl)); 4310 } 4311 4312 write_string ("DC"); 4313 unsigned int i; 4314 tree d; 4315 FOR_EACH_VEC_ELT (decls, i, d) 4316 write_unqualified_name (d); 4317 write_char ('E'); 4318 4319 if (nested) 4320 write_char ('E'); 4321 4322 tree id = finish_mangling_get_identifier (); 4323 if (DEBUG_MANGLE) 4324 fprintf (stderr, "mangle_decomp = '%s'\n\n", 4325 IDENTIFIER_POINTER (id)); 4326 4327 input_location = saved_loc; 4328 return id; 4329} 4330 4331/* Return an identifier for a construction vtable group. TYPE is 4332 the most derived class in the hierarchy; BINFO is the base 4333 subobject for which this construction vtable group will be used. 4334 4335 This mangling isn't part of the ABI specification; in the ABI 4336 specification, the vtable group is dumped in the same COMDAT as the 4337 main vtable, and is referenced only from that vtable, so it doesn't 4338 need an external name. For binary formats without COMDAT sections, 4339 though, we need external names for the vtable groups. 4340 4341 We use the production 4342 4343 <special-name> ::= CT <type> <offset number> _ <base type> */ 4344 4345tree 4346mangle_ctor_vtbl_for_type (const tree type, const tree binfo) 4347{ 4348 tree result; 4349 4350 start_mangling (type); 4351 4352 write_string ("_Z"); 4353 write_string ("TC"); 4354 write_type (type); 4355 write_integer_cst (BINFO_OFFSET (binfo)); 4356 write_char ('_'); 4357 write_type (BINFO_TYPE (binfo)); 4358 4359 result = finish_mangling_get_identifier (); 4360 if (DEBUG_MANGLE) 4361 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", 4362 IDENTIFIER_POINTER (result)); 4363 return result; 4364} 4365 4366/* Mangle a this pointer or result pointer adjustment. 4367 4368 <call-offset> ::= h <fixed offset number> _ 4369 ::= v <fixed offset number> _ <virtual offset number> _ */ 4370 4371static void 4372mangle_call_offset (const tree fixed_offset, const tree virtual_offset) 4373{ 4374 write_char (virtual_offset ? 'v' : 'h'); 4375 4376 /* For either flavor, write the fixed offset. */ 4377 write_integer_cst (fixed_offset); 4378 write_char ('_'); 4379 4380 /* For a virtual thunk, add the virtual offset. */ 4381 if (virtual_offset) 4382 { 4383 write_integer_cst (virtual_offset); 4384 write_char ('_'); 4385 } 4386} 4387 4388/* Return an identifier for the mangled name of a this-adjusting or 4389 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment 4390 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this 4391 is a virtual thunk, and it is the vtbl offset in 4392 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and 4393 zero for a covariant thunk. Note, that FN_DECL might be a covariant 4394 thunk itself. A covariant thunk name always includes the adjustment 4395 for the this pointer, even if there is none. 4396 4397 <special-name> ::= T <call-offset> <base encoding> 4398 ::= Tc <this_adjust call-offset> <result_adjust call-offset> 4399 <base encoding> */ 4400 4401tree 4402mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset, 4403 tree virtual_offset, tree thunk) 4404{ 4405 tree result; 4406 4407 if (abi_version_at_least (11)) 4408 maybe_check_abi_tags (fn_decl, thunk, 11); 4409 4410 start_mangling (fn_decl); 4411 4412 write_string ("_Z"); 4413 write_char ('T'); 4414 4415 if (!this_adjusting) 4416 { 4417 /* Covariant thunk with no this adjustment */ 4418 write_char ('c'); 4419 mangle_call_offset (integer_zero_node, NULL_TREE); 4420 mangle_call_offset (fixed_offset, virtual_offset); 4421 } 4422 else if (!DECL_THUNK_P (fn_decl)) 4423 /* Plain this adjusting thunk. */ 4424 mangle_call_offset (fixed_offset, virtual_offset); 4425 else 4426 { 4427 /* This adjusting thunk to covariant thunk. */ 4428 write_char ('c'); 4429 mangle_call_offset (fixed_offset, virtual_offset); 4430 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl)); 4431 virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl); 4432 if (virtual_offset) 4433 virtual_offset = BINFO_VPTR_FIELD (virtual_offset); 4434 mangle_call_offset (fixed_offset, virtual_offset); 4435 fn_decl = THUNK_TARGET (fn_decl); 4436 } 4437 4438 /* Scoped name. */ 4439 write_encoding (fn_decl); 4440 4441 result = finish_mangling_get_identifier (); 4442 if (DEBUG_MANGLE) 4443 fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result)); 4444 return result; 4445} 4446 4447/* Handle ABI backwards compatibility for past bugs where we didn't call 4448 check_abi_tags in places where it's needed: call check_abi_tags and warn if 4449 it makes a difference. If FOR_DECL is non-null, it's the declaration 4450 that we're actually trying to mangle; if it's null, we're mangling the 4451 guard variable for T. */ 4452 4453static void 4454maybe_check_abi_tags (tree t, tree for_decl, int ver) 4455{ 4456 if (DECL_ASSEMBLER_NAME_SET_P (t)) 4457 return; 4458 4459 tree oldtags = get_abi_tags (t); 4460 4461 mangle_decl (t); 4462 4463 tree newtags = get_abi_tags (t); 4464 if (newtags && newtags != oldtags 4465 && abi_version_crosses (ver)) 4466 { 4467 if (for_decl && DECL_THUNK_P (for_decl)) 4468 warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi, 4469 "the mangled name of a thunk for %qD changes between " 4470 "%<-fabi-version=%d%> and %<-fabi-version=%d%>", 4471 t, flag_abi_version, warn_abi_version); 4472 else if (for_decl) 4473 warning_at (DECL_SOURCE_LOCATION (for_decl), OPT_Wabi, 4474 "the mangled name of %qD changes between " 4475 "%<-fabi-version=%d%> and %<-fabi-version=%d%>", 4476 for_decl, flag_abi_version, warn_abi_version); 4477 else 4478 warning_at (DECL_SOURCE_LOCATION (t), OPT_Wabi, 4479 "the mangled name of the initialization guard variable " 4480 "for %qD changes between %<-fabi-version=%d%> and " 4481 "%<-fabi-version=%d%>", 4482 t, flag_abi_version, warn_abi_version); 4483 } 4484} 4485 4486/* Write out the appropriate string for this variable when generating 4487 another mangled name based on this one. */ 4488 4489static void 4490write_guarded_var_name (const tree variable) 4491{ 4492 if (DECL_NAME (variable) 4493 && startswith (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR")) 4494 /* The name of a guard variable for a reference temporary should refer 4495 to the reference, not the temporary. */ 4496 write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4); 4497 else 4498 write_name (variable, /*ignore_local_scope=*/0); 4499} 4500 4501/* Return an identifier for the name of an initialization guard 4502 variable for indicated VARIABLE. */ 4503 4504tree 4505mangle_guard_variable (const tree variable) 4506{ 4507 if (abi_version_at_least (10)) 4508 maybe_check_abi_tags (variable); 4509 start_mangling (variable); 4510 write_string ("_ZGV"); 4511 write_guarded_var_name (variable); 4512 return finish_mangling_get_identifier (); 4513} 4514 4515/* Return an identifier for the name of a thread_local initialization 4516 function for VARIABLE. */ 4517 4518tree 4519mangle_tls_init_fn (const tree variable) 4520{ 4521 check_abi_tags (variable); 4522 start_mangling (variable); 4523 write_string ("_ZTH"); 4524 write_guarded_var_name (variable); 4525 return finish_mangling_get_identifier (); 4526} 4527 4528/* Return an identifier for the name of a thread_local wrapper 4529 function for VARIABLE. */ 4530 4531#define TLS_WRAPPER_PREFIX "_ZTW" 4532 4533tree 4534mangle_tls_wrapper_fn (const tree variable) 4535{ 4536 check_abi_tags (variable); 4537 start_mangling (variable); 4538 write_string (TLS_WRAPPER_PREFIX); 4539 write_guarded_var_name (variable); 4540 return finish_mangling_get_identifier (); 4541} 4542 4543/* Return true iff FN is a thread_local wrapper function. */ 4544 4545bool 4546decl_tls_wrapper_p (const tree fn) 4547{ 4548 if (TREE_CODE (fn) != FUNCTION_DECL) 4549 return false; 4550 tree name = DECL_NAME (fn); 4551 return startswith (IDENTIFIER_POINTER (name), TLS_WRAPPER_PREFIX); 4552} 4553 4554/* Return an identifier for the name of a temporary variable used to 4555 initialize a static reference. This is now part of the ABI. */ 4556 4557tree 4558mangle_ref_init_variable (const tree variable) 4559{ 4560 start_mangling (variable); 4561 write_string ("_ZGR"); 4562 check_abi_tags (variable); 4563 write_name (variable, /*ignore_local_scope=*/0); 4564 /* Avoid name clashes with aggregate initialization of multiple 4565 references at once. */ 4566 write_compact_number (current_ref_temp_count++); 4567 return finish_mangling_get_identifier (); 4568} 4569 4570/* Return an identifier for the mangled name of a C++20 template parameter 4571 object for template argument EXPR. */ 4572 4573tree 4574mangle_template_parm_object (tree expr) 4575{ 4576 start_mangling (expr); 4577 write_string ("_ZTAX"); 4578 write_expression (expr); 4579 write_char ('E'); 4580 return finish_mangling_get_identifier (); 4581} 4582 4583/* Given a CLASS_TYPE, such as a record for std::bad_exception this 4584 function generates a mangled name for the vtable map variable of 4585 the class type. For example, if the class type is 4586 "std::bad_exception", the mangled name for the class is 4587 "St13bad_exception". This function would generate the name 4588 "_ZN4_VTVISt13bad_exceptionE12__vtable_mapE", which unmangles as: 4589 "_VTV<std::bad_exception>::__vtable_map". */ 4590 4591 4592char * 4593get_mangled_vtable_map_var_name (tree class_type) 4594{ 4595 char *var_name = NULL; 4596 const char *prefix = "_ZN4_VTVI"; 4597 const char *postfix = "E12__vtable_mapE"; 4598 4599 gcc_assert (TREE_CODE (class_type) == RECORD_TYPE); 4600 4601 tree class_id = DECL_ASSEMBLER_NAME (TYPE_NAME (class_type)); 4602 4603 if (strstr (IDENTIFIER_POINTER (class_id), "<anon>") != NULL) 4604 { 4605 class_id = get_mangled_id (TYPE_NAME (class_type)); 4606 vtbl_register_mangled_name (TYPE_NAME (class_type), class_id); 4607 } 4608 4609 unsigned int len = strlen (IDENTIFIER_POINTER (class_id)) + 4610 strlen (prefix) + 4611 strlen (postfix) + 1; 4612 4613 var_name = (char *) xmalloc (len); 4614 4615 sprintf (var_name, "%s%s%s", prefix, IDENTIFIER_POINTER (class_id), postfix); 4616 4617 return var_name; 4618} 4619 4620#include "gt-cp-mangle.h" 4621