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