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