gcc/config/i386/i386-interix.h

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