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.
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
27 #include "hard-reg-set.h"
30 #include "stringpool.h"
34 #include "diagnostic-core.h"
35 #include "hash-table.h"
36 #include "langhooks.h"
40 #include "pointer-set.h"
41 #include "hash-table.h"
43 #include "basic-block.h"
44 #include "tree-ssa-alias.h"
45 #include "internal-fn.h"
46 #include "gimple-fold.h"
48 #include "gimple-expr.h"
51 #include "lto-streamer.h"
53 /* i386/PE specific attribute support.
55 i386/PE has two new attributes:
56 dllexport - for exporting a function/variable that will live in a dll
57 dllimport - for importing a function/variable from a dll
59 Microsoft allows multiple declspecs in one __declspec, separating
60 them with spaces. We do NOT support this. Instead, use __declspec
64 /* Handle a "shared" attribute;
65 arguments as in struct attribute_spec.handler. */
67 ix86_handle_shared_attribute (tree
*node
, tree name
,
68 tree args ATTRIBUTE_UNUSED
,
69 int flags ATTRIBUTE_UNUSED
, bool *no_add_attrs
)
71 if (TREE_CODE (*node
) != VAR_DECL
)
73 warning (OPT_Wattributes
, "%qE attribute only applies to variables",
81 /* Handle a "selectany" attribute;
82 arguments as in struct attribute_spec.handler. */
84 ix86_handle_selectany_attribute (tree
*node
, tree name
,
85 tree args ATTRIBUTE_UNUSED
,
86 int flags ATTRIBUTE_UNUSED
,
89 /* The attribute applies only to objects that are initialized and have
90 external linkage. However, we may not know about initialization
91 until the language frontend has processed the decl. We'll check for
92 initialization later in encode_section_info. */
93 if (TREE_CODE (*node
) != VAR_DECL
|| !TREE_PUBLIC (*node
))
95 error ("%qE attribute applies only to initialized variables"
96 " with external linkage", name
);
104 /* Return the type that we should use to determine if DECL is
105 imported or exported. */
108 associated_type (tree decl
)
110 return (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
111 ? DECL_CONTEXT (decl
) : NULL_TREE
);
114 /* Return true if DECL should be a dllexport'd object. */
117 i386_pe_determine_dllexport_p (tree decl
)
119 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
122 /* Don't export local clones of dllexports. */
123 if (!TREE_PUBLIC (decl
))
126 if (TREE_CODE (decl
) == FUNCTION_DECL
127 && DECL_DECLARED_INLINE_P (decl
)
128 && !flag_keep_inline_dllexport
)
131 if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))
137 /* Return true if DECL should be a dllimport'd object. */
140 i386_pe_determine_dllimport_p (tree decl
)
144 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
147 if (DECL_DLLIMPORT_P (decl
))
150 /* The DECL_DLLIMPORT_P flag was set for decls in the class definition
151 by targetm.cxx.adjust_class_at_definition. Check again to emit
152 error message if the class attribute has been overridden by an
153 out-of-class definition of static data. */
154 assoc
= associated_type (decl
);
155 if (assoc
&& lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc
))
156 && TREE_CODE (decl
) == VAR_DECL
157 && TREE_STATIC (decl
) && TREE_PUBLIC (decl
)
158 && !DECL_EXTERNAL (decl
)
159 /* vtable's are linkonce constants, so defining a vtable is not
160 an error as long as we don't try to import it too. */
161 && !DECL_VIRTUAL_P (decl
))
162 error ("definition of static data member %q+D of "
163 "dllimport%'d class", decl
);
168 /* Handle the -mno-fun-dllimport target switch. */
171 i386_pe_valid_dllimport_attribute_p (const_tree decl
)
173 if (TARGET_NOP_FUN_DLLIMPORT
&& TREE_CODE (decl
) == FUNCTION_DECL
)
178 /* Return string which is the function name, identified by ID, modified
179 with a suffix consisting of an atsign (@) followed by the number of
180 bytes of arguments. If ID is NULL use the DECL_NAME as base. If
181 FASTCALL is true, also add the FASTCALL_PREFIX.
182 Return NULL if no change required. */
185 gen_stdcall_or_fastcall_suffix (tree decl
, tree id
, bool fastcall
)
187 HOST_WIDE_INT total
= 0;
188 const char *old_str
= IDENTIFIER_POINTER (id
!= NULL_TREE
? id
: DECL_NAME (decl
));
190 tree type
= TREE_TYPE (DECL_ORIGIN (decl
));
192 function_args_iterator args_iter
;
194 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
196 if (prototype_p (type
))
198 /* This attribute is ignored for variadic functions. */
202 /* Quit if we hit an incomplete type. Error is reported
203 by convert_arguments in c-typeck.c or cp/typeck.c. */
204 FOREACH_FUNCTION_ARGS(type
, arg
, args_iter
)
206 HOST_WIDE_INT parm_size
;
207 HOST_WIDE_INT parm_boundary_bytes
= PARM_BOUNDARY
/ BITS_PER_UNIT
;
209 if (! COMPLETE_TYPE_P (arg
))
212 parm_size
= int_size_in_bytes (arg
);
216 /* Must round up to include padding. This is done the same
217 way as in store_one_arg. */
218 parm_size
= ((parm_size
+ parm_boundary_bytes
- 1)
219 / parm_boundary_bytes
* parm_boundary_bytes
);
224 /* Assume max of 8 base 10 digits in the suffix. */
225 p
= new_str
= XALLOCAVEC (char, 1 + strlen (old_str
) + 1 + 8 + 1);
227 *p
++ = FASTCALL_PREFIX
;
228 sprintf (p
, "%s@" HOST_WIDE_INT_PRINT_DEC
, old_str
, total
);
230 return get_identifier (new_str
);
233 /* Maybe decorate and get a new identifier for the DECL of a stdcall or
234 fastcall function. The original identifier is supplied in ID. */
237 i386_pe_maybe_mangle_decl_assembler_name (tree decl
, tree id
)
239 tree new_id
= NULL_TREE
;
241 if (TREE_CODE (decl
) == FUNCTION_DECL
)
243 unsigned int ccvt
= ix86_get_callcvt (TREE_TYPE (decl
));
244 if ((ccvt
& IX86_CALLCVT_STDCALL
) != 0)
247 /* If we are using -mrtd emit undecorated symbol and let linker
248 do the proper resolving. */
250 new_id
= gen_stdcall_or_fastcall_suffix (decl
, id
, false);
252 else if ((ccvt
& IX86_CALLCVT_FASTCALL
) != 0)
253 new_id
= gen_stdcall_or_fastcall_suffix (decl
, id
, true);
259 /* Emit an assembler directive to set symbol for DECL visibility to
260 the visibility type VIS, which must not be VISIBILITY_DEFAULT.
261 As for PE there is no hidden support in gas, we just warn for
262 user-specified visibility attributes. */
265 i386_pe_assemble_visibility (tree decl
,
266 int vis ATTRIBUTE_UNUSED
)
269 || !lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
)))
271 if (!DECL_ARTIFICIAL (decl
))
272 warning (OPT_Wattributes
, "visibility attribute not supported "
273 "in this configuration; ignored");
276 /* This is used as a target hook to modify the DECL_ASSEMBLER_NAME
277 in the language-independent default hook
278 langhooks,c:lhd_set_decl_assembler_name ()
279 and in cp/mangle,c:mangle_decl (). */
281 i386_pe_mangle_decl_assembler_name (tree decl
, tree id
)
283 tree new_id
= i386_pe_maybe_mangle_decl_assembler_name (decl
, id
);
285 return (new_id
? new_id
: id
);
288 /* This hook behaves the same as varasm.c/assemble_name(), but
289 generates the name into memory rather than outputting it to
293 i386_pe_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED
)
295 const char *skipped
= name
+ (*name
== '*' ? 1 : 0);
296 const char *stripped
= targetm
.strip_name_encoding (skipped
);
297 if (*name
!= '*' && *user_label_prefix
&& *stripped
!= FASTCALL_PREFIX
)
298 stripped
= ACONCAT ((user_label_prefix
, stripped
, NULL
));
299 return get_identifier (stripped
);
303 i386_pe_encode_section_info (tree decl
, rtx rtl
, int first
)
308 /* Do this last, due to our frobbing of DECL_DLLIMPORT_P above. */
309 default_encode_section_info (decl
, rtl
, first
);
311 /* Careful not to prod global register variables. */
315 symbol
= XEXP (rtl
, 0);
316 gcc_assert (GET_CODE (symbol
) == SYMBOL_REF
);
318 switch (TREE_CODE (decl
))
321 /* FIXME: Imported stdcall names are not modified by the Ada frontend.
322 Check and decorate the RTL name now. */
323 if (strcmp (lang_hooks
.name
, "GNU Ada") == 0)
326 tree old_id
= DECL_ASSEMBLER_NAME (decl
);
327 const char* asm_str
= IDENTIFIER_POINTER (old_id
);
328 /* Do not change the identifier if a verbatim asmspec
329 or if stdcall suffix already added. */
330 if (!(*asm_str
== '*' || strchr (asm_str
, '@'))
331 && (new_id
= i386_pe_maybe_mangle_decl_assembler_name (decl
,
333 XSTR (symbol
, 0) = IDENTIFIER_POINTER (new_id
);
338 if (lookup_attribute ("selectany", DECL_ATTRIBUTES (decl
)))
340 if (DECL_INITIAL (decl
)
341 /* If an object is initialized with a ctor, the static
342 initialization and destruction code for it is present in
343 each unit defining the object. The code that calls the
344 ctor is protected by a link-once guard variable, so that
345 the object still has link-once semantics, */
346 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
)))
347 make_decl_one_only (decl
, DECL_ASSEMBLER_NAME (decl
));
349 error ("%q+D:'selectany' attribute applies only to "
350 "initialized objects", decl
);
358 /* Mark the decl so we can tell from the rtl whether the object is
359 dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes
360 handles dllexport/dllimport override semantics. */
361 flags
= (SYMBOL_REF_FLAGS (symbol
) &
362 ~(SYMBOL_FLAG_DLLIMPORT
| SYMBOL_FLAG_DLLEXPORT
));
363 if (i386_pe_determine_dllexport_p (decl
))
364 flags
|= SYMBOL_FLAG_DLLEXPORT
;
365 else if (i386_pe_determine_dllimport_p (decl
))
366 flags
|= SYMBOL_FLAG_DLLIMPORT
;
368 SYMBOL_REF_FLAGS (symbol
) = flags
;
373 i386_pe_binds_local_p (const_tree exp
)
375 if ((TREE_CODE (exp
) == VAR_DECL
|| TREE_CODE (exp
) == FUNCTION_DECL
)
376 && DECL_DLLIMPORT_P (exp
))
379 /* External public symbols, which aren't weakref-s,
380 have local-binding for PE targets. */
382 && !lookup_attribute ("weakref", DECL_ATTRIBUTES (exp
))
384 && DECL_EXTERNAL (exp
))
386 return default_binds_local_p_1 (exp
, 0);
389 /* Also strip the fastcall prefix and stdcall suffix. */
392 i386_pe_strip_name_encoding_full (const char *str
)
395 const char *name
= default_strip_name_encoding (str
);
397 /* Strip leading '@' on fastcall symbols. */
401 /* Strip trailing "@n". */
402 p
= strchr (name
, '@');
404 return ggc_alloc_string (name
, p
- name
);
410 i386_pe_unique_section (tree decl
, int reloc
)
413 const char *name
, *prefix
;
416 /* Ignore RELOC, if we are allowed to put relocated
417 const data into read-only section. */
418 if (!flag_writable_rel_rdata
)
420 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
421 name
= i386_pe_strip_name_encoding_full (name
);
423 /* The object is put in, for example, section .text$foo.
424 The linker will then ultimately place them in .text
425 (everything from the $ on is stripped). Don't put
426 read-only data in .rdata section to avoid a PE linker
427 bug when .rdata$* grouped sections are used in code
428 without a .rdata section. */
429 if (TREE_CODE (decl
) == FUNCTION_DECL
)
431 else if (decl_readonly_section (decl
, reloc
))
435 len
= strlen (name
) + strlen (prefix
);
436 string
= XALLOCAVEC (char, len
+ 1);
437 sprintf (string
, "%s%s", prefix
, name
);
439 DECL_SECTION_NAME (decl
) = build_string (len
, string
);
442 /* Local and global relocs can be placed always into readonly memory for
443 memory for PE-COFF targets. */
445 i386_pe_reloc_rw_mask (void)
450 /* Select a set of attributes for section NAME based on the properties
451 of DECL and whether or not RELOC indicates that DECL's initializer
452 might contain runtime relocations.
454 We make the section read-only and executable for a function decl,
455 read-only for a const data decl, and writable for a non-const data decl.
457 If the section has already been defined, to not allow it to have
458 different attributes, as (1) this is ambiguous since we're not seeing
459 all the declarations up front and (2) some assemblers (e.g. SVR4)
460 do not recognize section redefinitions. */
461 /* ??? This differs from the "standard" PE implementation in that we
462 handle the SHARED variable attribute. Should this be done for all
465 #define SECTION_PE_SHARED SECTION_MACH_DEP
468 i386_pe_section_type_flags (tree decl
, const char *name
, int reloc
)
470 static hash_table
<pointer_hash
<unsigned int> > htab
;
474 /* Ignore RELOC, if we are allowed to put relocated
475 const data into read-only section. */
476 if (!flag_writable_rel_rdata
)
478 /* The names we put in the hashtable will always be the unique
479 versions given to us by the stringtable, so we can just use
480 their addresses as the keys. */
481 if (!htab
.is_created ())
484 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
485 flags
= SECTION_CODE
;
486 else if (decl
&& decl_readonly_section (decl
, reloc
))
490 flags
= SECTION_WRITE
;
492 if (decl
&& TREE_CODE (decl
) == VAR_DECL
493 && lookup_attribute ("shared", DECL_ATTRIBUTES (decl
)))
494 flags
|= SECTION_PE_SHARED
;
497 if (decl
&& DECL_P (decl
) && DECL_ONE_ONLY (decl
))
498 flags
|= SECTION_LINKONCE
;
500 /* See if we already have an entry for this section. */
501 slot
= htab
.find_slot ((unsigned int *)name
, INSERT
);
504 *slot
= (unsigned int *) xmalloc (sizeof (unsigned int));
509 if (decl
&& **slot
!= flags
)
510 error ("%q+D causes a section type conflict", decl
);
517 i386_pe_asm_named_section (const char *name
, unsigned int flags
,
520 char flagchars
[8], *f
= flagchars
;
522 #if defined (HAVE_GAS_SECTION_EXCLUDE) && HAVE_GAS_SECTION_EXCLUDE == 1
523 if ((flags
& SECTION_EXCLUDE
) != 0)
527 if ((flags
& (SECTION_CODE
| SECTION_WRITE
)) == 0)
530 *f
++ ='d'; /* This is necessary for older versions of gas. */
535 if (flags
& SECTION_CODE
)
537 if (flags
& SECTION_WRITE
)
539 if (flags
& SECTION_PE_SHARED
)
541 #if !defined (HAVE_GAS_SECTION_EXCLUDE) || HAVE_GAS_SECTION_EXCLUDE == 0
542 /* If attribute "e" isn't supported we mark this section as
544 if ((flags
& SECTION_EXCLUDE
) != 0)
549 /* LTO sections need 1-byte alignment to avoid confusing the
550 zlib decompression algorithm with trailing zero pad bytes. */
551 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
552 strlen (LTO_SECTION_NAME_PREFIX
)) == 0)
557 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
559 if (flags
& SECTION_LINKONCE
)
561 /* Functions may have been compiled at various levels of
562 optimization so we can't use `same_size' here.
563 Instead, have the linker pick one, without warning.
564 If 'selectany' attribute has been specified, MS compiler
565 sets 'discard' characteristic, rather than telling linker
566 to warn of size or content mismatch, so do the same. */
567 bool discard
= (flags
& SECTION_CODE
)
568 || lookup_attribute ("selectany",
569 DECL_ATTRIBUTES (decl
));
570 fprintf (asm_out_file
, "\t.linkonce %s\n",
571 (discard
? "discard" : "same_size"));
575 /* Beware, DECL may be NULL if compile_file() is emitting the LTO marker. */
578 i386_pe_asm_output_aligned_decl_common (FILE *stream
, tree decl
,
579 const char *name
, HOST_WIDE_INT size
,
580 HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
582 HOST_WIDE_INT rounded
;
584 /* Compute as in assemble_noswitch_variable, since we don't have
585 support for aligned common on older binutils. We must also
586 avoid emitting a common symbol of size zero, as this is the
587 overloaded representation that indicates an undefined external
588 symbol in the PE object file format. */
589 rounded
= size
? size
: 1;
590 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
591 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
592 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
594 i386_pe_maybe_record_exported_symbol (decl
, name
, 1);
596 fprintf (stream
, "\t.comm\t");
597 assemble_name (stream
, name
);
598 if (use_pe_aligned_common
)
599 fprintf (stream
, ", " HOST_WIDE_INT_PRINT_DEC
", %d\n",
600 size
? size
: (HOST_WIDE_INT
) 1,
601 exact_log2 (align
) - exact_log2 (CHAR_BIT
));
603 fprintf (stream
, ", " HOST_WIDE_INT_PRINT_DEC
"\t" ASM_COMMENT_START
604 " " HOST_WIDE_INT_PRINT_DEC
"\n", rounded
, size
);
607 /* The Microsoft linker requires that every function be marked as
608 DT_FCN. When using gas on cygwin, we must emit appropriate .type
613 /* Mark a function appropriately. This should only be called for
614 functions for which we are not emitting COFF debugging information.
615 FILE is the assembler output file, NAME is the name of the
616 function, and PUB is nonzero if the function is globally
620 i386_pe_declare_function_type (FILE *file
, const char *name
, int pub
)
622 fprintf (file
, "\t.def\t");
623 assemble_name (file
, name
);
624 fprintf (file
, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
625 pub
? (int) C_EXT
: (int) C_STAT
,
626 (int) DT_FCN
<< N_BTSHFT
);
629 /* Keep a list of external functions. */
631 struct GTY(()) extern_list
633 struct extern_list
*next
;
638 static GTY(()) struct extern_list
*extern_head
;
640 /* Assemble an external function reference. We need to keep a list of
641 these, so that we can output the function types at the end of the
642 assembly. We can't output the types now, because we might see a
643 definition of the function later on and emit debugging information
647 i386_pe_record_external_function (tree decl
, const char *name
)
649 struct extern_list
*p
;
651 p
= ggc_alloc_extern_list ();
652 p
->next
= extern_head
;
658 /* Keep a list of exported symbols. */
660 struct GTY(()) export_list
662 struct export_list
*next
;
664 int is_data
; /* used to type tag exported symbols. */
667 /* Keep a list of stub symbols. */
669 struct GTY(()) stub_list
671 struct stub_list
*next
;
675 static GTY(()) struct export_list
*export_head
;
677 static GTY(()) struct stub_list
*stub_head
;
679 /* Assemble an export symbol entry. We need to keep a list of
680 these, so that we can output the export list at the end of the
681 assembly. We used to output these export symbols in each function,
682 but that causes problems with GNU ld when the sections are
683 linkonce. Beware, DECL may be NULL if compile_file() is emitting
687 i386_pe_maybe_record_exported_symbol (tree decl
, const char *name
, int is_data
)
690 struct export_list
*p
;
695 symbol
= XEXP (DECL_RTL (decl
), 0);
696 gcc_assert (GET_CODE (symbol
) == SYMBOL_REF
);
697 if (!SYMBOL_REF_DLLEXPORT_P (symbol
))
700 gcc_assert (TREE_PUBLIC (decl
));
702 p
= ggc_alloc_export_list ();
703 p
->next
= export_head
;
705 p
->is_data
= is_data
;
710 i386_pe_record_stub (const char *name
)
714 if (!name
|| *name
== 0)
720 if (p
->name
[0] == *name
721 && !strcmp (p
->name
, name
))
726 p
= ggc_alloc_stub_list ();
733 #ifdef CXX_WRAP_SPEC_LIST
735 /* Hashtable helpers. */
737 struct wrapped_symbol_hasher
: typed_noop_remove
<char>
739 typedef char value_type
;
740 typedef char compare_type
;
741 static inline hashval_t
hash (const value_type
*);
742 static inline bool equal (const value_type
*, const compare_type
*);
743 static inline void remove (value_type
*);
747 wrapped_symbol_hasher::hash (const value_type
*v
)
749 return htab_hash_string (v
);
752 /* Hash table equality helper function. */
755 wrapped_symbol_hasher::equal (const value_type
*x
, const compare_type
*y
)
757 return !strcmp (x
, y
);
760 /* Search for a function named TARGET in the list of library wrappers
761 we are using, returning a pointer to it if found or NULL if not.
762 This function might be called on quite a few symbols, and we only
763 have the list of names of wrapped functions available to us as a
764 spec string, so first time round we lazily initialise a hash table
765 to make things quicker. */
768 i386_find_on_wrapper_list (const char *target
)
770 static char first_time
= 1;
771 static hash_table
<wrapped_symbol_hasher
> wrappers
;
775 /* Beware that this is not a complicated parser, it assumes
776 that any sequence of non-whitespace beginning with an
777 underscore is one of the wrapped symbols. For now that's
778 adequate to distinguish symbols from spec substitutions
779 and command-line options. */
780 static char wrapper_list_buffer
[] = CXX_WRAP_SPEC_LIST
;
782 /* Breaks up the char array into separated strings
783 strings and enter them into the hash table. */
785 for (bufptr
= wrapper_list_buffer
; *bufptr
; ++bufptr
)
788 if (ISSPACE (*bufptr
))
792 while (*bufptr
&& !ISSPACE (*bufptr
))
797 *wrappers
.find_slot (found
, INSERT
) = found
;
802 return wrappers
.find (target
);
805 #endif /* CXX_WRAP_SPEC_LIST */
807 /* This is called at the end of assembly. For each external function
808 which has not been defined, we output a declaration now. We also
809 output the .drectve section. */
812 i386_pe_file_end (void)
814 struct extern_list
*p
;
816 for (p
= extern_head
; p
!= NULL
; p
= p
->next
)
822 /* Positively ensure only one declaration for any given symbol. */
823 if (! TREE_ASM_WRITTEN (decl
)
824 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
826 #ifdef CXX_WRAP_SPEC_LIST
827 /* To ensure the DLL that provides the corresponding real
828 functions is still loaded at runtime, we must reference
829 the real function so that an (unused) import is created. */
830 const char *realsym
= i386_find_on_wrapper_list (p
->name
);
832 i386_pe_declare_function_type (asm_out_file
,
833 concat ("__real_", realsym
, NULL
), TREE_PUBLIC (decl
));
834 #endif /* CXX_WRAP_SPEC_LIST */
835 TREE_ASM_WRITTEN (decl
) = 1;
836 i386_pe_declare_function_type (asm_out_file
, p
->name
,
843 struct export_list
*q
;
845 for (q
= export_head
; q
!= NULL
; q
= q
->next
)
847 fprintf (asm_out_file
, "\t.ascii \" -export:\\\"%s\\\"%s\"\n",
848 default_strip_name_encoding (q
->name
),
849 (q
->is_data
? ",data" : ""));
857 for (q
= stub_head
; q
!= NULL
; q
= q
->next
)
859 const char *name
= q
->name
;
867 if (strncmp (name
, "refptr.", 7) != 0)
870 fprintf (asm_out_file
, "\t.section\t.rdata$%s, \"dr\"\n"
872 "\t.linkonce\tdiscard\n", oname
, oname
);
873 fprintf (asm_out_file
, "%s:\n\t.quad\t%s\n", oname
, name
);
879 /* x64 Structured Exception Handling unwind info. */
881 struct seh_frame_state
883 /* SEH records saves relative to the "current" stack pointer, whether
884 or not there's a frame pointer in place. This tracks the current
885 stack pointer offset from the CFA. */
886 HOST_WIDE_INT sp_offset
;
888 /* The CFA is located at CFA_REG + CFA_OFFSET. */
889 HOST_WIDE_INT cfa_offset
;
893 /* Set up data structures beginning output for SEH. */
896 i386_pe_seh_init (FILE *f
)
898 struct seh_frame_state
*seh
;
905 /* We cannot support DRAP with SEH. We turned off support for it by
906 re-defining MAX_STACK_ALIGNMENT when SEH is enabled. */
907 gcc_assert (!stack_realign_drap
);
909 seh
= XCNEW (struct seh_frame_state
);
910 cfun
->machine
->seh
= seh
;
912 seh
->sp_offset
= INCOMING_FRAME_SP_OFFSET
;
913 seh
->cfa_offset
= INCOMING_FRAME_SP_OFFSET
;
914 seh
->cfa_reg
= stack_pointer_rtx
;
916 fputs ("\t.seh_proc\t", f
);
917 assemble_name (f
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun
->decl
)));
922 i386_pe_seh_end_prologue (FILE *f
)
924 struct seh_frame_state
*seh
;
930 seh
= cfun
->machine
->seh
;
933 cfun
->machine
->seh
= NULL
;
935 fputs ("\t.seh_endprologue\n", f
);
939 i386_pe_seh_fini (FILE *f
)
945 fputs ("\t.seh_endproc\n", f
);
948 /* Emit an assembler directive to save REG via a PUSH. */
951 seh_emit_push (FILE *f
, struct seh_frame_state
*seh
, rtx reg
)
953 unsigned int regno
= REGNO (reg
);
955 gcc_checking_assert (GENERAL_REGNO_P (regno
));
957 seh
->sp_offset
+= UNITS_PER_WORD
;
958 if (seh
->cfa_reg
== stack_pointer_rtx
)
959 seh
->cfa_offset
+= UNITS_PER_WORD
;
961 fputs ("\t.seh_pushreg\t", f
);
962 print_reg (reg
, 0, f
);
966 /* Emit an assembler directive to save REG at CFA - CFA_OFFSET. */
969 seh_emit_save (FILE *f
, struct seh_frame_state
*seh
,
970 rtx reg
, HOST_WIDE_INT cfa_offset
)
972 unsigned int regno
= REGNO (reg
);
973 HOST_WIDE_INT offset
;
975 /* Negative save offsets are of course not supported, since that
976 would be a store below the stack pointer and thus clobberable. */
977 gcc_assert (seh
->sp_offset
>= cfa_offset
);
978 offset
= seh
->sp_offset
- cfa_offset
;
980 fputs ((SSE_REGNO_P (regno
) ? "\t.seh_savexmm\t"
981 : GENERAL_REGNO_P (regno
) ? "\t.seh_savereg\t"
982 : (gcc_unreachable (), "")), f
);
983 print_reg (reg
, 0, f
);
984 fprintf (f
, ", " HOST_WIDE_INT_PRINT_DEC
"\n", offset
);
987 /* Emit an assembler directive to adjust RSP by OFFSET. */
990 seh_emit_stackalloc (FILE *f
, struct seh_frame_state
*seh
,
991 HOST_WIDE_INT offset
)
993 /* We're only concerned with prologue stack allocations, which all
994 are subtractions from the stack pointer. */
995 gcc_assert (offset
< 0);
998 if (seh
->cfa_reg
== stack_pointer_rtx
)
999 seh
->cfa_offset
+= offset
;
1000 seh
->sp_offset
+= offset
;
1002 /* Do not output the stackalloc in that case (it won't work as there is no
1003 encoding for very large frame size). */
1004 if (offset
< SEH_MAX_FRAME_SIZE
)
1005 fprintf (f
, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC
"\n", offset
);
1008 /* Process REG_CFA_ADJUST_CFA for SEH. */
1011 seh_cfa_adjust_cfa (FILE *f
, struct seh_frame_state
*seh
, rtx pat
)
1014 HOST_WIDE_INT reg_offset
= 0;
1015 unsigned int dest_regno
;
1017 dest
= SET_DEST (pat
);
1018 src
= SET_SRC (pat
);
1020 if (GET_CODE (src
) == PLUS
)
1022 reg_offset
= INTVAL (XEXP (src
, 1));
1023 src
= XEXP (src
, 0);
1025 else if (GET_CODE (src
) == MINUS
)
1027 reg_offset
= -INTVAL (XEXP (src
, 1));
1028 src
= XEXP (src
, 0);
1030 gcc_assert (src
== stack_pointer_rtx
);
1031 gcc_assert (seh
->cfa_reg
== stack_pointer_rtx
);
1032 dest_regno
= REGNO (dest
);
1034 if (dest_regno
== STACK_POINTER_REGNUM
)
1035 seh_emit_stackalloc (f
, seh
, reg_offset
);
1036 else if (dest_regno
== HARD_FRAME_POINTER_REGNUM
)
1038 HOST_WIDE_INT offset
;
1040 seh
->cfa_reg
= dest
;
1041 seh
->cfa_offset
-= reg_offset
;
1043 offset
= seh
->sp_offset
- seh
->cfa_offset
;
1045 gcc_assert ((offset
& 15) == 0);
1046 gcc_assert (IN_RANGE (offset
, 0, 240));
1048 fputs ("\t.seh_setframe\t", f
);
1049 print_reg (seh
->cfa_reg
, 0, f
);
1050 fprintf (f
, ", " HOST_WIDE_INT_PRINT_DEC
"\n", offset
);
1056 /* Process REG_CFA_OFFSET for SEH. */
1059 seh_cfa_offset (FILE *f
, struct seh_frame_state
*seh
, rtx pat
)
1062 HOST_WIDE_INT reg_offset
;
1064 dest
= SET_DEST (pat
);
1065 src
= SET_SRC (pat
);
1067 gcc_assert (MEM_P (dest
));
1068 dest
= XEXP (dest
, 0);
1073 gcc_assert (GET_CODE (dest
) == PLUS
);
1074 reg_offset
= INTVAL (XEXP (dest
, 1));
1075 dest
= XEXP (dest
, 0);
1077 gcc_assert (dest
== seh
->cfa_reg
);
1079 seh_emit_save (f
, seh
, src
, seh
->cfa_offset
- reg_offset
);
1082 /* Process a FRAME_RELATED_EXPR for SEH. */
1085 seh_frame_related_expr (FILE *f
, struct seh_frame_state
*seh
, rtx pat
)
1088 HOST_WIDE_INT addend
;
1090 /* See the full loop in dwarf2out_frame_debug_expr. */
1091 if (GET_CODE (pat
) == PARALLEL
|| GET_CODE (pat
) == SEQUENCE
)
1093 int i
, n
= XVECLEN (pat
, 0), pass
, npass
;
1095 npass
= (GET_CODE (pat
) == PARALLEL
? 2 : 1);
1096 for (pass
= 0; pass
< npass
; ++pass
)
1097 for (i
= 0; i
< n
; ++i
)
1099 rtx ele
= XVECEXP (pat
, 0, i
);
1101 if (GET_CODE (ele
) != SET
)
1103 dest
= SET_DEST (ele
);
1105 /* Process each member of the PARALLEL independently. The first
1106 member is always processed; others only if they are marked. */
1107 if (i
== 0 || RTX_FRAME_RELATED_P (ele
))
1109 /* Evaluate all register saves in the first pass and all
1110 register updates in the second pass. */
1111 if ((MEM_P (dest
) ^ pass
) || npass
== 1)
1112 seh_frame_related_expr (f
, seh
, ele
);
1118 dest
= SET_DEST (pat
);
1119 src
= SET_SRC (pat
);
1121 switch (GET_CODE (dest
))
1124 switch (GET_CODE (src
))
1127 /* REG = REG: This should be establishing a frame pointer. */
1128 gcc_assert (src
== stack_pointer_rtx
);
1129 gcc_assert (dest
== hard_frame_pointer_rtx
);
1130 seh_cfa_adjust_cfa (f
, seh
, pat
);
1134 addend
= INTVAL (XEXP (src
, 1));
1135 src
= XEXP (src
, 0);
1136 if (dest
== hard_frame_pointer_rtx
)
1137 seh_cfa_adjust_cfa (f
, seh
, pat
);
1138 else if (dest
== stack_pointer_rtx
)
1140 gcc_assert (src
== stack_pointer_rtx
);
1141 seh_emit_stackalloc (f
, seh
, addend
);
1153 /* A save of some kind. */
1154 dest
= XEXP (dest
, 0);
1155 if (GET_CODE (dest
) == PRE_DEC
)
1157 gcc_checking_assert (GET_MODE (src
) == Pmode
);
1158 gcc_checking_assert (REG_P (src
));
1159 seh_emit_push (f
, seh
, src
);
1162 seh_cfa_offset (f
, seh
, pat
);
1170 /* This function looks at a single insn and emits any SEH directives
1171 required for unwind of this insn. */
1174 i386_pe_seh_unwind_emit (FILE *asm_out_file
, rtx insn
)
1177 bool handled_one
= false;
1178 struct seh_frame_state
*seh
;
1183 /* We free the SEH data once done with the prologue. Ignore those
1184 RTX_FRAME_RELATED_P insns that are associated with the epilogue. */
1185 seh
= cfun
->machine
->seh
;
1189 if (NOTE_P (insn
) || !RTX_FRAME_RELATED_P (insn
))
1192 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1194 switch (REG_NOTE_KIND (note
))
1196 case REG_FRAME_RELATED_EXPR
:
1197 pat
= XEXP (note
, 0);
1200 case REG_CFA_DEF_CFA
:
1201 case REG_CFA_EXPRESSION
:
1202 /* Only emitted with DRAP, which we disable. */
1206 case REG_CFA_REGISTER
:
1207 /* Only emitted in epilogues, which we skip. */
1210 case REG_CFA_ADJUST_CFA
:
1211 pat
= XEXP (note
, 0);
1214 pat
= PATTERN (insn
);
1215 if (GET_CODE (pat
) == PARALLEL
)
1216 pat
= XVECEXP (pat
, 0, 0);
1218 seh_cfa_adjust_cfa (asm_out_file
, seh
, pat
);
1222 case REG_CFA_OFFSET
:
1223 pat
= XEXP (note
, 0);
1225 pat
= single_set (insn
);
1226 seh_cfa_offset (asm_out_file
, seh
, pat
);
1236 pat
= PATTERN (insn
);
1238 seh_frame_related_expr (asm_out_file
, seh
, pat
);
1242 i386_pe_seh_emit_except_personality (rtx personality
)
1249 fputs ("\t.seh_handler\t", asm_out_file
);
1250 output_addr_const (asm_out_file
, personality
);
1253 /* ??? The current implementation of _GCC_specific_handler requires
1254 both except and unwind handling, regardless of which sorts the
1255 user-level function requires. */
1257 FOR_ALL_EH_REGION(r
)
1259 if (r
->type
== ERT_CLEANUP
)
1269 fputs (", @unwind", asm_out_file
);
1271 fputs (", @except", asm_out_file
);
1272 fputc ('\n', asm_out_file
);
1276 i386_pe_seh_init_sections (void)
1279 exception_section
= get_unnamed_section (0, output_section_asm_op
,
1280 "\t.seh_handlerdata");
1284 i386_pe_start_function (FILE *f
, const char *name
, tree decl
)
1286 i386_pe_maybe_record_exported_symbol (decl
, name
, 0);
1287 if (write_symbols
!= SDB_DEBUG
)
1288 i386_pe_declare_function_type (f
, name
, TREE_PUBLIC (decl
));
1289 /* In case section was altered by debugging output. */
1290 if (decl
!= NULL_TREE
)
1291 switch_to_section (function_section (decl
));
1292 ASM_OUTPUT_FUNCTION_LABEL (f
, name
, decl
);
1296 i386_pe_end_function (FILE *f
, const char *name ATTRIBUTE_UNUSED
,
1297 tree decl ATTRIBUTE_UNUSED
)
1299 i386_pe_seh_fini (f
);
1303 #include "gt-winnt.h"