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