gcc/config/i386/i386-interix.h

   1 /* Target definitions for GNU compiler for Intel 80386 running Interix
   2    Parts Copyright (C) 1991, 1999, 2000, 2002 Free Software Foundation, Inc.
   3
   4    Parts:
   5      by Douglas B. Rupp (drupp@cs.washington.edu).
   6      by Ron Guilmette (rfg@netcom.com).
   7      by Donn Terry (donn@softway.com).
   8      by Mumit Khan (khan@xraylith.wisc.edu).
   9
  10 This file is part of GNU CC.
  11
  12 GNU CC is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2, or (at your option)
  15 any later version.
  16
  17 GNU CC is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GNU CC; see the file COPYING.  If not, write to
  24 the Free Software Foundation, 59 Temple Place - Suite 330,
  25 Boston, MA 02111-1307, USA.  */
  26
  27 /* The rest must follow.  */
  28
  29 #define DBX_DEBUGGING_INFO
  30 #define SDB_DEBUGGING_INFO
  31 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
  32
  33 #define HANDLE_SYSV_PRAGMA
  34 #undef HANDLE_PRAGMA_WEAK  /* until the link format can handle it */
  35
  36 /* By default, target has a 80387, uses IEEE compatible arithmetic,
  37    and returns float values in the 387 and needs stack probes
  38    We also align doubles to 64-bits for MSVC default compatibility */
  39 #undef TARGET_SUBTARGET_DEFAULT
  40 #define TARGET_SUBTARGET_DEFAULT \
  41    (MASK_80387 | MASK_IEEE_FP | MASK_FLOAT_RETURNS | MASK_STACK_PROBE | \
  42     MASK_ALIGN_DOUBLE)
  43
  44 #undef TARGET_CPU_DEFAULT
  45 #define TARGET_CPU_DEFAULT 2 /* 486 */
  46
  47 #define WCHAR_TYPE_SIZE 16
  48 #define WCHAR_TYPE "short unsigned int"
  49
  50 /* WinNT (and thus Interix) use unsigned int */
  51 #define SIZE_TYPE "unsigned int"
  52
  53 #define ASM_LOAD_ADDR(loc, reg)   "     leal " #loc "," #reg "\n"
  54
  55 /* cpp handles __STDC__ */
  56 #undef CPP_PREDEFINES
  57 #define CPP_PREDEFINES " \
  58   -D__INTERIX \
  59   -D__OPENNT \
  60   -D_M_IX86=300 -D_X86_=1 \
  61   -D__stdcall=__attribute__((__stdcall__)) \
  62   -D__cdecl=__attribute__((__cdecl__)) \
  63   -D__declspec(x)=__attribute__((x)) \
  64   -Asystem=unix -Asystem=interix"
  65
  66 #undef CPP_SPEC
  67 /* Write out the correct language type definition for the header files.
  68    Unless we have assembler language, write out the symbols for C.
  69    cpp_cpu is an Intel specific variant. See i386.h
  70    mieee is an Alpha specific variant.  Cross polination a bad idea.
  71    */
  72 #define CPP_SPEC "\
  73 %{!.S:  -D__LANGUAGE_C__ -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C}}  \
  74 %{.S:   -D__LANGUAGE_ASSEMBLY__ -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \
  75 %{.cc:  -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  76 %{.cxx: -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  77 %{.C:   -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  78 %{.m:   -D__LANGUAGE_OBJECTIVE_C__ -D__LANGUAGE_OBJECTIVE_C} \
  79 -remap \
  80 %(cpp_cpu) \
  81 %{posix:-D_POSIX_SOURCE} \
  82 -isystem %$INTERIX_ROOT/usr/include"
  83
  84 #define TARGET_VERSION fprintf (stderr, " (i386 Interix)");
  85
  86 /* The global __fltused is necessary to cause the printf/scanf routines
  87    for outputting/inputting floating point numbers to be loaded.  Since this
  88    is kind of hard to detect, we just do it all the time.  */
  89
  90 #ifdef ASM_FILE_START
  91 #undef ASM_FILE_START
  92 #endif
  93 #define ASM_FILE_START(FILE) \
  94   do {  fprintf (FILE, "\t.file\t");                            \
  95         output_quoted_string (FILE, dump_base_name);            \
  96         fprintf (FILE, "\n");                                   \
  97         fprintf (FILE, ".global\t__fltused\n");                 \
  98   } while (0)
  99
 100 /* A table of bytes codes used by the ASM_OUTPUT_ASCII and
 101    ASM_OUTPUT_LIMITED_STRING macros.  Each byte in the table
 102    corresponds to a particular byte value [0..255].  For any
 103    given byte value, if the value in the corresponding table
 104    position is zero, the given character can be output directly.
 105    If the table value is 1, the byte must be output as a \ooo
 106    octal escape.  If the tables value is anything else, then the
 107    byte value should be output as a \ followed by the value
 108    in the table.  Note that we can use standard UN*X escape
 109    sequences for many control characters, but we don't use
 110    \a to represent BEL because some svr4 assemblers (e.g. on
 111    the i386) don't know about that.  Also, we don't use \v
 112    since some versions of gas, such as 2.2 did not accept it.  */
 113
 114 #define ESCAPES \
 115 "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 116 \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
 117 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\
 118 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\
 119 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 120 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 121 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\
 122 \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1"
 123
 124 /* Some svr4 assemblers have a limit on the number of characters which
 125    can appear in the operand of a .string directive.  If your assembler
 126    has such a limitation, you should define STRING_LIMIT to reflect that
 127    limit.  Note that at least some svr4 assemblers have a limit on the
 128    actual number of bytes in the double-quoted string, and that they
 129    count each character in an escape sequence as one byte.  Thus, an
 130    escape sequence like \377 would count as four bytes.
 131
 132    If your target assembler doesn't support the .string directive, you
 133    should define this to zero.
 134 */
 135
 136 #define STRING_LIMIT    ((unsigned) 256)
 137
 138 #define STRING_ASM_OP   "\t.string\t"
 139
 140 /* The routine used to output NUL terminated strings.  We use a special
 141    version of this for most svr4 targets because doing so makes the
 142    generated assembly code more compact (and thus faster to assemble)
 143    as well as more readable, especially for targets like the i386
 144    (where the only alternative is to output character sequences as
 145    comma separated lists of numbers).   */
 146
 147 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)                            \
 148   do                                                                    \
 149     {                                                                   \
 150       register const unsigned char *_limited_str =                      \
 151         (const unsigned char *) (STR);                                  \
 152       register unsigned ch;                                             \
 153       fprintf ((FILE), "%s\"", STRING_ASM_OP);                          \
 154       for (; (ch = *_limited_str); _limited_str++)                      \
 155         {                                                               \
 156           register int escape = ESCAPES[ch];                            \
 157           switch (escape)                                               \
 158             {                                                           \
 159             case 0:                                                     \
 160               putc (ch, (FILE));                                        \
 161               break;                                                    \
 162             case 1:                                                     \
 163               fprintf ((FILE), "\\%03o", ch);                           \
 164               break;                                                    \
 165             default:                                                    \
 166               putc ('\\', (FILE));                                      \
 167               putc (escape, (FILE));                                    \
 168               break;                                                    \
 169             }                                                           \
 170         }                                                               \
 171       fprintf ((FILE), "\"\n");                                         \
 172     }                                                                   \
 173   while (0)
 174
 175 /* The routine used to output sequences of byte values.  We use a special
 176    version of this for most svr4 targets because doing so makes the
 177    generated assembly code more compact (and thus faster to assemble)
 178    as well as more readable.  Note that if we find subparts of the
 179    character sequence which end with NUL (and which are shorter than
 180    STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING.  */
 181
 182 #undef ASM_OUTPUT_ASCII
 183 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 184   do                                                                    \
 185     {                                                                   \
 186       register const unsigned char *_ascii_bytes =                      \
 187         (const unsigned char *) (STR);                                  \
 188       register const unsigned char *limit = _ascii_bytes + (LENGTH);    \
 189       register unsigned bytes_in_chunk = 0;                             \
 190       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 191         {                                                               \
 192           register const unsigned char *p;                              \
 193           if (bytes_in_chunk >= 64)                                     \
 194             {                                                           \
 195               fputc ('\n', (FILE));                                     \
 196               bytes_in_chunk = 0;                                       \
 197             }                                                           \
 198           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 199             continue;                                                   \
 200           if (p < limit && (p - _ascii_bytes) <= (long) STRING_LIMIT)   \
 201             {                                                           \
 202               if (bytes_in_chunk > 0)                                   \
 203                 {                                                       \
 204                   fputc ('\n', (FILE));                                 \
 205                   bytes_in_chunk = 0;                                   \
 206                 }                                                       \
 207               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 208               _ascii_bytes = p;                                         \
 209             }                                                           \
 210           else                                                          \
 211             {                                                           \
 212               if (bytes_in_chunk == 0)                                  \
 213                 fprintf ((FILE), "\t.byte\t");                          \
 214               else                                                      \
 215                 fputc (',', (FILE));                                    \
 216               fprintf ((FILE), "0x%02x", *_ascii_bytes);                \
 217               bytes_in_chunk += 5;                                      \
 218             }                                                           \
 219         }                                                               \
 220       if (bytes_in_chunk > 0)                                           \
 221         fprintf ((FILE), "\n");                                         \
 222     }                                                                   \
 223   while (0)
 224
 225 /* Emit code to check the stack when allocating more that 4000
 226    bytes in one go.  */
 227
 228 #define CHECK_STACK_LIMIT 0x1000
 229
 230 /* the following are OSF linker (not gld) specific... we don't want them */
 231 #undef HAS_INIT_SECTION
 232 #undef LD_INIT_SWITCH
 233 #undef LD_FINI_SWITCH
 234
 235 #define EH_FRAME_IN_DATA_SECTION
 236
 237 #define USE_CONST_SECTION       1
 238
 239 #define CONST_SECTION_ASM_OP    "\t.section\t.rdata,\"r\""
 240
 241 /* A default list of other sections which we might be "in" at any given
 242    time.  For targets that use additional sections (e.g. .tdesc) you
 243    should override this definition in the target-specific file which
 244    includes this file.  */
 245
 246 #undef EXTRA_SECTIONS
 247 #define EXTRA_SECTIONS in_const
 248
 249 /* A default list of extra section function definitions.  For targets
 250    that use additional sections (e.g. .tdesc) you should override this
 251    definition in the target-specific file which includes this file.  */
 252
 253 #undef EXTRA_SECTION_FUNCTIONS
 254 #define EXTRA_SECTION_FUNCTIONS                                         \
 255   CONST_SECTION_FUNCTION
 256
 257 #undef READONLY_DATA_SECTION
 258 #define READONLY_DATA_SECTION() const_section ()
 259
 260 #define CONST_SECTION_FUNCTION                                          \
 261 void                                                                    \
 262 const_section ()                                                        \
 263 {                                                                       \
 264   if (!USE_CONST_SECTION)                                               \
 265     text_section();                                                     \
 266   else if (in_section != in_const)                                      \
 267     {                                                                   \
 268       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);             \
 269       in_section = in_const;                                            \
 270     }                                                                   \
 271 }
 272
 273 /* The MS compilers take alignment as a number of bytes, so we do as well */
 274 #undef ASM_OUTPUT_ALIGN
 275 #define ASM_OUTPUT_ALIGN(FILE,LOG) \
 276   if ((LOG)!=0) fprintf ((FILE), "\t.balign %d\n", 1<<(LOG))
 277
 278 /* The linker will take care of this, and having them causes problems with
 279    ld -r (specifically -rU).  */
 280 #define CTOR_LISTS_DEFINED_EXTERNALLY 1
 281
 282 #define SET_ASM_OP      "\t.set\t"
 283 /* Output a definition (implements alias) */
 284 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
 285 do                                                                      \
 286 {                                                                       \
 287     fprintf ((FILE), "%s", SET_ASM_OP);                                 \
 288     assemble_name (FILE, LABEL1);                                       \
 289     fprintf (FILE, ",");                                                \
 290     assemble_name (FILE, LABEL2);                                       \
 291     fprintf (FILE, "\n");                                               \
 292     }                                                                   \
 293 while (0)
 294
 295 #define HOST_PTR_PRINTF "%p"
 296 #define HOST_PTR_AS_INT unsigned long
 297
 298 #define PCC_BITFIELD_TYPE_MATTERS 1
 299 #define PCC_BITFIELD_TYPE_TEST TYPE_NATIVE(rec)
 300 #define GROUP_BITFIELDS_BY_ALIGN TYPE_NATIVE(rec)
 301
 302 /* The following two flags are usually "off" for i386, because some non-gnu
 303    tools (for the i386) don't handle them.  However, we don't have that
 304    problem, so....  */
 305
 306 /* Forward references to tags are allowed.  */
 307 #define SDB_ALLOW_FORWARD_REFERENCES
 308
 309 /* Unknown tags are also allowed.  */
 310 #define SDB_ALLOW_UNKNOWN_REFERENCES
 311
 312 /* The integer half of this list needs to be constant.  However, there's
 313    a lot of disagreement about what the floating point adjustments should
 314    be.  We pick one that works with gdb.  (The underlying problem is
 315    what to do about the segment registers.  Since we have access to them
 316    from /proc, we'll allow them to be accessed in gdb, even tho the
 317    gcc compiler can't generate them.  (There's some evidence that
 318    MSVC does, but possibly only for certain special "canned" sequences.) */
 319
 320 #undef DBX_REGISTER_NUMBER
 321 #define DBX_REGISTER_NUMBER(n) \
 322 (TARGET_64BIT ? dbx64_register_map[n] \
 323  : (n) == 0 ? 0 \
 324  : (n) == 1 ? 2 \
 325  : (n) == 2 ? 1 \
 326  : (n) == 3 ? 3 \
 327  : (n) == 4 ? 6 \
 328  : (n) == 5 ? 7 \
 329  : (n) == 6 ? 5 \
 330  : (n) == 7 ? 4 \
 331  : ((n) >= FIRST_STACK_REG && (n) <= LAST_STACK_REG) ? (n)+8 \
 332  : (-1))
 333
 334 /* Define this macro if references to a symbol must be treated
 335    differently depending on something about the variable or
 336    function named by the symbol (such as what section it is in).
 337
 338    Apply stddef, handle (as yet unimplemented) pic.
 339
 340    stddef renaming does NOT apply to Alpha.  */
 341
 342 union tree_node;
 343 const char *gen_stdcall_suffix PARAMS ((union tree_node *));
 344
 345 #undef ENCODE_SECTION_INFO
 346 #define ENCODE_SECTION_INFO(DECL, FIRST)                                \
 347 do                                                                      \
 348   {                                                                     \
 349     if (flag_pic)                                                       \
 350       {                                                                 \
 351         rtx rtl = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd'            \
 352                    ? TREE_CST_RTL (DECL) : DECL_RTL (DECL));            \
 353         SYMBOL_REF_FLAG (XEXP (rtl, 0))                                 \
 354           = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd'                  \
 355              || ! TREE_PUBLIC (DECL));                                  \
 356       }                                                                 \
 357     if ((FIRST) && TREE_CODE (DECL) == FUNCTION_DECL)                   \
 358       if (lookup_attribute ("stdcall",                                  \
 359                             TYPE_ATTRIBUTES (TREE_TYPE (DECL))))        \
 360         XEXP (DECL_RTL (DECL), 0) =                                     \
 361           gen_rtx (SYMBOL_REF, Pmode, gen_stdcall_suffix (DECL));       \
 362   }                                                                     \
 363 while (0)
 364
 365 /* This macro gets just the user-specified name
 366    out of the string in a SYMBOL_REF.  Discard
 367    trailing @[NUM] encoded by ENCODE_SECTION_INFO.  */
 368 #undef  STRIP_NAME_ENCODING
 369 #define STRIP_NAME_ENCODING(VAR,SYMBOL_NAME)                            \
 370 do {                                                                    \
 371   const char *_p;                                                       \
 372   const char *_name = SYMBOL_NAME;                                      \
 373   for (_p = _name; *_p && *_p != '@'; ++_p)                             \
 374     ;                                                                   \
 375   if (*_p == '@')                                                       \
 376     {                                                                   \
 377       int _len = _p - _name;                                            \
 378       char *_new_name = (char *) alloca (_len + 1);                     \
 379       strncpy (_new_name, _name, _len);                                 \
 380       _new_name[_len] = '\0';                                           \
 381       (VAR) = _new_name;                                                \
 382     }                                                                   \
 383   else                                                                  \
 384     (VAR) = _name;                                                      \
 385 } while (0)
 386
 387 #if 0
 388 /* Turn this back on when the linker is updated to handle grouped
 389    .data$ sections correctly. See corresponding note in i386/interix.c.
 390    MK.  */
 391
 392 /* Define this macro if in some cases global symbols from one translation
 393    unit may not be bound to undefined symbols in another translation unit
 394    without user intervention.  For instance, under Microsoft Windows
 395    symbols must be explicitly imported from shared libraries (DLLs).  */
 396 #define MULTIPLE_SYMBOL_SPACES
 397
 398 extern void i386_pe_unique_section PARAMS ((tree, int));
 399 #define TARGET_ASM_UNIQUE_SECTION i386_pe_unique_section
 400
 401 #define SUPPORTS_ONE_ONLY 1
 402 #endif /* 0 */
 403
 404 /* Switch into a generic section.  */
 405 #define TARGET_ASM_NAMED_SECTION  default_pe_asm_named_section
 406
 407 /* DWARF2 Unwinding doesn't work with exception handling yet.  */
 408 #define DWARF2_UNWIND_INFO 0
 409
 410 /* Don't assume anything about the header files.  */
 411 #define NO_IMPLICIT_EXTERN_C
 412
 413 /* MSVC returns structs of up to 8 bytes via registers. */
 414
 415 #define DEFAULT_PCC_STRUCT_RETURN 0
 416
 417 #undef RETURN_IN_MEMORY
 418 #define RETURN_IN_MEMORY(TYPE) \
 419   (TYPE_MODE (TYPE) == BLKmode || \
 420      (AGGREGATE_TYPE_P (TYPE) && int_size_in_bytes(TYPE) > 8 ))