gcc/config/alpha/alpha.h

   1 /* Definitions of target machine for GNU compiler, for DEC Alpha.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002 Free Software Foundation, Inc.
   4    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* Target CPU builtins.  */
  24 #define TARGET_CPU_CPP_BUILTINS()                       \
  25   do                                                    \
  26     {                                                   \
  27         builtin_define ("__alpha");                     \
  28         builtin_define ("__alpha__");                   \
  29         builtin_assert ("cpu=alpha");                   \
  30         builtin_assert ("machine=alpha");               \
  31         if (TARGET_CIX)                                 \
  32           {                                             \
  33             builtin_define ("__alpha_cix__");           \
  34             builtin_assert ("cpu=cix");                 \
  35           }                                             \
  36         if (TARGET_FIX)                                 \
  37           {                                             \
  38             builtin_define ("__alpha_fix__");           \
  39             builtin_assert ("cpu=fix");                 \
  40           }                                             \
  41         if (TARGET_BWX)                                 \
  42           {                                             \
  43             builtin_define ("__alpha_bwx__");           \
  44             builtin_assert ("cpu=bwx");                 \
  45           }                                             \
  46         if (TARGET_MAX)                                 \
  47           {                                             \
  48             builtin_define ("__alpha_max__");           \
  49             builtin_assert ("cpu=max");                 \
  50           }                                             \
  51         if (TARGET_CPU_EV6)                             \
  52           {                                             \
  53             builtin_define ("__alpha_ev6__");           \
  54             builtin_assert ("cpu=ev6");                 \
  55           }                                             \
  56         else if (TARGET_CPU_EV5)                        \
  57           {                                             \
  58             builtin_define ("__alpha_ev5__");           \
  59             builtin_assert ("cpu=ev5");                 \
  60           }                                             \
  61         else    /* Presumably ev4.  */                  \
  62           {                                             \
  63             builtin_define ("__alpha_ev4__");           \
  64             builtin_assert ("cpu=ev4");                 \
  65           }                                             \
  66         if (TARGET_IEEE || TARGET_IEEE_WITH_INEXACT)    \
  67           builtin_define ("_IEEE_FP");                  \
  68         if (TARGET_IEEE_WITH_INEXACT)                   \
  69           builtin_define ("_IEEE_FP_INEXACT");          \
  70                                                         \
  71         /* Macros dependent on the C dialect.  */       \
  72         SUBTARGET_LANGUAGE_CPP_BUILTINS();              \
  73 } while (0)
  74
  75 #ifndef SUBTARGET_LANGUAGE_CPP_BUILTINS
  76 #define SUBTARGET_LANGUAGE_CPP_BUILTINS()               \
  77   do                                                    \
  78     {                                                   \
  79       if (preprocessing_asm_p ())                       \
  80         builtin_define_std ("LANGUAGE_ASSEMBLY");       \
  81       else if (c_language == clk_c)                     \
  82         builtin_define_std ("LANGUAGE_C");              \
  83       else if (c_language == clk_cplusplus)             \
  84         {                                               \
  85           builtin_define ("__LANGUAGE_C_PLUS_PLUS");    \
  86           builtin_define ("__LANGUAGE_C_PLUS_PLUS__");  \
  87         }                                               \
  88       if (flag_objc)                                    \
  89         {                                               \
  90           builtin_define ("__LANGUAGE_OBJECTIVE_C");    \
  91           builtin_define ("__LANGUAGE_OBJECTIVE_C__");  \
  92         }                                               \
  93     }                                                   \
  94   while (0)
  95 #endif
  96
  97 #define CPP_SPEC "%(cpp_subtarget)"
  98
  99 #ifndef CPP_SUBTARGET_SPEC
 100 #define CPP_SUBTARGET_SPEC ""
 101 #endif
 102
 103 #define WORD_SWITCH_TAKES_ARG(STR)              \
 104  (!strcmp (STR, "rpath") || DEFAULT_WORD_SWITCH_TAKES_ARG(STR))
 105
 106 /* Print subsidiary information on the compiler version in use.  */
 107 #define TARGET_VERSION
 108
 109 /* Run-time compilation parameters selecting different hardware subsets.  */
 110
 111 /* Which processor to schedule for. The cpu attribute defines a list that
 112    mirrors this list, so changes to alpha.md must be made at the same time.  */
 113
 114 enum processor_type
 115 {
 116   PROCESSOR_EV4,                        /* 2106[46]{a,} */
 117   PROCESSOR_EV5,                        /* 21164{a,pc,} */
 118   PROCESSOR_EV6,                        /* 21264 */
 119   PROCESSOR_MAX
 120 };
 121
 122 extern enum processor_type alpha_cpu;
 123
 124 enum alpha_trap_precision
 125 {
 126   ALPHA_TP_PROG,        /* No precision (default).  */
 127   ALPHA_TP_FUNC,        /* Trap contained within originating function.  */
 128   ALPHA_TP_INSN         /* Instruction accuracy and code is resumption safe.  */
 129 };
 130
 131 enum alpha_fp_rounding_mode
 132 {
 133   ALPHA_FPRM_NORM,      /* Normal rounding mode.  */
 134   ALPHA_FPRM_MINF,      /* Round towards minus-infinity.  */
 135   ALPHA_FPRM_CHOP,      /* Chopped rounding mode (towards 0).  */
 136   ALPHA_FPRM_DYN        /* Dynamic rounding mode.  */
 137 };
 138
 139 enum alpha_fp_trap_mode
 140 {
 141   ALPHA_FPTM_N,         /* Normal trap mode.  */
 142   ALPHA_FPTM_U,         /* Underflow traps enabled.  */
 143   ALPHA_FPTM_SU,        /* Software completion, w/underflow traps */
 144   ALPHA_FPTM_SUI        /* Software completion, w/underflow & inexact traps */
 145 };
 146
 147 extern int target_flags;
 148
 149 extern enum alpha_trap_precision alpha_tp;
 150 extern enum alpha_fp_rounding_mode alpha_fprm;
 151 extern enum alpha_fp_trap_mode alpha_fptm;
 152 extern int alpha_tls_size;
 153
 154 /* This means that floating-point support exists in the target implementation
 155    of the Alpha architecture.  This is usually the default.  */
 156 #define MASK_FP         (1 << 0)
 157 #define TARGET_FP       (target_flags & MASK_FP)
 158
 159 /* This means that floating-point registers are allowed to be used.  Note
 160    that Alpha implementations without FP operations are required to
 161    provide the FP registers.  */
 162
 163 #define MASK_FPREGS     (1 << 1)
 164 #define TARGET_FPREGS   (target_flags & MASK_FPREGS)
 165
 166 /* This means that gas is used to process the assembler file.  */
 167
 168 #define MASK_GAS        (1 << 2)
 169 #define TARGET_GAS      (target_flags & MASK_GAS)
 170
 171 /* This means that we should mark procedures as IEEE conformant.  */
 172
 173 #define MASK_IEEE_CONFORMANT (1 << 3)
 174 #define TARGET_IEEE_CONFORMANT  (target_flags & MASK_IEEE_CONFORMANT)
 175
 176 /* This means we should be IEEE-compliant except for inexact.  */
 177
 178 #define MASK_IEEE       (1 << 4)
 179 #define TARGET_IEEE     (target_flags & MASK_IEEE)
 180
 181 /* This means we should be fully IEEE-compliant.  */
 182
 183 #define MASK_IEEE_WITH_INEXACT (1 << 5)
 184 #define TARGET_IEEE_WITH_INEXACT (target_flags & MASK_IEEE_WITH_INEXACT)
 185
 186 /* This means we must construct all constants rather than emitting
 187    them as literal data.  */
 188
 189 #define MASK_BUILD_CONSTANTS (1 << 6)
 190 #define TARGET_BUILD_CONSTANTS (target_flags & MASK_BUILD_CONSTANTS)
 191
 192 /* This means we handle floating points in VAX F- (float)
 193    or G- (double) Format.  */
 194
 195 #define MASK_FLOAT_VAX  (1 << 7)
 196 #define TARGET_FLOAT_VAX (target_flags & MASK_FLOAT_VAX)
 197
 198 /* This means that the processor has byte and half word loads and stores
 199    (the BWX extension).  */
 200
 201 #define MASK_BWX        (1 << 8)
 202 #define TARGET_BWX      (target_flags & MASK_BWX)
 203
 204 /* This means that the processor has the MAX extension.  */
 205 #define MASK_MAX        (1 << 9)
 206 #define TARGET_MAX      (target_flags & MASK_MAX)
 207
 208 /* This means that the processor has the FIX extension.  */
 209 #define MASK_FIX        (1 << 10)
 210 #define TARGET_FIX      (target_flags & MASK_FIX)
 211
 212 /* This means that the processor has the CIX extension.  */
 213 #define MASK_CIX        (1 << 11)
 214 #define TARGET_CIX      (target_flags & MASK_CIX)
 215
 216 /* This means use !literal style explicit relocations.  */
 217 #define MASK_EXPLICIT_RELOCS (1 << 12)
 218 #define TARGET_EXPLICIT_RELOCS (target_flags & MASK_EXPLICIT_RELOCS)
 219
 220 /* This means use 16-bit relocations to .sdata/.sbss.  */
 221 #define MASK_SMALL_DATA (1 << 13)
 222 #define TARGET_SMALL_DATA (target_flags & MASK_SMALL_DATA)
 223
 224 /* This means emit thread pointer loads for kernel not user.  */
 225 #define MASK_TLS_KERNEL (1 << 14)
 226 #define TARGET_TLS_KERNEL (target_flags & MASK_TLS_KERNEL)
 227
 228 /* This means use direct branches to local functions.  */
 229 #define MASK_SMALL_TEXT (1 << 15)
 230 #define TARGET_SMALL_TEXT (target_flags & MASK_SMALL_TEXT)
 231
 232 /* This means that the processor is an EV5, EV56, or PCA56.
 233    Unlike alpha_cpu this is not affected by -mtune= setting.  */
 234 #define MASK_CPU_EV5    (1 << 28)
 235 #define TARGET_CPU_EV5  (target_flags & MASK_CPU_EV5)
 236
 237 /* Likewise for EV6.  */
 238 #define MASK_CPU_EV6    (1 << 29)
 239 #define TARGET_CPU_EV6  (target_flags & MASK_CPU_EV6)
 240
 241 /* This means we support the .arch directive in the assembler.  Only
 242    defined in TARGET_CPU_DEFAULT.  */
 243 #define MASK_SUPPORT_ARCH (1 << 30)
 244 #define TARGET_SUPPORT_ARCH     (target_flags & MASK_SUPPORT_ARCH)
 245
 246 /* These are for target os support and cannot be changed at runtime.  */
 247 #define TARGET_ABI_WINDOWS_NT 0
 248 #define TARGET_ABI_OPEN_VMS 0
 249 #define TARGET_ABI_UNICOSMK 0
 250 #define TARGET_ABI_OSF (!TARGET_ABI_WINDOWS_NT  \
 251                         && !TARGET_ABI_OPEN_VMS \
 252                         && !TARGET_ABI_UNICOSMK)
 253
 254 #ifndef TARGET_AS_CAN_SUBTRACT_LABELS
 255 #define TARGET_AS_CAN_SUBTRACT_LABELS TARGET_GAS
 256 #endif
 257 #ifndef TARGET_AS_SLASH_BEFORE_SUFFIX
 258 #define TARGET_AS_SLASH_BEFORE_SUFFIX TARGET_GAS
 259 #endif
 260 #ifndef TARGET_CAN_FAULT_IN_PROLOGUE
 261 #define TARGET_CAN_FAULT_IN_PROLOGUE 0
 262 #endif
 263 #ifndef TARGET_HAS_XFLOATING_LIBS
 264 #define TARGET_HAS_XFLOATING_LIBS 0
 265 #endif
 266 #ifndef TARGET_PROFILING_NEEDS_GP
 267 #define TARGET_PROFILING_NEEDS_GP 0
 268 #endif
 269 #ifndef TARGET_LD_BUGGY_LDGP
 270 #define TARGET_LD_BUGGY_LDGP 0
 271 #endif
 272 #ifndef TARGET_FIXUP_EV5_PREFETCH
 273 #define TARGET_FIXUP_EV5_PREFETCH 0
 274 #endif
 275 #ifndef HAVE_AS_TLS
 276 #define HAVE_AS_TLS 0
 277 #endif
 278
 279 /* Macro to define tables used to set the flags.
 280    This is a list in braces of pairs in braces,
 281    each pair being { "NAME", VALUE }
 282    where VALUE is the bits to set or minus the bits to clear.
 283    An empty string NAME is used to identify the default VALUE.  */
 284
 285 #define TARGET_SWITCHES                                                 \
 286   { {"no-soft-float", MASK_FP, N_("Use hardware fp")},                  \
 287     {"soft-float", - MASK_FP, N_("Do not use hardware fp")},            \
 288     {"fp-regs", MASK_FPREGS, N_("Use fp registers")},                   \
 289     {"no-fp-regs", - (MASK_FP|MASK_FPREGS),                             \
 290      N_("Do not use fp registers")},                                    \
 291     {"alpha-as", -MASK_GAS, N_("Do not assume GAS")},                   \
 292     {"gas", MASK_GAS, N_("Assume GAS")},                                \
 293     {"ieee-conformant", MASK_IEEE_CONFORMANT,                           \
 294      N_("Request IEEE-conformant math library routines (OSF/1)")},      \
 295     {"ieee", MASK_IEEE|MASK_IEEE_CONFORMANT,                            \
 296      N_("Emit IEEE-conformant code, without inexact exceptions")},      \
 297     {"ieee-with-inexact", MASK_IEEE_WITH_INEXACT|MASK_IEEE_CONFORMANT,  \
 298      N_("Emit IEEE-conformant code, with inexact exceptions")},         \
 299     {"build-constants", MASK_BUILD_CONSTANTS,                           \
 300      N_("Do not emit complex integer constants to read-only memory")},  \
 301     {"float-vax", MASK_FLOAT_VAX, N_("Use VAX fp")},                    \
 302     {"float-ieee", -MASK_FLOAT_VAX, N_("Do not use VAX fp")},           \
 303     {"bwx", MASK_BWX, N_("Emit code for the byte/word ISA extension")}, \
 304     {"no-bwx", -MASK_BWX, ""},                                          \
 305     {"max", MASK_MAX,                                                   \
 306      N_("Emit code for the motion video ISA extension")},               \
 307     {"no-max", -MASK_MAX, ""},                                          \
 308     {"fix", MASK_FIX,                                                   \
 309      N_("Emit code for the fp move and sqrt ISA extension")},           \
 310     {"no-fix", -MASK_FIX, ""},                                          \
 311     {"cix", MASK_CIX, N_("Emit code for the counting ISA extension")},  \
 312     {"no-cix", -MASK_CIX, ""},                                          \
 313     {"explicit-relocs", MASK_EXPLICIT_RELOCS,                           \
 314      N_("Emit code using explicit relocation directives")},             \
 315     {"no-explicit-relocs", -MASK_EXPLICIT_RELOCS, ""},                  \
 316     {"small-data", MASK_SMALL_DATA,                                     \
 317      N_("Emit 16-bit relocations to the small data areas")},            \
 318     {"large-data", -MASK_SMALL_DATA,                                    \
 319      N_("Emit 32-bit relocations to the small data areas")},            \
 320     {"small-text", MASK_SMALL_TEXT,                                     \
 321      N_("Emit direct branches to local functions")},                    \
 322     {"large-text", -MASK_SMALL_TEXT, ""},                               \
 323     {"tls-kernel", MASK_TLS_KERNEL,                                     \
 324      N_("Emit rdval instead of rduniq for thread pointer")},            \
 325     {"", TARGET_DEFAULT | TARGET_CPU_DEFAULT                            \
 326          | TARGET_DEFAULT_EXPLICIT_RELOCS, ""} }
 327
 328 #define TARGET_DEFAULT MASK_FP|MASK_FPREGS
 329
 330 #ifndef TARGET_CPU_DEFAULT
 331 #define TARGET_CPU_DEFAULT 0
 332 #endif
 333
 334 #ifndef TARGET_DEFAULT_EXPLICIT_RELOCS
 335 #ifdef HAVE_AS_EXPLICIT_RELOCS
 336 #define TARGET_DEFAULT_EXPLICIT_RELOCS MASK_EXPLICIT_RELOCS
 337 #else
 338 #define TARGET_DEFAULT_EXPLICIT_RELOCS 0
 339 #endif
 340 #endif
 341
 342 extern const char *alpha_cpu_string;    /* For -mcpu= */
 343 extern const char *alpha_tune_string;   /* For -mtune= */
 344 extern const char *alpha_fprm_string;   /* For -mfp-rounding-mode=[n|m|c|d] */
 345 extern const char *alpha_fptm_string;   /* For -mfp-trap-mode=[n|u|su|sui]  */
 346 extern const char *alpha_tp_string;     /* For -mtrap-precision=[p|f|i] */
 347 extern const char *alpha_mlat_string;   /* For -mmemory-latency= */
 348 extern const char *alpha_tls_size_string; /* For -mtls-size= */
 349
 350 #define TARGET_OPTIONS                                  \
 351 {                                                       \
 352   {"cpu=",              &alpha_cpu_string,              \
 353    N_("Use features of and schedule given CPU"), 0},    \
 354   {"tune=",             &alpha_tune_string,             \
 355    N_("Schedule given CPU"), 0},                        \
 356   {"fp-rounding-mode=", &alpha_fprm_string,             \
 357    N_("Control the generated fp rounding mode"), 0},    \
 358   {"fp-trap-mode=",     &alpha_fptm_string,             \
 359    N_("Control the IEEE trap mode"), 0},                \
 360   {"trap-precision=",   &alpha_tp_string,               \
 361    N_("Control the precision given to fp exceptions"), 0},      \
 362   {"memory-latency=",   &alpha_mlat_string,             \
 363    N_("Tune expected memory latency"), 0},              \
 364   {"tls-size=",         &alpha_tls_size_string,         \
 365    N_("Specify bit size of immediate TLS offsets"), 0}, \
 366 }
 367
 368 /* This macro defines names of additional specifications to put in the
 369    specs that can be used in various specifications like CC1_SPEC.  Its
 370    definition is an initializer with a subgrouping for each command option.
 371
 372    Each subgrouping contains a string constant, that defines the
 373    specification name, and a string constant that used by the GNU CC driver
 374    program.
 375
 376    Do not define this macro if it does not need to do anything.  */
 377
 378 #ifndef SUBTARGET_EXTRA_SPECS
 379 #define SUBTARGET_EXTRA_SPECS
 380 #endif
 381
 382 #define EXTRA_SPECS                             \
 383   { "cpp_subtarget", CPP_SUBTARGET_SPEC },      \
 384   SUBTARGET_EXTRA_SPECS
 385
 386
 387 /* Sometimes certain combinations of command options do not make sense
 388    on a particular target machine.  You can define a macro
 389    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
 390    defined, is executed once just after all the command options have
 391    been parsed.
 392
 393    On the Alpha, it is used to translate target-option strings into
 394    numeric values.  */
 395
 396 #define OVERRIDE_OPTIONS override_options ()
 397
 398
 399 /* Define this macro to change register usage conditional on target flags.
 400
 401    On the Alpha, we use this to disable the floating-point registers when
 402    they don't exist.  */
 403
 404 #define CONDITIONAL_REGISTER_USAGE              \
 405 {                                               \
 406   int i;                                        \
 407   if (! TARGET_FPREGS)                          \
 408     for (i = 32; i < 63; i++)                   \
 409       fixed_regs[i] = call_used_regs[i] = 1;    \
 410 }
 411
 412
 413 /* Show we can debug even without a frame pointer.  */
 414 #define CAN_DEBUG_WITHOUT_FP
 415 \f
 416 /* target machine storage layout */
 417
 418 /* Define the size of `int'.  The default is the same as the word size.  */
 419 #define INT_TYPE_SIZE 32
 420
 421 /* Define the size of `long long'.  The default is the twice the word size.  */
 422 #define LONG_LONG_TYPE_SIZE 64
 423
 424 /* We're IEEE unless someone says to use VAX.  */
 425 #define TARGET_FLOAT_FORMAT \
 426   (TARGET_FLOAT_VAX ? VAX_FLOAT_FORMAT : IEEE_FLOAT_FORMAT)
 427
 428 /* The two floating-point formats we support are S-floating, which is
 429    4 bytes, and T-floating, which is 8 bytes.  `float' is S and `double'
 430    and `long double' are T.  */
 431
 432 #define FLOAT_TYPE_SIZE 32
 433 #define DOUBLE_TYPE_SIZE 64
 434 #define LONG_DOUBLE_TYPE_SIZE 64
 435
 436 #define WCHAR_TYPE "unsigned int"
 437 #define WCHAR_TYPE_SIZE 32
 438
 439 /* Define this macro if it is advisable to hold scalars in registers
 440    in a wider mode than that declared by the program.  In such cases,
 441    the value is constrained to be within the bounds of the declared
 442    type, but kept valid in the wider mode.  The signedness of the
 443    extension may differ from that of the type.
 444
 445    For Alpha, we always store objects in a full register.  32-bit objects
 446    are always sign-extended, but smaller objects retain their signedness.  */
 447
 448 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \
 449   if (GET_MODE_CLASS (MODE) == MODE_INT         \
 450       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
 451     {                                           \
 452       if ((MODE) == SImode)                     \
 453         (UNSIGNEDP) = 0;                        \
 454       (MODE) = DImode;                          \
 455     }
 456
 457 /* Define this if function arguments should also be promoted using the above
 458    procedure.  */
 459
 460 #define PROMOTE_FUNCTION_ARGS
 461
 462 /* Likewise, if the function return value is promoted.  */
 463
 464 #define PROMOTE_FUNCTION_RETURN
 465
 466 /* Define this if most significant bit is lowest numbered
 467    in instructions that operate on numbered bit-fields.
 468
 469    There are no such instructions on the Alpha, but the documentation
 470    is little endian.  */
 471 #define BITS_BIG_ENDIAN 0
 472
 473 /* Define this if most significant byte of a word is the lowest numbered.
 474    This is false on the Alpha.  */
 475 #define BYTES_BIG_ENDIAN 0
 476
 477 /* Define this if most significant word of a multiword number is lowest
 478    numbered.
 479
 480    For Alpha we can decide arbitrarily since there are no machine instructions
 481    for them.  Might as well be consistent with bytes.  */
 482 #define WORDS_BIG_ENDIAN 0
 483
 484 /* Width of a word, in units (bytes).  */
 485 #define UNITS_PER_WORD 8
 486
 487 /* Width in bits of a pointer.
 488    See also the macro `Pmode' defined below.  */
 489 #define POINTER_SIZE 64
 490
 491 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
 492 #define PARM_BOUNDARY 64
 493
 494 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
 495 #define STACK_BOUNDARY 64
 496
 497 /* Allocation boundary (in *bits*) for the code of a function.  */
 498 #define FUNCTION_BOUNDARY 32
 499
 500 /* Alignment of field after `int : 0' in a structure.  */
 501 #define EMPTY_FIELD_BOUNDARY 64
 502
 503 /* Every structure's size must be a multiple of this.  */
 504 #define STRUCTURE_SIZE_BOUNDARY 8
 505
 506 /* A bit-field declared as `int' forces `int' alignment for the struct.  */
 507 #define PCC_BITFIELD_TYPE_MATTERS 1
 508
 509 /* No data type wants to be aligned rounder than this.  */
 510 #define BIGGEST_ALIGNMENT 128
 511
 512 /* For atomic access to objects, must have at least 32-bit alignment
 513    unless the machine has byte operations.  */
 514 #define MINIMUM_ATOMIC_ALIGNMENT ((unsigned int) (TARGET_BWX ? 8 : 32))
 515
 516 /* Align all constants and variables to at least a word boundary so
 517    we can pick up pieces of them faster.  */
 518 /* ??? Only if block-move stuff knows about different source/destination
 519    alignment.  */
 520 #if 0
 521 #define CONSTANT_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
 522 #define DATA_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
 523 #endif
 524
 525 /* Set this nonzero if move instructions will actually fail to work
 526    when given unaligned data.
 527
 528    Since we get an error message when we do one, call them invalid.  */
 529
 530 #define STRICT_ALIGNMENT 1
 531
 532 /* Set this nonzero if unaligned move instructions are extremely slow.
 533
 534    On the Alpha, they trap.  */
 535
 536 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
 537 \f
 538 /* Standard register usage.  */
 539
 540 /* Number of actual hardware registers.
 541    The hardware registers are assigned numbers for the compiler
 542    from 0 to just below FIRST_PSEUDO_REGISTER.
 543    All registers that the compiler knows about must be given numbers,
 544    even those that are not normally considered general registers.
 545
 546    We define all 32 integer registers, even though $31 is always zero,
 547    and all 32 floating-point registers, even though $f31 is also
 548    always zero.  We do not bother defining the FP status register and
 549    there are no other registers.
 550
 551    Since $31 is always zero, we will use register number 31 as the
 552    argument pointer.  It will never appear in the generated code
 553    because we will always be eliminating it in favor of the stack
 554    pointer or hardware frame pointer.
 555
 556    Likewise, we use $f31 for the frame pointer, which will always
 557    be eliminated in favor of the hardware frame pointer or the
 558    stack pointer.  */
 559
 560 #define FIRST_PSEUDO_REGISTER 64
 561
 562 /* 1 for registers that have pervasive standard uses
 563    and are not available for the register allocator.  */
 564
 565 #define FIXED_REGISTERS  \
 566  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 567   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, \
 568   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
 569   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
 570
 571 /* 1 for registers not available across function calls.
 572    These must include the FIXED_REGISTERS and also any
 573    registers that can be used without being saved.
 574    The latter must include the registers where values are returned
 575    and the register where structure-value addresses are passed.
 576    Aside from that, you can include as many other registers as you like.  */
 577 #define CALL_USED_REGISTERS  \
 578  {1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, \
 579   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, \
 580   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
 581   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
 582
 583 /* List the order in which to allocate registers.  Each register must be
 584    listed once, even those in FIXED_REGISTERS.
 585
 586    We allocate in the following order:
 587    $f10-$f15            (nonsaved floating-point register)
 588    $f22-$f30            (likewise)
 589    $f21-$f16            (likewise, but input args)
 590    $f0                  (nonsaved, but return value)
 591    $f1                  (nonsaved, but immediate before saved)
 592    $f2-$f9              (saved floating-point registers)
 593    $1-$8                (nonsaved integer registers)
 594    $22-$25              (likewise)
 595    $28                  (likewise)
 596    $0                   (likewise, but return value)
 597    $21-$16              (likewise, but input args)
 598    $27                  (procedure value in OSF, nonsaved in NT)
 599    $9-$14               (saved integer registers)
 600    $26                  (return PC)
 601    $15                  (frame pointer)
 602    $29                  (global pointer)
 603    $30, $31, $f31       (stack pointer and always zero/ap & fp)  */
 604
 605 #define REG_ALLOC_ORDER         \
 606   {42, 43, 44, 45, 46, 47,              \
 607    54, 55, 56, 57, 58, 59, 60, 61, 62,  \
 608    53, 52, 51, 50, 49, 48,              \
 609    32, 33,                              \
 610    34, 35, 36, 37, 38, 39, 40, 41,      \
 611    1, 2, 3, 4, 5, 6, 7, 8,              \
 612    22, 23, 24, 25,                      \
 613    28,                                  \
 614    0,                                   \
 615    21, 20, 19, 18, 17, 16,              \
 616    27,                                  \
 617    9, 10, 11, 12, 13, 14,               \
 618    26,                                  \
 619    15,                                  \
 620    29,                                  \
 621    30, 31, 63 }
 622
 623 /* Return number of consecutive hard regs needed starting at reg REGNO
 624    to hold something of mode MODE.
 625    This is ordinarily the length in words of a value of mode MODE
 626    but can be less for certain modes in special long registers.  */
 627
 628 #define HARD_REGNO_NREGS(REGNO, MODE)   \
 629   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 630
 631 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
 632    On Alpha, the integer registers can hold any mode.  The floating-point
 633    registers can hold 32-bit and 64-bit integers as well, but not 16-bit
 634    or 8-bit values.  */
 635
 636 #define HARD_REGNO_MODE_OK(REGNO, MODE)                                 \
 637   ((REGNO) >= 32 && (REGNO) <= 62                                       \
 638    ? GET_MODE_UNIT_SIZE (MODE) == 8 || GET_MODE_UNIT_SIZE (MODE) == 4   \
 639    : 1)
 640
 641 /* Value is 1 if MODE is a supported vector mode.  */
 642
 643 #define VECTOR_MODE_SUPPORTED_P(MODE) \
 644   (TARGET_MAX \
 645    && ((MODE) == V8QImode || (MODE) == V4HImode || (MODE) == V2SImode))
 646
 647 /* A C expression that is nonzero if a value of mode
 648    MODE1 is accessible in mode MODE2 without copying.
 649
 650    This asymmetric test is true when MODE1 could be put
 651    in an FP register but MODE2 could not.  */
 652
 653 #define MODES_TIEABLE_P(MODE1, MODE2)                           \
 654   (HARD_REGNO_MODE_OK (32, (MODE1))                             \
 655    ? HARD_REGNO_MODE_OK (32, (MODE2))                           \
 656    : 1)
 657
 658 /* Specify the registers used for certain standard purposes.
 659    The values of these macros are register numbers.  */
 660
 661 /* Alpha pc isn't overloaded on a register that the compiler knows about.  */
 662 /* #define PC_REGNUM  */
 663
 664 /* Register to use for pushing function arguments.  */
 665 #define STACK_POINTER_REGNUM 30
 666
 667 /* Base register for access to local variables of the function.  */
 668 #define HARD_FRAME_POINTER_REGNUM 15
 669
 670 /* Value should be nonzero if functions must have frame pointers.
 671    Zero means the frame pointer need not be set up (and parms
 672    may be accessed via the stack pointer) in functions that seem suitable.
 673    This is computed in `reload', in reload1.c.  */
 674 #define FRAME_POINTER_REQUIRED 0
 675
 676 /* Base register for access to arguments of the function.  */
 677 #define ARG_POINTER_REGNUM 31
 678
 679 /* Base register for access to local variables of function.  */
 680 #define FRAME_POINTER_REGNUM 63
 681
 682 /* Register in which static-chain is passed to a function.
 683
 684    For the Alpha, this is based on an example; the calling sequence
 685    doesn't seem to specify this.  */
 686 #define STATIC_CHAIN_REGNUM 1
 687
 688 /* The register number of the register used to address a table of
 689    static data addresses in memory.  */
 690 #define PIC_OFFSET_TABLE_REGNUM 29
 691
 692 /* Define this macro if the register defined by `PIC_OFFSET_TABLE_REGNUM'
 693    is clobbered by calls.  */
 694 /* ??? It is and it isn't.  It's required to be valid for a given
 695    function when the function returns.  It isn't clobbered by
 696    current_file functions.  Moreover, we do not expose the ldgp
 697    until after reload, so we're probably safe.  */
 698 /* #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED */
 699
 700 /* Register in which address to store a structure value
 701    arrives in the function.  On the Alpha, the address is passed
 702    as a hidden argument.  */
 703 #define STRUCT_VALUE 0
 704 \f
 705 /* Define the classes of registers for register constraints in the
 706    machine description.  Also define ranges of constants.
 707
 708    One of the classes must always be named ALL_REGS and include all hard regs.
 709    If there is more than one class, another class must be named NO_REGS
 710    and contain no registers.
 711
 712    The name GENERAL_REGS must be the name of a class (or an alias for
 713    another name such as ALL_REGS).  This is the class of registers
 714    that is allowed by "g" or "r" in a register constraint.
 715    Also, registers outside this class are allocated only when
 716    instructions express preferences for them.
 717
 718    The classes must be numbered in nondecreasing order; that is,
 719    a larger-numbered class must never be contained completely
 720    in a smaller-numbered class.
 721
 722    For any two classes, it is very desirable that there be another
 723    class that represents their union.  */
 724
 725 enum reg_class {
 726   NO_REGS, R0_REG, R24_REG, R25_REG, R27_REG,
 727   GENERAL_REGS, FLOAT_REGS, ALL_REGS,
 728   LIM_REG_CLASSES
 729 };
 730
 731 #define N_REG_CLASSES (int) LIM_REG_CLASSES
 732
 733 /* Give names of register classes as strings for dump file.  */
 734
 735 #define REG_CLASS_NAMES                                 \
 736  {"NO_REGS", "R0_REG", "R24_REG", "R25_REG", "R27_REG", \
 737   "GENERAL_REGS", "FLOAT_REGS", "ALL_REGS" }
 738
 739 /* Define which registers fit in which classes.
 740    This is an initializer for a vector of HARD_REG_SET
 741    of length N_REG_CLASSES.  */
 742
 743 #define REG_CLASS_CONTENTS                              \
 744 { {0x00000000, 0x00000000},     /* NO_REGS */           \
 745   {0x00000001, 0x00000000},     /* R0_REG */            \
 746   {0x01000000, 0x00000000},     /* R24_REG */           \
 747   {0x02000000, 0x00000000},     /* R25_REG */           \
 748   {0x08000000, 0x00000000},     /* R27_REG */           \
 749   {0xffffffff, 0x80000000},     /* GENERAL_REGS */      \
 750   {0x00000000, 0x7fffffff},     /* FLOAT_REGS */        \
 751   {0xffffffff, 0xffffffff} }
 752
 753 /* The same information, inverted:
 754    Return the class number of the smallest class containing
 755    reg number REGNO.  This could be a conditional expression
 756    or could index an array.  */
 757
 758 #define REGNO_REG_CLASS(REGNO)                  \
 759  ((REGNO) == 0 ? R0_REG                         \
 760   : (REGNO) == 24 ? R24_REG                     \
 761   : (REGNO) == 25 ? R25_REG                     \
 762   : (REGNO) == 27 ? R27_REG                     \
 763   : (REGNO) >= 32 && (REGNO) <= 62 ? FLOAT_REGS \
 764   : GENERAL_REGS)
 765
 766 /* The class value for index registers, and the one for base regs.  */
 767 #define INDEX_REG_CLASS NO_REGS
 768 #define BASE_REG_CLASS GENERAL_REGS
 769
 770 /* Get reg_class from a letter such as appears in the machine description.  */
 771
 772 #define REG_CLASS_FROM_LETTER(C)        \
 773  ((C) == 'a' ? R24_REG                  \
 774   : (C) == 'b' ? R25_REG                \
 775   : (C) == 'c' ? R27_REG                \
 776   : (C) == 'f' ? FLOAT_REGS             \
 777   : (C) == 'v' ? R0_REG                 \
 778   : NO_REGS)
 779
 780 /* Define this macro to change register usage conditional on target flags.  */
 781 /* #define CONDITIONAL_REGISTER_USAGE  */
 782
 783 /* The letters I, J, K, L, M, N, O, and P in a register constraint string
 784    can be used to stand for particular ranges of immediate operands.
 785    This macro defines what the ranges are.
 786    C is the letter, and VALUE is a constant value.
 787    Return 1 if VALUE is in the range specified by C.
 788
 789    For Alpha:
 790    `I' is used for the range of constants most insns can contain.
 791    `J' is the constant zero.
 792    `K' is used for the constant in an LDA insn.
 793    `L' is used for the constant in a LDAH insn.
 794    `M' is used for the constants that can be AND'ed with using a ZAP insn.
 795    `N' is used for complemented 8-bit constants.
 796    `O' is used for negated 8-bit constants.
 797    `P' is used for the constants 1, 2 and 3.  */
 798
 799 #define CONST_OK_FOR_LETTER_P   alpha_const_ok_for_letter_p
 800
 801 /* Similar, but for floating or large integer constants, and defining letters
 802    G and H.   Here VALUE is the CONST_DOUBLE rtx itself.
 803
 804    For Alpha, `G' is the floating-point constant zero.  `H' is a CONST_DOUBLE
 805    that is the operand of a ZAP insn.  */
 806
 807 #define CONST_DOUBLE_OK_FOR_LETTER_P  alpha_const_double_ok_for_letter_p
 808
 809 /* Optional extra constraints for this machine.
 810
 811    For the Alpha, `Q' means that this is a memory operand but not a
 812    reference to an unaligned location.
 813
 814    `R' is a SYMBOL_REF that has SYMBOL_REF_FLAG set or is the current
 815    function.
 816
 817    'S' is a 6-bit constant (valid for a shift insn).
 818
 819    'T' is a HIGH.
 820
 821    'U' is a symbolic operand.
 822
 823    'W' is a vector zero.   */
 824
 825 #define EXTRA_CONSTRAINT  alpha_extra_constraint
 826
 827 /* Given an rtx X being reloaded into a reg required to be
 828    in class CLASS, return the class of reg to actually use.
 829    In general this is just CLASS; but on some machines
 830    in some cases it is preferable to use a more restrictive class.  */
 831
 832 #define PREFERRED_RELOAD_CLASS  alpha_preferred_reload_class
 833
 834 /* Loading and storing HImode or QImode values to and from memory
 835    usually requires a scratch register.  The exceptions are loading
 836    QImode and HImode from an aligned address to a general register
 837    unless byte instructions are permitted.
 838    We also cannot load an unaligned address or a paradoxical SUBREG into an
 839    FP register.  */
 840
 841 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS,MODE,IN) \
 842   secondary_reload_class((CLASS), (MODE), (IN), 1)
 843
 844 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS,MODE,OUT) \
 845   secondary_reload_class((CLASS), (MODE), (OUT), 0)
 846
 847 /* If we are copying between general and FP registers, we need a memory
 848    location unless the FIX extension is available.  */
 849
 850 #define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) \
 851  (! TARGET_FIX && (((CLASS1) == FLOAT_REGS && (CLASS2) != FLOAT_REGS) \
 852                    || ((CLASS2) == FLOAT_REGS && (CLASS1) != FLOAT_REGS)))
 853
 854 /* Specify the mode to be used for memory when a secondary memory
 855    location is needed.  If MODE is floating-point, use it.  Otherwise,
 856    widen to a word like the default.  This is needed because we always
 857    store integers in FP registers in quadword format.  This whole
 858    area is very tricky! */
 859 #define SECONDARY_MEMORY_NEEDED_MODE(MODE)              \
 860   (GET_MODE_CLASS (MODE) == MODE_FLOAT ? (MODE)         \
 861    : GET_MODE_SIZE (MODE) >= 4 ? (MODE)                 \
 862    : mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (MODE), 0))
 863
 864 /* Return the maximum number of consecutive registers
 865    needed to represent mode MODE in a register of class CLASS.  */
 866
 867 #define CLASS_MAX_NREGS(CLASS, MODE)                            \
 868  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 869
 870 /* Return the class of registers that cannot change mode from FROM to TO.  */
 871
 872 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS)               \
 873   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO)                   \
 874    ? reg_classes_intersect_p (FLOAT_REGS, CLASS) : 0)
 875
 876 /* Define the cost of moving between registers of various classes.  Moving
 877    between FLOAT_REGS and anything else except float regs is expensive.
 878    In fact, we make it quite expensive because we really don't want to
 879    do these moves unless it is clearly worth it.  Optimizations may
 880    reduce the impact of not being able to allocate a pseudo to a
 881    hard register.  */
 882
 883 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2)        \
 884   (((CLASS1) == FLOAT_REGS) == ((CLASS2) == FLOAT_REGS) \
 885    ? 2                                                  \
 886    : TARGET_FIX ? 3 : 4+2*alpha_memory_latency)
 887
 888 /* A C expressions returning the cost of moving data of MODE from a register to
 889    or from memory.
 890
 891    On the Alpha, bump this up a bit.  */
 892
 893 extern int alpha_memory_latency;
 894 #define MEMORY_MOVE_COST(MODE,CLASS,IN)  (2*alpha_memory_latency)
 895
 896 /* Provide the cost of a branch.  Exact meaning under development.  */
 897 #define BRANCH_COST 5
 898 \f
 899 /* Stack layout; function entry, exit and calling.  */
 900
 901 /* Define this if pushing a word on the stack
 902    makes the stack pointer a smaller address.  */
 903 #define STACK_GROWS_DOWNWARD
 904
 905 /* Define this if the nominal address of the stack frame
 906    is at the high-address end of the local variables;
 907    that is, each additional local variable allocated
 908    goes at a more negative offset in the frame.  */
 909 /* #define FRAME_GROWS_DOWNWARD */
 910
 911 /* Offset within stack frame to start allocating local variables at.
 912    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
 913    first local allocated.  Otherwise, it is the offset to the BEGINNING
 914    of the first local allocated.  */
 915
 916 #define STARTING_FRAME_OFFSET 0
 917
 918 /* If we generate an insn to push BYTES bytes,
 919    this says how many the stack pointer really advances by.
 920    On Alpha, don't define this because there are no push insns.  */
 921 /*  #define PUSH_ROUNDING(BYTES) */
 922
 923 /* Define this to be nonzero if stack checking is built into the ABI.  */
 924 #define STACK_CHECK_BUILTIN 1
 925
 926 /* Define this if the maximum size of all the outgoing args is to be
 927    accumulated and pushed during the prologue.  The amount can be
 928    found in the variable current_function_outgoing_args_size.  */
 929 #define ACCUMULATE_OUTGOING_ARGS 1
 930
 931 /* Offset of first parameter from the argument pointer register value.  */
 932
 933 #define FIRST_PARM_OFFSET(FNDECL) 0
 934
 935 /* Definitions for register eliminations.
 936
 937    We have two registers that can be eliminated on the Alpha.  First, the
 938    frame pointer register can often be eliminated in favor of the stack
 939    pointer register.  Secondly, the argument pointer register can always be
 940    eliminated; it is replaced with either the stack or frame pointer.  */
 941
 942 /* This is an array of structures.  Each structure initializes one pair
 943    of eliminable registers.  The "from" register number is given first,
 944    followed by "to".  Eliminations of the same "from" register are listed
 945    in order of preference.  */
 946
 947 #define ELIMINABLE_REGS                              \
 948 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},        \
 949  { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},   \
 950  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},      \
 951  { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
 952
 953 /* Given FROM and TO register numbers, say whether this elimination is allowed.
 954    Frame pointer elimination is automatically handled.
 955
 956    All eliminations are valid since the cases where FP can't be
 957    eliminated are already handled.  */
 958
 959 #define CAN_ELIMINATE(FROM, TO) 1
 960
 961 /* Round up to a multiple of 16 bytes.  */
 962 #define ALPHA_ROUND(X) (((X) + 15) & ~ 15)
 963
 964 /* Define the offset between two registers, one to be eliminated, and the other
 965    its replacement, at the start of a routine.  */
 966 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
 967   ((OFFSET) = alpha_initial_elimination_offset(FROM, TO))
 968
 969 /* Define this if stack space is still allocated for a parameter passed
 970    in a register.  */
 971 /* #define REG_PARM_STACK_SPACE */
 972
 973 /* Value is the number of bytes of arguments automatically
 974    popped when returning from a subroutine call.
 975    FUNDECL is the declaration node of the function (as a tree),
 976    FUNTYPE is the data type of the function (as a tree),
 977    or for a library call it is an identifier node for the subroutine name.
 978    SIZE is the number of bytes of arguments passed on the stack.  */
 979
 980 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
 981
 982 /* Define how to find the value returned by a function.
 983    VALTYPE is the data type of the value (as a tree).
 984    If the precise function being called is known, FUNC is its FUNCTION_DECL;
 985    otherwise, FUNC is 0.
 986
 987    On Alpha the value is found in $0 for integer functions and
 988    $f0 for floating-point functions.  */
 989
 990 #define FUNCTION_VALUE(VALTYPE, FUNC)   \
 991   gen_rtx_REG (((INTEGRAL_TYPE_P (VALTYPE)                      \
 992                  && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD)   \
 993                 || POINTER_TYPE_P (VALTYPE))                    \
 994                ? word_mode : TYPE_MODE (VALTYPE),               \
 995                ((TARGET_FPREGS                                  \
 996                  && (TREE_CODE (VALTYPE) == REAL_TYPE           \
 997                      || TREE_CODE (VALTYPE) == COMPLEX_TYPE))   \
 998                 ? 32 : 0))
 999
1000 /* Define how to find the value returned by a library function
1001    assuming the value has mode MODE.  */
1002
1003 #define LIBCALL_VALUE(MODE)     \
1004    gen_rtx_REG (MODE,                                           \
1005                 (TARGET_FPREGS                                  \
1006                  && (GET_MODE_CLASS (MODE) == MODE_FLOAT        \
1007                      || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) \
1008                  ? 32 : 0))
1009
1010 /* The definition of this macro implies that there are cases where
1011    a scalar value cannot be returned in registers.
1012
1013    For the Alpha, any structure or union type is returned in memory, as
1014    are integers whose size is larger than 64 bits.  */
1015
1016 #define RETURN_IN_MEMORY(TYPE) \
1017   (TYPE_MODE (TYPE) == BLKmode \
1018    || TYPE_MODE (TYPE) == TFmode \
1019    || TYPE_MODE (TYPE) == TCmode \
1020    || (TREE_CODE (TYPE) == INTEGER_TYPE && TYPE_PRECISION (TYPE) > 64))
1021
1022 /* 1 if N is a possible register number for a function value
1023    as seen by the caller.  */
1024
1025 #define FUNCTION_VALUE_REGNO_P(N)  \
1026   ((N) == 0 || (N) == 1 || (N) == 32 || (N) == 33)
1027
1028 /* 1 if N is a possible register number for function argument passing.
1029    On Alpha, these are $16-$21 and $f16-$f21.  */
1030
1031 #define FUNCTION_ARG_REGNO_P(N) \
1032   (((N) >= 16 && (N) <= 21) || ((N) >= 16 + 32 && (N) <= 21 + 32))
1033 \f
1034 /* Define a data type for recording info about an argument list
1035    during the scan of that argument list.  This data type should
1036    hold all necessary information about the function itself
1037    and about the args processed so far, enough to enable macros
1038    such as FUNCTION_ARG to determine where the next arg should go.
1039
1040    On Alpha, this is a single integer, which is a number of words
1041    of arguments scanned so far.
1042    Thus 6 or more means all following args should go on the stack.  */
1043
1044 #define CUMULATIVE_ARGS int
1045
1046 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1047    for a call to a function whose data type is FNTYPE.
1048    For a library call, FNTYPE is 0.  */
1049
1050 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT)  (CUM) = 0
1051
1052 /* Define intermediate macro to compute the size (in registers) of an argument
1053    for the Alpha.  */
1054
1055 #define ALPHA_ARG_SIZE(MODE, TYPE, NAMED)                               \
1056   ((MODE) == TFmode || (MODE) == TCmode ? 1                             \
1057    : (((MODE) == BLKmode ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \
1058       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1059
1060 /* Update the data in CUM to advance over an argument
1061    of mode MODE and data type TYPE.
1062    (TYPE is null for libcalls where that information may not be available.)  */
1063
1064 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
1065   if (MUST_PASS_IN_STACK (MODE, TYPE))                                  \
1066     (CUM) = 6;                                                          \
1067   else                                                                  \
1068     (CUM) += ALPHA_ARG_SIZE (MODE, TYPE, NAMED)
1069
1070 /* Determine where to put an argument to a function.
1071    Value is zero to push the argument on the stack,
1072    or a hard register in which to store the argument.
1073
1074    MODE is the argument's machine mode.
1075    TYPE is the data type of the argument (as a tree).
1076     This is null for libcalls where that information may
1077     not be available.
1078    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1079     the preceding args and about the function being called.
1080    NAMED is nonzero if this argument is a named parameter
1081     (otherwise it is an extra parameter matching an ellipsis).
1082
1083    On Alpha the first 6 words of args are normally in registers
1084    and the rest are pushed.  */
1085
1086 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)    \
1087   function_arg((CUM), (MODE), (TYPE), (NAMED))
1088
1089 /* A C expression that indicates when an argument must be passed by
1090    reference.  If nonzero for an argument, a copy of that argument is
1091    made in memory and a pointer to the argument is passed instead of
1092    the argument itself.  The pointer is passed in whatever way is
1093    appropriate for passing a pointer to that type.  */
1094
1095 #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
1096   ((MODE) == TFmode || (MODE) == TCmode)
1097
1098 /* Specify the padding direction of arguments.
1099
1100    On the Alpha, we must pad upwards in order to be able to pass args in
1101    registers.  */
1102
1103 #define FUNCTION_ARG_PADDING(MODE, TYPE)        upward
1104
1105 /* For an arg passed partly in registers and partly in memory,
1106    this is the number of registers used.
1107    For args passed entirely in registers or entirely in memory, zero.  */
1108
1109 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED)      \
1110 ((CUM) < 6 && 6 < (CUM) + ALPHA_ARG_SIZE (MODE, TYPE, NAMED)    \
1111  ? 6 - (CUM) : 0)
1112
1113 /* Perform any needed actions needed for a function that is receiving a
1114    variable number of arguments.  */
1115 #define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL) \
1116   alpha_setup_incoming_varargs(CUM,MODE,TYPE,&(PRETEND_SIZE),NO_RTL)
1117
1118 /* Try to output insns to set TARGET equal to the constant C if it can be
1119    done in less than N insns.  Do all computations in MODE.  Returns the place
1120    where the output has been placed if it can be done and the insns have been
1121    emitted.  If it would take more than N insns, zero is returned and no
1122    insns and emitted.  */
1123
1124 /* Define the information needed to generate branch and scc insns.  This is
1125    stored from the compare operation.  Note that we can't use "rtx" here
1126    since it hasn't been defined!  */
1127
1128 struct alpha_compare
1129 {
1130   struct rtx_def *op0, *op1;
1131   int fp_p;
1132 };
1133
1134 extern struct alpha_compare alpha_compare;
1135
1136 /* Make (or fake) .linkage entry for function call.
1137    IS_LOCAL is 0 if name is used in call, 1 if name is used in definition.  */
1138
1139 /* This macro defines the start of an assembly comment.  */
1140
1141 #define ASM_COMMENT_START " #"
1142
1143 /* This macro produces the initial definition of a function.  */
1144
1145 #define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL) \
1146   alpha_start_function(FILE,NAME,DECL);
1147
1148 /* This macro closes up a function definition for the assembler.  */
1149
1150 #define ASM_DECLARE_FUNCTION_SIZE(FILE,NAME,DECL) \
1151   alpha_end_function(FILE,NAME,DECL)
1152
1153 /* Output any profiling code before the prologue.  */
1154
1155 #define PROFILE_BEFORE_PROLOGUE 1
1156
1157 /* Never use profile counters.  */
1158
1159 #define NO_PROFILE_COUNTERS 1
1160
1161 /* Output assembler code to FILE to increment profiler label # LABELNO
1162    for profiling a function entry.  Under OSF/1, profiling is enabled
1163    by simply passing -pg to the assembler and linker.  */
1164
1165 #define FUNCTION_PROFILER(FILE, LABELNO)
1166
1167 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
1168    the stack pointer does not matter.  The value is tested only in
1169    functions that have frame pointers.
1170    No definition is equivalent to always zero.  */
1171
1172 #define EXIT_IGNORE_STACK 1
1173
1174 /* Define registers used by the epilogue and return instruction.  */
1175
1176 #define EPILOGUE_USES(REGNO)    ((REGNO) == 26)
1177 \f
1178 /* Output assembler code for a block containing the constant parts
1179    of a trampoline, leaving space for the variable parts.
1180
1181    The trampoline should set the static chain pointer to value placed
1182    into the trampoline and should branch to the specified routine.
1183    Note that $27 has been set to the address of the trampoline, so we can
1184    use it for addressability of the two data items.  */
1185
1186 #define TRAMPOLINE_TEMPLATE(FILE)               \
1187 do {                                            \
1188   fprintf (FILE, "\tldq $1,24($27)\n");         \
1189   fprintf (FILE, "\tldq $27,16($27)\n");        \
1190   fprintf (FILE, "\tjmp $31,($27),0\n");        \
1191   fprintf (FILE, "\tnop\n");                    \
1192   fprintf (FILE, "\t.quad 0,0\n");              \
1193 } while (0)
1194
1195 /* Section in which to place the trampoline.  On Alpha, instructions
1196    may only be placed in a text segment.  */
1197
1198 #define TRAMPOLINE_SECTION text_section
1199
1200 /* Length in units of the trampoline for entering a nested function.  */
1201
1202 #define TRAMPOLINE_SIZE    32
1203
1204 /* The alignment of a trampoline, in bits.  */
1205
1206 #define TRAMPOLINE_ALIGNMENT  64
1207
1208 /* Emit RTL insns to initialize the variable parts of a trampoline.
1209    FNADDR is an RTX for the address of the function's pure code.
1210    CXT is an RTX for the static chain value for the function.  */
1211
1212 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
1213   alpha_initialize_trampoline (TRAMP, FNADDR, CXT, 16, 24, 8)
1214
1215 /* A C expression whose value is RTL representing the value of the return
1216    address for the frame COUNT steps up from the current frame.
1217    FRAMEADDR is the frame pointer of the COUNT frame, or the frame pointer of
1218    the COUNT-1 frame if RETURN_ADDR_IN_PREVIOUS_FRAME is defined.  */
1219
1220 #define RETURN_ADDR_RTX  alpha_return_addr
1221
1222 /* Before the prologue, RA lives in $26.  */
1223 #define INCOMING_RETURN_ADDR_RTX  gen_rtx_REG (Pmode, 26)
1224 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (26)
1225
1226 /* Describe how we implement __builtin_eh_return.  */
1227 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 16 : INVALID_REGNUM)
1228 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, 28)
1229 #define EH_RETURN_HANDLER_RTX \
1230   gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, \
1231                                      current_function_outgoing_args_size))
1232 \f
1233 /* Addressing modes, and classification of registers for them.  */
1234
1235 /* Macros to check register numbers against specific register classes.  */
1236
1237 /* These assume that REGNO is a hard or pseudo reg number.
1238    They give nonzero only if REGNO is a hard reg of the suitable class
1239    or a pseudo reg currently allocated to a suitable hard reg.
1240    Since they use reg_renumber, they are safe only once reg_renumber
1241    has been allocated, which happens in local-alloc.c.  */
1242
1243 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
1244 #define REGNO_OK_FOR_BASE_P(REGNO) \
1245 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32  \
1246  || (REGNO) == 63 || reg_renumber[REGNO] == 63)
1247 \f
1248 /* Maximum number of registers that can appear in a valid memory address.  */
1249 #define MAX_REGS_PER_ADDRESS 1
1250
1251 /* Recognize any constant value that is a valid address.  For the Alpha,
1252    there are only constants none since we want to use LDA to load any
1253    symbolic addresses into registers.  */
1254
1255 #define CONSTANT_ADDRESS_P(X)   \
1256   (GET_CODE (X) == CONST_INT    \
1257    && (unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
1258
1259 /* Include all constant integers and constant doubles, but not
1260    floating-point, except for floating-point zero.  */
1261
1262 #define LEGITIMATE_CONSTANT_P(X)                \
1263   (GET_MODE_CLASS (GET_MODE (X)) != MODE_FLOAT  \
1264    || (X) == CONST0_RTX (GET_MODE (X)))
1265
1266 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1267    and check its validity for a certain class.
1268    We have two alternate definitions for each of them.
1269    The usual definition accepts all pseudo regs; the other rejects
1270    them unless they have been allocated suitable hard regs.
1271    The symbol REG_OK_STRICT causes the latter definition to be used.
1272
1273    Most source files want to accept pseudo regs in the hope that
1274    they will get allocated to the class that the insn wants them to be in.
1275    Source files for reload pass need to be strict.
1276    After reload, it makes no difference, since pseudo regs have
1277    been eliminated by then.  */
1278
1279 /* Nonzero if X is a hard reg that can be used as an index
1280    or if it is a pseudo reg.  */
1281 #define REG_OK_FOR_INDEX_P(X) 0
1282
1283 /* Nonzero if X is a hard reg that can be used as a base reg
1284    or if it is a pseudo reg.  */
1285 #define NONSTRICT_REG_OK_FOR_BASE_P(X)  \
1286   (REGNO (X) < 32 || REGNO (X) == 63 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
1287
1288 /* ??? Nonzero if X is the frame pointer, or some virtual register
1289    that may eliminate to the frame pointer.  These will be allowed to
1290    have offsets greater than 32K.  This is done because register
1291    elimination offsets will change the hi/lo split, and if we split
1292    before reload, we will require additional instructions.  */
1293 #define NONSTRICT_REG_OK_FP_BASE_P(X)           \
1294   (REGNO (X) == 31 || REGNO (X) == 63           \
1295    || (REGNO (X) >= FIRST_PSEUDO_REGISTER       \
1296        && REGNO (X) < LAST_VIRTUAL_REGISTER))
1297
1298 /* Nonzero if X is a hard reg that can be used as a base reg.  */
1299 #define STRICT_REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
1300
1301 #ifdef REG_OK_STRICT
1302 #define REG_OK_FOR_BASE_P(X)    STRICT_REG_OK_FOR_BASE_P (X)
1303 #else
1304 #define REG_OK_FOR_BASE_P(X)    NONSTRICT_REG_OK_FOR_BASE_P (X)
1305 #endif
1306 \f
1307 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression that is a
1308    valid memory address for an instruction.  */
1309
1310 #ifdef REG_OK_STRICT
1311 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN)  \
1312 do {                                            \
1313   if (alpha_legitimate_address_p (MODE, X, 1))  \
1314     goto WIN;                                   \
1315 } while (0)
1316 #else
1317 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, WIN)  \
1318 do {                                            \
1319   if (alpha_legitimate_address_p (MODE, X, 0))  \
1320     goto WIN;                                   \
1321 } while (0)
1322 #endif
1323
1324 /* Try machine-dependent ways of modifying an illegitimate address
1325    to be legitimate.  If we find one, return the new, valid address.
1326    This macro is used in only one place: `memory_address' in explow.c.  */
1327
1328 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)                     \
1329 do {                                                            \
1330   rtx new_x = alpha_legitimize_address (X, NULL_RTX, MODE);     \
1331   if (new_x)                                                    \
1332     {                                                           \
1333       X = new_x;                                                \
1334       goto WIN;                                                 \
1335     }                                                           \
1336 } while (0)
1337
1338 /* Try a machine-dependent way of reloading an illegitimate address
1339    operand.  If we find one, push the reload and jump to WIN.  This
1340    macro is used in only one place: `find_reloads_address' in reload.c.  */
1341
1342 #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_L,WIN)               \
1343 do {                                                                         \
1344   rtx new_x = alpha_legitimize_reload_address (X, MODE, OPNUM, TYPE, IND_L); \
1345   if (new_x)                                                                 \
1346     {                                                                        \
1347       X = new_x;                                                             \
1348       goto WIN;                                                              \
1349     }                                                                        \
1350 } while (0)
1351
1352 /* Go to LABEL if ADDR (a legitimate address expression)
1353    has an effect that depends on the machine mode it is used for.
1354    On the Alpha this is true only for the unaligned modes.   We can
1355    simplify this test since we know that the address must be valid.  */
1356
1357 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)  \
1358 { if (GET_CODE (ADDR) == AND) goto LABEL; }
1359
1360 /* Machine-dependent reorg pass.  */
1361 #define MACHINE_DEPENDENT_REORG(X)      alpha_reorg(X)
1362 \f
1363 /* Specify the machine mode that this machine uses
1364    for the index in the tablejump instruction.  */
1365 #define CASE_VECTOR_MODE SImode
1366
1367 /* Define as C expression which evaluates to nonzero if the tablejump
1368    instruction expects the table to contain offsets from the address of the
1369    table.
1370
1371    Do not define this if the table should contain absolute addresses.
1372    On the Alpha, the table is really GP-relative, not relative to the PC
1373    of the table, but we pretend that it is PC-relative; this should be OK,
1374    but we should try to find some better way sometime.  */
1375 #define CASE_VECTOR_PC_RELATIVE 1
1376
1377 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1378 #define DEFAULT_SIGNED_CHAR 1
1379
1380 /* This flag, if defined, says the same insns that convert to a signed fixnum
1381    also convert validly to an unsigned one.
1382
1383    We actually lie a bit here as overflow conditions are different.  But
1384    they aren't being checked anyway.  */
1385
1386 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
1387
1388 /* Max number of bytes we can move to or from memory
1389    in one reasonably fast instruction.  */
1390
1391 #define MOVE_MAX 8
1392
1393 /* If a memory-to-memory move would take MOVE_RATIO or more simple
1394    move-instruction pairs, we will do a movstr or libcall instead.
1395
1396    Without byte/word accesses, we want no more than four instructions;
1397    with, several single byte accesses are better.  */
1398
1399 #define MOVE_RATIO  (TARGET_BWX ? 7 : 2)
1400
1401 /* Largest number of bytes of an object that can be placed in a register.
1402    On the Alpha we have plenty of registers, so use TImode.  */
1403 #define MAX_FIXED_MODE_SIZE     GET_MODE_BITSIZE (TImode)
1404
1405 /* Nonzero if access to memory by bytes is no faster than for words.
1406    Also nonzero if doing byte operations (specifically shifts) in registers
1407    is undesirable.
1408
1409    On the Alpha, we want to not use the byte operation and instead use
1410    masking operations to access fields; these will save instructions.  */
1411
1412 #define SLOW_BYTE_ACCESS        1
1413
1414 /* Define if operations between registers always perform the operation
1415    on the full register even if a narrower mode is specified.  */
1416 #define WORD_REGISTER_OPERATIONS
1417
1418 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
1419    will either zero-extend or sign-extend.  The value of this macro should
1420    be the code that says which one of the two operations is implicitly
1421    done, NIL if none.  */
1422 #define LOAD_EXTEND_OP(MODE) ((MODE) == SImode ? SIGN_EXTEND : ZERO_EXTEND)
1423
1424 /* Define if loading short immediate values into registers sign extends.  */
1425 #define SHORT_IMMEDIATES_SIGN_EXTEND
1426
1427 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1428    is done just by pretending it is already truncated.  */
1429 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1430
1431 /* We assume that the store-condition-codes instructions store 0 for false
1432    and some other value for true.  This is the value stored for true.  */
1433
1434 #define STORE_FLAG_VALUE 1
1435
1436 /* The CIX ctlz and cttz instructions return 64 for zero.  */
1437 #define CLZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  ((VALUE) = 64, TARGET_CIX)
1438 #define CTZ_DEFINED_VALUE_AT_ZERO(MODE, VALUE)  ((VALUE) = 64, TARGET_CIX)
1439
1440 /* Define the value returned by a floating-point comparison instruction.  */
1441
1442 #define FLOAT_STORE_FLAG_VALUE(MODE) \
1443   REAL_VALUE_ATOF ((TARGET_FLOAT_VAX ? "0.5" : "2.0"), (MODE))
1444
1445 /* Canonicalize a comparison from one we don't have to one we do have.  */
1446
1447 #define CANONICALIZE_COMPARISON(CODE,OP0,OP1) \
1448   do {                                                                  \
1449     if (((CODE) == GE || (CODE) == GT || (CODE) == GEU || (CODE) == GTU) \
1450         && (GET_CODE (OP1) == REG || (OP1) == const0_rtx))              \
1451       {                                                                 \
1452         rtx tem = (OP0);                                                \
1453         (OP0) = (OP1);                                                  \
1454         (OP1) = tem;                                                    \
1455         (CODE) = swap_condition (CODE);                                 \
1456       }                                                                 \
1457     if (((CODE) == LT || (CODE) == LTU)                                 \
1458         && GET_CODE (OP1) == CONST_INT && INTVAL (OP1) == 256)          \
1459       {                                                                 \
1460         (CODE) = (CODE) == LT ? LE : LEU;                               \
1461         (OP1) = GEN_INT (255);                                          \
1462       }                                                                 \
1463   } while (0)
1464
1465 /* Specify the machine mode that pointers have.
1466    After generation of rtl, the compiler makes no further distinction
1467    between pointers and any other objects of this machine mode.  */
1468 #define Pmode DImode
1469
1470 /* Mode of a function address in a call instruction (for indexing purposes).  */
1471
1472 #define FUNCTION_MODE Pmode
1473
1474 /* Define this if addresses of constant functions
1475    shouldn't be put through pseudo regs where they can be cse'd.
1476    Desirable on machines where ordinary constants are expensive
1477    but a CALL with constant address is cheap.
1478
1479    We define this on the Alpha so that gen_call and gen_call_value
1480    get to see the SYMBOL_REF (for the hint field of the jsr).  It will
1481    then copy it into a register, thus actually letting the address be
1482    cse'ed.  */
1483
1484 #define NO_FUNCTION_CSE
1485
1486 /* Define this to be nonzero if shift instructions ignore all but the low-order
1487    few bits.  */
1488 #define SHIFT_COUNT_TRUNCATED 1
1489 \f
1490 /* Control the assembler format that we output.  */
1491
1492 /* Output to assembler file text saying following lines
1493    may contain character constants, extra white space, comments, etc.  */
1494 #define ASM_APP_ON (TARGET_EXPLICIT_RELOCS ? "\t.set\tmacro\n" : "")
1495
1496 /* Output to assembler file text saying following lines
1497    no longer contain unusual constructs.  */
1498 #define ASM_APP_OFF (TARGET_EXPLICIT_RELOCS ? "\t.set\tnomacro\n" : "")
1499
1500 #define TEXT_SECTION_ASM_OP "\t.text"
1501
1502 /* Output before read-only data.  */
1503
1504 #define READONLY_DATA_SECTION_ASM_OP "\t.rdata"
1505
1506 /* Output before writable data.  */
1507
1508 #define DATA_SECTION_ASM_OP "\t.data"
1509
1510 /* How to refer to registers in assembler output.
1511    This sequence is indexed by compiler's hard-register-number (see above).  */
1512
1513 #define REGISTER_NAMES                                          \
1514 {"$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",          \
1515  "$9", "$10", "$11", "$12", "$13", "$14", "$15",                \
1516  "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",        \
1517  "$24", "$25", "$26", "$27", "$28", "$29", "$30", "AP",         \
1518  "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", "$f8", \
1519  "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",         \
1520  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",\
1521  "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "FP"}
1522
1523 /* Strip name encoding when emitting labels.  */
1524
1525 #define ASM_OUTPUT_LABELREF(STREAM, NAME)       \
1526 do {                                            \
1527   const char *name_ = NAME;                     \
1528   if (*name_ == '@' || *name_ == '%')           \
1529     name_ += 2;                                 \
1530   if (*name_ == '*')                            \
1531     name_++;                                    \
1532   else                                          \
1533     fputs (user_label_prefix, STREAM);          \
1534   fputs (name_, STREAM);                        \
1535 } while (0)
1536
1537 /* Globalizing directive for a label.  */
1538 #define GLOBAL_ASM_OP "\t.globl "
1539
1540 /* The prefix to add to user-visible assembler symbols.  */
1541
1542 #define USER_LABEL_PREFIX ""
1543
1544 /* This is how to output a label for a jump table.  Arguments are the same as
1545    for (*targetm.asm_out.internal_label), except the insn for the jump table is
1546    passed.  */
1547
1548 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
1549 { ASM_OUTPUT_ALIGN (FILE, 2); (*targetm.asm_out.internal_label) (FILE, PREFIX, NUM); }
1550
1551 /* This is how to store into the string LABEL
1552    the symbol_ref name of an internal numbered label where
1553    PREFIX is the class of label and NUM is the number within the class.
1554    This is suitable for output with `assemble_name'.  */
1555
1556 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
1557   sprintf ((LABEL), "*$%s%ld", (PREFIX), (long)(NUM))
1558
1559 /* We use the default ASCII-output routine, except that we don't write more
1560    than 50 characters since the assembler doesn't support very long lines.  */
1561
1562 #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
1563   do {                                                                        \
1564     FILE *_hide_asm_out_file = (MYFILE);                                      \
1565     const unsigned char *_hide_p = (const unsigned char *) (MYSTRING);        \
1566     int _hide_thissize = (MYLENGTH);                                          \
1567     int _size_so_far = 0;                                                     \
1568     {                                                                         \
1569       FILE *asm_out_file = _hide_asm_out_file;                                \
1570       const unsigned char *p = _hide_p;                                       \
1571       int thissize = _hide_thissize;                                          \
1572       int i;                                                                  \
1573       fprintf (asm_out_file, "\t.ascii \"");                                  \
1574                                                                               \
1575       for (i = 0; i < thissize; i++)                                          \
1576         {                                                                     \
1577           register int c = p[i];                                              \
1578                                                                               \
1579           if (_size_so_far ++ > 50 && i < thissize - 4)                       \
1580             _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \"");      \
1581                                                                               \
1582           if (c == '\"' || c == '\\')                                         \
1583             putc ('\\', asm_out_file);                                        \
1584           if (c >= ' ' && c < 0177)                                           \
1585             putc (c, asm_out_file);                                           \
1586           else                                                                \
1587             {                                                                 \
1588               fprintf (asm_out_file, "\\%o", c);                              \
1589               /* After an octal-escape, if a digit follows,                   \
1590                  terminate one string constant and start another.             \
1591                  The VAX assembler fails to stop reading the escape           \
1592                  after three digits, so this is the only way we               \
1593                  can get it to parse the data properly.  */                   \
1594               if (i < thissize - 1 && ISDIGIT (p[i + 1]))                     \
1595                 _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \"");  \
1596           }                                                                   \
1597         }                                                                     \
1598       fprintf (asm_out_file, "\"\n");                                         \
1599     }                                                                         \
1600   }                                                                           \
1601   while (0)
1602
1603 /* This is how to output an element of a case-vector that is absolute.
1604    (Alpha does not use such vectors, but we must define this macro anyway.)  */
1605
1606 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) abort ()
1607
1608 /* This is how to output an element of a case-vector that is relative.  */
1609
1610 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
1611   fprintf (FILE, "\t.%s $L%d\n", TARGET_ABI_WINDOWS_NT ? "long" : "gprel32", \
1612            (VALUE))
1613
1614 /* This is how to output an assembler line
1615    that says to advance the location counter
1616    to a multiple of 2**LOG bytes.  */
1617
1618 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
1619   if ((LOG) != 0)                       \
1620     fprintf (FILE, "\t.align %d\n", LOG);
1621
1622 /* This is how to advance the location counter by SIZE bytes.  */
1623
1624 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
1625   fprintf (FILE, "\t.space %d\n", (SIZE))
1626
1627 /* This says how to output an assembler line
1628    to define a global common symbol.  */
1629
1630 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
1631 ( fputs ("\t.comm ", (FILE)),                   \
1632   assemble_name ((FILE), (NAME)),               \
1633   fprintf ((FILE), ",%d\n", (SIZE)))
1634
1635 /* This says how to output an assembler line
1636    to define a local common symbol.  */
1637
1638 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE,ROUNDED)      \
1639 ( fputs ("\t.lcomm ", (FILE)),                          \
1640   assemble_name ((FILE), (NAME)),                       \
1641   fprintf ((FILE), ",%d\n", (SIZE)))
1642 \f
1643
1644 /* Print operand X (an rtx) in assembler syntax to file FILE.
1645    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
1646    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
1647
1648 #define PRINT_OPERAND(FILE, X, CODE)  print_operand (FILE, X, CODE)
1649
1650 /* Determine which codes are valid without a following integer.  These must
1651    not be alphabetic.
1652
1653    ~    Generates the name of the current function.
1654
1655    /    Generates the instruction suffix.  The TRAP_SUFFIX and ROUND_SUFFIX
1656         attributes are examined to determine what is appropriate.
1657
1658    ,    Generates single precision suffix for floating point
1659         instructions (s for IEEE, f for VAX)
1660
1661    -    Generates double precision suffix for floating point
1662         instructions (t for IEEE, g for VAX)
1663
1664    +    Generates a nop instruction after a noreturn call at the very end
1665         of the function
1666    */
1667
1668 #define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
1669   ((CODE) == '/' || (CODE) == ',' || (CODE) == '-' || (CODE) == '~' \
1670    || (CODE) == '#' || (CODE) == '*' || (CODE) == '&' || (CODE) == '+')
1671 \f
1672 /* Print a memory address as an operand to reference that memory location.  */
1673
1674 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
1675   print_operand_address((FILE), (ADDR))
1676
1677 /* Define the codes that are matched by predicates in alpha.c.  */
1678
1679 #define PREDICATE_CODES                                                 \
1680   {"reg_or_0_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE,           \
1681                         CONST_VECTOR}},                                 \
1682   {"reg_or_6bit_operand", {SUBREG, REG, CONST_INT}},                    \
1683   {"reg_or_8bit_operand", {SUBREG, REG, CONST_INT}},                    \
1684   {"reg_or_const_int_operand", {SUBREG, REG, CONST_INT}},               \
1685   {"cint8_operand", {CONST_INT}},                                       \
1686   {"reg_or_cint_operand", {SUBREG, REG, CONST_INT}},                    \
1687   {"add_operand", {SUBREG, REG, CONST_INT}},                            \
1688   {"sext_add_operand", {SUBREG, REG, CONST_INT}},                       \
1689   {"const48_operand", {CONST_INT}},                                     \
1690   {"and_operand", {SUBREG, REG, CONST_INT}},                            \
1691   {"or_operand", {SUBREG, REG, CONST_INT}},                             \
1692   {"mode_mask_operand", {CONST_INT}},                                   \
1693   {"mul8_operand", {CONST_INT}},                                        \
1694   {"mode_width_operand", {CONST_INT}},                                  \
1695   {"alpha_comparison_operator", {EQ, LE, LT, LEU, LTU}},                \
1696   {"alpha_zero_comparison_operator", {EQ, NE, LE, LT, LEU, LTU}},       \
1697   {"alpha_swapped_comparison_operator", {EQ, GE, GT, GEU, GTU}},        \
1698   {"signed_comparison_operator", {EQ, NE, LE, LT, GE, GT}},             \
1699   {"alpha_fp_comparison_operator", {EQ, LE, LT, UNORDERED}},            \
1700   {"divmod_operator", {DIV, MOD, UDIV, UMOD}},                          \
1701   {"const0_operand", {CONST_INT, CONST_DOUBLE, CONST_VECTOR}},          \
1702   {"samegp_function_operand", {SYMBOL_REF}},                            \
1703   {"direct_call_operand", {SYMBOL_REF}},                                \
1704   {"local_symbolic_operand", {SYMBOL_REF, CONST, LABEL_REF}},           \
1705   {"small_symbolic_operand", {SYMBOL_REF, CONST}},                      \
1706   {"global_symbolic_operand", {SYMBOL_REF, CONST}},                     \
1707   {"dtp16_symbolic_operand", {CONST}},                                  \
1708   {"dtp32_symbolic_operand", {CONST}},                                  \
1709   {"gotdtp_symbolic_operand", {CONST}},                                 \
1710   {"tp16_symbolic_operand", {CONST}},                                   \
1711   {"tp32_symbolic_operand", {CONST}},                                   \
1712   {"gottp_symbolic_operand", {CONST}},                                  \
1713   {"call_operand", {REG, SYMBOL_REF}},                                  \
1714   {"input_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE,         \
1715                      CONST_VECTOR, SYMBOL_REF, CONST, LABEL_REF, HIGH}},\
1716   {"some_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE,          \
1717                     CONST_VECTOR, SYMBOL_REF, CONST, LABEL_REF, HIGH}}, \
1718   {"some_ni_operand", {SUBREG, REG, MEM}},                              \
1719   {"aligned_memory_operand", {MEM}},                                    \
1720   {"unaligned_memory_operand", {MEM}},                                  \
1721   {"reg_or_unaligned_mem_operand", {SUBREG, REG, MEM}},                 \
1722   {"any_memory_operand", {MEM}},                                        \
1723   {"hard_fp_register_operand", {SUBREG, REG}},                          \
1724   {"hard_int_register_operand", {SUBREG, REG}},                         \
1725   {"reg_not_elim_operand", {SUBREG, REG}},                              \
1726   {"reg_no_subreg_operand", {REG}},                                     \
1727   {"addition_operation", {PLUS}},                                       \
1728   {"symbolic_operand", {SYMBOL_REF, LABEL_REF, CONST}},                 \
1729   {"some_small_symbolic_operand", {SET, PARALLEL, PREFETCH, UNSPEC,     \
1730                                    UNSPEC_VOLATILE}},
1731 \f
1732 /* Define the `__builtin_va_list' type for the ABI.  */
1733 #define BUILD_VA_LIST_TYPE(VALIST) \
1734   (VALIST) = alpha_build_va_list ()
1735
1736 /* Implement `va_start' for varargs and stdarg.  */
1737 #define EXPAND_BUILTIN_VA_START(valist, nextarg) \
1738   alpha_va_start (valist, nextarg)
1739
1740 /* Implement `va_arg'.  */
1741 #define EXPAND_BUILTIN_VA_ARG(valist, type) \
1742   alpha_va_arg (valist, type)
1743 \f
1744 /* Tell collect that the object format is ECOFF.  */
1745 #define OBJECT_FORMAT_COFF
1746 #define EXTENDED_COFF
1747
1748 /* If we use NM, pass -g to it so it only lists globals.  */
1749 #define NM_FLAGS "-pg"
1750
1751 /* Definitions for debugging.  */
1752
1753 #define SDB_DEBUGGING_INFO 1            /* generate info for mips-tfile */
1754 #define DBX_DEBUGGING_INFO 1            /* generate embedded stabs */
1755 #define MIPS_DEBUGGING_INFO 1           /* MIPS specific debugging info */
1756
1757 #ifndef PREFERRED_DEBUGGING_TYPE        /* assume SDB_DEBUGGING_INFO */
1758 #define PREFERRED_DEBUGGING_TYPE  SDB_DEBUG
1759 #endif
1760
1761
1762 /* Correct the offset of automatic variables and arguments.  Note that
1763    the Alpha debug format wants all automatic variables and arguments
1764    to be in terms of two different offsets from the virtual frame pointer,
1765    which is the stack pointer before any adjustment in the function.
1766    The offset for the argument pointer is fixed for the native compiler,
1767    it is either zero (for the no arguments case) or large enough to hold
1768    all argument registers.
1769    The offset for the auto pointer is the fourth argument to the .frame
1770    directive (local_offset).
1771    To stay compatible with the native tools we use the same offsets
1772    from the virtual frame pointer and adjust the debugger arg/auto offsets
1773    accordingly. These debugger offsets are set up in output_prolog.  */
1774
1775 extern long alpha_arg_offset;
1776 extern long alpha_auto_offset;
1777 #define DEBUGGER_AUTO_OFFSET(X) \
1778   ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) + alpha_auto_offset)
1779 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + alpha_arg_offset)
1780
1781
1782 #define ASM_OUTPUT_SOURCE_LINE(STREAM, LINE)                            \
1783   alpha_output_lineno (STREAM, LINE)
1784
1785 #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME)                        \
1786   alpha_output_filename (STREAM, NAME)
1787
1788 /* mips-tfile.c limits us to strings of one page.  We must underestimate this
1789    number, because the real length runs past this up to the next
1790    continuation point.  This is really a dbxout.c bug.  */
1791 #define DBX_CONTIN_LENGTH 3000
1792
1793 /* By default, turn on GDB extensions.  */
1794 #define DEFAULT_GDB_EXTENSIONS 1
1795
1796 /* Stabs-in-ECOFF can't handle dbxout_function_end().  */
1797 #define NO_DBX_FUNCTION_END 1
1798
1799 /* If we are smuggling stabs through the ALPHA ECOFF object
1800    format, put a comment in front of the .stab<x> operation so
1801    that the ALPHA assembler does not choke.  The mips-tfile program
1802    will correctly put the stab into the object file.  */
1803
1804 #define ASM_STABS_OP    ((TARGET_GAS) ? "\t.stabs\t" : " #.stabs\t")
1805 #define ASM_STABN_OP    ((TARGET_GAS) ? "\t.stabn\t" : " #.stabn\t")
1806 #define ASM_STABD_OP    ((TARGET_GAS) ? "\t.stabd\t" : " #.stabd\t")
1807
1808 /* Forward references to tags are allowed.  */
1809 #define SDB_ALLOW_FORWARD_REFERENCES
1810
1811 /* Unknown tags are also allowed.  */
1812 #define SDB_ALLOW_UNKNOWN_REFERENCES
1813
1814 #define PUT_SDB_DEF(a)                                  \
1815 do {                                                    \
1816   fprintf (asm_out_file, "\t%s.def\t",                  \
1817            (TARGET_GAS) ? "" : "#");                    \
1818   ASM_OUTPUT_LABELREF (asm_out_file, a);                \
1819   fputc (';', asm_out_file);                            \
1820 } while (0)
1821
1822 #define PUT_SDB_PLAIN_DEF(a)                            \
1823 do {                                                    \
1824   fprintf (asm_out_file, "\t%s.def\t.%s;",              \
1825            (TARGET_GAS) ? "" : "#", (a));               \
1826 } while (0)
1827
1828 #define PUT_SDB_TYPE(a)                                 \
1829 do {                                                    \
1830   fprintf (asm_out_file, "\t.type\t0x%x;", (a));        \
1831 } while (0)
1832
1833 /* For block start and end, we create labels, so that
1834    later we can figure out where the correct offset is.
1835    The normal .ent/.end serve well enough for functions,
1836    so those are just commented out.  */
1837
1838 extern int sdb_label_count;             /* block start/end next label # */
1839
1840 #define PUT_SDB_BLOCK_START(LINE)                       \
1841 do {                                                    \
1842   fprintf (asm_out_file,                                \
1843            "$Lb%d:\n\t%s.begin\t$Lb%d\t%d\n",           \
1844            sdb_label_count,                             \
1845            (TARGET_GAS) ? "" : "#",                     \
1846            sdb_label_count,                             \
1847            (LINE));                                     \
1848   sdb_label_count++;                                    \
1849 } while (0)
1850
1851 #define PUT_SDB_BLOCK_END(LINE)                         \
1852 do {                                                    \
1853   fprintf (asm_out_file,                                \
1854            "$Le%d:\n\t%s.bend\t$Le%d\t%d\n",            \
1855            sdb_label_count,                             \
1856            (TARGET_GAS) ? "" : "#",                     \
1857            sdb_label_count,                             \
1858            (LINE));                                     \
1859   sdb_label_count++;                                    \
1860 } while (0)
1861
1862 #define PUT_SDB_FUNCTION_START(LINE)
1863
1864 #define PUT_SDB_FUNCTION_END(LINE)
1865
1866 #define PUT_SDB_EPILOGUE_END(NAME) ((void)(NAME))
1867
1868 /* Macros for mips-tfile.c to encapsulate stabs in ECOFF, and for
1869    mips-tdump.c to print them out.
1870
1871    These must match the corresponding definitions in gdb/mipsread.c.
1872    Unfortunately, gcc and gdb do not currently share any directories.  */
1873
1874 #define CODE_MASK 0x8F300
1875 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
1876 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
1877 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
1878
1879 /* Override some mips-tfile definitions.  */
1880
1881 #define SHASH_SIZE 511
1882 #define THASH_SIZE 55
1883
1884 /* Align ecoff symbol tables to avoid OSF1/1.3 nm complaints.  */
1885
1886 #define ALIGN_SYMTABLE_OFFSET(OFFSET) (((OFFSET) + 7) & ~7)
1887
1888 /* The system headers under Alpha systems are generally C++-aware.  */
1889 #define NO_IMPLICIT_EXTERN_C
1890
1891 /* Generate calls to memcpy, etc., not bcopy, etc.  */
1892 #define TARGET_MEM_FUNCTIONS 1