gcc/config/alpha/vms.h

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