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   if (TARGET_BWX | TARGET_MAX | TARGET_FIX | TARGET_CIX)        \
 255     {                                                           \
 256       fprintf (FILE, "\t.arch %s\n",                            \
 257                (TARGET_CPU_EV6 ? "ev6"                          \
 258                 : TARGET_MAX ? "pca56" : "ev56"));              \
 259     }                                                           \
 260   ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename);       \
 261 }
 262
 263 #define LINK_SECTION_ASM_OP "\t.link"
 264 #define READONLY_SECTION_ASM_OP "\t.rdata"
 265 #define LITERALS_SECTION_ASM_OP "\t.literals"
 266 #define CTORS_SECTION_ASM_OP "\t.ctors"
 267 #define DTORS_SECTION_ASM_OP "\t.dtors"
 268
 269 #undef EXTRA_SECTIONS
 270 #define EXTRA_SECTIONS  in_link, in_rdata, in_literals
 271
 272 #undef EXTRA_SECTION_FUNCTIONS
 273 #define EXTRA_SECTION_FUNCTIONS                                 \
 274 void                                                            \
 275 readonly_section ()                                             \
 276 {                                                               \
 277   if (in_section != in_rdata)                           \
 278     {                                                           \
 279       fprintf (asm_out_file, "%s\n", READONLY_SECTION_ASM_OP);  \
 280       in_section = in_rdata;                            \
 281     }                                                           \
 282 }                                                               \
 283 void                                                            \
 284 link_section ()                                                 \
 285 {                                                               \
 286   if (in_section != in_link)                                    \
 287     {                                                           \
 288       fprintf (asm_out_file, "%s\n", LINK_SECTION_ASM_OP);      \
 289       in_section = in_link;                                     \
 290     }                                                           \
 291 }                                                               \
 292 void                                                            \
 293 literals_section ()                                             \
 294 {                                                               \
 295   if (in_section != in_literals)                                \
 296     {                                                           \
 297       fprintf (asm_out_file, "%s\n", LITERALS_SECTION_ASM_OP);  \
 298       in_section = in_literals;                                 \
 299     }                                                           \
 300 }
 301
 302 extern void readonly_section    PARAMS ((void));
 303 extern void link_section        PARAMS ((void));
 304 extern void literals_section    PARAMS ((void));
 305
 306 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 307 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) abort ()
 308
 309 #undef ASM_OUTPUT_ADDR_VEC_ELT
 310 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
 311   fprintf (FILE, "\t.quad $L%d\n", (VALUE))
 312
 313 #undef READONLY_DATA_SECTION
 314 #define READONLY_DATA_SECTION readonly_section
 315
 316 #define ASM_FILE_END(FILE) alpha_write_linkage (FILE);
 317
 318 #undef CASE_VECTOR_MODE
 319 #define CASE_VECTOR_MODE DImode
 320 #undef CASE_VECTOR_PC_RELATIVE
 321
 322 #undef ASM_OUTPUT_CASE_LABEL
 323 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
 324 { ASM_OUTPUT_ALIGN (FILE, 3); ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); }
 325
 326 /* This says how to output assembler code to declare an
 327    uninitialized external linkage data object.  */
 328
 329 #define COMMON_ASM_OP "\t.comm\t"
 330
 331 #undef ASM_OUTPUT_ALIGNED_COMMON
 332 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
 333 do {                                                                    \
 334   fprintf ((FILE), "%s", COMMON_ASM_OP);                                \
 335   assemble_name ((FILE), (NAME));                                       \
 336   fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);        \
 337 } while (0)
 338
 339 \f
 340 /* Output assembler code for a block containing the constant parts
 341    of a trampoline, leaving space for the variable parts.
 342
 343    The trampoline should set the static chain pointer to value placed
 344    into the trampoline and should branch to the specified routine.
 345    Note that $27 has been set to the address of the trampoline, so we can
 346    use it for addressability of the two data items.  */
 347
 348 #undef TRAMPOLINE_TEMPLATE
 349 #define TRAMPOLINE_TEMPLATE(FILE)               \
 350 {                                               \
 351   fprintf (FILE, "\t.quad 0\n");                \
 352   fprintf (FILE, "\t.linkage __tramp\n");       \
 353   fprintf (FILE, "\t.quad 0\n");                \
 354 }
 355
 356 /* Length in units of the trampoline for entering a nested function.  */
 357
 358 #undef TRAMPOLINE_SIZE
 359 #define TRAMPOLINE_SIZE    32
 360
 361 /* The alignment of a trampoline, in bits.  */
 362
 363 #undef TRAMPOLINE_ALIGNMENT
 364 #define TRAMPOLINE_ALIGNMENT  64
 365
 366 /* Emit RTL insns to initialize the variable parts of a trampoline.
 367    FNADDR is an RTX for the address of the function's pure code.
 368    CXT is an RTX for the static chain value for the function.  */
 369
 370 #undef INITIALIZE_TRAMPOLINE
 371 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
 372   alpha_initialize_trampoline (TRAMP, FNADDR, CXT, 16, 24, -1)
 373
 374 /* Control how constructors and destructors are emitted.  */
 375 #define TARGET_ASM_CONSTRUCTOR  vms_asm_out_constructor
 376 #define TARGET_ASM_DESTRUCTOR   vms_asm_out_destructor
 377
 378 #undef SDB_DEBUGGING_INFO
 379 #undef MIPS_DEBUGGING_INFO
 380 #undef DBX_DEBUGGING_INFO
 381
 382 #define DWARF2_DEBUGGING_INFO
 383 #define VMS_DEBUGGING_INFO
 384
 385 #define DWARF2_UNWIND_INFO 1
 386
 387 #undef EH_RETURN_HANDLER_RTX
 388 #define EH_RETURN_HANDLER_RTX \
 389   gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, 8))
 390
 391 #define LINK_EH_SPEC "vms-dwarf2eh.o%s "
 392
 393 #ifdef IN_LIBGCC2
 394 #include <pdscdef.h>
 395
 396 #define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)               \
 397  do {                                                                   \
 398   PDSCDEF *pv = *((PDSCDEF **) (CONTEXT)->reg [29]);                    \
 399                                                                         \
 400   if (pv && ((long) pv & 0x7) == 0) /* low bits 0 means address */      \
 401     pv = *(PDSCDEF **) pv;                                              \
 402                                                                         \
 403   if (pv && ((pv->pdsc$w_flags & 0xf) == PDSC$K_KIND_FP_STACK))         \
 404     {                                                                   \
 405       int i, j;                                                         \
 406                                                                         \
 407       (FS)->cfa_offset = pv->pdsc$l_size;                               \
 408       (FS)->cfa_reg = pv->pdsc$w_flags & PDSC$M_BASE_REG_IS_FP ? 29 : 30; \
 409       (FS)->retaddr_column = 26;                                        \
 410       (FS)->cfa_how = CFA_REG_OFFSET;                                   \
 411       (FS)->regs.reg[27].loc.offset = -pv->pdsc$l_size;                 \
 412       (FS)->regs.reg[27].how = REG_SAVED_OFFSET;                        \
 413       (FS)->regs.reg[26].loc.offset                                     \
 414          = -(pv->pdsc$l_size - pv->pdsc$w_rsa_offset);                  \
 415       (FS)->regs.reg[26].how = REG_SAVED_OFFSET;                        \
 416                                                                         \
 417       for (i = 0, j = 0; i < 32; i++)                                   \
 418         if (1<<i & pv->pdsc$l_ireg_mask)                                \
 419           {                                                             \
 420             (FS)->regs.reg[i].loc.offset                                \
 421               = -(pv->pdsc$l_size - pv->pdsc$w_rsa_offset - 8 * ++j);   \
 422             (FS)->regs.reg[i].how = REG_SAVED_OFFSET;                   \
 423           }                                                             \
 424                                                                         \
 425       goto SUCCESS;                                                     \
 426     }                                                                   \
 427   else if (pv && ((pv->pdsc$w_flags & 0xf) == PDSC$K_KIND_FP_REGISTER)) \
 428     {                                                                   \
 429       (FS)->cfa_offset = pv->pdsc$l_size;                               \
 430       (FS)->cfa_reg = pv->pdsc$w_flags & PDSC$M_BASE_REG_IS_FP ? 29 : 30; \
 431       (FS)->retaddr_column = 26;                                        \
 432       (FS)->cfa_how = CFA_REG_OFFSET;                                   \
 433       (FS)->regs.reg[26].loc.reg = pv->pdsc$b_save_ra;                  \
 434       (FS)->regs.reg[26].how = REG_SAVED_REG;                           \
 435       (FS)->regs.reg[29].loc.reg = pv->pdsc$b_save_fp;                  \
 436       (FS)->regs.reg[29].how = REG_SAVED_REG;                           \
 437                                                                         \
 438       goto SUCCESS;                                                     \
 439     }                                                                   \
 440 } while (0)
 441 #endif
 442
 443 /* This is how to output an assembler line
 444    that says to advance the location counter
 445    to a multiple of 2**LOG bytes.  */
 446
 447 #undef ASM_OUTPUT_ALIGN
 448 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 449     fprintf (FILE, "\t.align %d\n", LOG);
 450
 451 /* Switch into a generic section.  */
 452 #define TARGET_ASM_NAMED_SECTION vms_asm_named_section
 453
 454 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
 455   do {  literals_section();                                             \
 456         fprintf ((FILE), "\t");                                         \
 457         assemble_name (FILE, LABEL1);                                   \
 458         fprintf (FILE, " = ");                                          \
 459         assemble_name (FILE, LABEL2);                                   \
 460         fprintf (FILE, "\n");                                           \
 461   } while (0)
 462
 463 #undef PREFERRED_DEBUGGING_TYPE
 464 #define PREFERRED_DEBUGGING_TYPE VMS_AND_DWARF2_DEBUG
 465
 466 #undef ASM_FORMAT_PRIVATE_NAME
 467 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 468 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
 469   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 470
 471 /* ??? VMS uses different linkage.  */
 472 #undef ASM_OUTPUT_MI_THUNK
 473
 474 #undef ASM_SPEC
 475 #undef ASM_FINAL_SPEC
 476
 477 /* The VMS convention is to always provide minimal debug info
 478    for a traceback unless specifically overridden.  Defaulting this here
 479    is a kludge.  */
 480
 481 #define OPTIMIZATION_OPTIONS(OPTIMIZE, OPTIMIZE_SIZE) \
 482 {                                                  \
 483    write_symbols = VMS_DEBUG;                      \
 484    debug_info_level = (enum debug_info_level) 1;   \
 485 }
 486
 487 /* Override traceback debug info on -g0.  */
 488 #undef OVERRIDE_OPTIONS
 489 #define OVERRIDE_OPTIONS                           \
 490 {                                                  \
 491    if (write_symbols == NO_DEBUG)                  \
 492      debug_info_level = (enum debug_info_level) 0; \
 493    override_options ();                            \
 494 }
 495
 496 /* Link with vms-dwarf2.o if -g (except -g0). This causes the
 497    VMS link to pull all the dwarf2 debug sections together. */
 498 #undef LINK_SPEC
 499 #define LINK_SPEC "%{g:-g vms-dwarf2.o%s} %{g0} %{g1:-g1 vms-dwarf2.o%s} \
 500 %{g2:-g2 vms-dwarf2.o%s} %{g3:-g3 vms-dwarf2.o%s} %{shared} %{v} %{map}"
 501
 502 #undef STARTFILE_SPEC
 503 #define STARTFILE_SPEC "%{!shared:%{mvms-return-codes:vcrt0.o%s} \
 504 %{!mvms-return-codes:pcrt0.o%s}}"
 505
 506 #undef LIB_SPEC
 507 #define LIB_SPEC "-lc"
 508
 509 /* Define the names of the division and modulus functions.  */
 510 #define DIVSI3_LIBCALL "OTS$DIV_I"
 511 #define DIVDI3_LIBCALL "OTS$DIV_L"
 512 #define UDIVSI3_LIBCALL "OTS$DIV_UI"
 513 #define UDIVDI3_LIBCALL "OTS$DIV_UL"
 514 #define MODSI3_LIBCALL "OTS$REM_I"
 515 #define MODDI3_LIBCALL "OTS$REM_L"
 516 #define UMODSI3_LIBCALL "OTS$REM_UI"
 517 #define UMODDI3_LIBCALL "OTS$REM_UL"
 518
 519 #define NAME__MAIN "__gccmain"
 520 #define SYMBOL__MAIN __gccmain
 521
 522 /* Specify the list of include file directories.  */
 523 #define INCLUDE_DEFAULTS                \
 524 {                                       \
 525   { "/gnu_gxx_include", 0, 1, 1 },      \
 526   { "/gnu_cc_include", 0, 0, 0 },       \
 527   { "/gnu/include", 0, 0, 0 },          \
 528   { 0, 0, 0, 0 }                        \
 529 }