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