1/* Subroutines for insn-output.c for Windows NT. 2 Contributed by Douglas Rupp (drupp@cs.washington.edu) 3 Copyright (C) 1995-2020 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 3, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21#define IN_TARGET_CODE 1 22 23#include "config.h" 24#include "system.h" 25#include "coretypes.h" 26#include "target.h" 27#include "function.h" 28#include "basic-block.h" 29#include "rtl.h" 30#include "tree.h" 31#include "gimple.h" 32#include "memmodel.h" 33#include "tm_p.h" 34#include "stringpool.h" 35#include "attribs.h" 36#include "emit-rtl.h" 37#include "cgraph.h" 38#include "lto-streamer.h" 39#include "except.h" 40#include "output.h" 41#include "varasm.h" 42#include "lto-section-names.h" 43 44/* i386/PE specific attribute support. 45 46 i386/PE has two new attributes: 47 dllexport - for exporting a function/variable that will live in a dll 48 dllimport - for importing a function/variable from a dll 49 50 Microsoft allows multiple declspecs in one __declspec, separating 51 them with spaces. We do NOT support this. Instead, use __declspec 52 multiple times. 53*/ 54 55/* Handle a "shared" attribute; 56 arguments as in struct attribute_spec.handler. */ 57tree 58ix86_handle_shared_attribute (tree *node, tree name, tree, int, 59 bool *no_add_attrs) 60{ 61 if (TREE_CODE (*node) != VAR_DECL) 62 { 63 warning (OPT_Wattributes, "%qE attribute only applies to variables", 64 name); 65 *no_add_attrs = true; 66 } 67 68 return NULL_TREE; 69} 70 71/* Handle a "selectany" attribute; 72 arguments as in struct attribute_spec.handler. */ 73tree 74ix86_handle_selectany_attribute (tree *node, tree name, tree, int, 75 bool *no_add_attrs) 76{ 77 tree decl = *node; 78 /* The attribute applies only to objects that are initialized and have 79 external linkage. However, we may not know about initialization 80 until the language frontend has processed the decl. Therefore 81 we make sure that variable isn't initialized as common. */ 82 if (TREE_CODE (decl) != VAR_DECL || !TREE_PUBLIC (decl)) 83 error ("%qE attribute applies only to initialized variables" 84 " with external linkage", name); 85 else 86 { 87 make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl)); 88 /* A variable with attribute selectany never can be common. */ 89 DECL_COMMON (decl) = 0; 90 } 91 92 /* We don't need to keep attribute itself. */ 93 *no_add_attrs = true; 94 return NULL_TREE; 95} 96 97 98/* Return the type that we should use to determine if DECL is 99 imported or exported. */ 100 101static tree 102associated_type (tree decl) 103{ 104 return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 105 ? DECL_CONTEXT (decl) : NULL_TREE); 106} 107 108/* Return true if DECL should be a dllexport'd object. */ 109 110static bool 111i386_pe_determine_dllexport_p (tree decl) 112{ 113 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL) 114 return false; 115 116 /* Don't export local clones of dllexports. */ 117 if (!TREE_PUBLIC (decl)) 118 return false; 119 120 if (TREE_CODE (decl) == FUNCTION_DECL 121 && DECL_DECLARED_INLINE_P (decl) 122 && !flag_keep_inline_dllexport) 123 return false; 124 125 if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl))) 126 return true; 127 128 return false; 129} 130 131/* Return true if DECL should be a dllimport'd object. */ 132 133static bool 134i386_pe_determine_dllimport_p (tree decl) 135{ 136 tree assoc; 137 138 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL) 139 return false; 140 141 if (DECL_DLLIMPORT_P (decl)) 142 return true; 143 144 /* The DECL_DLLIMPORT_P flag was set for decls in the class definition 145 by targetm.cxx.adjust_class_at_definition. Check again to emit 146 error message if the class attribute has been overridden by an 147 out-of-class definition of static data. */ 148 assoc = associated_type (decl); 149 if (assoc && lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc)) 150 && TREE_CODE (decl) == VAR_DECL 151 && TREE_STATIC (decl) && TREE_PUBLIC (decl) 152 && !DECL_EXTERNAL (decl) 153 /* vtable's are linkonce constants, so defining a vtable is not 154 an error as long as we don't try to import it too. */ 155 && !DECL_VIRTUAL_P (decl)) 156 error ("definition of static data member %q+D of " 157 "dllimport%'d class", decl); 158 159 return false; 160} 161 162/* Handle the -mno-fun-dllimport target switch. */ 163 164bool 165i386_pe_valid_dllimport_attribute_p (const_tree decl) 166{ 167 if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL) 168 return false; 169 return true; 170} 171 172/* Return string which is the function name, identified by ID, modified 173 with a suffix consisting of an atsign (@) followed by the number of 174 bytes of arguments. If ID is NULL use the DECL_NAME as base. If 175 FASTCALL is true, also add the FASTCALL_PREFIX. 176 Return NULL if no change required. */ 177 178static tree 179gen_stdcall_or_fastcall_suffix (tree decl, tree id, bool fastcall) 180{ 181 HOST_WIDE_INT total = 0; 182 const char *old_str = IDENTIFIER_POINTER (id != NULL_TREE ? id : DECL_NAME (decl)); 183 char *new_str, *p; 184 tree type = TREE_TYPE (DECL_ORIGIN (decl)); 185 tree arg; 186 function_args_iterator args_iter; 187 188 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); 189 190 if (prototype_p (type)) 191 { 192 /* This attribute is ignored for variadic functions. */ 193 if (stdarg_p (type)) 194 return NULL_TREE; 195 196 /* Quit if we hit an incomplete type. Error is reported 197 by convert_arguments in c-typeck.c or cp/typeck.c. */ 198 FOREACH_FUNCTION_ARGS(type, arg, args_iter) 199 { 200 HOST_WIDE_INT parm_size; 201 HOST_WIDE_INT parm_boundary_bytes = PARM_BOUNDARY / BITS_PER_UNIT; 202 203 if (! COMPLETE_TYPE_P (arg)) 204 break; 205 206 parm_size = int_size_in_bytes (arg); 207 if (parm_size < 0) 208 break; 209 210 /* Must round up to include padding. This is done the same 211 way as in store_one_arg. */ 212 parm_size = ((parm_size + parm_boundary_bytes - 1) 213 / parm_boundary_bytes * parm_boundary_bytes); 214 total += parm_size; 215 } 216 } 217 218 /* Assume max of 8 base 10 digits in the suffix. */ 219 p = new_str = XALLOCAVEC (char, 1 + strlen (old_str) + 1 + 8 + 1); 220 if (fastcall) 221 *p++ = FASTCALL_PREFIX; 222 sprintf (p, "%s@" HOST_WIDE_INT_PRINT_DEC, old_str, total); 223 224 return get_identifier (new_str); 225} 226 227/* Maybe decorate and get a new identifier for the DECL of a stdcall or 228 fastcall function. The original identifier is supplied in ID. */ 229 230static tree 231i386_pe_maybe_mangle_decl_assembler_name (tree decl, tree id) 232{ 233 tree new_id = NULL_TREE; 234 235 if (TREE_CODE (decl) == FUNCTION_DECL) 236 { 237 unsigned int ccvt = ix86_get_callcvt (TREE_TYPE (decl)); 238 if ((ccvt & IX86_CALLCVT_STDCALL) != 0) 239 { 240 if (TARGET_RTD) 241 /* If we are using -mrtd emit undecorated symbol and let linker 242 do the proper resolving. */ 243 return NULL_TREE; 244 new_id = gen_stdcall_or_fastcall_suffix (decl, id, false); 245 } 246 else if ((ccvt & IX86_CALLCVT_FASTCALL) != 0) 247 new_id = gen_stdcall_or_fastcall_suffix (decl, id, true); 248 } 249 250 return new_id; 251} 252 253/* Emit an assembler directive to set symbol for DECL visibility to 254 the visibility type VIS, which must not be VISIBILITY_DEFAULT. 255 As for PE there is no hidden support in gas, we just warn for 256 user-specified visibility attributes. */ 257 258void 259i386_pe_assemble_visibility (tree decl, int) 260{ 261 if (!decl 262 || !lookup_attribute ("visibility", DECL_ATTRIBUTES (decl))) 263 return; 264 if (!DECL_ARTIFICIAL (decl)) 265 warning (OPT_Wattributes, "visibility attribute not supported " 266 "in this configuration; ignored"); 267} 268 269/* This is used as a target hook to modify the DECL_ASSEMBLER_NAME 270 in the language-independent default hook 271 langhooks,c:lhd_set_decl_assembler_name () 272 and in cp/mangle,c:mangle_decl (). */ 273tree 274i386_pe_mangle_decl_assembler_name (tree decl, tree id) 275{ 276 tree new_id = i386_pe_maybe_mangle_decl_assembler_name (decl, id); 277 278 return (new_id ? new_id : id); 279} 280 281/* This hook behaves the same as varasm.c/assemble_name(), but 282 generates the name into memory rather than outputting it to 283 a file stream. */ 284 285tree 286i386_pe_mangle_assembler_name (const char *name) 287{ 288 const char *skipped = name + (*name == '*' ? 1 : 0); 289 const char *stripped = targetm.strip_name_encoding (skipped); 290 if (*name != '*' && *user_label_prefix && *stripped != FASTCALL_PREFIX) 291 stripped = ACONCAT ((user_label_prefix, stripped, NULL)); 292 return get_identifier (stripped); 293} 294 295void 296i386_pe_encode_section_info (tree decl, rtx rtl, int first) 297{ 298 rtx symbol; 299 int flags; 300 301 /* Do this last, due to our frobbing of DECL_DLLIMPORT_P above. */ 302 default_encode_section_info (decl, rtl, first); 303 304 /* Careful not to prod global register variables. */ 305 if (!MEM_P (rtl)) 306 return; 307 308 symbol = XEXP (rtl, 0); 309 gcc_assert (GET_CODE (symbol) == SYMBOL_REF); 310 311 switch (TREE_CODE (decl)) 312 { 313 case FUNCTION_DECL: 314 case VAR_DECL: 315 break; 316 317 default: 318 return; 319 } 320 321 /* Mark the decl so we can tell from the rtl whether the object is 322 dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes 323 handles dllexport/dllimport override semantics. */ 324 flags = (SYMBOL_REF_FLAGS (symbol) & 325 ~(SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT)); 326 if (i386_pe_determine_dllexport_p (decl)) 327 flags |= SYMBOL_FLAG_DLLEXPORT; 328 else if (i386_pe_determine_dllimport_p (decl)) 329 flags |= SYMBOL_FLAG_DLLIMPORT; 330 331 SYMBOL_REF_FLAGS (symbol) = flags; 332} 333 334 335bool 336i386_pe_binds_local_p (const_tree exp) 337{ 338 if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL) 339 && DECL_DLLIMPORT_P (exp)) 340 return false; 341 342 /* External public symbols, which aren't weakref-s, 343 have local-binding for PE targets. */ 344 if (DECL_P (exp) 345 && !lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)) 346 && TREE_PUBLIC (exp) 347 && DECL_EXTERNAL (exp)) 348 return true; 349 350#ifndef MAKE_DECL_ONE_ONLY 351 /* PR target/66655: If a function has been marked as DECL_ONE_ONLY 352 but we do not the means to make it so, then do not allow it to 353 bind locally. */ 354 if (DECL_P (exp) 355 && TREE_CODE (exp) == FUNCTION_DECL 356 && TREE_PUBLIC (exp) 357 && DECL_ONE_ONLY (exp) 358 && ! DECL_EXTERNAL (exp) 359 && DECL_DECLARED_INLINE_P (exp)) 360 return false; 361#endif 362 363 return default_binds_local_p_1 (exp, 0); 364} 365 366/* Also strip the fastcall prefix and stdcall suffix. */ 367 368const char * 369i386_pe_strip_name_encoding_full (const char *str) 370{ 371 const char *p; 372 const char *name = default_strip_name_encoding (str); 373 374 /* Strip leading '@' on fastcall symbols. */ 375 if (*name == '@') 376 name++; 377 378 /* Strip trailing "@n". */ 379 p = strchr (name, '@'); 380 if (p) 381 return ggc_alloc_string (name, p - name); 382 383 return name; 384} 385 386void 387i386_pe_unique_section (tree decl, int reloc) 388{ 389 int len; 390 const char *name, *prefix; 391 char *string; 392 393 /* Ignore RELOC, if we are allowed to put relocated 394 const data into read-only section. */ 395 if (!flag_writable_rel_rdata) 396 reloc = 0; 397 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 398 name = i386_pe_strip_name_encoding_full (name); 399 400 /* The object is put in, for example, section .text$foo. 401 The linker will then ultimately place them in .text 402 (everything from the $ on is stripped). Don't put 403 read-only data in .rdata section to avoid a PE linker 404 bug when .rdata$* grouped sections are used in code 405 without a .rdata section. */ 406 if (TREE_CODE (decl) == FUNCTION_DECL) 407 prefix = ".text$"; 408 else if (decl_readonly_section (decl, reloc)) 409 prefix = ".rdata$"; 410 else 411 prefix = ".data$"; 412 len = strlen (name) + strlen (prefix); 413 string = XALLOCAVEC (char, len + 1); 414 sprintf (string, "%s%s", prefix, name); 415 416 set_decl_section_name (decl, string); 417} 418 419/* Local and global relocs can be placed always into readonly memory for 420 memory for PE-COFF targets. */ 421int 422i386_pe_reloc_rw_mask (void) 423{ 424 return 0; 425} 426 427/* Select a set of attributes for section NAME based on the properties 428 of DECL and whether or not RELOC indicates that DECL's initializer 429 might contain runtime relocations. 430 431 We make the section read-only and executable for a function decl, 432 read-only for a const data decl, and writable for a non-const data decl. 433 434 If the section has already been defined, to not allow it to have 435 different attributes, as (1) this is ambiguous since we're not seeing 436 all the declarations up front and (2) some assemblers (e.g. SVR4) 437 do not recognize section redefinitions. */ 438/* ??? This differs from the "standard" PE implementation in that we 439 handle the SHARED variable attribute. Should this be done for all 440 PE targets? */ 441 442#define SECTION_PE_SHARED SECTION_MACH_DEP 443 444unsigned int 445i386_pe_section_type_flags (tree decl, const char *, int reloc) 446{ 447 unsigned int flags; 448 449 /* Ignore RELOC, if we are allowed to put relocated 450 const data into read-only section. */ 451 if (!flag_writable_rel_rdata) 452 reloc = 0; 453 454 if (decl && TREE_CODE (decl) == FUNCTION_DECL) 455 flags = SECTION_CODE; 456 else if (decl && decl_readonly_section (decl, reloc)) 457 flags = 0; 458 else 459 { 460 flags = SECTION_WRITE; 461 462 if (decl && TREE_CODE (decl) == VAR_DECL 463 && lookup_attribute ("shared", DECL_ATTRIBUTES (decl))) 464 flags |= SECTION_PE_SHARED; 465 } 466 467 if (decl && DECL_P (decl) && DECL_ONE_ONLY (decl)) 468 flags |= SECTION_LINKONCE; 469 470 return flags; 471} 472 473void 474i386_pe_asm_named_section (const char *name, unsigned int flags, 475 tree decl) 476{ 477 char flagchars[8], *f = flagchars; 478 479#if defined (HAVE_GAS_SECTION_EXCLUDE) && HAVE_GAS_SECTION_EXCLUDE == 1 480 if ((flags & SECTION_EXCLUDE) != 0) 481 *f++ = 'e'; 482#endif 483 484 if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0) 485 /* readonly data */ 486 { 487 *f++ ='d'; /* This is necessary for older versions of gas. */ 488 *f++ ='r'; 489 } 490 else 491 { 492 if (flags & SECTION_CODE) 493 *f++ = 'x'; 494 if (flags & SECTION_WRITE) 495 *f++ = 'w'; 496 if (flags & SECTION_PE_SHARED) 497 *f++ = 's'; 498#if !defined (HAVE_GAS_SECTION_EXCLUDE) || HAVE_GAS_SECTION_EXCLUDE == 0 499 /* If attribute "e" isn't supported we mark this section as 500 never-load. */ 501 if ((flags & SECTION_EXCLUDE) != 0) 502 *f++ = 'n'; 503#endif 504 } 505 506 /* LTO sections need 1-byte alignment to avoid confusing the 507 zlib decompression algorithm with trailing zero pad bytes. */ 508 if (strncmp (name, LTO_SECTION_NAME_PREFIX, 509 strlen (LTO_SECTION_NAME_PREFIX)) == 0) 510 *f++ = '0'; 511 512 *f = '\0'; 513 514 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars); 515 516 if (flags & SECTION_LINKONCE) 517 { 518 /* Functions may have been compiled at various levels of 519 optimization so we can't use `same_size' here. 520 Instead, have the linker pick one, without warning. 521 If 'selectany' attribute has been specified, MS compiler 522 sets 'discard' characteristic, rather than telling linker 523 to warn of size or content mismatch, so do the same. */ 524 bool discard = (flags & SECTION_CODE) 525 || (TREE_CODE (decl) != IDENTIFIER_NODE 526 && lookup_attribute ("selectany", 527 DECL_ATTRIBUTES (decl))); 528 fprintf (asm_out_file, "\t.linkonce %s\n", 529 (discard ? "discard" : "same_size")); 530 } 531} 532 533/* Beware, DECL may be NULL if compile_file() is emitting the LTO marker. */ 534 535void 536i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl, 537 const char *name, HOST_WIDE_INT size, 538 HOST_WIDE_INT align) 539{ 540 HOST_WIDE_INT rounded; 541 542 /* Compute as in assemble_noswitch_variable, since we don't have 543 support for aligned common on older binutils. We must also 544 avoid emitting a common symbol of size zero, as this is the 545 overloaded representation that indicates an undefined external 546 symbol in the PE object file format. */ 547 rounded = size ? size : 1; 548 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1; 549 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) 550 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT)); 551 552 i386_pe_maybe_record_exported_symbol (decl, name, 1); 553 554 fprintf (stream, "\t.comm\t"); 555 assemble_name (stream, name); 556 if (use_pe_aligned_common) 557 fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC ", %d\n", 558 size ? size : HOST_WIDE_INT_1, 559 exact_log2 (align) - exact_log2 (CHAR_BIT)); 560 else 561 fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC "\t" ASM_COMMENT_START 562 " " HOST_WIDE_INT_PRINT_DEC "\n", rounded, size); 563} 564 565/* The Microsoft linker requires that every function be marked as 566 DT_FCN. When using gas on cygwin, we must emit appropriate .type 567 directives. */ 568 569#include "gsyms.h" 570 571/* Mark a function appropriately. This should only be called for 572 functions for which we are not emitting COFF debugging information. 573 FILE is the assembler output file, NAME is the name of the 574 function, and PUB is nonzero if the function is globally 575 visible. */ 576 577void 578i386_pe_declare_function_type (FILE *file, const char *name, int pub) 579{ 580 fprintf (file, "\t.def\t"); 581 assemble_name (file, name); 582 fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n", 583 pub ? (int) C_EXT : (int) C_STAT, 584 (int) DT_FCN << N_BTSHFT); 585} 586 587/* Keep a list of external functions. */ 588 589struct GTY(()) extern_list 590{ 591 struct extern_list *next; 592 tree decl; 593 const char *name; 594}; 595 596static GTY(()) struct extern_list *extern_head; 597 598/* Assemble an external function reference. We need to keep a list of 599 these, so that we can output the function types at the end of the 600 assembly. We can't output the types now, because we might see a 601 definition of the function later on and emit debugging information 602 for it then. */ 603 604void 605i386_pe_record_external_function (tree decl, const char *name) 606{ 607 struct extern_list *p; 608 609 p = ggc_alloc<extern_list> (); 610 p->next = extern_head; 611 p->decl = decl; 612 p->name = name; 613 extern_head = p; 614} 615 616/* Keep a list of exported symbols. */ 617 618struct GTY(()) export_list 619{ 620 struct export_list *next; 621 const char *name; 622 int is_data; /* used to type tag exported symbols. */ 623}; 624 625/* Keep a list of stub symbols. */ 626 627struct GTY(()) stub_list 628{ 629 struct stub_list *next; 630 const char *name; 631}; 632 633static GTY(()) struct export_list *export_head; 634 635static GTY(()) struct stub_list *stub_head; 636 637/* Assemble an export symbol entry. We need to keep a list of 638 these, so that we can output the export list at the end of the 639 assembly. We used to output these export symbols in each function, 640 but that causes problems with GNU ld when the sections are 641 linkonce. Beware, DECL may be NULL if compile_file() is emitting 642 the LTO marker. */ 643 644void 645i386_pe_maybe_record_exported_symbol (tree decl, const char *name, int is_data) 646{ 647 rtx symbol; 648 struct export_list *p; 649 650 if (!decl) 651 return; 652 653 symbol = XEXP (DECL_RTL (decl), 0); 654 gcc_assert (GET_CODE (symbol) == SYMBOL_REF); 655 if (!SYMBOL_REF_DLLEXPORT_P (symbol)) 656 return; 657 658 gcc_assert (TREE_PUBLIC (decl)); 659 660 p = ggc_alloc<export_list> (); 661 p->next = export_head; 662 p->name = name; 663 p->is_data = is_data; 664 export_head = p; 665} 666 667void 668i386_pe_record_stub (const char *name) 669{ 670 struct stub_list *p; 671 672 if (!name || *name == 0) 673 return; 674 675 p = stub_head; 676 while (p != NULL) 677 { 678 if (p->name[0] == *name 679 && !strcmp (p->name, name)) 680 return; 681 p = p->next; 682 } 683 684 p = ggc_alloc<stub_list> (); 685 p->next = stub_head; 686 p->name = name; 687 stub_head = p; 688} 689 690 691#ifdef CXX_WRAP_SPEC_LIST 692 693/* Search for a function named TARGET in the list of library wrappers 694 we are using, returning a pointer to it if found or NULL if not. 695 This function might be called on quite a few symbols, and we only 696 have the list of names of wrapped functions available to us as a 697 spec string, so first time round we lazily initialise a hash table 698 to make things quicker. */ 699 700static const char * 701i386_find_on_wrapper_list (const char *target) 702{ 703 static char first_time = 1; 704 static hash_table<nofree_string_hash> *wrappers; 705 706 if (first_time) 707 { 708 /* Beware that this is not a complicated parser, it assumes 709 that any sequence of non-whitespace beginning with an 710 underscore is one of the wrapped symbols. For now that's 711 adequate to distinguish symbols from spec substitutions 712 and command-line options. */ 713 static char wrapper_list_buffer[] = CXX_WRAP_SPEC_LIST; 714 char *bufptr; 715 /* Breaks up the char array into separated strings 716 strings and enter them into the hash table. */ 717 wrappers = new hash_table<nofree_string_hash> (8); 718 for (bufptr = wrapper_list_buffer; *bufptr; ++bufptr) 719 { 720 char *found = NULL; 721 if (ISSPACE (*bufptr)) 722 continue; 723 if (*bufptr == '_') 724 found = bufptr; 725 while (*bufptr && !ISSPACE (*bufptr)) 726 ++bufptr; 727 if (*bufptr) 728 *bufptr = 0; 729 if (found) 730 *wrappers->find_slot (found, INSERT) = found; 731 } 732 first_time = 0; 733 } 734 735 return wrappers->find (target); 736} 737 738#endif /* CXX_WRAP_SPEC_LIST */ 739 740/* This is called at the end of assembly. For each external function 741 which has not been defined, we output a declaration now. We also 742 output the .drectve section. */ 743 744void 745i386_pe_file_end (void) 746{ 747 struct extern_list *p; 748 749 for (p = extern_head; p != NULL; p = p->next) 750 { 751 tree decl; 752 753 decl = p->decl; 754 755 /* Positively ensure only one declaration for any given symbol. */ 756 if (! TREE_ASM_WRITTEN (decl) 757 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 758 { 759#ifdef CXX_WRAP_SPEC_LIST 760 /* To ensure the DLL that provides the corresponding real 761 functions is still loaded at runtime, we must reference 762 the real function so that an (unused) import is created. */ 763 const char *realsym = i386_find_on_wrapper_list (p->name); 764 if (realsym) 765 i386_pe_declare_function_type (asm_out_file, 766 concat ("__real_", realsym, NULL), TREE_PUBLIC (decl)); 767#endif /* CXX_WRAP_SPEC_LIST */ 768 TREE_ASM_WRITTEN (decl) = 1; 769 i386_pe_declare_function_type (asm_out_file, p->name, 770 TREE_PUBLIC (decl)); 771 } 772 } 773 774 if (export_head) 775 { 776 struct export_list *q; 777 drectve_section (); 778 for (q = export_head; q != NULL; q = q->next) 779 { 780 fprintf (asm_out_file, "\t.ascii \" -export:\\\"%s\\\"%s\"\n", 781 default_strip_name_encoding (q->name), 782 (q->is_data ? ",data" : "")); 783 } 784 } 785 786 if (stub_head) 787 { 788 struct stub_list *q; 789 790 for (q = stub_head; q != NULL; q = q->next) 791 { 792 const char *name = q->name; 793 const char *oname; 794 795 if (name[0] == '*') 796 ++name; 797 oname = name; 798 if (name[0] == '.') 799 ++name; 800 if (strncmp (name, "refptr.", 7) != 0) 801 continue; 802 name += 7; 803 fprintf (asm_out_file, "\t.section\t.rdata$%s, \"dr\"\n" 804 "\t.globl\t%s\n" 805 "\t.linkonce\tdiscard\n", oname, oname); 806 fprintf (asm_out_file, "%s:\n\t.quad\t%s\n", oname, name); 807 } 808 } 809} 810 811/* Kludge because of missing PE-COFF support for early LTO debug. */ 812 813static enum debug_info_levels saved_debug_info_level; 814 815void 816i386_pe_asm_lto_start (void) 817{ 818 saved_debug_info_level = debug_info_level; 819 debug_info_level = DINFO_LEVEL_NONE; 820} 821 822void 823i386_pe_asm_lto_end (void) 824{ 825 debug_info_level = saved_debug_info_level; 826} 827 828 829/* x64 Structured Exception Handling unwind info. */ 830 831struct seh_frame_state 832{ 833 /* SEH records offsets relative to the lowest address of the fixed stack 834 allocation. If there is no frame pointer, these offsets are from the 835 stack pointer; if there is a frame pointer, these offsets are from the 836 value of the stack pointer when the frame pointer was established, i.e. 837 the frame pointer minus the offset in the .seh_setframe directive. 838 839 We do not distinguish these two cases, i.e. we consider that the offsets 840 are always relative to the "current" stack pointer. This means that we 841 need to perform the fixed stack allocation before establishing the frame 842 pointer whenever there are registers to be saved, and this is guaranteed 843 by the prologue provided that we force the frame pointer to point at or 844 below the lowest used register save area, see ix86_compute_frame_layout. 845 846 This tracks the current stack pointer offset from the CFA. */ 847 HOST_WIDE_INT sp_offset; 848 849 /* The CFA is located at CFA_REG + CFA_OFFSET. */ 850 HOST_WIDE_INT cfa_offset; 851 rtx cfa_reg; 852 853 /* The offset wrt the CFA where register N has been saved. */ 854 HOST_WIDE_INT reg_offset[FIRST_PSEUDO_REGISTER]; 855 856 /* True if we are past the end of the epilogue. */ 857 bool after_prologue; 858 859 /* True if we are in the cold section. */ 860 bool in_cold_section; 861}; 862 863/* Set up data structures beginning output for SEH. */ 864 865void 866i386_pe_seh_init (FILE *f) 867{ 868 struct seh_frame_state *seh; 869 870 if (!TARGET_SEH) 871 return; 872 if (cfun->is_thunk) 873 return; 874 875 /* We cannot support DRAP with SEH. We turned off support for it by 876 re-defining MAX_STACK_ALIGNMENT when SEH is enabled. */ 877 gcc_assert (!stack_realign_drap); 878 879 seh = XCNEW (struct seh_frame_state); 880 cfun->machine->seh = seh; 881 882 seh->sp_offset = INCOMING_FRAME_SP_OFFSET; 883 seh->cfa_offset = INCOMING_FRAME_SP_OFFSET; 884 seh->cfa_reg = stack_pointer_rtx; 885 886 fputs ("\t.seh_proc\t", f); 887 assemble_name (f, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun->decl))); 888 fputc ('\n', f); 889} 890 891/* Emit an assembler directive for the end of the prologue. */ 892 893void 894i386_pe_seh_end_prologue (FILE *f) 895{ 896 if (!TARGET_SEH) 897 return; 898 if (cfun->is_thunk) 899 return; 900 cfun->machine->seh->after_prologue = true; 901 fputs ("\t.seh_endprologue\n", f); 902} 903 904/* Emit assembler directives to reconstruct the SEH state. */ 905 906void 907i386_pe_seh_cold_init (FILE *f, const char *name) 908{ 909 struct seh_frame_state *seh; 910 HOST_WIDE_INT alloc_offset, offset; 911 912 if (!TARGET_SEH) 913 return; 914 if (cfun->is_thunk) 915 return; 916 seh = cfun->machine->seh; 917 918 fputs ("\t.seh_proc\t", f); 919 assemble_name (f, name); 920 fputc ('\n', f); 921 922 /* In the normal case, the frame pointer is near the bottom of the frame 923 so we can do the full stack allocation and set it afterwards. There 924 is an exception if the function overflows the SEH maximum frame size 925 or accesses prior frames so, in this case, we need to pre-allocate a 926 small chunk of stack before setting it. */ 927 offset = seh->sp_offset - INCOMING_FRAME_SP_OFFSET; 928 if (offset < SEH_MAX_FRAME_SIZE && !crtl->accesses_prior_frames) 929 alloc_offset = seh->sp_offset; 930 else 931 alloc_offset = MIN (seh->cfa_offset + 240, seh->sp_offset); 932 933 offset = alloc_offset - INCOMING_FRAME_SP_OFFSET; 934 if (offset > 0) 935 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset); 936 937 for (int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 938 if (seh->reg_offset[regno] > 0 && seh->reg_offset[regno] <= alloc_offset) 939 { 940 if (SSE_REGNO_P (regno)) 941 fputs ("\t.seh_savexmm\t", f); 942 else if (GENERAL_REGNO_P (regno)) 943 fputs ("\t.seh_savereg\t", f); 944 else 945 gcc_unreachable (); 946 print_reg (gen_rtx_REG (DImode, regno), 0, f); 947 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", 948 alloc_offset - seh->reg_offset[regno]); 949 } 950 951 if (seh->cfa_reg != stack_pointer_rtx) 952 { 953 offset = alloc_offset - seh->cfa_offset; 954 955 gcc_assert ((offset & 15) == 0); 956 gcc_assert (IN_RANGE (offset, 0, 240)); 957 958 fputs ("\t.seh_setframe\t", f); 959 print_reg (seh->cfa_reg, 0, f); 960 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset); 961 } 962 963 if (alloc_offset != seh->sp_offset) 964 { 965 offset = seh->sp_offset - alloc_offset; 966 if (offset > 0 && offset < SEH_MAX_FRAME_SIZE) 967 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset); 968 969 for (int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 970 if (seh->reg_offset[regno] > alloc_offset) 971 { 972 if (SSE_REGNO_P (regno)) 973 fputs ("\t.seh_savexmm\t", f); 974 else if (GENERAL_REGNO_P (regno)) 975 fputs ("\t.seh_savereg\t", f); 976 else 977 gcc_unreachable (); 978 print_reg (gen_rtx_REG (DImode, regno), 0, f); 979 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", 980 seh->sp_offset - seh->reg_offset[regno]); 981 } 982 } 983 984 fputs ("\t.seh_endprologue\n", f); 985} 986 987/* Emit an assembler directive for the end of the function. */ 988 989static void 990i386_pe_seh_fini (FILE *f, bool cold) 991{ 992 struct seh_frame_state *seh; 993 994 if (!TARGET_SEH) 995 return; 996 if (cfun->is_thunk) 997 return; 998 seh = cfun->machine->seh; 999 if (cold != seh->in_cold_section) 1000 return; 1001 XDELETE (seh); 1002 cfun->machine->seh = NULL; 1003 fputs ("\t.seh_endproc\n", f); 1004} 1005 1006/* Emit an assembler directive to save REG via a PUSH. */ 1007 1008static void 1009seh_emit_push (FILE *f, struct seh_frame_state *seh, rtx reg) 1010{ 1011 const unsigned int regno = REGNO (reg); 1012 1013 gcc_checking_assert (GENERAL_REGNO_P (regno)); 1014 1015 seh->sp_offset += UNITS_PER_WORD; 1016 seh->reg_offset[regno] = seh->sp_offset; 1017 if (seh->cfa_reg == stack_pointer_rtx) 1018 seh->cfa_offset += UNITS_PER_WORD; 1019 1020 fputs ("\t.seh_pushreg\t", f); 1021 print_reg (reg, 0, f); 1022 fputc ('\n', f); 1023} 1024 1025/* Emit an assembler directive to save REG at CFA - CFA_OFFSET. */ 1026 1027static void 1028seh_emit_save (FILE *f, struct seh_frame_state *seh, 1029 rtx reg, HOST_WIDE_INT cfa_offset) 1030{ 1031 const unsigned int regno = REGNO (reg); 1032 HOST_WIDE_INT offset; 1033 1034 seh->reg_offset[regno] = cfa_offset; 1035 1036 /* Negative save offsets are of course not supported, since that 1037 would be a store below the stack pointer and thus clobberable. */ 1038 gcc_assert (seh->sp_offset >= cfa_offset); 1039 offset = seh->sp_offset - cfa_offset; 1040 1041 fputs ((SSE_REGNO_P (regno) ? "\t.seh_savexmm\t" 1042 : GENERAL_REGNO_P (regno) ? "\t.seh_savereg\t" 1043 : (gcc_unreachable (), "")), f); 1044 print_reg (reg, 0, f); 1045 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset); 1046} 1047 1048/* Emit an assembler directive to adjust RSP by OFFSET. */ 1049 1050static void 1051seh_emit_stackalloc (FILE *f, struct seh_frame_state *seh, 1052 HOST_WIDE_INT offset) 1053{ 1054 /* We're only concerned with prologue stack allocations, which all 1055 are subtractions from the stack pointer. */ 1056 gcc_assert (offset < 0); 1057 offset = -offset; 1058 1059 if (seh->cfa_reg == stack_pointer_rtx) 1060 seh->cfa_offset += offset; 1061 seh->sp_offset += offset; 1062 1063 /* Do not output the stackalloc in that case (it won't work as there is no 1064 encoding for very large frame size). */ 1065 if (offset < SEH_MAX_FRAME_SIZE) 1066 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset); 1067} 1068 1069/* Process REG_CFA_ADJUST_CFA for SEH. */ 1070 1071static void 1072seh_cfa_adjust_cfa (FILE *f, struct seh_frame_state *seh, rtx pat) 1073{ 1074 rtx dest, src; 1075 HOST_WIDE_INT reg_offset = 0; 1076 unsigned int dest_regno; 1077 1078 dest = SET_DEST (pat); 1079 src = SET_SRC (pat); 1080 1081 if (GET_CODE (src) == PLUS) 1082 { 1083 reg_offset = INTVAL (XEXP (src, 1)); 1084 src = XEXP (src, 0); 1085 } 1086 else if (GET_CODE (src) == MINUS) 1087 { 1088 reg_offset = -INTVAL (XEXP (src, 1)); 1089 src = XEXP (src, 0); 1090 } 1091 gcc_assert (src == stack_pointer_rtx); 1092 gcc_assert (seh->cfa_reg == stack_pointer_rtx); 1093 dest_regno = REGNO (dest); 1094 1095 if (dest_regno == STACK_POINTER_REGNUM) 1096 seh_emit_stackalloc (f, seh, reg_offset); 1097 else if (dest_regno == HARD_FRAME_POINTER_REGNUM) 1098 { 1099 HOST_WIDE_INT offset; 1100 1101 seh->cfa_reg = dest; 1102 seh->cfa_offset -= reg_offset; 1103 1104 offset = seh->sp_offset - seh->cfa_offset; 1105 1106 gcc_assert ((offset & 15) == 0); 1107 gcc_assert (IN_RANGE (offset, 0, 240)); 1108 1109 fputs ("\t.seh_setframe\t", f); 1110 print_reg (seh->cfa_reg, 0, f); 1111 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset); 1112 } 1113 else 1114 gcc_unreachable (); 1115} 1116 1117/* Process REG_CFA_OFFSET for SEH. */ 1118 1119static void 1120seh_cfa_offset (FILE *f, struct seh_frame_state *seh, rtx pat) 1121{ 1122 rtx dest, src; 1123 HOST_WIDE_INT reg_offset; 1124 1125 dest = SET_DEST (pat); 1126 src = SET_SRC (pat); 1127 1128 gcc_assert (MEM_P (dest)); 1129 dest = XEXP (dest, 0); 1130 if (REG_P (dest)) 1131 reg_offset = 0; 1132 else 1133 { 1134 gcc_assert (GET_CODE (dest) == PLUS); 1135 reg_offset = INTVAL (XEXP (dest, 1)); 1136 dest = XEXP (dest, 0); 1137 } 1138 gcc_assert (dest == seh->cfa_reg); 1139 1140 seh_emit_save (f, seh, src, seh->cfa_offset - reg_offset); 1141} 1142 1143/* Process a FRAME_RELATED_EXPR for SEH. */ 1144 1145static void 1146seh_frame_related_expr (FILE *f, struct seh_frame_state *seh, rtx pat) 1147{ 1148 rtx dest, src; 1149 HOST_WIDE_INT addend; 1150 1151 /* See the full loop in dwarf2out_frame_debug_expr. */ 1152 if (GET_CODE (pat) == PARALLEL || GET_CODE (pat) == SEQUENCE) 1153 { 1154 int i, n = XVECLEN (pat, 0), pass, npass; 1155 1156 npass = (GET_CODE (pat) == PARALLEL ? 2 : 1); 1157 for (pass = 0; pass < npass; ++pass) 1158 for (i = 0; i < n; ++i) 1159 { 1160 rtx ele = XVECEXP (pat, 0, i); 1161 1162 if (GET_CODE (ele) != SET) 1163 continue; 1164 dest = SET_DEST (ele); 1165 1166 /* Process each member of the PARALLEL independently. The first 1167 member is always processed; others only if they are marked. */ 1168 if (i == 0 || RTX_FRAME_RELATED_P (ele)) 1169 { 1170 /* Evaluate all register saves in the first pass and all 1171 register updates in the second pass. */ 1172 if ((MEM_P (dest) ^ pass) || npass == 1) 1173 seh_frame_related_expr (f, seh, ele); 1174 } 1175 } 1176 return; 1177 } 1178 1179 dest = SET_DEST (pat); 1180 src = SET_SRC (pat); 1181 1182 switch (GET_CODE (dest)) 1183 { 1184 case REG: 1185 switch (GET_CODE (src)) 1186 { 1187 case REG: 1188 /* REG = REG: This should be establishing a frame pointer. */ 1189 gcc_assert (src == stack_pointer_rtx); 1190 gcc_assert (dest == hard_frame_pointer_rtx); 1191 seh_cfa_adjust_cfa (f, seh, pat); 1192 break; 1193 1194 case PLUS: 1195 addend = INTVAL (XEXP (src, 1)); 1196 src = XEXP (src, 0); 1197 if (dest == hard_frame_pointer_rtx) 1198 seh_cfa_adjust_cfa (f, seh, pat); 1199 else if (dest == stack_pointer_rtx) 1200 { 1201 gcc_assert (src == stack_pointer_rtx); 1202 seh_emit_stackalloc (f, seh, addend); 1203 } 1204 else 1205 gcc_unreachable (); 1206 break; 1207 1208 default: 1209 gcc_unreachable (); 1210 } 1211 break; 1212 1213 case MEM: 1214 /* A save of some kind. */ 1215 dest = XEXP (dest, 0); 1216 if (GET_CODE (dest) == PRE_DEC) 1217 { 1218 gcc_checking_assert (GET_MODE (src) == Pmode); 1219 gcc_checking_assert (REG_P (src)); 1220 seh_emit_push (f, seh, src); 1221 } 1222 else 1223 seh_cfa_offset (f, seh, pat); 1224 break; 1225 1226 default: 1227 gcc_unreachable (); 1228 } 1229} 1230 1231/* This function looks at a single insn and emits any SEH directives 1232 required for unwind of this insn. */ 1233 1234void 1235i386_pe_seh_unwind_emit (FILE *asm_out_file, rtx_insn *insn) 1236{ 1237 rtx note, pat; 1238 bool handled_one = false; 1239 struct seh_frame_state *seh; 1240 1241 if (!TARGET_SEH) 1242 return; 1243 1244 seh = cfun->machine->seh; 1245 if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS) 1246 { 1247 /* See ix86_output_call_insn/seh_fixup_eh_fallthru for the rationale. */ 1248 rtx_insn *prev = prev_active_insn (insn); 1249 if (prev && (CALL_P (prev) || !insn_nothrow_p (prev))) 1250 fputs ("\tnop\n", asm_out_file); 1251 fputs ("\t.seh_endproc\n", asm_out_file); 1252 seh->in_cold_section = true; 1253 return; 1254 } 1255 1256 if (NOTE_P (insn) || !RTX_FRAME_RELATED_P (insn)) 1257 return; 1258 1259 /* Skip RTX_FRAME_RELATED_P insns that are associated with the epilogue. */ 1260 if (seh->after_prologue) 1261 return; 1262 1263 for (note = REG_NOTES (insn); note ; note = XEXP (note, 1)) 1264 { 1265 switch (REG_NOTE_KIND (note)) 1266 { 1267 case REG_FRAME_RELATED_EXPR: 1268 pat = XEXP (note, 0); 1269 goto found; 1270 1271 case REG_CFA_DEF_CFA: 1272 case REG_CFA_EXPRESSION: 1273 /* Only emitted with DRAP and aligned memory access using a 1274 realigned SP, both of which we disable. */ 1275 gcc_unreachable (); 1276 break; 1277 1278 case REG_CFA_REGISTER: 1279 /* Only emitted in epilogues, which we skip. */ 1280 gcc_unreachable (); 1281 1282 case REG_CFA_ADJUST_CFA: 1283 pat = XEXP (note, 0); 1284 if (pat == NULL) 1285 { 1286 pat = PATTERN (insn); 1287 if (GET_CODE (pat) == PARALLEL) 1288 pat = XVECEXP (pat, 0, 0); 1289 } 1290 seh_cfa_adjust_cfa (asm_out_file, seh, pat); 1291 handled_one = true; 1292 break; 1293 1294 case REG_CFA_OFFSET: 1295 pat = XEXP (note, 0); 1296 if (pat == NULL) 1297 pat = single_set (insn); 1298 seh_cfa_offset (asm_out_file, seh, pat); 1299 handled_one = true; 1300 break; 1301 1302 default: 1303 break; 1304 } 1305 } 1306 if (handled_one) 1307 return; 1308 pat = PATTERN (insn); 1309 found: 1310 seh_frame_related_expr (asm_out_file, seh, pat); 1311} 1312 1313void 1314i386_pe_seh_emit_except_personality (rtx personality) 1315{ 1316 int flags = 0; 1317 1318 if (!TARGET_SEH) 1319 return; 1320 1321 fputs ("\t.seh_handler\t", asm_out_file); 1322 output_addr_const (asm_out_file, personality); 1323 1324#if 0 1325 /* ??? The current implementation of _GCC_specific_handler requires 1326 both except and unwind handling, regardless of which sorts the 1327 user-level function requires. */ 1328 eh_region r; 1329 FOR_ALL_EH_REGION(r) 1330 { 1331 if (r->type == ERT_CLEANUP) 1332 flags |= 1; 1333 else 1334 flags |= 2; 1335 } 1336#else 1337 flags = 3; 1338#endif 1339 1340 if (flags & 1) 1341 fputs (", @unwind", asm_out_file); 1342 if (flags & 2) 1343 fputs (", @except", asm_out_file); 1344 fputc ('\n', asm_out_file); 1345} 1346 1347void 1348i386_pe_seh_init_sections (void) 1349{ 1350 if (TARGET_SEH) 1351 exception_section = get_unnamed_section (0, output_section_asm_op, 1352 "\t.seh_handlerdata"); 1353} 1354 1355void 1356i386_pe_start_function (FILE *f, const char *name, tree decl) 1357{ 1358 i386_pe_maybe_record_exported_symbol (decl, name, 0); 1359 i386_pe_declare_function_type (f, name, TREE_PUBLIC (decl)); 1360 /* In case section was altered by debugging output. */ 1361 if (decl != NULL_TREE) 1362 switch_to_section (function_section (decl)); 1363 ASM_OUTPUT_FUNCTION_LABEL (f, name, decl); 1364} 1365 1366void 1367i386_pe_end_function (FILE *f, const char *, tree) 1368{ 1369 i386_pe_seh_fini (f, false); 1370} 1371 1372void 1373i386_pe_end_cold_function (FILE *f, const char *, tree) 1374{ 1375 i386_pe_seh_fini (f, true); 1376} 1377 1378#include "gt-winnt.h" 1379