gcc/config/alpha/vms.h

   1 /* Output variables, constants and external declarations, for GNU compiler.
   2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #define OPEN_VMS 1
  22
  23 /* This enables certain macros in alpha.h, which will make an indirect
  24    reference to an external symbol an invalid address.  This needs to be
  25    defined before we include alpha.h, since it determines which macros
  26    are used for GO_IF_*.  */
  27
  28 #define NO_EXTERNAL_INDIRECT_ADDRESS
  29
  30 #include "alpha/alpha.h"
  31
  32 #undef CPP_PREDEFINES
  33 #define CPP_PREDEFINES \
  34 "-D__ALPHA -Dvms -DVMS -D__alpha__ -D__alpha -D__vms__ -D__VMS__\
  35  -Asystem(vms) -Acpu(alpha) -Amachine(alpha)"
  36
  37 #undef CPP_SPEC
  38 #define CPP_SPEC "\
  39 %{mfloat-ieee:-D__IEEE_FLOAT} \
  40 %{mfloat-vax:-D__G_FLOAT} \
  41 %{!mfloat-vax:-D__IEEE_FLOAT} \
  42 %{!.S:  -D__LANGUAGE_C__ -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C}}  \
  43 %{.S:   -D__LANGUAGE_ASSEMBLY__ -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \
  44 %{.cc:  -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  45 %{.cxx: -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  46 %{.C:   -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus} \
  47 %{.m:   -D__LANGUAGE_OBJECTIVE_C__ -D__LANGUAGE_OBJECTIVE_C}"
  48
  49 /* Under OSF4, -p and -pg require -lprof1, and -lprof1 requires -lpdf.  */
  50
  51 #define LIB_SPEC "%{p:-lprof1 -lpdf} %{pg:-lprof1 -lpdf} %{a:-lprof2} -lc"
  52
  53 /* Pass "-G 8" to ld because Alpha's CC does.  Pass -O3 if we are
  54    optimizing, -O1 if we are not.  Pass -shared, -non_shared or
  55    -call_shared as appropriate.  Also pass -pg.  */
  56 #define LINK_SPEC  \
  57   "-G 8 %{O*:-O3} %{!O*:-O1} %{static:-non_shared} \
  58    %{!static:%{shared:-shared} %{!shared:-call_shared}} %{pg} %{taso} \
  59    %{rpath*}"
  60
  61 /* We allow $'s in identifiers unless -ansi is used .. */
  62
  63 #define DOLLARS_IN_IDENTIFIERS 2
  64
  65 /* These match the definitions used in DECCRTL, the VMS C run-time library
  66
  67 #define SIZE_TYPE       "unsigned int"
  68 #define PTRDIFF_TYPE    "int"
  69 */
  70
  71 /* Use memcpy for structure copying, and so forth.  */
  72 #define TARGET_MEM_FUNCTIONS
  73
  74 /* By default, allow $ to be part of an identifier.  */
  75 #define DOLLARS_IN_IDENTIFIERS 2
  76
  77 #undef TARGET_DEFAULT
  78 #define TARGET_DEFAULT (MASK_FP|MASK_FPREGS|MASK_GAS)
  79 #undef TARGET_OPEN_VMS
  80 #define TARGET_OPEN_VMS 1
  81
  82 #undef TARGET_NAME
  83 #define TARGET_NAME "OpenVMS/Alpha"
  84 #undef TARGET_VERSION
  85 #define TARGET_VERSION fprintf (stderr, " (%s)", TARGET_NAME);
  86
  87 /* The structure return address arrives as an "argument" on VMS.  */
  88 #undef STRUCT_VALUE_REGNUM
  89 #define STRUCT_VALUE 0
  90 #undef PCC_STATIC_STRUCT_RETURN
  91
  92 /* no floating emulation.  */
  93 #undef REAL_ARITHMETIC
  94
  95 /* "long" is 32 bits.  */
  96 #undef LONG_TYPE_SIZE
  97 #define LONG_TYPE_SIZE 32
  98
  99 /* Pointer is 32 bits but the hardware has 64-bit addresses, sign extended. */
 100 #undef POINTER_SIZE
 101 #define POINTER_SIZE 32
 102 #define POINTERS_EXTEND_UNSIGNED 0
 103
 104 #define MAX_OFILE_ALIGNMENT 524288  /* 8 x 2^16 by DEC Ada Test CD40VRA */
 105
 106 #undef FIXED_REGISTERS
 107 #define FIXED_REGISTERS  \
 108  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 109   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
 110   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 111   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
 112
 113 #undef CALL_USED_REGISTERS
 114 #define CALL_USED_REGISTERS  \
 115  {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 116   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
 117   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
 118   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
 119
 120 #undef HARD_FRAME_POINTER_REGNUM
 121 #define HARD_FRAME_POINTER_REGNUM 29
 122
 123 #undef CAN_ELIMINATE
 124 #define CAN_ELIMINATE(FROM, TO)  \
 125 ((TO) != STACK_POINTER_REGNUM || ! alpha_using_fp ())
 126
 127 #undef INITIAL_ELIMINATION_OFFSET
 128 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
 129 { if ((FROM) == FRAME_POINTER_REGNUM)                                   \
 130     (OFFSET) = alpha_sa_size () + alpha_pv_save_size ();                \
 131   else if ((FROM) == ARG_POINTER_REGNUM)                                \
 132     (OFFSET) = (ALPHA_ROUND (alpha_sa_size () + alpha_pv_save_size ()   \
 133                              + get_frame_size ()                        \
 134                              + current_function_pretend_args_size)      \
 135                 - current_function_pretend_args_size);                  \
 136   if ((TO) == STACK_POINTER_REGNUM)                                     \
 137     (OFFSET) += ALPHA_ROUND (current_function_outgoing_args_size);      \
 138 }
 139 \f
 140 /* Define a data type for recording info about an argument list
 141    during the scan of that argument list.  This data type should
 142    hold all necessary information about the function itself
 143    and about the args processed so far, enough to enable macros
 144    such as FUNCTION_ARG to determine where the next arg should go.
 145
 146    On Alpha/VMS, this is a structure that contains the number of
 147    arguments and, for each argument, the datatype of that argument.
 148
 149    The number of arguments is a number of words of arguments scanned so far.
 150    Thus 6 or more means all following args should go on the stack.  */
 151
 152 enum avms_arg_type {I64, FF, FD, FG, FS, FT};
 153 typedef struct {char num_args; enum avms_arg_type atypes[6];} avms_arg_info;
 154
 155 #undef CUMULATIVE_ARGS
 156 #define CUMULATIVE_ARGS avms_arg_info
 157
 158 /* Initialize a variable CUM of type CUMULATIVE_ARGS
 159    for a call to a function whose data type is FNTYPE.
 160    For a library call, FNTYPE is 0.  */
 161
 162 #undef INIT_CUMULATIVE_ARGS
 163 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
 164   (CUM).num_args = 0;                                           \
 165   (CUM).atypes[0] = (CUM).atypes[1] = (CUM).atypes[2] = I64;    \
 166   (CUM).atypes[3] = (CUM).atypes[4] = (CUM).atypes[5] = I64;
 167
 168 /* Update the data in CUM to advance over an argument
 169    of mode MODE and data type TYPE.
 170    (TYPE is null for libcalls where that information may not be available.)  */
 171
 172 extern enum avms_arg_type alpha_arg_type ();
 173
 174 /* Determine where to put an argument to a function.
 175    Value is zero to push the argument on the stack,
 176    or a hard register in which to store the argument.
 177
 178    MODE is the argument's machine mode (or VOIDmode for no more args).
 179    TYPE is the data type of the argument (as a tree).
 180     This is null for libcalls where that information may
 181     not be available.
 182    CUM is a variable of type CUMULATIVE_ARGS which gives info about
 183     the preceding args and about the function being called.
 184    NAMED is nonzero if this argument is a named parameter
 185     (otherwise it is an extra parameter matching an ellipsis).
 186
 187    On Alpha the first 6 words of args are normally in registers
 188    and the rest are pushed.  */
 189
 190 extern struct rtx_def *alpha_arg_info_reg_val ();
 191 #undef FUNCTION_ARG
 192 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)    \
 193 ((MODE) == VOIDmode ? alpha_arg_info_reg_val (CUM)              \
 194  : ((CUM.num_args) < 6 && ! MUST_PASS_IN_STACK (MODE, TYPE)     \
 195     ? gen_rtx(REG, (MODE),                                      \
 196               ((CUM).num_args + 16                              \
 197                + ((TARGET_FPREGS                                \
 198                    && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
 199                        || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
 200                   * 32)))                       \
 201     : 0))
 202
 203 #undef FUNCTION_ARG_ADVANCE
 204 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
 205   if (MUST_PASS_IN_STACK (MODE, TYPE))                                  \
 206     (CUM).num_args += 6;                                                \
 207   else                                                                  \
 208     {                                                                   \
 209       if ((CUM).num_args < 6)                                           \
 210         (CUM).atypes[(CUM).num_args] = alpha_arg_type (MODE);           \
 211                                                                         \
 212      (CUM).num_args += ALPHA_ARG_SIZE (MODE, TYPE, NAMED);              \
 213     }
 214
 215 /* For an arg passed partly in registers and partly in memory,
 216    this is the number of registers used.
 217    For args passed entirely in registers or entirely in memory, zero.  */
 218
 219 #undef FUNCTION_ARG_PARTIAL_NREGS
 220 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED)              \
 221 ((CUM).num_args < 6 && 6 < (CUM).num_args                               \
 222    + ALPHA_ARG_SIZE (MODE, TYPE, NAMED)                                 \
 223  ? 6 - (CUM).num_args : 0)
 224
 225 /* Perform any needed actions needed for a function that is receiving a
 226    variable number of arguments.
 227
 228    CUM is as for INIT_CUMULATIVE_ARGS.
 229
 230    MODE and TYPE are the mode and type of the current parameter.
 231
 232    PRETEND_SIZE is a variable that should be set to the amount of stack
 233    that must be pushed by the prolog to pretend that our caller pushed
 234    it.
 235
 236    Normally, this macro will push all remaining incoming registers on the
 237    stack and set PRETEND_SIZE to the length of the registers pushed.
 238
 239    For VMS, we allocate space for all 6 arg registers plus a count.
 240
 241    However, if NO registers need to be saved, don't allocate any space.
 242    This is not only because we won't need the space, but because AP includes
 243    the current_pretend_args_size and we don't want to mess up any
 244    ap-relative addresses already made.   */
 245
 246 #undef SETUP_INCOMING_VARARGS
 247 #define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL)       \
 248 { if ((CUM).num_args < 6)                               \
 249     {                                                   \
 250       if (! (NO_RTL))                                   \
 251         {                                               \
 252           emit_move_insn (gen_rtx (REG, DImode, 1),     \
 253                           virtual_incoming_args_rtx);   \
 254           emit_insn (gen_arg_home ());                  \
 255         }                                               \
 256                                                         \
 257       PRETEND_SIZE = 7 * UNITS_PER_WORD;                \
 258     }                                                   \
 259 }
 260
 261 #undef ASM_FILE_START
 262 #define ASM_FILE_START(FILE)                                    \
 263 {                                                               \
 264   alpha_write_verstamp (FILE);                                  \
 265   fprintf (FILE, "\t.set noreorder\n");                         \
 266   fprintf (FILE, "\t.set volatile\n");                          \
 267   ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename);       \
 268 }
 269
 270 #undef ASM_OUTPUT_FLOAT
 271 #define ASM_OUTPUT_FLOAT(FILE,VALUE)                                    \
 272   {                                                                     \
 273     if (REAL_VALUE_ISINF (VALUE)                                        \
 274         || REAL_VALUE_ISNAN (VALUE)                                     \
 275         || REAL_VALUE_MINUS_ZERO (VALUE))                               \
 276       {                                                                 \
 277         long t;                                                         \
 278         REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t);                       \
 279         fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff);              \
 280       }                                                                 \
 281     else                                                                \
 282       {                                                                 \
 283         char str[30];                                                   \
 284         REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", str);                  \
 285         fprintf (FILE, "\t.%c_floating %s\n", (TARGET_FLOAT_VAX)?'f':'s', str); \
 286       }                                                                 \
 287   }
 288
 289 #define LINK_SECTION_ASM_OP ".link"
 290 #define READONLY_SECTION_ASM_OP ".rdata"
 291 #define LITERALS_SECTION_ASM_OP ".literals"
 292
 293 #undef EXTRA_SECTIONS
 294 #define EXTRA_SECTIONS  in_link, in_rdata, in_literals
 295
 296 #undef EXTRA_SECTION_FUNCTIONS
 297 #define EXTRA_SECTION_FUNCTIONS                                 \
 298 void                                                            \
 299 readonly_section ()                                             \
 300 {                                                               \
 301   if (in_section != in_rdata)                           \
 302     {                                                           \
 303       fprintf (asm_out_file, "%s\n", READONLY_SECTION_ASM_OP);  \
 304       in_section = in_rdata;                            \
 305     }                                                           \
 306 }                                                               \
 307 void                                                            \
 308 link_section ()                                                 \
 309 {                                                               \
 310   if (in_section != in_link)                                    \
 311     {                                                           \
 312       fprintf (asm_out_file, "%s\n", LINK_SECTION_ASM_OP);      \
 313       in_section = in_link;                                     \
 314     }                                                           \
 315 }                                                               \
 316 void                                                            \
 317 literals_section ()                                             \
 318 {                                                               \
 319   if (in_section != in_literals)                                \
 320     {                                                           \
 321       fprintf (asm_out_file, "%s\n", LITERALS_SECTION_ASM_OP);  \
 322       in_section = in_literals;                                 \
 323     }                                                           \
 324 }
 325
 326 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 327 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) abort ()
 328
 329 #undef ASM_OUTPUT_ADDR_VEC_ELT
 330 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
 331   fprintf (FILE, "\t.quad $L%d\n", (VALUE))
 332
 333 #undef READONLY_DATA_SECTION
 334 #define READONLY_DATA_SECTION readonly_section
 335
 336 #define ASM_FILE_END(FILE) alpha_write_linkage (FILE);
 337
 338 #undef CASE_VECTOR_MODE
 339 #define CASE_VECTOR_MODE DImode
 340 #undef CASE_VECTOR_PC_RELATIVE
 341
 342 #undef ASM_OUTPUT_CASE_LABEL
 343 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
 344 { ASM_OUTPUT_ALIGN (FILE, 3); ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); }
 345
 346 #define NO_MD_PROTOTYPES
 347 \f
 348 /* Output assembler code for a block containing the constant parts
 349    of a trampoline, leaving space for the variable parts.
 350
 351    The trampoline should set the static chain pointer to value placed
 352    into the trampoline and should branch to the specified routine.
 353    Note that $27 has been set to the address of the trampoline, so we can
 354    use it for addressability of the two data items.  Trampolines are always
 355    aligned to FUNCTION_BOUNDARY, which is 64 bits.  */
 356
 357 #undef TRAMPOLINE_TEMPLATE
 358 #define TRAMPOLINE_TEMPLATE(FILE)               \
 359 {                                               \
 360   fprintf (FILE, "\t.quad 0\n");                \
 361   fprintf (FILE, "\t.linkage __tramp\n");       \
 362   fprintf (FILE, "\t.quad 0\n");                \
 363 }
 364
 365 /* Length in units of the trampoline for entering a nested function.  */
 366
 367 #undef TRAMPOLINE_SIZE
 368 #define TRAMPOLINE_SIZE    32
 369
 370 /* Emit RTL insns to initialize the variable parts of a trampoline.
 371    FNADDR is an RTX for the address of the function's pure code.
 372    CXT is an RTX for the static chain value for the function.  */
 373
 374 #undef INITIALIZE_TRAMPOLINE
 375 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                         \
 376 {                                                                         \
 377   emit_move_insn (gen_rtx (MEM, Pmode,                                    \
 378                            memory_address (Pmode,                         \
 379                                            plus_constant ((TRAMP), 16))), \
 380                   (FNADDR));                                              \
 381   emit_move_insn (gen_rtx (MEM, Pmode,                                    \
 382                            memory_address (Pmode,                         \
 383                                            plus_constant ((TRAMP), 24))), \
 384                   (CXT));                                                 \
 385 }
 386
 387 #undef TRANSFER_FROM_TRAMPOLINE
 388
 389 #define VALID_MACHINE_DECL_ATTRIBUTE(DECL, ATTRIBUTES, NAME, ARGS) \
 390   (vms_valid_decl_attribute_p (DECL, ATTRIBUTES, NAME, ARGS))
 391 extern int vms_valid_decl_attribute_p ();
 392
 393 #undef SDB_DEBUGGING_INFO
 394 #undef MIPS_DEBUGGING_INFO
 395 #undef DBX_DEBUGGING_INFO
 396
 397 #define DWARF2_DEBUGGING_INFO
 398
 399 /* This is how to output an assembler line
 400    that says to advance the location counter
 401    to a multiple of 2**LOG bytes.  */
 402
 403 #undef ASM_OUTPUT_ALIGN
 404 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 405     fprintf (FILE, "\t.align %d\n", LOG);
 406
 407 #define UNALIGNED_SHORT_ASM_OP  ".word"
 408 #define UNALIGNED_INT_ASM_OP    ".long"
 409 #define UNALIGNED_DOUBLE_INT_ASM_OP     ".quad"
 410
 411 #define ASM_OUTPUT_SECTION(FILE,SECTION)                        \
 412    (strcmp (SECTION, ".text") == 0)                             \
 413      ? text_section ()                                          \
 414      : named_section (NULL_TREE, SECTION, 0),                   \
 415        ASM_OUTPUT_ALIGN (FILE, 0)                               \
 416
 417 #define ASM_OUTPUT_SECTION_NAME(FILE,DECL,NAME,RELOC)           \
 418   do                                                            \
 419     {                                                           \
 420       char *flags;                                              \
 421       int ovr = 0;                                              \
 422       if (DECL && DECL_MACHINE_ATTRIBUTES (DECL)                \
 423           && lookup_attribute                                   \
 424               ("overlaid", DECL_MACHINE_ATTRIBUTES (DECL)))     \
 425         flags = ",OVR", ovr = 1;                                \
 426       else if (strncmp (NAME,".debug", 6) == 0)                 \
 427         flags = ",NOWRT";                                       \
 428       else                                                      \
 429         flags = "";                                             \
 430       fputc ('\n', (FILE));                                     \
 431       fprintf (FILE, ".section\t%s%s\n", NAME, flags);          \
 432       if (ovr)                                                  \
 433         (NAME) = "";                                            \
 434     } while (0)
 435
 436 #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)                              \
 437   do {  literals_section();                                             \
 438         fprintf ((FILE), "\t");                                         \
 439         assemble_name (FILE, LABEL1);                                   \
 440         fprintf (FILE, " = ");                                          \
 441         assemble_name (FILE, LABEL2);                                   \
 442         fprintf (FILE, "\n");                                           \
 443   } while (0)
 444
 445 #undef PREFERRED_DEBUGGING_TYPE
 446 #define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 447
 448 #undef ASM_FORMAT_PRIVATE_NAME
 449 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 450 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
 451   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 452
 453 /* ??? VMS uses different linkage.  */
 454 #undef ASM_OUTPUT_MI_THUNK
 455
 456 #undef ASM_SPEC
 457 #undef ASM_FINAL_SPEC
 458 #undef LINK_SPEC
 459 #undef STARTFILE_SPEC
 460 #define ASM_SPEC "-nocpp %{pg}"
 461 #define LINK_SPEC "%{g3:-g3} %{g0:-g0} %{shared:-shared} %{v:-v}"
 462
 463 /* Define the names of the division and modulus functions.  */
 464 #define DIVSI3_LIBCALL "OTS$DIV_I"
 465 #define DIVDI3_LIBCALL "OTS$DIV_L"
 466 #define UDIVSI3_LIBCALL "OTS$DIV_UI"
 467 #define UDIVDI3_LIBCALL "OTS$DIV_UL"
 468 #define MODSI3_LIBCALL "OTS$REM_I"
 469 #define MODDI3_LIBCALL "OTS$REM_L"
 470 #define UMODSI3_LIBCALL "OTS$REM_UI"
 471 #define UMODDI3_LIBCALL "OTS$REM_UL"
 472
 473 #define DIR_SEPARATOR ']'
 474
 475 #define PREFIX "GNU_ROOT:"