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 "diagnostic-core.h"
  34 #include "hashtab.h"
  35 #include "langhooks.h"
  36 #include "ggc.h"
  37 #include "target.h"
  38 #include "except.h"
  39 #include "lto-streamer.h"
  40
  41 /* i386/PE specific attribute support.
  42
  43    i386/PE has two new attributes:
  44    dllexport - for exporting a function/variable that will live in a dll
  45    dllimport - for importing a function/variable from a dll
  46
  47    Microsoft allows multiple declspecs in one __declspec, separating
  48    them with spaces.  We do NOT support this.  Instead, use __declspec
  49    multiple times.
  50 */
  51
  52 /* Handle a "shared" attribute;
  53    arguments as in struct attribute_spec.handler.  */
  54 tree
  55 ix86_handle_shared_attribute (tree *node, tree name,
  56                               tree args ATTRIBUTE_UNUSED,
  57                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
  58 {
  59   if (TREE_CODE (*node) != VAR_DECL)
  60     {
  61       warning (OPT_Wattributes, "%qE attribute only applies to variables",
  62                name);
  63       *no_add_attrs = true;
  64     }
  65
  66   return NULL_TREE;
  67 }
  68
  69 /* Handle a "selectany" attribute;
  70    arguments as in struct attribute_spec.handler.  */
  71 tree
  72 ix86_handle_selectany_attribute (tree *node, tree name,
  73                                  tree args ATTRIBUTE_UNUSED,
  74                                  int flags ATTRIBUTE_UNUSED,
  75                                  bool *no_add_attrs)
  76 {
  77   /* The attribute applies only to objects that are initialized and have
  78      external linkage.  However, we may not know about initialization
  79      until the language frontend has processed the decl. We'll check for
  80      initialization later in encode_section_info.  */
  81   if (TREE_CODE (*node) != VAR_DECL || !TREE_PUBLIC (*node))
  82     {
  83       error ("%qE attribute applies only to initialized variables"
  84              " with external linkage", name);
  85       *no_add_attrs = true;
  86     }
  87
  88   return NULL_TREE;
  89 }
  90
  91 \f
  92 /* Return the type that we should use to determine if DECL is
  93    imported or exported.  */
  94
  95 static tree
  96 associated_type (tree decl)
  97 {
  98   return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
  99           ?  DECL_CONTEXT (decl) : NULL_TREE);
 100 }
 101
 102 /* Return true if DECL should be a dllexport'd object.  */
 103
 104 static bool
 105 i386_pe_determine_dllexport_p (tree decl)
 106 {
 107   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
 108     return false;
 109
 110   /* Don't export local clones of dllexports.  */
 111   if (!TREE_PUBLIC (decl))
 112     return false;
 113
 114   if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
 115     return true;
 116
 117   return false;
 118 }
 119
 120 /* Return true if DECL should be a dllimport'd object.  */
 121
 122 static bool
 123 i386_pe_determine_dllimport_p (tree decl)
 124 {
 125   tree assoc;
 126
 127   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
 128     return false;
 129
 130   if (DECL_DLLIMPORT_P (decl))
 131     return true;
 132
 133   /* The DECL_DLLIMPORT_P flag was set for decls in the class definition
 134      by  targetm.cxx.adjust_class_at_definition.  Check again to emit
 135      error message if the class attribute has been overridden by an
 136      out-of-class definition of static data.  */
 137   assoc = associated_type (decl);
 138   if (assoc && lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc))
 139       && TREE_CODE (decl) == VAR_DECL
 140       && TREE_STATIC (decl) && TREE_PUBLIC (decl)
 141       && !DECL_EXTERNAL (decl)
 142       /* vtable's are linkonce constants, so defining a vtable is not
 143          an error as long as we don't try to import it too.  */
 144       && !DECL_VIRTUAL_P (decl))
 145         error ("definition of static data member %q+D of "
 146                "dllimport%'d class", decl);
 147
 148   return false;
 149 }
 150
 151 /* Handle the -mno-fun-dllimport target switch.  */
 152
 153 bool
 154 i386_pe_valid_dllimport_attribute_p (const_tree decl)
 155 {
 156    if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
 157      return false;
 158    return true;
 159 }
 160
 161 /* Return string which is the function name, identified by ID, modified
 162    with a suffix consisting of an atsign (@) followed by the number of
 163    bytes of arguments.  If ID is NULL use the DECL_NAME as base. If
 164    FASTCALL is true, also add the FASTCALL_PREFIX.
 165    Return NULL if no change required.  */
 166
 167 static tree
 168 gen_stdcall_or_fastcall_suffix (tree decl, tree id, bool fastcall)
 169 {
 170   HOST_WIDE_INT total = 0;
 171   const char *old_str = IDENTIFIER_POINTER (id != NULL_TREE ? id : DECL_NAME (decl));
 172   char *new_str, *p;
 173   tree type = TREE_TYPE (decl);
 174   tree arg;
 175   function_args_iterator args_iter;
 176
 177   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 178
 179   if (prototype_p (type))
 180     {
 181       /* This attribute is ignored for variadic functions.  */
 182       if (stdarg_p (type))
 183         return NULL_TREE;
 184
 185       /* Quit if we hit an incomplete type.  Error is reported
 186          by convert_arguments in c-typeck.c or cp/typeck.c.  */
 187       FOREACH_FUNCTION_ARGS(type, arg, args_iter)
 188         {
 189           HOST_WIDE_INT parm_size;
 190           HOST_WIDE_INT parm_boundary_bytes = PARM_BOUNDARY / BITS_PER_UNIT;
 191
 192           if (! COMPLETE_TYPE_P (arg))
 193             break;
 194
 195           parm_size = int_size_in_bytes (arg);
 196           if (parm_size < 0)
 197             break;
 198
 199           /* Must round up to include padding.  This is done the same
 200              way as in store_one_arg.  */
 201           parm_size = ((parm_size + parm_boundary_bytes - 1)
 202                        / parm_boundary_bytes * parm_boundary_bytes);
 203           total += parm_size;
 204         }
 205       }
 206   /* Assume max of 8 base 10 digits in the suffix.  */
 207   p = new_str = XALLOCAVEC (char, 1 + strlen (old_str) + 1 + 8 + 1);
 208   if (fastcall)
 209     *p++ = FASTCALL_PREFIX;
 210   sprintf (p, "%s@" HOST_WIDE_INT_PRINT_DEC, old_str, total);
 211
 212   return get_identifier (new_str);
 213 }
 214
 215 /* Maybe decorate and get a new identifier for the DECL of a stdcall or
 216    fastcall function. The original identifier is supplied in ID. */
 217
 218 static tree
 219 i386_pe_maybe_mangle_decl_assembler_name (tree decl, tree id)
 220 {
 221   tree new_id = NULL_TREE;
 222
 223   if (TREE_CODE (decl) == FUNCTION_DECL)
 224     {
 225       tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
 226       if (lookup_attribute ("stdcall", type_attributes))
 227         new_id = gen_stdcall_or_fastcall_suffix (decl, id, false);
 228       else if (lookup_attribute ("fastcall", type_attributes))
 229         new_id = gen_stdcall_or_fastcall_suffix (decl, id, true);
 230     }
 231
 232   return new_id;
 233 }
 234
 235 /* Emit an assembler directive to set symbol for DECL visibility to
 236    the visibility type VIS, which must not be VISIBILITY_DEFAULT.
 237    As for PE there is no hidden support in gas, we just warn for
 238    user-specified visibility attributes.  */
 239
 240 void
 241 i386_pe_assemble_visibility (tree decl,
 242                              int vis ATTRIBUTE_UNUSED)
 243 {
 244   if (!decl
 245       || !lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
 246     return;
 247   warning (OPT_Wattributes, "visibility attribute not supported "
 248            "in this configuration; ignored");
 249 }
 250
 251 /* This is used as a target hook to modify the DECL_ASSEMBLER_NAME
 252    in the language-independent default hook
 253    langhooks,c:lhd_set_decl_assembler_name ()
 254    and in cp/mangle,c:mangle_decl ().  */
 255 tree
 256 i386_pe_mangle_decl_assembler_name (tree decl, tree id)
 257 {
 258   tree new_id = i386_pe_maybe_mangle_decl_assembler_name (decl, id);
 259
 260   return (new_id ? new_id : id);
 261 }
 262
 263 /* This hook behaves the same as varasm.c/assemble_name(), but
 264    generates the name into memory rather than outputting it to
 265    a file stream.  */
 266
 267 tree
 268 i386_pe_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
 269 {
 270   const char *skipped = name + (*name == '*' ? 1 : 0);
 271   const char *stripped = targetm.strip_name_encoding (skipped);
 272   if (*name != '*' && *user_label_prefix && *stripped != FASTCALL_PREFIX)
 273     stripped = ACONCAT ((user_label_prefix, stripped, NULL));
 274   return get_identifier (stripped);
 275 }
 276
 277 void
 278 i386_pe_encode_section_info (tree decl, rtx rtl, int first)
 279 {
 280   rtx symbol;
 281   int flags;
 282
 283   /* Do this last, due to our frobbing of DECL_DLLIMPORT_P above.  */
 284   default_encode_section_info (decl, rtl, first);
 285
 286   /* Careful not to prod global register variables.  */
 287   if (!MEM_P (rtl))
 288     return;
 289
 290   symbol = XEXP (rtl, 0);
 291   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
 292
 293   switch (TREE_CODE (decl))
 294     {
 295     case FUNCTION_DECL:
 296       /* FIXME:  Imported stdcall names are not modified by the Ada frontend.
 297          Check and decorate the RTL name now.  */
 298       if  (strcmp (lang_hooks.name, "GNU Ada") == 0)
 299         {
 300           tree new_id;
 301           tree old_id = DECL_ASSEMBLER_NAME (decl);
 302           const char* asm_str = IDENTIFIER_POINTER (old_id);
 303           /* Do not change the identifier if a verbatim asmspec
 304              or if stdcall suffix already added. */
 305           if (!(*asm_str == '*' || strchr (asm_str, '@'))
 306               && (new_id = i386_pe_maybe_mangle_decl_assembler_name (decl,
 307                                                                      old_id)))
 308             XSTR (symbol, 0) = IDENTIFIER_POINTER (new_id);
 309         }
 310       break;
 311
 312     case VAR_DECL:
 313       if (lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
 314         {
 315           if (DECL_INITIAL (decl)
 316               /* If an object is initialized with a ctor, the static
 317                  initialization and destruction code for it is present in
 318                  each unit defining the object.  The code that calls the
 319                  ctor is protected by a link-once guard variable, so that
 320                  the object still has link-once semantics,  */
 321               || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
 322             make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
 323           else
 324             error ("%q+D:'selectany' attribute applies only to "
 325                    "initialized objects", decl);
 326         }
 327       break;
 328
 329     default:
 330       return;
 331     }
 332
 333   /* Mark the decl so we can tell from the rtl whether the object is
 334      dllexport'd or dllimport'd.  tree.c: merge_dllimport_decl_attributes
 335      handles dllexport/dllimport override semantics.  */
 336   flags = (SYMBOL_REF_FLAGS (symbol) &
 337            ~(SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT));
 338   if (i386_pe_determine_dllexport_p (decl))
 339     flags |= SYMBOL_FLAG_DLLEXPORT;
 340   else if (i386_pe_determine_dllimport_p (decl))
 341     flags |= SYMBOL_FLAG_DLLIMPORT;
 342
 343   SYMBOL_REF_FLAGS (symbol) = flags;
 344 }
 345
 346 bool
 347 i386_pe_binds_local_p (const_tree exp)
 348 {
 349   /* PE does not do dynamic binding.  Indeed, the only kind of
 350      non-local reference comes from a dllimport'd symbol.  */
 351   if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
 352       && DECL_DLLIMPORT_P (exp))
 353     return false;
 354
 355   /* Or a weak one, now that they are supported.  */
 356   if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
 357       && DECL_WEAK (exp))
 358     return false;
 359
 360   return true;
 361 }
 362
 363 /* Also strip the fastcall prefix and stdcall suffix.  */
 364
 365 const char *
 366 i386_pe_strip_name_encoding_full (const char *str)
 367 {
 368   const char *p;
 369   const char *name = default_strip_name_encoding (str);
 370
 371   /* Strip leading '@' on fastcall symbols.  */
 372   if (*name == '@')
 373     name++;
 374
 375   /* Strip trailing "@n".  */
 376   p = strchr (name, '@');
 377   if (p)
 378     return ggc_alloc_string (name, p - name);
 379
 380   return name;
 381 }
 382
 383 void
 384 i386_pe_unique_section (tree decl, int reloc)
 385 {
 386   int len;
 387   const char *name, *prefix;
 388   char *string;
 389
 390   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 391   name = i386_pe_strip_name_encoding_full (name);
 392
 393   /* The object is put in, for example, section .text$foo.
 394      The linker will then ultimately place them in .text
 395      (everything from the $ on is stripped). Don't put
 396      read-only data in .rdata section to avoid a PE linker
 397      bug when .rdata$* grouped sections are used in code
 398      without a .rdata section.  */
 399   if (TREE_CODE (decl) == FUNCTION_DECL)
 400     prefix = ".text$";
 401   else if (decl_readonly_section (decl, reloc))
 402     prefix = ".rdata$";
 403   else
 404     prefix = ".data$";
 405   len = strlen (name) + strlen (prefix);
 406   string = XALLOCAVEC (char, len + 1);
 407   sprintf (string, "%s%s", prefix, name);
 408
 409   DECL_SECTION_NAME (decl) = build_string (len, string);
 410 }
 411
 412 /* Select a set of attributes for section NAME based on the properties
 413    of DECL and whether or not RELOC indicates that DECL's initializer
 414    might contain runtime relocations.
 415
 416    We make the section read-only and executable for a function decl,
 417    read-only for a const data decl, and writable for a non-const data decl.
 418
 419    If the section has already been defined, to not allow it to have
 420    different attributes, as (1) this is ambiguous since we're not seeing
 421    all the declarations up front and (2) some assemblers (e.g. SVR4)
 422    do not recognize section redefinitions.  */
 423 /* ??? This differs from the "standard" PE implementation in that we
 424    handle the SHARED variable attribute.  Should this be done for all
 425    PE targets?  */
 426
 427 #define SECTION_PE_SHARED       SECTION_MACH_DEP
 428
 429 unsigned int
 430 i386_pe_section_type_flags (tree decl, const char *name, int reloc)
 431 {
 432   static htab_t htab;
 433   unsigned int flags;
 434   unsigned int **slot;
 435
 436   /* The names we put in the hashtable will always be the unique
 437      versions given to us by the stringtable, so we can just use
 438      their addresses as the keys.  */
 439   if (!htab)
 440     htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
 441
 442   if (decl && TREE_CODE (decl) == FUNCTION_DECL)
 443     flags = SECTION_CODE;
 444   else if (decl && decl_readonly_section (decl, reloc))
 445     flags = 0;
 446   else
 447     {
 448       flags = SECTION_WRITE;
 449
 450       if (decl && TREE_CODE (decl) == VAR_DECL
 451           && lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
 452         flags |= SECTION_PE_SHARED;
 453     }
 454
 455   if (decl && DECL_ONE_ONLY (decl))
 456     flags |= SECTION_LINKONCE;
 457
 458   /* See if we already have an entry for this section.  */
 459   slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
 460   if (!*slot)
 461     {
 462       *slot = (unsigned int *) xmalloc (sizeof (unsigned int));
 463       **slot = flags;
 464     }
 465   else
 466     {
 467       if (decl && **slot != flags)
 468         error ("%q+D causes a section type conflict", decl);
 469     }
 470
 471   return flags;
 472 }
 473
 474 void
 475 i386_pe_asm_named_section (const char *name, unsigned int flags,
 476                            tree decl)
 477 {
 478   char flagchars[8], *f = flagchars;
 479
 480   if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
 481     /* readonly data */
 482     {
 483       *f++ ='d';  /* This is necessary for older versions of gas.  */
 484       *f++ ='r';
 485     }
 486   else
 487     {
 488       if (flags & SECTION_CODE)
 489         *f++ = 'x';
 490       if (flags & SECTION_WRITE)
 491         *f++ = 'w';
 492       if (flags & SECTION_PE_SHARED)
 493         *f++ = 's';
 494     }
 495
 496   /* LTO sections need 1-byte alignment to avoid confusing the
 497      zlib decompression algorithm with trailing zero pad bytes.  */
 498   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 499                         strlen (LTO_SECTION_NAME_PREFIX)) == 0)
 500     *f++ = '0';
 501
 502   *f = '\0';
 503
 504   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
 505
 506   if (flags & SECTION_LINKONCE)
 507     {
 508       /* Functions may have been compiled at various levels of
 509          optimization so we can't use `same_size' here.
 510          Instead, have the linker pick one, without warning.
 511          If 'selectany' attribute has been specified,  MS compiler
 512          sets 'discard' characteristic, rather than telling linker
 513          to warn of size or content mismatch, so do the same.  */
 514       bool discard = (flags & SECTION_CODE)
 515                       || lookup_attribute ("selectany",
 516                                            DECL_ATTRIBUTES (decl));
 517       fprintf (asm_out_file, "\t.linkonce %s\n",
 518                (discard  ? "discard" : "same_size"));
 519     }
 520 }
 521
 522 /* Beware, DECL may be NULL if compile_file() is emitting the LTO marker.  */
 523
 524 void
 525 i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl,
 526                                         const char *name, HOST_WIDE_INT size,
 527                                         HOST_WIDE_INT align ATTRIBUTE_UNUSED)
 528 {
 529   HOST_WIDE_INT rounded;
 530
 531   /* Compute as in assemble_noswitch_variable, since we don't have
 532      support for aligned common on older binutils.  We must also
 533      avoid emitting a common symbol of size zero, as this is the
 534      overloaded representation that indicates an undefined external
 535      symbol in the PE object file format.  */
 536   rounded = size ? size : 1;
 537   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
 538   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
 539              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 540
 541   i386_pe_maybe_record_exported_symbol (decl, name, 1);
 542
 543   fprintf (stream, "\t.comm\t");
 544   assemble_name (stream, name);
 545   if (use_pe_aligned_common)
 546     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC ", %d\n",
 547            size ? size : (HOST_WIDE_INT) 1,
 548            exact_log2 (align) - exact_log2 (CHAR_BIT));
 549   else
 550     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC "\t" ASM_COMMENT_START
 551            " " HOST_WIDE_INT_PRINT_DEC "\n", rounded, size);
 552 }
 553 \f
 554 /* The Microsoft linker requires that every function be marked as
 555    DT_FCN.  When using gas on cygwin, we must emit appropriate .type
 556    directives.  */
 557
 558 #include "gsyms.h"
 559
 560 /* Mark a function appropriately.  This should only be called for
 561    functions for which we are not emitting COFF debugging information.
 562    FILE is the assembler output file, NAME is the name of the
 563    function, and PUB is nonzero if the function is globally
 564    visible.  */
 565
 566 void
 567 i386_pe_declare_function_type (FILE *file, const char *name, int pub)
 568 {
 569   fprintf (file, "\t.def\t");
 570   assemble_name (file, name);
 571   fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
 572            pub ? (int) C_EXT : (int) C_STAT,
 573            (int) DT_FCN << N_BTSHFT);
 574 }
 575
 576 /* Keep a list of external functions.  */
 577
 578 struct GTY(()) extern_list
 579 {
 580   struct extern_list *next;
 581   tree decl;
 582   const char *name;
 583 };
 584
 585 static GTY(()) struct extern_list *extern_head;
 586
 587 /* Assemble an external function reference.  We need to keep a list of
 588    these, so that we can output the function types at the end of the
 589    assembly.  We can't output the types now, because we might see a
 590    definition of the function later on and emit debugging information
 591    for it then.  */
 592
 593 void
 594 i386_pe_record_external_function (tree decl, const char *name)
 595 {
 596   struct extern_list *p;
 597
 598   p = ggc_alloc_extern_list ();
 599   p->next = extern_head;
 600   p->decl = decl;
 601   p->name = name;
 602   extern_head = p;
 603 }
 604
 605 /* Keep a list of exported symbols.  */
 606
 607 struct GTY(()) export_list
 608 {
 609   struct export_list *next;
 610   const char *name;
 611   int is_data;          /* used to type tag exported symbols.  */
 612 };
 613
 614 static GTY(()) struct export_list *export_head;
 615
 616 /* Assemble an export symbol entry.  We need to keep a list of
 617    these, so that we can output the export list at the end of the
 618    assembly.  We used to output these export symbols in each function,
 619    but that causes problems with GNU ld when the sections are
 620    linkonce.  Beware, DECL may be NULL if compile_file() is emitting
 621    the LTO marker.  */
 622
 623 void
 624 i386_pe_maybe_record_exported_symbol (tree decl, const char *name, int is_data)
 625 {
 626   rtx symbol;
 627   struct export_list *p;
 628
 629   if (!decl)
 630     return;
 631
 632   symbol = XEXP (DECL_RTL (decl), 0);
 633   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
 634   if (!SYMBOL_REF_DLLEXPORT_P (symbol))
 635     return;
 636
 637   gcc_assert (TREE_PUBLIC (decl));
 638
 639   p = ggc_alloc_export_list ();
 640   p->next = export_head;
 641   p->name = name;
 642   p->is_data = is_data;
 643   export_head = p;
 644 }
 645
 646 #ifdef CXX_WRAP_SPEC_LIST
 647
 648 /*  Hash table equality helper function.  */
 649
 650 static int
 651 wrapper_strcmp (const void *x, const void *y)
 652 {
 653   return !strcmp ((const char *) x, (const char *) y);
 654 }
 655
 656 /* Search for a function named TARGET in the list of library wrappers
 657    we are using, returning a pointer to it if found or NULL if not.
 658    This function might be called on quite a few symbols, and we only
 659    have the list of names of wrapped functions available to us as a
 660    spec string, so first time round we lazily initialise a hash table
 661    to make things quicker.  */
 662
 663 static const char *
 664 i386_find_on_wrapper_list (const char *target)
 665 {
 666   static char first_time = 1;
 667   static htab_t wrappers;
 668
 669   if (first_time)
 670     {
 671       /* Beware that this is not a complicated parser, it assumes
 672          that any sequence of non-whitespace beginning with an
 673          underscore is one of the wrapped symbols.  For now that's
 674          adequate to distinguish symbols from spec substitutions
 675          and command-line options.  */
 676       static char wrapper_list_buffer[] = CXX_WRAP_SPEC_LIST;
 677       char *bufptr;
 678       /* Breaks up the char array into separated strings
 679          strings and enter them into the hash table.  */
 680       wrappers = htab_create_alloc (8, htab_hash_string, wrapper_strcmp,
 681         0, xcalloc, free);
 682       for (bufptr = wrapper_list_buffer; *bufptr; ++bufptr)
 683         {
 684           char *found = NULL;
 685           if (ISSPACE (*bufptr))
 686             continue;
 687           if (*bufptr == '_')
 688             found = bufptr;
 689           while (*bufptr && !ISSPACE (*bufptr))
 690             ++bufptr;
 691           if (*bufptr)
 692             *bufptr = 0;
 693           if (found)
 694             *htab_find_slot (wrappers, found, INSERT) = found;
 695         }
 696       first_time = 0;
 697     }
 698
 699   return (const char *) htab_find (wrappers, target);
 700 }
 701
 702 #endif /* CXX_WRAP_SPEC_LIST */
 703
 704 /* This is called at the end of assembly.  For each external function
 705    which has not been defined, we output a declaration now.  We also
 706    output the .drectve section.  */
 707
 708 void
 709 i386_pe_file_end (void)
 710 {
 711   struct extern_list *p;
 712
 713   for (p = extern_head; p != NULL; p = p->next)
 714     {
 715       tree decl;
 716
 717       decl = p->decl;
 718
 719       /* Positively ensure only one declaration for any given symbol.  */
 720       if (! TREE_ASM_WRITTEN (decl)
 721           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
 722         {
 723 #ifdef CXX_WRAP_SPEC_LIST
 724           /* To ensure the DLL that provides the corresponding real
 725              functions is still loaded at runtime, we must reference
 726              the real function so that an (unused) import is created.  */
 727           const char *realsym = i386_find_on_wrapper_list (p->name);
 728           if (realsym)
 729             i386_pe_declare_function_type (asm_out_file,
 730                 concat ("__real_", realsym, NULL), TREE_PUBLIC (decl));
 731 #endif /* CXX_WRAP_SPEC_LIST */
 732           TREE_ASM_WRITTEN (decl) = 1;
 733           i386_pe_declare_function_type (asm_out_file, p->name,
 734                                          TREE_PUBLIC (decl));
 735         }
 736     }
 737
 738   if (export_head)
 739     {
 740       struct export_list *q;
 741       drectve_section ();
 742       for (q = export_head; q != NULL; q = q->next)
 743         {
 744           fprintf (asm_out_file, "\t.ascii \" -export:\\\"%s\\\"%s\"\n",
 745                    default_strip_name_encoding (q->name),
 746                    (q->is_data ? ",data" : ""));
 747         }
 748     }
 749 }
 750
 751 \f
 752 /* x64 Structured Exception Handling unwind info.  */
 753
 754 struct seh_frame_state
 755 {
 756   /* SEH records saves relative to the "current" stack pointer, whether
 757      or not there's a frame pointer in place.  This tracks the current
 758      stack pointer offset from the CFA.  */
 759   HOST_WIDE_INT sp_offset;
 760
 761   /* The CFA is located at CFA_REG + CFA_OFFSET.  */
 762   HOST_WIDE_INT cfa_offset;
 763   rtx cfa_reg;
 764 };
 765
 766 /* Set up data structures beginning output for SEH.  */
 767
 768 void
 769 i386_pe_seh_init (FILE *f)
 770 {
 771   struct seh_frame_state *seh;
 772
 773   if (!TARGET_SEH)
 774     return;
 775   if (cfun->is_thunk)
 776     return;
 777
 778   /* We cannot support DRAP with SEH.  We turned off support for it by
 779      re-defining MAX_STACK_ALIGNMENT when SEH is enabled.  */
 780   gcc_assert (!stack_realign_drap);
 781
 782   seh = XCNEW (struct seh_frame_state);
 783   cfun->machine->seh = seh;
 784
 785   seh->sp_offset = INCOMING_FRAME_SP_OFFSET;
 786   seh->cfa_offset = INCOMING_FRAME_SP_OFFSET;
 787   seh->cfa_reg = stack_pointer_rtx;
 788
 789   fputs ("\t.seh_proc\t", f);
 790   assemble_name (f, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun->decl)));
 791   fputc ('\n', f);
 792 }
 793
 794 void
 795 i386_pe_seh_end_prologue (FILE *f)
 796 {
 797   struct seh_frame_state *seh;
 798
 799   if (!TARGET_SEH)
 800     return;
 801   if (cfun->is_thunk)
 802     return;
 803   seh = cfun->machine->seh;
 804
 805   /* Emit an assembler directive to set up the frame pointer.  Always do
 806      this last.  The documentation talks about doing this "before" any
 807      other code that uses offsets, but (experimentally) that's after we
 808      emit the codes in reverse order (handled by the assembler).  */
 809   if (seh->cfa_reg != stack_pointer_rtx)
 810     {
 811       HOST_WIDE_INT offset = seh->sp_offset - seh->cfa_offset;
 812
 813       gcc_assert ((offset & 15) == 0);
 814       gcc_assert (IN_RANGE (offset, 0, 240));
 815
 816       fputs ("\t.seh_setframe\t", f);
 817       print_reg (seh->cfa_reg, 0, f);
 818       fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
 819     }
 820
 821   XDELETE (seh);
 822   cfun->machine->seh = NULL;
 823
 824   fputs ("\t.seh_endprologue\n", f);
 825 }
 826
 827 static void
 828 i386_pe_seh_fini (FILE *f)
 829 {
 830   if (!TARGET_SEH)
 831     return;
 832   if (cfun->is_thunk)
 833     return;
 834   fputs ("\t.seh_endproc\n", f);
 835 }
 836
 837 /* Emit an assembler directive to save REG via a PUSH.  */
 838
 839 static void
 840 seh_emit_push (FILE *f, struct seh_frame_state *seh, rtx reg)
 841 {
 842   unsigned int regno = REGNO (reg);
 843
 844   gcc_checking_assert (GENERAL_REGNO_P (regno));
 845
 846   seh->sp_offset += UNITS_PER_WORD;
 847   if (seh->cfa_reg == stack_pointer_rtx)
 848     seh->cfa_offset += UNITS_PER_WORD;
 849
 850   fputs ("\t.seh_pushreg\t", f);
 851   print_reg (reg, 0, f);
 852   fputc ('\n', f);
 853 }
 854
 855 /* Emit an assembler directive to save REG at CFA - CFA_OFFSET.  */
 856
 857 static void
 858 seh_emit_save (FILE *f, struct seh_frame_state *seh,
 859                rtx reg, HOST_WIDE_INT cfa_offset)
 860 {
 861   unsigned int regno = REGNO (reg);
 862   HOST_WIDE_INT offset;
 863
 864   /* Negative save offsets are of course not supported, since that
 865      would be a store below the stack pointer and thus clobberable.  */
 866   gcc_assert (seh->sp_offset >= cfa_offset);
 867   offset = seh->sp_offset - cfa_offset;
 868
 869   fputs ((SSE_REGNO_P (regno) ? "\t.seh_savexmm\t"
 870          : GENERAL_REGNO_P (regno) ?  "\t.seh_savereg\t"
 871          : (gcc_unreachable (), "")), f);
 872   print_reg (reg, 0, f);
 873   fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
 874 }
 875
 876 /* Emit an assembler directive to adjust RSP by OFFSET.  */
 877
 878 static void
 879 seh_emit_stackalloc (FILE *f, struct seh_frame_state *seh,
 880                      HOST_WIDE_INT offset)
 881 {
 882   /* We're only concerned with prologue stack allocations, which all
 883      are subtractions from the stack pointer.  */
 884   gcc_assert (offset < 0);
 885   offset = -offset;
 886
 887   if (seh->cfa_reg == stack_pointer_rtx)
 888     seh->cfa_offset += offset;
 889   seh->sp_offset += offset;
 890
 891   fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset);
 892 }
 893
 894 /* Process REG_CFA_ADJUST_CFA for SEH.  */
 895
 896 static void
 897 seh_cfa_adjust_cfa (FILE *f, struct seh_frame_state *seh, rtx pat)
 898 {
 899   rtx dest, src;
 900   HOST_WIDE_INT reg_offset = 0;
 901   unsigned int dest_regno;
 902
 903   dest = SET_DEST (pat);
 904   src = SET_SRC (pat);
 905
 906   if (GET_CODE (src) == PLUS)
 907     {
 908       reg_offset = INTVAL (XEXP (src, 1));
 909       src = XEXP (src, 0);
 910     }
 911   else if (GET_CODE (src) == MINUS)
 912     {
 913       reg_offset = -INTVAL (XEXP (src, 1));
 914       src = XEXP (src, 0);
 915     }
 916   gcc_assert (src == stack_pointer_rtx);
 917   gcc_assert (seh->cfa_reg == stack_pointer_rtx);
 918   dest_regno = REGNO (dest);
 919
 920   if (dest_regno == STACK_POINTER_REGNUM)
 921     seh_emit_stackalloc (f, seh, reg_offset);
 922   else if (dest_regno == HARD_FRAME_POINTER_REGNUM)
 923     {
 924       seh->cfa_reg = dest;
 925       seh->cfa_offset -= reg_offset;
 926     }
 927   else
 928     gcc_unreachable ();
 929 }
 930
 931 /* Process REG_CFA_OFFSET for SEH.  */
 932
 933 static void
 934 seh_cfa_offset (FILE *f, struct seh_frame_state *seh, rtx pat)
 935 {
 936   rtx dest, src;
 937   HOST_WIDE_INT reg_offset;
 938
 939   dest = SET_DEST (pat);
 940   src = SET_SRC (pat);
 941
 942   gcc_assert (MEM_P (dest));
 943   dest = XEXP (dest, 0);
 944   if (REG_P (dest))
 945     reg_offset = 0;
 946   else
 947     {
 948       gcc_assert (GET_CODE (dest) == PLUS);
 949       reg_offset = INTVAL (XEXP (dest, 1));
 950       dest = XEXP (dest, 0);
 951     }
 952   gcc_assert (dest == seh->cfa_reg);
 953
 954   seh_emit_save (f, seh, src, seh->cfa_offset - reg_offset);
 955 }
 956
 957 /* Process a FRAME_RELATED_EXPR for SEH.  */
 958
 959 static void
 960 seh_frame_related_expr (FILE *f, struct seh_frame_state *seh, rtx pat)
 961 {
 962   rtx dest, src;
 963   HOST_WIDE_INT addend;
 964
 965   /* See the full loop in dwarf2out_frame_debug_expr.  */
 966   if (GET_CODE (pat) == PARALLEL || GET_CODE (pat) == SEQUENCE)
 967     {
 968       int i, n = XVECLEN (pat, 0), pass, npass;
 969
 970       npass = (GET_CODE (pat) == PARALLEL ? 2 : 1);
 971       for (pass = 0; pass < npass; ++pass)
 972         for (i = 0; i < n; ++i)
 973           {
 974             rtx ele = XVECEXP (pat, 0, i);
 975
 976             if (GET_CODE (ele) != SET)
 977               continue;
 978             dest = SET_DEST (ele);
 979
 980             /* Process each member of the PARALLEL independently.  The first
 981                member is always processed; others only if they are marked.  */
 982             if (i == 0 || RTX_FRAME_RELATED_P (ele))
 983               {
 984                 /* Evaluate all register saves in the first pass and all
 985                    register updates in the second pass.  */
 986                 if ((MEM_P (dest) ^ pass) || npass == 1)
 987                   seh_frame_related_expr (f, seh, ele);
 988               }
 989           }
 990       return;
 991     }
 992
 993   dest = SET_DEST (pat);
 994   src = SET_SRC (pat);
 995
 996   switch (GET_CODE (dest))
 997     {
 998     case REG:
 999       switch (GET_CODE (src))
1000         {
1001         case REG:
1002           /* REG = REG: This should be establishing a frame pointer.  */
1003           gcc_assert (src == stack_pointer_rtx);
1004           gcc_assert (dest == hard_frame_pointer_rtx);
1005           seh_cfa_adjust_cfa (f, seh, pat);
1006           break;
1007
1008         case PLUS:
1009           addend = INTVAL (XEXP (src, 1));
1010           src = XEXP (src, 0);
1011           if (dest == hard_frame_pointer_rtx)
1012             seh_cfa_adjust_cfa (f, seh, pat);
1013           else if (dest == stack_pointer_rtx)
1014             {
1015               gcc_assert (src == stack_pointer_rtx);
1016               seh_emit_stackalloc (f, seh, addend);
1017             }
1018           else
1019             gcc_unreachable ();
1020           break;
1021
1022         default:
1023           gcc_unreachable ();
1024         }
1025       break;
1026
1027     case MEM:
1028       /* A save of some kind.  */
1029       dest = XEXP (dest, 0);
1030       if (GET_CODE (dest) == PRE_DEC)
1031         {
1032           gcc_checking_assert (GET_MODE (src) == Pmode);
1033           gcc_checking_assert (REG_P (src));
1034           seh_emit_push (f, seh, src);
1035         }
1036       else
1037         seh_cfa_offset (f, seh, pat);
1038       break;
1039
1040     default:
1041       gcc_unreachable ();
1042     }
1043 }
1044
1045 /* This function looks at a single insn and emits any SEH directives
1046    required for unwind of this insn.  */
1047
1048 void
1049 i386_pe_seh_unwind_emit (FILE *asm_out_file, rtx insn)
1050 {
1051   rtx note, pat;
1052   bool handled_one = false;
1053   struct seh_frame_state *seh;
1054
1055   if (!TARGET_SEH)
1056     return;
1057
1058   /* We free the SEH data once done with the prologue.  Ignore those
1059      RTX_FRAME_RELATED_P insns that are associated with the epilogue.  */
1060   seh = cfun->machine->seh;
1061   if (seh == NULL)
1062     return;
1063
1064   if (NOTE_P (insn) || !RTX_FRAME_RELATED_P (insn))
1065     return;
1066
1067   for (note = REG_NOTES (insn); note ; note = XEXP (note, 1))
1068     {
1069       pat = XEXP (note, 0);
1070       switch (REG_NOTE_KIND (note))
1071         {
1072         case REG_FRAME_RELATED_EXPR:
1073           goto found;
1074
1075         case REG_CFA_DEF_CFA:
1076         case REG_CFA_EXPRESSION:
1077           /* Only emitted with DRAP, which we disable.  */
1078           gcc_unreachable ();
1079           break;
1080
1081         case REG_CFA_REGISTER:
1082           /* Only emitted in epilogues, which we skip.  */
1083           gcc_unreachable ();
1084
1085         case REG_CFA_ADJUST_CFA:
1086           if (pat == NULL)
1087             {
1088               pat = PATTERN (insn);
1089               if (GET_CODE (pat) == PARALLEL)
1090                 pat = XVECEXP (pat, 0, 0);
1091             }
1092           seh_cfa_adjust_cfa (asm_out_file, seh, pat);
1093           handled_one = true;
1094           break;
1095
1096         case REG_CFA_OFFSET:
1097           if (pat == NULL)
1098             pat = single_set (insn);
1099           seh_cfa_offset (asm_out_file, seh, pat);
1100           handled_one = true;
1101           break;
1102
1103         default:
1104           break;
1105         }
1106     }
1107   if (handled_one)
1108     return;
1109   pat = PATTERN (insn);
1110  found:
1111   seh_frame_related_expr (asm_out_file, seh, pat);
1112 }
1113 \f
1114 void
1115 i386_pe_start_function (FILE *f, const char *name, tree decl)
1116 {
1117   i386_pe_maybe_record_exported_symbol (decl, name, 0);
1118   if (write_symbols != SDB_DEBUG)
1119     i386_pe_declare_function_type (f, name, TREE_PUBLIC (decl));
1120   /* In case section was altered by debugging output.  */
1121   if (decl != NULL_TREE)
1122     switch_to_section (function_section (decl));
1123   ASM_OUTPUT_FUNCTION_LABEL (f, name, decl);
1124 }
1125
1126 void
1127 i386_pe_end_function (FILE *f, const char *name ATTRIBUTE_UNUSED,
1128                       tree decl ATTRIBUTE_UNUSED)
1129 {
1130   i386_pe_seh_fini (f);
1131 }
1132 \f
1133
1134 #include "gt-winnt.h"