gcc/config/alpha/vms.h

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