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
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "rtl.h"
  26 #include "regs.h"
  27 #include "hard-reg-set.h"
  28 #include "output.h"
  29 #include "tree.h"
  30 #include "flags.h"
  31 #include "tm_p.h"
  32 #include "toplev.h"
  33 #include "hashtab.h"
  34
  35 /* i386/PE specific attribute support.
  36
  37    i386/PE has two new attributes:
  38    dllexport - for exporting a function/variable that will live in a dll
  39    dllimport - for importing a function/variable from a dll
  40
  41    Microsoft allows multiple declspecs in one __declspec, separating
  42    them with spaces.  We do NOT support this.  Instead, use __declspec
  43    multiple times.
  44 */
  45
  46 static tree associated_type PARAMS ((tree));
  47 const char * gen_stdcall_suffix PARAMS ((tree));
  48 int i386_pe_dllexport_p PARAMS ((tree));
  49 int i386_pe_dllimport_p PARAMS ((tree));
  50 void i386_pe_mark_dllexport PARAMS ((tree));
  51 void i386_pe_mark_dllimport PARAMS ((tree));
  52
  53 /* Handle a "dllimport" or "dllexport" attribute;
  54    arguments as in struct attribute_spec.handler.  */
  55 tree
  56 ix86_handle_dll_attribute (node, name, args, flags, no_add_attrs)
  57      tree *node;
  58      tree name;
  59      tree args;
  60      int flags;
  61      bool *no_add_attrs;
  62 {
  63   /* These attributes may apply to structure and union types being created,
  64      but otherwise should pass to the declaration involved.  */
  65   if (!DECL_P (*node))
  66     {
  67       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
  68                    | (int) ATTR_FLAG_ARRAY_NEXT))
  69         {
  70           *no_add_attrs = true;
  71           return tree_cons (name, args, NULL_TREE);
  72         }
  73       if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
  74         {
  75           warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
  76           *no_add_attrs = true;
  77         }
  78     }
  79
  80   return NULL_TREE;
  81 }
  82
  83 /* Handle a "shared" attribute;
  84    arguments as in struct attribute_spec.handler.  */
  85 tree
  86 ix86_handle_shared_attribute (node, name, args, flags, no_add_attrs)
  87      tree *node;
  88      tree name;
  89      tree args ATTRIBUTE_UNUSED;
  90      int flags ATTRIBUTE_UNUSED;
  91      bool *no_add_attrs;
  92 {
  93   if (TREE_CODE (*node) != VAR_DECL)
  94     {
  95       warning ("`%s' attribute only applies to variables",
  96                IDENTIFIER_POINTER (name));
  97       *no_add_attrs = true;
  98     }
  99
 100   return NULL_TREE;
 101 }
 102 \f
 103 /* Return the type that we should use to determine if DECL is
 104    imported or exported.  */
 105
 106 static tree
 107 associated_type (decl)
 108      tree decl;
 109 {
 110   tree t = NULL_TREE;
 111
 112   /* In the C++ frontend, DECL_CONTEXT for a method doesn't actually refer
 113      to the containing class.  So we look at the 'this' arg.  */
 114   if (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
 115     {
 116       /* Artificial methods are not affected by the import/export status of
 117          their class unless they are virtual.  */
 118       if (! DECL_ARTIFICIAL (decl) || DECL_VINDEX (decl))
 119         t = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))));
 120     }
 121   else if (DECL_CONTEXT (decl)
 122            && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
 123     t = DECL_CONTEXT (decl);
 124
 125   return t;
 126 }
 127
 128 /* Return non-zero if DECL is a dllexport'd object.  */
 129
 130 int
 131 i386_pe_dllexport_p (decl)
 132      tree decl;
 133 {
 134   tree exp;
 135
 136   if (TREE_CODE (decl) != VAR_DECL
 137       && TREE_CODE (decl) != FUNCTION_DECL)
 138     return 0;
 139   exp = lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl));
 140   if (exp)
 141     return 1;
 142
 143   /* Class members get the dllexport status of their class.  */
 144   if (associated_type (decl))
 145     {
 146       exp = lookup_attribute ("dllexport",
 147                               TYPE_ATTRIBUTES (associated_type (decl)));
 148       if (exp)
 149         return 1;
 150     }
 151
 152   return 0;
 153 }
 154
 155 /* Return non-zero if DECL is a dllimport'd object.  */
 156
 157 int
 158 i386_pe_dllimport_p (decl)
 159      tree decl;
 160 {
 161   tree imp;
 162
 163   if (TREE_CODE (decl) == FUNCTION_DECL
 164       && TARGET_NOP_FUN_DLLIMPORT)
 165     return 0;
 166
 167   if (TREE_CODE (decl) != VAR_DECL
 168       && TREE_CODE (decl) != FUNCTION_DECL)
 169     return 0;
 170   imp = lookup_attribute ("dllimport", DECL_ATTRIBUTES (decl));
 171   if (imp)
 172     return 1;
 173
 174   /* Class members get the dllimport status of their class.  */
 175   if (associated_type (decl))
 176     {
 177       imp = lookup_attribute ("dllimport",
 178                               TYPE_ATTRIBUTES (associated_type (decl)));
 179       if (imp)
 180         return 1;
 181     }
 182
 183   return 0;
 184 }
 185
 186 /* Return non-zero if SYMBOL is marked as being dllexport'd.  */
 187
 188 int
 189 i386_pe_dllexport_name_p (symbol)
 190      const char *symbol;
 191 {
 192   return symbol[0] == '@' && symbol[1] == 'e' && symbol[2] == '.';
 193 }
 194
 195 /* Return non-zero if SYMBOL is marked as being dllimport'd.  */
 196
 197 int
 198 i386_pe_dllimport_name_p (symbol)
 199      const char *symbol;
 200 {
 201   return symbol[0] == '@' && symbol[1] == 'i' && symbol[2] == '.';
 202 }
 203
 204 /* Mark a DECL as being dllexport'd.
 205    Note that we override the previous setting (eg: dllimport).  */
 206
 207 void
 208 i386_pe_mark_dllexport (decl)
 209      tree decl;
 210 {
 211   const char *oldname;
 212   char  *newname;
 213   rtx rtlname;
 214   tree idp;
 215
 216   rtlname = XEXP (DECL_RTL (decl), 0);
 217   if (GET_CODE (rtlname) == SYMBOL_REF)
 218     oldname = XSTR (rtlname, 0);
 219   else if (GET_CODE (rtlname) == MEM
 220            && GET_CODE (XEXP (rtlname, 0)) == SYMBOL_REF)
 221     oldname = XSTR (XEXP (rtlname, 0), 0);
 222   else
 223     abort ();
 224   if (i386_pe_dllimport_name_p (oldname))
 225     oldname += 9;
 226   else if (i386_pe_dllexport_name_p (oldname))
 227     return; /* already done */
 228
 229   newname = alloca (strlen (oldname) + 4);
 230   sprintf (newname, "@e.%s", oldname);
 231
 232   /* We pass newname through get_identifier to ensure it has a unique
 233      address.  RTL processing can sometimes peek inside the symbol ref
 234      and compare the string's addresses to see if two symbols are
 235      identical.  */
 236   idp = get_identifier (newname);
 237
 238   XEXP (DECL_RTL (decl), 0) =
 239     gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (idp));
 240 }
 241
 242 /* Mark a DECL as being dllimport'd.  */
 243
 244 void
 245 i386_pe_mark_dllimport (decl)
 246      tree decl;
 247 {
 248   const char *oldname;
 249   char  *newname;
 250   tree idp;
 251   rtx rtlname, newrtl;
 252
 253   rtlname = XEXP (DECL_RTL (decl), 0);
 254   if (GET_CODE (rtlname) == SYMBOL_REF)
 255     oldname = XSTR (rtlname, 0);
 256   else if (GET_CODE (rtlname) == MEM
 257            && GET_CODE (XEXP (rtlname, 0)) == SYMBOL_REF)
 258     oldname = XSTR (XEXP (rtlname, 0), 0);
 259   else
 260     abort ();
 261   if (i386_pe_dllexport_name_p (oldname))
 262     {
 263       error ("`%s' declared as both exported to and imported from a DLL",
 264              IDENTIFIER_POINTER (DECL_NAME (decl)));
 265       return;
 266     }
 267   else if (i386_pe_dllimport_name_p (oldname))
 268     {
 269       /* Already done, but force correct linkage since the redeclaration
 270          might have omitted explicit extern.  Sigh.  */
 271       if (TREE_CODE (decl) == VAR_DECL
 272           /* ??? Is this test for vtables needed?  */
 273           && !DECL_VIRTUAL_P (decl))
 274         {
 275           DECL_EXTERNAL (decl) = 1;
 276           TREE_PUBLIC (decl) = 1;
 277         }
 278       return;
 279     }
 280
 281   /* ??? One can well ask why we're making these checks here,
 282      and that would be a good question.  */
 283
 284   /* Imported variables can't be initialized. Note that C++ classes
 285      are marked initial, so we need to check.  */
 286   if (TREE_CODE (decl) == VAR_DECL
 287       && !DECL_VIRTUAL_P (decl)
 288       && (DECL_INITIAL (decl)
 289           && ! TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
 290     {
 291       error_with_decl (decl, "initialized variable `%s' is marked dllimport");
 292       return;
 293     }
 294   /* Nor can they be static.  */
 295   if (TREE_CODE (decl) == VAR_DECL
 296       /* ??? Is this test for vtables needed?  */
 297       && !DECL_VIRTUAL_P (decl)
 298       && 0 /*???*/)
 299     {
 300       error_with_decl (decl, "static variable `%s' is marked dllimport");
 301       return;
 302     }
 303
 304   /* `extern' needn't be specified with dllimport.
 305      Specify `extern' now and hope for the best.  Sigh.  */
 306   if (TREE_CODE (decl) == VAR_DECL
 307       /* ??? Is this test for vtables needed?  */
 308       && !DECL_VIRTUAL_P (decl))
 309     {
 310       DECL_EXTERNAL (decl) = 1;
 311       TREE_PUBLIC (decl) = 1;
 312     }
 313
 314   newname = alloca (strlen (oldname) + 11);
 315   sprintf (newname, "@i._imp__%s", oldname);
 316
 317   /* We pass newname through get_identifier to ensure it has a unique
 318      address.  RTL processing can sometimes peek inside the symbol ref
 319      and compare the string's addresses to see if two symbols are
 320      identical.  */
 321   idp = get_identifier (newname);
 322
 323   newrtl = gen_rtx (MEM, Pmode,
 324                     gen_rtx (SYMBOL_REF, Pmode,
 325                              IDENTIFIER_POINTER (idp)));
 326   XEXP (DECL_RTL (decl), 0) = newrtl;
 327
 328   /* Can't treat a pointer to this as a constant address */
 329   DECL_NON_ADDR_CONST_P (decl) = 1;
 330 }
 331
 332 /* Return string which is the former assembler name modified with a
 333    suffix consisting of an atsign (@) followed by the number of bytes of
 334    arguments */
 335
 336 const char *
 337 gen_stdcall_suffix (decl)
 338   tree decl;
 339 {
 340   int total = 0;
 341   /* ??? This probably should use XSTR (XEXP (DECL_RTL (decl), 0), 0) instead
 342      of DECL_ASSEMBLER_NAME.  */
 343   const char *asmname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 344   char *newsym;
 345
 346   if (TYPE_ARG_TYPES (TREE_TYPE (decl)))
 347     if (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (decl))))
 348         == void_type_node)
 349       {
 350         tree formal_type = TYPE_ARG_TYPES (TREE_TYPE (decl));
 351
 352         while (TREE_VALUE (formal_type) != void_type_node)
 353           {
 354             int parm_size
 355               = TREE_INT_CST_LOW (TYPE_SIZE (TREE_VALUE (formal_type)));
 356             /* Must round up to include padding.  This is done the same
 357                way as in store_one_arg.  */
 358             parm_size = ((parm_size + PARM_BOUNDARY - 1)
 359                          / PARM_BOUNDARY * PARM_BOUNDARY);
 360             total += parm_size;
 361             formal_type = TREE_CHAIN (formal_type);
 362           }
 363       }
 364
 365   newsym = xmalloc (strlen (asmname) + 10);
 366   sprintf (newsym, "%s@%d", asmname, total/BITS_PER_UNIT);
 367   return IDENTIFIER_POINTER (get_identifier (newsym));
 368 }
 369
 370 void
 371 i386_pe_encode_section_info (decl, first)
 372      tree decl;
 373      int first;
 374 {
 375   if (!first)
 376     return;
 377
 378   /* This bit is copied from i386.h.  */
 379   if (optimize > 0 && TREE_CONSTANT (decl)
 380       && (!flag_writable_strings || TREE_CODE (decl) != STRING_CST))
 381     {
 382       rtx rtl = (TREE_CODE_CLASS (TREE_CODE (decl)) != 'd'
 383                  ? TREE_CST_RTL (decl) : DECL_RTL (decl));
 384       SYMBOL_REF_FLAG (XEXP (rtl, 0)) = 1;
 385     }
 386
 387   if (TREE_CODE (decl) == FUNCTION_DECL)
 388     if (lookup_attribute ("stdcall",
 389                           TYPE_ATTRIBUTES (TREE_TYPE (decl))))
 390       XEXP (DECL_RTL (decl), 0) =
 391         gen_rtx (SYMBOL_REF, Pmode, gen_stdcall_suffix (decl));
 392
 393   /* Mark the decl so we can tell from the rtl whether the object is
 394      dllexport'd or dllimport'd.  */
 395
 396   if (i386_pe_dllexport_p (decl))
 397     i386_pe_mark_dllexport (decl);
 398   else if (i386_pe_dllimport_p (decl))
 399     i386_pe_mark_dllimport (decl);
 400   /* It might be that DECL has already been marked as dllimport, but a
 401      subsequent definition nullified that.  The attribute is gone but
 402      DECL_RTL still has @i._imp__foo.  We need to remove that. Ditto
 403      for the DECL_NON_ADDR_CONST_P flag.  */
 404   else if ((TREE_CODE (decl) == FUNCTION_DECL
 405             || TREE_CODE (decl) == VAR_DECL)
 406            && DECL_RTL (decl) != NULL_RTX
 407            && GET_CODE (DECL_RTL (decl)) == MEM
 408            && GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
 409            && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == SYMBOL_REF
 410            && i386_pe_dllimport_name_p (XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0)))
 411     {
 412       const char *oldname = XSTR (XEXP (XEXP (DECL_RTL (decl), 0), 0), 0);
 413       tree idp = get_identifier (oldname + 9);
 414       rtx newrtl = gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (idp));
 415
 416       XEXP (DECL_RTL (decl), 0) = newrtl;
 417
 418       DECL_NON_ADDR_CONST_P (decl) = 0;
 419
 420       /* We previously set TREE_PUBLIC and DECL_EXTERNAL.
 421          We leave these alone for now.  */
 422     }
 423 }
 424
 425 void
 426 i386_pe_unique_section (decl, reloc)
 427      tree decl;
 428      int reloc;
 429 {
 430   int len;
 431   const char *name, *prefix;
 432   char *string;
 433
 434   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 435   /* Strip off any encoding in fnname.  */
 436   STRIP_NAME_ENCODING (name, name);
 437
 438   /* The object is put in, for example, section .text$foo.
 439      The linker will then ultimately place them in .text
 440      (everything from the $ on is stripped). Don't put
 441      read-only data in .rdata section to avoid a PE linker
 442      bug when .rdata$* grouped sections are used in code
 443      without a .rdata section.  */
 444   if (TREE_CODE (decl) == FUNCTION_DECL)
 445     prefix = ".text$";
 446   else if (DECL_READONLY_SECTION (decl, reloc))
 447     prefix = ".rdata$";
 448   else
 449     prefix = ".data$";
 450   len = strlen (name) + strlen (prefix);
 451   string = alloca (len + 1);
 452   sprintf (string, "%s%s", prefix, name);
 453
 454   DECL_SECTION_NAME (decl) = build_string (len, string);
 455 }
 456
 457 /* Select a set of attributes for section NAME based on the properties
 458    of DECL and whether or not RELOC indicates that DECL's initializer
 459    might contain runtime relocations.
 460
 461    We make the section read-only and executable for a function decl,
 462    read-only for a const data decl, and writable for a non-const data decl.
 463
 464    If the section has already been defined, to not allow it to have
 465    different attributes, as (1) this is ambiguous since we're not seeing
 466    all the declarations up front and (2) some assemblers (e.g. SVR4)
 467    do not recoginize section redefinitions.  */
 468 /* ??? This differs from the "standard" PE implementation in that we
 469    handle the SHARED variable attribute.  Should this be done for all
 470    PE targets?  */
 471
 472 #define SECTION_PE_SHARED       SECTION_MACH_DEP
 473
 474 unsigned int
 475 i386_pe_section_type_flags (decl, name, reloc)
 476      tree decl;
 477      const char *name;
 478      int reloc;
 479 {
 480   static htab_t htab;
 481   unsigned int flags;
 482   unsigned int **slot;
 483
 484   /* The names we put in the hashtable will always be the unique
 485      versions gived to us by the stringtable, so we can just use
 486      their addresses as the keys.  */
 487   if (!htab)
 488     htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
 489
 490   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
 491     flags = SECTION_CODE;
 492   else if (decl && DECL_READONLY_SECTION (decl, reloc))
 493     flags = 0;
 494   else
 495     {
 496       flags = SECTION_WRITE;
 497
 498       if (decl && TREE_CODE (decl) == VAR_DECL
 499           && lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
 500         flags |= SECTION_PE_SHARED;
 501     }
 502
 503   if (decl && DECL_ONE_ONLY (decl))
 504     flags |= SECTION_LINKONCE;
 505
 506   /* See if we already have an entry for this section.  */
 507   slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
 508   if (!*slot)
 509     {
 510       *slot = (unsigned int *) xmalloc (sizeof (unsigned int));
 511       **slot = flags;
 512     }
 513   else
 514     {
 515       if (decl && **slot != flags)
 516         error_with_decl (decl, "%s causes a section type conflict");
 517     }
 518
 519   return flags;
 520 }
 521
 522 void
 523 i386_pe_asm_named_section (name, flags)
 524      const char *name;
 525      unsigned int flags;
 526 {
 527   char flagchars[8], *f = flagchars;
 528
 529   if (flags & SECTION_CODE)
 530     *f++ = 'x';
 531   if (flags & SECTION_WRITE)
 532     *f++ = 'w';
 533   if (flags & SECTION_PE_SHARED)
 534     *f++ = 's';
 535   *f = '\0';
 536
 537   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
 538
 539   if (flags & SECTION_LINKONCE)
 540     {
 541       /* Functions may have been compiled at various levels of
 542          optimization so we can't use `same_size' here.
 543          Instead, have the linker pick one.  */
 544       fprintf (asm_out_file, "\t.linkonce %s\n",
 545                (flags & SECTION_CODE ? "discard" : "same_size"));
 546     }
 547 }
 548 \f
 549 /* The Microsoft linker requires that every function be marked as
 550    DT_FCN.  When using gas on cygwin, we must emit appropriate .type
 551    directives.  */
 552
 553 #include "gsyms.h"
 554
 555 /* Mark a function appropriately.  This should only be called for
 556    functions for which we are not emitting COFF debugging information.
 557    FILE is the assembler output file, NAME is the name of the
 558    function, and PUBLIC is non-zero if the function is globally
 559    visible.  */
 560
 561 void
 562 i386_pe_declare_function_type (file, name, public)
 563      FILE *file;
 564      const char *name;
 565      int public;
 566 {
 567   fprintf (file, "\t.def\t");
 568   assemble_name (file, name);
 569   fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
 570            public ? (int) C_EXT : (int) C_STAT,
 571            (int) DT_FCN << N_BTSHFT);
 572 }
 573
 574 /* Keep a list of external functions.  */
 575
 576 struct extern_list
 577 {
 578   struct extern_list *next;
 579   const char *name;
 580 };
 581
 582 static struct extern_list *extern_head;
 583
 584 /* Assemble an external function reference.  We need to keep a list of
 585    these, so that we can output the function types at the end of the
 586    assembly.  We can't output the types now, because we might see a
 587    definition of the function later on and emit debugging information
 588    for it then.  */
 589
 590 void
 591 i386_pe_record_external_function (name)
 592      const char *name;
 593 {
 594   struct extern_list *p;
 595
 596   p = (struct extern_list *) permalloc (sizeof *p);
 597   p->next = extern_head;
 598   p->name = name;
 599   extern_head = p;
 600 }
 601
 602 /* Keep a list of exported symbols.  */
 603
 604 struct export_list
 605 {
 606   struct export_list *next;
 607   const char *name;
 608   int is_data;          /* used to type tag exported symbols.  */
 609 };
 610
 611 static struct export_list *export_head;
 612
 613 /* Assemble an export symbol entry.  We need to keep a list of
 614    these, so that we can output the export list at the end of the
 615    assembly.  We used to output these export symbols in each function,
 616    but that causes problems with GNU ld when the sections are
 617    linkonce.  */
 618
 619 void
 620 i386_pe_record_exported_symbol (name, is_data)
 621      const char *name;
 622      int is_data;
 623 {
 624   struct export_list *p;
 625
 626   p = (struct export_list *) permalloc (sizeof *p);
 627   p->next = export_head;
 628   p->name = name;
 629   p->is_data = is_data;
 630   export_head = p;
 631 }
 632
 633 /* This is called at the end of assembly.  For each external function
 634    which has not been defined, we output a declaration now.  We also
 635    output the .drectve section.  */
 636
 637 void
 638 i386_pe_asm_file_end (file)
 639      FILE *file;
 640 {
 641   struct extern_list *p;
 642
 643   ix86_asm_file_end (file);
 644
 645   for (p = extern_head; p != NULL; p = p->next)
 646     {
 647       tree decl;
 648
 649       decl = get_identifier (p->name);
 650
 651       /* Positively ensure only one declaration for any given symbol.  */
 652       if (! TREE_ASM_WRITTEN (decl) && TREE_SYMBOL_REFERENCED (decl))
 653         {
 654           TREE_ASM_WRITTEN (decl) = 1;
 655           i386_pe_declare_function_type (file, p->name, TREE_PUBLIC (decl));
 656         }
 657     }
 658
 659   if (export_head)
 660     {
 661       struct export_list *q;
 662       drectve_section ();
 663       for (q = export_head; q != NULL; q = q->next)
 664         {
 665           fprintf (file, "\t.ascii \" -export:%s%s\"\n",
 666                    I386_PE_STRIP_ENCODING (q->name),
 667                    (q->is_data) ? ",data" : "");
 668         }
 669     }
 670 }
 671