gcc/config/vax/vax.h

   1 /* Definitions of target machine for GNU compiler.  VAX version.
   2    Copyright (C) 1987, 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC 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 GCC 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 GCC; 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
  23 /* Target CPU builtins.  */
  24 #define TARGET_CPU_CPP_BUILTINS()               \
  25   do                                            \
  26     {                                           \
  27       builtin_define ("__vax__");               \
  28       builtin_assert ("cpu=vax");               \
  29       builtin_assert ("machine=vax");           \
  30       if (TARGET_G_FLOAT)                       \
  31         {                                       \
  32           builtin_define ("__GFLOAT");          \
  33           builtin_define ("__GFLOAT__");        \
  34         }                                       \
  35     }                                           \
  36   while (0)
  37
  38 #define VMS_TARGET 0
  39
  40 /* Use -J option for long branch support with Unix assembler.  */
  41
  42 #define ASM_SPEC "-J"
  43
  44 /* Choose proper libraries depending on float format.
  45    Note that there are no profiling libraries for g-format.
  46    Also use -lg for the sake of dbx.  */
  47
  48 #define LIB_SPEC "%{g:-lg}\
  49  %{mg:%{lm:-lmg} -lcg \
  50   %{p:%eprofiling not supported with -mg\n}\
  51   %{pg:%eprofiling not supported with -mg\n}}\
  52  %{!mg:%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
  53
  54 /* Print subsidiary information on the compiler version in use.  */
  55
  56 #ifndef TARGET_NAME     /* A more specific value might be supplied via -D.  */
  57 #define TARGET_NAME "vax"
  58 #endif
  59 #define TARGET_VERSION fprintf (stderr, " (%s)", TARGET_NAME)
  60
  61 /* Run-time compilation parameters selecting different hardware subsets.  */
  62
  63 extern int target_flags;
  64
  65 #define MASK_UNIX_ASM           1
  66 #define MASK_VAXC_ALIGNMENT     2
  67 #define MASK_G_FLOAT            4
  68
  69
  70 /* Macros used in the machine description to test the flags.  */
  71
  72 /* Nonzero if compiling code that Unix assembler can assemble.  */
  73 #define TARGET_UNIX_ASM (target_flags & MASK_UNIX_ASM)
  74
  75 /* Nonzero if compiling with VAX-11 "C" style structure alignment */
  76 #define TARGET_VAXC_ALIGNMENT (target_flags & MASK_VAXC_ALIGNMENT)
  77
  78 /* Nonzero if compiling with `G'-format floating point */
  79 #define TARGET_G_FLOAT (target_flags & MASK_G_FLOAT)
  80
  81 /* Macro to define tables used to set the flags.
  82    This is a list in braces of pairs in braces,
  83    each pair being { "NAME", VALUE }
  84    where VALUE is the bits to set or minus the bits to clear.
  85    An empty string NAME is used to identify the default VALUE.  */
  86
  87 #define TARGET_SWITCHES                                         \
  88   { {"unix", MASK_UNIX_ASM,                                     \
  89      "Generate code for UNIX assembler"},                       \
  90     {"gnu", -MASK_UNIX_ASM,                                     \
  91      "Generate code for GNU assembler (gas)"},                  \
  92     {"vaxc-alignment", MASK_VAXC_ALIGNMENT,                     \
  93      "Use VAXC structure conventions"},                         \
  94     {"g", MASK_G_FLOAT,                                         \
  95      "Generate GFLOAT double precision code"},                  \
  96     {"g-float", MASK_G_FLOAT,                                   \
  97      "Generate GFLOAT double precision code"},                  \
  98     {"d", -MASK_G_FLOAT,                                        \
  99      "Generate DFLOAT double precision code"},                  \
 100     {"d-float", -MASK_G_FLOAT,                                  \
 101      "Generate DFLOAT double precision code"},                  \
 102     { "", TARGET_DEFAULT, 0}}
 103
 104 /* Default target_flags if no switches specified.  */
 105
 106 #ifndef TARGET_DEFAULT
 107 #define TARGET_DEFAULT (MASK_UNIX_ASM)
 108 #endif
 109
 110 #define OVERRIDE_OPTIONS override_options ()
 111
 112 \f
 113 /* Target machine storage layout */
 114
 115 /* Define this if most significant bit is lowest numbered
 116    in instructions that operate on numbered bit-fields.
 117    This is not true on the VAX.  */
 118 #define BITS_BIG_ENDIAN 0
 119
 120 /* Define this if most significant byte of a word is the lowest numbered.  */
 121 /* That is not true on the VAX.  */
 122 #define BYTES_BIG_ENDIAN 0
 123
 124 /* Define this if most significant word of a multiword number is the lowest
 125    numbered.  */
 126 /* This is not true on the VAX.  */
 127 #define WORDS_BIG_ENDIAN 0
 128
 129 /* Width of a word, in units (bytes).  */
 130 #define UNITS_PER_WORD 4
 131
 132 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
 133 #define PARM_BOUNDARY 32
 134
 135 /* Allocation boundary (in *bits*) for the code of a function.  */
 136 #define FUNCTION_BOUNDARY 16
 137
 138 /* Alignment of field after `int : 0' in a structure.  */
 139 #define EMPTY_FIELD_BOUNDARY (TARGET_VAXC_ALIGNMENT ? 8 : 32)
 140
 141 /* Every structure's size must be a multiple of this.  */
 142 #define STRUCTURE_SIZE_BOUNDARY 8
 143
 144 /* A bit-field declared as `int' forces `int' alignment for the struct.  */
 145 #define PCC_BITFIELD_TYPE_MATTERS (! TARGET_VAXC_ALIGNMENT)
 146
 147 /* No data type wants to be aligned rounder than this.  */
 148 #define BIGGEST_ALIGNMENT 32
 149
 150 /* No structure field wants to be aligned rounder than this.  */
 151 #define BIGGEST_FIELD_ALIGNMENT (TARGET_VAXC_ALIGNMENT ? 8 : 32)
 152
 153 /* Set this nonzero if move instructions will actually fail to work
 154    when given unaligned data.  */
 155 #define STRICT_ALIGNMENT 0
 156
 157 /* Let's keep the stack somewhat aligned.  */
 158 #define STACK_BOUNDARY 32
 159
 160 /* The table of an ADDR_DIFF_VEC must be contiguous with the case
 161    opcode, it is part of the case instruction.  */
 162 #define ADDR_VEC_ALIGN(ADDR_VEC) 0
 163 \f
 164 /* Standard register usage.  */
 165
 166 /* Number of actual hardware registers.
 167    The hardware registers are assigned numbers for the compiler
 168    from 0 to just below FIRST_PSEUDO_REGISTER.
 169    All registers that the compiler knows about must be given numbers,
 170    even those that are not normally considered general registers.  */
 171 #define FIRST_PSEUDO_REGISTER 16
 172
 173 /* 1 for registers that have pervasive standard uses
 174    and are not available for the register allocator.
 175    On the VAX, these are the AP, FP, SP and PC.  */
 176 #define FIXED_REGISTERS {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}
 177
 178 /* 1 for registers not available across function calls.
 179    These must include the FIXED_REGISTERS and also any
 180    registers that can be used without being saved.
 181    The latter must include the registers where values are returned
 182    and the register where structure-value addresses are passed.
 183    Aside from that, you can include as many other registers as you like.  */
 184 #define CALL_USED_REGISTERS {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}
 185
 186 /* Return number of consecutive hard regs needed starting at reg REGNO
 187    to hold something of mode MODE.
 188    This is ordinarily the length in words of a value of mode MODE
 189    but can be less for certain modes in special long registers.
 190    On the VAX, all registers are one word long.  */
 191 #define HARD_REGNO_NREGS(REGNO, MODE)   \
 192  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 193
 194 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
 195    On the VAX, all registers can hold all modes.  */
 196 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
 197
 198 /* Value is 1 if it is a good idea to tie two pseudo registers
 199    when one has mode MODE1 and one has mode MODE2.
 200    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
 201    for any hard reg, then this must be 0 for correct output.  */
 202 #define MODES_TIEABLE_P(MODE1, MODE2)  1
 203
 204 /* Specify the registers used for certain standard purposes.
 205    The values of these macros are register numbers.  */
 206
 207 /* VAX pc is overloaded on a register.  */
 208 #define PC_REGNUM 15
 209
 210 /* Register to use for pushing function arguments.  */
 211 #define STACK_POINTER_REGNUM 14
 212
 213 /* Base register for access to local variables of the function.  */
 214 #define FRAME_POINTER_REGNUM 13
 215
 216 /* Value should be nonzero if functions must have frame pointers.
 217    Zero means the frame pointer need not be set up (and parms
 218    may be accessed via the stack pointer) in functions that seem suitable.
 219    This is computed in `reload', in reload1.c.  */
 220 #define FRAME_POINTER_REQUIRED 1
 221
 222 /* Base register for access to arguments of the function.  */
 223 #define ARG_POINTER_REGNUM 12
 224
 225 /* Register in which static-chain is passed to a function.  */
 226 #define STATIC_CHAIN_REGNUM 0
 227
 228 /* Register in which address to store a structure value
 229    is passed to a function.  */
 230 #define STRUCT_VALUE_REGNUM 1
 231 \f
 232 /* Define the classes of registers for register constraints in the
 233    machine description.  Also define ranges of constants.
 234
 235    One of the classes must always be named ALL_REGS and include all hard regs.
 236    If there is more than one class, another class must be named NO_REGS
 237    and contain no registers.
 238
 239    The name GENERAL_REGS must be the name of a class (or an alias for
 240    another name such as ALL_REGS).  This is the class of registers
 241    that is allowed by "g" or "r" in a register constraint.
 242    Also, registers outside this class are allocated only when
 243    instructions express preferences for them.
 244
 245    The classes must be numbered in nondecreasing order; that is,
 246    a larger-numbered class must never be contained completely
 247    in a smaller-numbered class.
 248
 249    For any two classes, it is very desirable that there be another
 250    class that represents their union.  */
 251
 252 /* The VAX has only one kind of registers, so NO_REGS and ALL_REGS
 253    are the only classes.  */
 254
 255 enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES };
 256
 257 #define N_REG_CLASSES (int) LIM_REG_CLASSES
 258
 259 /* Since GENERAL_REGS is the same class as ALL_REGS,
 260    don't give it a different class number; just make it an alias.  */
 261
 262 #define GENERAL_REGS ALL_REGS
 263
 264 /* Give names of register classes as strings for dump file.  */
 265
 266 #define REG_CLASS_NAMES \
 267  {"NO_REGS", "ALL_REGS" }
 268
 269 /* Define which registers fit in which classes.
 270    This is an initializer for a vector of HARD_REG_SET
 271    of length N_REG_CLASSES.  */
 272
 273 #define REG_CLASS_CONTENTS {{0}, {0xffff}}
 274
 275 /* The same information, inverted:
 276    Return the class number of the smallest class containing
 277    reg number REGNO.  This could be a conditional expression
 278    or could index an array.  */
 279
 280 #define REGNO_REG_CLASS(REGNO) ALL_REGS
 281
 282 /* The class value for index registers, and the one for base regs.  */
 283
 284 #define INDEX_REG_CLASS ALL_REGS
 285 #define BASE_REG_CLASS ALL_REGS
 286
 287 /* Get reg_class from a letter such as appears in the machine description.  */
 288
 289 #define REG_CLASS_FROM_LETTER(C) NO_REGS
 290
 291 /* The letters I, J, K, L, M, N, and O in a register constraint string
 292    can be used to stand for particular ranges of immediate operands.
 293    This macro defines what the ranges are.
 294    C is the letter, and VALUE is a constant value.
 295    Return 1 if VALUE is in the range specified by C.
 296
 297    `I' is the constant zero.
 298    `J' is a value between 0 .. 63 (inclusive)
 299    `K' is a value between -128 and 127 (inclusive)
 300    'L' is a value between -32768 and 32767 (inclusive)
 301    `M' is a value between 0 and 255 (inclusive)
 302    'N' is a value between 0 and 65535 (inclusive)
 303    `O' is a value between -63 and -1 (inclusive)  */
 304
 305 #define CONST_OK_FOR_LETTER_P(VALUE, C) \
 306   (  (C) == 'I' ?       (VALUE) == 0                            \
 307    : (C) == 'J' ?       0 <= (VALUE) && (VALUE) < 64            \
 308    : (C) == 'O' ?       -63 <= (VALUE) && (VALUE) < 0           \
 309    : (C) == 'K' ?       -128 <= (VALUE) && (VALUE) < 128        \
 310    : (C) == 'M' ?       0 <= (VALUE) && (VALUE) < 256           \
 311    : (C) == 'L' ?       -32768 <= (VALUE) && (VALUE) < 32768    \
 312    : (C) == 'N' ?       0 <= (VALUE) && (VALUE) < 65536         \
 313    : 0)
 314
 315 /* Similar, but for floating constants, and defining letters G and H.
 316    Here VALUE is the CONST_DOUBLE rtx itself.
 317
 318    `G' is a floating-point zero.  */
 319
 320 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \
 321   ((C) == 'G' ? ((VALUE) == CONST0_RTX (DFmode)         \
 322                  || (VALUE) == CONST0_RTX (SFmode))     \
 323    : 0)
 324
 325 /* Optional extra constraints for this machine.
 326
 327    For the VAX, `Q' means that OP is a MEM that does not have a mode-dependent
 328    address.  */
 329
 330 #define EXTRA_CONSTRAINT(OP, C) \
 331   ((C) == 'Q'                                                           \
 332    ? GET_CODE (OP) == MEM && ! mode_dependent_address_p (XEXP (OP, 0))  \
 333    : 0)
 334
 335 /* Given an rtx X being reloaded into a reg required to be
 336    in class CLASS, return the class of reg to actually use.
 337    In general this is just CLASS; but on some machines
 338    in some cases it is preferable to use a more restrictive class.  */
 339
 340 #define PREFERRED_RELOAD_CLASS(X,CLASS)  (CLASS)
 341
 342 /* Return the maximum number of consecutive registers
 343    needed to represent mode MODE in a register of class CLASS.  */
 344 /* On the VAX, this is always the size of MODE in words,
 345    since all registers are the same size.  */
 346 #define CLASS_MAX_NREGS(CLASS, MODE)    \
 347  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 348 \f
 349 /* Stack layout; function entry, exit and calling.  */
 350
 351 /* Define this if pushing a word on the stack
 352    makes the stack pointer a smaller address.  */
 353 #define STACK_GROWS_DOWNWARD
 354
 355 /* Define this if the nominal address of the stack frame
 356    is at the high-address end of the local variables;
 357    that is, each additional local variable allocated
 358    goes at a more negative offset in the frame.  */
 359 #define FRAME_GROWS_DOWNWARD
 360
 361 /* Offset within stack frame to start allocating local variables at.
 362    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
 363    first local allocated.  Otherwise, it is the offset to the BEGINNING
 364    of the first local allocated.  */
 365 #define STARTING_FRAME_OFFSET 0
 366
 367 /* Given an rtx for the address of a frame,
 368    return an rtx for the address of the word in the frame
 369    that holds the dynamic chain--the previous frame's address.  */
 370 #define DYNAMIC_CHAIN_ADDRESS(FRAME) plus_constant ((FRAME), 12)
 371
 372 /* If we generate an insn to push BYTES bytes,
 373    this says how many the stack pointer really advances by.
 374    On the VAX, -(sp) pushes only the bytes of the operands.  */
 375 #define PUSH_ROUNDING(BYTES) (BYTES)
 376
 377 /* Offset of first parameter from the argument pointer register value.  */
 378 #define FIRST_PARM_OFFSET(FNDECL) 4
 379
 380 /* Value is the number of bytes of arguments automatically
 381    popped when returning from a subroutine call.
 382    FUNDECL is the declaration node of the function (as a tree),
 383    FUNTYPE is the data type of the function (as a tree),
 384    or for a library call it is an identifier node for the subroutine name.
 385    SIZE is the number of bytes of arguments passed on the stack.
 386
 387    On the VAX, the RET insn pops a maximum of 255 args for any function.  */
 388
 389 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
 390   ((SIZE) > 255*4 ? 0 : (SIZE))
 391
 392 /* Define how to find the value returned by a function.
 393    VALTYPE is the data type of the value (as a tree).
 394    If the precise function being called is known, FUNC is its FUNCTION_DECL;
 395    otherwise, FUNC is 0.  */
 396
 397 /* On the VAX the return value is in R0 regardless.  */
 398
 399 #define FUNCTION_VALUE(VALTYPE, FUNC)  \
 400   gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
 401
 402 /* Define how to find the value returned by a library function
 403    assuming the value has mode MODE.  */
 404
 405 /* On the VAX the return value is in R0 regardless.  */
 406
 407 #define LIBCALL_VALUE(MODE)  gen_rtx_REG (MODE, 0)
 408
 409 /* Define this if PCC uses the nonreentrant convention for returning
 410    structure and union values.  */
 411
 412 #define PCC_STATIC_STRUCT_RETURN
 413
 414 /* 1 if N is a possible register number for a function value.
 415    On the VAX, R0 is the only register thus used.  */
 416
 417 #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
 418
 419 /* 1 if N is a possible register number for function argument passing.
 420    On the VAX, no registers are used in this way.  */
 421
 422 #define FUNCTION_ARG_REGNO_P(N) 0
 423 \f
 424 /* Define a data type for recording info about an argument list
 425    during the scan of that argument list.  This data type should
 426    hold all necessary information about the function itself
 427    and about the args processed so far, enough to enable macros
 428    such as FUNCTION_ARG to determine where the next arg should go.
 429
 430    On the VAX, this is a single integer, which is a number of bytes
 431    of arguments scanned so far.  */
 432
 433 #define CUMULATIVE_ARGS int
 434
 435 /* Initialize a variable CUM of type CUMULATIVE_ARGS
 436    for a call to a function whose data type is FNTYPE.
 437    For a library call, FNTYPE is 0.
 438
 439    On the VAX, the offset starts at 0.  */
 440
 441 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT)       \
 442  ((CUM) = 0)
 443
 444 /* Update the data in CUM to advance over an argument
 445    of mode MODE and data type TYPE.
 446    (TYPE is null for libcalls where that information may not be available.)  */
 447
 448 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
 449  ((CUM) += ((MODE) != BLKmode                   \
 450             ? (GET_MODE_SIZE (MODE) + 3) & ~3   \
 451             : (int_size_in_bytes (TYPE) + 3) & ~3))
 452
 453 /* Define where to put the arguments to a function.
 454    Value is zero to push the argument on the stack,
 455    or a hard register in which to store the argument.
 456
 457    MODE is the argument's machine mode.
 458    TYPE is the data type of the argument (as a tree).
 459     This is null for libcalls where that information may
 460     not be available.
 461    CUM is a variable of type CUMULATIVE_ARGS which gives info about
 462     the preceding args and about the function being called.
 463    NAMED is nonzero if this argument is a named parameter
 464     (otherwise it is an extra parameter matching an ellipsis).  */
 465
 466 /* On the VAX all args are pushed.  */
 467
 468 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0
 469
 470 /* Output assembler code to FILE to increment profiler label # LABELNO
 471    for profiling a function entry.  */
 472
 473 #define VAX_FUNCTION_PROFILER_NAME "mcount"
 474 #define FUNCTION_PROFILER(FILE, LABELNO)                        \
 475   do                                                            \
 476     {                                                           \
 477       char label[256];                                          \
 478       ASM_GENERATE_INTERNAL_LABEL (label, "LP", (LABELNO));     \
 479       fprintf (FILE, "\tmovab ");                               \
 480       assemble_name (FILE, label);                              \
 481       asm_fprintf (FILE, ",%Rr0\n\tjsb %s\n",                   \
 482                    VAX_FUNCTION_PROFILER_NAME);                 \
 483     }                                                           \
 484   while (0)
 485
 486 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
 487    the stack pointer does not matter.  The value is tested only in
 488    functions that have frame pointers.
 489    No definition is equivalent to always zero.  */
 490
 491 #define EXIT_IGNORE_STACK 1
 492
 493 /* Store in the variable DEPTH the initial difference between the
 494    frame pointer reg contents and the stack pointer reg contents,
 495    as of the start of the function body.  This depends on the layout
 496    of the fixed parts of the stack frame and on how registers are saved.
 497
 498    On the VAX, FRAME_POINTER_REQUIRED is always 1, so the definition of this
 499    macro doesn't matter.  But it must be defined.  */
 500
 501 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) (DEPTH) = 0;
 502
 503 /* Output assembler code for a block containing the constant parts
 504    of a trampoline, leaving space for the variable parts.  */
 505
 506 /* On the VAX, the trampoline contains an entry mask and two instructions:
 507      .word NN
 508      movl $STATIC,r0   (store the functions static chain)
 509      jmp  *$FUNCTION   (jump to function code at address FUNCTION)  */
 510
 511 #define TRAMPOLINE_TEMPLATE(FILE)                                       \
 512 {                                                                       \
 513   assemble_aligned_integer (2, const0_rtx);                             \
 514   assemble_aligned_integer (2, GEN_INT (0x8fd0));                       \
 515   assemble_aligned_integer (4, const0_rtx);                             \
 516   assemble_aligned_integer (1, GEN_INT (0x50 + STATIC_CHAIN_REGNUM));   \
 517   assemble_aligned_integer (2, GEN_INT (0x9f17));                       \
 518   assemble_aligned_integer (4, const0_rtx);                             \
 519 }
 520
 521 /* Length in units of the trampoline for entering a nested function.  */
 522
 523 #define TRAMPOLINE_SIZE 15
 524
 525 /* Emit RTL insns to initialize the variable parts of a trampoline.
 526    FNADDR is an RTX for the address of the function's pure code.
 527    CXT is an RTX for the static chain value for the function.  */
 528
 529 /* We copy the register-mask from the function's pure code
 530    to the start of the trampoline.  */
 531 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                       \
 532 {                                                                       \
 533   emit_move_insn (gen_rtx_MEM (HImode, TRAMP),                          \
 534                   gen_rtx_MEM (HImode, FNADDR));                        \
 535   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 4)), CXT); \
 536   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 11)),      \
 537                   plus_constant (FNADDR, 2));                           \
 538   emit_insn (gen_sync_istream ());                                      \
 539 }
 540
 541 /* Byte offset of return address in a stack frame.  The "saved PC" field
 542    is in element [4] when treating the frame as an array of longwords.  */
 543
 544 #define RETURN_ADDRESS_OFFSET   (4 * UNITS_PER_WORD)    /* 16 */
 545
 546 /* A C expression whose value is RTL representing the value of the return
 547    address for the frame COUNT steps up from the current frame.
 548    FRAMEADDR is already the frame pointer of the COUNT frame, so we
 549    can ignore COUNT.  */
 550
 551 #define RETURN_ADDR_RTX(COUNT, FRAME)   \
 552   ((COUNT == 0)                         \
 553    ? gen_rtx_MEM (Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET)) \
 554    : (rtx) 0)
 555
 556 \f
 557 /* Addressing modes, and classification of registers for them.  */
 558
 559 #define HAVE_POST_INCREMENT 1
 560
 561 #define HAVE_PRE_DECREMENT 1
 562
 563 /* Macros to check register numbers against specific register classes.  */
 564
 565 /* These assume that REGNO is a hard or pseudo reg number.
 566    They give nonzero only if REGNO is a hard reg of the suitable class
 567    or a pseudo reg currently allocated to a suitable hard reg.
 568    Since they use reg_renumber, they are safe only once reg_renumber
 569    has been allocated, which happens in local-alloc.c.  */
 570
 571 #define REGNO_OK_FOR_INDEX_P(regno)  \
 572 ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
 573 #define REGNO_OK_FOR_BASE_P(regno) \
 574 ((regno) < FIRST_PSEUDO_REGISTER || reg_renumber[regno] >= 0)
 575 \f
 576 /* Maximum number of registers that can appear in a valid memory address.  */
 577
 578 #define MAX_REGS_PER_ADDRESS 2
 579
 580 /* 1 if X is an rtx for a constant that is a valid address.  */
 581
 582 #define CONSTANT_ADDRESS_P(X)   \
 583   (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF              \
 584    || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST                \
 585    || GET_CODE (X) == HIGH)
 586
 587 /* Nonzero if the constant value X is a legitimate general operand.
 588    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
 589
 590 #define LEGITIMATE_CONSTANT_P(X) 1
 591
 592 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
 593    and check its validity for a certain class.
 594    We have two alternate definitions for each of them.
 595    The usual definition accepts all pseudo regs; the other rejects
 596    them unless they have been allocated suitable hard regs.
 597    The symbol REG_OK_STRICT causes the latter definition to be used.
 598
 599    Most source files want to accept pseudo regs in the hope that
 600    they will get allocated to the class that the insn wants them to be in.
 601    Source files for reload pass need to be strict.
 602    After reload, it makes no difference, since pseudo regs have
 603    been eliminated by then.  */
 604
 605 #ifndef REG_OK_STRICT
 606
 607 /* Nonzero if X is a hard reg that can be used as an index
 608    or if it is a pseudo reg.  */
 609 #define REG_OK_FOR_INDEX_P(X) 1
 610 /* Nonzero if X is a hard reg that can be used as a base reg
 611    or if it is a pseudo reg.  */
 612 #define REG_OK_FOR_BASE_P(X) 1
 613
 614 #else
 615
 616 /* Nonzero if X is a hard reg that can be used as an index.  */
 617 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
 618 /* Nonzero if X is a hard reg that can be used as a base reg.  */
 619 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
 620
 621 #endif
 622 \f
 623 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
 624    that is a valid memory address for an instruction.
 625    The MODE argument is the machine mode for the MEM expression
 626    that wants to use this address.
 627
 628    The other macros defined here are used only in GO_IF_LEGITIMATE_ADDRESS,
 629    except for CONSTANT_ADDRESS_P which is actually machine-independent.  */
 630
 631 #ifdef NO_EXTERNAL_INDIRECT_ADDRESS
 632
 633 /* Zero if this contains a (CONST (PLUS (SYMBOL_REF) (...))) and the
 634    symbol in the SYMBOL_REF is an external symbol.  */
 635
 636 #define INDIRECTABLE_CONSTANT_P(X) \
 637  (! (GET_CODE ((X)) == CONST                                    \
 638      && GET_CODE (XEXP ((X), 0)) == PLUS                        \
 639      && GET_CODE (XEXP (XEXP ((X), 0), 0)) == SYMBOL_REF        \
 640      && SYMBOL_REF_FLAG (XEXP (XEXP ((X), 0), 0))))
 641
 642 /* Re-definition of CONSTANT_ADDRESS_P, which is true only when there
 643    are no SYMBOL_REFs for external symbols present.  */
 644
 645 #define INDIRECTABLE_CONSTANT_ADDRESS_P(X)                              \
 646   (GET_CODE (X) == LABEL_REF                                            \
 647    || (GET_CODE (X) == SYMBOL_REF && !SYMBOL_REF_FLAG (X))              \
 648    || (GET_CODE (X) == CONST && INDIRECTABLE_CONSTANT_P(X))             \
 649    || GET_CODE (X) == CONST_INT)
 650
 651
 652 /* Nonzero if X is an address which can be indirected.  External symbols
 653    could be in a sharable image library, so we disallow those.  */
 654
 655 #define INDIRECTABLE_ADDRESS_P(X)  \
 656   (INDIRECTABLE_CONSTANT_ADDRESS_P (X)                                  \
 657    || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X))                    \
 658    || (GET_CODE (X) == PLUS                                             \
 659        && GET_CODE (XEXP (X, 0)) == REG                                 \
 660        && REG_OK_FOR_BASE_P (XEXP (X, 0))                               \
 661        && INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 1))))
 662
 663 #else /* not NO_EXTERNAL_INDIRECT_ADDRESS */
 664
 665 #define INDIRECTABLE_CONSTANT_ADDRESS_P(X) CONSTANT_ADDRESS_P(X)
 666
 667 /* Nonzero if X is an address which can be indirected.  */
 668 #define INDIRECTABLE_ADDRESS_P(X)  \
 669   (CONSTANT_ADDRESS_P (X)                                               \
 670    || (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X))                    \
 671    || (GET_CODE (X) == PLUS                                             \
 672        && GET_CODE (XEXP (X, 0)) == REG                                 \
 673        && REG_OK_FOR_BASE_P (XEXP (X, 0))                               \
 674        && CONSTANT_ADDRESS_P (XEXP (X, 1))))
 675
 676 #endif /* not NO_EXTERNAL_INDIRECT_ADDRESS */
 677
 678 /* Go to ADDR if X is a valid address not using indexing.
 679    (This much is the easy part.)  */
 680 #define GO_IF_NONINDEXED_ADDRESS(X, ADDR)  \
 681 { register rtx xfoob = (X);                                             \
 682   if (GET_CODE (xfoob) == REG)                                          \
 683     {                                                                   \
 684       extern rtx *reg_equiv_mem;                                        \
 685       if (! reload_in_progress                                          \
 686           || reg_equiv_mem[REGNO (xfoob)] == 0                          \
 687           || INDIRECTABLE_ADDRESS_P (reg_equiv_mem[REGNO (xfoob)]))     \
 688         goto ADDR;                                                      \
 689     }                                                                   \
 690   if (CONSTANT_ADDRESS_P (xfoob)) goto ADDR;                            \
 691   if (INDIRECTABLE_ADDRESS_P (xfoob)) goto ADDR;                        \
 692   xfoob = XEXP (X, 0);                                                  \
 693   if (GET_CODE (X) == MEM && INDIRECTABLE_ADDRESS_P (xfoob))            \
 694     goto ADDR;                                                          \
 695   if ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC)             \
 696       && GET_CODE (xfoob) == REG && REG_OK_FOR_BASE_P (xfoob))          \
 697     goto ADDR; }
 698
 699 /* 1 if PROD is either a reg times size of mode MODE and MODE is less
 700    than or equal 8 bytes, or just a reg if MODE is one byte.
 701    This macro's expansion uses the temporary variables xfoo0 and xfoo1
 702    that must be declared in the surrounding context.  */
 703 #define INDEX_TERM_P(PROD, MODE)   \
 704 (GET_MODE_SIZE (MODE) == 1                                              \
 705  ? (GET_CODE (PROD) == REG && REG_OK_FOR_BASE_P (PROD))                 \
 706  : (GET_CODE (PROD) == MULT && GET_MODE_SIZE (MODE) <= 8                \
 707     &&                                                                  \
 708     (xfoo0 = XEXP (PROD, 0), xfoo1 = XEXP (PROD, 1),                    \
 709      ((((GET_CODE (xfoo0) == CONST_INT                                  \
 710          && GET_CODE (xfoo1) == REG)                                    \
 711          && INTVAL (xfoo0) == (int)GET_MODE_SIZE (MODE))                \
 712          && REG_OK_FOR_INDEX_P (xfoo1))                                 \
 713         ||                                                              \
 714       (((GET_CODE (xfoo1) == CONST_INT                                  \
 715          && GET_CODE (xfoo0) == REG)                                    \
 716          && INTVAL (xfoo1) == (int)GET_MODE_SIZE (MODE))                \
 717          && REG_OK_FOR_INDEX_P (xfoo0))))))
 718
 719 /* Go to ADDR if X is the sum of a register
 720    and a valid index term for mode MODE.  */
 721 #define GO_IF_REG_PLUS_INDEX(X, MODE, ADDR)     \
 722 { register rtx xfooa;                                                   \
 723   if (GET_CODE (X) == PLUS)                                             \
 724     { if (GET_CODE (XEXP (X, 0)) == REG                                 \
 725           && REG_OK_FOR_BASE_P (XEXP (X, 0))                            \
 726           && (xfooa = XEXP (X, 1),                                      \
 727               INDEX_TERM_P (xfooa, MODE)))                              \
 728         goto ADDR;                                                      \
 729       if (GET_CODE (XEXP (X, 1)) == REG                                 \
 730           && REG_OK_FOR_BASE_P (XEXP (X, 1))                            \
 731           && (xfooa = XEXP (X, 0),                                      \
 732               INDEX_TERM_P (xfooa, MODE)))                              \
 733         goto ADDR; } }
 734
 735 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)  \
 736 { register rtx xfoo, xfoo0, xfoo1;                                      \
 737   GO_IF_NONINDEXED_ADDRESS (X, ADDR);                                   \
 738   if (GET_CODE (X) == PLUS)                                             \
 739     { /* Handle <address>[index] represented with index-sum outermost */\
 740       xfoo = XEXP (X, 0);                                               \
 741       if (INDEX_TERM_P (xfoo, MODE))                                    \
 742         { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 1), ADDR); }               \
 743       xfoo = XEXP (X, 1);                                               \
 744       if (INDEX_TERM_P (xfoo, MODE))                                    \
 745         { GO_IF_NONINDEXED_ADDRESS (XEXP (X, 0), ADDR); }               \
 746       /* Handle offset(reg)[index] with offset added outermost */       \
 747       if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 0)))                \
 748         { if (GET_CODE (XEXP (X, 1)) == REG                             \
 749               && REG_OK_FOR_BASE_P (XEXP (X, 1)))                       \
 750             goto ADDR;                                                  \
 751           GO_IF_REG_PLUS_INDEX (XEXP (X, 1), MODE, ADDR); }             \
 752       if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 1)))                \
 753         { if (GET_CODE (XEXP (X, 0)) == REG                             \
 754               && REG_OK_FOR_BASE_P (XEXP (X, 0)))                       \
 755             goto ADDR;                                                  \
 756           GO_IF_REG_PLUS_INDEX (XEXP (X, 0), MODE, ADDR); } } }
 757 \f
 758 /* Try machine-dependent ways of modifying an illegitimate address
 759    to be legitimate.  If we find one, return the new, valid address.
 760    This macro is used in only one place: `memory_address' in explow.c.
 761
 762    OLDX is the address as it was before break_out_memory_refs was called.
 763    In some cases it is useful to look at this to decide what needs to be done.
 764
 765    MODE and WIN are passed so that this macro can use
 766    GO_IF_LEGITIMATE_ADDRESS.
 767
 768    It is always safe for this macro to do nothing.  It exists to recognize
 769    opportunities to optimize the output.
 770
 771    For the VAX, nothing needs to be done.  */
 772
 773 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)  {}
 774
 775 /* Go to LABEL if ADDR (a legitimate address expression)
 776    has an effect that depends on the machine mode it is used for.
 777    On the VAX, the predecrement and postincrement address depend thus
 778    (the amount of decrement or increment being the length of the operand)
 779    and all indexed address depend thus (because the index scale factor
 780    is the length of the operand).  */
 781 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)        \
 782  { if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC)       \
 783      goto LABEL;                                                        \
 784    if (GET_CODE (ADDR) == PLUS)                                         \
 785      { if (CONSTANT_ADDRESS_P (XEXP (ADDR, 0))                          \
 786            && GET_CODE (XEXP (ADDR, 1)) == REG);                        \
 787        else if (CONSTANT_ADDRESS_P (XEXP (ADDR, 1))                     \
 788                 && GET_CODE (XEXP (ADDR, 0)) == REG);                   \
 789        else goto LABEL; }}
 790 \f
 791 /* Specify the machine mode that this machine uses
 792    for the index in the tablejump instruction.  */
 793 #define CASE_VECTOR_MODE HImode
 794
 795 /* Define as C expression which evaluates to nonzero if the tablejump
 796    instruction expects the table to contain offsets from the address of the
 797    table.
 798    Do not define this if the table should contain absolute addresses.  */
 799 #define CASE_VECTOR_PC_RELATIVE 1
 800
 801 /* Define this if the case instruction drops through after the table
 802    when the index is out of range.  Don't define it if the case insn
 803    jumps to the default label instead.  */
 804 #define CASE_DROPS_THROUGH
 805
 806 /* Indicate that jump tables go in the text section.  This is
 807    necessary when compiling PIC code.  */
 808 #define JUMP_TABLES_IN_TEXT_SECTION 1
 809
 810 /* Define this as 1 if `char' should by default be signed; else as 0.  */
 811 #define DEFAULT_SIGNED_CHAR 1
 812
 813 /* This flag, if defined, says the same insns that convert to a signed fixnum
 814    also convert validly to an unsigned one.  */
 815 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
 816
 817 /* Max number of bytes we can move from memory to memory
 818    in one reasonably fast instruction.  */
 819 #define MOVE_MAX 8
 820
 821 /* Nonzero if access to memory by bytes is slow and undesirable.  */
 822 #define SLOW_BYTE_ACCESS 0
 823
 824 /* Define if shifts truncate the shift count
 825    which implies one can omit a sign-extension or zero-extension
 826    of a shift count.  */
 827 /* #define SHIFT_COUNT_TRUNCATED */
 828
 829 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
 830    is done just by pretending it is already truncated.  */
 831 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
 832
 833 /* When a prototype says `char' or `short', really pass an `int'.
 834    (On the VAX, this is required for system-library compatibility.)  */
 835 #define PROMOTE_PROTOTYPES 1
 836
 837 /* Specify the machine mode that pointers have.
 838    After generation of rtl, the compiler makes no further distinction
 839    between pointers and any other objects of this machine mode.  */
 840 #define Pmode SImode
 841
 842 /* A function address in a call instruction
 843    is a byte address (for indexing purposes)
 844    so give the MEM rtx a byte's mode.  */
 845 #define FUNCTION_MODE QImode
 846
 847 /* This machine doesn't use IEEE floats.  */
 848
 849 #define TARGET_FLOAT_FORMAT VAX_FLOAT_FORMAT
 850
 851 /* Specify the cost of a branch insn; roughly the number of extra insns that
 852    should be added to avoid a branch.
 853
 854    Branches are extremely cheap on the VAX while the shift insns often
 855    used to replace branches can be expensive.  */
 856
 857 #define BRANCH_COST 0
 858
 859 /*
 860  * We can use the BSD C library routines for the libgcc calls that are
 861  * still generated, since that's what they boil down to anyways.
 862  */
 863
 864 #define UDIVSI3_LIBCALL "*udiv"
 865 #define UMODSI3_LIBCALL "*urem"
 866 \f
 867 /* Tell final.c how to eliminate redundant test instructions.  */
 868
 869 /* Here we define machine-dependent flags and fields in cc_status
 870    (see `conditions.h').  No extra ones are needed for the VAX.  */
 871
 872 /* Store in cc_status the expressions
 873    that the condition codes will describe
 874    after execution of an instruction whose pattern is EXP.
 875    Do not alter them if the instruction would not alter the cc's.  */
 876
 877 #define NOTICE_UPDATE_CC(EXP, INSN) \
 878 { if (GET_CODE (EXP) == SET)                                    \
 879     { if (GET_CODE (SET_SRC (EXP)) == CALL)                     \
 880         CC_STATUS_INIT;                                         \
 881       else if (GET_CODE (SET_DEST (EXP)) != ZERO_EXTRACT        \
 882                && GET_CODE (SET_DEST (EXP)) != PC)              \
 883         {                                                       \
 884           cc_status.flags = 0;                                  \
 885           /* The integer operations below don't set carry or    \
 886              set it in an incompatible way.  That's ok though   \
 887              as the Z bit is all we need when doing unsigned    \
 888              comparisons on the result of these insns (since    \
 889              they're always with 0).  Set CC_NO_OVERFLOW to     \
 890              generate the correct unsigned branches.  */        \
 891           switch (GET_CODE (SET_SRC (EXP)))                     \
 892             {                                                   \
 893             case NEG:                                           \
 894               if (GET_MODE_CLASS (GET_MODE (EXP)) == MODE_FLOAT)\
 895                 break;                                          \
 896             case AND:                                           \
 897             case IOR:                                           \
 898             case XOR:                                           \
 899             case NOT:                                           \
 900             case MEM:                                           \
 901             case REG:                                           \
 902               cc_status.flags = CC_NO_OVERFLOW;                 \
 903               break;                                            \
 904             default:                                            \
 905               break;                                            \
 906             }                                                   \
 907           cc_status.value1 = SET_DEST (EXP);                    \
 908           cc_status.value2 = SET_SRC (EXP); } }                 \
 909   else if (GET_CODE (EXP) == PARALLEL                           \
 910            && GET_CODE (XVECEXP (EXP, 0, 0)) == SET)            \
 911     {                                                           \
 912       if (GET_CODE (SET_SRC (XVECEXP (EXP, 0, 0))) == CALL)     \
 913         CC_STATUS_INIT;                                         \
 914       else if (GET_CODE (SET_DEST (XVECEXP (EXP, 0, 0))) != PC) \
 915         { cc_status.flags = 0;                                  \
 916           cc_status.value1 = SET_DEST (XVECEXP (EXP, 0, 0));    \
 917           cc_status.value2 = SET_SRC (XVECEXP (EXP, 0, 0)); }   \
 918       else                                                      \
 919         /* PARALLELs whose first element sets the PC are aob,   \
 920            sob insns.  They do change the cc's.  */             \
 921         CC_STATUS_INIT; }                                       \
 922   else CC_STATUS_INIT;                                          \
 923   if (cc_status.value1 && GET_CODE (cc_status.value1) == REG    \
 924       && cc_status.value2                                       \
 925       && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2))  \
 926     cc_status.value2 = 0;                                       \
 927   if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM    \
 928       && cc_status.value2                                       \
 929       && GET_CODE (cc_status.value2) == MEM)                    \
 930     cc_status.value2 = 0; }
 931 /* Actual condition, one line up, should be that value2's address
 932    depends on value1, but that is too much of a pain.  */
 933
 934 #define OUTPUT_JUMP(NORMAL, FLOAT, NO_OV)  \
 935 { if (cc_status.flags & CC_NO_OVERFLOW)                         \
 936     return NO_OV;                                               \
 937   return NORMAL; }
 938 \f
 939 /* Control the assembler format that we output.  */
 940
 941 /* Output at beginning of assembler file.  */
 942 /* When debugging, we want to output an extra dummy label so that gas
 943    can distinguish between D_float and G_float prior to processing the
 944    .stabs directive identifying type double.  */
 945
 946 #define ASM_FILE_START(FILE) \
 947   do {                                                          \
 948     fputs (ASM_APP_OFF, FILE);                                  \
 949     if (write_symbols == DBX_DEBUG)                             \
 950       fprintf (FILE, "___vax_%c_doubles:\n", ASM_DOUBLE_CHAR);  \
 951   } while (0)
 952
 953
 954 /* Output to assembler file text saying following lines
 955    may contain character constants, extra white space, comments, etc.  */
 956
 957 #define ASM_APP_ON "#APP\n"
 958
 959 /* Output to assembler file text saying following lines
 960    no longer contain unusual constructs.  */
 961
 962 #define ASM_APP_OFF "#NO_APP\n"
 963
 964 /* Output before read-only data.  */
 965
 966 #define TEXT_SECTION_ASM_OP "\t.text"
 967
 968 /* Output before writable data.  */
 969
 970 #define DATA_SECTION_ASM_OP "\t.data"
 971
 972 /* How to refer to registers in assembler output.
 973    This sequence is indexed by compiler's hard-register-number (see above).
 974    The register names will be prefixed by REGISTER_PREFIX, if any.  */
 975
 976 #define REGISTER_PREFIX ""
 977 #define REGISTER_NAMES \
 978 {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", \
 979  "r9", "r10", "r11", "ap", "fp", "sp", "pc"}
 980
 981 /* This is BSD, so it wants DBX format.  */
 982
 983 #define DBX_DEBUGGING_INFO 1
 984
 985 /* Do not break .stabs pseudos into continuations.  */
 986
 987 #define DBX_CONTIN_LENGTH 0
 988
 989 /* This is the char to use for continuation (in case we need to turn
 990    continuation back on).  */
 991
 992 #define DBX_CONTIN_CHAR '?'
 993
 994 /* Don't use the `xsfoo;' construct in DBX output; this system
 995    doesn't support it.  */
 996
 997 #define DBX_NO_XREFS
 998
 999 /* Output the .stabs for a C `static' variable in the data section.  */
1000 #define DBX_STATIC_STAB_DATA_SECTION
1001
1002 /* VAX specific: which type character is used for type double?  */
1003
1004 #define ASM_DOUBLE_CHAR (TARGET_G_FLOAT ? 'g' : 'd')
1005
1006 /* This is how to output a command to make the user-level label named NAME
1007    defined for reference from other files.  */
1008
1009 /* Globalizing directive for a label.  */
1010 #define GLOBAL_ASM_OP ".globl "
1011
1012 /* The prefix to add to user-visible assembler symbols.  */
1013
1014 #define USER_LABEL_PREFIX "_"
1015
1016 /* This is how to store into the string LABEL
1017    the symbol_ref name of an internal numbered label where
1018    PREFIX is the class of label and NUM is the number within the class.
1019    This is suitable for output with `assemble_name'.  */
1020
1021 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
1022   sprintf (LABEL, "*%s%d", PREFIX, NUM)
1023
1024 /* This is how to output an insn to push a register on the stack.
1025    It need not be very fast code.  */
1026
1027 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
1028   fprintf (FILE, "\tpushl %s\n", reg_names[REGNO])
1029
1030 /* This is how to output an insn to pop a register from the stack.
1031    It need not be very fast code.  */
1032
1033 #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
1034   fprintf (FILE, "\tmovl (%s)+,%s\n", reg_names[STACK_POINTER_REGNUM], \
1035            reg_names[REGNO])
1036
1037 /* This is how to output an element of a case-vector that is absolute.
1038    (The VAX does not use such vectors,
1039    but we must define this macro anyway.)  */
1040
1041 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)            \
1042   do                                                    \
1043     {                                                   \
1044       char label[256];                                  \
1045       ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE));\
1046       fprintf (FILE, "\t.long ");                       \
1047       assemble_name (FILE, label);                      \
1048       fprintf (FILE, "\n");                             \
1049     }                                                   \
1050   while (0)
1051
1052 /* This is how to output an element of a case-vector that is relative.  */
1053
1054 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)        \
1055   do                                                            \
1056     {                                                           \
1057       char label[256];                                          \
1058       ASM_GENERATE_INTERNAL_LABEL (label, "L", (VALUE));        \
1059       fprintf (FILE, "\t.word ");                               \
1060       assemble_name (FILE, label);                              \
1061       ASM_GENERATE_INTERNAL_LABEL (label, "L", (REL));          \
1062       fprintf (FILE, "-");                                      \
1063       assemble_name (FILE, label);                              \
1064       fprintf (FILE, "\n");                                     \
1065     }                                                           \
1066   while (0)
1067
1068 /* This is how to output an assembler line
1069    that says to advance the location counter
1070    to a multiple of 2**LOG bytes.  */
1071
1072 #define ASM_OUTPUT_ALIGN(FILE,LOG)  \
1073   fprintf (FILE, "\t.align %d\n", (LOG))
1074
1075 /* This is how to output an assembler line
1076    that says to advance the location counter by SIZE bytes.  */
1077
1078 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
1079   fprintf (FILE, "\t.space %u\n", (SIZE))
1080
1081 /* This says how to output an assembler line
1082    to define a global common symbol.  */
1083
1084 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
1085 ( fputs (".comm ", (FILE)),                     \
1086   assemble_name ((FILE), (NAME)),               \
1087   fprintf ((FILE), ",%u\n", (ROUNDED)))
1088
1089 /* This says how to output an assembler line
1090    to define a local common symbol.  */
1091
1092 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
1093 ( fputs (".lcomm ", (FILE)),                    \
1094   assemble_name ((FILE), (NAME)),               \
1095   fprintf ((FILE), ",%u\n", (ROUNDED)))
1096
1097 /* Store in OUTPUT a string (made with alloca) containing
1098    an assembler-name for a local static variable named NAME.
1099    LABELNO is an integer which is different for each call.  */
1100
1101 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
1102 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
1103   sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
1104
1105 /* Print an instruction operand X on file FILE.
1106    CODE is the code from the %-spec that requested printing this operand;
1107    if `%z3' was used to print operand 3, then CODE is 'z'.
1108
1109 VAX operand formatting codes:
1110
1111  letter    print
1112    C    reverse branch condition
1113    D    64-bit immediate operand
1114    B    the low 8 bits of the complement of a constant operand
1115    H    the low 16 bits of the complement of a constant operand
1116    M    a mask for the N highest bits of a word
1117    N    the complement of a constant integer operand
1118    P    constant operand plus 1
1119    R    32 - constant operand
1120    b    the low 8 bits of a negated constant operand
1121    h    the low 16 bits of a negated constant operand
1122    #    'd' or 'g' depending on whether dfloat or gfloat is used
1123    |    register prefix  */
1124
1125 /* The purpose of D is to get around a quirk or bug in VAX assembler
1126    whereby -1 in a 64-bit immediate operand means 0x00000000ffffffff,
1127    which is not a 64-bit minus one.  */
1128
1129 #define PRINT_OPERAND_PUNCT_VALID_P(CODE)                               \
1130   ((CODE) == '#' || (CODE) == '|')
1131
1132 #define PRINT_OPERAND(FILE, X, CODE)  \
1133 { if (CODE == '#') fputc (ASM_DOUBLE_CHAR, FILE);                       \
1134   else if (CODE == '|')                                                 \
1135     fputs (REGISTER_PREFIX, FILE);                                      \
1136   else if (CODE == 'C')                                                 \
1137     fputs (rev_cond_name (X), FILE);                                    \
1138   else if (CODE == 'D' && GET_CODE (X) == CONST_INT && INTVAL (X) < 0)  \
1139     fprintf (FILE, "$0xffffffff%08x", INTVAL (X));                      \
1140   else if (CODE == 'P' && GET_CODE (X) == CONST_INT)                    \
1141     fprintf (FILE, "$%d", INTVAL (X) + 1);                              \
1142   else if (CODE == 'N' && GET_CODE (X) == CONST_INT)                    \
1143     fprintf (FILE, "$%d", ~ INTVAL (X));                                \
1144   /* rotl instruction cannot deal with negative arguments.  */          \
1145   else if (CODE == 'R' && GET_CODE (X) == CONST_INT)                    \
1146     fprintf (FILE, "$%d", 32 - INTVAL (X));                             \
1147   else if (CODE == 'H' && GET_CODE (X) == CONST_INT)                    \
1148     fprintf (FILE, "$%d", 0xffff & ~ INTVAL (X));                       \
1149   else if (CODE == 'h' && GET_CODE (X) == CONST_INT)                    \
1150     fprintf (FILE, "$%d", (short) - INTVAL (x));                        \
1151   else if (CODE == 'B' && GET_CODE (X) == CONST_INT)                    \
1152     fprintf (FILE, "$%d", 0xff & ~ INTVAL (X));                         \
1153   else if (CODE == 'b' && GET_CODE (X) == CONST_INT)                    \
1154     fprintf (FILE, "$%d", 0xff & - INTVAL (X));                         \
1155   else if (CODE == 'M' && GET_CODE (X) == CONST_INT)                    \
1156     fprintf (FILE, "$%d", ~((1 << INTVAL (x)) - 1));                    \
1157   else if (GET_CODE (X) == REG)                                         \
1158     fprintf (FILE, "%s", reg_names[REGNO (X)]);                         \
1159   else if (GET_CODE (X) == MEM)                                         \
1160     output_address (XEXP (X, 0));                                       \
1161   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)      \
1162     { char dstr[30];                                                    \
1163       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (X),               \
1164                        sizeof (dstr), 0, 1);                            \
1165       fprintf (FILE, "$0f%s", dstr); }                                  \
1166   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)      \
1167     { char dstr[30];                                                    \
1168       real_to_decimal (dstr, CONST_DOUBLE_REAL_VALUE (X),               \
1169                        sizeof (dstr), 0, 1);                            \
1170       fprintf (FILE, "$0%c%s", ASM_DOUBLE_CHAR, dstr); }                \
1171   else { putc ('$', FILE); output_addr_const (FILE, X); }}
1172
1173 /* Print a memory operand whose address is X, on file FILE.
1174    This uses a function in output-vax.c.  */
1175
1176 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
1177  print_operand_address (FILE, ADDR)
1178
1179 /* This is a blatent lie.  However, it's good enough, since we don't
1180    actually have any code whatsoever for which this isn't overridden
1181    by the proper FDE definition.  */
1182 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, PC_REGNUM)