gcc/config/alpha/vms.h

   1 /* Output variables, constants and external declarations, for GNU compiler.
   2    Copyright (C) 1996, 1997, 1998, 2000, 2001, 2002
   3    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 #define TARGET_OBJECT_SUFFIX ".obj"
  23 #define TARGET_EXECUTABLE_SUFFIX ".exe"
  24
  25 /* This enables certain macros in alpha.h, which will make an indirect
  26    reference to an external symbol an invalid address.  This needs to be
  27    defined before we include alpha.h, since it determines which macros
  28    are used for GO_IF_*.  */
  29
  30 #define NO_EXTERNAL_INDIRECT_ADDRESS
  31
  32 #include "alpha/alpha.h"
  33
  34 #undef CPP_PREDEFINES
  35 #define CPP_PREDEFINES \
  36 "-D__ALPHA -Dvms -DVMS -D__vms__ -D__VMS__ -Asystem=vms"
  37
  38 #undef CPP_SUBTARGET_SPEC
  39 #define CPP_SUBTARGET_SPEC "\
  40 %{mfloat-ieee:-D__IEEE_FLOAT} \
  41 %{mfloat-vax:-D__G_FLOAT} \
  42 %{!mfloat-vax:-D__IEEE_FLOAT}"
  43
  44 /* By default, allow $ to be part of an identifier.  */
  45 #define DOLLARS_IN_IDENTIFIERS 2
  46
  47 #undef TARGET_DEFAULT
  48 #define TARGET_DEFAULT (MASK_FP|MASK_FPREGS|MASK_GAS)
  49 #undef TARGET_ABI_OPEN_VMS
  50 #define TARGET_ABI_OPEN_VMS 1
  51
  52 #undef TARGET_NAME
  53 #define TARGET_NAME "OpenVMS/Alpha"
  54 #undef TARGET_VERSION
  55 #define TARGET_VERSION fprintf (stderr, " (%s)", TARGET_NAME);
  56
  57 /* The structure return address arrives as an "argument" on VMS.  */
  58 #undef STRUCT_VALUE_REGNUM
  59 #define STRUCT_VALUE 0
  60 #undef PCC_STATIC_STRUCT_RETURN
  61
  62 /* "long" is 32 bits, but 64 bits for Ada.  */
  63 #undef LONG_TYPE_SIZE
  64 #define LONG_TYPE_SIZE 32
  65 #define ADA_LONG_TYPE_SIZE 64
  66
  67 /* Pointer is 32 bits but the hardware has 64-bit addresses, sign extended.  */
  68 #undef POINTER_SIZE
  69 #define POINTER_SIZE 32
  70 #define POINTERS_EXTEND_UNSIGNED 0
  71
  72 #define MAX_OFILE_ALIGNMENT 524288  /* 8 x 2^16 by DEC Ada Test CD40VRA */
  73
  74 #undef FIXED_REGISTERS
  75 #define FIXED_REGISTERS  \
  76  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  77   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
  78   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  79   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
  80
  81 #undef CALL_USED_REGISTERS
  82 #define CALL_USED_REGISTERS  \
  83  {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
  84   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
  85   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
  86   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
  87
  88 /* List the order in which to allocate registers.  Each register must be
  89    listed once, even those in FIXED_REGISTERS.
  90
  91    We allocate in the following order:
  92    $f1                  (nonsaved floating-point register)
  93    $f10-$f15            (likewise)
  94    $f22-$f30            (likewise)
  95    $f21-$f16            (likewise, but input args)
  96    $f0                  (nonsaved, but return value)
  97    $f2-$f9              (saved floating-point registers)
  98    $1                   (nonsaved integer registers)
  99    $22-$25              (likewise)
 100    $28                  (likewise)
 101    $0                   (likewise, but return value)
 102    $21-$16              (likewise, but input args)
 103    $27                  (procedure value in OSF, nonsaved in NT)
 104    $2-$8                (saved integer registers)
 105    $9-$14               (saved integer registers)
 106    $26                  (return PC)
 107    $15                  (frame pointer)
 108    $29                  (global pointer)
 109    $30, $31, $f31       (stack pointer and always zero/ap & fp)  */
 110
 111 #undef REG_ALLOC_ORDER
 112 #define REG_ALLOC_ORDER         \
 113   {33,                                  \
 114    42, 43, 44, 45, 46, 47,              \
 115    54, 55, 56, 57, 58, 59, 60, 61, 62,  \
 116    53, 52, 51, 50, 49, 48,              \
 117    32,                                  \
 118    34, 35, 36, 37, 38, 39, 40, 41,      \
 119    1,                                   \
 120    22, 23, 24, 25,                      \
 121    28,                                  \
 122    0,                                   \
 123    21, 20, 19, 18, 17, 16,              \
 124    27,                                  \
 125    2, 3, 4, 5, 6, 7, 8,                 \
 126    9, 10, 11, 12, 13, 14,               \
 127    26,                                  \
 128    15,                                  \
 129    29,                                  \
 130    30, 31, 63 }
 131
 132 #undef HARD_FRAME_POINTER_REGNUM
 133 #define HARD_FRAME_POINTER_REGNUM 29
 134
 135 /* Define registers used by the epilogue and return instruction.  */
 136 #undef EPILOGUE_USES
 137 #define EPILOGUE_USES(REGNO)    ((REGNO) == 26 || (REGNO) == 29)
 138
 139 #undef CAN_ELIMINATE
 140 #define CAN_ELIMINATE(FROM, TO)  \
 141 ((TO) != STACK_POINTER_REGNUM || ! alpha_using_fp ())
 142
 143 #undef INITIAL_ELIMINATION_OFFSET
 144 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
 145 { if ((FROM) == FRAME_POINTER_REGNUM)                                   \
 146     (OFFSET) = alpha_sa_size () + alpha_pv_save_size ();                \
 147   else if ((FROM) == ARG_POINTER_REGNUM)                                \
 148     (OFFSET) = (ALPHA_ROUND (alpha_sa_size () + alpha_pv_save_size ()   \
 149                              + get_frame_size ()                        \
 150                              + current_function_pretend_args_size)      \
 151                 - current_function_pretend_args_size);                  \
 152   else                                                                  \
 153     abort();                                                            \
 154   if ((TO) == STACK_POINTER_REGNUM)                                     \
 155     (OFFSET) += ALPHA_ROUND (current_function_outgoing_args_size);      \
 156 }
 157 \f
 158 /* Define a data type for recording info about an argument list
 159    during the scan of that argument list.  This data type should
 160    hold all necessary information about the function itself
 161    and about the args processed so far, enough to enable macros
 162    such as FUNCTION_ARG to determine where the next arg should go.
 163
 164    On Alpha/VMS, this is a structure that contains the number of
 165    arguments and, for each argument, the datatype of that argument.
 166
 167    The number of arguments is a number of words of arguments scanned so far.
 168    Thus 6 or more means all following args should go on the stack.  */
 169
 170 enum avms_arg_type {I64, FF, FD, FG, FS, FT};
 171 typedef struct {int num_args; enum avms_arg_type atypes[6];} avms_arg_info;
 172
 173 #undef CUMULATIVE_ARGS
 174 #define CUMULATIVE_ARGS avms_arg_info
 175
 176 /* Initialize a variable CUM of type CUMULATIVE_ARGS
 177    for a call to a function whose data type is FNTYPE.
 178    For a library call, FNTYPE is 0.  */
 179
 180 #undef INIT_CUMULATIVE_ARGS
 181 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
 182   (CUM).num_args = 0;                                           \
 183   (CUM).atypes[0] = (CUM).atypes[1] = (CUM).atypes[2] = I64;    \
 184   (CUM).atypes[3] = (CUM).atypes[4] = (CUM).atypes[5] = I64;
 185
 186 #undef FUNCTION_ARG_ADVANCE
 187 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
 188   if (MUST_PASS_IN_STACK (MODE, TYPE))                                  \
 189     (CUM).num_args += 6;                                                \
 190   else                                                                  \
 191     {                                                                   \
 192       if ((CUM).num_args < 6)                                           \
 193         (CUM).atypes[(CUM).num_args] = alpha_arg_type (MODE);           \
 194                                                                         \
 195      (CUM).num_args += ALPHA_ARG_SIZE (MODE, TYPE, NAMED);              \
 196     }
 197
 198 /* For an arg passed partly in registers and partly in memory,
 199    this is the number of registers used.
 200    For args passed entirely in registers or entirely in memory, zero.  */
 201
 202 #undef FUNCTION_ARG_PARTIAL_NREGS
 203 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED)              \
 204 ((CUM).num_args < 6 && 6 < (CUM).num_args                               \
 205    + ALPHA_ARG_SIZE (MODE, TYPE, NAMED)                                 \
 206  ? 6 - (CUM).num_args : 0)
 207
 208 /* Perform any needed actions needed for a function that is receiving a
 209    variable number of arguments.
 210
 211    CUM is as for INIT_CUMULATIVE_ARGS.
 212
 213    MODE and TYPE are the mode and type of the current parameter.
 214
 215    PRETEND_SIZE is a variable that should be set to the amount of stack
 216    that must be pushed by the prolog to pretend that our caller pushed
 217    it.
 218
 219    Normally, this macro will push all remaining incoming registers on the
 220    stack and set PRETEND_SIZE to the length of the registers pushed.
 221
 222    For VMS, we allocate space for all 6 arg registers plus a count.
 223
 224    However, if NO registers need to be saved, don't allocate any space.
 225    This is not only because we won't need the space, but because AP includes
 226    the current_pretend_args_size and we don't want to mess up any
 227    ap-relative addresses already made.  */
 228
 229 #undef SETUP_INCOMING_VARARGS
 230 #define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL)       \
 231 { if ((CUM).num_args < 6)                               \
 232     {                                                   \
 233       if (! (NO_RTL))                                   \
 234         {                                               \
 235           emit_move_insn (gen_rtx_REG (DImode, 1),      \
 236                           virtual_incoming_args_rtx);   \
 237           emit_insn (gen_arg_home ());                  \
 238         }                                               \
 239                                                         \
 240       PRETEND_SIZE = 7 * UNITS_PER_WORD;                \
 241     }                                                   \
 242 }
 243
 244 /* ABI has stack checking, but it's broken.  */
 245 #undef STACK_CHECK_BUILTIN
 246 #define STACK_CHECK_BUILTIN 0
 247
 248 #undef ASM_FILE_START
 249 #define ASM_FILE_START(FILE)                                    \
 250 {                                                               \
 251   alpha_write_verstamp (FILE);                                  \
 252   fprintf (FILE, "\t.set noreorder\n");                         \
 253   fprintf (FILE, "\t.set volatile\n");                          \
 254   ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename);       \
 255 }
 256
 257 #define LINK_SECTION_ASM_OP "\t.link"
 258 #define READONLY_SECTION_ASM_OP "\t.rdata"
 259 #define LITERALS_SECTION_ASM_OP "\t.literals"
 260 #define CTORS_SECTION_ASM_OP "\t.ctors"
 261 #define DTORS_SECTION_ASM_OP "\t.dtors"
 262
 263 #undef EXTRA_SECTIONS
 264 #define EXTRA_SECTIONS  in_link, in_rdata, in_literals
 265
 266 #undef EXTRA_SECTION_FUNCTIONS
 267 #define EXTRA_SECTION_FUNCTIONS                                 \
 268 void                                                            \
 269 readonly_section ()                                             \
 270 {                                                               \
 271   if (in_section != in_rdata)                           \
 272     {                                                           \
 273       fprintf (asm_out_file, "%s\n", READONLY_SECTION_ASM_OP);  \
 274       in_section = in_rdata;                            \
 275     }                                                           \
 276 }                                                               \
 277 void                                                            \
 278 link_section ()                                                 \
 279 {                                                               \
 280   if (in_section != in_link)                                    \
 281     {                                                           \
 282       fprintf (asm_out_file, "%s\n", LINK_SECTION_ASM_OP);      \
 283       in_section = in_link;                                     \
 284     }                                                           \
 285 }                                                               \
 286 void                                                            \
 287 literals_section ()                                             \
 288 {                                                               \
 289   if (in_section != in_literals)                                \
 290     {                                                           \
 291       fprintf (asm_out_file, "%s\n", LITERALS_SECTION_ASM_OP);  \
 292       in_section = in_literals;                                 \
 293     }                                                           \
 294 }
 295
 296 extern void readonly_section    PARAMS ((void));
 297 extern void link_section        PARAMS ((void));
 298 extern void literals_section    PARAMS ((void));
 299
 300 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 301 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) abort ()
 302
 303 #undef ASM_OUTPUT_ADDR_VEC_ELT
 304 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
 305   fprintf (FILE, "\t.quad $L%d\n", (VALUE))
 306
 307 #undef READONLY_DATA_SECTION
 308 #define READONLY_DATA_SECTION readonly_section
 309
 310 #define ASM_FILE_END(FILE) alpha_write_linkage (FILE);
 311
 312 #undef CASE_VECTOR_MODE
 313 #define CASE_VECTOR_MODE DImode
 314 #undef CASE_VECTOR_PC_RELATIVE
 315
 316 #undef ASM_OUTPUT_CASE_LABEL
 317 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
 318 { ASM_OUTPUT_ALIGN (FILE, 3); ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); }
 319
 320 /* This says how to output assembler code to declare an
 321    uninitialized external linkage data object.  */
 322
 323 #define COMMON_ASM_OP "\t.comm\t"
 324
 325 #undef ASM_OUTPUT_ALIGNED_COMMON
 326 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 327 do {                                                                    \
 328   fprintf ((FILE), "%s", COMMON_ASM_OP);                                \
 329   assemble_name ((FILE), (NAME));                                       \
 330   fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);        \
 331 } while (0)
 332
 333 \f
 334 /* Output assembler code for a block containing the constant parts
 335    of a trampoline, leaving space for the variable parts.
 336
 337    The trampoline should set the static chain pointer to value placed
 338    into the trampoline and should branch to the specified routine.
 339    Note that $27 has been set to the address of the trampoline, so we can
 340    use it for addressability of the two data items.  */
 341
 342 #undef TRAMPOLINE_TEMPLATE
 343 #define TRAMPOLINE_TEMPLATE(FILE)               \
 344 {                                               \
 345   fprintf (FILE, "\t.quad 0\n");                \
 346   fprintf (FILE, "\t.linkage __tramp\n");       \
 347   fprintf (FILE, "\t.quad 0\n");                \
 348 }
 349
 350 /* Length in units of the trampoline for entering a nested function.  */
 351
 352 #undef TRAMPOLINE_SIZE
 353 #define TRAMPOLINE_SIZE    32
 354
 355 /* The alignment of a trampoline, in bits.  */
 356
 357 #undef TRAMPOLINE_ALIGNMENT
 358 #define TRAMPOLINE_ALIGNMENT  64
 359
 360 /* Emit RTL insns to initialize the variable parts of a trampoline.
 361    FNADDR is an RTX for the address of the function's pure code.
 362    CXT is an RTX for the static chain value for the function.  */
 363
 364 #undef INITIALIZE_TRAMPOLINE
 365 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
 366   alpha_initialize_trampoline (TRAMP, FNADDR, CXT, 16, 24, -1)
 367
 368 /* Control how constructors and destructors are emitted.  */
 369 #define TARGET_ASM_CONSTRUCTOR  vms_asm_out_constructor
 370 #define TARGET_ASM_DESTRUCTOR   vms_asm_out_destructor
 371
 372 #undef SDB_DEBUGGING_INFO
 373 #undef MIPS_DEBUGGING_INFO
 374 #undef DBX_DEBUGGING_INFO
 375
 376 #define DWARF2_DEBUGGING_INFO
 377 #define VMS_DEBUGGING_INFO
 378
 379 #define DWARF2_UNWIND_INFO 1
 380
 381 #undef EH_RETURN_HANDLER_RTX
 382 #define EH_RETURN_HANDLER_RTX \
 383   gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, 8))
 384
 385 #define LINK_EH_SPEC "vms-dwarf2eh.o%s"
 386
 387 #ifdef IN_LIBGCC2
 388 #include <libicb.h>
 389 #include <pdscdef.h>
 390 #endif
 391
 392 #define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)               \
 393  do {                                                                   \
 394   unsigned long handle;                                                 \
 395   PDSCDEF *pv;                                                          \
 396   INVO_CONTEXT_BLK invo;                                                \
 397                                                                         \
 398   memset (&invo, 0, sizeof INVO_CONTEXT_BLK);                           \
 399                                                                         \
 400   invo.libicb$q_ireg [29] = *((long long *) (CONTEXT)->reg [29]);       \
 401   invo.libicb$q_ireg [30] = (long long) (CONTEXT)->cfa                  \
 402   handle = LIB$GET_INVO_HANDLE (&invo);                                 \
 403   LIB$GET_INVO_CONTEXT (handle, &invo);                                 \
 404   pv = (PDSCDEF *) invo.libicb$ph_procedure_descriptor;                 \
 405                                                                         \
 406   if (pv && ((pv->pdsc$w_flags & 0xf) == PDSC$K_KIND_FP_STACK))         \
 407     {                                                                   \
 408       int i, j;                                                         \
 409                                                                         \
 410       (FS)->cfa_offset = pv->pdsc$l_size;                               \
 411       (FS)->cfg_reg = pv->pdsc$w_flags & PDSC$M_BASE_REG_IS_FP ? 29 : 30; \
 412       (FS)->retaddr_column = 26;                                        \
 413       (FS)->cfa_how = CFA_REG_OFFSET;                                   \
 414       (FS)->regs.reg[27].loc.offset = -pv->pdsc$l_size;                 \
 415       (FS)->regs.reg[27].how = REG_SAVED_OFFSET;                        \
 416       (FS)->regs.reg[26].loc.offset                                     \
 417          = pv->pdsc$w_rsa_offset - pv->pdsc$l_size);                    \
 418       (FS)->regs.reg[26].how = REG_SAVED_OFFSET;                        \
 419                                                                         \
 420       for (i = 0, j = 0; i < 32; i++)                                   \
 421         if (1<<i & pv->pdsc$l_ireg_mask)                                \
 422           {                                                             \
 423             (FS)->regs.reg[i].loc.offset                                \
 424               = pv->pdsc$l_size - pv->pdsc$w_rsa_offset - 8 * j++;      \
 425             (FS)->regs.reg[i].how = REG_SAVED_OFFSET;                   \
 426           }                                                             \
 427                                                                         \
 428       goto SUCCESS;                                                     \
 429     }                                                                   \
 430 } while (0)
 431
 432 /* This is how to output an assembler line
 433    that says to advance the location counter
 434    to a multiple of 2**LOG bytes.  */
 435
 436 #undef ASM_OUTPUT_ALIGN
 437 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 438     fprintf (FILE, "\t.align %d\n", LOG);
 439
 440 /* Switch into a generic section.  */
 441 #define TARGET_ASM_NAMED_SECTION vms_asm_named_section
 442
 443 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
 444   do {  literals_section();                                             \
 445         fprintf ((FILE), "\t");                                         \
 446         assemble_name (FILE, LABEL1);                                   \
 447         fprintf (FILE, " = ");                                          \
 448         assemble_name (FILE, LABEL2);                                   \
 449         fprintf (FILE, "\n");                                           \
 450   } while (0)
 451
 452 #undef PREFERRED_DEBUGGING_TYPE
 453 #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
 454
 455 #undef ASM_FORMAT_PRIVATE_NAME
 456 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 457 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
 458   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 459
 460 /* ??? VMS uses different linkage.  */
 461 #undef ASM_OUTPUT_MI_THUNK
 462
 463 #undef ASM_SPEC
 464 #undef ASM_FINAL_SPEC
 465
 466 /* The VMS convention is to always provide minimal debug info
 467    for a traceback unless specifically overridden.  Defaulting this here
 468    is a kludge.  */
 469
 470 #define OPTIMIZATION_OPTIONS(OPTIMIZE, OPTIMIZE_SIZE) \
 471 {                                                  \
 472    write_symbols = VMS_DEBUG;                      \
 473    debug_info_level = (enum debug_info_level) 1;   \
 474 }
 475
 476 /* Override traceback debug info on -g0.  */
 477 #undef OVERRIDE_OPTIONS
 478 #define OVERRIDE_OPTIONS                           \
 479 {                                                  \
 480    if (write_symbols == NO_DEBUG)                  \
 481      debug_info_level = (enum debug_info_level) 0; \
 482    override_options ();                            \
 483 }
 484
 485 /* Link with vms-dwarf2.o if -g (except -g0). This causes the
 486    VMS link to pull all the dwarf2 debug sections together. */
 487 #undef LINK_SPEC
 488 #define LINK_SPEC "%{g:-g vms-dwarf2.o%s} %{g0} %{g1:-g1 vms-dwarf2.o%s} \
 489 %{g2:-g2 vms-dwarf2.o%s} %{g3:-g3 vms-dwarf2.o%s} %{shared} %{v} %{map}"
 490
 491 #undef STARTFILE_SPEC
 492 #define STARTFILE_SPEC "%{!shared:%{mvms-return-codes:vcrt0.o%s} \
 493 %{!mvms-return-codes:pcrt0.o%s}}"
 494
 495 #undef LIB_SPEC
 496 #define LIB_SPEC "-lc"
 497
 498 /* Define the names of the division and modulus functions.  */
 499 #define DIVSI3_LIBCALL "OTS$DIV_I"
 500 #define DIVDI3_LIBCALL "OTS$DIV_L"
 501 #define UDIVSI3_LIBCALL "OTS$DIV_UI"
 502 #define UDIVDI3_LIBCALL "OTS$DIV_UL"
 503 #define MODSI3_LIBCALL "OTS$REM_I"
 504 #define MODDI3_LIBCALL "OTS$REM_L"
 505 #define UMODSI3_LIBCALL "OTS$REM_UI"
 506 #define UMODDI3_LIBCALL "OTS$REM_UL"
 507
 508 #define NAME__MAIN "__gccmain"
 509 #define SYMBOL__MAIN __gccmain
 510
 511 /* Specify the list of include file directories.  */
 512 #define INCLUDE_DEFAULTS                \
 513 {                                       \
 514   { "/gnu_gxx_include", 0, 1, 1 },      \
 515   { "/gnu_cc_include", 0, 0, 0 },       \
 516   { "/gnu/include", 0, 0, 0 },          \
 517   { 0, 0, 0, 0 }                        \
 518 }