gcc/config/i386/sco5.h

   1 /* Definitions for Intel 386 running SCO Unix System V 3.2 Version 5.
   2    Copyright (C) 1992, 1995, 1996 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 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 /* The prefix to add to user-visible assembler symbols. */
 487
 488 #undef USER_LABEL_PREFIX
 489 #define USER_LABEL_PREFIX ""
 490
 491 #undef ASM_OUTPUT_SECTION_NAME
 492 #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \
 493 do {                                                                    \
 494   if (TARGET_ELF)                                                       \
 495     fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME,             \
 496            (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" :         \
 497            (DECL) && TREE_READONLY (DECL) ? "a" : "aw");                \
 498 } while (0)
 499
 500 #undef ASM_OUTPUT_SKIP
 501 #define ASM_OUTPUT_SKIP(FILE,SIZE) \
 502 do {                                                                    \
 503   if (TARGET_ELF)                                                       \
 504     fprintf (FILE, "%s\t%u\n", SKIP_ASM_OP, (SIZE));                    \
 505   else                                                                  \
 506     fprintf ((FILE), "%s\t.,.+%u\n", SET_ASM_OP, (SIZE));               \
 507 } while (0)
 508
 509
 510 #undef CTOR_LIST_BEGIN
 511 #define CTOR_LIST_BEGIN                                                 \
 512 do {                                                                    \
 513   asm (CTORS_SECTION_ASM_OP);                                           \
 514   if (TARGET_ELF)                                                       \
 515     STATIC func_ptr __CTOR_LIST__[1] = { (func_ptr) (-1) };             \
 516   else                                                                  \
 517     asm ("pushl $0");                                                   \
 518 } while (0)
 519
 520 #undef CTOR_LIST_END
 521 #define CTOR_LIST_END                                                   \
 522 do {                                                                    \
 523   if (TARGET_ELF) {                                                     \
 524     asm (CTORS_SECTION_ASM_OP);                                         \
 525     STATIC func_ptr __CTOR_LIST__[1] = { (func_ptr) (0) };              \
 526   } else {                                                              \
 527     CTOR_LIST_BEGIN;                                                    \
 528   }                                                                     \
 529 } while (0)
 530
 531 #undef DBX_BLOCKS_FUNCTION_RELATIVE
 532 #define DBX_BLOCKS_FUNCTION_RELATIVE 1
 533
 534 #undef DBX_FUNCTION_FIRST
 535 #define DBX_FUNCTION_FIRST 1
 536
 537 #undef DBX_REGISTER_NUMBER
 538 #define DBX_REGISTER_NUMBER(n)                                          \
 539 ((TARGET_ELF) ?                                                         \
 540  ((n) == 0 ? 0                                                          \
 541   : (n) == 1 ? 2                                                        \
 542   : (n) == 2 ? 1                                                        \
 543   : (n) == 3 ? 3                                                        \
 544   : (n) == 4 ? 6                                                        \
 545   : (n) == 5 ? 7                                                        \
 546   : (n) == 6 ? 5                                                        \
 547   : (n) == 7 ? 4                                                        \
 548   : ((n) >= FIRST_STACK_REG && (n) <= LAST_STACK_REG) ? (n)+3           \
 549   : (-1))                                                               \
 550  :                                                                      \
 551  ((n) == 0 ? 0 :                                                        \
 552   (n) == 1 ? 2 :                                                        \
 553   (n) == 2 ? 1 :                                                        \
 554   (n) == 3 ? 3 :                                                        \
 555   (n) == 4 ? 6 :                                                        \
 556   (n) == 5 ? 7 :                                                        \
 557   (n) == 6 ? 4 :                                                        \
 558   (n) == 7 ? 5 :                                                        \
 559   (n) + 4))
 560
 561 #undef DWARF_DEBUGGING_INFO
 562 #undef SDB_DEBUGGING_INFO
 563 #undef DBX_DEBUGGING_INFO
 564 #undef PREFERRED_DEBUGGING_TYPE
 565
 566 #define DWARF_DEBUGGING_INFO 1
 567 #define SDB_DEBUGGING_INFO   1
 568 #define PREFERRED_DEBUGGING_TYPE                                        \
 569   ((TARGET_ELF) ? DWARF_DEBUG: SDB_DEBUG)
 570
 571 #undef EXTRA_SECTIONS
 572 #define EXTRA_SECTIONS in_const, in_init, in_fini, in_ctors, in_dtors
 573
 574 #undef EXTRA_SECTION_FUNCTIONS
 575 #define EXTRA_SECTION_FUNCTIONS                                         \
 576   CONST_SECTION_FUNCTION                                                \
 577   INIT_SECTION_FUNCTION                                                 \
 578   FINI_SECTION_FUNCTION                                                 \
 579   CTORS_SECTION_FUNCTION                                                \
 580   DTORS_SECTION_FUNCTION
 581
 582 #undef CONST_SECTION_FUNCTION
 583 #define CONST_SECTION_FUNCTION                                          \
 584 void                                                                    \
 585 const_section ()                                                        \
 586 {                                                                       \
 587   extern void text_section();                                           \
 588   if (!USE_CONST_SECTION)                                               \
 589     text_section();                                                     \
 590   else if (in_section != in_const)                                      \
 591     {                                                                   \
 592       fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP);             \
 593       in_section = in_const;                                            \
 594     }                                                                   \
 595 }
 596
 597 #undef FINI_SECTION_FUNCTION
 598 #define FINI_SECTION_FUNCTION                                           \
 599 void                                                                    \
 600 fini_section ()                                                         \
 601 {                                                                       \
 602   if ((!TARGET_ELF) && in_section != in_fini)                           \
 603     {                                                                   \
 604       fprintf (asm_out_file, "%s\n", FINI_SECTION_ASM_OP);              \
 605       in_section = in_fini;                                             \
 606     }                                                                   \
 607 }
 608
 609 #undef INIT_SECTION_FUNCTION
 610 #define INIT_SECTION_FUNCTION                                           \
 611 void                                                                    \
 612 init_section ()                                                         \
 613 {                                                                       \
 614   if ((!TARGET_ELF) && in_section != in_init)                           \
 615     {                                                                   \
 616       fprintf (asm_out_file, "%s\n", INIT_SECTION_ASM_OP);              \
 617       in_section = in_init;                                             \
 618     }                                                                   \
 619 }
 620
 621 #undef CTORS_SECTION_FUNCTION
 622 #define CTORS_SECTION_FUNCTION                                          \
 623 void                                                                    \
 624 ctors_section ()                                                        \
 625 {                                                                       \
 626   if (in_section != in_ctors)                                           \
 627     {                                                                   \
 628       fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP);             \
 629       in_section = in_ctors;                                            \
 630     }                                                                   \
 631 }
 632
 633 #undef DTORS_SECTION_FUNCTION
 634 #define DTORS_SECTION_FUNCTION                                          \
 635 void                                                                    \
 636 dtors_section ()                                                        \
 637 {                                                                       \
 638   if (in_section != in_dtors)                                           \
 639     {                                                                   \
 640       fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP);             \
 641       in_section = in_dtors;                                            \
 642     }                                                                   \
 643 }
 644
 645 #undef FRAME_POINTER_REQUIRED
 646 #define FRAME_POINTER_REQUIRED                                          \
 647   ((TARGET_ELF) ? 0 :                                                   \
 648    (current_function_calls_setjmp || current_function_calls_longjmp))
 649
 650 #undef JUMP_TABLES_IN_TEXT_SECTION
 651 #define JUMP_TABLES_IN_TEXT_SECTION 1
 652
 653 #undef LOCAL_LABEL_PREFIX
 654 #define LOCAL_LABEL_PREFIX                                              \
 655  ((TARGET_ELF) ? "" : ".")
 656
 657 #undef MD_EXEC_PREFIX
 658 #undef MD_STARTFILE_PREFIX
 659 #define MD_EXEC_PREFIX "/usr/ccs/bin/"
 660 #define MD_STARTFILE_PREFIX "/usr/ccs/lib/"
 661
 662 #undef NON_SAVING_SETJMP
 663 #define NON_SAVING_SETJMP                                               \
 664   ((TARGET_ELF) ? 0 :                                                   \
 665    (current_function_calls_setjmp && current_function_calls_longjmp))
 666
 667 #undef NO_IMPLICIT_EXTERN_C
 668 #define NO_IMPLICIT_EXTERN_C 1
 669
 670 /* JKJ FIXME - examine the rammifications of RETURN_IN_MEMORY and
 671    RETURN_POPS_ARGS */
 672
 673 #undef RETURN_POPS_ARGS
 674 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE)                          \
 675  ((TARGET_ELF) ?                                                        \
 676   (i386_return_pops_args (FUNDECL, FUNTYPE, SIZE)) :                    \
 677   (TREE_CODE (FUNTYPE) == IDENTIFIER_NODE ? 0                           \
 678    : (TARGET_RTD                                                        \
 679       && (TYPE_ARG_TYPES (FUNTYPE) == 0                                 \
 680           || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE)))         \
 681               == void_type_node))) ? (SIZE)                             \
 682    : 0))
 683
 684 #undef SELECT_SECTION
 685 #define SELECT_SECTION(DECL,RELOC)                                      \
 686 {                                                                       \
 687   if (TREE_CODE (DECL) == STRING_CST)                                   \
 688     {                                                                   \
 689       if (! flag_writable_strings)                                      \
 690         const_section ();                                               \
 691       else                                                              \
 692         data_section ();                                                \
 693     }                                                                   \
 694   else if (TREE_CODE (DECL) == VAR_DECL)                                \
 695     {                                                                   \
 696       if ((TARGET_ELF && flag_pic && RELOC)                             \
 697           || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)          \
 698           || !DECL_INITIAL (DECL)                                       \
 699           || (DECL_INITIAL (DECL) != error_mark_node                    \
 700               && !TREE_CONSTANT (DECL_INITIAL (DECL))))                 \
 701         data_section ();                                                \
 702       else                                                              \
 703         const_section ();                                               \
 704     }                                                                   \
 705   else                                                                  \
 706     const_section ();                                                   \
 707 }
 708
 709 #undef SWITCH_TAKES_ARG
 710 #define SWITCH_TAKES_ARG(CHAR)                                          \
 711   (DEFAULT_SWITCH_TAKES_ARG(CHAR)                                       \
 712    || (CHAR) == 'h'                                                     \
 713    || (CHAR) == 'R'                                                     \
 714    || (CHAR) == 'Y'                                                     \
 715    || (CHAR) == 'z')
 716
 717 #undef WORD_SWITCH_TAKES_ARG
 718 #define WORD_SWITCH_TAKES_ARG(STR)                                      \
 719  (DEFAULT_WORD_SWITCH_TAKES_ARG (STR)                                   \
 720   && strcmp (STR, "Tdata") && strcmp (STR, "Ttext")                     \
 721   && strcmp (STR, "Tbss"))
 722
 723 #undef TARGET_DEFAULT
 724 #define TARGET_DEFAULT 0301
 725
 726 #undef HANDLE_SYSV_PRAGMA
 727 #define HANDLE_SYSV_PRAGMA 1
 728
 729 #undef SCCS_DIRECTIVE
 730 #define SCCS_DIRECTIVE 1
 731
 732 /*
 733  * Define sizes and types
 734  */
 735 #undef SIZE_TYPE
 736 #undef PTRDIFF_TYPE
 737 #undef WCHAR_TYPE
 738 #undef WCHAR_TYPE_SIZE
 739 #undef LONG_DOUBLE_TYPE_SIZE
 740 #define LONG_DOUBLE_TYPE_SIZE   96
 741 #define SIZE_TYPE               "unsigned int"
 742 #define PTRDIFF_TYPE            "int"
 743 #define WCHAR_TYPE              "long int"
 744 #define WCHAR_TYPE_SIZE         BITS_PER_WORD
 745
 746 \f
 747 /* Please note that these specs may look messy but they are required in
 748    order to emulate the SCO Development system as closely as possible.
 749    With SCO Open Server 5.0, you now get the linker and assembler free,
 750    so that is what these specs are targeted for. These utilities are
 751    very argument sensitive: a space in the wrong place breaks everything.
 752    So RMS, please forgive this mess. It works.
 753
 754    Parameters which can be passed to gcc, and their SCO equivalents:
 755    GCC Parameter                SCO Equivalent
 756    -ansi                        -a ansi
 757    -posix                       -a posix
 758    -Xpg4                        -a xpg4
 759    -Xpg4plus                    -a xpg4plus
 760    -Xods30                      -a ods30
 761
 762    As with SCO, the default is XPG4 plus mode. SCO also allows you to
 763    specify a C dialect with -Xt, -Xa, -Xc, -Xk and -Xm. These are passed
 764    on to the assembler and linker in the same way that the SCO compiler
 765    does.
 766
 767    SCO also allows you to compile, link and generate either ELF or COFF
 768    binaries. With gcc, as with the SCO compiler, the default is coff.
 769    Specify -melf to gcc to produce elf binaries. -fpic will get the
 770    assembler and linker to produce PIC code.
 771 */
 772
 773 /* Set up assembler flags for PIC and ELF compilations */
 774 #undef ASM_SPEC
 775 #define ASM_SPEC \
 776  "-b %{melf:elf}%{!melf:coff \
 777    %{static:%e-static only valid with -melf} \
 778    %{shared:%e-shared only valid with -melf} \
 779    %{symbolic:%e-symbolic only valid with -melf}} \
 780   %{Ym,*} %{Yd,*} %{Wa,*:%*} \
 781   %{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}}"
 782
 783 /* Use crt1.o as a startup file and crtn.o as a closing file.  */
 784
 785 #undef STARTFILE_SPEC
 786 #define STARTFILE_SPEC \
 787  "%{!shared:\
 788    %{!symbolic: \
 789     %{pg:gcrt.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}} \
 790   %{ansi:values-Xc.o%s} \
 791   %{!ansi: \
 792    %{traditional:values-Xt.o%s} \
 793     %{!traditional: \
 794      %{Xa:values-Xa.o%s} \
 795       %{!Xa:%{Xc:values-Xc.o%s} \
 796        %{!Xc:%{Xk:values-Xk.o%s} \
 797         %{!Xk:%{Xt:values-Xt.o%s} \
 798          %{!Xt:values-Xa.o%s}}}}}} \
 799   %{!melf:crtbegin.o%s} \
 800   %{melf:%{static:crtbegin.o%s}%{!static:crtbeginS.o%s}}"
 801
 802 #undef ENDFILE_SPEC
 803 #define ENDFILE_SPEC \
 804  "%{melf:%{!static:crtendS.o%s}%{static:crtend.o%s}} \
 805   %{!melf:crtend.o%s} \
 806   %{pg:gcrtn.o%s}%{!pg:crtn.o%s}"
 807
 808 #undef CPP_PREDEFINES
 809 #define CPP_PREDEFINES \
 810  "-Di386 -Asystem(unix) -Asystem(svr3) -Acpu(i386) -Amachine(i386)"
 811
 812 /* You are in a maze of GCC specs ... all alike */
 813
 814 #undef CPP_SPEC
 815 #define CPP_SPEC \
 816  "%{fpic:%{!melf:%e-fpic is only valid with -melf}} \
 817   %{fPIC:%{!melf:%e-fPIC is only valid with -melf}} \
 818   -D__i386 -D__unix -D_SCO_DS=1 -D_M_I386 -D_M_XENIX -D_M_UNIX \
 819   %{!Xods30:-D_STRICT_NAMES} \
 820   %{!ansi:%{!posix:%{!Xods30:-D_SCO_XPG_VERS=4}}} \
 821   %{ansi:-isystem include/ansi%s -isystem /usr/include/ansi -D_STRICT_ANSI} \
 822   %{!ansi: \
 823    %{posix:-isystem include/posix%s -isystem /usr/include/posix \
 824            -D_POSIX_C_SOURCE=2 -D_POSIX_SOURCE=1} \
 825     %{!posix:%{Xpg4:-isystem include/xpg4%s -isystem /usr/include/xpg4 \
 826                     -D_XOPEN_SOURCE=1} \
 827      %{!Xpg4:-D_M_I86 -D_M_I86SM -D_M_INTERNAT -D_M_SDATA -D_M_STEXT \
 828              -D_M_BITFIELDS -D_M_SYS5 -D_M_SYSV -D_M_SYSIII \
 829              -D_M_WORDSWAP -Dunix -DM_I386 -DM_UNIX -DM_XENIX \
 830              %{Xods30:-isystem include/ods_30_compat%s \
 831                       -isystem /usr/include/ods_30_compat \
 832                       -D_SCO_ODS_30 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \
 833                       -DM_BITFIELDS -DM_SYS5 -DM_SYSV -DM_INTERNAT -DM_SYSIII \
 834                       -DM_WORDSWAP}}}} \
 835   %{scointl:-DM_INTERNAT -D_M_INTERNAT} \
 836   %{traditional:-D_KR -D_SVID -D_NO_PROTOTYPE} \
 837   %{melf:-D_SCO_ELF} \
 838   %{!melf:-D_M_COFF -D_SCO_COFF} \
 839   %{melf:%{fpic:-D__PIC__ -D__pic__} \
 840          %{fPIC:%{!fpic:-D__PIC__ -D__pic__}}} \
 841   %{Xa:-D_SCO_C_DIALECT=1} \
 842   %{!Xa:%{Xc:-D_SCO_C_DIALECT=3} \
 843    %{!Xc:%{Xk:-D_SCO_C_DIALECT=4} \
 844     %{!Xk:%{Xt:-D_SCO_C_DIALECT=2} \
 845      %{!Xt:-D_SCO_C_DIALECT=1}}}} \
 846   %{traditional:-traditional -D_KR -D_NO_PROTOTYPE}"
 847
 848 #undef LINK_SPEC
 849 #define LINK_SPEC \
 850  "-b %{melf:elf}%{!melf:coff \
 851    %{static:%e-static only valid with -melf} \
 852    %{shared:%e-shared only valid with -melf} \
 853    %{symbolic:%e-symbolic only valid with -melf} \
 854    %{fpic:%e-fpic only valid with -melf} \
 855    %{fPIC:%e-fPIC only valid with -melf}} \
 856   -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} \
 857   %{Wl,*%*} %{YP,*} %{YL,*} %{YU,*} \
 858   %{!YP,*:%{p:-YP,/usr/ccs/libp:/lib/libp:/usr/lib/libp:/usr/ccs/lib:/lib:/usr/lib} \
 859    %{!p:-YP,/usr/ccs/lib:/lib:/usr/lib}} \
 860   %{h*} %{static:-dn -Bstatic} %{shared:-G -dy %{!z*:-z text}} \
 861   %{symbolic:-Bsymbolic -G -dy %{!z*:-z text}} %{z*} %{R*} %{Y*} \
 862   %{G:-G} %{melf:%{Qn:} %{!Qy:-Qn}}"
 863
 864 /* Library spec. If we are not building a shared library, provide the
 865    standard libraries, as per the SCO compiler.  */
 866
 867 #undef LIB_SPEC
 868 #define LIB_SPEC \
 869  "%{!shared:%{!symbolic:-lcrypt -lgen -lc}}"
 870
 871 #undef LIBGCC_SPEC
 872 #define LIBGCC_SPEC \
 873  "%{!melf:-lgcc}%{melf:%{!shared:%{!symbolic:-lgcc-elf}}}"
 874
 875 #define MASK_ELF                010000000000    /* Mask for elf generation */
 876 #define TARGET_ELF              (target_flags & MASK_ELF)
 877
 878 #undef SUBTARGET_SWITCHES
 879 #define SUBTARGET_SWITCHES { "elf", MASK_ELF },
 880
 881 #define NO_DOLLAR_IN_LABEL
 882
 883 /*
 884 Here comes some major hackery to get the crt stuff to compile properly.
 885 Since we can (and do) compile for both COFF and ELF environments, we
 886 set things up accordingly, based on the pre-processor defines for ELF
 887 and COFF. This is insane, but then I guess having one compiler with a
 888 single back-end supporting two vastly different file format types is
 889 a little insane too. But it is not impossible and we get a useful
 890 compiler at the end of the day. Onward we go ...
 891 */
 892
 893 #if defined(CRT_BEGIN) || defined(CRT_END) || defined(IN_LIBGCC2)
 894 # undef OBJECT_FORMAT_ELF
 895 # undef HAVE_ATEXIT
 896 # undef INIT_SECTION_ASM_OP
 897 # undef FINI_SECTION_ASM_OP
 898 # undef CTORS_SECTION_ASM_OP
 899 # undef DTORS_SECTION_ASM_OP
 900 # undef CTOR_LIST_BEGIN
 901 # undef CTOR_LIST_END
 902 # undef DO_GLOBAL_CTORS_BODY
 903
 904 # if defined (_SCO_ELF)
 905 #  define OBJECT_FORMAT_ELF
 906 #  define HAVE_ATEXIT
 907 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_ELF
 908 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_ELF
 909 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_ELF
 910 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_ELF
 911 # else /* ! _SCO_ELF */
 912 #  define INIT_SECTION_ASM_OP INIT_SECTION_ASM_OP_COFF
 913 #  define FINI_SECTION_ASM_OP FINI_SECTION_ASM_OP_COFF
 914 #  define DTORS_SECTION_ASM_OP DTORS_SECTION_ASM_OP_COFF
 915 #  define CTORS_SECTION_ASM_OP CTORS_SECTION_ASM_OP_COFF
 916 #  define CTOR_LIST_BEGIN asm (INIT_SECTION_ASM_OP); asm ("pushl $0")
 917 #  define CTOR_LIST_END CTOR_LIST_BEGIN
 918 #  define DO_GLOBAL_CTORS_BODY                                          \
 919 do {                                                                    \
 920      func_ptr *p, *beg = alloca(0);                                     \
 921      for (p = beg; *p;)                                                 \
 922       (*p++) ();                                                        \
 923 } while (0)
 924 # endif /* ! _SCO_ELF */
 925 #endif /* CRT_BEGIN !! CRT_END */
 926