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