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