gcc/config/i386/sco5.h

   1 /* Definitions for Intel 386 running SCO Unix System V 3.2 Version 5.
   2    Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2002
   3    Free Software Foundation, Inc.
   4    Contributed by Kean Johnston (hug@netcom.com)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #define TARGET_VERSION fprintf (stderr, " (i386, SCO OpenServer 5 Syntax)");
  24
  25 #undef LPREFIX
  26 #define LPREFIX                         ".L"
  27
  28 #undef ALIGN_ASM_OP
  29 #define ALIGN_ASM_OP                    "\t.align\t"
  30
  31 #undef ASCII_DATA_ASM_OP
  32 #define ASCII_DATA_ASM_OP               "\t.ascii\t"
  33
  34 #undef IDENT_ASM_OP
  35 #define IDENT_ASM_OP                    "\t.ident\t"
  36
  37 #undef COMMON_ASM_OP
  38 #define COMMON_ASM_OP                   "\t.comm\t"
  39
  40 #undef SET_ASM_OP
  41 #define SET_ASM_OP                      "\t.set\t"
  42
  43 #undef LOCAL_ASM_OP
  44 #define LOCAL_ASM_OP                    "\t.local\t"
  45
  46 #undef ASM_SHORT
  47 #define ASM_SHORT                       "\t.value\t"
  48
  49 #undef ASM_LONG
  50 #define ASM_LONG                        "\t.long\t"
  51
  52 #undef ASM_QUAD
  53
  54 #undef TYPE_ASM_OP
  55 #define TYPE_ASM_OP                     "\t.type\t"
  56
  57 #undef SIZE_ASM_OP
  58 #define SIZE_ASM_OP                     "\t.size\t"
  59
  60 #undef STRING_ASM_OP
  61 #define STRING_ASM_OP                   "\t.string\t"
  62
  63 #undef SKIP_ASM_OP
  64 #define SKIP_ASM_OP                     "\t.zero\t"
  65
  66 #undef GLOBAL_ASM_OP
  67 #define GLOBAL_ASM_OP                   "\t.globl\t"
  68
  69 #undef EH_FRAME_SECTION_ASM_OP
  70 #define EH_FRAME_SECTION_NAME_COFF      ".ehfram"
  71 #define EH_FRAME_SECTION_NAME_ELF       ".eh_frame"
  72 #define EH_FRAME_SECTION_NAME   \
  73   ((TARGET_ELF) ? EH_FRAME_SECTION_NAME_ELF : EH_FRAME_SECTION_NAME_COFF)
  74
  75 /* Avoid problems (long sectino names, forward assembler refs) with DWARF
  76    exception unwinding when we're generating COFF */
  77 #define DWARF2_UNWIND_INFO      \
  78   ((TARGET_ELF) ? 1 : 0 )
  79
  80 #undef READONLY_DATA_SECTION_ASM_OP
  81 #define READONLY_DATA_SECTION_ASM_OP_COFF       "\t.section\t.rodata, \"x\""
  82 #define READONLY_DATA_SECTION_ASM_OP_ELF        "\t.section\t.rodata"
  83 #define READONLY_DATA_SECTION_ASM_OP            \
  84   ((TARGET_ELF)                                 \
  85    ? READONLY_DATA_SECTION_ASM_OP_ELF           \
  86    : READONLY_DATA_SECTION_ASM_OP_COFF)
  87
  88 #undef INIT_SECTION_ASM_OP
  89 #define INIT_SECTION_ASM_OP_ELF         "\t.section\t.init"
  90 /* Rename these for COFF because crt1.o will try to run them.  */
  91 #define INIT_SECTION_ASM_OP_COFF        "\t.section\t.ctor ,\"x\""
  92 #define INIT_SECTION_ASM_OP     \
  93   ((TARGET_ELF) ? INIT_SECTION_ASM_OP_ELF : INIT_SECTION_ASM_OP_COFF)
  94
  95 #undef CTORS_SECTION_ASM_OP
  96 #define CTORS_SECTION_ASM_OP_ELF        "\t.section\t.ctors,\"aw\""
  97 #define CTORS_SECTION_ASM_OP_COFF       INIT_SECTION_ASM_OP_COFF
  98 #define CTORS_SECTION_ASM_OP    \
  99  ((TARGET_ELF) ? CTORS_SECTION_ASM_OP_ELF : CTORS_SECTION_ASM_OP_COFF)
 100
 101 #undef DTORS_SECTION_ASM_OP
 102 #define DTORS_SECTION_ASM_OP_ELF        "\t.section\t.dtors, \"aw\""
 103 #define DTORS_SECTION_ASM_OP_COFF       FINI_SECTION_ASM_OP_COFF
 104 #define DTORS_SECTION_ASM_OP    \
 105  ((TARGET_ELF) ? DTORS_SECTION_ASM_OP_ELF : DTORS_SECTION_ASM_OP_COFF)
 106
 107 #undef FINI_SECTION_ASM_OP
 108 #define FINI_SECTION_ASM_OP_ELF         "\t.section\t.fini"
 109 #define FINI_SECTION_ASM_OP_COFF        "\t.section\t.dtor, \"x\""
 110 #define FINI_SECTION_ASM_OP     \
 111  ((TARGET_ELF) ? FINI_SECTION_ASM_OP_ELF : FINI_SECTION_ASM_OP_COFF)
 112
 113 #undef BSS_SECTION_ASM_OP
 114 #define BSS_SECTION_ASM_OP              "\t.data"
 115
 116 #undef TEXT_SECTION_ASM_OP
 117 #define TEXT_SECTION_ASM_OP             "\t.text"
 118
 119 #undef DATA_SECTION_ASM_OP
 120 #define DATA_SECTION_ASM_OP             "\t.data"
 121
 122 #undef TYPE_OPERAND_FMT
 123 #define TYPE_OPERAND_FMT                "@%s"
 124
 125 #undef APPLY_RESULT_SIZE
 126 #define APPLY_RESULT_SIZE                                               \
 127 (TARGET_ELF) ? size : 116
 128
 129 #ifndef ASM_DECLARE_RESULT
 130 #define ASM_DECLARE_RESULT(FILE, RESULT)
 131 #endif
 132
 133 #define SCO_DEFAULT_ASM_COFF(FILE,NAME)                                 \
 134 do {                                                                    \
 135       ASM_OUTPUT_LABEL (FILE, NAME);                                    \
 136   } while (0)
 137
 138 #undef ASM_DECLARE_FUNCTION_NAME
 139 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
 140   do {                                                                  \
 141     if (TARGET_ELF) {                                                   \
 142       fprintf (FILE, "%s", TYPE_ASM_OP);                                \
 143       assemble_name (FILE, NAME);                                       \
 144       putc (',', FILE);                                                 \
 145       fprintf (FILE, TYPE_OPERAND_FMT, "function");                     \
 146       putc ('\n', FILE);                                                \
 147       ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));                    \
 148       ASM_OUTPUT_LABEL(FILE, NAME);                                     \
 149     } else                                                              \
 150       SCO_DEFAULT_ASM_COFF(FILE, NAME);                                 \
 151 } while (0)
 152
 153 #undef ASM_DECLARE_FUNCTION_SIZE
 154 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                    \
 155   do {                                                                  \
 156     if (TARGET_ELF) { if (!flag_inhibit_size_directive)                 \
 157       {                                                                 \
 158         fprintf (FILE, "%s", SIZE_ASM_OP);                              \
 159         assemble_name (FILE, (FNAME));                                  \
 160         fprintf (FILE, ",.-");                                          \
 161         assemble_name (FILE, (FNAME));                                  \
 162         putc ('\n', FILE);                                              \
 163       } }                                                               \
 164   } while (0)
 165
 166 #undef ASM_DECLARE_OBJECT_NAME
 167 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)                       \
 168   do {                                                                  \
 169     if (TARGET_ELF) {                                                   \
 170       fprintf (FILE, "%s", TYPE_ASM_OP);                                \
 171       assemble_name (FILE, NAME);                                       \
 172       putc (',', FILE);                                                 \
 173       fprintf (FILE, TYPE_OPERAND_FMT, "object");                       \
 174       putc ('\n', FILE);                                                \
 175       size_directive_output = 0;                                        \
 176       if (!flag_inhibit_size_directive && DECL_SIZE (DECL))             \
 177         {                                                               \
 178         size_directive_output = 1;                                      \
 179         fprintf (FILE, "%s", SIZE_ASM_OP);                              \
 180         assemble_name (FILE, NAME);                                     \
 181         fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 182         }                                                               \
 183       ASM_OUTPUT_LABEL(FILE, NAME);                                     \
 184     } else                                                              \
 185       SCO_DEFAULT_ASM_COFF(FILE, NAME);                                 \
 186   } while (0)
 187
 188 #undef ASM_FILE_START_1
 189 #define ASM_FILE_START_1(FILE)
 190
 191 #undef ASM_FILE_START
 192 #define ASM_FILE_START(FILE)                                            \
 193 do {                                                                    \
 194   output_file_directive((FILE),main_input_filename);                    \
 195   fprintf ((FILE), "\t.version\t\"01.01\"\n");                          \
 196 } while (0)
 197
 198 #undef ASM_FINISH_DECLARE_OBJECT
 199 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)         \
 200 do {                                                                     \
 201   if (TARGET_ELF) {                                                     \
 202      const char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);             \
 203      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)                \
 204          && ! AT_END && TOP_LEVEL                                        \
 205          && DECL_INITIAL (DECL) == error_mark_node                       \
 206          && !size_directive_output)                                      \
 207        {                                                                 \
 208          size_directive_output = 1;                                      \
 209          fprintf (FILE, "%s", SIZE_ASM_OP);                              \
 210          assemble_name (FILE, name);                                     \
 211          fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 212        }                                                                 \
 213     }                                                                    \
 214 } while (0)
 215
 216 #undef ASM_GENERATE_INTERNAL_LABEL
 217 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM)                 \
 218 do {                                                                    \
 219   if (TARGET_ELF)                                                       \
 220     sprintf (LABEL, "*.%s%ld", (PREFIX), (long)(NUM));                  \
 221   else                                                                  \
 222     sprintf (LABEL, ".%s%ld", (PREFIX), (long)(NUM));                   \
 223 } while (0)
 224
 225 #undef ASM_OUTPUT_ALIGNED_COMMON
 226 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 227 do {                                                                    \
 228   fprintf ((FILE), "%s", COMMON_ASM_OP);                                \
 229   assemble_name ((FILE), (NAME));                                       \
 230   if (TARGET_ELF)                                                       \
 231     fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);      \
 232   else                                                                  \
 233     fprintf ((FILE), ",%u\n", (SIZE));                                  \
 234 } while (0)
 235
 236 #undef ASM_OUTPUT_ALIGNED_LOCAL
 237 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
 238 do {                                                                    \
 239   if (TARGET_ELF) {                                                     \
 240     fprintf ((FILE), "%s", LOCAL_ASM_OP);                               \
 241     assemble_name ((FILE), (NAME));                                     \
 242     fprintf ((FILE), "\n");                                             \
 243     ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);                \
 244   } else {                                                              \
 245     int align = exact_log2 (ALIGN);                                     \
 246     if (align > 2) align = 2;                                           \
 247     if (TARGET_SVR3_SHLIB)                                              \
 248       data_section ();                                                  \
 249     else                                                                \
 250       bss_section ();                                                   \
 251     ASM_OUTPUT_ALIGN ((FILE), align == -1 ? 2 : align);                 \
 252     fprintf ((FILE), "%s\t", "\t.lcomm");                               \
 253     assemble_name ((FILE), (NAME));                                     \
 254     fprintf ((FILE), ",%u\n", (SIZE));                                  \
 255    }                                                                    \
 256 } while (0)
 257
 258 /* A C statement (sans semicolon) to output to the stdio stream
 259    FILE the assembler definition of uninitialized global DECL named
 260    NAME whose size is SIZE bytes and alignment is ALIGN bytes.
 261    Try to use asm_output_aligned_bss to implement this macro.  */
 262
 263 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN) \
 264 asm_output_aligned_bss (FILE, DECL, NAME, SIZE, ALIGN)
 265
 266 #undef ESCAPES
 267 #define ESCAPES \
 268 "\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\
 269 \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\
 270 \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\
 271 \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\
 272 \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\
 273 \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\
 274 \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\
 275 \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"
 276
 277 #undef STRING_LIMIT
 278 #define STRING_LIMIT    ((unsigned) 256)
 279
 280 #undef ASM_OUTPUT_LIMITED_STRING
 281 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)                            \
 282   do                                                                    \
 283     {                                                                   \
 284       register const unsigned char *_limited_str =                      \
 285         (const unsigned char *) (STR);                                  \
 286       register unsigned ch;                                             \
 287       fprintf ((FILE), "%s\"", STRING_ASM_OP);                          \
 288       for (; (ch = *_limited_str); _limited_str++)                      \
 289         {                                                               \
 290           register int escape;                                          \
 291           switch (escape = ESCAPES[ch])                                 \
 292             {                                                           \
 293             case 0:                                                     \
 294               putc (ch, (FILE));                                        \
 295               break;                                                    \
 296             case 1:                                                     \
 297               fprintf ((FILE), "\\%03o", ch);                           \
 298               break;                                                    \
 299             default:                                                    \
 300               putc ('\\', (FILE));                                      \
 301               putc (escape, (FILE));                                    \
 302               break;                                                    \
 303             }                                                           \
 304         }                                                               \
 305       fprintf ((FILE), "\"\n");                                         \
 306     }                                                                   \
 307   while (0)
 308
 309
 310 #undef ASM_OUTPUT_ASCII
 311 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 312 do {                                                                    \
 313       register const unsigned char *_ascii_bytes =                      \
 314         (const unsigned char *) (STR);                                  \
 315       register const unsigned char *limit = _ascii_bytes + (LENGTH);    \
 316       register unsigned bytes_in_chunk = 0;                             \
 317       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 318         {                                                               \
 319           register unsigned const char *p;                              \
 320           if (bytes_in_chunk >= 64)                                     \
 321             {                                                           \
 322               fputc ('\n', (FILE));                                     \
 323               bytes_in_chunk = 0;                                       \
 324             }                                                           \
 325           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 326             continue;                                                   \
 327           if (p < limit && (p - _ascii_bytes) <= (long) STRING_LIMIT)   \
 328             {                                                           \
 329               if (bytes_in_chunk > 0)                                   \
 330                 {                                                       \
 331                   fputc ('\n', (FILE));                                 \
 332                   bytes_in_chunk = 0;                                   \
 333                 }                                                       \
 334               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 335               _ascii_bytes = p;                                         \
 336             }                                                           \
 337           else                                                          \
 338             {                                                           \
 339               if (bytes_in_chunk == 0)                                  \
 340                 fputs ("\t.byte\t", (FILE));                            \
 341               else                                                      \
 342                 fputc (',', (FILE));                                    \
 343               fprintf ((FILE), "0x%02x", *_ascii_bytes);                \
 344               bytes_in_chunk += 5;                                      \
 345             }                                                           \
 346         }                                                               \
 347       if (bytes_in_chunk > 0)                                           \
 348         fprintf ((FILE), "\n");                                         \
 349 } while (0)
 350
 351 /* Must use data section for relocatable constants when pic.  */
 352 #undef SELECT_RTX_SECTION
 353 #define SELECT_RTX_SECTION(MODE,RTX,ALIGN)              \
 354 {                                                       \
 355   if (TARGET_ELF) {                                     \
 356     if (flag_pic && symbolic_operand (RTX, VOIDmode))   \
 357       data_section ();                                  \
 358     else                                                \
 359       readonly_data_section ();                         \
 360   } else                                                \
 361     readonly_data_section();                            \
 362 }
 363
 364 #undef ASM_OUTPUT_CASE_LABEL
 365 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE)                \
 366 do {                                                                    \
 367   if (TARGET_ELF)                                                       \
 368     ASM_OUTPUT_ALIGN ((FILE), 2);                                       \
 369   ASM_OUTPUT_INTERNAL_LABEL((FILE),(PREFIX),(NUM));                     \
 370 } while (0)
 371
 372 #undef ASM_OUTPUT_IDENT
 373 #define ASM_OUTPUT_IDENT(FILE, NAME) \
 374   fprintf (FILE, "%s\"%s\"\n", IDENT_ASM_OP, NAME);
 375
 376 #undef ASM_GLOBALIZE_LABEL
 377 #define ASM_GLOBALIZE_LABEL(FILE,NAME)  \
 378   (fprintf ((FILE), "%s", GLOBAL_ASM_OP), assemble_name (FILE, NAME), fputs ("\n", FILE))
 379
 380 #undef ASM_OUTPUT_EXTERNAL_LIBCALL
 381 #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)                          \
 382   if (TARGET_ELF) ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
 383
 384 #undef ASM_OUTPUT_INTERNAL_LABEL
 385 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)                      \
 386   fprintf (FILE, ".%s%d:\n", PREFIX, NUM)
 387
 388 /* The prefix to add to user-visible assembler symbols.  */
 389
 390 #undef USER_LABEL_PREFIX
 391 #define USER_LABEL_PREFIX ""
 392
 393 /*
 394  * We rename 'gcc_except_table' to the shorter name in preparation
 395  * for the day when we're ready to do DWARF2 eh unwinding under COFF.
 396  */
 397 /* #define EXCEPTION_SECTION()          named_section (NULL, ".gccexc", 1) */
 398
 399 /* Switch into a generic section.  */
 400 #define TARGET_ASM_NAMED_SECTION default_elf_asm_named_section
 401
 402 #undef ASM_OUTPUT_SKIP
 403 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
 404 do {                                                                    \
 405   if (TARGET_ELF)                                                       \
 406     fprintf (FILE, "%s%u\n", SKIP_ASM_OP, (SIZE));                      \
 407   else                                                                  \
 408     fprintf ((FILE), "%s.,.+%u\n", SET_ASM_OP, (SIZE));         \
 409 } while (0)
 410
 411
 412 #undef CTOR_LIST_BEGIN
 413 #define CTOR_LIST_BEGIN                                                 \
 414 do {                                                                    \
 415   asm (CTORS_SECTION_ASM_OP);                                           \
 416   if (TARGET_ELF)                                                       \
 417     STATIC func_ptr __CTOR_LIST__[1] = { (func_ptr) (-1) };             \
 418   else                                                                  \
 419     asm ("pushl $0");                                                   \
 420 } while (0)
 421
 422 #undef CTOR_LIST_END
 423 #define CTOR_LIST_END                                                   \
 424 do {                                                                    \
 425   if (TARGET_ELF) {                                                     \
 426     asm (CTORS_SECTION_ASM_OP);                                         \
 427     STATIC func_ptr __CTOR_LIST__[1] = { (func_ptr) (0) };              \
 428   } else {                                                              \
 429     CTOR_LIST_BEGIN;                                                    \
 430   }                                                                     \
 431 } while (0)
 432
 433 #undef DBX_BLOCKS_FUNCTION_RELATIVE
 434 #define DBX_BLOCKS_FUNCTION_RELATIVE 1
 435
 436 #undef DBX_FUNCTION_FIRST
 437 #define DBX_FUNCTION_FIRST 1
 438
 439 #undef DBX_REGISTER_NUMBER
 440 #define DBX_REGISTER_NUMBER(n) \
 441   ((TARGET_ELF) ? svr4_dbx_register_map[n] : dbx_register_map[n])
 442
 443 #undef DWARF2_DEBUGGING_INFO
 444 #undef DWARF_DEBUGGING_INFO
 445 #undef SDB_DEBUGGING_INFO
 446 #undef DBX_DEBUGGING_INFO
 447 #undef PREFERRED_DEBUGGING_TYPE
 448
 449 #define DWARF2_DEBUGGING_INFO 1
 450 #define DWARF_DEBUGGING_INFO 1
 451 #define SDB_DEBUGGING_INFO   1
 452 #define DBX_DEBUGGING_INFO   1
 453 #define PREFERRED_DEBUGGING_TYPE                                        \
 454   ((TARGET_ELF) ? DWARF2_DEBUG: SDB_DEBUG)
 455
 456 #undef EXTRA_SECTIONS
 457 #define EXTRA_SECTIONS in_init, in_fini
 458
 459 #undef EXTRA_SECTION_FUNCTIONS
 460 #define EXTRA_SECTION_FUNCTIONS                                         \
 461   INIT_SECTION_FUNCTION                                                 \
 462   FINI_SECTION_FUNCTION
 463
 464 #undef FINI_SECTION_FUNCTION
 465 #define FINI_SECTION_FUNCTION                                           \
 466 void                                                                    \
 467 fini_section ()                                                         \
 468 {                                                                       \
 469   if ((!TARGET_ELF) && in_section != in_fini)                           \
 470     {                                                                   \
 471       fprintf (asm_out_file, "%s\n", FINI_SECTION_ASM_OP);              \
 472       in_section = in_fini;                                             \
 473     }                                                                   \
 474 }
 475
 476 #undef INIT_SECTION_FUNCTION
 477 #define INIT_SECTION_FUNCTION                                           \
 478 void                                                                    \
 479 init_section ()                                                         \
 480 {                                                                       \
 481   if ((!TARGET_ELF) && in_section != in_init)                           \
 482     {                                                                   \
 483       fprintf (asm_out_file, "%s\n", INIT_SECTION_ASM_OP);              \
 484       in_section = in_init;                                             \
 485     }                                                                   \
 486 }
 487
 488 #undef SUBTARGET_FRAME_POINTER_REQUIRED
 489 #define SUBTARGET_FRAME_POINTER_REQUIRED                                \
 490   ((TARGET_ELF) ? 0 :                                                   \
 491    (current_function_calls_setjmp || current_function_calls_longjmp))
 492
 493 #undef LOCAL_LABEL_PREFIX
 494 #define LOCAL_LABEL_PREFIX                                              \
 495  ((TARGET_ELF) ? "" : ".")
 496
 497 #undef MD_EXEC_PREFIX
 498 #undef MD_STARTFILE_PREFIX
 499 #define MD_EXEC_PREFIX "/usr/ccs/bin/"
 500 #define MD_STARTFILE_PREFIX "/usr/ccs/lib/"
 501
 502 #undef NON_SAVING_SETJMP
 503 #define NON_SAVING_SETJMP                                               \
 504   ((TARGET_ELF) ? 0 :                                                   \
 505    (current_function_calls_setjmp && current_function_calls_longjmp))
 506
 507 #undef NO_IMPLICIT_EXTERN_C
 508 #define NO_IMPLICIT_EXTERN_C 1
 509
 510 /* JKJ FIXME - examine the ramifications of RETURN_IN_MEMORY and
 511    RETURN_POPS_ARGS */
 512
 513 #undef RETURN_POPS_ARGS
 514 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE)                          \
 515  ((TARGET_ELF) ?                                                        \
 516   (ix86_return_pops_args (FUNDECL, FUNTYPE, SIZE)) :                    \
 517   (((FUNDECL) && (TREE_CODE (FUNDECL) == IDENTIFIER_NODE)) ? 0          \
 518    : (TARGET_RTD                                                        \
 519       && (TYPE_ARG_TYPES (FUNTYPE) == 0                                 \
 520           || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE)))         \
 521               == void_type_node))) ? (SIZE)                             \
 522    : 0))
 523
 524 /* ??? Ignore coff.  */
 525 #undef  TARGET_ASM_SELECT_SECTION
 526 #define TARGET_ASM_SELECT_SECTION  default_elf_select_section
 527
 528 #undef SWITCH_TAKES_ARG
 529 #define SWITCH_TAKES_ARG(CHAR)                                          \
 530   (DEFAULT_SWITCH_TAKES_ARG(CHAR)                                       \
 531    || (CHAR) == 'h'                                                     \
 532    || (CHAR) == 'R'                                                     \
 533    || (CHAR) == 'Y'                                                     \
 534    || (CHAR) == 'z')
 535
 536 #undef WORD_SWITCH_TAKES_ARG
 537 #define WORD_SWITCH_TAKES_ARG(STR)                                      \
 538  (DEFAULT_WORD_SWITCH_TAKES_ARG (STR)                                   \
 539   && strcmp (STR, "Tdata") && strcmp (STR, "Ttext")                     \
 540   && strcmp (STR, "Tbss"))
 541
 542 #undef TARGET_SUBTARGET_DEFAULT
 543 #define TARGET_SUBTARGET_DEFAULT (MASK_80387 | MASK_IEEE_FP | MASK_FLOAT_RETURNS)
 544
 545 #undef HANDLE_SYSV_PRAGMA
 546 #define HANDLE_SYSV_PRAGMA 1
 547
 548 /* Though OpenServer supports .weak in COFF, we don't use it.
 549  * G++ will frequently emit a symol as .weak and then (in the same .s
 550  * file) declare it global.   The COFF assembler finds this unamusing.
 551  */
 552 #define SUPPORTS_WEAK (TARGET_ELF)
 553 #define ASM_WEAKEN_LABEL(FILE,NAME) \
 554   do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME);           \
 555         fputc ('\n', FILE); } while (0)
 556
 557 #undef SCCS_DIRECTIVE
 558 #define SCCS_DIRECTIVE 1
 559
 560 /*
 561  * Define sizes and types
 562  */
 563 #undef SIZE_TYPE
 564 #undef PTRDIFF_TYPE
 565 #undef WCHAR_TYPE
 566 #undef WCHAR_TYPE_SIZE
 567 #undef LONG_DOUBLE_TYPE_SIZE
 568 #define LONG_DOUBLE_TYPE_SIZE   96
 569 #define SIZE_TYPE               "unsigned int"
 570 #define PTRDIFF_TYPE            "int"
 571 #define WCHAR_TYPE              "long int"
 572 #define WCHAR_TYPE_SIZE         BITS_PER_WORD
 573
 574 /*
 575  * New for multilib support. Set the default switches for multilib,
 576  * which is -melf.
 577  */
 578 #define MULTILIB_DEFAULTS { "melf" }
 579
 580 \f
 581 /* Please note that these specs may look messy but they are required in
 582    order to emulate the SCO Development system as closely as possible.
 583    With SCO Open Server 5.0, you now get the linker and assembler free,
 584    so that is what these specs are targeted for. These utilities are
 585    very argument sensitive: a space in the wrong place breaks everything.
 586    So RMS, please forgive this mess. It works.
 587
 588    Parameters which can be passed to gcc, and their SCO equivalents:
 589    GCC Parameter                SCO Equivalent
 590    -ansi                        -a ansi
 591    -posix                       -a posix
 592    -Xpg4                        -a xpg4
 593    -Xpg4plus                    -a xpg4plus
 594    -Xods30                      -a ods30
 595
 596    As with SCO, the default is XPG4 plus mode. SCO also allows you to
 597    specify a C dialect with -Xt, -Xa, -Xc, -Xk and -Xm. These are passed
 598    on to the assembler and linker in the same way that the SCO compiler
 599    does.
 600
 601    SCO also allows you to compile, link and generate either ELF or COFF
 602    binaries. With gcc, unlike the SCO compiler, the default is ELF.
 603    Specify -mcoff to gcc to produce COFF binaries. -fpic will get the
 604    assembler and linker to produce PIC code.
 605 */
 606
 607 /* Set up assembler flags for PIC and ELF compilations */
 608 #undef ASM_SPEC
 609
 610 #if USE_GAS
 611   /* Leave ASM_SPEC undefined so we pick up the master copy from gcc.c
 612    * Undef MD_EXEC_PREFIX because we don't know where GAS is, but it's not
 613    * likely in /usr/ccs/bin/
 614    */
 615 #undef MD_EXEC_PREFIX
 616 #else
 617
 618 #define ASM_SPEC \
 619    "-b %{!mcoff:elf}%{mcoff:coff \
 620      %{static:%e-static not valid with -mcoff} \
 621      %{shared:%e-shared not valid with -mcoff} \
 622      %{symbolic:%e-symbolic not valid with -mcoff}} \
 623     %{Ym,*} %{Yd,*} %{Wa,*:%*} \
 624     %{!mcoff:-E%{Xa:a}%{!Xa:%{Xc:c}%{!Xc:%{Xk:k}%{!Xk:%{Xt:t}%{!Xt:a}}}},%{ansi:ansi}%{!ansi:%{posix:posix}%{!posix:%{Xpg4:xpg4}%{!Xpg4:%{Xpg4plus:XPG4PLUS}%{!Xpg4plus:%{Xods30:ods30}%{!Xods30:XPG4PLUS}}}}},ELF %{Qn:} %{!Qy:-Qn}}"
 625 #endif
 626
 627 /* Use crt1.o as a startup file and crtn.o as a closing file.  */
 628
 629 #undef STARTFILE_SPEC
 630 #define STARTFILE_SPEC \
 631  "%{shared: %{!mcoff: crti.o%s}} \
 632   %{!shared:\
 633    %{!symbolic: \
 634     %{pg:gcrt.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}} \
 635   %{ansi:values-Xc.o%s} \
 636   %{!ansi: \
 637    %{Xa:values-Xa.o%s} \
 638     %{!Xa:%{Xc:values-Xc.o%s} \
 639      %{!Xc:%{Xk:values-Xk.o%s} \
 640       %{!Xk:%{Xt:values-Xt.o%s} \
 641        %{!Xt:values-Xa.o%s}}}}} \
 642   %{mcoff:crtbeginS.o%s} %{!mcoff:crtbegin.o%s}"
 643
 644 #undef ENDFILE_SPEC
 645 #define ENDFILE_SPEC \
 646  "%{!mcoff:crtend.o%s} \
 647   %{mcoff:crtendS.o%s} \
 648   %{pg:gcrtn.o%s}%{!pg:crtn.o%s}"
 649
 650 #undef CPP_PREDEFINES
 651 #define CPP_PREDEFINES \
 652  "-Asystem=svr3"
 653
 654 /* You are in a maze of GCC specs ... all alike */
 655
 656 #undef CPP_SPEC
 657 #define CPP_SPEC "%(cpp_cpu) \
 658   %{fpic:%{mcoff:%e-fpic is not valid with -mcoff}} \
 659   %{fPIC:%{mcoff:%e-fPIC is not valid with -mcoff}} \
 660   -D__i386 -D__unix -D_SCO_DS=1 -D_M_I386 -D_M_XENIX -D_M_UNIX \
 661   %{!Xods30:-D_STRICT_NAMES} \
 662   %{!ansi:%{!posix:%{!Xods30:-D_SCO_XPG_VERS=4}}} \
 663   %{ansi:-isystem include/ansi%s -isystem /usr/include/ansi -D_STRICT_ANSI} \
 664   %{!ansi: \
 665    %{posix:-isystem include/posix%s -isystem /usr/include/posix \
 666            -D_POSIX_C_SOURCE=2 -D_POSIX_SOURCE=1} \
 667     %{!posix:%{Xpg4:-isystem include/xpg4%s -isystem /usr/include/xpg4 \
 668                     -D_XOPEN_SOURCE=1} \
 669      %{!Xpg4:-D_M_I86 -D_M_I86SM -D_M_INTERNAT -D_M_SDATA -D_M_STEXT \
 670              -D_M_BITFIELDS -D_M_SYS5 -D_M_SYSV -D_M_SYSIII \
 671              -D_M_WORDSWAP -Dunix -DM_I386 -DM_UNIX -DM_XENIX \
 672              %{Xods30:-isystem include/ods_30_compat%s \
 673                       -isystem /usr/include/ods_30_compat \
 674                       -D_SCO_ODS_30 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \
 675                       -DM_BITFIELDS -DM_SYS5 -DM_SYSV -DM_INTERNAT -DM_SYSIII \
 676                       -DM_WORDSWAP}}}} \
 677   %{scointl:-DM_INTERNAT -D_M_INTERNAT} \
 678   %{!mcoff:-D_SCO_ELF} \
 679   %{mcoff:-D_M_COFF -D_SCO_COFF} \
 680   %{!mcoff:%{fpic:-D__PIC__ -D__pic__} \
 681          %{fPIC:%{!fpic:-D__PIC__ -D__pic__}}} \
 682   %{Xa:-D_SCO_C_DIALECT=1} \
 683   %{!Xa:%{Xc:-D_SCO_C_DIALECT=3} \
 684    %{!Xc:%{Xk:-D_SCO_C_DIALECT=4} \
 685     %{!Xk:%{Xt:-D_SCO_C_DIALECT=2} \
 686      %{!Xt:-D_SCO_C_DIALECT=1}}}}"
 687
 688 #undef LINK_SPEC
 689 #define LINK_SPEC \
 690  "-b %{!mcoff:elf}%{mcoff:coff \
 691    %{static:%e-static not valid with -mcoff} \
 692    %{shared:%e-shared not valid with -mcoff} \
 693    %{symbolic:%e-symbolic not valid with -mcoff} \
 694    %{fpic:%e-fpic not valid with -mcoff} \
 695    %{fPIC:%e-fPIC not valid with -mcoff}} \
 696   -R%{Xa:a}%{!Xa:%{Xc:c}%{!Xc:%{Xk:k}%{!Xk:%{Xt:t}%{!Xt:a}}}},%{ansi:ansi}%{!ansi:%{posix:posix}%{!posix:%{Xpg4:xpg4}%{!Xpg4:%{Xpg4plus:XPG4PLUS}%{!Xpg4plus:%{Xods30:ods30}%{!Xods30:XPG4PLUS}}}}},%{mcoff:COFF}%{!mcoff:ELF} \
 697   %{Wl,*%*} %{YP,*} %{YL,*} %{YU,*} \
 698   %{!YP,*:%{p:-YP,/usr/ccs/libp:/lib/libp:/usr/lib/libp:/usr/ccs/lib:/lib:/usr/lib} \
 699    %{!p:-YP,/usr/ccs/lib:/lib:/usr/lib}} \
 700   %{h*} %{static:-dn -Bstatic} %{shared:-G -dy %{!z*:-z text}} \
 701   %{symbolic:-Bsymbolic -G -dy %{!z*:-z text}} %{z*} %{R*} %{Y*} \
 702   %{G:-G} %{!mcoff:%{Qn:} %{!Qy:-Qn}}"
 703
 704 /* The SCO COFF linker gets confused on the difference between "-ofoo"
 705    and "-o foo".   So we just always force a single space.  */
 706
 707 #define SWITCHES_NEED_SPACES "o"
 708
 709 /* Library spec. If we are not building a shared library, provide the
 710    standard libraries, as per the SCO compiler.  */
 711
 712 #undef LIB_SPEC
 713 #define LIB_SPEC \
 714  "%{shared:pic/libgcc.a%s}%{!shared:%{!symbolic:-lcrypt -lgen -lc}}"
 715
 716 #undef LIBGCC_SPEC
 717 #define LIBGCC_SPEC \
 718  "%{!shared:-lgcc}"
 719
 720 #define MASK_COFF               010000000000    /* Mask for elf generation */
 721 #define TARGET_ELF              (1) /* (!(target_flags & MASK_COFF)) */
 722
 723 #undef SUBTARGET_SWITCHES
 724 #define SUBTARGET_SWITCHES                                      \
 725         { "elf", -MASK_COFF, N_("Generate ELF output")  },
 726
 727 #define NO_DOLLAR_IN_LABEL
 728
 729 /* Implicit library calls should use memcpy, not bcopy, etc.  They are
 730    faster on OpenServer libraries.  */
 731
 732 #define TARGET_MEM_FUNCTIONS
 733
 734 /* Biggest alignment supported by the object file format of this
 735    machine.  Use this macro to limit the alignment which can be
 736    specified using the `__attribute__ ((aligned (N)))' construct.  If
 737    not defined, the default value is `BIGGEST_ALIGNMENT'.  */
 738
 739 #define MAX_OFILE_ALIGNMENT (32768*8)
 740
 741 /* Define the `__builtin_va_list' type for the ABI.  On OpenServer, this
 742    type is `char *'.  */
 743 #undef BUILD_VA_LIST_TYPE
 744 #define BUILD_VA_LIST_TYPE(VALIST) \
 745   (VALIST) = build_pointer_type (char_type_node)
 746
 747
 748 /*
 749 Here comes some major hackery to get the crt stuff to compile properly.
 750 Since we can (and do) compile for both COFF and ELF environments, we
 751 set things up accordingly, based on the pre-processor defines for ELF
 752 and COFF. This is insane, but then I guess having one compiler with a
 753 single back-end supporting two vastly different file format types is
 754 a little insane too. But it is not impossible and we get a useful
 755 compiler at the end of the day. Onward we go ...
 756 */
 757
 758 #if defined(CRT_BEGIN) || defined(CRT_END) || defined(IN_LIBGCC2)
 759 # undef OBJECT_FORMAT_ELF
 760 # undef INIT_SECTION_ASM_OP
 761 # undef FINI_SECTION_ASM_OP
 762 # undef CTORS_SECTION_ASM_OP
 763 # undef DTORS_SECTION_ASM_OP
 764 # undef EH_FRAME_SECTION_NAME
 765 # undef CTOR_LIST_BEGIN
 766 # undef CTOR_LIST_END
 767 # undef DO_GLOBAL_CTORS_BODY
 768
 769 # if defined (_SCO_ELF)
 770 #  define OBJECT_FORMAT_ELF
 771 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_ELF
 772 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_ELF
 773 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_ELF
 774 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_ELF
 775 #  define EH_FRAME_SECTION_NAME EH_FRAME_SECTION_NAME_ELF
 776 # else /* ! _SCO_ELF */
 777 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_COFF
 778 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_COFF
 779 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_COFF
 780 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_COFF
 781 #  define EH_FRAME_SECTION_NAME EH_FRAME_SECTION_NAME_COFF
 782 #  define CTOR_LIST_BEGIN asm (INIT_SECTION_ASM_OP); asm ("pushl $0")
 783 #  define CTOR_LIST_END CTOR_LIST_BEGIN
 784 #  define DO_GLOBAL_CTORS_BODY                                          \
 785 do {                                                                    \
 786      func_ptr *p, *beg = alloca(0);                                     \
 787      for (p = beg; *p;)                                                 \
 788       (*p++) ();                                                        \
 789 } while (0)
 790 # endif /* ! _SCO_ELF */
 791 #endif /* CRT_BEGIN !! CRT_END */
 792
 793 /* Handle special EH pointer encodings.  Absolute, pc-relative, and
 794    indirect are handled automatically.  */
 795 #define ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX(FILE, ENCODING, SIZE, ADDR, DONE) \
 796   do {                                                                  \
 797     if ((SIZE) == 4 && ((ENCODING) & 0x70) == DW_EH_PE_datarel)         \
 798       {                                                                 \
 799         fputs (ASM_LONG, FILE);                                         \
 800         assemble_name (FILE, XSTR (ADDR, 0));                           \
 801         fputs (((ENCODING) & DW_EH_PE_indirect ? "@GOT" : "@GOTOFF"), FILE); \
 802         goto DONE;                                                      \
 803       }                                                                 \
 804   } while (0)
 805
 806 /* Used by crtstuff.c to initialize the base of data-relative relocations.
 807    These are GOT relative on x86, so return the pic register.  */
 808 #ifdef __PIC__
 809 #define CRT_GET_RFIB_DATA(BASE)                 \
 810   {                                             \
 811     register void *ebx_ __asm__("ebx");         \
 812     BASE = ebx_;                                \
 813   }
 814 #else
 815 #define CRT_GET_RFIB_DATA(BASE)                                         \
 816   __asm__ ("call\t.LPR%=\n"                                             \
 817            ".LPR%=:\n\t"                                                \
 818            "popl\t%0\n\t"                                               \
 819            /* Due to a GAS bug, this cannot use EAX.  That encodes      \
 820               smaller than the traditional EBX, which results in the    \
 821               offset being off by one.  */                              \
 822            "addl\t$_GLOBAL_OFFSET_TABLE_+[.-.LPR%=],%0"                 \
 823            : "=d"(BASE))
 824 #endif
 825
 826 /* Select a format to encode pointers in exception handling data.  CODE
 827    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
 828    true if the symbol may be affected by dynamic relocations.  */
 829 #undef ASM_PREFERRED_EH_DATA_FORMAT
 830 #define ASM_PREFERRED_EH_DATA_FORMAT(CODE,GLOBAL)                       \
 831   (flag_pic ? (GLOBAL ? DW_EH_PE_indirect : 0) | DW_EH_PE_datarel       \
 832    : DW_EH_PE_absptr)