OSDN Git Service

PR target/43888
[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,
4    2005, 2006, 2007, 2008, 2009, 2010 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 3, 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 COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "regs.h"
28 #include "hard-reg-set.h"
29 #include "output.h"
30 #include "tree.h"
31 #include "flags.h"
32 #include "tm_p.h"
33 #include "toplev.h"
34 #include "hashtab.h"
35 #include "langhooks.h"
36 #include "ggc.h"
37 #include "target.h"
38 #include "lto-streamer.h"
39
40 /* i386/PE specific attribute support.
41
42    i386/PE has two new attributes:
43    dllexport - for exporting a function/variable that will live in a dll
44    dllimport - for importing a function/variable from a dll
45
46    Microsoft allows multiple declspecs in one __declspec, separating
47    them with spaces.  We do NOT support this.  Instead, use __declspec
48    multiple times.
49 */
50
51 /* Handle a "shared" attribute;
52    arguments as in struct attribute_spec.handler.  */
53 tree
54 ix86_handle_shared_attribute (tree *node, tree name,
55                               tree args ATTRIBUTE_UNUSED,
56                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
57 {
58   if (TREE_CODE (*node) != VAR_DECL)
59     {
60       warning (OPT_Wattributes, "%qE attribute only applies to variables",
61                name);
62       *no_add_attrs = true;
63     }
64
65   return NULL_TREE;
66 }
67
68 /* Handle a "selectany" attribute;
69    arguments as in struct attribute_spec.handler.  */
70 tree
71 ix86_handle_selectany_attribute (tree *node, tree name,
72                                  tree args ATTRIBUTE_UNUSED,
73                                  int flags ATTRIBUTE_UNUSED,
74                                  bool *no_add_attrs)
75 {
76   /* The attribute applies only to objects that are initialized and have
77      external linkage.  However, we may not know about initialization
78      until the language frontend has processed the decl. We'll check for
79      initialization later in encode_section_info.  */
80   if (TREE_CODE (*node) != VAR_DECL || !TREE_PUBLIC (*node))
81     {   
82       error ("%qE attribute applies only to initialized variables"
83              " with external linkage", name);
84       *no_add_attrs = true;
85     }
86
87   return NULL_TREE;
88 }
89
90 \f
91 /* Return the type that we should use to determine if DECL is
92    imported or exported.  */
93
94 static tree
95 associated_type (tree decl)
96 {
97   return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
98           ?  DECL_CONTEXT (decl) : NULL_TREE);
99 }
100
101 /* Return true if DECL should be a dllexport'd object.  */
102
103 static bool
104 i386_pe_determine_dllexport_p (tree decl)
105 {
106   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
107     return false;
108
109   /* Don't export local clones of dllexports.  */
110   if (!TREE_PUBLIC (decl))
111     return false;
112
113   if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
114     return true;
115
116   return false;
117 }
118
119 /* Return true if DECL should be a dllimport'd object.  */
120
121 static bool
122 i386_pe_determine_dllimport_p (tree decl)
123 {
124   tree assoc;
125
126   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
127     return false;
128
129   if (DECL_DLLIMPORT_P (decl))
130     return true;
131
132   /* The DECL_DLLIMPORT_P flag was set for decls in the class definition
133      by  targetm.cxx.adjust_class_at_definition.  Check again to emit
134      error message if the class attribute has been overridden by an
135      out-of-class definition of static data.  */
136   assoc = associated_type (decl);
137   if (assoc && lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc))
138       && TREE_CODE (decl) == VAR_DECL
139       && TREE_STATIC (decl) && TREE_PUBLIC (decl)
140       && !DECL_EXTERNAL (decl)
141       /* vtable's are linkonce constants, so defining a vtable is not
142          an error as long as we don't try to import it too.  */
143       && !DECL_VIRTUAL_P (decl))
144         error ("definition of static data member %q+D of "
145                "dllimport'd class", decl);
146
147   return false;
148 }
149
150 /* Handle the -mno-fun-dllimport target switch.  */
151
152 bool
153 i386_pe_valid_dllimport_attribute_p (const_tree decl)
154 {
155    if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
156      return false;
157    return true;
158 }
159
160 /* Return string which is the function name, identified by ID, modified
161    with a suffix consisting of an atsign (@) followed by the number of
162    bytes of arguments.  If ID is NULL use the DECL_NAME as base. If
163    FASTCALL is true, also add the FASTCALL_PREFIX.
164    Return NULL if no change required.  */
165
166 static tree
167 gen_stdcall_or_fastcall_suffix (tree decl, tree id, bool fastcall)
168 {
169   HOST_WIDE_INT total = 0;
170   const char *old_str = IDENTIFIER_POINTER (id != NULL_TREE ? id : DECL_NAME (decl));
171   char *new_str, *p;
172   tree type = TREE_TYPE (decl);
173   tree arg;
174   function_args_iterator args_iter;
175
176   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);  
177
178   if (prototype_p (type))
179     {
180       /* This attribute is ignored for variadic functions.  */ 
181       if (stdarg_p (type))
182         return NULL_TREE;
183
184       /* Quit if we hit an incomplete type.  Error is reported
185          by convert_arguments in c-typeck.c or cp/typeck.c.  */
186       FOREACH_FUNCTION_ARGS(type, arg, args_iter)
187         {
188           HOST_WIDE_INT parm_size;
189           HOST_WIDE_INT parm_boundary_bytes = PARM_BOUNDARY / BITS_PER_UNIT;
190
191           if (! COMPLETE_TYPE_P (arg))
192             break;
193
194           parm_size = int_size_in_bytes (arg);
195           if (parm_size < 0)
196             break;
197
198           /* Must round up to include padding.  This is done the same
199              way as in store_one_arg.  */
200           parm_size = ((parm_size + parm_boundary_bytes - 1)
201                        / parm_boundary_bytes * parm_boundary_bytes);
202           total += parm_size;
203         }
204       }
205   /* Assume max of 8 base 10 digits in the suffix.  */
206   p = new_str = XALLOCAVEC (char, 1 + strlen (old_str) + 1 + 8 + 1);
207   if (fastcall)
208     *p++ = FASTCALL_PREFIX;
209   sprintf (p, "%s@" HOST_WIDE_INT_PRINT_DEC, old_str, total);
210
211   return get_identifier (new_str);
212 }
213
214 /* Maybe decorate and get a new identifier for the DECL of a stdcall or
215    fastcall function. The original identifier is supplied in ID. */
216
217 static tree
218 i386_pe_maybe_mangle_decl_assembler_name (tree decl, tree id)
219 {
220   tree new_id = NULL_TREE;
221
222   if (TREE_CODE (decl) == FUNCTION_DECL)
223     { 
224       tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
225       if (lookup_attribute ("stdcall", type_attributes))
226         new_id = gen_stdcall_or_fastcall_suffix (decl, id, false);
227       else if (lookup_attribute ("fastcall", type_attributes))
228         new_id = gen_stdcall_or_fastcall_suffix (decl, id, true);
229     }
230
231   return new_id;
232 }
233
234 /* This is used as a target hook to modify the DECL_ASSEMBLER_NAME
235    in the language-independent default hook
236    langhooks,c:lhd_set_decl_assembler_name ()
237    and in cp/mangle,c:mangle_decl ().  */
238 tree
239 i386_pe_mangle_decl_assembler_name (tree decl, tree id)
240 {
241   tree new_id = i386_pe_maybe_mangle_decl_assembler_name (decl, id);   
242
243   return (new_id ? new_id : id);
244 }
245
246 void
247 i386_pe_encode_section_info (tree decl, rtx rtl, int first)
248 {
249   rtx symbol;
250   int flags;
251
252   /* Do this last, due to our frobbing of DECL_DLLIMPORT_P above.  */
253   default_encode_section_info (decl, rtl, first);
254
255   /* Careful not to prod global register variables.  */
256   if (!MEM_P (rtl))
257     return;
258
259   symbol = XEXP (rtl, 0);
260   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
261
262   switch (TREE_CODE (decl))
263     {
264     case FUNCTION_DECL:
265       /* FIXME:  Imported stdcall names are not modified by the Ada frontend.
266          Check and decorate the RTL name now.  */
267       if  (strcmp (lang_hooks.name, "GNU Ada") == 0)
268         {
269           tree new_id;
270           tree old_id = DECL_ASSEMBLER_NAME (decl);
271           const char* asm_str = IDENTIFIER_POINTER (old_id);
272           /* Do not change the identifier if a verbatim asmspec
273              or if stdcall suffix already added. */
274           if (!(*asm_str == '*' || strchr (asm_str, '@'))
275               && (new_id = i386_pe_maybe_mangle_decl_assembler_name (decl,
276                                                                      old_id)))
277             XSTR (symbol, 0) = IDENTIFIER_POINTER (new_id);
278         }
279       break;
280
281     case VAR_DECL:
282       if (lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
283         {
284           if (DECL_INITIAL (decl)
285               /* If an object is initialized with a ctor, the static
286                  initialization and destruction code for it is present in
287                  each unit defining the object.  The code that calls the
288                  ctor is protected by a link-once guard variable, so that
289                  the object still has link-once semantics,  */
290               || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
291             make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
292           else
293             error ("%q+D:'selectany' attribute applies only to "
294                    "initialized objects", decl);
295         }
296       break;
297
298     default:
299       return;
300     }
301
302   /* Mark the decl so we can tell from the rtl whether the object is
303      dllexport'd or dllimport'd.  tree.c: merge_dllimport_decl_attributes
304      handles dllexport/dllimport override semantics.  */
305   flags = (SYMBOL_REF_FLAGS (symbol) &
306            ~(SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT));
307   if (i386_pe_determine_dllexport_p (decl))
308     flags |= SYMBOL_FLAG_DLLEXPORT;
309   else if (i386_pe_determine_dllimport_p (decl))
310     flags |= SYMBOL_FLAG_DLLIMPORT;
311  
312   SYMBOL_REF_FLAGS (symbol) = flags;
313 }
314
315 bool
316 i386_pe_binds_local_p (const_tree exp)
317 {
318   /* PE does not do dynamic binding.  Indeed, the only kind of
319      non-local reference comes from a dllimport'd symbol.  */
320   if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
321       && DECL_DLLIMPORT_P (exp))
322     return false;
323
324   /* Or a weak one, now that they are supported.  */
325   if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
326       && DECL_WEAK (exp))
327     /* But x64 gets confused and attempts to use unsupported GOTPCREL
328        relocations if we tell it the truth, so we still return true in
329        that case until the deeper problem can be fixed.  */
330     return (TARGET_64BIT && DEFAULT_ABI == MS_ABI);
331
332   return true;
333 }
334
335 /* Also strip the fastcall prefix and stdcall suffix.  */
336
337 const char *
338 i386_pe_strip_name_encoding_full (const char *str)
339 {
340   const char *p;
341   const char *name = default_strip_name_encoding (str);
342
343   /* Strip leading '@' on fastcall symbols.  */
344   if (*name == '@')
345     name++;
346
347   /* Strip trailing "@n".  */
348   p = strchr (name, '@');
349   if (p)
350     return ggc_alloc_string (name, p - name);
351
352   return name;
353 }
354
355 void
356 i386_pe_unique_section (tree decl, int reloc)
357 {
358   int len;
359   const char *name, *prefix;
360   char *string;
361
362   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
363   name = i386_pe_strip_name_encoding_full (name);
364
365   /* The object is put in, for example, section .text$foo.
366      The linker will then ultimately place them in .text
367      (everything from the $ on is stripped). Don't put
368      read-only data in .rdata section to avoid a PE linker
369      bug when .rdata$* grouped sections are used in code
370      without a .rdata section.  */
371   if (TREE_CODE (decl) == FUNCTION_DECL)
372     prefix = ".text$";
373   else if (decl_readonly_section (decl, reloc))
374     prefix = ".rdata$";
375   else
376     prefix = ".data$";
377   len = strlen (name) + strlen (prefix);
378   string = XALLOCAVEC (char, len + 1);
379   sprintf (string, "%s%s", prefix, name);
380
381   DECL_SECTION_NAME (decl) = build_string (len, string);
382 }
383
384 /* Select a set of attributes for section NAME based on the properties
385    of DECL and whether or not RELOC indicates that DECL's initializer
386    might contain runtime relocations.
387
388    We make the section read-only and executable for a function decl,
389    read-only for a const data decl, and writable for a non-const data decl.
390
391    If the section has already been defined, to not allow it to have
392    different attributes, as (1) this is ambiguous since we're not seeing
393    all the declarations up front and (2) some assemblers (e.g. SVR4)
394    do not recognize section redefinitions.  */
395 /* ??? This differs from the "standard" PE implementation in that we
396    handle the SHARED variable attribute.  Should this be done for all
397    PE targets?  */
398
399 #define SECTION_PE_SHARED       SECTION_MACH_DEP
400
401 unsigned int
402 i386_pe_section_type_flags (tree decl, const char *name, int reloc)
403 {
404   static htab_t htab;
405   unsigned int flags;
406   unsigned int **slot;
407
408   /* The names we put in the hashtable will always be the unique
409      versions given to us by the stringtable, so we can just use
410      their addresses as the keys.  */
411   if (!htab)
412     htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
413
414   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
415     flags = SECTION_CODE;
416   else if (decl && decl_readonly_section (decl, reloc))
417     flags = 0;
418   else if (current_function_decl
419            && cfun
420            && crtl->subsections.unlikely_text_section_name
421            && strcmp (name, crtl->subsections.unlikely_text_section_name) == 0)
422     flags = SECTION_CODE;
423   else if (!decl
424            && (!current_function_decl || !cfun)
425            && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
426     flags = SECTION_CODE;
427   else
428     {
429       flags = SECTION_WRITE;
430
431       if (decl && TREE_CODE (decl) == VAR_DECL
432           && lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
433         flags |= SECTION_PE_SHARED;
434     }
435
436   if (decl && DECL_ONE_ONLY (decl))
437     flags |= SECTION_LINKONCE;
438
439   /* See if we already have an entry for this section.  */
440   slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
441   if (!*slot)
442     {
443       *slot = (unsigned int *) xmalloc (sizeof (unsigned int));
444       **slot = flags;
445     }
446   else
447     {
448       if (decl && **slot != flags)
449         error ("%q+D causes a section type conflict", decl);
450     }
451
452   return flags;
453 }
454
455 void
456 i386_pe_asm_named_section (const char *name, unsigned int flags, 
457                            tree decl)
458 {
459   char flagchars[8], *f = flagchars;
460
461   if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
462     /* readonly data */
463     {
464       *f++ ='d';  /* This is necessary for older versions of gas.  */
465       *f++ ='r';
466     }
467   else  
468     {
469       if (flags & SECTION_CODE)
470         *f++ = 'x';
471       if (flags & SECTION_WRITE)
472         *f++ = 'w';
473       if (flags & SECTION_PE_SHARED)
474         *f++ = 's';
475     }
476
477   /* LTO sections need 1-byte alignment to avoid confusing the
478      zlib decompression algorithm with trailing zero pad bytes.  */
479   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
480                         strlen (LTO_SECTION_NAME_PREFIX)) == 0)
481     *f++ = '0';
482
483   *f = '\0';
484
485   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
486
487   if (flags & SECTION_LINKONCE)
488     {
489       /* Functions may have been compiled at various levels of
490          optimization so we can't use `same_size' here.
491          Instead, have the linker pick one, without warning.
492          If 'selectany' attribute has been specified,  MS compiler
493          sets 'discard' characteristic, rather than telling linker
494          to warn of size or content mismatch, so do the same.  */ 
495       bool discard = (flags & SECTION_CODE)
496                       || lookup_attribute ("selectany",
497                                            DECL_ATTRIBUTES (decl));      
498       fprintf (asm_out_file, "\t.linkonce %s\n",
499                (discard  ? "discard" : "same_size"));
500     }
501 }
502
503 /* Beware, DECL may be NULL if compile_file() is emitting the LTO marker.  */
504
505 void
506 i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl,
507                                         const char *name, HOST_WIDE_INT size,
508                                         HOST_WIDE_INT align ATTRIBUTE_UNUSED)
509 {
510   HOST_WIDE_INT rounded;
511
512   /* Compute as in assemble_noswitch_variable, since we don't have
513      support for aligned common on older binutils.  We must also
514      avoid emitting a common symbol of size zero, as this is the
515      overloaded representation that indicates an undefined external
516      symbol in the PE object file format.  */
517   rounded = size ? size : 1;
518   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
519   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
520              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
521   
522   i386_pe_maybe_record_exported_symbol (decl, name, 1);
523
524   fprintf (stream, "\t.comm\t");
525   assemble_name (stream, name);
526   if (use_pe_aligned_common)
527     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC ", %d\n",
528            size ? size : (HOST_WIDE_INT) 1,
529            exact_log2 (align) - exact_log2 (CHAR_BIT));
530   else
531     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC "\t" ASM_COMMENT_START
532            " " HOST_WIDE_INT_PRINT_DEC "\n", rounded, size);
533 }
534 \f
535 /* The Microsoft linker requires that every function be marked as
536    DT_FCN.  When using gas on cygwin, we must emit appropriate .type
537    directives.  */
538
539 #include "gsyms.h"
540
541 /* Mark a function appropriately.  This should only be called for
542    functions for which we are not emitting COFF debugging information.
543    FILE is the assembler output file, NAME is the name of the
544    function, and PUB is nonzero if the function is globally
545    visible.  */
546
547 void
548 i386_pe_declare_function_type (FILE *file, const char *name, int pub)
549 {
550   fprintf (file, "\t.def\t");
551   assemble_name (file, name);
552   fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
553            pub ? (int) C_EXT : (int) C_STAT,
554            (int) DT_FCN << N_BTSHFT);
555 }
556
557 /* Keep a list of external functions.  */
558
559 struct GTY(()) extern_list
560 {
561   struct extern_list *next;
562   tree decl;
563   const char *name;
564 };
565
566 static GTY(()) struct extern_list *extern_head;
567
568 /* Assemble an external function reference.  We need to keep a list of
569    these, so that we can output the function types at the end of the
570    assembly.  We can't output the types now, because we might see a
571    definition of the function later on and emit debugging information
572    for it then.  */
573
574 void
575 i386_pe_record_external_function (tree decl, const char *name)
576 {
577   struct extern_list *p;
578
579   p = (struct extern_list *) ggc_alloc (sizeof *p);
580   p->next = extern_head;
581   p->decl = decl;
582   p->name = name;
583   extern_head = p;
584 }
585
586 /* Keep a list of exported symbols.  */
587
588 struct GTY(()) export_list
589 {
590   struct export_list *next;
591   const char *name;
592   int is_data;          /* used to type tag exported symbols.  */
593 };
594
595 static GTY(()) struct export_list *export_head;
596
597 /* Assemble an export symbol entry.  We need to keep a list of
598    these, so that we can output the export list at the end of the
599    assembly.  We used to output these export symbols in each function,
600    but that causes problems with GNU ld when the sections are
601    linkonce.  Beware, DECL may be NULL if compile_file() is emitting
602    the LTO marker.  */
603
604 void
605 i386_pe_maybe_record_exported_symbol (tree decl, const char *name, int is_data)
606 {
607   rtx symbol;
608   struct export_list *p;
609
610   if (!decl)
611     return;
612
613   symbol = XEXP (DECL_RTL (decl), 0);
614   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
615   if (!SYMBOL_REF_DLLEXPORT_P (symbol))
616     return;
617
618   gcc_assert (TREE_PUBLIC (decl));
619
620   p = (struct export_list *) ggc_alloc (sizeof *p);
621   p->next = export_head;
622   p->name = name;
623   p->is_data = is_data;
624   export_head = p;
625 }
626
627 #ifdef CXX_WRAP_SPEC_LIST
628
629 /*  Hash table equality helper function.  */
630
631 static int
632 wrapper_strcmp (const void *x, const void *y)
633 {
634   return !strcmp ((const char *) x, (const char *) y);
635 }
636
637 /* Search for a function named TARGET in the list of library wrappers
638    we are using, returning a pointer to it if found or NULL if not.
639    This function might be called on quite a few symbols, and we only
640    have the list of names of wrapped functions available to us as a
641    spec string, so first time round we lazily initialise a hash table
642    to make things quicker.  */
643
644 static const char *
645 i386_find_on_wrapper_list (const char *target)
646 {
647   static char first_time = 1;
648   static htab_t wrappers;
649
650   if (first_time)
651     {
652       /* Beware that this is not a complicated parser, it assumes
653          that any sequence of non-whitespace beginning with an
654          underscore is one of the wrapped symbols.  For now that's
655          adequate to distinguish symbols from spec substitutions
656          and command-line options.  */
657       static char wrapper_list_buffer[] = CXX_WRAP_SPEC_LIST;
658       char *bufptr;
659       /* Breaks up the char array into separated strings
660          strings and enter them into the hash table.  */
661       wrappers = htab_create_alloc (8, htab_hash_string, wrapper_strcmp,
662         0, xcalloc, free);
663       for (bufptr = wrapper_list_buffer; *bufptr; ++bufptr)
664         {
665           char *found = NULL;
666           if (ISSPACE (*bufptr))
667             continue;
668           if (*bufptr == '_')
669             found = bufptr;
670           while (*bufptr && !ISSPACE (*bufptr))
671             ++bufptr;
672           if (*bufptr)
673             *bufptr = 0;
674           if (found)
675             *htab_find_slot (wrappers, found, INSERT) = found;
676         }
677       first_time = 0;
678     }
679
680   return (const char *) htab_find (wrappers, target);
681 }
682
683 #endif /* CXX_WRAP_SPEC_LIST */
684
685 /* This is called at the end of assembly.  For each external function
686    which has not been defined, we output a declaration now.  We also
687    output the .drectve section.  */
688
689 void
690 i386_pe_file_end (void)
691 {
692   struct extern_list *p;
693
694   for (p = extern_head; p != NULL; p = p->next)
695     {
696       tree decl;
697
698       decl = p->decl;
699
700       /* Positively ensure only one declaration for any given symbol.  */
701       if (! TREE_ASM_WRITTEN (decl)
702           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
703         {
704 #ifdef CXX_WRAP_SPEC_LIST
705           /* To ensure the DLL that provides the corresponding real
706              functions is still loaded at runtime, we must reference
707              the real function so that an (unused) import is created.  */
708           const char *realsym = i386_find_on_wrapper_list (p->name);
709           if (realsym)
710             i386_pe_declare_function_type (asm_out_file,
711                 concat ("__real_", realsym, NULL), TREE_PUBLIC (decl));
712 #endif /* CXX_WRAP_SPEC_LIST */
713           TREE_ASM_WRITTEN (decl) = 1;
714           i386_pe_declare_function_type (asm_out_file, p->name,
715                                          TREE_PUBLIC (decl));
716         }
717     }
718
719   if (export_head)
720     {
721       struct export_list *q;
722       drectve_section ();
723       for (q = export_head; q != NULL; q = q->next)
724         {
725           fprintf (asm_out_file, "\t.ascii \" -export:%s%s\"\n",
726                    default_strip_name_encoding (q->name),
727                    (q->is_data ? ",data" : ""));
728         }
729     }
730 }
731
732 #include "gt-winnt.h"