1 /* Subroutines for insn-output.c for Windows NT.
2 Contributed by Douglas Rupp (drupp@cs.washington.edu)
3 Copyright (C) 1995-2018 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 #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. */
57 tree
ix86_handle_shared_attribute(tree * node,tree name,tree,int,bool * no_add_attrs)58 ix86_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. */
73 tree
ix86_handle_selectany_attribute(tree * node,tree name,tree,int,bool * no_add_attrs)74 ix86_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
101 static tree
associated_type(tree decl)102 associated_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
110 static bool
i386_pe_determine_dllexport_p(tree decl)111 i386_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
133 static bool
i386_pe_determine_dllimport_p(tree decl)134 i386_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
164 bool
i386_pe_valid_dllimport_attribute_p(const_tree decl)165 i386_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
178 static tree
gen_stdcall_or_fastcall_suffix(tree decl,tree id,bool fastcall)179 gen_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
230 static tree
i386_pe_maybe_mangle_decl_assembler_name(tree decl,tree id)231 i386_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
258 void
i386_pe_assemble_visibility(tree decl,int)259 i386_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 (). */
273 tree
i386_pe_mangle_decl_assembler_name(tree decl,tree id)274 i386_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
285 tree
i386_pe_mangle_assembler_name(const char * name)286 i386_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
295 void
i386_pe_encode_section_info(tree decl,rtx rtl,int first)296 i386_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
335 bool
i386_pe_binds_local_p(const_tree exp)336 i386_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
368 const char *
i386_pe_strip_name_encoding_full(const char * str)369 i386_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
386 void
i386_pe_unique_section(tree decl,int reloc)387 i386_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. */
421 int
i386_pe_reloc_rw_mask(void)422 i386_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
444 unsigned int
i386_pe_section_type_flags(tree decl,const char *,int reloc)445 i386_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
473 void
i386_pe_asm_named_section(const char * name,unsigned int flags,tree decl)474 i386_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
535 void
i386_pe_asm_output_aligned_decl_common(FILE * stream,tree decl,const char * name,HOST_WIDE_INT size,HOST_WIDE_INT align)536 i386_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
577 void
i386_pe_declare_function_type(FILE * file,const char * name,int pub)578 i386_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
589 struct GTY(()) extern_list
590 {
591 struct extern_list *next;
592 tree decl;
593 const char *name;
594 };
595
596 static 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
604 void
i386_pe_record_external_function(tree decl,const char * name)605 i386_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
618 struct 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
627 struct GTY(()) stub_list
628 {
629 struct stub_list *next;
630 const char *name;
631 };
632
633 static GTY(()) struct export_list *export_head;
634
635 static 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
644 void
i386_pe_maybe_record_exported_symbol(tree decl,const char * name,int is_data)645 i386_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
667 void
i386_pe_record_stub(const char * name)668 i386_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
700 static const char *
i386_find_on_wrapper_list(const char * target)701 i386_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
744 void
i386_pe_file_end(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 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
813 static enum debug_info_levels saved_debug_info_level;
814
815 void
i386_pe_asm_lto_start(void)816 i386_pe_asm_lto_start (void)
817 {
818 saved_debug_info_level = debug_info_level;
819 debug_info_level = DINFO_LEVEL_NONE;
820 }
821
822 void
i386_pe_asm_lto_end(void)823 i386_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
831 struct seh_frame_state
832 {
833 /* SEH records saves relative to the "current" stack pointer, whether
834 or not there's a frame pointer in place. This tracks the current
835 stack pointer offset from the CFA. */
836 HOST_WIDE_INT sp_offset;
837
838 /* The CFA is located at CFA_REG + CFA_OFFSET. */
839 HOST_WIDE_INT cfa_offset;
840 rtx cfa_reg;
841
842 /* The offset wrt the CFA where register N has been saved. */
843 HOST_WIDE_INT reg_offset[FIRST_PSEUDO_REGISTER];
844
845 /* True if we are past the end of the epilogue. */
846 bool after_prologue;
847
848 /* True if we are in the cold section. */
849 bool in_cold_section;
850 };
851
852 /* Set up data structures beginning output for SEH. */
853
854 void
i386_pe_seh_init(FILE * f)855 i386_pe_seh_init (FILE *f)
856 {
857 struct seh_frame_state *seh;
858
859 if (!TARGET_SEH)
860 return;
861 if (cfun->is_thunk)
862 return;
863
864 /* We cannot support DRAP with SEH. We turned off support for it by
865 re-defining MAX_STACK_ALIGNMENT when SEH is enabled. */
866 gcc_assert (!stack_realign_drap);
867
868 seh = XCNEW (struct seh_frame_state);
869 cfun->machine->seh = seh;
870
871 seh->sp_offset = INCOMING_FRAME_SP_OFFSET;
872 seh->cfa_offset = INCOMING_FRAME_SP_OFFSET;
873 seh->cfa_reg = stack_pointer_rtx;
874
875 fputs ("\t.seh_proc\t", f);
876 assemble_name (f, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun->decl)));
877 fputc ('\n', f);
878 }
879
880 /* Emit an assembler directive for the end of the prologue. */
881
882 void
i386_pe_seh_end_prologue(FILE * f)883 i386_pe_seh_end_prologue (FILE *f)
884 {
885 if (!TARGET_SEH)
886 return;
887 if (cfun->is_thunk)
888 return;
889 cfun->machine->seh->after_prologue = true;
890 fputs ("\t.seh_endprologue\n", f);
891 }
892
893 /* Emit assembler directives to reconstruct the SEH state. */
894
895 void
i386_pe_seh_cold_init(FILE * f,const char * name)896 i386_pe_seh_cold_init (FILE *f, const char *name)
897 {
898 struct seh_frame_state *seh;
899 HOST_WIDE_INT alloc_offset, offset;
900
901 if (!TARGET_SEH)
902 return;
903 if (cfun->is_thunk)
904 return;
905 seh = cfun->machine->seh;
906
907 fputs ("\t.seh_proc\t", f);
908 assemble_name (f, name);
909 fputc ('\n', f);
910
911 /* In the normal case, the frame pointer is near the bottom of the frame
912 so we can do the full stack allocation and set it afterwards. There
913 is an exception when the function accesses prior frames so, in this
914 case, we need to pre-allocate a small chunk before setting it. */
915 if (crtl->accesses_prior_frames)
916 alloc_offset = seh->cfa_offset;
917 else
918 alloc_offset = seh->sp_offset;
919
920 offset = alloc_offset - INCOMING_FRAME_SP_OFFSET;
921 if (offset > 0 && offset < SEH_MAX_FRAME_SIZE)
922 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset);
923
924 for (int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
925 if (seh->reg_offset[regno] > 0 && seh->reg_offset[regno] <= alloc_offset)
926 {
927 if (SSE_REGNO_P (regno))
928 fputs ("\t.seh_savexmm\t", f);
929 else if (GENERAL_REGNO_P (regno))
930 fputs ("\t.seh_savereg\t", f);
931 else
932 gcc_unreachable ();
933 print_reg (gen_rtx_REG (DImode, regno), 0, f);
934 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n",
935 alloc_offset - seh->reg_offset[regno]);
936 }
937
938 if (seh->cfa_reg != stack_pointer_rtx)
939 {
940 offset = alloc_offset - seh->cfa_offset;
941
942 gcc_assert ((offset & 15) == 0);
943 gcc_assert (IN_RANGE (offset, 0, 240));
944
945 fputs ("\t.seh_setframe\t", f);
946 print_reg (seh->cfa_reg, 0, f);
947 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
948 }
949
950 if (crtl->accesses_prior_frames)
951 {
952 offset = seh->sp_offset - alloc_offset;
953 if (offset > 0 && offset < SEH_MAX_FRAME_SIZE)
954 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset);
955
956 for (int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
957 if (seh->reg_offset[regno] > alloc_offset)
958 {
959 if (SSE_REGNO_P (regno))
960 fputs ("\t.seh_savexmm\t", f);
961 else if (GENERAL_REGNO_P (regno))
962 fputs ("\t.seh_savereg\t", f);
963 else
964 gcc_unreachable ();
965 print_reg (gen_rtx_REG (DImode, regno), 0, f);
966 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n",
967 seh->sp_offset - seh->reg_offset[regno]);
968 }
969 }
970
971 fputs ("\t.seh_endprologue\n", f);
972 }
973
974 /* Emit an assembler directive for the end of the function. */
975
976 static void
i386_pe_seh_fini(FILE * f,bool cold)977 i386_pe_seh_fini (FILE *f, bool cold)
978 {
979 struct seh_frame_state *seh;
980
981 if (!TARGET_SEH)
982 return;
983 if (cfun->is_thunk)
984 return;
985 seh = cfun->machine->seh;
986 if (cold != seh->in_cold_section)
987 return;
988 XDELETE (seh);
989 cfun->machine->seh = NULL;
990 fputs ("\t.seh_endproc\n", f);
991 }
992
993 /* Emit an assembler directive to save REG via a PUSH. */
994
995 static void
seh_emit_push(FILE * f,struct seh_frame_state * seh,rtx reg)996 seh_emit_push (FILE *f, struct seh_frame_state *seh, rtx reg)
997 {
998 const unsigned int regno = REGNO (reg);
999
1000 gcc_checking_assert (GENERAL_REGNO_P (regno));
1001
1002 seh->sp_offset += UNITS_PER_WORD;
1003 seh->reg_offset[regno] = seh->sp_offset;
1004 if (seh->cfa_reg == stack_pointer_rtx)
1005 seh->cfa_offset += UNITS_PER_WORD;
1006
1007 fputs ("\t.seh_pushreg\t", f);
1008 print_reg (reg, 0, f);
1009 fputc ('\n', f);
1010 }
1011
1012 /* Emit an assembler directive to save REG at CFA - CFA_OFFSET. */
1013
1014 static void
seh_emit_save(FILE * f,struct seh_frame_state * seh,rtx reg,HOST_WIDE_INT cfa_offset)1015 seh_emit_save (FILE *f, struct seh_frame_state *seh,
1016 rtx reg, HOST_WIDE_INT cfa_offset)
1017 {
1018 const unsigned int regno = REGNO (reg);
1019 HOST_WIDE_INT offset;
1020
1021 seh->reg_offset[regno] = cfa_offset;
1022
1023 /* Negative save offsets are of course not supported, since that
1024 would be a store below the stack pointer and thus clobberable. */
1025 gcc_assert (seh->sp_offset >= cfa_offset);
1026 offset = seh->sp_offset - cfa_offset;
1027
1028 fputs ((SSE_REGNO_P (regno) ? "\t.seh_savexmm\t"
1029 : GENERAL_REGNO_P (regno) ? "\t.seh_savereg\t"
1030 : (gcc_unreachable (), "")), f);
1031 print_reg (reg, 0, f);
1032 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
1033 }
1034
1035 /* Emit an assembler directive to adjust RSP by OFFSET. */
1036
1037 static void
seh_emit_stackalloc(FILE * f,struct seh_frame_state * seh,HOST_WIDE_INT offset)1038 seh_emit_stackalloc (FILE *f, struct seh_frame_state *seh,
1039 HOST_WIDE_INT offset)
1040 {
1041 /* We're only concerned with prologue stack allocations, which all
1042 are subtractions from the stack pointer. */
1043 gcc_assert (offset < 0);
1044 offset = -offset;
1045
1046 if (seh->cfa_reg == stack_pointer_rtx)
1047 seh->cfa_offset += offset;
1048 seh->sp_offset += offset;
1049
1050 /* Do not output the stackalloc in that case (it won't work as there is no
1051 encoding for very large frame size). */
1052 if (offset < SEH_MAX_FRAME_SIZE)
1053 fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset);
1054 }
1055
1056 /* Process REG_CFA_ADJUST_CFA for SEH. */
1057
1058 static void
seh_cfa_adjust_cfa(FILE * f,struct seh_frame_state * seh,rtx pat)1059 seh_cfa_adjust_cfa (FILE *f, struct seh_frame_state *seh, rtx pat)
1060 {
1061 rtx dest, src;
1062 HOST_WIDE_INT reg_offset = 0;
1063 unsigned int dest_regno;
1064
1065 dest = SET_DEST (pat);
1066 src = SET_SRC (pat);
1067
1068 if (GET_CODE (src) == PLUS)
1069 {
1070 reg_offset = INTVAL (XEXP (src, 1));
1071 src = XEXP (src, 0);
1072 }
1073 else if (GET_CODE (src) == MINUS)
1074 {
1075 reg_offset = -INTVAL (XEXP (src, 1));
1076 src = XEXP (src, 0);
1077 }
1078 gcc_assert (src == stack_pointer_rtx);
1079 gcc_assert (seh->cfa_reg == stack_pointer_rtx);
1080 dest_regno = REGNO (dest);
1081
1082 if (dest_regno == STACK_POINTER_REGNUM)
1083 seh_emit_stackalloc (f, seh, reg_offset);
1084 else if (dest_regno == HARD_FRAME_POINTER_REGNUM)
1085 {
1086 HOST_WIDE_INT offset;
1087
1088 seh->cfa_reg = dest;
1089 seh->cfa_offset -= reg_offset;
1090
1091 offset = seh->sp_offset - seh->cfa_offset;
1092
1093 gcc_assert ((offset & 15) == 0);
1094 gcc_assert (IN_RANGE (offset, 0, 240));
1095
1096 fputs ("\t.seh_setframe\t", f);
1097 print_reg (seh->cfa_reg, 0, f);
1098 fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
1099 }
1100 else
1101 gcc_unreachable ();
1102 }
1103
1104 /* Process REG_CFA_OFFSET for SEH. */
1105
1106 static void
seh_cfa_offset(FILE * f,struct seh_frame_state * seh,rtx pat)1107 seh_cfa_offset (FILE *f, struct seh_frame_state *seh, rtx pat)
1108 {
1109 rtx dest, src;
1110 HOST_WIDE_INT reg_offset;
1111
1112 dest = SET_DEST (pat);
1113 src = SET_SRC (pat);
1114
1115 gcc_assert (MEM_P (dest));
1116 dest = XEXP (dest, 0);
1117 if (REG_P (dest))
1118 reg_offset = 0;
1119 else
1120 {
1121 gcc_assert (GET_CODE (dest) == PLUS);
1122 reg_offset = INTVAL (XEXP (dest, 1));
1123 dest = XEXP (dest, 0);
1124 }
1125 gcc_assert (dest == seh->cfa_reg);
1126
1127 seh_emit_save (f, seh, src, seh->cfa_offset - reg_offset);
1128 }
1129
1130 /* Process a FRAME_RELATED_EXPR for SEH. */
1131
1132 static void
seh_frame_related_expr(FILE * f,struct seh_frame_state * seh,rtx pat)1133 seh_frame_related_expr (FILE *f, struct seh_frame_state *seh, rtx pat)
1134 {
1135 rtx dest, src;
1136 HOST_WIDE_INT addend;
1137
1138 /* See the full loop in dwarf2out_frame_debug_expr. */
1139 if (GET_CODE (pat) == PARALLEL || GET_CODE (pat) == SEQUENCE)
1140 {
1141 int i, n = XVECLEN (pat, 0), pass, npass;
1142
1143 npass = (GET_CODE (pat) == PARALLEL ? 2 : 1);
1144 for (pass = 0; pass < npass; ++pass)
1145 for (i = 0; i < n; ++i)
1146 {
1147 rtx ele = XVECEXP (pat, 0, i);
1148
1149 if (GET_CODE (ele) != SET)
1150 continue;
1151 dest = SET_DEST (ele);
1152
1153 /* Process each member of the PARALLEL independently. The first
1154 member is always processed; others only if they are marked. */
1155 if (i == 0 || RTX_FRAME_RELATED_P (ele))
1156 {
1157 /* Evaluate all register saves in the first pass and all
1158 register updates in the second pass. */
1159 if ((MEM_P (dest) ^ pass) || npass == 1)
1160 seh_frame_related_expr (f, seh, ele);
1161 }
1162 }
1163 return;
1164 }
1165
1166 dest = SET_DEST (pat);
1167 src = SET_SRC (pat);
1168
1169 switch (GET_CODE (dest))
1170 {
1171 case REG:
1172 switch (GET_CODE (src))
1173 {
1174 case REG:
1175 /* REG = REG: This should be establishing a frame pointer. */
1176 gcc_assert (src == stack_pointer_rtx);
1177 gcc_assert (dest == hard_frame_pointer_rtx);
1178 seh_cfa_adjust_cfa (f, seh, pat);
1179 break;
1180
1181 case PLUS:
1182 addend = INTVAL (XEXP (src, 1));
1183 src = XEXP (src, 0);
1184 if (dest == hard_frame_pointer_rtx)
1185 seh_cfa_adjust_cfa (f, seh, pat);
1186 else if (dest == stack_pointer_rtx)
1187 {
1188 gcc_assert (src == stack_pointer_rtx);
1189 seh_emit_stackalloc (f, seh, addend);
1190 }
1191 else
1192 gcc_unreachable ();
1193 break;
1194
1195 default:
1196 gcc_unreachable ();
1197 }
1198 break;
1199
1200 case MEM:
1201 /* A save of some kind. */
1202 dest = XEXP (dest, 0);
1203 if (GET_CODE (dest) == PRE_DEC)
1204 {
1205 gcc_checking_assert (GET_MODE (src) == Pmode);
1206 gcc_checking_assert (REG_P (src));
1207 seh_emit_push (f, seh, src);
1208 }
1209 else
1210 seh_cfa_offset (f, seh, pat);
1211 break;
1212
1213 default:
1214 gcc_unreachable ();
1215 }
1216 }
1217
1218 /* This function looks at a single insn and emits any SEH directives
1219 required for unwind of this insn. */
1220
1221 void
i386_pe_seh_unwind_emit(FILE * asm_out_file,rtx_insn * insn)1222 i386_pe_seh_unwind_emit (FILE *asm_out_file, rtx_insn *insn)
1223 {
1224 rtx note, pat;
1225 bool handled_one = false;
1226 struct seh_frame_state *seh;
1227
1228 if (!TARGET_SEH)
1229 return;
1230
1231 seh = cfun->machine->seh;
1232 if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
1233 {
1234 fputs ("\t.seh_endproc\n", asm_out_file);
1235 seh->in_cold_section = true;
1236 return;
1237 }
1238
1239 if (NOTE_P (insn) || !RTX_FRAME_RELATED_P (insn))
1240 return;
1241
1242 /* Skip RTX_FRAME_RELATED_P insns that are associated with the epilogue. */
1243 if (seh->after_prologue)
1244 return;
1245
1246 for (note = REG_NOTES (insn); note ; note = XEXP (note, 1))
1247 {
1248 switch (REG_NOTE_KIND (note))
1249 {
1250 case REG_FRAME_RELATED_EXPR:
1251 pat = XEXP (note, 0);
1252 goto found;
1253
1254 case REG_CFA_DEF_CFA:
1255 case REG_CFA_EXPRESSION:
1256 /* Only emitted with DRAP and aligned memory access using a
1257 realigned SP, both of which we disable. */
1258 gcc_unreachable ();
1259 break;
1260
1261 case REG_CFA_REGISTER:
1262 /* Only emitted in epilogues, which we skip. */
1263 gcc_unreachable ();
1264
1265 case REG_CFA_ADJUST_CFA:
1266 pat = XEXP (note, 0);
1267 if (pat == NULL)
1268 {
1269 pat = PATTERN (insn);
1270 if (GET_CODE (pat) == PARALLEL)
1271 pat = XVECEXP (pat, 0, 0);
1272 }
1273 seh_cfa_adjust_cfa (asm_out_file, seh, pat);
1274 handled_one = true;
1275 break;
1276
1277 case REG_CFA_OFFSET:
1278 pat = XEXP (note, 0);
1279 if (pat == NULL)
1280 pat = single_set (insn);
1281 seh_cfa_offset (asm_out_file, seh, pat);
1282 handled_one = true;
1283 break;
1284
1285 default:
1286 break;
1287 }
1288 }
1289 if (handled_one)
1290 return;
1291 pat = PATTERN (insn);
1292 found:
1293 seh_frame_related_expr (asm_out_file, seh, pat);
1294 }
1295
1296 void
i386_pe_seh_emit_except_personality(rtx personality)1297 i386_pe_seh_emit_except_personality (rtx personality)
1298 {
1299 int flags = 0;
1300
1301 if (!TARGET_SEH)
1302 return;
1303
1304 fputs ("\t.seh_handler\t", asm_out_file);
1305 output_addr_const (asm_out_file, personality);
1306
1307 #if 0
1308 /* ??? The current implementation of _GCC_specific_handler requires
1309 both except and unwind handling, regardless of which sorts the
1310 user-level function requires. */
1311 eh_region r;
1312 FOR_ALL_EH_REGION(r)
1313 {
1314 if (r->type == ERT_CLEANUP)
1315 flags |= 1;
1316 else
1317 flags |= 2;
1318 }
1319 #else
1320 flags = 3;
1321 #endif
1322
1323 if (flags & 1)
1324 fputs (", @unwind", asm_out_file);
1325 if (flags & 2)
1326 fputs (", @except", asm_out_file);
1327 fputc ('\n', asm_out_file);
1328 }
1329
1330 void
i386_pe_seh_init_sections(void)1331 i386_pe_seh_init_sections (void)
1332 {
1333 if (TARGET_SEH)
1334 exception_section = get_unnamed_section (0, output_section_asm_op,
1335 "\t.seh_handlerdata");
1336 }
1337
1338 void
i386_pe_start_function(FILE * f,const char * name,tree decl)1339 i386_pe_start_function (FILE *f, const char *name, tree decl)
1340 {
1341 i386_pe_maybe_record_exported_symbol (decl, name, 0);
1342 i386_pe_declare_function_type (f, name, TREE_PUBLIC (decl));
1343 /* In case section was altered by debugging output. */
1344 if (decl != NULL_TREE)
1345 switch_to_section (function_section (decl));
1346 ASM_OUTPUT_FUNCTION_LABEL (f, name, decl);
1347 }
1348
1349 void
i386_pe_end_function(FILE * f,const char *,tree)1350 i386_pe_end_function (FILE *f, const char *, tree)
1351 {
1352 i386_pe_seh_fini (f, false);
1353 }
1354
1355 void
i386_pe_end_cold_function(FILE * f,const char *,tree)1356 i386_pe_end_cold_function (FILE *f, const char *, tree)
1357 {
1358 i386_pe_seh_fini (f, true);
1359 }
1360
1361 #include "gt-winnt.h"
1362