OSDN Git Service

c7eae6cb85d65a99735e09490e91921f62fb50cf
[pf3gnuchains/gcc-fork.git] / gcc / config / i386 / winnt.c
1 /* Subroutines for insn-output.c for Windows NT.
2    Contributed by Douglas Rupp (drupp@cs.washington.edu)
3    Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "output.h"
31 #include "tree.h"
32 #include "flags.h"
33 #include "tm_p.h"
34 #include "toplev.h"
35 #include "hashtab.h"
36 #include "ggc.h"
37
38 /* i386/PE specific attribute support.
39
40    i386/PE has two new attributes:
41    dllexport - for exporting a function/variable that will live in a dll
42    dllimport - for importing a function/variable from a dll
43
44    Microsoft allows multiple declspecs in one __declspec, separating
45    them with spaces.  We do NOT support this.  Instead, use __declspec
46    multiple times.
47 */
48
49 static tree associated_type (tree);
50 static tree gen_stdcall_or_fastcall_suffix (tree, bool);
51 static bool i386_pe_dllexport_p (tree);
52 static bool i386_pe_dllimport_p (tree);
53 static void i386_pe_mark_dllexport (tree);
54 static void i386_pe_mark_dllimport (tree);
55
56 /* This is we how mark internal identifiers with dllimport or dllexport
57    attributes.  */
58 #ifndef DLL_IMPORT_PREFIX
59 #define DLL_IMPORT_PREFIX "#i."
60 #endif
61 #ifndef DLL_EXPORT_PREFIX
62 #define DLL_EXPORT_PREFIX "#e."
63 #endif
64
65 /* Handle a "shared" attribute;
66    arguments as in struct attribute_spec.handler.  */
67 tree
68 ix86_handle_shared_attribute (tree *node, tree name,
69                               tree args ATTRIBUTE_UNUSED,
70                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
71 {
72   if (TREE_CODE (*node) != VAR_DECL)
73     {
74       warning (OPT_Wattributes, "%qs attribute only applies to variables",
75                IDENTIFIER_POINTER (name));
76       *no_add_attrs = true;
77     }
78
79   return NULL_TREE;
80 }
81
82 /* Handle a "selectany" attribute;
83    arguments as in struct attribute_spec.handler.  */
84 tree
85 ix86_handle_selectany_attribute (tree *node, tree name,
86                                  tree args ATTRIBUTE_UNUSED,
87                                  int flags ATTRIBUTE_UNUSED,
88                                  bool *no_add_attrs)
89 {
90   /* The attribute applies only to objects that are initialized and have
91      external linkage,  */      
92   if (TREE_CODE (*node) == VAR_DECL && TREE_PUBLIC (*node)
93       && (DECL_INITIAL (*node)
94           /* If an object is initialized with a ctor, the static
95              initialization and destruction code for it is present in
96              each unit defining the object.  The code that calls the
97              ctor is protected by a link-once guard variable, so that
98              the object still has link-once semantics,  */
99           || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (*node))))
100     make_decl_one_only (*node);
101   else
102     {   
103       error ("%qs attribute applies only to initialized variables"
104              " with external linkage",  IDENTIFIER_POINTER (name));
105       *no_add_attrs = true;
106     }
107
108   return NULL_TREE;
109 }
110
111 \f
112 /* Return the type that we should use to determine if DECL is
113    imported or exported.  */
114
115 static tree
116 associated_type (tree decl)
117 {
118   return  (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
119             ?  DECL_CONTEXT (decl) : NULL_TREE;
120 }
121
122
123 /* Return true if DECL is a dllexport'd object.  */
124
125 static bool
126 i386_pe_dllexport_p (tree decl)
127 {
128   if (TREE_CODE (decl) != VAR_DECL
129        && TREE_CODE (decl) != FUNCTION_DECL)
130     return false;
131
132   if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
133     return true;
134
135   /* Also mark class members of exported classes with dllexport.  */
136   if (associated_type (decl)
137       && lookup_attribute ("dllexport",
138                             TYPE_ATTRIBUTES (associated_type (decl))))
139     return i386_pe_type_dllexport_p (decl);
140
141   return false;
142 }
143
144 static bool
145 i386_pe_dllimport_p (tree decl)
146 {
147   if (TREE_CODE (decl) != VAR_DECL
148        && TREE_CODE (decl) != FUNCTION_DECL)
149     return false;
150
151   /* Lookup the attribute rather than rely on the DECL_DLLIMPORT_P flag.
152      We may need to override an earlier decision.  */
153   if (lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl)))
154     return true;
155
156   /* The DECL_DLLIMPORT_P flag was set for decls in the class definition
157      by  targetm.cxx.adjust_class_at_definition.  Check again to emit
158      warnings if the class attribute has been overridden by an
159      out-of-class definition.  */
160   if (associated_type (decl)
161       && lookup_attribute ("dllimport",
162                             TYPE_ATTRIBUTES (associated_type (decl))))
163     return i386_pe_type_dllimport_p (decl);
164
165   return false;
166 }
167
168 /* Handle the -mno-fun-dllimport target switch.  */
169 bool
170 i386_pe_valid_dllimport_attribute_p (tree decl)
171 {
172    if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
173      return false;
174    return true;
175 }
176
177 /* Return nonzero if SYMBOL is marked as being dllexport'd.  */
178
179 int
180 i386_pe_dllexport_name_p (const char *symbol)
181 {
182   return (strncmp (DLL_EXPORT_PREFIX, symbol,
183                    strlen (DLL_EXPORT_PREFIX)) == 0);
184 }
185
186 /* Return nonzero if SYMBOL is marked as being dllimport'd.  */
187
188 int
189 i386_pe_dllimport_name_p (const char *symbol)
190 {
191   return (strncmp (DLL_IMPORT_PREFIX, symbol,
192                    strlen (DLL_IMPORT_PREFIX)) == 0);
193 }
194
195 /* Mark a DECL as being dllexport'd.
196    Note that we override the previous setting (e.g.: dllimport).  */
197
198 static void
199 i386_pe_mark_dllexport (tree decl)
200 {
201   const char *oldname;
202   char  *newname;
203   rtx rtlname;
204   rtx symref;
205   tree idp;
206
207   rtlname = XEXP (DECL_RTL (decl), 0);
208   if (GET_CODE (rtlname) == MEM)
209     rtlname = XEXP (rtlname, 0);
210   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
211   oldname = XSTR (rtlname, 0);
212   if (i386_pe_dllimport_name_p (oldname))
213     {
214       warning (0, "inconsistent dll linkage for %q+D, dllexport assumed",
215                decl);
216      /* Remove DLL_IMPORT_PREFIX.  */
217       oldname += strlen (DLL_IMPORT_PREFIX);
218     }
219   else if (i386_pe_dllexport_name_p (oldname))
220     return;  /*  already done  */
221
222   newname = alloca (strlen (DLL_EXPORT_PREFIX) + strlen (oldname) + 1);
223   sprintf (newname, "%s%s", DLL_EXPORT_PREFIX, oldname);
224
225   /* We pass newname through get_identifier to ensure it has a unique
226      address.  RTL processing can sometimes peek inside the symbol ref
227      and compare the string's addresses to see if two symbols are
228      identical.  */
229   idp = get_identifier (newname);
230
231   symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
232   SET_SYMBOL_REF_DECL (symref, decl);
233   XEXP (DECL_RTL (decl), 0) = symref;
234 }
235
236 /* Mark a DECL as being dllimport'd.  */
237
238 static void
239 i386_pe_mark_dllimport (tree decl)
240 {
241   const char *oldname;
242   char  *newname;
243   tree idp;
244   rtx rtlname, newrtl;
245   rtx symref;
246
247   rtlname = XEXP (DECL_RTL (decl), 0);
248   if (GET_CODE (rtlname) == MEM)
249     rtlname = XEXP (rtlname, 0);
250   gcc_assert (GET_CODE (rtlname) == SYMBOL_REF);
251   oldname = XSTR (rtlname, 0);
252   if (i386_pe_dllexport_name_p (oldname))
253     {
254       error ("%qs declared as both exported to and imported from a DLL",
255              IDENTIFIER_POINTER (DECL_NAME (decl)));
256       return;
257     }
258   else if (i386_pe_dllimport_name_p (oldname))
259     {
260       /* Already done, but do a sanity check to prevent assembler
261          errors.  */
262       gcc_assert (DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)
263                   && DECL_DLLIMPORT_P (decl));
264       return;
265     }
266
267   newname = alloca (strlen (DLL_IMPORT_PREFIX) + strlen (oldname) + 1);
268   sprintf (newname, "%s%s", DLL_IMPORT_PREFIX, oldname);
269
270   /* We pass newname through get_identifier to ensure it has a unique
271      address.  RTL processing can sometimes peek inside the symbol ref
272      and compare the string's addresses to see if two symbols are
273      identical.  */
274   idp = get_identifier (newname);
275
276   symref = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (idp));
277   SET_SYMBOL_REF_DECL (symref, decl);
278   newrtl = gen_rtx_MEM (Pmode,symref);
279   XEXP (DECL_RTL (decl), 0) = newrtl;
280
281   DECL_DLLIMPORT_P (decl) = 1;
282 }
283
284 /* Return string which is the former assembler name modified with a
285    suffix consisting of an atsign (@) followed by the number of bytes of
286    arguments.  If FASTCALL is true, also add the FASTCALL_PREFIX.  */
287
288 static tree
289 gen_stdcall_or_fastcall_suffix (tree decl, bool fastcall)
290 {
291   int total = 0;
292   /* ??? This probably should use XSTR (XEXP (DECL_RTL (decl), 0), 0) instead
293      of DECL_ASSEMBLER_NAME.  */
294    const char *asmname =  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
295   char *newsym;
296   char *p;
297   tree formal_type;
298
299   /* Do not change the identifier if a verbatim asmspec or already done. */
300   if (*asmname == '*' || strchr (asmname, '@'))
301     return DECL_ASSEMBLER_NAME (decl);
302
303   formal_type = TYPE_ARG_TYPES (TREE_TYPE (decl));
304   if (formal_type != NULL_TREE)
305     {
306       /* These attributes are ignored for variadic functions in
307          i386.c:ix86_return_pops_args. For compatibility with MS
308          compiler do not add @0 suffix here.  */ 
309       if (TREE_VALUE (tree_last (formal_type)) != void_type_node)
310         return DECL_ASSEMBLER_NAME (decl);
311
312       /* Quit if we hit an incomplete type.  Error is reported
313          by convert_arguments in c-typeck.c or cp/typeck.c.  */
314       while (TREE_VALUE (formal_type) != void_type_node
315              && COMPLETE_TYPE_P (TREE_VALUE (formal_type)))     
316         {
317           int parm_size
318             = TREE_INT_CST_LOW (TYPE_SIZE (TREE_VALUE (formal_type)));
319             /* Must round up to include padding.  This is done the same
320                way as in store_one_arg.  */
321           parm_size = ((parm_size + PARM_BOUNDARY - 1)
322                        / PARM_BOUNDARY * PARM_BOUNDARY);
323           total += parm_size;
324           formal_type = TREE_CHAIN (formal_type);\
325         }
326      }
327
328   /* Assume max of 8 base 10 digits in the suffix.  */
329   newsym = alloca (1 + strlen (asmname) + 1 + 8 + 1);
330   p = newsym;
331   if (fastcall)
332     *p++ = FASTCALL_PREFIX;
333   sprintf (p, "%s@%d", asmname, total/BITS_PER_UNIT);
334   return get_identifier (newsym);
335 }
336
337 void
338 i386_pe_encode_section_info (tree decl, rtx rtl, int first)
339 {
340   default_encode_section_info (decl, rtl, first);
341
342   if (first && TREE_CODE (decl) == FUNCTION_DECL)
343     {
344       tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
345       tree newid = NULL_TREE;
346
347       if (lookup_attribute ("stdcall", type_attributes))
348         newid = gen_stdcall_or_fastcall_suffix (decl, false);
349       else if (lookup_attribute ("fastcall", type_attributes))
350         newid = gen_stdcall_or_fastcall_suffix (decl, true);
351       if (newid != NULL_TREE)   
352         {
353           rtx rtlname = XEXP (rtl, 0);
354           if (GET_CODE (rtlname) == MEM)
355             rtlname = XEXP (rtlname, 0);
356           XSTR (rtlname, 0) = IDENTIFIER_POINTER (newid);
357           /* These attributes must be present on first declaration,
358              change_decl_assembler_name will warn if they are added
359              later and the decl has been referenced, but duplicate_decls
360              should catch the mismatch before this is called.  */ 
361           change_decl_assembler_name (decl, newid);
362         }
363     }
364
365   /* Mark the decl so we can tell from the rtl whether the object is
366      dllexport'd or dllimport'd.  tree.c: merge_dllimport_decl_attributes
367      handles dllexport/dllimport override semantics.  */
368
369   if (i386_pe_dllexport_p (decl))
370     i386_pe_mark_dllexport (decl);
371   else if (i386_pe_dllimport_p (decl))
372     i386_pe_mark_dllimport (decl);
373   /* It might be that DECL has been declared as dllimport, but a
374      subsequent definition nullified that.  Assert that
375      tree.c: merge_dllimport_decl_attributes has removed the attribute
376      before the RTL name was marked with the DLL_IMPORT_PREFIX.  */
377   else
378     gcc_assert (!((TREE_CODE (decl) == FUNCTION_DECL
379                    || TREE_CODE (decl) == VAR_DECL)
380                   && rtl != NULL_RTX
381                   && GET_CODE (rtl) == MEM
382                   && GET_CODE (XEXP (rtl, 0)) == MEM
383                   && GET_CODE (XEXP (XEXP (rtl, 0), 0)) == SYMBOL_REF
384                   && i386_pe_dllimport_name_p (XSTR (XEXP (XEXP (rtl, 0), 0), 0))));
385 }
386
387 /* Strip only the leading encoding, leaving the stdcall suffix and fastcall
388    prefix if it exists.  */
389
390 const char *
391 i386_pe_strip_name_encoding (const char *str)
392 {
393   if (strncmp (str, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
394       == 0)
395     str += strlen (DLL_IMPORT_PREFIX);
396   else if (strncmp (str, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
397            == 0)
398     str += strlen (DLL_EXPORT_PREFIX);
399   if (*str == '*')
400     str += 1;
401   return str;
402 }
403
404 /* Also strip the fastcall prefix and stdcall suffix.  */
405
406 const char *
407 i386_pe_strip_name_encoding_full (const char *str)
408 {
409   const char *p;
410   const char *name = i386_pe_strip_name_encoding (str);
411
412   /* Strip leading '@' on fastcall symbols.  */
413   if (*name == '@')
414     name++;
415
416   /* Strip trailing "@n".  */
417   p = strchr (name, '@');
418   if (p)
419     return ggc_alloc_string (name, p - name);
420
421   return name;
422 }
423
424 /* Output a reference to a label. Fastcall symbols are prefixed with @,
425    whereas symbols for functions using other calling conventions don't
426    have a prefix (unless they are marked dllimport or dllexport).  */
427
428 void i386_pe_output_labelref (FILE *stream, const char *name)
429 {
430   if (strncmp (name, DLL_IMPORT_PREFIX, strlen (DLL_IMPORT_PREFIX))
431       == 0)
432     /* A dll import */
433     {
434       if (name[strlen (DLL_IMPORT_PREFIX)] == FASTCALL_PREFIX)
435       /* A dllimport fastcall symbol.  */
436         {
437           fprintf (stream, "__imp_%s",
438                    i386_pe_strip_name_encoding (name));
439         }
440       else
441       /* A dllimport non-fastcall symbol.  */
442         {
443           fprintf (stream, "__imp__%s",
444                    i386_pe_strip_name_encoding (name));
445         }
446     }
447   else if ((name[0] == FASTCALL_PREFIX)
448            || (strncmp (name, DLL_EXPORT_PREFIX, strlen (DLL_EXPORT_PREFIX))
449                == 0
450                && name[strlen (DLL_EXPORT_PREFIX)] == FASTCALL_PREFIX))
451     /* A fastcall symbol.  */
452     {
453       fprintf (stream, "%s",
454                i386_pe_strip_name_encoding (name));
455     }
456   else
457     /* Everything else.  */
458     {
459       fprintf (stream, "%s%s", USER_LABEL_PREFIX,
460                i386_pe_strip_name_encoding (name));
461     }
462 }
463
464 void
465 i386_pe_unique_section (tree decl, int reloc)
466 {
467   int len;
468   const char *name, *prefix;
469   char *string;
470
471   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
472   name = i386_pe_strip_name_encoding_full (name);
473
474   /* The object is put in, for example, section .text$foo.
475      The linker will then ultimately place them in .text
476      (everything from the $ on is stripped). Don't put
477      read-only data in .rdata section to avoid a PE linker
478      bug when .rdata$* grouped sections are used in code
479      without a .rdata section.  */
480   if (TREE_CODE (decl) == FUNCTION_DECL)
481     prefix = ".text$";
482   else if (decl_readonly_section (decl, reloc))
483     prefix = ".rdata$";
484   else
485     prefix = ".data$";
486   len = strlen (name) + strlen (prefix);
487   string = alloca (len + 1);
488   sprintf (string, "%s%s", prefix, name);
489
490   DECL_SECTION_NAME (decl) = build_string (len, string);
491 }
492
493 /* Select a set of attributes for section NAME based on the properties
494    of DECL and whether or not RELOC indicates that DECL's initializer
495    might contain runtime relocations.
496
497    We make the section read-only and executable for a function decl,
498    read-only for a const data decl, and writable for a non-const data decl.
499
500    If the section has already been defined, to not allow it to have
501    different attributes, as (1) this is ambiguous since we're not seeing
502    all the declarations up front and (2) some assemblers (e.g. SVR4)
503    do not recognize section redefinitions.  */
504 /* ??? This differs from the "standard" PE implementation in that we
505    handle the SHARED variable attribute.  Should this be done for all
506    PE targets?  */
507
508 #define SECTION_PE_SHARED       SECTION_MACH_DEP
509
510 unsigned int
511 i386_pe_section_type_flags (tree decl, const char *name, int reloc)
512 {
513   static htab_t htab;
514   unsigned int flags;
515   unsigned int **slot;
516
517   /* The names we put in the hashtable will always be the unique
518      versions given to us by the stringtable, so we can just use
519      their addresses as the keys.  */
520   if (!htab)
521     htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
522
523   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
524     flags = SECTION_CODE;
525   else if (decl && decl_readonly_section (decl, reloc))
526     flags = 0;
527   else
528     {
529       flags = SECTION_WRITE;
530
531       if (decl && TREE_CODE (decl) == VAR_DECL
532           && lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
533         flags |= SECTION_PE_SHARED;
534     }
535
536   if (decl && DECL_ONE_ONLY (decl))
537     flags |= SECTION_LINKONCE;
538
539   /* See if we already have an entry for this section.  */
540   slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
541   if (!*slot)
542     {
543       *slot = (unsigned int *) xmalloc (sizeof (unsigned int));
544       **slot = flags;
545     }
546   else
547     {
548       if (decl && **slot != flags)
549         error ("%q+D causes a section type conflict", decl);
550     }
551
552   return flags;
553 }
554
555 void
556 i386_pe_asm_named_section (const char *name, unsigned int flags, 
557                            tree decl)
558 {
559   char flagchars[8], *f = flagchars;
560
561   if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
562     /* readonly data */
563     {
564       *f++ ='d';  /* This is necessary for older versions of gas.  */
565       *f++ ='r';
566     }
567   else  
568     {
569       if (flags & SECTION_CODE)
570         *f++ = 'x';
571       if (flags & SECTION_WRITE)
572         *f++ = 'w';
573       if (flags & SECTION_PE_SHARED)
574         *f++ = 's';
575     }
576
577   *f = '\0';
578
579   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
580
581   if (flags & SECTION_LINKONCE)
582     {
583       /* Functions may have been compiled at various levels of
584          optimization so we can't use `same_size' here.
585          Instead, have the linker pick one, without warning.
586          If 'selectany' attribute has been specified,  MS compiler
587          sets 'discard' characteristic, rather than telling linker
588          to warn of size or content mismatch, so do the same.  */ 
589       bool discard = (flags & SECTION_CODE)
590                       || lookup_attribute ("selectany",
591                                            DECL_ATTRIBUTES (decl));      
592       fprintf (asm_out_file, "\t.linkonce %s\n",
593                (discard  ? "discard" : "same_size"));
594     }
595 }
596 \f
597 /* The Microsoft linker requires that every function be marked as
598    DT_FCN.  When using gas on cygwin, we must emit appropriate .type
599    directives.  */
600
601 #include "gsyms.h"
602
603 /* Mark a function appropriately.  This should only be called for
604    functions for which we are not emitting COFF debugging information.
605    FILE is the assembler output file, NAME is the name of the
606    function, and PUBLIC is nonzero if the function is globally
607    visible.  */
608
609 void
610 i386_pe_declare_function_type (FILE *file, const char *name, int public)
611 {
612   fprintf (file, "\t.def\t");
613   assemble_name (file, name);
614   fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
615            public ? (int) C_EXT : (int) C_STAT,
616            (int) DT_FCN << N_BTSHFT);
617 }
618
619 /* Keep a list of external functions.  */
620
621 struct extern_list GTY(())
622 {
623   struct extern_list *next;
624   tree decl;
625   const char *name;
626 };
627
628 static GTY(()) struct extern_list *extern_head;
629
630 /* Assemble an external function reference.  We need to keep a list of
631    these, so that we can output the function types at the end of the
632    assembly.  We can't output the types now, because we might see a
633    definition of the function later on and emit debugging information
634    for it then.  */
635
636 void
637 i386_pe_record_external_function (tree decl, const char *name)
638 {
639   struct extern_list *p;
640
641   p = (struct extern_list *) ggc_alloc (sizeof *p);
642   p->next = extern_head;
643   p->decl = decl;
644   p->name = name;
645   extern_head = p;
646 }
647
648 /* Keep a list of exported symbols.  */
649
650 struct export_list GTY(())
651 {
652   struct export_list *next;
653   const char *name;
654   int is_data;          /* used to type tag exported symbols.  */
655 };
656
657 static GTY(()) struct export_list *export_head;
658
659 /* Assemble an export symbol entry.  We need to keep a list of
660    these, so that we can output the export list at the end of the
661    assembly.  We used to output these export symbols in each function,
662    but that causes problems with GNU ld when the sections are
663    linkonce.  */
664
665 void
666 i386_pe_record_exported_symbol (const char *name, int is_data)
667 {
668   struct export_list *p;
669
670   p = (struct export_list *) ggc_alloc (sizeof *p);
671   p->next = export_head;
672   p->name = name;
673   p->is_data = is_data;
674   export_head = p;
675 }
676
677 /* This is called at the end of assembly.  For each external function
678    which has not been defined, we output a declaration now.  We also
679    output the .drectve section.  */
680
681 void
682 i386_pe_file_end (void)
683 {
684   struct extern_list *p;
685
686   ix86_file_end ();
687
688   for (p = extern_head; p != NULL; p = p->next)
689     {
690       tree decl;
691
692       decl = p->decl;
693
694       /* Positively ensure only one declaration for any given symbol.  */
695       if (! TREE_ASM_WRITTEN (decl)
696           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
697         {
698           TREE_ASM_WRITTEN (decl) = 1;
699           i386_pe_declare_function_type (asm_out_file, p->name,
700                                          TREE_PUBLIC (decl));
701         }
702     }
703
704   if (export_head)
705     {
706       struct export_list *q;
707       drectve_section ();
708       for (q = export_head; q != NULL; q = q->next)
709         {
710           fprintf (asm_out_file, "\t.ascii \" -export:%s%s\"\n",
711                    i386_pe_strip_name_encoding (q->name),
712                    (q->is_data) ? ",data" : "");
713         }
714     }
715 }
716
717 #include "gt-winnt.h"