gcc/config/i386/sco5.h

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