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 defined (HAVE_GAS_SECTION_EXCLUDE) && HAVE_GAS_SECTION_EXCLUDE == 1
 488   if ((flags & SECTION_EXCLUDE) != 0)
 489     *f++ = 'e';
 490 #endif
 491
 492   if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
 493     /* readonly data */
 494     {
 495       *f++ ='d';  /* This is necessary for older versions of gas.  */
 496       *f++ ='r';
 497     }
 498   else
 499     {
 500       if (flags & SECTION_CODE)
 501         *f++ = 'x';
 502       if (flags & SECTION_WRITE)
 503         *f++ = 'w';
 504       if (flags & SECTION_PE_SHARED)
 505         *f++ = 's';
 506 #if !defined (HAVE_GAS_SECTION_EXCLUDE) || HAVE_GAS_SECTION_EXCLUDE == 0
 507       /* If attribute "e" isn't supported we mark this section as
 508          never-load.  */
 509       if ((flags & SECTION_EXCLUDE) != 0)
 510         *f++ = 'n';
 511 #endif
 512     }
 513
 514   /* LTO sections need 1-byte alignment to avoid confusing the
 515      zlib decompression algorithm with trailing zero pad bytes.  */
 516   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 517                         strlen (LTO_SECTION_NAME_PREFIX)) == 0)
 518     *f++ = '0';
 519
 520   *f = '\0';
 521
 522   fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
 523
 524   if (flags & SECTION_LINKONCE)
 525     {
 526       /* Functions may have been compiled at various levels of
 527          optimization so we can't use `same_size' here.
 528          Instead, have the linker pick one, without warning.
 529          If 'selectany' attribute has been specified,  MS compiler
 530          sets 'discard' characteristic, rather than telling linker
 531          to warn of size or content mismatch, so do the same.  */
 532       bool discard = (flags & SECTION_CODE)
 533                       || lookup_attribute ("selectany",
 534                                            DECL_ATTRIBUTES (decl));
 535       fprintf (asm_out_file, "\t.linkonce %s\n",
 536                (discard  ? "discard" : "same_size"));
 537     }
 538 }
 539
 540 /* Beware, DECL may be NULL if compile_file() is emitting the LTO marker.  */
 541
 542 void
 543 i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl,
 544                                         const char *name, HOST_WIDE_INT size,
 545                                         HOST_WIDE_INT align ATTRIBUTE_UNUSED)
 546 {
 547   HOST_WIDE_INT rounded;
 548
 549   /* Compute as in assemble_noswitch_variable, since we don't have
 550      support for aligned common on older binutils.  We must also
 551      avoid emitting a common symbol of size zero, as this is the
 552      overloaded representation that indicates an undefined external
 553      symbol in the PE object file format.  */
 554   rounded = size ? size : 1;
 555   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
 556   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
 557              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 558
 559   i386_pe_maybe_record_exported_symbol (decl, name, 1);
 560
 561   fprintf (stream, "\t.comm\t");
 562   assemble_name (stream, name);
 563   if (use_pe_aligned_common)
 564     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC ", %d\n",
 565            size ? size : (HOST_WIDE_INT) 1,
 566            exact_log2 (align) - exact_log2 (CHAR_BIT));
 567   else
 568     fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC "\t" ASM_COMMENT_START
 569            " " HOST_WIDE_INT_PRINT_DEC "\n", rounded, size);
 570 }
 571 \f
 572 /* The Microsoft linker requires that every function be marked as
 573    DT_FCN.  When using gas on cygwin, we must emit appropriate .type
 574    directives.  */
 575
 576 #include "gsyms.h"
 577
 578 /* Mark a function appropriately.  This should only be called for
 579    functions for which we are not emitting COFF debugging information.
 580    FILE is the assembler output file, NAME is the name of the
 581    function, and PUB is nonzero if the function is globally
 582    visible.  */
 583
 584 void
 585 i386_pe_declare_function_type (FILE *file, const char *name, int pub)
 586 {
 587   fprintf (file, "\t.def\t");
 588   assemble_name (file, name);
 589   fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
 590            pub ? (int) C_EXT : (int) C_STAT,
 591            (int) DT_FCN << N_BTSHFT);
 592 }
 593
 594 /* Keep a list of external functions.  */
 595
 596 struct GTY(()) extern_list
 597 {
 598   struct extern_list *next;
 599   tree decl;
 600   const char *name;
 601 };
 602
 603 static GTY(()) struct extern_list *extern_head;
 604
 605 /* Assemble an external function reference.  We need to keep a list of
 606    these, so that we can output the function types at the end of the
 607    assembly.  We can't output the types now, because we might see a
 608    definition of the function later on and emit debugging information
 609    for it then.  */
 610
 611 void
 612 i386_pe_record_external_function (tree decl, const char *name)
 613 {
 614   struct extern_list *p;
 615
 616   p = ggc_alloc_extern_list ();
 617   p->next = extern_head;
 618   p->decl = decl;
 619   p->name = name;
 620   extern_head = p;
 621 }
 622
 623 /* Keep a list of exported symbols.  */
 624
 625 struct GTY(()) export_list
 626 {
 627   struct export_list *next;
 628   const char *name;
 629   int is_data;          /* used to type tag exported symbols.  */
 630 };
 631
 632 static GTY(()) struct export_list *export_head;
 633
 634 /* Assemble an export symbol entry.  We need to keep a list of
 635    these, so that we can output the export list at the end of the
 636    assembly.  We used to output these export symbols in each function,
 637    but that causes problems with GNU ld when the sections are
 638    linkonce.  Beware, DECL may be NULL if compile_file() is emitting
 639    the LTO marker.  */
 640
 641 void
 642 i386_pe_maybe_record_exported_symbol (tree decl, const char *name, int is_data)
 643 {
 644   rtx symbol;
 645   struct export_list *p;
 646
 647   if (!decl)
 648     return;
 649
 650   symbol = XEXP (DECL_RTL (decl), 0);
 651   gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
 652   if (!SYMBOL_REF_DLLEXPORT_P (symbol))
 653     return;
 654
 655   gcc_assert (TREE_PUBLIC (decl));
 656
 657   p = ggc_alloc_export_list ();
 658   p->next = export_head;
 659   p->name = name;
 660   p->is_data = is_data;
 661   export_head = p;
 662 }
 663
 664 #ifdef CXX_WRAP_SPEC_LIST
 665
 666 /*  Hash table equality helper function.  */
 667
 668 static int
 669 wrapper_strcmp (const void *x, const void *y)
 670 {
 671   return !strcmp ((const char *) x, (const char *) y);
 672 }
 673
 674 /* Search for a function named TARGET in the list of library wrappers
 675    we are using, returning a pointer to it if found or NULL if not.
 676    This function might be called on quite a few symbols, and we only
 677    have the list of names of wrapped functions available to us as a
 678    spec string, so first time round we lazily initialise a hash table
 679    to make things quicker.  */
 680
 681 static const char *
 682 i386_find_on_wrapper_list (const char *target)
 683 {
 684   static char first_time = 1;
 685   static htab_t wrappers;
 686
 687   if (first_time)
 688     {
 689       /* Beware that this is not a complicated parser, it assumes
 690          that any sequence of non-whitespace beginning with an
 691          underscore is one of the wrapped symbols.  For now that's
 692          adequate to distinguish symbols from spec substitutions
 693          and command-line options.  */
 694       static char wrapper_list_buffer[] = CXX_WRAP_SPEC_LIST;
 695       char *bufptr;
 696       /* Breaks up the char array into separated strings
 697          strings and enter them into the hash table.  */
 698       wrappers = htab_create_alloc (8, htab_hash_string, wrapper_strcmp,
 699         0, xcalloc, free);
 700       for (bufptr = wrapper_list_buffer; *bufptr; ++bufptr)
 701         {
 702           char *found = NULL;
 703           if (ISSPACE (*bufptr))
 704             continue;
 705           if (*bufptr == '_')
 706             found = bufptr;
 707           while (*bufptr && !ISSPACE (*bufptr))
 708             ++bufptr;
 709           if (*bufptr)
 710             *bufptr = 0;
 711           if (found)
 712             *htab_find_slot (wrappers, found, INSERT) = found;
 713         }
 714       first_time = 0;
 715     }
 716
 717   return (const char *) htab_find (wrappers, target);
 718 }
 719
 720 #endif /* CXX_WRAP_SPEC_LIST */
 721
 722 /* This is called at the end of assembly.  For each external function
 723    which has not been defined, we output a declaration now.  We also
 724    output the .drectve section.  */
 725
 726 void
 727 i386_pe_file_end (void)
 728 {
 729   struct extern_list *p;
 730
 731   for (p = extern_head; p != NULL; p = p->next)
 732     {
 733       tree decl;
 734
 735       decl = p->decl;
 736
 737       /* Positively ensure only one declaration for any given symbol.  */
 738       if (! TREE_ASM_WRITTEN (decl)
 739           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
 740         {
 741 #ifdef CXX_WRAP_SPEC_LIST
 742           /* To ensure the DLL that provides the corresponding real
 743              functions is still loaded at runtime, we must reference
 744              the real function so that an (unused) import is created.  */
 745           const char *realsym = i386_find_on_wrapper_list (p->name);
 746           if (realsym)
 747             i386_pe_declare_function_type (asm_out_file,
 748                 concat ("__real_", realsym, NULL), TREE_PUBLIC (decl));
 749 #endif /* CXX_WRAP_SPEC_LIST */
 750           TREE_ASM_WRITTEN (decl) = 1;
 751           i386_pe_declare_function_type (asm_out_file, p->name,
 752                                          TREE_PUBLIC (decl));
 753         }
 754     }
 755
 756   if (export_head)
 757     {
 758       struct export_list *q;
 759       drectve_section ();
 760       for (q = export_head; q != NULL; q = q->next)
 761         {
 762           fprintf (asm_out_file, "\t.ascii \" -export:\\\"%s\\\"%s\"\n",
 763                    default_strip_name_encoding (q->name),
 764                    (q->is_data ? ",data" : ""));
 765         }
 766     }
 767 }
 768
 769 \f
 770 /* x64 Structured Exception Handling unwind info.  */
 771
 772 struct seh_frame_state
 773 {
 774   /* SEH records saves relative to the "current" stack pointer, whether
 775      or not there's a frame pointer in place.  This tracks the current
 776      stack pointer offset from the CFA.  */
 777   HOST_WIDE_INT sp_offset;
 778
 779   /* The CFA is located at CFA_REG + CFA_OFFSET.  */
 780   HOST_WIDE_INT cfa_offset;
 781   rtx cfa_reg;
 782 };
 783
 784 /* Set up data structures beginning output for SEH.  */
 785
 786 void
 787 i386_pe_seh_init (FILE *f)
 788 {
 789   struct seh_frame_state *seh;
 790
 791   if (!TARGET_SEH)
 792     return;
 793   if (cfun->is_thunk)
 794     return;
 795
 796   /* We cannot support DRAP with SEH.  We turned off support for it by
 797      re-defining MAX_STACK_ALIGNMENT when SEH is enabled.  */
 798   gcc_assert (!stack_realign_drap);
 799
 800   seh = XCNEW (struct seh_frame_state);
 801   cfun->machine->seh = seh;
 802
 803   seh->sp_offset = INCOMING_FRAME_SP_OFFSET;
 804   seh->cfa_offset = INCOMING_FRAME_SP_OFFSET;
 805   seh->cfa_reg = stack_pointer_rtx;
 806
 807   fputs ("\t.seh_proc\t", f);
 808   assemble_name (f, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (cfun->decl)));
 809   fputc ('\n', f);
 810 }
 811
 812 void
 813 i386_pe_seh_end_prologue (FILE *f)
 814 {
 815   struct seh_frame_state *seh;
 816
 817   if (!TARGET_SEH)
 818     return;
 819   if (cfun->is_thunk)
 820     return;
 821   seh = cfun->machine->seh;
 822
 823   /* Emit an assembler directive to set up the frame pointer.  Always do
 824      this last.  The documentation talks about doing this "before" any
 825      other code that uses offsets, but (experimentally) that's after we
 826      emit the codes in reverse order (handled by the assembler).  */
 827   if (seh->cfa_reg != stack_pointer_rtx)
 828     {
 829       HOST_WIDE_INT offset = seh->sp_offset - seh->cfa_offset;
 830
 831       gcc_assert ((offset & 15) == 0);
 832       gcc_assert (IN_RANGE (offset, 0, 240));
 833
 834       fputs ("\t.seh_setframe\t", f);
 835       print_reg (seh->cfa_reg, 0, f);
 836       fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
 837     }
 838
 839   XDELETE (seh);
 840   cfun->machine->seh = NULL;
 841
 842   fputs ("\t.seh_endprologue\n", f);
 843 }
 844
 845 static void
 846 i386_pe_seh_fini (FILE *f)
 847 {
 848   if (!TARGET_SEH)
 849     return;
 850   if (cfun->is_thunk)
 851     return;
 852   fputs ("\t.seh_endproc\n", f);
 853 }
 854
 855 /* Emit an assembler directive to save REG via a PUSH.  */
 856
 857 static void
 858 seh_emit_push (FILE *f, struct seh_frame_state *seh, rtx reg)
 859 {
 860   unsigned int regno = REGNO (reg);
 861
 862   gcc_checking_assert (GENERAL_REGNO_P (regno));
 863
 864   seh->sp_offset += UNITS_PER_WORD;
 865   if (seh->cfa_reg == stack_pointer_rtx)
 866     seh->cfa_offset += UNITS_PER_WORD;
 867
 868   fputs ("\t.seh_pushreg\t", f);
 869   print_reg (reg, 0, f);
 870   fputc ('\n', f);
 871 }
 872
 873 /* Emit an assembler directive to save REG at CFA - CFA_OFFSET.  */
 874
 875 static void
 876 seh_emit_save (FILE *f, struct seh_frame_state *seh,
 877                rtx reg, HOST_WIDE_INT cfa_offset)
 878 {
 879   unsigned int regno = REGNO (reg);
 880   HOST_WIDE_INT offset;
 881
 882   /* Negative save offsets are of course not supported, since that
 883      would be a store below the stack pointer and thus clobberable.  */
 884   gcc_assert (seh->sp_offset >= cfa_offset);
 885   offset = seh->sp_offset - cfa_offset;
 886
 887   fputs ((SSE_REGNO_P (regno) ? "\t.seh_savexmm\t"
 888          : GENERAL_REGNO_P (regno) ?  "\t.seh_savereg\t"
 889          : (gcc_unreachable (), "")), f);
 890   print_reg (reg, 0, f);
 891   fprintf (f, ", " HOST_WIDE_INT_PRINT_DEC "\n", offset);
 892 }
 893
 894 /* Emit an assembler directive to adjust RSP by OFFSET.  */
 895
 896 static void
 897 seh_emit_stackalloc (FILE *f, struct seh_frame_state *seh,
 898                      HOST_WIDE_INT offset)
 899 {
 900   /* We're only concerned with prologue stack allocations, which all
 901      are subtractions from the stack pointer.  */
 902   gcc_assert (offset < 0);
 903   offset = -offset;
 904
 905   if (seh->cfa_reg == stack_pointer_rtx)
 906     seh->cfa_offset += offset;
 907   seh->sp_offset += offset;
 908
 909   fprintf (f, "\t.seh_stackalloc\t" HOST_WIDE_INT_PRINT_DEC "\n", offset);
 910 }
 911
 912 /* Process REG_CFA_ADJUST_CFA for SEH.  */
 913
 914 static void
 915 seh_cfa_adjust_cfa (FILE *f, struct seh_frame_state *seh, rtx pat)
 916 {
 917   rtx dest, src;
 918   HOST_WIDE_INT reg_offset = 0;
 919   unsigned int dest_regno;
 920
 921   dest = SET_DEST (pat);
 922   src = SET_SRC (pat);
 923
 924   if (GET_CODE (src) == PLUS)
 925     {
 926       reg_offset = INTVAL (XEXP (src, 1));
 927       src = XEXP (src, 0);
 928     }
 929   else if (GET_CODE (src) == MINUS)
 930     {
 931       reg_offset = -INTVAL (XEXP (src, 1));
 932       src = XEXP (src, 0);
 933     }
 934   gcc_assert (src == stack_pointer_rtx);
 935   gcc_assert (seh->cfa_reg == stack_pointer_rtx);
 936   dest_regno = REGNO (dest);
 937
 938   if (dest_regno == STACK_POINTER_REGNUM)
 939     seh_emit_stackalloc (f, seh, reg_offset);
 940   else if (dest_regno == HARD_FRAME_POINTER_REGNUM)
 941     {
 942       seh->cfa_reg = dest;
 943       seh->cfa_offset -= reg_offset;
 944     }
 945   else
 946     gcc_unreachable ();
 947 }
 948
 949 /* Process REG_CFA_OFFSET for SEH.  */
 950
 951 static void
 952 seh_cfa_offset (FILE *f, struct seh_frame_state *seh, rtx pat)
 953 {
 954   rtx dest, src;
 955   HOST_WIDE_INT reg_offset;
 956
 957   dest = SET_DEST (pat);
 958   src = SET_SRC (pat);
 959
 960   gcc_assert (MEM_P (dest));
 961   dest = XEXP (dest, 0);
 962   if (REG_P (dest))
 963     reg_offset = 0;
 964   else
 965     {
 966       gcc_assert (GET_CODE (dest) == PLUS);
 967       reg_offset = INTVAL (XEXP (dest, 1));
 968       dest = XEXP (dest, 0);
 969     }
 970   gcc_assert (dest == seh->cfa_reg);
 971
 972   seh_emit_save (f, seh, src, seh->cfa_offset - reg_offset);
 973 }
 974
 975 /* Process a FRAME_RELATED_EXPR for SEH.  */
 976
 977 static void
 978 seh_frame_related_expr (FILE *f, struct seh_frame_state *seh, rtx pat)
 979 {
 980   rtx dest, src;
 981   HOST_WIDE_INT addend;
 982
 983   /* See the full loop in dwarf2out_frame_debug_expr.  */
 984   if (GET_CODE (pat) == PARALLEL || GET_CODE (pat) == SEQUENCE)
 985     {
 986       int i, n = XVECLEN (pat, 0), pass, npass;
 987
 988       npass = (GET_CODE (pat) == PARALLEL ? 2 : 1);
 989       for (pass = 0; pass < npass; ++pass)
 990         for (i = 0; i < n; ++i)
 991           {
 992             rtx ele = XVECEXP (pat, 0, i);
 993
 994             if (GET_CODE (ele) != SET)
 995               continue;
 996             dest = SET_DEST (ele);
 997
 998             /* Process each member of the PARALLEL independently.  The first
 999                member is always processed; others only if they are marked.  */
1000             if (i == 0 || RTX_FRAME_RELATED_P (ele))
1001               {
1002                 /* Evaluate all register saves in the first pass and all
1003                    register updates in the second pass.  */
1004                 if ((MEM_P (dest) ^ pass) || npass == 1)
1005                   seh_frame_related_expr (f, seh, ele);
1006               }
1007           }
1008       return;
1009     }
1010
1011   dest = SET_DEST (pat);
1012   src = SET_SRC (pat);
1013
1014   switch (GET_CODE (dest))
1015     {
1016     case REG:
1017       switch (GET_CODE (src))
1018         {
1019         case REG:
1020           /* REG = REG: This should be establishing a frame pointer.  */
1021           gcc_assert (src == stack_pointer_rtx);
1022           gcc_assert (dest == hard_frame_pointer_rtx);
1023           seh_cfa_adjust_cfa (f, seh, pat);
1024           break;
1025
1026         case PLUS:
1027           addend = INTVAL (XEXP (src, 1));
1028           src = XEXP (src, 0);
1029           if (dest == hard_frame_pointer_rtx)
1030             seh_cfa_adjust_cfa (f, seh, pat);
1031           else if (dest == stack_pointer_rtx)
1032             {
1033               gcc_assert (src == stack_pointer_rtx);
1034               seh_emit_stackalloc (f, seh, addend);
1035             }
1036           else
1037             gcc_unreachable ();
1038           break;
1039
1040         default:
1041           gcc_unreachable ();
1042         }
1043       break;
1044
1045     case MEM:
1046       /* A save of some kind.  */
1047       dest = XEXP (dest, 0);
1048       if (GET_CODE (dest) == PRE_DEC)
1049         {
1050           gcc_checking_assert (GET_MODE (src) == Pmode);
1051           gcc_checking_assert (REG_P (src));
1052           seh_emit_push (f, seh, src);
1053         }
1054       else
1055         seh_cfa_offset (f, seh, pat);
1056       break;
1057
1058     default:
1059       gcc_unreachable ();
1060     }
1061 }
1062
1063 /* This function looks at a single insn and emits any SEH directives
1064    required for unwind of this insn.  */
1065
1066 void
1067 i386_pe_seh_unwind_emit (FILE *asm_out_file, rtx insn)
1068 {
1069   rtx note, pat;
1070   bool handled_one = false;
1071   struct seh_frame_state *seh;
1072
1073   if (!TARGET_SEH)
1074     return;
1075
1076   /* We free the SEH data once done with the prologue.  Ignore those
1077      RTX_FRAME_RELATED_P insns that are associated with the epilogue.  */
1078   seh = cfun->machine->seh;
1079   if (seh == NULL)
1080     return;
1081
1082   if (NOTE_P (insn) || !RTX_FRAME_RELATED_P (insn))
1083     return;
1084
1085   for (note = REG_NOTES (insn); note ; note = XEXP (note, 1))
1086     {
1087       pat = XEXP (note, 0);
1088       switch (REG_NOTE_KIND (note))
1089         {
1090         case REG_FRAME_RELATED_EXPR:
1091           goto found;
1092
1093         case REG_CFA_DEF_CFA:
1094         case REG_CFA_EXPRESSION:
1095           /* Only emitted with DRAP, which we disable.  */
1096           gcc_unreachable ();
1097           break;
1098
1099         case REG_CFA_REGISTER:
1100           /* Only emitted in epilogues, which we skip.  */
1101           gcc_unreachable ();
1102
1103         case REG_CFA_ADJUST_CFA:
1104           if (pat == NULL)
1105             {
1106               pat = PATTERN (insn);
1107               if (GET_CODE (pat) == PARALLEL)
1108                 pat = XVECEXP (pat, 0, 0);
1109             }
1110           seh_cfa_adjust_cfa (asm_out_file, seh, pat);
1111           handled_one = true;
1112           break;
1113
1114         case REG_CFA_OFFSET:
1115           if (pat == NULL)
1116             pat = single_set (insn);
1117           seh_cfa_offset (asm_out_file, seh, pat);
1118           handled_one = true;
1119           break;
1120
1121         default:
1122           break;
1123         }
1124     }
1125   if (handled_one)
1126     return;
1127   pat = PATTERN (insn);
1128  found:
1129   seh_frame_related_expr (asm_out_file, seh, pat);
1130 }
1131 \f
1132 void
1133 i386_pe_start_function (FILE *f, const char *name, tree decl)
1134 {
1135   i386_pe_maybe_record_exported_symbol (decl, name, 0);
1136   if (write_symbols != SDB_DEBUG)
1137     i386_pe_declare_function_type (f, name, TREE_PUBLIC (decl));
1138   /* In case section was altered by debugging output.  */
1139   if (decl != NULL_TREE)
1140     switch_to_section (function_section (decl));
1141   ASM_OUTPUT_FUNCTION_LABEL (f, name, decl);
1142 }
1143
1144 void
1145 i386_pe_end_function (FILE *f, const char *name ATTRIBUTE_UNUSED,
1146                       tree decl ATTRIBUTE_UNUSED)
1147 {
1148   i386_pe_seh_fini (f);
1149 }
1150 \f
1151
1152 #include "gt-winnt.h"