1 /* Name mangling for the 3.0 C++ ABI. 2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 3 2011 Free Software Foundation, Inc. 4 Written by Alex Samuel <samuel@codesourcery.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it 9 under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, but 14 WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 /* This file implements mangling of C++ names according to the IA64 23 C++ ABI specification. A mangled name encodes a function or 24 variable's name, scope, type, and/or template arguments into a text 25 identifier. This identifier is used as the function's or 26 variable's linkage name, to preserve compatibility between C++'s 27 language features (templates, scoping, and overloading) and C 28 linkers. 29 30 Additionally, g++ uses mangled names internally. To support this, 31 mangling of types is allowed, even though the mangled name of a 32 type should not appear by itself as an exported name. Ditto for 33 uninstantiated templates. 34 35 The primary entry point for this module is mangle_decl, which 36 returns an identifier containing the mangled name for a decl. 37 Additional entry points are provided to build mangled names of 38 particular constructs when the appropriate decl for that construct 39 is not available. These are: 40 41 mangle_typeinfo_for_type: typeinfo data 42 mangle_typeinfo_string_for_type: typeinfo type name 43 mangle_vtbl_for_type: virtual table data 44 mangle_vtt_for_type: VTT data 45 mangle_ctor_vtbl_for_type: `C-in-B' constructor virtual table data 46 mangle_thunk: thunk function or entry */ 47 48 #include "config.h" 49 #include "system.h" 50 #include "coretypes.h" 51 #include "tm.h" 52 #include "tree.h" 53 #include "tm_p.h" 54 #include "cp-tree.h" 55 #include "obstack.h" 56 #include "flags.h" 57 #include "target.h" 58 #include "cgraph.h" 59 60 /* Debugging support. */ 61 62 /* Define DEBUG_MANGLE to enable very verbose trace messages. */ 63 #ifndef DEBUG_MANGLE 64 #define DEBUG_MANGLE 0 65 #endif 66 67 /* Macros for tracing the write_* functions. */ 68 #if DEBUG_MANGLE 69 # define MANGLE_TRACE(FN, INPUT) \ 70 fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT)) 71 # define MANGLE_TRACE_TREE(FN, NODE) \ 72 fprintf (stderr, " %-24s: %-24s (%p)\n", \ 73 (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE)) 74 #else 75 # define MANGLE_TRACE(FN, INPUT) 76 # define MANGLE_TRACE_TREE(FN, NODE) 77 #endif 78 79 /* Nonzero if NODE is a class template-id. We can't rely on 80 CLASSTYPE_USE_TEMPLATE here because of tricky bugs in the parser 81 that hard to distinguish A<T> from A, where A<T> is the type as 82 instantiated outside of the template, and A is the type used 83 without parameters inside the template. */ 84 #define CLASSTYPE_TEMPLATE_ID_P(NODE) \ 85 (TYPE_LANG_SPECIFIC (NODE) != NULL \ 86 && (TREE_CODE (NODE) == BOUND_TEMPLATE_TEMPLATE_PARM \ 87 || (CLASSTYPE_TEMPLATE_INFO (NODE) != NULL \ 88 && (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (NODE)))))) 89 90 /* Things we only need one of. This module is not reentrant. */ 91 typedef struct GTY(()) globals { 92 /* An array of the current substitution candidates, in the order 93 we've seen them. */ 94 VEC(tree,gc) *substitutions; 95 96 /* The entity that is being mangled. */ 97 tree GTY ((skip)) entity; 98 99 /* How many parameter scopes we are inside. */ 100 int parm_depth; 101 102 /* True if the mangling will be different in a future version of the 103 ABI. */ 104 bool need_abi_warning; 105 } globals; 106 107 static GTY (()) globals G; 108 109 /* The obstack on which we build mangled names. */ 110 static struct obstack *mangle_obstack; 111 112 /* The obstack on which we build mangled names that are not going to 113 be IDENTIFIER_NODEs. */ 114 static struct obstack name_obstack; 115 116 /* The first object on the name_obstack; we use this to free memory 117 allocated on the name_obstack. */ 118 static void *name_base; 119 120 /* Indices into subst_identifiers. These are identifiers used in 121 special substitution rules. */ 122 typedef enum 123 { 124 SUBID_ALLOCATOR, 125 SUBID_BASIC_STRING, 126 SUBID_CHAR_TRAITS, 127 SUBID_BASIC_ISTREAM, 128 SUBID_BASIC_OSTREAM, 129 SUBID_BASIC_IOSTREAM, 130 SUBID_MAX 131 } 132 substitution_identifier_index_t; 133 134 /* For quick substitution checks, look up these common identifiers 135 once only. */ 136 static GTY(()) tree subst_identifiers[SUBID_MAX]; 137 138 /* Single-letter codes for builtin integer types, defined in 139 <builtin-type>. These are indexed by integer_type_kind values. */ 140 static const char 141 integer_type_codes[itk_none] = 142 { 143 'c', /* itk_char */ 144 'a', /* itk_signed_char */ 145 'h', /* itk_unsigned_char */ 146 's', /* itk_short */ 147 't', /* itk_unsigned_short */ 148 'i', /* itk_int */ 149 'j', /* itk_unsigned_int */ 150 'l', /* itk_long */ 151 'm', /* itk_unsigned_long */ 152 'x', /* itk_long_long */ 153 'y', /* itk_unsigned_long_long */ 154 'n', /* itk_int128 */ 155 'o', /* itk_unsigned_int128 */ 156 }; 157 158 static int decl_is_template_id (const tree, tree* const); 159 160 /* Functions for handling substitutions. */ 161 162 static inline tree canonicalize_for_substitution (tree); 163 static void add_substitution (tree); 164 static inline int is_std_substitution (const tree, 165 const substitution_identifier_index_t); 166 static inline int is_std_substitution_char (const tree, 167 const substitution_identifier_index_t); 168 static int find_substitution (tree); 169 static void mangle_call_offset (const tree, const tree); 170 171 /* Functions for emitting mangled representations of things. */ 172 173 static void write_mangled_name (const tree, bool); 174 static void write_encoding (const tree); 175 static void write_name (tree, const int); 176 static void write_unscoped_name (const tree); 177 static void write_unscoped_template_name (const tree); 178 static void write_nested_name (const tree); 179 static void write_prefix (const tree); 180 static void write_template_prefix (const tree); 181 static void write_unqualified_name (const tree); 182 static void write_conversion_operator_name (const tree); 183 static void write_source_name (tree); 184 static void write_literal_operator_name (tree); 185 static void write_unnamed_type_name (const tree); 186 static void write_closure_type_name (const tree); 187 static int hwint_to_ascii (unsigned HOST_WIDE_INT, const unsigned int, char *, 188 const unsigned int); 189 static void write_number (unsigned HOST_WIDE_INT, const int, 190 const unsigned int); 191 static void write_compact_number (int num); 192 static void write_integer_cst (const tree); 193 static void write_real_cst (const tree); 194 static void write_identifier (const char *); 195 static void write_special_name_constructor (const tree); 196 static void write_special_name_destructor (const tree); 197 static void write_type (tree); 198 static int write_CV_qualifiers_for_type (const tree); 199 static void write_builtin_type (tree); 200 static void write_function_type (const tree); 201 static void write_bare_function_type (const tree, const int, const tree); 202 static void write_method_parms (tree, const int, const tree); 203 static void write_class_enum_type (const tree); 204 static void write_template_args (tree); 205 static void write_expression (tree); 206 static void write_template_arg_literal (const tree); 207 static void write_template_arg (tree); 208 static void write_template_template_arg (const tree); 209 static void write_array_type (const tree); 210 static void write_pointer_to_member_type (const tree); 211 static void write_template_param (const tree); 212 static void write_template_template_param (const tree); 213 static void write_substitution (const int); 214 static int discriminator_for_local_entity (tree); 215 static int discriminator_for_string_literal (tree, tree); 216 static void write_discriminator (const int); 217 static void write_local_name (tree, const tree, const tree); 218 static void dump_substitution_candidates (void); 219 static tree mangle_decl_string (const tree); 220 static int local_class_index (tree); 221 222 /* Control functions. */ 223 224 static inline void start_mangling (const tree); 225 static inline const char *finish_mangling (const bool); 226 static tree mangle_special_for_type (const tree, const char *); 227 228 /* Foreign language functions. */ 229 230 static void write_java_integer_type_codes (const tree); 231 232 /* Append a single character to the end of the mangled 233 representation. */ 234 #define write_char(CHAR) \ 235 obstack_1grow (mangle_obstack, (CHAR)) 236 237 /* Append a sized buffer to the end of the mangled representation. */ 238 #define write_chars(CHAR, LEN) \ 239 obstack_grow (mangle_obstack, (CHAR), (LEN)) 240 241 /* Append a NUL-terminated string to the end of the mangled 242 representation. */ 243 #define write_string(STRING) \ 244 obstack_grow (mangle_obstack, (STRING), strlen (STRING)) 245 246 /* Nonzero if NODE1 and NODE2 are both TREE_LIST nodes and have the 247 same purpose (context, which may be a type) and value (template 248 decl). See write_template_prefix for more information on what this 249 is used for. */ 250 #define NESTED_TEMPLATE_MATCH(NODE1, NODE2) \ 251 (TREE_CODE (NODE1) == TREE_LIST \ 252 && TREE_CODE (NODE2) == TREE_LIST \ 253 && ((TYPE_P (TREE_PURPOSE (NODE1)) \ 254 && same_type_p (TREE_PURPOSE (NODE1), TREE_PURPOSE (NODE2))) \ 255 || TREE_PURPOSE (NODE1) == TREE_PURPOSE (NODE2)) \ 256 && TREE_VALUE (NODE1) == TREE_VALUE (NODE2)) 257 258 /* Write out an unsigned quantity in base 10. */ 259 #define write_unsigned_number(NUMBER) \ 260 write_number ((NUMBER), /*unsigned_p=*/1, 10) 261 262 /* If DECL is a template instance, return nonzero and, if 263 TEMPLATE_INFO is non-NULL, set *TEMPLATE_INFO to its template info. 264 Otherwise return zero. */ 265 266 static int 267 decl_is_template_id (const tree decl, tree* const template_info) 268 { 269 if (TREE_CODE (decl) == TYPE_DECL) 270 { 271 /* TYPE_DECLs are handled specially. Look at its type to decide 272 if this is a template instantiation. */ 273 const tree type = TREE_TYPE (decl); 274 275 if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_ID_P (type)) 276 { 277 if (template_info != NULL) 278 /* For a templated TYPE_DECL, the template info is hanging 279 off the type. */ 280 *template_info = TYPE_TEMPLATE_INFO (type); 281 return 1; 282 } 283 } 284 else 285 { 286 /* Check if this is a primary template. */ 287 if (DECL_LANG_SPECIFIC (decl) != NULL 288 && DECL_USE_TEMPLATE (decl) 289 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)) 290 && TREE_CODE (decl) != TEMPLATE_DECL) 291 { 292 if (template_info != NULL) 293 /* For most templated decls, the template info is hanging 294 off the decl. */ 295 *template_info = DECL_TEMPLATE_INFO (decl); 296 return 1; 297 } 298 } 299 300 /* It's not a template id. */ 301 return 0; 302 } 303 304 /* Produce debugging output of current substitution candidates. */ 305 306 static void 307 dump_substitution_candidates (void) 308 { 309 unsigned i; 310 tree el; 311 312 fprintf (stderr, " ++ substitutions "); 313 FOR_EACH_VEC_ELT (tree, G.substitutions, i, el) 314 { 315 const char *name = "???"; 316 317 if (i > 0) 318 fprintf (stderr, " "); 319 if (DECL_P (el)) 320 name = IDENTIFIER_POINTER (DECL_NAME (el)); 321 else if (TREE_CODE (el) == TREE_LIST) 322 name = IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (el))); 323 else if (TYPE_NAME (el)) 324 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (el))); 325 fprintf (stderr, " S%d_ = ", i - 1); 326 if (TYPE_P (el) && 327 (CP_TYPE_RESTRICT_P (el) 328 || CP_TYPE_VOLATILE_P (el) 329 || CP_TYPE_CONST_P (el))) 330 fprintf (stderr, "CV-"); 331 fprintf (stderr, "%s (%s at %p)\n", 332 name, tree_code_name[TREE_CODE (el)], (void *) el); 333 } 334 } 335 336 /* Both decls and types can be substitution candidates, but sometimes 337 they refer to the same thing. For instance, a TYPE_DECL and 338 RECORD_TYPE for the same class refer to the same thing, and should 339 be treated accordingly in substitutions. This function returns a 340 canonicalized tree node representing NODE that is used when adding 341 and substitution candidates and finding matches. */ 342 343 static inline tree 344 canonicalize_for_substitution (tree node) 345 { 346 /* For a TYPE_DECL, use the type instead. */ 347 if (TREE_CODE (node) == TYPE_DECL) 348 node = TREE_TYPE (node); 349 if (TYPE_P (node) 350 && TYPE_CANONICAL (node) != node 351 && TYPE_MAIN_VARIANT (node) != node) 352 { 353 /* Here we want to strip the topmost typedef only. 354 We need to do that so is_std_substitution can do proper 355 name matching. */ 356 if (TREE_CODE (node) == FUNCTION_TYPE) 357 /* Use build_qualified_type and TYPE_QUALS here to preserve 358 the old buggy mangling of attribute noreturn with abi<5. */ 359 node = build_qualified_type (TYPE_MAIN_VARIANT (node), 360 TYPE_QUALS (node)); 361 else 362 node = cp_build_qualified_type (TYPE_MAIN_VARIANT (node), 363 cp_type_quals (node)); 364 } 365 return node; 366 } 367 368 /* Add NODE as a substitution candidate. NODE must not already be on 369 the list of candidates. */ 370 371 static void 372 add_substitution (tree node) 373 { 374 tree c; 375 376 if (DEBUG_MANGLE) 377 fprintf (stderr, " ++ add_substitution (%s at %10p)\n", 378 tree_code_name[TREE_CODE (node)], (void *) node); 379 380 /* Get the canonicalized substitution candidate for NODE. */ 381 c = canonicalize_for_substitution (node); 382 if (DEBUG_MANGLE && c != node) 383 fprintf (stderr, " ++ using candidate (%s at %10p)\n", 384 tree_code_name[TREE_CODE (node)], (void *) node); 385 node = c; 386 387 #if ENABLE_CHECKING 388 /* Make sure NODE isn't already a candidate. */ 389 { 390 int i; 391 tree candidate; 392 393 FOR_EACH_VEC_ELT (tree, G.substitutions, i, candidate) 394 { 395 gcc_assert (!(DECL_P (node) && node == candidate)); 396 gcc_assert (!(TYPE_P (node) && TYPE_P (candidate) 397 && same_type_p (node, candidate))); 398 } 399 } 400 #endif /* ENABLE_CHECKING */ 401 402 /* Put the decl onto the varray of substitution candidates. */ 403 VEC_safe_push (tree, gc, G.substitutions, node); 404 405 if (DEBUG_MANGLE) 406 dump_substitution_candidates (); 407 } 408 409 /* Helper function for find_substitution. Returns nonzero if NODE, 410 which may be a decl or a CLASS_TYPE, is a template-id with template 411 name of substitution_index[INDEX] in the ::std namespace. */ 412 413 static inline int 414 is_std_substitution (const tree node, 415 const substitution_identifier_index_t index) 416 { 417 tree type = NULL; 418 tree decl = NULL; 419 420 if (DECL_P (node)) 421 { 422 type = TREE_TYPE (node); 423 decl = node; 424 } 425 else if (CLASS_TYPE_P (node)) 426 { 427 type = node; 428 decl = TYPE_NAME (node); 429 } 430 else 431 /* These are not the droids you're looking for. */ 432 return 0; 433 434 return (DECL_NAMESPACE_STD_P (CP_DECL_CONTEXT (decl)) 435 && TYPE_LANG_SPECIFIC (type) 436 && TYPE_TEMPLATE_INFO (type) 437 && (DECL_NAME (TYPE_TI_TEMPLATE (type)) 438 == subst_identifiers[index])); 439 } 440 441 /* Helper function for find_substitution. Returns nonzero if NODE, 442 which may be a decl or a CLASS_TYPE, is the template-id 443 ::std::identifier<char>, where identifier is 444 substitution_index[INDEX]. */ 445 446 static inline int 447 is_std_substitution_char (const tree node, 448 const substitution_identifier_index_t index) 449 { 450 tree args; 451 /* Check NODE's name is ::std::identifier. */ 452 if (!is_std_substitution (node, index)) 453 return 0; 454 /* Figure out its template args. */ 455 if (DECL_P (node)) 456 args = DECL_TI_ARGS (node); 457 else if (CLASS_TYPE_P (node)) 458 args = CLASSTYPE_TI_ARGS (node); 459 else 460 /* Oops, not a template. */ 461 return 0; 462 /* NODE's template arg list should be <char>. */ 463 return 464 TREE_VEC_LENGTH (args) == 1 465 && TREE_VEC_ELT (args, 0) == char_type_node; 466 } 467 468 /* Check whether a substitution should be used to represent NODE in 469 the mangling. 470 471 First, check standard special-case substitutions. 472 473 <substitution> ::= St 474 # ::std 475 476 ::= Sa 477 # ::std::allocator 478 479 ::= Sb 480 # ::std::basic_string 481 482 ::= Ss 483 # ::std::basic_string<char, 484 ::std::char_traits<char>, 485 ::std::allocator<char> > 486 487 ::= Si 488 # ::std::basic_istream<char, ::std::char_traits<char> > 489 490 ::= So 491 # ::std::basic_ostream<char, ::std::char_traits<char> > 492 493 ::= Sd 494 # ::std::basic_iostream<char, ::std::char_traits<char> > 495 496 Then examine the stack of currently available substitution 497 candidates for entities appearing earlier in the same mangling 498 499 If a substitution is found, write its mangled representation and 500 return nonzero. If none is found, just return zero. */ 501 502 static int 503 find_substitution (tree node) 504 { 505 int i; 506 const int size = VEC_length (tree, G.substitutions); 507 tree decl; 508 tree type; 509 510 if (DEBUG_MANGLE) 511 fprintf (stderr, " ++ find_substitution (%s at %p)\n", 512 tree_code_name[TREE_CODE (node)], (void *) node); 513 514 /* Obtain the canonicalized substitution representation for NODE. 515 This is what we'll compare against. */ 516 node = canonicalize_for_substitution (node); 517 518 /* Check for builtin substitutions. */ 519 520 decl = TYPE_P (node) ? TYPE_NAME (node) : node; 521 type = TYPE_P (node) ? node : TREE_TYPE (node); 522 523 /* Check for std::allocator. */ 524 if (decl 525 && is_std_substitution (decl, SUBID_ALLOCATOR) 526 && !CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl))) 527 { 528 write_string ("Sa"); 529 return 1; 530 } 531 532 /* Check for std::basic_string. */ 533 if (decl && is_std_substitution (decl, SUBID_BASIC_STRING)) 534 { 535 if (TYPE_P (node)) 536 { 537 /* If this is a type (i.e. a fully-qualified template-id), 538 check for 539 std::basic_string <char, 540 std::char_traits<char>, 541 std::allocator<char> > . */ 542 if (cp_type_quals (type) == TYPE_UNQUALIFIED 543 && CLASSTYPE_USE_TEMPLATE (type)) 544 { 545 tree args = CLASSTYPE_TI_ARGS (type); 546 if (TREE_VEC_LENGTH (args) == 3 547 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node) 548 && is_std_substitution_char (TREE_VEC_ELT (args, 1), 549 SUBID_CHAR_TRAITS) 550 && is_std_substitution_char (TREE_VEC_ELT (args, 2), 551 SUBID_ALLOCATOR)) 552 { 553 write_string ("Ss"); 554 return 1; 555 } 556 } 557 } 558 else 559 /* Substitute for the template name only if this isn't a type. */ 560 { 561 write_string ("Sb"); 562 return 1; 563 } 564 } 565 566 /* Check for basic_{i,o,io}stream. */ 567 if (TYPE_P (node) 568 && cp_type_quals (type) == TYPE_UNQUALIFIED 569 && CLASS_TYPE_P (type) 570 && CLASSTYPE_USE_TEMPLATE (type) 571 && CLASSTYPE_TEMPLATE_INFO (type) != NULL) 572 { 573 /* First, check for the template 574 args <char, std::char_traits<char> > . */ 575 tree args = CLASSTYPE_TI_ARGS (type); 576 if (TREE_VEC_LENGTH (args) == 2 577 && TYPE_P (TREE_VEC_ELT (args, 0)) 578 && same_type_p (TREE_VEC_ELT (args, 0), char_type_node) 579 && is_std_substitution_char (TREE_VEC_ELT (args, 1), 580 SUBID_CHAR_TRAITS)) 581 { 582 /* Got them. Is this basic_istream? */ 583 if (is_std_substitution (decl, SUBID_BASIC_ISTREAM)) 584 { 585 write_string ("Si"); 586 return 1; 587 } 588 /* Or basic_ostream? */ 589 else if (is_std_substitution (decl, SUBID_BASIC_OSTREAM)) 590 { 591 write_string ("So"); 592 return 1; 593 } 594 /* Or basic_iostream? */ 595 else if (is_std_substitution (decl, SUBID_BASIC_IOSTREAM)) 596 { 597 write_string ("Sd"); 598 return 1; 599 } 600 } 601 } 602 603 /* Check for namespace std. */ 604 if (decl && DECL_NAMESPACE_STD_P (decl)) 605 { 606 write_string ("St"); 607 return 1; 608 } 609 610 /* Now check the list of available substitutions for this mangling 611 operation. */ 612 for (i = 0; i < size; ++i) 613 { 614 tree candidate = VEC_index (tree, G.substitutions, i); 615 /* NODE is a matched to a candidate if it's the same decl node or 616 if it's the same type. */ 617 if (decl == candidate 618 || (TYPE_P (candidate) && type && TYPE_P (node) 619 && same_type_p (type, candidate)) 620 || NESTED_TEMPLATE_MATCH (node, candidate)) 621 { 622 write_substitution (i); 623 return 1; 624 } 625 } 626 627 /* No substitution found. */ 628 return 0; 629 } 630 631 632 /* TOP_LEVEL is true, if this is being called at outermost level of 633 mangling. It should be false when mangling a decl appearing in an 634 expression within some other mangling. 635 636 <mangled-name> ::= _Z <encoding> */ 637 638 static void 639 write_mangled_name (const tree decl, bool top_level) 640 { 641 MANGLE_TRACE_TREE ("mangled-name", decl); 642 643 if (/* The names of `extern "C"' functions are not mangled. */ 644 DECL_EXTERN_C_FUNCTION_P (decl) 645 /* But overloaded operator names *are* mangled. */ 646 && !DECL_OVERLOADED_OPERATOR_P (decl)) 647 { 648 unmangled_name:; 649 650 if (top_level) 651 write_string (IDENTIFIER_POINTER (DECL_NAME (decl))); 652 else 653 { 654 /* The standard notes: "The <encoding> of an extern "C" 655 function is treated like global-scope data, i.e. as its 656 <source-name> without a type." We cannot write 657 overloaded operators that way though, because it contains 658 characters invalid in assembler. */ 659 if (abi_version_at_least (2)) 660 write_string ("_Z"); 661 else 662 G.need_abi_warning = true; 663 write_source_name (DECL_NAME (decl)); 664 } 665 } 666 else if (TREE_CODE (decl) == VAR_DECL 667 /* The names of non-static global variables aren't mangled. */ 668 && DECL_EXTERNAL_LINKAGE_P (decl) 669 && (CP_DECL_CONTEXT (decl) == global_namespace 670 /* And neither are `extern "C"' variables. */ 671 || DECL_EXTERN_C_P (decl))) 672 { 673 if (top_level || abi_version_at_least (2)) 674 goto unmangled_name; 675 else 676 { 677 G.need_abi_warning = true; 678 goto mangled_name; 679 } 680 } 681 else 682 { 683 mangled_name:; 684 write_string ("_Z"); 685 write_encoding (decl); 686 if (DECL_LANG_SPECIFIC (decl) 687 && (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl) 688 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl))) 689 /* We need a distinct mangled name for these entities, but 690 we should never actually output it. So, we append some 691 characters the assembler won't like. */ 692 write_string (" *INTERNAL* "); 693 } 694 } 695 696 /* <encoding> ::= <function name> <bare-function-type> 697 ::= <data name> */ 698 699 static void 700 write_encoding (const tree decl) 701 { 702 MANGLE_TRACE_TREE ("encoding", decl); 703 704 if (DECL_LANG_SPECIFIC (decl) && DECL_EXTERN_C_FUNCTION_P (decl)) 705 { 706 /* For overloaded operators write just the mangled name 707 without arguments. */ 708 if (DECL_OVERLOADED_OPERATOR_P (decl)) 709 write_name (decl, /*ignore_local_scope=*/0); 710 else 711 write_source_name (DECL_NAME (decl)); 712 return; 713 } 714 715 write_name (decl, /*ignore_local_scope=*/0); 716 if (TREE_CODE (decl) == FUNCTION_DECL) 717 { 718 tree fn_type; 719 tree d; 720 721 if (decl_is_template_id (decl, NULL)) 722 { 723 fn_type = get_mostly_instantiated_function_type (decl); 724 /* FN_TYPE will not have parameter types for in-charge or 725 VTT parameters. Therefore, we pass NULL_TREE to 726 write_bare_function_type -- otherwise, it will get 727 confused about which artificial parameters to skip. */ 728 d = NULL_TREE; 729 } 730 else 731 { 732 fn_type = TREE_TYPE (decl); 733 d = decl; 734 } 735 736 write_bare_function_type (fn_type, 737 (!DECL_CONSTRUCTOR_P (decl) 738 && !DECL_DESTRUCTOR_P (decl) 739 && !DECL_CONV_FN_P (decl) 740 && decl_is_template_id (decl, NULL)), 741 d); 742 } 743 } 744 745 /* Lambdas can have a bit more context for mangling, specifically VAR_DECL 746 or PARM_DECL context, which doesn't belong in DECL_CONTEXT. */ 747 748 static tree 749 decl_mangling_context (tree decl) 750 { 751 tree tcontext = targetm.cxx.decl_mangling_context (decl); 752 753 if (tcontext != NULL_TREE) 754 return tcontext; 755 756 if (TREE_CODE (decl) == TYPE_DECL 757 && LAMBDA_TYPE_P (TREE_TYPE (decl))) 758 { 759 tree extra = LAMBDA_TYPE_EXTRA_SCOPE (TREE_TYPE (decl)); 760 if (extra) 761 return extra; 762 } 763 else if (TREE_CODE (decl) == TYPE_DECL 764 && TREE_CODE (TREE_TYPE (decl)) == TEMPLATE_TYPE_PARM) 765 /* template type parms have no mangling context. */ 766 return NULL_TREE; 767 return CP_DECL_CONTEXT (decl); 768 } 769 770 /* <name> ::= <unscoped-name> 771 ::= <unscoped-template-name> <template-args> 772 ::= <nested-name> 773 ::= <local-name> 774 775 If IGNORE_LOCAL_SCOPE is nonzero, this production of <name> is 776 called from <local-name>, which mangles the enclosing scope 777 elsewhere and then uses this function to mangle just the part 778 underneath the function scope. So don't use the <local-name> 779 production, to avoid an infinite recursion. */ 780 781 static void 782 write_name (tree decl, const int ignore_local_scope) 783 { 784 tree context; 785 786 MANGLE_TRACE_TREE ("name", decl); 787 788 if (TREE_CODE (decl) == TYPE_DECL) 789 { 790 /* In case this is a typedef, fish out the corresponding 791 TYPE_DECL for the main variant. */ 792 decl = TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))); 793 } 794 795 context = decl_mangling_context (decl); 796 797 /* A decl in :: or ::std scope is treated specially. The former is 798 mangled using <unscoped-name> or <unscoped-template-name>, the 799 latter with a special substitution. Also, a name that is 800 directly in a local function scope is also mangled with 801 <unscoped-name> rather than a full <nested-name>. */ 802 if (context == NULL 803 || context == global_namespace 804 || DECL_NAMESPACE_STD_P (context) 805 || (ignore_local_scope && TREE_CODE (context) == FUNCTION_DECL)) 806 { 807 tree template_info; 808 /* Is this a template instance? */ 809 if (decl_is_template_id (decl, &template_info)) 810 { 811 /* Yes: use <unscoped-template-name>. */ 812 write_unscoped_template_name (TI_TEMPLATE (template_info)); 813 write_template_args (TI_ARGS (template_info)); 814 } 815 else 816 /* Everything else gets an <unqualified-name>. */ 817 write_unscoped_name (decl); 818 } 819 else 820 { 821 /* Handle local names, unless we asked not to (that is, invoked 822 under <local-name>, to handle only the part of the name under 823 the local scope). */ 824 if (!ignore_local_scope) 825 { 826 /* Scan up the list of scope context, looking for a 827 function. If we find one, this entity is in local 828 function scope. local_entity tracks context one scope 829 level down, so it will contain the element that's 830 directly in that function's scope, either decl or one of 831 its enclosing scopes. */ 832 tree local_entity = decl; 833 while (context != NULL && context != global_namespace) 834 { 835 /* Make sure we're always dealing with decls. */ 836 if (context != NULL && TYPE_P (context)) 837 context = TYPE_NAME (context); 838 /* Is this a function? */ 839 if (TREE_CODE (context) == FUNCTION_DECL 840 || TREE_CODE (context) == PARM_DECL) 841 { 842 /* Yes, we have local scope. Use the <local-name> 843 production for the innermost function scope. */ 844 write_local_name (context, local_entity, decl); 845 return; 846 } 847 /* Up one scope level. */ 848 local_entity = context; 849 context = decl_mangling_context (context); 850 } 851 852 /* No local scope found? Fall through to <nested-name>. */ 853 } 854 855 /* Other decls get a <nested-name> to encode their scope. */ 856 write_nested_name (decl); 857 } 858 } 859 860 /* <unscoped-name> ::= <unqualified-name> 861 ::= St <unqualified-name> # ::std:: */ 862 863 static void 864 write_unscoped_name (const tree decl) 865 { 866 tree context = decl_mangling_context (decl); 867 868 MANGLE_TRACE_TREE ("unscoped-name", decl); 869 870 /* Is DECL in ::std? */ 871 if (DECL_NAMESPACE_STD_P (context)) 872 { 873 write_string ("St"); 874 write_unqualified_name (decl); 875 } 876 else 877 { 878 /* If not, it should be either in the global namespace, or directly 879 in a local function scope. */ 880 gcc_assert (context == global_namespace 881 || context != NULL 882 || TREE_CODE (context) == FUNCTION_DECL); 883 884 write_unqualified_name (decl); 885 } 886 } 887 888 /* <unscoped-template-name> ::= <unscoped-name> 889 ::= <substitution> */ 890 891 static void 892 write_unscoped_template_name (const tree decl) 893 { 894 MANGLE_TRACE_TREE ("unscoped-template-name", decl); 895 896 if (find_substitution (decl)) 897 return; 898 write_unscoped_name (decl); 899 add_substitution (decl); 900 } 901 902 /* Write the nested name, including CV-qualifiers, of DECL. 903 904 <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E 905 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E 906 907 <CV-qualifiers> ::= [r] [V] [K] */ 908 909 static void 910 write_nested_name (const tree decl) 911 { 912 tree template_info; 913 914 MANGLE_TRACE_TREE ("nested-name", decl); 915 916 write_char ('N'); 917 918 /* Write CV-qualifiers, if this is a member function. */ 919 if (TREE_CODE (decl) == FUNCTION_DECL 920 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)) 921 { 922 if (DECL_VOLATILE_MEMFUNC_P (decl)) 923 write_char ('V'); 924 if (DECL_CONST_MEMFUNC_P (decl)) 925 write_char ('K'); 926 } 927 928 /* Is this a template instance? */ 929 if (decl_is_template_id (decl, &template_info)) 930 { 931 /* Yes, use <template-prefix>. */ 932 write_template_prefix (decl); 933 write_template_args (TI_ARGS (template_info)); 934 } 935 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE) 936 { 937 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl)); 938 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 939 { 940 write_template_prefix (decl); 941 write_template_args (TREE_OPERAND (name, 1)); 942 } 943 else 944 { 945 write_prefix (CP_DECL_CONTEXT (decl)); 946 write_unqualified_name (decl); 947 } 948 } 949 else 950 { 951 /* No, just use <prefix> */ 952 write_prefix (decl_mangling_context (decl)); 953 write_unqualified_name (decl); 954 } 955 write_char ('E'); 956 } 957 958 /* <prefix> ::= <prefix> <unqualified-name> 959 ::= <template-param> 960 ::= <template-prefix> <template-args> 961 ::= <decltype> 962 ::= # empty 963 ::= <substitution> */ 964 965 static void 966 write_prefix (const tree node) 967 { 968 tree decl; 969 /* Non-NULL if NODE represents a template-id. */ 970 tree template_info = NULL; 971 972 if (node == NULL 973 || node == global_namespace) 974 return; 975 976 MANGLE_TRACE_TREE ("prefix", node); 977 978 if (TREE_CODE (node) == DECLTYPE_TYPE) 979 { 980 write_type (node); 981 return; 982 } 983 984 if (find_substitution (node)) 985 return; 986 987 if (DECL_P (node)) 988 { 989 /* If this is a function or parm decl, that means we've hit function 990 scope, so this prefix must be for a local name. In this 991 case, we're under the <local-name> production, which encodes 992 the enclosing function scope elsewhere. So don't continue 993 here. */ 994 if (TREE_CODE (node) == FUNCTION_DECL 995 || TREE_CODE (node) == PARM_DECL) 996 return; 997 998 decl = node; 999 decl_is_template_id (decl, &template_info); 1000 } 1001 else 1002 { 1003 /* Node is a type. */ 1004 decl = TYPE_NAME (node); 1005 if (CLASSTYPE_TEMPLATE_ID_P (node)) 1006 template_info = TYPE_TEMPLATE_INFO (node); 1007 } 1008 1009 /* In G++ 3.2, the name of the template parameter was used. */ 1010 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM 1011 && !abi_version_at_least (2)) 1012 G.need_abi_warning = true; 1013 1014 if (TREE_CODE (node) == TEMPLATE_TYPE_PARM 1015 && abi_version_at_least (2)) 1016 write_template_param (node); 1017 else if (template_info != NULL) 1018 /* Templated. */ 1019 { 1020 write_template_prefix (decl); 1021 write_template_args (TI_ARGS (template_info)); 1022 } 1023 else if (TREE_CODE (TREE_TYPE (decl)) == TYPENAME_TYPE) 1024 { 1025 tree name = TYPENAME_TYPE_FULLNAME (TREE_TYPE (decl)); 1026 if (TREE_CODE (name) == TEMPLATE_ID_EXPR) 1027 { 1028 write_template_prefix (decl); 1029 write_template_args (TREE_OPERAND (name, 1)); 1030 } 1031 else 1032 { 1033 write_prefix (CP_DECL_CONTEXT (decl)); 1034 write_unqualified_name (decl); 1035 } 1036 } 1037 else 1038 /* Not templated. */ 1039 { 1040 write_prefix (decl_mangling_context (decl)); 1041 write_unqualified_name (decl); 1042 if (TREE_CODE (decl) == VAR_DECL 1043 || TREE_CODE (decl) == FIELD_DECL) 1044 { 1045 /* <data-member-prefix> := <member source-name> M */ 1046 write_char ('M'); 1047 return; 1048 } 1049 } 1050 1051 add_substitution (node); 1052 } 1053 1054 /* <template-prefix> ::= <prefix> <template component> 1055 ::= <template-param> 1056 ::= <substitution> */ 1057 1058 static void 1059 write_template_prefix (const tree node) 1060 { 1061 tree decl = DECL_P (node) ? node : TYPE_NAME (node); 1062 tree type = DECL_P (node) ? TREE_TYPE (node) : node; 1063 tree context = CP_DECL_CONTEXT (decl); 1064 tree template_info; 1065 tree templ; 1066 tree substitution; 1067 1068 MANGLE_TRACE_TREE ("template-prefix", node); 1069 1070 /* Find the template decl. */ 1071 if (decl_is_template_id (decl, &template_info)) 1072 templ = TI_TEMPLATE (template_info); 1073 else if (TREE_CODE (type) == TYPENAME_TYPE) 1074 /* For a typename type, all we have is the name. */ 1075 templ = DECL_NAME (decl); 1076 else 1077 { 1078 gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type)); 1079 1080 templ = TYPE_TI_TEMPLATE (type); 1081 } 1082 1083 /* For a member template, though, the template name for the 1084 innermost name must have all the outer template levels 1085 instantiated. For instance, consider 1086 1087 template<typename T> struct Outer { 1088 template<typename U> struct Inner {}; 1089 }; 1090 1091 The template name for `Inner' in `Outer<int>::Inner<float>' is 1092 `Outer<int>::Inner<U>'. In g++, we don't instantiate the template 1093 levels separately, so there's no TEMPLATE_DECL available for this 1094 (there's only `Outer<T>::Inner<U>'). 1095 1096 In order to get the substitutions right, we create a special 1097 TREE_LIST to represent the substitution candidate for a nested 1098 template. The TREE_PURPOSE is the template's context, fully 1099 instantiated, and the TREE_VALUE is the TEMPLATE_DECL for the inner 1100 template. 1101 1102 So, for the example above, `Outer<int>::Inner' is represented as a 1103 substitution candidate by a TREE_LIST whose purpose is `Outer<int>' 1104 and whose value is `Outer<T>::Inner<U>'. */ 1105 if (TYPE_P (context)) 1106 substitution = build_tree_list (context, templ); 1107 else 1108 substitution = templ; 1109 1110 if (find_substitution (substitution)) 1111 return; 1112 1113 /* In G++ 3.2, the name of the template template parameter was used. */ 1114 if (TREE_TYPE (templ) 1115 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM 1116 && !abi_version_at_least (2)) 1117 G.need_abi_warning = true; 1118 1119 if (TREE_TYPE (templ) 1120 && TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM 1121 && abi_version_at_least (2)) 1122 write_template_param (TREE_TYPE (templ)); 1123 else 1124 { 1125 write_prefix (context); 1126 write_unqualified_name (decl); 1127 } 1128 1129 add_substitution (substitution); 1130 } 1131 1132 /* We don't need to handle thunks, vtables, or VTTs here. Those are 1133 mangled through special entry points. 1134 1135 <unqualified-name> ::= <operator-name> 1136 ::= <special-name> 1137 ::= <source-name> 1138 ::= <unnamed-type-name> 1139 ::= <local-source-name> 1140 1141 <local-source-name> ::= L <source-name> <discriminator> */ 1142 1143 static void 1144 write_unqualified_id (tree identifier) 1145 { 1146 if (IDENTIFIER_TYPENAME_P (identifier)) 1147 write_conversion_operator_name (TREE_TYPE (identifier)); 1148 else if (IDENTIFIER_OPNAME_P (identifier)) 1149 { 1150 int i; 1151 const char *mangled_name = NULL; 1152 1153 /* Unfortunately, there is no easy way to go from the 1154 name of the operator back to the corresponding tree 1155 code. */ 1156 for (i = 0; i < MAX_TREE_CODES; ++i) 1157 if (operator_name_info[i].identifier == identifier) 1158 { 1159 /* The ABI says that we prefer binary operator 1160 names to unary operator names. */ 1161 if (operator_name_info[i].arity == 2) 1162 { 1163 mangled_name = operator_name_info[i].mangled_name; 1164 break; 1165 } 1166 else if (!mangled_name) 1167 mangled_name = operator_name_info[i].mangled_name; 1168 } 1169 else if (assignment_operator_name_info[i].identifier 1170 == identifier) 1171 { 1172 mangled_name 1173 = assignment_operator_name_info[i].mangled_name; 1174 break; 1175 } 1176 write_string (mangled_name); 1177 } 1178 else if (UDLIT_OPER_P (identifier)) 1179 write_literal_operator_name (identifier); 1180 else 1181 write_source_name (identifier); 1182 } 1183 1184 static void 1185 write_unqualified_name (const tree decl) 1186 { 1187 MANGLE_TRACE_TREE ("unqualified-name", decl); 1188 1189 if (TREE_CODE (decl) == IDENTIFIER_NODE) 1190 { 1191 write_unqualified_id (decl); 1192 return; 1193 } 1194 1195 if (DECL_NAME (decl) == NULL_TREE) 1196 { 1197 gcc_assert (DECL_ASSEMBLER_NAME_SET_P (decl)); 1198 write_source_name (DECL_ASSEMBLER_NAME (decl)); 1199 return; 1200 } 1201 else if (DECL_DECLARES_FUNCTION_P (decl)) 1202 { 1203 bool found = true; 1204 if (DECL_CONSTRUCTOR_P (decl)) 1205 write_special_name_constructor (decl); 1206 else if (DECL_DESTRUCTOR_P (decl)) 1207 write_special_name_destructor (decl); 1208 else if (DECL_CONV_FN_P (decl)) 1209 { 1210 /* Conversion operator. Handle it right here. 1211 <operator> ::= cv <type> */ 1212 tree type; 1213 if (decl_is_template_id (decl, NULL)) 1214 { 1215 tree fn_type; 1216 fn_type = get_mostly_instantiated_function_type (decl); 1217 type = TREE_TYPE (fn_type); 1218 } 1219 else 1220 type = DECL_CONV_FN_TYPE (decl); 1221 write_conversion_operator_name (type); 1222 } 1223 else if (DECL_OVERLOADED_OPERATOR_P (decl)) 1224 { 1225 operator_name_info_t *oni; 1226 if (DECL_ASSIGNMENT_OPERATOR_P (decl)) 1227 oni = assignment_operator_name_info; 1228 else 1229 oni = operator_name_info; 1230 1231 write_string (oni[DECL_OVERLOADED_OPERATOR_P (decl)].mangled_name); 1232 } 1233 else if (UDLIT_OPER_P (DECL_NAME (decl))) 1234 write_literal_operator_name (DECL_NAME (decl)); 1235 else 1236 found = false; 1237 1238 if (found) 1239 return; 1240 } 1241 1242 if (VAR_OR_FUNCTION_DECL_P (decl) && ! TREE_PUBLIC (decl) 1243 && DECL_NAMESPACE_SCOPE_P (decl) 1244 && decl_linkage (decl) == lk_internal) 1245 { 1246 MANGLE_TRACE_TREE ("local-source-name", decl); 1247 write_char ('L'); 1248 write_source_name (DECL_NAME (decl)); 1249 /* The default discriminator is 1, and that's all we ever use, 1250 so there's no code to output one here. */ 1251 } 1252 else 1253 { 1254 tree type = TREE_TYPE (decl); 1255 1256 if (TREE_CODE (decl) == TYPE_DECL 1257 && TYPE_ANONYMOUS_P (type)) 1258 write_unnamed_type_name (type); 1259 else if (TREE_CODE (decl) == TYPE_DECL 1260 && LAMBDA_TYPE_P (type)) 1261 write_closure_type_name (type); 1262 else 1263 write_source_name (DECL_NAME (decl)); 1264 } 1265 } 1266 1267 /* Write the unqualified-name for a conversion operator to TYPE. */ 1268 1269 static void 1270 write_conversion_operator_name (const tree type) 1271 { 1272 write_string ("cv"); 1273 write_type (type); 1274 } 1275 1276 /* Non-terminal <source-name>. IDENTIFIER is an IDENTIFIER_NODE. 1277 1278 <source-name> ::= </length/ number> <identifier> */ 1279 1280 static void 1281 write_source_name (tree identifier) 1282 { 1283 MANGLE_TRACE_TREE ("source-name", identifier); 1284 1285 /* Never write the whole template-id name including the template 1286 arguments; we only want the template name. */ 1287 if (IDENTIFIER_TEMPLATE (identifier)) 1288 identifier = IDENTIFIER_TEMPLATE (identifier); 1289 1290 write_unsigned_number (IDENTIFIER_LENGTH (identifier)); 1291 write_identifier (IDENTIFIER_POINTER (identifier)); 1292 } 1293 1294 /* Write a user-defined literal operator. 1295 ::= li <source-name> # "" <source-name> 1296 IDENTIFIER is an LITERAL_IDENTIFIER_NODE. */ 1297 1298 static void 1299 write_literal_operator_name (tree identifier) 1300 { 1301 const char* suffix = UDLIT_OP_SUFFIX (identifier); 1302 write_identifier (UDLIT_OP_MANGLED_PREFIX); 1303 write_unsigned_number (strlen (suffix)); 1304 write_identifier (suffix); 1305 } 1306 1307 /* Encode 0 as _, and 1+ as n-1_. */ 1308 1309 static void 1310 write_compact_number (int num) 1311 { 1312 if (num > 0) 1313 write_unsigned_number (num - 1); 1314 write_char ('_'); 1315 } 1316 1317 /* Return how many unnamed types precede TYPE in its enclosing class. */ 1318 1319 static int 1320 nested_anon_class_index (tree type) 1321 { 1322 int index = 0; 1323 tree member = TYPE_FIELDS (TYPE_CONTEXT (type)); 1324 for (; member; member = DECL_CHAIN (member)) 1325 if (DECL_IMPLICIT_TYPEDEF_P (member)) 1326 { 1327 tree memtype = TREE_TYPE (member); 1328 if (memtype == type) 1329 return index; 1330 else if (TYPE_ANONYMOUS_P (memtype)) 1331 ++index; 1332 } 1333 1334 gcc_unreachable (); 1335 } 1336 1337 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */ 1338 1339 static void 1340 write_unnamed_type_name (const tree type ATTRIBUTE_UNUSED) 1341 { 1342 int discriminator; 1343 MANGLE_TRACE_TREE ("unnamed-type-name", type); 1344 1345 if (TYPE_FUNCTION_SCOPE_P (type)) 1346 discriminator = local_class_index (type); 1347 else if (TYPE_CLASS_SCOPE_P (type)) 1348 discriminator = nested_anon_class_index (type); 1349 else 1350 { 1351 gcc_assert (no_linkage_check (type, /*relaxed_p=*/true)); 1352 /* Just use the old mangling at namespace scope. */ 1353 write_source_name (TYPE_IDENTIFIER (type)); 1354 return; 1355 } 1356 1357 write_string ("Ut"); 1358 write_compact_number (discriminator); 1359 } 1360 1361 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ 1362 <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters */ 1363 1364 static void 1365 write_closure_type_name (const tree type) 1366 { 1367 tree fn = lambda_function (type); 1368 tree lambda = CLASSTYPE_LAMBDA_EXPR (type); 1369 tree parms = TYPE_ARG_TYPES (TREE_TYPE (fn)); 1370 1371 MANGLE_TRACE_TREE ("closure-type-name", type); 1372 1373 write_string ("Ul"); 1374 write_method_parms (parms, /*method_p=*/1, fn); 1375 write_char ('E'); 1376 write_compact_number (LAMBDA_EXPR_DISCRIMINATOR (lambda)); 1377 } 1378 1379 /* Convert NUMBER to ascii using base BASE and generating at least 1380 MIN_DIGITS characters. BUFFER points to the _end_ of the buffer 1381 into which to store the characters. Returns the number of 1382 characters generated (these will be layed out in advance of where 1383 BUFFER points). */ 1384 1385 static int 1386 hwint_to_ascii (unsigned HOST_WIDE_INT number, const unsigned int base, 1387 char *buffer, const unsigned int min_digits) 1388 { 1389 static const char base_digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 1390 unsigned digits = 0; 1391 1392 while (number) 1393 { 1394 unsigned HOST_WIDE_INT d = number / base; 1395 1396 *--buffer = base_digits[number - d * base]; 1397 digits++; 1398 number = d; 1399 } 1400 while (digits < min_digits) 1401 { 1402 *--buffer = base_digits[0]; 1403 digits++; 1404 } 1405 return digits; 1406 } 1407 1408 /* Non-terminal <number>. 1409 1410 <number> ::= [n] </decimal integer/> */ 1411 1412 static void 1413 write_number (unsigned HOST_WIDE_INT number, const int unsigned_p, 1414 const unsigned int base) 1415 { 1416 char buffer[sizeof (HOST_WIDE_INT) * 8]; 1417 unsigned count = 0; 1418 1419 if (!unsigned_p && (HOST_WIDE_INT) number < 0) 1420 { 1421 write_char ('n'); 1422 number = -((HOST_WIDE_INT) number); 1423 } 1424 count = hwint_to_ascii (number, base, buffer + sizeof (buffer), 1); 1425 write_chars (buffer + sizeof (buffer) - count, count); 1426 } 1427 1428 /* Write out an integral CST in decimal. Most numbers are small, and 1429 representable in a HOST_WIDE_INT. Occasionally we'll have numbers 1430 bigger than that, which we must deal with. */ 1431 1432 static inline void 1433 write_integer_cst (const tree cst) 1434 { 1435 int sign = tree_int_cst_sgn (cst); 1436 1437 if (TREE_INT_CST_HIGH (cst) + (sign < 0)) 1438 { 1439 /* A bignum. We do this in chunks, each of which fits in a 1440 HOST_WIDE_INT. */ 1441 char buffer[sizeof (HOST_WIDE_INT) * 8 * 2]; 1442 unsigned HOST_WIDE_INT chunk; 1443 unsigned chunk_digits; 1444 char *ptr = buffer + sizeof (buffer); 1445 unsigned count = 0; 1446 tree n, base, type; 1447 int done; 1448 1449 /* HOST_WIDE_INT must be at least 32 bits, so 10^9 is 1450 representable. */ 1451 chunk = 1000000000; 1452 chunk_digits = 9; 1453 1454 if (sizeof (HOST_WIDE_INT) >= 8) 1455 { 1456 /* It is at least 64 bits, so 10^18 is representable. */ 1457 chunk_digits = 18; 1458 chunk *= chunk; 1459 } 1460 1461 type = c_common_signed_or_unsigned_type (1, TREE_TYPE (cst)); 1462 base = build_int_cstu (type, chunk); 1463 n = build_int_cst_wide (type, 1464 TREE_INT_CST_LOW (cst), TREE_INT_CST_HIGH (cst)); 1465 1466 if (sign < 0) 1467 { 1468 write_char ('n'); 1469 n = fold_build1_loc (input_location, NEGATE_EXPR, type, n); 1470 } 1471 do 1472 { 1473 tree d = fold_build2_loc (input_location, FLOOR_DIV_EXPR, type, n, base); 1474 tree tmp = fold_build2_loc (input_location, MULT_EXPR, type, d, base); 1475 unsigned c; 1476 1477 done = integer_zerop (d); 1478 tmp = fold_build2_loc (input_location, MINUS_EXPR, type, n, tmp); 1479 c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr, 1480 done ? 1 : chunk_digits); 1481 ptr -= c; 1482 count += c; 1483 n = d; 1484 } 1485 while (!done); 1486 write_chars (ptr, count); 1487 } 1488 else 1489 { 1490 /* A small num. */ 1491 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst); 1492 1493 if (sign < 0) 1494 { 1495 write_char ('n'); 1496 low = -low; 1497 } 1498 write_unsigned_number (low); 1499 } 1500 } 1501 1502 /* Write out a floating-point literal. 1503 1504 "Floating-point literals are encoded using the bit pattern of the 1505 target processor's internal representation of that number, as a 1506 fixed-length lowercase hexadecimal string, high-order bytes first 1507 (even if the target processor would store low-order bytes first). 1508 The "n" prefix is not used for floating-point literals; the sign 1509 bit is encoded with the rest of the number. 1510 1511 Here are some examples, assuming the IEEE standard representation 1512 for floating point numbers. (Spaces are for readability, not 1513 part of the encoding.) 1514 1515 1.0f Lf 3f80 0000 E 1516 -1.0f Lf bf80 0000 E 1517 1.17549435e-38f Lf 0080 0000 E 1518 1.40129846e-45f Lf 0000 0001 E 1519 0.0f Lf 0000 0000 E" 1520 1521 Caller is responsible for the Lx and the E. */ 1522 static void 1523 write_real_cst (const tree value) 1524 { 1525 if (abi_version_at_least (2)) 1526 { 1527 long target_real[4]; /* largest supported float */ 1528 char buffer[9]; /* eight hex digits in a 32-bit number */ 1529 int i, limit, dir; 1530 1531 tree type = TREE_TYPE (value); 1532 int words = GET_MODE_BITSIZE (TYPE_MODE (type)) / 32; 1533 1534 real_to_target (target_real, &TREE_REAL_CST (value), 1535 TYPE_MODE (type)); 1536 1537 /* The value in target_real is in the target word order, 1538 so we must write it out backward if that happens to be 1539 little-endian. write_number cannot be used, it will 1540 produce uppercase. */ 1541 if (FLOAT_WORDS_BIG_ENDIAN) 1542 i = 0, limit = words, dir = 1; 1543 else 1544 i = words - 1, limit = -1, dir = -1; 1545 1546 for (; i != limit; i += dir) 1547 { 1548 sprintf (buffer, "%08lx", (unsigned long) target_real[i]); 1549 write_chars (buffer, 8); 1550 } 1551 } 1552 else 1553 { 1554 /* In G++ 3.3 and before the REAL_VALUE_TYPE was written out 1555 literally. Note that compatibility with 3.2 is impossible, 1556 because the old floating-point emulator used a different 1557 format for REAL_VALUE_TYPE. */ 1558 size_t i; 1559 for (i = 0; i < sizeof (TREE_REAL_CST (value)); ++i) 1560 write_number (((unsigned char *) &TREE_REAL_CST (value))[i], 1561 /*unsigned_p*/ 1, 1562 /*base*/ 16); 1563 G.need_abi_warning = 1; 1564 } 1565 } 1566 1567 /* Non-terminal <identifier>. 1568 1569 <identifier> ::= </unqualified source code identifier> */ 1570 1571 static void 1572 write_identifier (const char *identifier) 1573 { 1574 MANGLE_TRACE ("identifier", identifier); 1575 write_string (identifier); 1576 } 1577 1578 /* Handle constructor productions of non-terminal <special-name>. 1579 CTOR is a constructor FUNCTION_DECL. 1580 1581 <special-name> ::= C1 # complete object constructor 1582 ::= C2 # base object constructor 1583 ::= C3 # complete object allocating constructor 1584 1585 Currently, allocating constructors are never used. 1586 1587 We also need to provide mangled names for the maybe-in-charge 1588 constructor, so we treat it here too. mangle_decl_string will 1589 append *INTERNAL* to that, to make sure we never emit it. */ 1590 1591 static void 1592 write_special_name_constructor (const tree ctor) 1593 { 1594 if (DECL_BASE_CONSTRUCTOR_P (ctor)) 1595 write_string ("C2"); 1596 else 1597 { 1598 gcc_assert (DECL_COMPLETE_CONSTRUCTOR_P (ctor) 1599 /* Even though we don't ever emit a definition of 1600 the old-style destructor, we still have to 1601 consider entities (like static variables) nested 1602 inside it. */ 1603 || DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (ctor)); 1604 write_string ("C1"); 1605 } 1606 } 1607 1608 /* Handle destructor productions of non-terminal <special-name>. 1609 DTOR is a destructor FUNCTION_DECL. 1610 1611 <special-name> ::= D0 # deleting (in-charge) destructor 1612 ::= D1 # complete object (in-charge) destructor 1613 ::= D2 # base object (not-in-charge) destructor 1614 1615 We also need to provide mangled names for the maybe-incharge 1616 destructor, so we treat it here too. mangle_decl_string will 1617 append *INTERNAL* to that, to make sure we never emit it. */ 1618 1619 static void 1620 write_special_name_destructor (const tree dtor) 1621 { 1622 if (DECL_DELETING_DESTRUCTOR_P (dtor)) 1623 write_string ("D0"); 1624 else if (DECL_BASE_DESTRUCTOR_P (dtor)) 1625 write_string ("D2"); 1626 else 1627 { 1628 gcc_assert (DECL_COMPLETE_DESTRUCTOR_P (dtor) 1629 /* Even though we don't ever emit a definition of 1630 the old-style destructor, we still have to 1631 consider entities (like static variables) nested 1632 inside it. */ 1633 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (dtor)); 1634 write_string ("D1"); 1635 } 1636 } 1637 1638 /* Scan the vector of local classes and return how many others with the 1639 same name (or same no name) and context precede ENTITY. */ 1640 1641 static int 1642 local_class_index (tree entity) 1643 { 1644 int ix, discriminator = 0; 1645 tree name = (TYPE_ANONYMOUS_P (entity) ? NULL_TREE 1646 : TYPE_IDENTIFIER (entity)); 1647 tree ctx = TYPE_CONTEXT (entity); 1648 for (ix = 0; ; ix++) 1649 { 1650 tree type = VEC_index (tree, local_classes, ix); 1651 if (type == entity) 1652 return discriminator; 1653 if (TYPE_CONTEXT (type) == ctx 1654 && (name ? TYPE_IDENTIFIER (type) == name 1655 : TYPE_ANONYMOUS_P (type))) 1656 ++discriminator; 1657 } 1658 gcc_unreachable (); 1659 } 1660 1661 /* Return the discriminator for ENTITY appearing inside 1662 FUNCTION. The discriminator is the lexical ordinal of VAR among 1663 entities with the same name in the same FUNCTION. */ 1664 1665 static int 1666 discriminator_for_local_entity (tree entity) 1667 { 1668 if (DECL_DISCRIMINATOR_P (entity)) 1669 { 1670 if (DECL_DISCRIMINATOR_SET_P (entity)) 1671 return DECL_DISCRIMINATOR (entity); 1672 else 1673 /* The first entity with a particular name doesn't get 1674 DECL_DISCRIMINATOR set up. */ 1675 return 0; 1676 } 1677 else if (TREE_CODE (entity) == TYPE_DECL) 1678 { 1679 /* Scan the list of local classes. */ 1680 entity = TREE_TYPE (entity); 1681 1682 /* Lambdas and unnamed types have their own discriminators. */ 1683 if (LAMBDA_TYPE_P (entity) || TYPE_ANONYMOUS_P (entity)) 1684 return 0; 1685 1686 return local_class_index (entity); 1687 } 1688 else 1689 gcc_unreachable (); 1690 } 1691 1692 /* Return the discriminator for STRING, a string literal used inside 1693 FUNCTION. The discriminator is the lexical ordinal of STRING among 1694 string literals used in FUNCTION. */ 1695 1696 static int 1697 discriminator_for_string_literal (tree function ATTRIBUTE_UNUSED, 1698 tree string ATTRIBUTE_UNUSED) 1699 { 1700 /* For now, we don't discriminate amongst string literals. */ 1701 return 0; 1702 } 1703 1704 /* <discriminator> := _ <number> 1705 1706 The discriminator is used only for the second and later occurrences 1707 of the same name within a single function. In this case <number> is 1708 n - 2, if this is the nth occurrence, in lexical order. */ 1709 1710 static void 1711 write_discriminator (const int discriminator) 1712 { 1713 /* If discriminator is zero, don't write anything. Otherwise... */ 1714 if (discriminator > 0) 1715 { 1716 write_char ('_'); 1717 write_unsigned_number (discriminator - 1); 1718 } 1719 } 1720 1721 /* Mangle the name of a function-scope entity. FUNCTION is the 1722 FUNCTION_DECL for the enclosing function, or a PARM_DECL for lambdas in 1723 default argument scope. ENTITY is the decl for the entity itself. 1724 LOCAL_ENTITY is the entity that's directly scoped in FUNCTION_DECL, 1725 either ENTITY itself or an enclosing scope of ENTITY. 1726 1727 <local-name> := Z <function encoding> E <entity name> [<discriminator>] 1728 := Z <function encoding> E s [<discriminator>] 1729 := Z <function encoding> Ed [ <parameter number> ] _ <entity name> */ 1730 1731 static void 1732 write_local_name (tree function, const tree local_entity, 1733 const tree entity) 1734 { 1735 tree parm = NULL_TREE; 1736 1737 MANGLE_TRACE_TREE ("local-name", entity); 1738 1739 if (TREE_CODE (function) == PARM_DECL) 1740 { 1741 parm = function; 1742 function = DECL_CONTEXT (parm); 1743 } 1744 1745 write_char ('Z'); 1746 write_encoding (function); 1747 write_char ('E'); 1748 1749 /* For this purpose, parameters are numbered from right-to-left. */ 1750 if (parm) 1751 { 1752 tree t; 1753 int i = 0; 1754 for (t = DECL_ARGUMENTS (function); t; t = DECL_CHAIN (t)) 1755 { 1756 if (t == parm) 1757 i = 1; 1758 else if (i) 1759 ++i; 1760 } 1761 write_char ('d'); 1762 write_compact_number (i - 1); 1763 } 1764 1765 if (TREE_CODE (entity) == STRING_CST) 1766 { 1767 write_char ('s'); 1768 write_discriminator (discriminator_for_string_literal (function, 1769 entity)); 1770 } 1771 else 1772 { 1773 /* Now the <entity name>. Let write_name know its being called 1774 from <local-name>, so it doesn't try to process the enclosing 1775 function scope again. */ 1776 write_name (entity, /*ignore_local_scope=*/1); 1777 write_discriminator (discriminator_for_local_entity (local_entity)); 1778 } 1779 } 1780 1781 /* Non-terminals <type> and <CV-qualifier>. 1782 1783 <type> ::= <builtin-type> 1784 ::= <function-type> 1785 ::= <class-enum-type> 1786 ::= <array-type> 1787 ::= <pointer-to-member-type> 1788 ::= <template-param> 1789 ::= <substitution> 1790 ::= <CV-qualifier> 1791 ::= P <type> # pointer-to 1792 ::= R <type> # reference-to 1793 ::= C <type> # complex pair (C 2000) 1794 ::= G <type> # imaginary (C 2000) [not supported] 1795 ::= U <source-name> <type> # vendor extended type qualifier 1796 1797 C++0x extensions 1798 1799 <type> ::= RR <type> # rvalue reference-to 1800 <type> ::= Dt <expression> # decltype of an id-expression or 1801 # class member access 1802 <type> ::= DT <expression> # decltype of an expression 1803 <type> ::= Dn # decltype of nullptr 1804 1805 TYPE is a type node. */ 1806 1807 static void 1808 write_type (tree type) 1809 { 1810 /* This gets set to nonzero if TYPE turns out to be a (possibly 1811 CV-qualified) builtin type. */ 1812 int is_builtin_type = 0; 1813 1814 MANGLE_TRACE_TREE ("type", type); 1815 1816 if (type == error_mark_node) 1817 return; 1818 1819 type = canonicalize_for_substitution (type); 1820 if (find_substitution (type)) 1821 return; 1822 1823 1824 if (write_CV_qualifiers_for_type (type) > 0) 1825 /* If TYPE was CV-qualified, we just wrote the qualifiers; now 1826 mangle the unqualified type. The recursive call is needed here 1827 since both the qualified and unqualified types are substitution 1828 candidates. */ 1829 write_type (TYPE_MAIN_VARIANT (type)); 1830 else if (TREE_CODE (type) == ARRAY_TYPE) 1831 /* It is important not to use the TYPE_MAIN_VARIANT of TYPE here 1832 so that the cv-qualification of the element type is available 1833 in write_array_type. */ 1834 write_array_type (type); 1835 else 1836 { 1837 tree type_orig = type; 1838 1839 /* See through any typedefs. */ 1840 type = TYPE_MAIN_VARIANT (type); 1841 1842 /* According to the C++ ABI, some library classes are passed the 1843 same as the scalar type of their single member and use the same 1844 mangling. */ 1845 if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type)) 1846 type = TREE_TYPE (first_field (type)); 1847 1848 if (TYPE_PTRMEM_P (type)) 1849 write_pointer_to_member_type (type); 1850 else 1851 { 1852 /* Handle any target-specific fundamental types. */ 1853 const char *target_mangling 1854 = targetm.mangle_type (type_orig); 1855 1856 if (target_mangling) 1857 { 1858 write_string (target_mangling); 1859 /* Add substitutions for types other than fundamental 1860 types. */ 1861 if (TREE_CODE (type) != VOID_TYPE 1862 && TREE_CODE (type) != INTEGER_TYPE 1863 && TREE_CODE (type) != REAL_TYPE 1864 && TREE_CODE (type) != BOOLEAN_TYPE) 1865 add_substitution (type); 1866 return; 1867 } 1868 1869 switch (TREE_CODE (type)) 1870 { 1871 case VOID_TYPE: 1872 case BOOLEAN_TYPE: 1873 case INTEGER_TYPE: /* Includes wchar_t. */ 1874 case REAL_TYPE: 1875 case FIXED_POINT_TYPE: 1876 { 1877 /* If this is a typedef, TYPE may not be one of 1878 the standard builtin type nodes, but an alias of one. Use 1879 TYPE_MAIN_VARIANT to get to the underlying builtin type. */ 1880 write_builtin_type (TYPE_MAIN_VARIANT (type)); 1881 ++is_builtin_type; 1882 } 1883 break; 1884 1885 case COMPLEX_TYPE: 1886 write_char ('C'); 1887 write_type (TREE_TYPE (type)); 1888 break; 1889 1890 case FUNCTION_TYPE: 1891 case METHOD_TYPE: 1892 write_function_type (type); 1893 break; 1894 1895 case UNION_TYPE: 1896 case RECORD_TYPE: 1897 case ENUMERAL_TYPE: 1898 /* A pointer-to-member function is represented as a special 1899 RECORD_TYPE, so check for this first. */ 1900 if (TYPE_PTRMEMFUNC_P (type)) 1901 write_pointer_to_member_type (type); 1902 else 1903 write_class_enum_type (type); 1904 break; 1905 1906 case TYPENAME_TYPE: 1907 case UNBOUND_CLASS_TEMPLATE: 1908 /* We handle TYPENAME_TYPEs and UNBOUND_CLASS_TEMPLATEs like 1909 ordinary nested names. */ 1910 write_nested_name (TYPE_STUB_DECL (type)); 1911 break; 1912 1913 case POINTER_TYPE: 1914 case REFERENCE_TYPE: 1915 if (TREE_CODE (type) == POINTER_TYPE) 1916 write_char ('P'); 1917 else if (TYPE_REF_IS_RVALUE (type)) 1918 write_char ('O'); 1919 else 1920 write_char ('R'); 1921 { 1922 tree target = TREE_TYPE (type); 1923 /* Attribute const/noreturn are not reflected in mangling. 1924 We strip them here rather than at a lower level because 1925 a typedef or template argument can have function type 1926 with function-cv-quals (that use the same representation), 1927 but you can't have a pointer/reference to such a type. */ 1928 if (abi_version_at_least (5) 1929 && TREE_CODE (target) == FUNCTION_TYPE) 1930 target = build_qualified_type (target, TYPE_UNQUALIFIED); 1931 write_type (target); 1932 } 1933 break; 1934 1935 case TEMPLATE_TYPE_PARM: 1936 if (is_auto (type)) 1937 { 1938 write_identifier ("Da"); 1939 ++is_builtin_type; 1940 break; 1941 } 1942 /* else fall through. */ 1943 case TEMPLATE_PARM_INDEX: 1944 write_template_param (type); 1945 break; 1946 1947 case TEMPLATE_TEMPLATE_PARM: 1948 write_template_template_param (type); 1949 break; 1950 1951 case BOUND_TEMPLATE_TEMPLATE_PARM: 1952 write_template_template_param (type); 1953 write_template_args 1954 (TI_ARGS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (type))); 1955 break; 1956 1957 case VECTOR_TYPE: 1958 if (abi_version_at_least (4)) 1959 { 1960 write_string ("Dv"); 1961 /* Non-constant vector size would be encoded with 1962 _ expression, but we don't support that yet. */ 1963 write_unsigned_number (TYPE_VECTOR_SUBPARTS (type)); 1964 write_char ('_'); 1965 } 1966 else 1967 { 1968 G.need_abi_warning = 1; 1969 write_string ("U8__vector"); 1970 } 1971 write_type (TREE_TYPE (type)); 1972 break; 1973 1974 case TYPE_PACK_EXPANSION: 1975 write_string ("Dp"); 1976 write_type (PACK_EXPANSION_PATTERN (type)); 1977 break; 1978 1979 case DECLTYPE_TYPE: 1980 /* These shouldn't make it into mangling. */ 1981 gcc_assert (!DECLTYPE_FOR_LAMBDA_CAPTURE (type) 1982 && !DECLTYPE_FOR_LAMBDA_PROXY (type)); 1983 1984 /* In ABI <5, we stripped decltype of a plain decl. */ 1985 if (!abi_version_at_least (5) 1986 && DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)) 1987 { 1988 tree expr = DECLTYPE_TYPE_EXPR (type); 1989 tree etype = NULL_TREE; 1990 switch (TREE_CODE (expr)) 1991 { 1992 case VAR_DECL: 1993 case PARM_DECL: 1994 case RESULT_DECL: 1995 case FUNCTION_DECL: 1996 case CONST_DECL: 1997 case TEMPLATE_PARM_INDEX: 1998 etype = TREE_TYPE (expr); 1999 break; 2000 2001 default: 2002 break; 2003 } 2004 2005 if (etype && !type_uses_auto (etype)) 2006 { 2007 G.need_abi_warning = 1; 2008 write_type (etype); 2009 return; 2010 } 2011 } 2012 2013 write_char ('D'); 2014 if (DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P (type)) 2015 write_char ('t'); 2016 else 2017 write_char ('T'); 2018 ++cp_unevaluated_operand; 2019 write_expression (DECLTYPE_TYPE_EXPR (type)); 2020 --cp_unevaluated_operand; 2021 write_char ('E'); 2022 break; 2023 2024 case NULLPTR_TYPE: 2025 write_string ("Dn"); 2026 break; 2027 2028 case TYPEOF_TYPE: 2029 sorry ("mangling typeof, use decltype instead"); 2030 break; 2031 2032 case UNDERLYING_TYPE: 2033 sorry ("mangling __underlying_type"); 2034 break; 2035 2036 case LANG_TYPE: 2037 /* fall through. */ 2038 2039 default: 2040 gcc_unreachable (); 2041 } 2042 } 2043 } 2044 2045 /* Types other than builtin types are substitution candidates. */ 2046 if (!is_builtin_type) 2047 add_substitution (type); 2048 } 2049 2050 /* Non-terminal <CV-qualifiers> for type nodes. Returns the number of 2051 CV-qualifiers written for TYPE. 2052 2053 <CV-qualifiers> ::= [r] [V] [K] */ 2054 2055 static int 2056 write_CV_qualifiers_for_type (const tree type) 2057 { 2058 int num_qualifiers = 0; 2059 2060 /* The order is specified by: 2061 2062 "In cases where multiple order-insensitive qualifiers are 2063 present, they should be ordered 'K' (closest to the base type), 2064 'V', 'r', and 'U' (farthest from the base type) ..." 2065 2066 Note that we do not use cp_type_quals below; given "const 2067 int[3]", the "const" is emitted with the "int", not with the 2068 array. */ 2069 cp_cv_quals quals = TYPE_QUALS (type); 2070 2071 if (quals & TYPE_QUAL_RESTRICT) 2072 { 2073 write_char ('r'); 2074 ++num_qualifiers; 2075 } 2076 if (quals & TYPE_QUAL_VOLATILE) 2077 { 2078 write_char ('V'); 2079 ++num_qualifiers; 2080 } 2081 if (quals & TYPE_QUAL_CONST) 2082 { 2083 write_char ('K'); 2084 ++num_qualifiers; 2085 } 2086 2087 return num_qualifiers; 2088 } 2089 2090 /* Non-terminal <builtin-type>. 2091 2092 <builtin-type> ::= v # void 2093 ::= b # bool 2094 ::= w # wchar_t 2095 ::= c # char 2096 ::= a # signed char 2097 ::= h # unsigned char 2098 ::= s # short 2099 ::= t # unsigned short 2100 ::= i # int 2101 ::= j # unsigned int 2102 ::= l # long 2103 ::= m # unsigned long 2104 ::= x # long long, __int64 2105 ::= y # unsigned long long, __int64 2106 ::= n # __int128 2107 ::= o # unsigned __int128 2108 ::= f # float 2109 ::= d # double 2110 ::= e # long double, __float80 2111 ::= g # __float128 [not supported] 2112 ::= u <source-name> # vendor extended type */ 2113 2114 static void 2115 write_builtin_type (tree type) 2116 { 2117 if (TYPE_CANONICAL (type)) 2118 type = TYPE_CANONICAL (type); 2119 2120 switch (TREE_CODE (type)) 2121 { 2122 case VOID_TYPE: 2123 write_char ('v'); 2124 break; 2125 2126 case BOOLEAN_TYPE: 2127 write_char ('b'); 2128 break; 2129 2130 case INTEGER_TYPE: 2131 /* TYPE may still be wchar_t, char16_t, or char32_t, since that 2132 isn't in integer_type_nodes. */ 2133 if (type == wchar_type_node) 2134 write_char ('w'); 2135 else if (type == char16_type_node) 2136 write_string ("Ds"); 2137 else if (type == char32_type_node) 2138 write_string ("Di"); 2139 else if (TYPE_FOR_JAVA (type)) 2140 write_java_integer_type_codes (type); 2141 else 2142 { 2143 size_t itk; 2144 /* Assume TYPE is one of the shared integer type nodes. Find 2145 it in the array of these nodes. */ 2146 iagain: 2147 for (itk = 0; itk < itk_none; ++itk) 2148 if (integer_types[itk] != NULL_TREE 2149 && type == integer_types[itk]) 2150 { 2151 /* Print the corresponding single-letter code. */ 2152 write_char (integer_type_codes[itk]); 2153 break; 2154 } 2155 2156 if (itk == itk_none) 2157 { 2158 tree t = c_common_type_for_mode (TYPE_MODE (type), 2159 TYPE_UNSIGNED (type)); 2160 if (type != t) 2161 { 2162 type = t; 2163 goto iagain; 2164 } 2165 2166 if (TYPE_PRECISION (type) == 128) 2167 write_char (TYPE_UNSIGNED (type) ? 'o' : 'n'); 2168 else 2169 { 2170 /* Allow for cases where TYPE is not one of the shared 2171 integer type nodes and write a "vendor extended builtin 2172 type" with a name the form intN or uintN, respectively. 2173 Situations like this can happen if you have an 2174 __attribute__((__mode__(__SI__))) type and use exotic 2175 switches like '-mint8' on AVR. Of course, this is 2176 undefined by the C++ ABI (and '-mint8' is not even 2177 Standard C conforming), but when using such special 2178 options you're pretty much in nowhere land anyway. */ 2179 const char *prefix; 2180 char prec[11]; /* up to ten digits for an unsigned */ 2181 2182 prefix = TYPE_UNSIGNED (type) ? "uint" : "int"; 2183 sprintf (prec, "%u", (unsigned) TYPE_PRECISION (type)); 2184 write_char ('u'); /* "vendor extended builtin type" */ 2185 write_unsigned_number (strlen (prefix) + strlen (prec)); 2186 write_string (prefix); 2187 write_string (prec); 2188 } 2189 } 2190 } 2191 break; 2192 2193 case REAL_TYPE: 2194 if (type == float_type_node 2195 || type == java_float_type_node) 2196 write_char ('f'); 2197 else if (type == double_type_node 2198 || type == java_double_type_node) 2199 write_char ('d'); 2200 else if (type == long_double_type_node) 2201 write_char ('e'); 2202 else if (type == dfloat32_type_node) 2203 write_string ("Df"); 2204 else if (type == dfloat64_type_node) 2205 write_string ("Dd"); 2206 else if (type == dfloat128_type_node) 2207 write_string ("De"); 2208 else 2209 gcc_unreachable (); 2210 break; 2211 2212 case FIXED_POINT_TYPE: 2213 write_string ("DF"); 2214 if (GET_MODE_IBIT (TYPE_MODE (type)) > 0) 2215 write_unsigned_number (GET_MODE_IBIT (TYPE_MODE (type))); 2216 if (type == fract_type_node 2217 || type == sat_fract_type_node 2218 || type == accum_type_node 2219 || type == sat_accum_type_node) 2220 write_char ('i'); 2221 else if (type == unsigned_fract_type_node 2222 || type == sat_unsigned_fract_type_node 2223 || type == unsigned_accum_type_node 2224 || type == sat_unsigned_accum_type_node) 2225 write_char ('j'); 2226 else if (type == short_fract_type_node 2227 || type == sat_short_fract_type_node 2228 || type == short_accum_type_node 2229 || type == sat_short_accum_type_node) 2230 write_char ('s'); 2231 else if (type == unsigned_short_fract_type_node 2232 || type == sat_unsigned_short_fract_type_node 2233 || type == unsigned_short_accum_type_node 2234 || type == sat_unsigned_short_accum_type_node) 2235 write_char ('t'); 2236 else if (type == long_fract_type_node 2237 || type == sat_long_fract_type_node 2238 || type == long_accum_type_node 2239 || type == sat_long_accum_type_node) 2240 write_char ('l'); 2241 else if (type == unsigned_long_fract_type_node 2242 || type == sat_unsigned_long_fract_type_node 2243 || type == unsigned_long_accum_type_node 2244 || type == sat_unsigned_long_accum_type_node) 2245 write_char ('m'); 2246 else if (type == long_long_fract_type_node 2247 || type == sat_long_long_fract_type_node 2248 || type == long_long_accum_type_node 2249 || type == sat_long_long_accum_type_node) 2250 write_char ('x'); 2251 else if (type == unsigned_long_long_fract_type_node 2252 || type == sat_unsigned_long_long_fract_type_node 2253 || type == unsigned_long_long_accum_type_node 2254 || type == sat_unsigned_long_long_accum_type_node) 2255 write_char ('y'); 2256 else 2257 sorry ("mangling unknown fixed point type"); 2258 write_unsigned_number (GET_MODE_FBIT (TYPE_MODE (type))); 2259 if (TYPE_SATURATING (type)) 2260 write_char ('s'); 2261 else 2262 write_char ('n'); 2263 break; 2264 2265 default: 2266 gcc_unreachable (); 2267 } 2268 } 2269 2270 /* Non-terminal <function-type>. NODE is a FUNCTION_TYPE or 2271 METHOD_TYPE. The return type is mangled before the parameter 2272 types. 2273 2274 <function-type> ::= F [Y] <bare-function-type> E */ 2275 2276 static void 2277 write_function_type (const tree type) 2278 { 2279 MANGLE_TRACE_TREE ("function-type", type); 2280 2281 /* For a pointer to member function, the function type may have 2282 cv-qualifiers, indicating the quals for the artificial 'this' 2283 parameter. */ 2284 if (TREE_CODE (type) == METHOD_TYPE) 2285 { 2286 /* The first parameter must be a POINTER_TYPE pointing to the 2287 `this' parameter. */ 2288 tree this_type = class_of_this_parm (type); 2289 write_CV_qualifiers_for_type (this_type); 2290 } 2291 2292 write_char ('F'); 2293 /* We don't track whether or not a type is `extern "C"'. Note that 2294 you can have an `extern "C"' function that does not have 2295 `extern "C"' type, and vice versa: 2296 2297 extern "C" typedef void function_t(); 2298 function_t f; // f has C++ linkage, but its type is 2299 // `extern "C"' 2300 2301 typedef void function_t(); 2302 extern "C" function_t f; // Vice versa. 2303 2304 See [dcl.link]. */ 2305 write_bare_function_type (type, /*include_return_type_p=*/1, 2306 /*decl=*/NULL); 2307 write_char ('E'); 2308 } 2309 2310 /* Non-terminal <bare-function-type>. TYPE is a FUNCTION_TYPE or 2311 METHOD_TYPE. If INCLUDE_RETURN_TYPE is nonzero, the return value 2312 is mangled before the parameter types. If non-NULL, DECL is 2313 FUNCTION_DECL for the function whose type is being emitted. 2314 2315 If DECL is a member of a Java type, then a literal 'J' 2316 is output and the return type is mangled as if INCLUDE_RETURN_TYPE 2317 were nonzero. 2318 2319 <bare-function-type> ::= [J]</signature/ type>+ */ 2320 2321 static void 2322 write_bare_function_type (const tree type, const int include_return_type_p, 2323 const tree decl) 2324 { 2325 int java_method_p; 2326 2327 MANGLE_TRACE_TREE ("bare-function-type", type); 2328 2329 /* Detect Java methods and emit special encoding. */ 2330 if (decl != NULL 2331 && DECL_FUNCTION_MEMBER_P (decl) 2332 && TYPE_FOR_JAVA (DECL_CONTEXT (decl)) 2333 && !DECL_CONSTRUCTOR_P (decl) 2334 && !DECL_DESTRUCTOR_P (decl) 2335 && !DECL_CONV_FN_P (decl)) 2336 { 2337 java_method_p = 1; 2338 write_char ('J'); 2339 } 2340 else 2341 { 2342 java_method_p = 0; 2343 } 2344 2345 /* Mangle the return type, if requested. */ 2346 if (include_return_type_p || java_method_p) 2347 write_type (TREE_TYPE (type)); 2348 2349 /* Now mangle the types of the arguments. */ 2350 ++G.parm_depth; 2351 write_method_parms (TYPE_ARG_TYPES (type), 2352 TREE_CODE (type) == METHOD_TYPE, 2353 decl); 2354 --G.parm_depth; 2355 } 2356 2357 /* Write the mangled representation of a method parameter list of 2358 types given in PARM_TYPES. If METHOD_P is nonzero, the function is 2359 considered a non-static method, and the this parameter is omitted. 2360 If non-NULL, DECL is the FUNCTION_DECL for the function whose 2361 parameters are being emitted. */ 2362 2363 static void 2364 write_method_parms (tree parm_types, const int method_p, const tree decl) 2365 { 2366 tree first_parm_type; 2367 tree parm_decl = decl ? DECL_ARGUMENTS (decl) : NULL_TREE; 2368 2369 /* Assume this parameter type list is variable-length. If it ends 2370 with a void type, then it's not. */ 2371 int varargs_p = 1; 2372 2373 /* If this is a member function, skip the first arg, which is the 2374 this pointer. 2375 "Member functions do not encode the type of their implicit this 2376 parameter." 2377 2378 Similarly, there's no need to mangle artificial parameters, like 2379 the VTT parameters for constructors and destructors. */ 2380 if (method_p) 2381 { 2382 parm_types = TREE_CHAIN (parm_types); 2383 parm_decl = parm_decl ? DECL_CHAIN (parm_decl) : NULL_TREE; 2384 2385 while (parm_decl && DECL_ARTIFICIAL (parm_decl)) 2386 { 2387 parm_types = TREE_CHAIN (parm_types); 2388 parm_decl = DECL_CHAIN (parm_decl); 2389 } 2390 } 2391 2392 for (first_parm_type = parm_types; 2393 parm_types; 2394 parm_types = TREE_CHAIN (parm_types)) 2395 { 2396 tree parm = TREE_VALUE (parm_types); 2397 if (parm == void_type_node) 2398 { 2399 /* "Empty parameter lists, whether declared as () or 2400 conventionally as (void), are encoded with a void parameter 2401 (v)." */ 2402 if (parm_types == first_parm_type) 2403 write_type (parm); 2404 /* If the parm list is terminated with a void type, it's 2405 fixed-length. */ 2406 varargs_p = 0; 2407 /* A void type better be the last one. */ 2408 gcc_assert (TREE_CHAIN (parm_types) == NULL); 2409 } 2410 else 2411 write_type (parm); 2412 } 2413 2414 if (varargs_p) 2415 /* <builtin-type> ::= z # ellipsis */ 2416 write_char ('z'); 2417 } 2418 2419 /* <class-enum-type> ::= <name> */ 2420 2421 static void 2422 write_class_enum_type (const tree type) 2423 { 2424 write_name (TYPE_NAME (type), /*ignore_local_scope=*/0); 2425 } 2426 2427 /* Non-terminal <template-args>. ARGS is a TREE_VEC of template 2428 arguments. 2429 2430 <template-args> ::= I <template-arg>* E */ 2431 2432 static void 2433 write_template_args (tree args) 2434 { 2435 int i; 2436 int length = 0; 2437 2438 MANGLE_TRACE_TREE ("template-args", args); 2439 2440 write_char ('I'); 2441 2442 if (args) 2443 length = TREE_VEC_LENGTH (args); 2444 2445 if (args && TREE_CODE (TREE_VEC_ELT (args, 0)) == TREE_VEC) 2446 { 2447 /* We have nested template args. We want the innermost template 2448 argument list. */ 2449 args = TREE_VEC_ELT (args, length - 1); 2450 length = TREE_VEC_LENGTH (args); 2451 } 2452 for (i = 0; i < length; ++i) 2453 write_template_arg (TREE_VEC_ELT (args, i)); 2454 2455 write_char ('E'); 2456 } 2457 2458 /* Write out the 2459 <unqualified-name> 2460 <unqualified-name> <template-args> 2461 part of SCOPE_REF or COMPONENT_REF mangling. */ 2462 2463 static void 2464 write_member_name (tree member) 2465 { 2466 if (TREE_CODE (member) == IDENTIFIER_NODE) 2467 write_unqualified_id (member); 2468 else if (DECL_P (member)) 2469 write_unqualified_name (member); 2470 else if (TREE_CODE (member) == TEMPLATE_ID_EXPR) 2471 { 2472 tree name = TREE_OPERAND (member, 0); 2473 if (TREE_CODE (name) == OVERLOAD) 2474 name = OVL_FUNCTION (name); 2475 write_member_name (name); 2476 write_template_args (TREE_OPERAND (member, 1)); 2477 } 2478 else 2479 write_expression (member); 2480 } 2481 2482 /* <expression> ::= <unary operator-name> <expression> 2483 ::= <binary operator-name> <expression> <expression> 2484 ::= <expr-primary> 2485 2486 <expr-primary> ::= <template-param> 2487 ::= L <type> <value number> E # literal 2488 ::= L <mangled-name> E # external name 2489 ::= st <type> # sizeof 2490 ::= sr <type> <unqualified-name> # dependent name 2491 ::= sr <type> <unqualified-name> <template-args> */ 2492 2493 static void 2494 write_expression (tree expr) 2495 { 2496 enum tree_code code = TREE_CODE (expr); 2497 2498 /* Skip NOP_EXPRs. They can occur when (say) a pointer argument 2499 is converted (via qualification conversions) to another 2500 type. */ 2501 while (TREE_CODE (expr) == NOP_EXPR 2502 || TREE_CODE (expr) == NON_LVALUE_EXPR) 2503 { 2504 expr = TREE_OPERAND (expr, 0); 2505 code = TREE_CODE (expr); 2506 } 2507 2508 if (code == BASELINK 2509 && (!type_unknown_p (expr) 2510 || !BASELINK_QUALIFIED_P (expr))) 2511 { 2512 expr = BASELINK_FUNCTIONS (expr); 2513 code = TREE_CODE (expr); 2514 } 2515 2516 /* Handle pointers-to-members by making them look like expression 2517 nodes. */ 2518 if (code == PTRMEM_CST) 2519 { 2520 expr = build_nt (ADDR_EXPR, 2521 build_qualified_name (/*type=*/NULL_TREE, 2522 PTRMEM_CST_CLASS (expr), 2523 PTRMEM_CST_MEMBER (expr), 2524 /*template_p=*/false)); 2525 code = TREE_CODE (expr); 2526 } 2527 2528 /* Handle template parameters. */ 2529 if (code == TEMPLATE_TYPE_PARM 2530 || code == TEMPLATE_TEMPLATE_PARM 2531 || code == BOUND_TEMPLATE_TEMPLATE_PARM 2532 || code == TEMPLATE_PARM_INDEX) 2533 write_template_param (expr); 2534 /* Handle literals. */ 2535 else if (TREE_CODE_CLASS (code) == tcc_constant 2536 || (abi_version_at_least (2) && code == CONST_DECL)) 2537 write_template_arg_literal (expr); 2538 else if (code == PARM_DECL && DECL_ARTIFICIAL (expr)) 2539 { 2540 gcc_assert (!strcmp ("this", IDENTIFIER_POINTER (DECL_NAME (expr)))); 2541 write_string ("fpT"); 2542 } 2543 else if (code == PARM_DECL) 2544 { 2545 /* A function parameter used in a late-specified return type. */ 2546 int index = DECL_PARM_INDEX (expr); 2547 int level = DECL_PARM_LEVEL (expr); 2548 int delta = G.parm_depth - level + 1; 2549 gcc_assert (index >= 1); 2550 write_char ('f'); 2551 if (delta != 0) 2552 { 2553 if (abi_version_at_least (5)) 2554 { 2555 /* Let L be the number of function prototype scopes from the 2556 innermost one (in which the parameter reference occurs) up 2557 to (and including) the one containing the declaration of 2558 the referenced parameter. If the parameter declaration 2559 clause of the innermost function prototype scope has been 2560 completely seen, it is not counted (in that case -- which 2561 is perhaps the most common -- L can be zero). */ 2562 write_char ('L'); 2563 write_unsigned_number (delta - 1); 2564 } 2565 else 2566 G.need_abi_warning = true; 2567 } 2568 write_char ('p'); 2569 write_compact_number (index - 1); 2570 } 2571 else if (DECL_P (expr)) 2572 { 2573 /* G++ 3.2 incorrectly mangled non-type template arguments of 2574 enumeration type using their names. */ 2575 if (code == CONST_DECL) 2576 G.need_abi_warning = 1; 2577 write_char ('L'); 2578 write_mangled_name (expr, false); 2579 write_char ('E'); 2580 } 2581 else if (TREE_CODE (expr) == SIZEOF_EXPR 2582 && TYPE_P (TREE_OPERAND (expr, 0))) 2583 { 2584 write_string ("st"); 2585 write_type (TREE_OPERAND (expr, 0)); 2586 } 2587 else if (TREE_CODE (expr) == ALIGNOF_EXPR 2588 && TYPE_P (TREE_OPERAND (expr, 0))) 2589 { 2590 write_string ("at"); 2591 write_type (TREE_OPERAND (expr, 0)); 2592 } 2593 else if (code == SCOPE_REF 2594 || code == BASELINK) 2595 { 2596 tree scope, member; 2597 if (code == SCOPE_REF) 2598 { 2599 scope = TREE_OPERAND (expr, 0); 2600 member = TREE_OPERAND (expr, 1); 2601 } 2602 else 2603 { 2604 scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (expr)); 2605 member = BASELINK_FUNCTIONS (expr); 2606 } 2607 2608 if (!abi_version_at_least (2) && DECL_P (member)) 2609 { 2610 write_string ("sr"); 2611 write_type (scope); 2612 /* G++ 3.2 incorrectly put out both the "sr" code and 2613 the nested name of the qualified name. */ 2614 G.need_abi_warning = 1; 2615 write_encoding (member); 2616 } 2617 2618 /* If the MEMBER is a real declaration, then the qualifying 2619 scope was not dependent. Ideally, we would not have a 2620 SCOPE_REF in those cases, but sometimes we do. If the second 2621 argument is a DECL, then the name must not have been 2622 dependent. */ 2623 else if (DECL_P (member)) 2624 write_expression (member); 2625 else 2626 { 2627 write_string ("sr"); 2628 write_type (scope); 2629 write_member_name (member); 2630 } 2631 } 2632 else if (TREE_CODE (expr) == INDIRECT_REF 2633 && TREE_TYPE (TREE_OPERAND (expr, 0)) 2634 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) 2635 { 2636 write_expression (TREE_OPERAND (expr, 0)); 2637 } 2638 else if (TREE_CODE (expr) == IDENTIFIER_NODE) 2639 { 2640 /* An operator name appearing as a dependent name needs to be 2641 specially marked to disambiguate between a use of the operator 2642 name and a use of the operator in an expression. */ 2643 if (IDENTIFIER_OPNAME_P (expr)) 2644 write_string ("on"); 2645 write_unqualified_id (expr); 2646 } 2647 else if (TREE_CODE (expr) == TEMPLATE_ID_EXPR) 2648 { 2649 tree fn = TREE_OPERAND (expr, 0); 2650 if (is_overloaded_fn (fn)) 2651 fn = DECL_NAME (get_first_fn (fn)); 2652 if (IDENTIFIER_OPNAME_P (fn)) 2653 write_string ("on"); 2654 write_unqualified_id (fn); 2655 write_template_args (TREE_OPERAND (expr, 1)); 2656 } 2657 else if (TREE_CODE (expr) == MODOP_EXPR) 2658 { 2659 enum tree_code subop = TREE_CODE (TREE_OPERAND (expr, 1)); 2660 const char *name = (assignment_operator_name_info[(int) subop] 2661 .mangled_name); 2662 write_string (name); 2663 write_expression (TREE_OPERAND (expr, 0)); 2664 write_expression (TREE_OPERAND (expr, 2)); 2665 } 2666 else if (code == NEW_EXPR || code == VEC_NEW_EXPR) 2667 { 2668 /* ::= [gs] nw <expression>* _ <type> E 2669 ::= [gs] nw <expression>* _ <type> <initializer> 2670 ::= [gs] na <expression>* _ <type> E 2671 ::= [gs] na <expression>* _ <type> <initializer> 2672 <initializer> ::= pi <expression>* E */ 2673 tree placement = TREE_OPERAND (expr, 0); 2674 tree type = TREE_OPERAND (expr, 1); 2675 tree nelts = TREE_OPERAND (expr, 2); 2676 tree init = TREE_OPERAND (expr, 3); 2677 tree t; 2678 2679 gcc_assert (code == NEW_EXPR); 2680 if (TREE_OPERAND (expr, 2)) 2681 code = VEC_NEW_EXPR; 2682 2683 if (NEW_EXPR_USE_GLOBAL (expr)) 2684 write_string ("gs"); 2685 2686 write_string (operator_name_info[(int) code].mangled_name); 2687 2688 for (t = placement; t; t = TREE_CHAIN (t)) 2689 write_expression (TREE_VALUE (t)); 2690 2691 write_char ('_'); 2692 2693 if (nelts) 2694 { 2695 tree domain; 2696 ++processing_template_decl; 2697 domain = compute_array_index_type (NULL_TREE, nelts, 2698 tf_warning_or_error); 2699 type = build_cplus_array_type (type, domain); 2700 --processing_template_decl; 2701 } 2702 write_type (type); 2703 2704 if (init && TREE_CODE (init) == TREE_LIST 2705 && TREE_CODE (TREE_VALUE (init)) == CONSTRUCTOR 2706 && CONSTRUCTOR_IS_DIRECT_INIT (TREE_VALUE (init))) 2707 write_expression (TREE_VALUE (init)); 2708 else 2709 { 2710 if (init) 2711 write_string ("pi"); 2712 if (init && init != void_zero_node) 2713 for (t = init; t; t = TREE_CHAIN (t)) 2714 write_expression (TREE_VALUE (t)); 2715 write_char ('E'); 2716 } 2717 } 2718 else if (code == DELETE_EXPR || code == VEC_DELETE_EXPR) 2719 { 2720 gcc_assert (code == DELETE_EXPR); 2721 if (DELETE_EXPR_USE_VEC (expr)) 2722 code = VEC_DELETE_EXPR; 2723 2724 if (DELETE_EXPR_USE_GLOBAL (expr)) 2725 write_string ("gs"); 2726 2727 write_string (operator_name_info[(int) code].mangled_name); 2728 2729 write_expression (TREE_OPERAND (expr, 0)); 2730 } 2731 else if (code == THROW_EXPR) 2732 { 2733 tree op = TREE_OPERAND (expr, 0); 2734 if (op) 2735 { 2736 write_string ("tw"); 2737 write_expression (op); 2738 } 2739 else 2740 write_string ("tr"); 2741 } 2742 else if (code == CONSTRUCTOR) 2743 { 2744 VEC(constructor_elt,gc)* elts = CONSTRUCTOR_ELTS (expr); 2745 unsigned i; tree val; 2746 2747 if (BRACE_ENCLOSED_INITIALIZER_P (expr)) 2748 write_string ("il"); 2749 else 2750 { 2751 write_string ("tl"); 2752 write_type (TREE_TYPE (expr)); 2753 } 2754 FOR_EACH_CONSTRUCTOR_VALUE (elts, i, val) 2755 write_expression (val); 2756 write_char ('E'); 2757 } 2758 else if (dependent_name (expr)) 2759 { 2760 write_unqualified_id (dependent_name (expr)); 2761 } 2762 else 2763 { 2764 int i, len; 2765 const char *name; 2766 2767 /* When we bind a variable or function to a non-type template 2768 argument with reference type, we create an ADDR_EXPR to show 2769 the fact that the entity's address has been taken. But, we 2770 don't actually want to output a mangling code for the `&'. */ 2771 if (TREE_CODE (expr) == ADDR_EXPR 2772 && TREE_TYPE (expr) 2773 && TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE) 2774 { 2775 expr = TREE_OPERAND (expr, 0); 2776 if (DECL_P (expr)) 2777 { 2778 write_expression (expr); 2779 return; 2780 } 2781 2782 code = TREE_CODE (expr); 2783 } 2784 2785 if (code == COMPONENT_REF) 2786 { 2787 tree ob = TREE_OPERAND (expr, 0); 2788 2789 if (TREE_CODE (ob) == ARROW_EXPR) 2790 { 2791 write_string (operator_name_info[(int)code].mangled_name); 2792 ob = TREE_OPERAND (ob, 0); 2793 } 2794 else 2795 write_string ("dt"); 2796 2797 write_expression (ob); 2798 write_member_name (TREE_OPERAND (expr, 1)); 2799 return; 2800 } 2801 2802 /* If it wasn't any of those, recursively expand the expression. */ 2803 name = operator_name_info[(int) code].mangled_name; 2804 2805 /* We used to mangle const_cast and static_cast like a C cast. */ 2806 if (!abi_version_at_least (6) 2807 && (code == CONST_CAST_EXPR 2808 || code == STATIC_CAST_EXPR)) 2809 { 2810 name = operator_name_info[CAST_EXPR].mangled_name; 2811 G.need_abi_warning = 1; 2812 } 2813 2814 if (name == NULL) 2815 { 2816 sorry ("mangling %C", code); 2817 return; 2818 } 2819 else 2820 write_string (name); 2821 2822 switch (code) 2823 { 2824 case CALL_EXPR: 2825 { 2826 tree fn = CALL_EXPR_FN (expr); 2827 2828 if (TREE_CODE (fn) == ADDR_EXPR) 2829 fn = TREE_OPERAND (fn, 0); 2830 2831 /* Mangle a dependent name as the name, not whatever happens to 2832 be the first function in the overload set. */ 2833 if ((TREE_CODE (fn) == FUNCTION_DECL 2834 || TREE_CODE (fn) == OVERLOAD) 2835 && type_dependent_expression_p_push (expr)) 2836 fn = DECL_NAME (get_first_fn (fn)); 2837 2838 write_expression (fn); 2839 } 2840 2841 for (i = 0; i < call_expr_nargs (expr); ++i) 2842 write_expression (CALL_EXPR_ARG (expr, i)); 2843 write_char ('E'); 2844 break; 2845 2846 case CAST_EXPR: 2847 write_type (TREE_TYPE (expr)); 2848 if (list_length (TREE_OPERAND (expr, 0)) == 1) 2849 write_expression (TREE_VALUE (TREE_OPERAND (expr, 0))); 2850 else 2851 { 2852 tree args = TREE_OPERAND (expr, 0); 2853 write_char ('_'); 2854 for (; args; args = TREE_CHAIN (args)) 2855 write_expression (TREE_VALUE (args)); 2856 write_char ('E'); 2857 } 2858 break; 2859 2860 case DYNAMIC_CAST_EXPR: 2861 case REINTERPRET_CAST_EXPR: 2862 case STATIC_CAST_EXPR: 2863 case CONST_CAST_EXPR: 2864 write_type (TREE_TYPE (expr)); 2865 write_expression (TREE_OPERAND (expr, 0)); 2866 break; 2867 2868 case PREINCREMENT_EXPR: 2869 case PREDECREMENT_EXPR: 2870 if (abi_version_at_least (6)) 2871 write_char ('_'); 2872 else 2873 G.need_abi_warning = 1; 2874 /* Fall through. */ 2875 2876 default: 2877 /* In the middle-end, some expressions have more operands than 2878 they do in templates (and mangling). */ 2879 len = cp_tree_operand_length (expr); 2880 2881 for (i = 0; i < len; ++i) 2882 { 2883 tree operand = TREE_OPERAND (expr, i); 2884 /* As a GNU extension, the middle operand of a 2885 conditional may be omitted. Since expression 2886 manglings are supposed to represent the input token 2887 stream, there's no good way to mangle such an 2888 expression without extending the C++ ABI. */ 2889 if (code == COND_EXPR && i == 1 && !operand) 2890 { 2891 error ("omitted middle operand to %<?:%> operand " 2892 "cannot be mangled"); 2893 continue; 2894 } 2895 write_expression (operand); 2896 } 2897 } 2898 } 2899 } 2900 2901 /* Literal subcase of non-terminal <template-arg>. 2902 2903 "Literal arguments, e.g. "A<42L>", are encoded with their type 2904 and value. Negative integer values are preceded with "n"; for 2905 example, "A<-42L>" becomes "1AILln42EE". The bool value false is 2906 encoded as 0, true as 1." */ 2907 2908 static void 2909 write_template_arg_literal (const tree value) 2910 { 2911 write_char ('L'); 2912 write_type (TREE_TYPE (value)); 2913 2914 /* Write a null member pointer value as (type)0, regardless of its 2915 real representation. */ 2916 if (null_member_pointer_value_p (value)) 2917 write_integer_cst (integer_zero_node); 2918 else 2919 switch (TREE_CODE (value)) 2920 { 2921 case CONST_DECL: 2922 write_integer_cst (DECL_INITIAL (value)); 2923 break; 2924 2925 case INTEGER_CST: 2926 gcc_assert (!same_type_p (TREE_TYPE (value), boolean_type_node) 2927 || integer_zerop (value) || integer_onep (value)); 2928 write_integer_cst (value); 2929 break; 2930 2931 case REAL_CST: 2932 write_real_cst (value); 2933 break; 2934 2935 case COMPLEX_CST: 2936 if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST 2937 && TREE_CODE (TREE_IMAGPART (value)) == INTEGER_CST) 2938 { 2939 write_integer_cst (TREE_REALPART (value)); 2940 write_char ('_'); 2941 write_integer_cst (TREE_IMAGPART (value)); 2942 } 2943 else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST 2944 && TREE_CODE (TREE_IMAGPART (value)) == REAL_CST) 2945 { 2946 write_real_cst (TREE_REALPART (value)); 2947 write_char ('_'); 2948 write_real_cst (TREE_IMAGPART (value)); 2949 } 2950 else 2951 gcc_unreachable (); 2952 break; 2953 2954 case STRING_CST: 2955 sorry ("string literal in function template signature"); 2956 break; 2957 2958 default: 2959 gcc_unreachable (); 2960 } 2961 2962 write_char ('E'); 2963 } 2964 2965 /* Non-terminal <template-arg>. 2966 2967 <template-arg> ::= <type> # type 2968 ::= L <type> </value/ number> E # literal 2969 ::= LZ <name> E # external name 2970 ::= X <expression> E # expression */ 2971 2972 static void 2973 write_template_arg (tree node) 2974 { 2975 enum tree_code code = TREE_CODE (node); 2976 2977 MANGLE_TRACE_TREE ("template-arg", node); 2978 2979 /* A template template parameter's argument list contains TREE_LIST 2980 nodes of which the value field is the actual argument. */ 2981 if (code == TREE_LIST) 2982 { 2983 node = TREE_VALUE (node); 2984 /* If it's a decl, deal with its type instead. */ 2985 if (DECL_P (node)) 2986 { 2987 node = TREE_TYPE (node); 2988 code = TREE_CODE (node); 2989 } 2990 } 2991 2992 if (TREE_CODE (node) == NOP_EXPR 2993 && TREE_CODE (TREE_TYPE (node)) == REFERENCE_TYPE) 2994 { 2995 /* Template parameters can be of reference type. To maintain 2996 internal consistency, such arguments use a conversion from 2997 address of object to reference type. */ 2998 gcc_assert (TREE_CODE (TREE_OPERAND (node, 0)) == ADDR_EXPR); 2999 if (abi_version_at_least (2)) 3000 node = TREE_OPERAND (TREE_OPERAND (node, 0), 0); 3001 else 3002 G.need_abi_warning = 1; 3003 } 3004 3005 if (TREE_CODE (node) == BASELINK 3006 && !type_unknown_p (node)) 3007 { 3008 if (abi_version_at_least (6)) 3009 node = BASELINK_FUNCTIONS (node); 3010 else 3011 /* We wrongly wrapped a class-scope function in X/E. */ 3012 G.need_abi_warning = 1; 3013 } 3014 3015 if (ARGUMENT_PACK_P (node)) 3016 { 3017 /* Expand the template argument pack. */ 3018 tree args = ARGUMENT_PACK_ARGS (node); 3019 int i, length = TREE_VEC_LENGTH (args); 3020 if (abi_version_at_least (6)) 3021 write_char ('J'); 3022 else 3023 { 3024 write_char ('I'); 3025 G.need_abi_warning = 1; 3026 } 3027 for (i = 0; i < length; ++i) 3028 write_template_arg (TREE_VEC_ELT (args, i)); 3029 write_char ('E'); 3030 } 3031 else if (TYPE_P (node)) 3032 write_type (node); 3033 else if (code == TEMPLATE_DECL) 3034 /* A template appearing as a template arg is a template template arg. */ 3035 write_template_template_arg (node); 3036 else if ((TREE_CODE_CLASS (code) == tcc_constant && code != PTRMEM_CST) 3037 || (abi_version_at_least (2) && code == CONST_DECL) 3038 || null_member_pointer_value_p (node)) 3039 write_template_arg_literal (node); 3040 else if (DECL_P (node)) 3041 { 3042 /* Until ABI version 2, non-type template arguments of 3043 enumeration type were mangled using their names. */ 3044 if (code == CONST_DECL && !abi_version_at_least (2)) 3045 G.need_abi_warning = 1; 3046 write_char ('L'); 3047 /* Until ABI version 3, the underscore before the mangled name 3048 was incorrectly omitted. */ 3049 if (!abi_version_at_least (3)) 3050 { 3051 G.need_abi_warning = 1; 3052 write_char ('Z'); 3053 } 3054 else 3055 write_string ("_Z"); 3056 write_encoding (node); 3057 write_char ('E'); 3058 } 3059 else 3060 { 3061 /* Template arguments may be expressions. */ 3062 write_char ('X'); 3063 write_expression (node); 3064 write_char ('E'); 3065 } 3066 } 3067 3068 /* <template-template-arg> 3069 ::= <name> 3070 ::= <substitution> */ 3071 3072 static void 3073 write_template_template_arg (const tree decl) 3074 { 3075 MANGLE_TRACE_TREE ("template-template-arg", decl); 3076 3077 if (find_substitution (decl)) 3078 return; 3079 write_name (decl, /*ignore_local_scope=*/0); 3080 add_substitution (decl); 3081 } 3082 3083 3084 /* Non-terminal <array-type>. TYPE is an ARRAY_TYPE. 3085 3086 <array-type> ::= A [</dimension/ number>] _ </element/ type> 3087 ::= A <expression> _ </element/ type> 3088 3089 "Array types encode the dimension (number of elements) and the 3090 element type. For variable length arrays, the dimension (but not 3091 the '_' separator) is omitted." */ 3092 3093 static void 3094 write_array_type (const tree type) 3095 { 3096 write_char ('A'); 3097 if (TYPE_DOMAIN (type)) 3098 { 3099 tree index_type; 3100 tree max; 3101 3102 index_type = TYPE_DOMAIN (type); 3103 /* The INDEX_TYPE gives the upper and lower bounds of the 3104 array. */ 3105 max = TYPE_MAX_VALUE (index_type); 3106 if (TREE_CODE (max) == INTEGER_CST) 3107 { 3108 /* The ABI specifies that we should mangle the number of 3109 elements in the array, not the largest allowed index. */ 3110 double_int dmax 3111 = double_int_add (tree_to_double_int (max), double_int_one); 3112 /* Truncate the result - this will mangle [0, SIZE_INT_MAX] 3113 number of elements as zero. */ 3114 dmax = double_int_zext (dmax, TYPE_PRECISION (TREE_TYPE (max))); 3115 gcc_assert (double_int_fits_in_uhwi_p (dmax)); 3116 write_unsigned_number (dmax.low); 3117 } 3118 else 3119 { 3120 max = TREE_OPERAND (max, 0); 3121 if (!abi_version_at_least (2)) 3122 { 3123 /* value_dependent_expression_p presumes nothing is 3124 dependent when PROCESSING_TEMPLATE_DECL is zero. */ 3125 ++processing_template_decl; 3126 if (!value_dependent_expression_p (max)) 3127 G.need_abi_warning = 1; 3128 --processing_template_decl; 3129 } 3130 write_expression (max); 3131 } 3132 3133 } 3134 write_char ('_'); 3135 write_type (TREE_TYPE (type)); 3136 } 3137 3138 /* Non-terminal <pointer-to-member-type> for pointer-to-member 3139 variables. TYPE is a pointer-to-member POINTER_TYPE. 3140 3141 <pointer-to-member-type> ::= M </class/ type> </member/ type> */ 3142 3143 static void 3144 write_pointer_to_member_type (const tree type) 3145 { 3146 write_char ('M'); 3147 write_type (TYPE_PTRMEM_CLASS_TYPE (type)); 3148 write_type (TYPE_PTRMEM_POINTED_TO_TYPE (type)); 3149 } 3150 3151 /* Non-terminal <template-param>. PARM is a TEMPLATE_TYPE_PARM, 3152 TEMPLATE_TEMPLATE_PARM, BOUND_TEMPLATE_TEMPLATE_PARM or a 3153 TEMPLATE_PARM_INDEX. 3154 3155 <template-param> ::= T </parameter/ number> _ */ 3156 3157 static void 3158 write_template_param (const tree parm) 3159 { 3160 int parm_index; 3161 3162 MANGLE_TRACE_TREE ("template-parm", parm); 3163 3164 switch (TREE_CODE (parm)) 3165 { 3166 case TEMPLATE_TYPE_PARM: 3167 case TEMPLATE_TEMPLATE_PARM: 3168 case BOUND_TEMPLATE_TEMPLATE_PARM: 3169 parm_index = TEMPLATE_TYPE_IDX (parm); 3170 break; 3171 3172 case TEMPLATE_PARM_INDEX: 3173 parm_index = TEMPLATE_PARM_IDX (parm); 3174 break; 3175 3176 default: 3177 gcc_unreachable (); 3178 } 3179 3180 write_char ('T'); 3181 /* NUMBER as it appears in the mangling is (-1)-indexed, with the 3182 earliest template param denoted by `_'. */ 3183 write_compact_number (parm_index); 3184 } 3185 3186 /* <template-template-param> 3187 ::= <template-param> 3188 ::= <substitution> */ 3189 3190 static void 3191 write_template_template_param (const tree parm) 3192 { 3193 tree templ = NULL_TREE; 3194 3195 /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the 3196 template template parameter. The substitution candidate here is 3197 only the template. */ 3198 if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM) 3199 { 3200 templ 3201 = TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm)); 3202 if (find_substitution (templ)) 3203 return; 3204 } 3205 3206 /* <template-param> encodes only the template parameter position, 3207 not its template arguments, which is fine here. */ 3208 write_template_param (parm); 3209 if (templ) 3210 add_substitution (templ); 3211 } 3212 3213 /* Non-terminal <substitution>. 3214 3215 <substitution> ::= S <seq-id> _ 3216 ::= S_ */ 3217 3218 static void 3219 write_substitution (const int seq_id) 3220 { 3221 MANGLE_TRACE ("substitution", ""); 3222 3223 write_char ('S'); 3224 if (seq_id > 0) 3225 write_number (seq_id - 1, /*unsigned=*/1, 36); 3226 write_char ('_'); 3227 } 3228 3229 /* Start mangling ENTITY. */ 3230 3231 static inline void 3232 start_mangling (const tree entity) 3233 { 3234 G.entity = entity; 3235 G.need_abi_warning = false; 3236 obstack_free (&name_obstack, name_base); 3237 mangle_obstack = &name_obstack; 3238 name_base = obstack_alloc (&name_obstack, 0); 3239 } 3240 3241 /* Done with mangling. If WARN is true, and the name of G.entity will 3242 be mangled differently in a future version of the ABI, issue a 3243 warning. */ 3244 3245 static void 3246 finish_mangling_internal (const bool warn) 3247 { 3248 if (warn_abi && warn && G.need_abi_warning) 3249 warning (OPT_Wabi, "the mangled name of %qD will change in a future " 3250 "version of GCC", 3251 G.entity); 3252 3253 /* Clear all the substitutions. */ 3254 VEC_truncate (tree, G.substitutions, 0); 3255 3256 /* Null-terminate the string. */ 3257 write_char ('\0'); 3258 } 3259 3260 3261 /* Like finish_mangling_internal, but return the mangled string. */ 3262 3263 static inline const char * 3264 finish_mangling (const bool warn) 3265 { 3266 finish_mangling_internal (warn); 3267 return (const char *) obstack_finish (mangle_obstack); 3268 } 3269 3270 /* Like finish_mangling_internal, but return an identifier. */ 3271 3272 static tree 3273 finish_mangling_get_identifier (const bool warn) 3274 { 3275 finish_mangling_internal (warn); 3276 /* Don't obstack_finish here, and the next start_mangling will 3277 remove the identifier. */ 3278 return get_identifier ((const char *) obstack_base (mangle_obstack)); 3279 } 3280 3281 /* Initialize data structures for mangling. */ 3282 3283 void 3284 init_mangle (void) 3285 { 3286 gcc_obstack_init (&name_obstack); 3287 name_base = obstack_alloc (&name_obstack, 0); 3288 G.substitutions = NULL; 3289 3290 /* Cache these identifiers for quick comparison when checking for 3291 standard substitutions. */ 3292 subst_identifiers[SUBID_ALLOCATOR] = get_identifier ("allocator"); 3293 subst_identifiers[SUBID_BASIC_STRING] = get_identifier ("basic_string"); 3294 subst_identifiers[SUBID_CHAR_TRAITS] = get_identifier ("char_traits"); 3295 subst_identifiers[SUBID_BASIC_ISTREAM] = get_identifier ("basic_istream"); 3296 subst_identifiers[SUBID_BASIC_OSTREAM] = get_identifier ("basic_ostream"); 3297 subst_identifiers[SUBID_BASIC_IOSTREAM] = get_identifier ("basic_iostream"); 3298 } 3299 3300 /* Generate the mangled name of DECL. */ 3301 3302 static tree 3303 mangle_decl_string (const tree decl) 3304 { 3305 tree result; 3306 location_t saved_loc = input_location; 3307 tree saved_fn = NULL_TREE; 3308 bool template_p = false; 3309 3310 /* We shouldn't be trying to mangle an uninstantiated template. */ 3311 gcc_assert (!type_dependent_expression_p (decl)); 3312 3313 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl)) 3314 { 3315 struct tinst_level *tl = current_instantiation (); 3316 if ((!tl || tl->decl != decl) 3317 && push_tinst_level (decl)) 3318 { 3319 template_p = true; 3320 saved_fn = current_function_decl; 3321 current_function_decl = NULL_TREE; 3322 } 3323 } 3324 input_location = DECL_SOURCE_LOCATION (decl); 3325 3326 start_mangling (decl); 3327 3328 if (TREE_CODE (decl) == TYPE_DECL) 3329 write_type (TREE_TYPE (decl)); 3330 else 3331 write_mangled_name (decl, true); 3332 3333 result = finish_mangling_get_identifier (/*warn=*/true); 3334 if (DEBUG_MANGLE) 3335 fprintf (stderr, "mangle_decl_string = '%s'\n\n", 3336 IDENTIFIER_POINTER (result)); 3337 3338 if (template_p) 3339 { 3340 pop_tinst_level (); 3341 current_function_decl = saved_fn; 3342 } 3343 input_location = saved_loc; 3344 3345 return result; 3346 } 3347 3348 /* Return an identifier for the external mangled name of DECL. */ 3349 3350 static tree 3351 get_mangled_id (tree decl) 3352 { 3353 tree id = mangle_decl_string (decl); 3354 return targetm.mangle_decl_assembler_name (decl, id); 3355 } 3356 3357 /* Create an identifier for the external mangled name of DECL. */ 3358 3359 void 3360 mangle_decl (const tree decl) 3361 { 3362 tree id; 3363 bool dep; 3364 3365 /* Don't bother mangling uninstantiated templates. */ 3366 ++processing_template_decl; 3367 if (TREE_CODE (decl) == TYPE_DECL) 3368 dep = dependent_type_p (TREE_TYPE (decl)); 3369 else 3370 dep = (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl) 3371 && any_dependent_template_arguments_p (DECL_TI_ARGS (decl))); 3372 --processing_template_decl; 3373 if (dep) 3374 return; 3375 3376 id = get_mangled_id (decl); 3377 SET_DECL_ASSEMBLER_NAME (decl, id); 3378 3379 if (G.need_abi_warning 3380 /* Don't do this for a fake symbol we aren't going to emit anyway. */ 3381 && !DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl) 3382 && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)) 3383 { 3384 #ifdef ASM_OUTPUT_DEF 3385 /* If the mangling will change in the future, emit an alias with the 3386 future mangled name for forward-compatibility. */ 3387 int save_ver; 3388 tree id2, alias; 3389 #endif 3390 3391 SET_IDENTIFIER_GLOBAL_VALUE (id, decl); 3392 if (IDENTIFIER_GLOBAL_VALUE (id) != decl) 3393 inform (DECL_SOURCE_LOCATION (decl), "-fabi-version=6 (or =0) " 3394 "avoids this error with a change in mangling"); 3395 3396 #ifdef ASM_OUTPUT_DEF 3397 save_ver = flag_abi_version; 3398 flag_abi_version = 0; 3399 id2 = mangle_decl_string (decl); 3400 id2 = targetm.mangle_decl_assembler_name (decl, id2); 3401 flag_abi_version = save_ver; 3402 3403 alias = make_alias_for (decl, id2); 3404 DECL_IGNORED_P (alias) = 1; 3405 TREE_PUBLIC (alias) = TREE_PUBLIC (decl); 3406 DECL_VISIBILITY (alias) = DECL_VISIBILITY (decl); 3407 if (vague_linkage_p (decl)) 3408 DECL_WEAK (alias) = 1; 3409 if (TREE_CODE (decl) == FUNCTION_DECL) 3410 cgraph_same_body_alias (cgraph_get_create_node (decl), alias, decl); 3411 else 3412 varpool_extra_name_alias (alias, decl); 3413 #endif 3414 } 3415 } 3416 3417 /* Generate the mangled representation of TYPE. */ 3418 3419 const char * 3420 mangle_type_string (const tree type) 3421 { 3422 const char *result; 3423 3424 start_mangling (type); 3425 write_type (type); 3426 result = finish_mangling (/*warn=*/false); 3427 if (DEBUG_MANGLE) 3428 fprintf (stderr, "mangle_type_string = '%s'\n\n", result); 3429 return result; 3430 } 3431 3432 /* Create an identifier for the mangled name of a special component 3433 for belonging to TYPE. CODE is the ABI-specified code for this 3434 component. */ 3435 3436 static tree 3437 mangle_special_for_type (const tree type, const char *code) 3438 { 3439 tree result; 3440 3441 /* We don't have an actual decl here for the special component, so 3442 we can't just process the <encoded-name>. Instead, fake it. */ 3443 start_mangling (type); 3444 3445 /* Start the mangling. */ 3446 write_string ("_Z"); 3447 write_string (code); 3448 3449 /* Add the type. */ 3450 write_type (type); 3451 result = finish_mangling_get_identifier (/*warn=*/false); 3452 3453 if (DEBUG_MANGLE) 3454 fprintf (stderr, "mangle_special_for_type = %s\n\n", 3455 IDENTIFIER_POINTER (result)); 3456 3457 return result; 3458 } 3459 3460 /* Create an identifier for the mangled representation of the typeinfo 3461 structure for TYPE. */ 3462 3463 tree 3464 mangle_typeinfo_for_type (const tree type) 3465 { 3466 return mangle_special_for_type (type, "TI"); 3467 } 3468 3469 /* Create an identifier for the mangled name of the NTBS containing 3470 the mangled name of TYPE. */ 3471 3472 tree 3473 mangle_typeinfo_string_for_type (const tree type) 3474 { 3475 return mangle_special_for_type (type, "TS"); 3476 } 3477 3478 /* Create an identifier for the mangled name of the vtable for TYPE. */ 3479 3480 tree 3481 mangle_vtbl_for_type (const tree type) 3482 { 3483 return mangle_special_for_type (type, "TV"); 3484 } 3485 3486 /* Returns an identifier for the mangled name of the VTT for TYPE. */ 3487 3488 tree 3489 mangle_vtt_for_type (const tree type) 3490 { 3491 return mangle_special_for_type (type, "TT"); 3492 } 3493 3494 /* Return an identifier for a construction vtable group. TYPE is 3495 the most derived class in the hierarchy; BINFO is the base 3496 subobject for which this construction vtable group will be used. 3497 3498 This mangling isn't part of the ABI specification; in the ABI 3499 specification, the vtable group is dumped in the same COMDAT as the 3500 main vtable, and is referenced only from that vtable, so it doesn't 3501 need an external name. For binary formats without COMDAT sections, 3502 though, we need external names for the vtable groups. 3503 3504 We use the production 3505 3506 <special-name> ::= CT <type> <offset number> _ <base type> */ 3507 3508 tree 3509 mangle_ctor_vtbl_for_type (const tree type, const tree binfo) 3510 { 3511 tree result; 3512 3513 start_mangling (type); 3514 3515 write_string ("_Z"); 3516 write_string ("TC"); 3517 write_type (type); 3518 write_integer_cst (BINFO_OFFSET (binfo)); 3519 write_char ('_'); 3520 write_type (BINFO_TYPE (binfo)); 3521 3522 result = finish_mangling_get_identifier (/*warn=*/false); 3523 if (DEBUG_MANGLE) 3524 fprintf (stderr, "mangle_ctor_vtbl_for_type = %s\n\n", 3525 IDENTIFIER_POINTER (result)); 3526 return result; 3527 } 3528 3529 /* Mangle a this pointer or result pointer adjustment. 3530 3531 <call-offset> ::= h <fixed offset number> _ 3532 ::= v <fixed offset number> _ <virtual offset number> _ */ 3533 3534 static void 3535 mangle_call_offset (const tree fixed_offset, const tree virtual_offset) 3536 { 3537 write_char (virtual_offset ? 'v' : 'h'); 3538 3539 /* For either flavor, write the fixed offset. */ 3540 write_integer_cst (fixed_offset); 3541 write_char ('_'); 3542 3543 /* For a virtual thunk, add the virtual offset. */ 3544 if (virtual_offset) 3545 { 3546 write_integer_cst (virtual_offset); 3547 write_char ('_'); 3548 } 3549 } 3550 3551 /* Return an identifier for the mangled name of a this-adjusting or 3552 covariant thunk to FN_DECL. FIXED_OFFSET is the initial adjustment 3553 to this used to find the vptr. If VIRTUAL_OFFSET is non-NULL, this 3554 is a virtual thunk, and it is the vtbl offset in 3555 bytes. THIS_ADJUSTING is nonzero for a this adjusting thunk and 3556 zero for a covariant thunk. Note, that FN_DECL might be a covariant 3557 thunk itself. A covariant thunk name always includes the adjustment 3558 for the this pointer, even if there is none. 3559 3560 <special-name> ::= T <call-offset> <base encoding> 3561 ::= Tc <this_adjust call-offset> <result_adjust call-offset> 3562 <base encoding> */ 3563 3564 tree 3565 mangle_thunk (tree fn_decl, const int this_adjusting, tree fixed_offset, 3566 tree virtual_offset) 3567 { 3568 tree result; 3569 3570 start_mangling (fn_decl); 3571 3572 write_string ("_Z"); 3573 write_char ('T'); 3574 3575 if (!this_adjusting) 3576 { 3577 /* Covariant thunk with no this adjustment */ 3578 write_char ('c'); 3579 mangle_call_offset (integer_zero_node, NULL_TREE); 3580 mangle_call_offset (fixed_offset, virtual_offset); 3581 } 3582 else if (!DECL_THUNK_P (fn_decl)) 3583 /* Plain this adjusting thunk. */ 3584 mangle_call_offset (fixed_offset, virtual_offset); 3585 else 3586 { 3587 /* This adjusting thunk to covariant thunk. */ 3588 write_char ('c'); 3589 mangle_call_offset (fixed_offset, virtual_offset); 3590 fixed_offset = ssize_int (THUNK_FIXED_OFFSET (fn_decl)); 3591 virtual_offset = THUNK_VIRTUAL_OFFSET (fn_decl); 3592 if (virtual_offset) 3593 virtual_offset = BINFO_VPTR_FIELD (virtual_offset); 3594 mangle_call_offset (fixed_offset, virtual_offset); 3595 fn_decl = THUNK_TARGET (fn_decl); 3596 } 3597 3598 /* Scoped name. */ 3599 write_encoding (fn_decl); 3600 3601 result = finish_mangling_get_identifier (/*warn=*/false); 3602 if (DEBUG_MANGLE) 3603 fprintf (stderr, "mangle_thunk = %s\n\n", IDENTIFIER_POINTER (result)); 3604 return result; 3605 } 3606 3607 /* This hash table maps TYPEs to the IDENTIFIER for a conversion 3608 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the 3609 TYPE. */ 3610 3611 static GTY ((param_is (union tree_node))) htab_t conv_type_names; 3612 3613 /* Hash a node (VAL1) in the table. */ 3614 3615 static hashval_t 3616 hash_type (const void *val) 3617 { 3618 return (hashval_t) TYPE_UID (TREE_TYPE ((const_tree) val)); 3619 } 3620 3621 /* Compare VAL1 (a node in the table) with VAL2 (a TYPE). */ 3622 3623 static int 3624 compare_type (const void *val1, const void *val2) 3625 { 3626 return TREE_TYPE ((const_tree) val1) == (const_tree) val2; 3627 } 3628 3629 /* Return an identifier for the mangled unqualified name for a 3630 conversion operator to TYPE. This mangling is not specified by the 3631 ABI spec; it is only used internally. */ 3632 3633 tree 3634 mangle_conv_op_name_for_type (const tree type) 3635 { 3636 void **slot; 3637 tree identifier; 3638 3639 if (type == error_mark_node) 3640 return error_mark_node; 3641 3642 if (conv_type_names == NULL) 3643 conv_type_names = htab_create_ggc (31, &hash_type, &compare_type, NULL); 3644 3645 slot = htab_find_slot_with_hash (conv_type_names, type, 3646 (hashval_t) TYPE_UID (type), INSERT); 3647 identifier = (tree)*slot; 3648 if (!identifier) 3649 { 3650 char buffer[64]; 3651 3652 /* Create a unique name corresponding to TYPE. */ 3653 sprintf (buffer, "operator %lu", 3654 (unsigned long) htab_elements (conv_type_names)); 3655 identifier = get_identifier (buffer); 3656 *slot = identifier; 3657 3658 /* Hang TYPE off the identifier so it can be found easily later 3659 when performing conversions. */ 3660 TREE_TYPE (identifier) = type; 3661 3662 /* Set bits on the identifier so we know later it's a conversion. */ 3663 IDENTIFIER_OPNAME_P (identifier) = 1; 3664 IDENTIFIER_TYPENAME_P (identifier) = 1; 3665 } 3666 3667 return identifier; 3668 } 3669 3670 /* Return an identifier for the name of an initialization guard 3671 variable for indicated VARIABLE. */ 3672 3673 tree 3674 mangle_guard_variable (const tree variable) 3675 { 3676 start_mangling (variable); 3677 write_string ("_ZGV"); 3678 if (strncmp (IDENTIFIER_POINTER (DECL_NAME (variable)), "_ZGR", 4) == 0) 3679 /* The name of a guard variable for a reference temporary should refer 3680 to the reference, not the temporary. */ 3681 write_string (IDENTIFIER_POINTER (DECL_NAME (variable)) + 4); 3682 else 3683 write_name (variable, /*ignore_local_scope=*/0); 3684 return finish_mangling_get_identifier (/*warn=*/false); 3685 } 3686 3687 /* Return an identifier for the name of a temporary variable used to 3688 initialize a static reference. This isn't part of the ABI, but we might 3689 as well call them something readable. */ 3690 3691 static GTY(()) int temp_count; 3692 3693 tree 3694 mangle_ref_init_variable (const tree variable) 3695 { 3696 start_mangling (variable); 3697 write_string ("_ZGR"); 3698 write_name (variable, /*ignore_local_scope=*/0); 3699 /* Avoid name clashes with aggregate initialization of multiple 3700 references at once. */ 3701 write_unsigned_number (temp_count++); 3702 return finish_mangling_get_identifier (/*warn=*/false); 3703 } 3704 3705 3706 /* Foreign language type mangling section. */ 3707 3708 /* How to write the type codes for the integer Java type. */ 3709 3710 static void 3711 write_java_integer_type_codes (const tree type) 3712 { 3713 if (type == java_int_type_node) 3714 write_char ('i'); 3715 else if (type == java_short_type_node) 3716 write_char ('s'); 3717 else if (type == java_byte_type_node) 3718 write_char ('c'); 3719 else if (type == java_char_type_node) 3720 write_char ('w'); 3721 else if (type == java_long_type_node) 3722 write_char ('x'); 3723 else if (type == java_boolean_type_node) 3724 write_char ('b'); 3725 else 3726 gcc_unreachable (); 3727 } 3728 3729 #include "gt-cp-mangle.h" 3730