gcc/config/i386/sco5.h

   1 /* Definitions for Intel 386 running SCO Unix System V 3.2 Version 5.
   2    Written by Kean Johnston (hug@netcom.com)
   3    Copyright (C) 1992, 1995, 1996 Free Software Foundation, Inc.
   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 CONST_SECTION_ASM_OP
  80 #define CONST_SECTION_ASM_OP_COFF       "\t.section\t.rodata, \"x\""
  81 #define CONST_SECTION_ASM_OP_ELF        "\t.section\t.rodata"
  82 #define CONST_SECTION_ASM_OP    \
  83   ((TARGET_ELF) ? CONST_SECTION_ASM_OP_ELF : CONST_SECTION_ASM_OP_COFF)
  84
  85 #undef USE_CONST_SECTION
  86 #define USE_CONST_SECTION_ELF           1
  87 #define USE_CONST_SECTION_COFF          0
  88 #define USE_CONST_SECTION       \
  89  ((TARGET_ELF) ? USE_CONST_SECTION_ELF : USE_CONST_SECTION_COFF)
  90
  91 #undef INIT_SECTION_ASM_OP
  92 #define INIT_SECTION_ASM_OP_ELF         "\t.section\t.init"
  93 #define INIT_SECTION_ASM_OP_COFF        "\t.section\t.init ,\"x\""
  94 #define INIT_SECTION_ASM_OP     \
  95   ((TARGET_ELF) ? INIT_SECTION_ASM_OP_ELF : INIT_SECTION_ASM_OP_COFF)
  96
  97 #undef CTORS_SECTION_ASM_OP
  98 #define CTORS_SECTION_ASM_OP_ELF        "\t.section\t.ctors,\"aw\""
  99 #define CTORS_SECTION_ASM_OP_COFF       INIT_SECTION_ASM_OP_COFF
 100 #define CTORS_SECTION_ASM_OP    \
 101  ((TARGET_ELF) ? CTORS_SECTION_ASM_OP_ELF : CTORS_SECTION_ASM_OP_COFF)
 102
 103 #undef DTORS_SECTION_ASM_OP
 104 #define DTORS_SECTION_ASM_OP_ELF        "\t.section\t.dtors, \"aw\""
 105 #define DTORS_SECTION_ASM_OP_COFF       FINI_SECTION_ASM_OP_COFF
 106 #define DTORS_SECTION_ASM_OP    \
 107  ((TARGET_ELF) ? DTORS_SECTION_ASM_OP_ELF : DTORS_SECTION_ASM_OP_COFF)
 108
 109 #undef FINI_SECTION_ASM_OP
 110 #define FINI_SECTION_ASM_OP_ELF         "\t.section\t.fini"
 111 #define FINI_SECTION_ASM_OP_COFF        "\t.section\t.fini, \"x\""
 112 #define FINI_SECTION_ASM_OP     \
 113  ((TARGET_ELF) ? FINI_SECTION_ASM_OP_ELF : FINI_SECTION_ASM_OP_COFF)
 114
 115 #undef BSS_SECTION_ASM_OP
 116 #define BSS_SECTION_ASM_OP              "\t.data"
 117
 118 #undef TEXT_SECTION_ASM_OP
 119 #define TEXT_SECTION_ASM_OP             "\t.text"
 120
 121 #undef DATA_SECTION_ASM_OP
 122 #define DATA_SECTION_ASM_OP             "\t.data"
 123
 124 #undef TYPE_OPERAND_FMT
 125 #define TYPE_OPERAND_FMT                "@%s"
 126
 127 #undef APPLY_RESULT_SIZE
 128 #define APPLY_RESULT_SIZE                                               \
 129 (TARGET_ELF) ? size : 116
 130
 131 #ifndef ASM_DECLARE_RESULT
 132 #define ASM_DECLARE_RESULT(FILE, RESULT)
 133 #endif
 134
 135 #define SCO_DEFAULT_ASM_COFF(FILE,NAME)                                 \
 136 do {                                                                    \
 137     if (output_bytecode)                                                \
 138       BC_OUTPUT_LABEL (FILE, NAME);                                     \
 139     else                                                                \
 140       ASM_OUTPUT_LABEL (FILE, NAME);                                    \
 141   } while (0)
 142
 143 #undef ASM_DECLARE_FUNCTION_NAME
 144 #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)                     \
 145   do {                                                                  \
 146     if (TARGET_ELF) {                                                   \
 147       fprintf (FILE, "%s\t ", TYPE_ASM_OP);                             \
 148       assemble_name (FILE, NAME);                                       \
 149       putc (',', FILE);                                                 \
 150       fprintf (FILE, TYPE_OPERAND_FMT, "function");                     \
 151       putc ('\n', FILE);                                                \
 152       ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL));                    \
 153       ASM_OUTPUT_LABEL(FILE, NAME);                                     \
 154     } else                                                              \
 155       SCO_DEFAULT_ASM_COFF(FILE, NAME);                                 \
 156 } while (0)
 157
 158 #undef ASM_DECLARE_FUNCTION_SIZE
 159 #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)                    \
 160   do {                                                                  \
 161     if (TARGET_ELF) { if (!flag_inhibit_size_directive)                 \
 162       {                                                                 \
 163         fprintf (FILE, "%s\t ", SIZE_ASM_OP);                           \
 164         assemble_name (FILE, (FNAME));                                  \
 165         fprintf (FILE, ",.-");                                          \
 166         assemble_name (FILE, (FNAME));                                  \
 167         putc ('\n', FILE);                                              \
 168       } }                                                               \
 169   } while (0)
 170
 171 #undef ASM_DECLARE_OBJECT_NAME
 172 #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)                       \
 173   do {                                                                  \
 174     if (TARGET_ELF) {                                                   \
 175       fprintf (FILE, "%s\t ", TYPE_ASM_OP);                             \
 176       assemble_name (FILE, NAME);                                       \
 177       putc (',', FILE);                                                 \
 178       fprintf (FILE, TYPE_OPERAND_FMT, "object");                       \
 179       putc ('\n', FILE);                                                \
 180       size_directive_output = 0;                                        \
 181       if (!flag_inhibit_size_directive && DECL_SIZE (DECL))             \
 182         {                                                               \
 183         size_directive_output = 1;                                      \
 184         fprintf (FILE, "%s\t ", SIZE_ASM_OP);                           \
 185         assemble_name (FILE, NAME);                                     \
 186         fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 187         }                                                               \
 188       ASM_OUTPUT_LABEL(FILE, NAME);                                     \
 189     } else                                                              \
 190       SCO_DEFAULT_ASM_COFF(FILE, NAME);                                 \
 191   } while (0)
 192
 193 #undef ASM_FILE_START_1
 194 #define ASM_FILE_START_1(FILE)
 195
 196 #undef ASM_FILE_START
 197 #define ASM_FILE_START(FILE)                                            \
 198 do {                                                                    \
 199   output_file_directive((FILE),main_input_filename);                    \
 200   fprintf ((FILE), "\t.version\t\"01.01\"\n");                          \
 201 } while (0)
 202
 203 #undef ASM_FILE_END
 204 #define ASM_FILE_END(FILE)                                              \
 205 do {                                                                    \
 206   fprintf ((FILE), "%s\t\"GCC: (GNU) %s\"\n",                           \
 207     IDENT_ASM_OP, version_string);                                      \
 208 } while (0)
 209
 210 #undef ASM_FINISH_DECLARE_OBJECT
 211 #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)         \
 212 do {                                                                     \
 213   if (TARGET_ELF) {                                                     \
 214      char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);                   \
 215      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)                \
 216          && ! AT_END && TOP_LEVEL                                        \
 217          && DECL_INITIAL (DECL) == error_mark_node                       \
 218          && !size_directive_output)                                      \
 219        {                                                                 \
 220          size_directive_output = 1;                                      \
 221          fprintf (FILE, "%s\t ", SIZE_ASM_OP);                           \
 222          assemble_name (FILE, name);                                     \
 223          fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
 224        }                                                                 \
 225     }                                                                    \
 226 } while (0)
 227
 228 #undef ASM_GENERATE_INTERNAL_LABEL
 229 #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM)                 \
 230 do {                                                                    \
 231   if (TARGET_ELF)                                                       \
 232     sprintf (LABEL, "*.%s%d", (PREFIX), (NUM));                         \
 233   else                                                                  \
 234     sprintf (LABEL, ".%s%d", (PREFIX), (NUM));                          \
 235 } while (0)
 236
 237 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 238 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
 239 do {                                                                    \
 240   if (TARGET_ELF)                                                       \
 241     fprintf (FILE, "%s _GLOBAL_OFFSET_TABLE_+[.-%s%d]\n", ASM_LONG, LPREFIX, VALUE); \
 242   else                                                                  \
 243     fprintf (FILE, "\t.word %s%d-%s%d\n", LPREFIX,VALUE,LPREFIX,REL);   \
 244 } while (0)
 245
 246 #undef ASM_OUTPUT_ALIGNED_COMMON
 247 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 248 do {                                                                    \
 249   fprintf ((FILE), "%s\t", COMMON_ASM_OP);                              \
 250   assemble_name ((FILE), (NAME));                                       \
 251   if (TARGET_ELF)                                                       \
 252     fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);      \
 253   else                                                                  \
 254     fprintf ((FILE), ",%u\n", (SIZE));                                  \
 255 } while (0)
 256
 257 #undef ASM_OUTPUT_ALIGNED_LOCAL
 258 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
 259 do {                                                                    \
 260   if (TARGET_ELF) {                                                     \
 261     fprintf ((FILE), "%s\t", LOCAL_ASM_OP);                             \
 262     assemble_name ((FILE), (NAME));                                     \
 263     fprintf ((FILE), "\n");                                             \
 264     ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);                \
 265   } else {                                                              \
 266     int align = exact_log2 (ALIGN);                                     \
 267     if (align > 2) align = 2;                                           \
 268     if (TARGET_SVR3_SHLIB)                                              \
 269       data_section ();                                                  \
 270     else                                                                \
 271       bss_section ();                                                   \
 272     ASM_OUTPUT_ALIGN ((FILE), align == -1 ? 2 : align);                 \
 273     fprintf ((FILE), "%s\t", "\t.lcomm");                               \
 274     assemble_name ((FILE), (NAME));                                     \
 275     fprintf ((FILE), ",%u\n", (SIZE));                                  \
 276    }                                                                    \
 277 } while (0)
 278
 279 #undef ESCAPES
 280 #define ESCAPES \
 281 "\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\
 282 \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\
 283 \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\
 284 \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\
 285 \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\
 286 \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\
 287 \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\
 288 \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"
 289
 290 #undef STRING_LIMIT
 291 #define STRING_LIMIT    ((unsigned) 256)
 292
 293 #undef ASM_OUTPUT_LIMITED_STRING
 294 #define ASM_OUTPUT_LIMITED_STRING(FILE, STR)                            \
 295   do                                                                    \
 296     {                                                                   \
 297       register unsigned char *_limited_str = (unsigned char *) (STR);   \
 298       register unsigned ch;                                             \
 299       fprintf ((FILE), "%s\t\"", STRING_ASM_OP);                        \
 300       for (; ch = *_limited_str; _limited_str++)                        \
 301         {                                                               \
 302           register int escape;                                          \
 303           switch (escape = ESCAPES[ch])                                 \
 304             {                                                           \
 305             case 0:                                                     \
 306               putc (ch, (FILE));                                        \
 307               break;                                                    \
 308             case 1:                                                     \
 309               fprintf ((FILE), "\\%03o", ch);                           \
 310               break;                                                    \
 311             default:                                                    \
 312               putc ('\\', (FILE));                                      \
 313               putc (escape, (FILE));                                    \
 314               break;                                                    \
 315             }                                                           \
 316         }                                                               \
 317       fprintf ((FILE), "\"\n");                                         \
 318     }                                                                   \
 319   while (0)
 320
 321
 322 #undef ASM_OUTPUT_ASCII
 323 #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH)                             \
 324 do {                                                                    \
 325    if (TARGET_ELF) {                                                    \
 326       register unsigned char *_ascii_bytes = (unsigned char *) (STR);   \
 327       register unsigned char *limit = _ascii_bytes + (LENGTH);          \
 328       register unsigned bytes_in_chunk = 0;                             \
 329       for (; _ascii_bytes < limit; _ascii_bytes++)                      \
 330         {                                                               \
 331           register unsigned char *p;                                    \
 332           if (bytes_in_chunk >= 64)                                     \
 333             {                                                           \
 334               fputc ('\n', (FILE));                                     \
 335               bytes_in_chunk = 0;                                       \
 336             }                                                           \
 337           for (p = _ascii_bytes; p < limit && *p != '\0'; p++)          \
 338             continue;                                                   \
 339           if (p < limit && (p - _ascii_bytes) <= STRING_LIMIT)          \
 340             {                                                           \
 341               if (bytes_in_chunk > 0)                                   \
 342                 {                                                       \
 343                   fputc ('\n', (FILE));                                 \
 344                   bytes_in_chunk = 0;                                   \
 345                 }                                                       \
 346               ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes);         \
 347               _ascii_bytes = p;                                         \
 348             }                                                           \
 349           else                                                          \
 350             {                                                           \
 351               if (bytes_in_chunk == 0)                                  \
 352                 fprintf ((FILE), "%s\t", ASM_BYTE_OP);                  \
 353               else                                                      \
 354                 fputc (',', (FILE));                                    \
 355               fprintf ((FILE), "0x%02x", *_ascii_bytes);                \
 356               bytes_in_chunk += 5;                                      \
 357             }                                                           \
 358         }                                                               \
 359       if (bytes_in_chunk > 0)                                           \
 360         fprintf ((FILE), "\n");                                         \
 361   } else {                                                              \
 362    int i = 0;                                                           \
 363    while (i < (LENGTH))                                                 \
 364     { if (i%10 == 0) { if (i!=0) fprintf ((FILE), "\n");                \
 365                        fprintf ((FILE), "%s ", ASM_BYTE_OP); }          \
 366       else fprintf ((FILE), ",");                                       \
 367         fprintf ((FILE), "0x%x", ((STR)[i++] & 0377)) ;}                \
 368       fprintf ((FILE), "\n"); }                                         \
 369 } while (0)
 370
 371 #undef ASM_OUTPUT_CASE_LABEL
 372 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE)                \
 373 do {                                                                    \
 374   if (TARGET_ELF)                                                       \
 375     ASM_OUTPUT_ALIGN ((FILE), 2);                                       \
 376   ASM_OUTPUT_INTERNAL_LABEL((FILE),(PREFIX),(NUM));                     \
 377 } while (0)
 378
 379
 380 #undef ASM_OUTPUT_CONSTRUCTOR
 381 #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME)                               \
 382 do {                                                                    \
 383   if (TARGET_ELF) {                                                     \
 384      ctors_section ();                                                  \
 385      fprintf (FILE, "%s\t ", INT_ASM_OP);                               \
 386      assemble_name (FILE, NAME);                                        \
 387      fprintf (FILE, "\n");                                              \
 388   } else {                                                              \
 389     init_section ();                                                    \
 390     fprintf (FILE, "\tpushl $");                                        \
 391     assemble_name (FILE, NAME);                                         \
 392     fprintf (FILE, "\n"); }                                             \
 393   } while (0)
 394
 395 #undef ASM_OUTPUT_DESTRUCTOR
 396 #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME)                                \
 397 do {                                                                    \
 398   if (TARGET_ELF) {                                                     \
 399     dtors_section ();                                                   \
 400     fprintf (FILE, "%s\t ", INT_ASM_OP);                                \
 401     assemble_name (FILE, NAME);                                         \
 402     fprintf (FILE, "\n");                                               \
 403   } else {                                                              \
 404     fini_section ();                                                    \
 405     fprintf (FILE, "%s\t ", ASM_LONG);                                  \
 406     assemble_name (FILE, NAME);                                         \
 407     fprintf (FILE, "\n"); }                                             \
 408   } while (0)
 409
 410
 411 #undef ASM_OUTPUT_DOUBLE
 412 #define ASM_OUTPUT_DOUBLE(FILE,VALUE)                                   \
 413 do {                                                                    \
 414   long value[2];                                                        \
 415   REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), value);                         \
 416   if (TARGET_ELF) {                                                     \
 417      if (sizeof (int) == sizeof (long))                                 \
 418        {                                                                \
 419          fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[0]);             \
 420          fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value[1]);             \
 421        }                                                                \
 422      else                                                               \
 423        {                                                                \
 424          fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[0]);            \
 425          fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value[1]);            \
 426        }                                                                \
 427   } else {                                                              \
 428      if (sizeof (int) == sizeof (long))                                 \
 429        fprintf (FILE, "%s 0x%x,0x%x\n", ASM_LONG, value[0], value[1]);  \
 430      else                                                               \
 431        fprintf (FILE, "%s 0x%lx,0x%lx\n", ASM_LONG,value[0],value[1]);} \
 432 } while (0)
 433
 434 #undef ASM_OUTPUT_FLOAT
 435 #define ASM_OUTPUT_FLOAT(FILE,VALUE)                                    \
 436 do {                                                                    \
 437   long value;                                                           \
 438   REAL_VALUE_TO_TARGET_SINGLE ((VALUE), value);                         \
 439   if (sizeof (int) == sizeof (long))                                    \
 440      fprintf((FILE), "%s\t0x%x\n", ASM_LONG, value);                    \
 441   else                                                                  \
 442      fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, value);                   \
 443 } while (0)
 444
 445 #undef ASM_OUTPUT_LONG_DOUBLE
 446 #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)                              \
 447 do {                                                                    \
 448   long l[3];                                                            \
 449   REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), l);                        \
 450   if (TARGET_ELF) {                                                     \
 451      if (sizeof (int) == sizeof (long))                                 \
 452        {                                                                \
 453          fprintf((FILE), "%s\t0x%x\n", ASM_LONG, l[0]);                 \
 454          fprintf((FILE), "%s\t0x%x\n", ASM_LONG, l[1]);                 \
 455          fprintf((FILE), "%s\t0x%x\n", ASM_LONG, l[2]);                 \
 456        }                                                                \
 457      else                                                               \
 458        {                                                                \
 459          fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, l[0]);                \
 460          fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, l[1]);                \
 461          fprintf((FILE), "%s\t0x%lx\n", ASM_LONG, l[2]);                \
 462        }                                                                \
 463   } else {                                                              \
 464      if (sizeof (int) == sizeof (long))                                 \
 465        fprintf (FILE, "%s 0x%x,0x%x,0x%x\n", ASM_LONG, l[0], l[1], l[2]); \
 466      else                                                               \
 467        fprintf (FILE, "%s 0x%lx,0x%lx,0x%lx\n", ASM_LONG,l[0],l[1],l[2]);} \
 468 } while (0)
 469
 470 #undef ASM_OUTPUT_IDENT
 471 #define ASM_OUTPUT_IDENT(FILE, NAME) \
 472   fprintf (FILE, "%s\t\"%s\"\n", IDENT_ASM_OP, NAME);
 473
 474 #undef ASM_GLOBALIZE_LABEL
 475 #define ASM_GLOBALIZE_LABEL(FILE,NAME)  \
 476   (fprintf ((FILE), "%s ", GLOBAL_ASM_OP), assemble_name (FILE, NAME), fputs ("\n", FILE))
 477
 478 #undef ASM_OUTPUT_EXTERNAL_LIBCALL
 479 #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN)                          \
 480   if (TARGET_ELF) ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0))
 481
 482 #undef ASM_OUTPUT_INTERNAL_LABEL
 483 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)                      \
 484   fprintf (FILE, ".%s%d:\n", PREFIX, NUM)
 485
 486 #undef ASM_OUTPUT_LABELREF
 487 #define ASM_OUTPUT_LABELREF(FILE,NAME)                                  \
 488   fprintf (FILE, "%s", NAME)
 489
 490 #undef ASM_OUTPUT_SECTION_NAME
 491 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \
 492 do {                                                                    \
 493   if (TARGET_ELF)                                                       \
 494     fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME,             \
 495            (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" :         \
 496            (DECL) && TREE_READONLY (DECL) ? "a" : "aw");                \
 497 } while (0)
 498
 499 #undef ASM_OUTPUT_SKIP
 500 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
 501 do {                                                                    \
 502   if (TARGET_ELF)                                                       \
 503     fprintf (FILE, "%s\t%u\n", SKIP_ASM_OP, (SIZE));                    \
 504   else                                                                  \
 505     fprintf ((FILE), "%s\t.,.+%u\n", SET_ASM_OP, (SIZE));               \
 506 } while (0)
 507
 508
 509 #undef CLASS_LIKELY_SPILLED_P
 510 #define CLASS_LIKELY_SPILLED_P(CLASS)                                   \
 511   (TARGET_ELF) ? (reg_class_size[(int)(CLASS)] == 1) :                  \
 512     (((CLASS) == AREG) || ((CLASS) == DREG) || ((CLASS) == CREG) ||     \
 513     ((CLASS) == BREG) || ((CLASS) == SIREG) || ((CLASS) == DIREG))
 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 PREFERRED_DEBUGGING_TYPE                                        \
 574   ((TARGET_ELF) ? DWARF_DEBUG: SDB_DEBUG)
 575
 576 #undef EXTRA_SECTIONS
 577 #define EXTRA_SECTIONS in_const, in_init, in_fini, in_ctors, in_dtors
 578
 579 #undef EXTRA_SECTION_FUNCTIONS
 580 #define EXTRA_SECTION_FUNCTIONS                                         \
 581   CONST_SECTION_FUNCTION                                                \
 582   INIT_SECTION_FUNCTION                                                 \
 583   FINI_SECTION_FUNCTION                                                 \
 584   CTORS_SECTION_FUNCTION                                                \
 585   DTORS_SECTION_FUNCTION
 586
 587 #undef CONST_SECTION_FUNCTION
 588 #define CONST_SECTION_FUNCTION                                          \
 589 void                                                                    \
 590 const_section ()                                                        \
 591 {                                                                       \
 592   extern void text_section();                                           \
 593   if (!USE_CONST_SECTION)                                               \
 594     text_section();                                                     \
 595   else if (in_section != in_const)                                      \
 596     {                                                                   \
 597       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);             \
 598       in_section = in_const;                                            \
 599     }                                                                   \
 600 }
 601
 602 #undef FINI_SECTION_FUNCTION
 603 #define FINI_SECTION_FUNCTION                                           \
 604 void                                                                    \
 605 fini_section ()                                                         \
 606 {                                                                       \
 607   if ((!TARGET_ELF) && in_section != in_fini)                           \
 608     {                                                                   \
 609       fprintf (asm_out_file, "%s\n", FINI_SECTION_ASM_OP);              \
 610       in_section = in_fini;                                             \
 611     }                                                                   \
 612 }
 613
 614 #undef INIT_SECTION_FUNCTION
 615 #define INIT_SECTION_FUNCTION                                           \
 616 void                                                                    \
 617 init_section ()                                                         \
 618 {                                                                       \
 619   if ((!TARGET_ELF) && in_section != in_init)                           \
 620     {                                                                   \
 621       fprintf (asm_out_file, "%s\n", INIT_SECTION_ASM_OP);              \
 622       in_section = in_init;                                             \
 623     }                                                                   \
 624 }
 625
 626 #undef CTORS_SECTION_FUNCTION
 627 #define CTORS_SECTION_FUNCTION                                          \
 628 void                                                                    \
 629 ctors_section ()                                                        \
 630 {                                                                       \
 631   if (in_section != in_ctors)                                           \
 632     {                                                                   \
 633       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);             \
 634       in_section = in_ctors;                                            \
 635     }                                                                   \
 636 }
 637
 638 #undef DTORS_SECTION_FUNCTION
 639 #define DTORS_SECTION_FUNCTION                                          \
 640 void                                                                    \
 641 dtors_section ()                                                        \
 642 {                                                                       \
 643   if (in_section != in_dtors)                                           \
 644     {                                                                   \
 645       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);             \
 646       in_section = in_dtors;                                            \
 647     }                                                                   \
 648 }
 649
 650 #undef FRAME_POINTER_REQUIRED
 651 #define FRAME_POINTER_REQUIRED                                          \
 652   ((TARGET_ELF) ? 0 :                                                   \
 653    (current_function_calls_setjmp || current_function_calls_longjmp))
 654
 655 #undef JUMP_TABLES_IN_TEXT_SECTION
 656 #define JUMP_TABLES_IN_TEXT_SECTION 1
 657
 658 #undef LOCAL_LABEL_PREFIX
 659 #define LOCAL_LABEL_PREFIX                                              \
 660  ((TARGET_ELF) ? "" : ".")
 661
 662 #undef MD_EXEC_PREFIX
 663 #undef MD_STARTFILE_PREFIX
 664 #define MD_EXEC_PREFIX "/usr/ccs/bin/"
 665 #define MD_STARTFILE_PREFIX "/usr/ccs/lib/"
 666
 667 #undef NON_SAVING_SETJMP
 668 #define NON_SAVING_SETJMP                                               \
 669   ((TARGET_ELF) ? 0 :                                                   \
 670    (current_function_calls_setjmp && current_function_calls_longjmp))
 671
 672 #undef NO_IMPLICIT_EXTERN_C
 673 #define NO_IMPLICIT_EXTERN_C 1
 674
 675 /* JKJ FIXME - examine the rammifications of RETURN_IN_MEMORY and
 676    RETURN_POPS_ARGS */
 677
 678 #undef RETURN_POPS_ARGS
 679 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE)                          \
 680  ((TARGET_ELF) ?                                                        \
 681   (i386_return_pops_args (FUNDECL, FUNTYPE, SIZE)) :                    \
 682   (TREE_CODE (FUNTYPE) == IDENTIFIER_NODE ? 0                           \
 683    : (TARGET_RTD                                                        \
 684       && (TYPE_ARG_TYPES (FUNTYPE) == 0                                 \
 685           || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE)))         \
 686               == void_type_node))) ? (SIZE)                             \
 687    : 0))
 688
 689 #undef SELECT_SECTION
 690 #define SELECT_SECTION(DECL,RELOC)                                      \
 691 {                                                                       \
 692   if (TREE_CODE (DECL) == STRING_CST)                                   \
 693     {                                                                   \
 694       if (! flag_writable_strings)                                      \
 695         const_section ();                                               \
 696       else                                                              \
 697         data_section ();                                                \
 698     }                                                                   \
 699   else if (TREE_CODE (DECL) == VAR_DECL)                                \
 700     {                                                                   \
 701       if ((TARGET_ELF && flag_pic && RELOC)                             \
 702           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)          \
 703           || !DECL_INITIAL (DECL)                                       \
 704           || (DECL_INITIAL (DECL) != error_mark_node                    \
 705               && !TREE_CONSTANT (DECL_INITIAL (DECL))))                 \
 706         data_section ();                                                \
 707       else                                                              \
 708         const_section ();                                               \
 709     }                                                                   \
 710   else                                                                  \
 711     const_section ();                                                   \
 712 }
 713
 714 #undef SWITCH_TAKES_ARG
 715 #define SWITCH_TAKES_ARG(CHAR)                                          \
 716   (   (CHAR) == 'D'                                                     \
 717    || (CHAR) == 'U'                                                     \
 718    || (CHAR) == 'o'                                                     \
 719    || (CHAR) == 'e'                                                     \
 720    || (CHAR) == 'u'                                                     \
 721    || (CHAR) == 'I'                                                     \
 722    || (CHAR) == 'm'                                                     \
 723    || (CHAR) == 'L'                                                     \
 724    || (CHAR) == 'A'                                                     \
 725    || (CHAR) == 'h'                                                     \
 726    || (CHAR) == 'z')
 727
 728 #undef WORD_SWITCH_TAKES_ARG
 729 #define WORD_SWITCH_TAKES_ARG(STR)                                      \
 730  (DEFAULT_WORD_SWITCH_TAKES_ARG (STR)                                   \
 731   && strcmp (STR, "Tdata") && strcmp (STR, "Ttext")                     \
 732   && strcmp (STR, "Tbss"))
 733
 734 #undef TARGET_DEFAULT
 735 #define TARGET_DEFAULT 0301
 736
 737 #undef HANDLE_SYSV_PRAGMA
 738 #define HANDLE_SYSV_PRAGMA 1
 739
 740 #undef SCCS_DIRECTIVE
 741 #define SCCS_DIRECTIVE 1
 742
 743 /*
 744  * Define sizes and types
 745  */
 746 #undef SIZE_TYPE
 747 #undef PTRDIFF_TYPE
 748 #undef WCHAR_TYPE
 749 #undef WCHAR_TYPE_SIZE
 750 #undef LONG_DOUBLE_TYPE_SIZE
 751 #define LONG_DOUBLE_TYPE_SIZE   96
 752 #define SIZE_TYPE               "unsigned int"
 753 #define PTRDIFF_TYPE            "int"
 754 #define WCHAR_TYPE              "long int"
 755 #define WCHAR_TYPE_SIZE         BITS_PER_WORD
 756
 757 \f
 758 /* Please note that these specs may look messy but they are required in
 759    order to emulate the SCO Development system as closely as possible.
 760    With SCO Open Server 5.0, you now get the linker and assembler free,
 761    so that is what these specs are targeted for. These utilities are
 762    very argument sensitive: a space in the wrong place breaks everything.
 763    So RMS, please forgive this mess. It works.
 764
 765    Parameters which can be passed to gcc, and their SCO equivalents:
 766    GCC Parameter                SCO Equivalent
 767    -ansi                        -a ansi
 768    -posix                       -a posix
 769    -Xpg4                        -a xpg4
 770    -Xpg4plus                    -a xpg4plus
 771    -Xods30                      -a ods30
 772
 773    As with SCO, the default is XPG4 plus mode. SCO also allows you to
 774    specify a C dialect with -Xt, -Xa, -Xc, -Xk and -Xm. These are passed
 775    on to the assembler and linker in the same way that the SCO compiler
 776    does.
 777
 778    SCO also allows you to compile, link and generate either ELF or COFF
 779    binaries. With gcc, as with the SCO compiler, the default is coff.
 780    Specify -melf to gcc to produce elf binaries. -fpic will get the
 781    assembler and linker to produce PIC code.
 782 */
 783
 784 /* Set up assembler flags for PIC and ELF compilations */
 785 #undef ASM_SPEC
 786 #define ASM_SPEC \
 787  "-b %{melf:elf}%{!melf:coff \
 788    %{static:%e-static only valid with -melf} \
 789    %{shared:%e-shared only valid with -melf} \
 790    %{symbolic:%e-symbolic only valid with -melf}} \
 791   %{Ym,*} %{Yd,*} %{Wa,*:%*} \
 792   %{melf:-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}}"
 793
 794 /* Use crt1.o as a startup file and crtn.o as a closing file.  */
 795
 796 #undef STARTFILE_SPEC
 797 #define STARTFILE_SPEC \
 798  "%{!shared:\
 799    %{!symbolic: \
 800     %{pg:gcrt.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}} \
 801   %{!melf:crtbegin.o%s} \
 802   %{melf:%{ansi:values-Xc.o%s} \
 803     %{!ansi: \
 804      %{traditional:values-Xt.o%s} \
 805      %{!traditional: \
 806       %{Xa:values-Xa.o%s} \
 807        %{!Xa:%{Xc:values-Xc.o%s} \
 808         %{!Xc:%{Xk:values-Xk.o%s} \
 809          %{!Xk:%{Xt:values-Xt.o%s} \
 810           %{!Xt:values-Xa.o%s}}}}}} \
 811    %{static:crtbegin.o%s}%{!static:crtbeginS.o%s}}"
 812
 813 #undef ENDFILE_SPEC
 814 #define ENDFILE_SPEC \
 815  "%{melf:%{!static:crtendS.o%s}%{static:crtend.o%s}} \
 816   %{!melf:crtend.o%s} \
 817   %{pg:gcrtn.o%s}%{!pg:crtn.o%s}"
 818
 819 #undef CPP_PREDEFINES
 820 #define CPP_PREDEFINES \
 821  "-Di386 -Asystem(unix) -Asystem(svr3) -Acpu(i386) -Amachine(i386)"
 822
 823 /* You are in a maze of GCC specs ... all alike */
 824
 825 #undef CPP_SPEC
 826 #define CPP_SPEC \
 827  "%{melf:-Asystem(svr4) -D__svr4__} \
 828   %{fpic:%{!melf:%e-fpic is only valid with -melf}} \
 829   %{fPIC:%{!melf:%e-fPIC is only valid with -melf}} \
 830   -D__i386 -D__unix -D_SCO_DS=1 -D_M_I386 -D_M_XENIX -D_M_UNIX \
 831   %{!Xods30:-D_STRICT_NAMES} \
 832   %{!ansi:%{!posix:%{!Xods30:-D_SCO_XPG_VERS=4}}} \
 833   %{ansi:-D_STRICT_ANSI} \
 834   %{!ansi: \
 835    %{!Xpg4: \
 836     %{!Xpg4plus: \
 837      %{!Xods30: \
 838       %{posix:-D_POSIX_C_SOURCE=2 -D_POSIX_SOURCE}}}}} \
 839   %{!ansi: \
 840    %{!posix: \
 841     %{!Xods30: \
 842      %{!Xpg4plus: \
 843       %{Xpg4:-D_XOPEN_SOURCE}}}}} \
 844   %{!ansi: \
 845    %{!posix: \
 846     %{!Xpg4: \
 847      %{!Xpg4plus: \
 848       %{Xods30:-D_SCO_ODS_30 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \
 849                -DM_BITFIELDS -DM_SYS5 -DM_SYSV -DM_SYS3 -DM_SYSIII \
 850                -DM_WORDSWAP}}}}} \
 851   %{!ansi: \
 852    %{!posix: \
 853     %{!Xpg4:-D_M_I86 -D_M_I86SM -D_M_I86SM -D_M_SDATA -D_M_STEXT \
 854             -D_M_BITFIELDS -D_M_SYS5 -D_M_SYSV -D_M_SYS3 -D_M_SYSIII \
 855             -D_M_WORDSWAP -Di386 -Dunix -DM_I386 -DM_UNIX -DM_XENIX}}} \
 856   %{scointl:-DM_INTERNAT -D_M_INTERNAT} \
 857   %{traditional:-D_KR -D_SVID -D_NO_PROTOTYPE} \
 858   %{melf:-D_SCO_ELF -DM_ELF -D_M_ELF} \
 859   %{!melf:-D_M_COFF -DM_COFF -D_SCO_COFF} \
 860   %{melf:%{fpic:-D__PIC__ -D__pic__} \
 861          %{fPIC:%{!fpic:-D__PIC__ -D__pic__}}} \
 862   %{Xa:-D_SCO_C_DIALECT=1} \
 863    %{!Xa:%{Xc:-D_SCO_C_DIALECT=3} \
 864     %{!Xc:%{Xk:-D_SCO_C_DIALECT=4} \
 865      %{!Xk:%{Xt:-D_SCO_C_DIALECT=2  \
 866              %{!traditional:-traditional -D_KR -D_NO_PROTOTYPE}}}}} \
 867   %{traditional:-traditional -D_KR -D_NO_PROTOTYPE}"
 868
 869 #undef LINK_SPEC
 870 #define LINK_SPEC \
 871  "-b %{melf:elf}%{!melf:coff \
 872    %{static:%e-static only valid with -melf} \
 873    %{shared:%e-shared only valid with -melf} \
 874    %{symbolic:%e-symbolic only valid with -melf} \
 875    %{fpic:%e-fpic only valid with -melf} \
 876    %{fPIC:%e-fPIC only valid with -melf}} \
 877   -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}}}}},%{melf:ELF}%{!melf:COFF} \
 878   %{Wl,*%*} %{YP,*} %{YL,*} %{YU,*} \
 879   %{!YP,*:%{p:-YP,/usr/ccs/libp:/usr/libp:/usr/ccs/lib:/usr/lib} \
 880    %{!p:-YP,/usr/ccs/lib:/usr/lib}} \
 881   %{h*} %{static:-dn -Bstatic} %{shared:-G -dy %{!z*:-z text}} \
 882   %{symbolic:-Bsymbolic -G -dy %{!z*:-z text}} \
 883   %{G:-G} %{melf:%{Qn:} %{!Qy:-Qn}}"
 884
 885 /* Library spec. If we are not building a shared library, provide the
 886    standard libraries, as per the SCO compiler.  */
 887
 888 #undef LIB_SPEC
 889 #define LIB_SPEC \
 890  "%{!shared:%{!symbolic:-lcrypt -lgen -lc}}"
 891
 892 #undef LIBGCC_SPEC
 893 #define LIBGCC_SPEC \
 894  "%{!melf:-lgcc}%{melf:%{!shared:%{!symbolic:-lgcc-elf}}}"
 895
 896 #define MASK_ELF                010000000000    /* Mask for elf generation */
 897 #define TARGET_ELF              (target_flags & MASK_ELF)
 898
 899 #undef SUBTARGET_SWITCHES
 900 #define SUBTARGET_SWITCHES { "elf", MASK_ELF },
 901
 902 #define NO_DOLLAR_IN_LABEL
 903
 904 /*
 905 Here comes some major hackery to get the crt stuff to compile properly.
 906 Since we can (and do) compile for both COFF and ELF environments, we
 907 set things up accordingly, based on the pre-processor defines for ELF
 908 and COFF. This is insane, but then I guess having one compiler with a
 909 single back-end supporting two vastly different file format types is
 910 a little insane too. But it is not impossible and we get a useful
 911 compiler at the end of the day. Onward we go ...
 912 */
 913
 914 #if defined(CRT_BEGIN) || defined(CRT_END) || defined(IN_LIBGCC2)
 915 # if defined (_SCO_ELF)
 916 #  undef OBJECT_FORMAT_ELF
 917 #  define OBJECT_FORMAT_ELF
 918 #  undef INIT_SECTION_ASM_OP
 919 #  undef FINI_SECTION_ASM_OP
 920 #  undef DTORS_SECTION_ASM_OP
 921 #  undef CTORS_SECTION_ASM_OP
 922 #  undef CTOR_LIST_BEGIN
 923 #  undef CTOR_LIST_END
 924 #  undef DO_GLOBAL_CTORS_BODY
 925 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_ELF
 926 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_ELF
 927 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_ELF
 928 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_ELF
 929 #  define CTOR_LIST_BEGIN asm (CTORS_SECTION_ASM_OP_ELF); \
 930     STATIC func_ptr __CTOR_LIST__[1] = { (func_ptr) (-1) };
 931 #  define DO_GLOBAL_CTORS_BODY                                          \
 932 do {                                                                    \
 933     unsigned long nptrs = (unsigned long) __CTOR_LIST__[0];             \
 934     unsigned i;                                                         \
 935     if (nptrs == -1)                                                    \
 936       for (nptrs=0; __CTOR_LIST__[nptrs+1] != 0; nptrs++);              \
 937     for (i = nptrs; i >= 1; i--)                                        \
 938       __CTOR_LIST__[i] ();                                              \
 939 } while (0)
 940 # else /* ! _SCO_ELF */
 941 #  undef OBJECT_FORMAT_ELF
 942 #  undef INIT_SECTION_ASM_OP
 943 #  undef FINI_SECTION_ASM_OP
 944 #  undef DTORS_SECTION_ASM_OP
 945 #  undef CTORS_SECTION_ASM_OP
 946 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_COFF
 947 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_COFF
 948 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_COFF
 949 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_COFF
 950 #  undef CTOR_LIST_BEGIN
 951 #  undef CTOR_LIST_END
 952 #  undef DO_GLOBAL_CTORS_BODY
 953 #  define CTOR_LIST_BEGIN asm (INIT_SECTION_ASM_OP); asm ("pushl $0")
 954 #  define CTOR_LIST_END CTOR_LIST_BEGIN
 955 #  define DO_GLOBAL_CTORS_BODY                                          \
 956 do {                                                                    \
 957      func_ptr *p, *beg = alloca(0);                                     \
 958      for (p = beg; *p;)                                                 \
 959       (*p++) ();                                                        \
 960 } while (0)
 961 # endif /* ! _SCO_ELF */
 962 #endif /* CRT_BEGIN !! CRT_END */
 963