OSDN Git Service

739a177cb0b697f01b342bbdcda36b7ee3222f07
[pf3gnuchains/gcc-fork.git] / 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 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
24 /* For C++ we need to ensure that __LANGUAGE_C_PLUS_PLUS is defined independent
25    of the source file extension.  */
26 #define CPLUSPLUS_CPP_SPEC "\
27 -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS -D__cplusplus \
28 %(cpp) \
29 "
30
31 /* Write out the correct language type definition for the header files.  
32    Unless we have assembler language, write out the symbols for C.  */
33 #define CPP_SPEC "\
34 %{!undef:\
35 %{.S:-D__LANGUAGE_ASSEMBLY__ -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY }}\
36 %{.m:-D__LANGUAGE_OBJECTIVE_C__ -D__LANGUAGE_OBJECTIVE_C }\
37 %{!.S:%{!.cc:%{!.cxx:%{!.cpp:%{!.cp:%{!.c++:%{!.C:%{!.m:-D__LANGUAGE_C__ -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C }}}}}}}}}\
38 %{mieee:-D_IEEE_FP }\
39 %{mieee-with-inexact:-D_IEEE_FP -D_IEEE_FP_INEXACT }}\
40 %(cpp_cpu) %(cpp_subtarget)"
41
42 #ifndef CPP_SUBTARGET_SPEC
43 #define CPP_SUBTARGET_SPEC ""
44 #endif
45
46 /* Set the spec to use for signed char.  The default tests the above macro
47    but DEC's compiler can't handle the conditional in a "constant"
48    operand.  */
49
50 #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}"
51
52 #define WORD_SWITCH_TAKES_ARG(STR)              \
53  (!strcmp (STR, "rpath") || DEFAULT_WORD_SWITCH_TAKES_ARG(STR))
54
55 /* Print subsidiary information on the compiler version in use.  */
56 #define TARGET_VERSION
57
58 /* Run-time compilation parameters selecting different hardware subsets.  */
59
60 /* Which processor to schedule for. The cpu attribute defines a list that
61    mirrors this list, so changes to alpha.md must be made at the same time.  */
62
63 enum processor_type
64  {PROCESSOR_EV4,                        /* 2106[46]{a,} */
65   PROCESSOR_EV5,                        /* 21164{a,pc,} */
66   PROCESSOR_EV6};                       /* 21264 */
67
68 extern enum processor_type alpha_cpu;
69
70 enum alpha_trap_precision
71 {
72   ALPHA_TP_PROG,        /* No precision (default).  */
73   ALPHA_TP_FUNC,        /* Trap contained within originating function.  */
74   ALPHA_TP_INSN         /* Instruction accuracy and code is resumption safe. */
75 };
76
77 enum alpha_fp_rounding_mode
78 {
79   ALPHA_FPRM_NORM,      /* Normal rounding mode.  */
80   ALPHA_FPRM_MINF,      /* Round towards minus-infinity.  */
81   ALPHA_FPRM_CHOP,      /* Chopped rounding mode (towards 0). */
82   ALPHA_FPRM_DYN        /* Dynamic rounding mode.  */
83 };
84
85 enum alpha_fp_trap_mode
86 {
87   ALPHA_FPTM_N,         /* Normal trap mode. */
88   ALPHA_FPTM_U,         /* Underflow traps enabled.  */
89   ALPHA_FPTM_SU,        /* Software completion, w/underflow traps */
90   ALPHA_FPTM_SUI        /* Software completion, w/underflow & inexact traps */
91 };
92
93 extern int target_flags;
94
95 extern enum alpha_trap_precision alpha_tp;
96 extern enum alpha_fp_rounding_mode alpha_fprm;
97 extern enum alpha_fp_trap_mode alpha_fptm;
98
99 /* This means that floating-point support exists in the target implementation
100    of the Alpha architecture.  This is usually the default.  */
101 #define MASK_FP         (1 << 0)
102 #define TARGET_FP       (target_flags & MASK_FP)
103
104 /* This means that floating-point registers are allowed to be used.  Note
105    that Alpha implementations without FP operations are required to
106    provide the FP registers.  */
107
108 #define MASK_FPREGS     (1 << 1)
109 #define TARGET_FPREGS   (target_flags & MASK_FPREGS)
110
111 /* This means that gas is used to process the assembler file.  */
112
113 #define MASK_GAS        (1 << 2)
114 #define TARGET_GAS      (target_flags & MASK_GAS)
115
116 /* This means that we should mark procedures as IEEE conformant. */
117
118 #define MASK_IEEE_CONFORMANT (1 << 3)
119 #define TARGET_IEEE_CONFORMANT  (target_flags & MASK_IEEE_CONFORMANT)
120
121 /* This means we should be IEEE-compliant except for inexact.  */
122
123 #define MASK_IEEE       (1 << 4)
124 #define TARGET_IEEE     (target_flags & MASK_IEEE)
125
126 /* This means we should be fully IEEE-compliant.  */
127
128 #define MASK_IEEE_WITH_INEXACT (1 << 5)
129 #define TARGET_IEEE_WITH_INEXACT (target_flags & MASK_IEEE_WITH_INEXACT)
130
131 /* This means we must construct all constants rather than emitting
132    them as literal data.  */
133
134 #define MASK_BUILD_CONSTANTS (1 << 6)
135 #define TARGET_BUILD_CONSTANTS (target_flags & MASK_BUILD_CONSTANTS)
136
137 /* This means we handle floating points in VAX F- (float)
138    or G- (double) Format.  */
139
140 #define MASK_FLOAT_VAX  (1 << 7)
141 #define TARGET_FLOAT_VAX (target_flags & MASK_FLOAT_VAX)
142
143 /* This means that the processor has byte and half word loads and stores
144    (the BWX extension).  */
145
146 #define MASK_BWX        (1 << 8)
147 #define TARGET_BWX      (target_flags & MASK_BWX)
148
149 /* This means that the processor has the MAX extension.  */
150 #define MASK_MAX        (1 << 9)
151 #define TARGET_MAX      (target_flags & MASK_MAX)
152
153 /* This means that the processor has the FIX extension.  */
154 #define MASK_FIX        (1 << 10)
155 #define TARGET_FIX      (target_flags & MASK_FIX)
156
157 /* This means that the processor has the CIX extension.  */
158 #define MASK_CIX        (1 << 11)
159 #define TARGET_CIX      (target_flags & MASK_CIX)
160
161 /* This means that the processor is an EV5, EV56, or PCA56.
162    Unlike alpha_cpu this is not affected by -mtune= setting.  */
163 #define MASK_CPU_EV5    (1 << 28)
164 #define TARGET_CPU_EV5  (target_flags & MASK_CPU_EV5)
165
166 /* Likewise for EV6.  */
167 #define MASK_CPU_EV6    (1 << 29)
168 #define TARGET_CPU_EV6  (target_flags & MASK_CPU_EV6)
169
170 /* This means we support the .arch directive in the assembler.  Only
171    defined in TARGET_CPU_DEFAULT.  */
172 #define MASK_SUPPORT_ARCH (1 << 30)
173 #define TARGET_SUPPORT_ARCH     (target_flags & MASK_SUPPORT_ARCH)
174
175 /* These are for target os support and cannot be changed at runtime.  */
176 #ifndef TARGET_WINDOWS_NT
177 #define TARGET_WINDOWS_NT 0
178 #endif
179 #ifndef TARGET_OPEN_VMS
180 #define TARGET_OPEN_VMS 0
181 #endif
182
183 #ifndef TARGET_AS_CAN_SUBTRACT_LABELS
184 #define TARGET_AS_CAN_SUBTRACT_LABELS TARGET_GAS
185 #endif
186 #ifndef TARGET_CAN_FAULT_IN_PROLOGUE
187 #define TARGET_CAN_FAULT_IN_PROLOGUE 0
188 #endif
189 #ifndef TARGET_HAS_XFLOATING_LIBS
190 #define TARGET_HAS_XFLOATING_LIBS 0
191 #endif
192 #ifndef TARGET_PROFILING_NEEDS_GP
193 #define TARGET_PROFILING_NEEDS_GP 0
194 #endif
195 #ifndef TARGET_LD_BUGGY_LDGP
196 #define TARGET_LD_BUGGY_LDGP 0
197 #endif
198
199 /* Macro to define tables used to set the flags.
200    This is a list in braces of pairs in braces,
201    each pair being { "NAME", VALUE }
202    where VALUE is the bits to set or minus the bits to clear.
203    An empty string NAME is used to identify the default VALUE.  */
204
205 #define TARGET_SWITCHES                                                 \
206   { {"no-soft-float", MASK_FP, N_("Use hardware fp")},                  \
207     {"soft-float", - MASK_FP, N_("Do not use hardware fp")},            \
208     {"fp-regs", MASK_FPREGS, N_("Use fp registers")},                   \
209     {"no-fp-regs", - (MASK_FP|MASK_FPREGS),                             \
210      N_("Do not use fp registers")},                                    \
211     {"alpha-as", -MASK_GAS, N_("Do not assume GAS")},                   \
212     {"gas", MASK_GAS, N_("Assume GAS")},                                \
213     {"ieee-conformant", MASK_IEEE_CONFORMANT,                           \
214      N_("Request IEEE-conformant math library routines (OSF/1)")},      \
215     {"ieee", MASK_IEEE|MASK_IEEE_CONFORMANT,                            \
216      N_("Emit IEEE-conformant code, without inexact exceptions")},      \
217     {"ieee-with-inexact", MASK_IEEE_WITH_INEXACT|MASK_IEEE_CONFORMANT,  \
218      N_("Emit IEEE-conformant code, with inexact exceptions")},         \
219     {"build-constants", MASK_BUILD_CONSTANTS,                           \
220      N_("Do not emit complex integer constants to read-only memory")},  \
221     {"float-vax", MASK_FLOAT_VAX, N_("Use VAX fp")},                    \
222     {"float-ieee", -MASK_FLOAT_VAX, N_("Do not use VAX fp")},           \
223     {"bwx", MASK_BWX, N_("Emit code for the byte/word ISA extension")}, \
224     {"no-bwx", -MASK_BWX, ""},                                          \
225     {"max", MASK_MAX,                                                   \
226      N_("Emit code for the motion video ISA extension")},               \
227     {"no-max", -MASK_MAX, ""},                                          \
228     {"fix", MASK_FIX,                                                   \
229      N_("Emit code for the fp move and sqrt ISA extension")},           \
230     {"no-fix", -MASK_FIX, ""},                                          \
231     {"cix", MASK_CIX, N_("Emit code for the counting ISA extension")},  \
232     {"no-cix", -MASK_CIX, ""},                                          \
233     {"", TARGET_DEFAULT | TARGET_CPU_DEFAULT, ""} }
234
235 #define TARGET_DEFAULT MASK_FP|MASK_FPREGS
236
237 #ifndef TARGET_CPU_DEFAULT
238 #define TARGET_CPU_DEFAULT 0
239 #endif
240
241 /* This macro is similar to `TARGET_SWITCHES' but defines names of
242    command options that have values.  Its definition is an initializer
243    with a subgrouping for each command option.
244
245    Each subgrouping contains a string constant, that defines the fixed
246    part of the option name, and the address of a variable.  The
247    variable, type `char *', is set to the variable part of the given
248    option if the fixed part matches.  The actual option name is made
249    by appending `-m' to the specified name.
250
251    Here is an example which defines `-mshort-data-NUMBER'.  If the
252    given option is `-mshort-data-512', the variable `m88k_short_data'
253    will be set to the string `"512"'.
254
255         extern char *m88k_short_data;
256         #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }  */
257
258 extern const char *alpha_cpu_string;    /* For -mcpu= */
259 extern const char *alpha_tune_string;   /* For -mtune= */
260 extern const char *alpha_fprm_string;   /* For -mfp-rounding-mode=[n|m|c|d] */
261 extern const char *alpha_fptm_string;   /* For -mfp-trap-mode=[n|u|su|sui]  */
262 extern const char *alpha_tp_string;     /* For -mtrap-precision=[p|f|i] */
263 extern const char *alpha_mlat_string;   /* For -mmemory-latency= */
264
265 #define TARGET_OPTIONS                                  \
266 {                                                       \
267   {"cpu=",              &alpha_cpu_string,              \
268    N_("Use features of and schedule given CPU")},       \
269   {"tune=",             &alpha_tune_string,             \
270    N_("Schedule given CPU")},                           \
271   {"fp-rounding-mode=", &alpha_fprm_string,             \
272    N_("Control the generated fp rounding mode")},       \
273   {"fp-trap-mode=",     &alpha_fptm_string,             \
274    N_("Control the IEEE trap mode")},                   \
275   {"trap-precision=",   &alpha_tp_string,               \
276    N_("Control the precision given to fp exceptions")}, \
277   {"memory-latency=",   &alpha_mlat_string,             \
278    N_("Tune expected memory latency")},                 \
279 }
280
281 /* Attempt to describe CPU characteristics to the preprocessor.  */
282
283 /* Corresponding to amask... */
284 #define CPP_AM_BWX_SPEC "-D__alpha_bwx__ -Acpu=bwx"
285 #define CPP_AM_MAX_SPEC "-D__alpha_max__ -Acpu=max"
286 #define CPP_AM_FIX_SPEC "-D__alpha_fix__ -Acpu=fix"
287 #define CPP_AM_CIX_SPEC "-D__alpha_cix__ -Acpu=cix"
288
289 /* Corresponding to implver... */
290 #define CPP_IM_EV4_SPEC "-D__alpha_ev4__ -Acpu=ev4"
291 #define CPP_IM_EV5_SPEC "-D__alpha_ev5__ -Acpu=ev5"
292 #define CPP_IM_EV6_SPEC "-D__alpha_ev6__ -Acpu=ev6"
293
294 /* Common combinations.  */
295 #define CPP_CPU_EV4_SPEC        "%(cpp_im_ev4)"
296 #define CPP_CPU_EV5_SPEC        "%(cpp_im_ev5)"
297 #define CPP_CPU_EV56_SPEC       "%(cpp_im_ev5) %(cpp_am_bwx)"
298 #define CPP_CPU_PCA56_SPEC      "%(cpp_im_ev5) %(cpp_am_bwx) %(cpp_am_max)"
299 #define CPP_CPU_EV6_SPEC \
300   "%(cpp_im_ev6) %(cpp_am_bwx) %(cpp_am_max) %(cpp_am_fix)"
301 #define CPP_CPU_EV67_SPEC \
302   "%(cpp_im_ev6) %(cpp_am_bwx) %(cpp_am_max) %(cpp_am_fix) %(cpp_am_cix)"
303
304 #ifndef CPP_CPU_DEFAULT_SPEC
305 # if TARGET_CPU_DEFAULT & MASK_CPU_EV6
306 #  if TARGET_CPU_DEFAULT & MASK_CIX
307 #    define CPP_CPU_DEFAULT_SPEC        CPP_CPU_EV67_SPEC
308 #  else
309 #    define CPP_CPU_DEFAULT_SPEC        CPP_CPU_EV6_SPEC
310 #  endif
311 # else
312 #  if TARGET_CPU_DEFAULT & MASK_CPU_EV5
313 #   if TARGET_CPU_DEFAULT & MASK_MAX
314 #    define CPP_CPU_DEFAULT_SPEC        CPP_CPU_PCA56_SPEC
315 #   else
316 #    if TARGET_CPU_DEFAULT & MASK_BWX
317 #     define CPP_CPU_DEFAULT_SPEC       CPP_CPU_EV56_SPEC
318 #    else
319 #     define CPP_CPU_DEFAULT_SPEC       CPP_CPU_EV5_SPEC
320 #    endif
321 #   endif
322 #  else
323 #   define CPP_CPU_DEFAULT_SPEC         CPP_CPU_EV4_SPEC
324 #  endif
325 # endif
326 #endif /* CPP_CPU_DEFAULT_SPEC */
327
328 #ifndef CPP_CPU_SPEC
329 #define CPP_CPU_SPEC "\
330 %{!undef:-Acpu=alpha -Amachine=alpha -D__alpha -D__alpha__ \
331 %{mcpu=ev4|mcpu=21064:%(cpp_cpu_ev4) }\
332 %{mcpu=ev5|mcpu=21164:%(cpp_cpu_ev5) }\
333 %{mcpu=ev56|mcpu=21164a:%(cpp_cpu_ev56) }\
334 %{mcpu=pca56|mcpu=21164pc|mcpu=21164PC:%(cpp_cpu_pca56) }\
335 %{mcpu=ev6|mcpu=21264:%(cpp_cpu_ev6) }\
336 %{mcpu=ev67|mcpu=21264a:%(cpp_cpu_ev67) }\
337 %{!mcpu*:%(cpp_cpu_default) }}"
338 #endif
339
340 /* This macro defines names of additional specifications to put in the
341    specs that can be used in various specifications like CC1_SPEC.  Its
342    definition is an initializer with a subgrouping for each command option.
343
344    Each subgrouping contains a string constant, that defines the
345    specification name, and a string constant that used by the GNU CC driver
346    program.
347
348    Do not define this macro if it does not need to do anything.  */
349
350 #ifndef SUBTARGET_EXTRA_SPECS
351 #define SUBTARGET_EXTRA_SPECS
352 #endif
353
354 #define EXTRA_SPECS                             \
355   { "cpp_am_bwx", CPP_AM_BWX_SPEC },            \
356   { "cpp_am_max", CPP_AM_MAX_SPEC },            \
357   { "cpp_am_fix", CPP_AM_FIX_SPEC },            \
358   { "cpp_am_cix", CPP_AM_CIX_SPEC },            \
359   { "cpp_im_ev4", CPP_IM_EV4_SPEC },            \
360   { "cpp_im_ev5", CPP_IM_EV5_SPEC },            \
361   { "cpp_im_ev6", CPP_IM_EV6_SPEC },            \
362   { "cpp_cpu_ev4", CPP_CPU_EV4_SPEC },          \
363   { "cpp_cpu_ev5", CPP_CPU_EV5_SPEC },          \
364   { "cpp_cpu_ev56", CPP_CPU_EV56_SPEC },        \
365   { "cpp_cpu_pca56", CPP_CPU_PCA56_SPEC },      \
366   { "cpp_cpu_ev6", CPP_CPU_EV6_SPEC },          \
367   { "cpp_cpu_ev67", CPP_CPU_EV67_SPEC },        \
368   { "cpp_cpu_default", CPP_CPU_DEFAULT_SPEC },  \
369   { "cpp_cpu", CPP_CPU_SPEC },                  \
370   { "cpp_subtarget", CPP_SUBTARGET_SPEC },      \
371   SUBTARGET_EXTRA_SPECS
372
373
374 /* Sometimes certain combinations of command options do not make sense
375    on a particular target machine.  You can define a macro
376    `OVERRIDE_OPTIONS' to take account of this.  This macro, if
377    defined, is executed once just after all the command options have
378    been parsed.
379
380    On the Alpha, it is used to translate target-option strings into
381    numeric values.  */
382
383 #define OVERRIDE_OPTIONS override_options ()
384
385
386 /* Define this macro to change register usage conditional on target flags.
387
388    On the Alpha, we use this to disable the floating-point registers when
389    they don't exist.  */
390
391 #define CONDITIONAL_REGISTER_USAGE      \
392   if (! TARGET_FPREGS)                  \
393     for (i = 32; i < 63; i++)           \
394       fixed_regs[i] = call_used_regs[i] = 1;
395
396 /* Show we can debug even without a frame pointer.  */
397 #define CAN_DEBUG_WITHOUT_FP
398 \f
399 /* target machine storage layout */
400
401 /* Define to enable software floating point emulation. */
402 #define REAL_ARITHMETIC
403
404 /* Define the size of `int'.  The default is the same as the word size.  */
405 #define INT_TYPE_SIZE 32
406
407 /* Define the size of `long long'.  The default is the twice the word size.  */
408 #define LONG_LONG_TYPE_SIZE 64
409
410 /* The two floating-point formats we support are S-floating, which is
411    4 bytes, and T-floating, which is 8 bytes.  `float' is S and `double'
412    and `long double' are T.  */
413
414 #define FLOAT_TYPE_SIZE 32
415 #define DOUBLE_TYPE_SIZE 64
416 #define LONG_DOUBLE_TYPE_SIZE 64
417
418 #define WCHAR_TYPE "unsigned int"
419 #define WCHAR_TYPE_SIZE 32
420
421 /* Define this macro if it is advisable to hold scalars in registers
422    in a wider mode than that declared by the program.  In such cases, 
423    the value is constrained to be within the bounds of the declared
424    type, but kept valid in the wider mode.  The signedness of the
425    extension may differ from that of the type.
426
427    For Alpha, we always store objects in a full register.  32-bit objects
428    are always sign-extended, but smaller objects retain their signedness.  */
429
430 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \
431   if (GET_MODE_CLASS (MODE) == MODE_INT         \
432       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
433     {                                           \
434       if ((MODE) == SImode)                     \
435         (UNSIGNEDP) = 0;                        \
436       (MODE) = DImode;                          \
437     }
438
439 /* Define this if function arguments should also be promoted using the above
440    procedure.  */
441
442 #define PROMOTE_FUNCTION_ARGS
443
444 /* Likewise, if the function return value is promoted.  */
445
446 #define PROMOTE_FUNCTION_RETURN
447
448 /* Define this if most significant bit is lowest numbered
449    in instructions that operate on numbered bit-fields.
450
451    There are no such instructions on the Alpha, but the documentation
452    is little endian.  */
453 #define BITS_BIG_ENDIAN 0
454
455 /* Define this if most significant byte of a word is the lowest numbered.
456    This is false on the Alpha.  */
457 #define BYTES_BIG_ENDIAN 0
458
459 /* Define this if most significant word of a multiword number is lowest
460    numbered.
461
462    For Alpha we can decide arbitrarily since there are no machine instructions
463    for them.  Might as well be consistent with bytes. */
464 #define WORDS_BIG_ENDIAN 0
465
466 /* number of bits in an addressable storage unit */
467 #define BITS_PER_UNIT 8
468
469 /* Width in bits of a "word", which is the contents of a machine register.
470    Note that this is not necessarily the width of data type `int';
471    if using 16-bit ints on a 68000, this would still be 32.
472    But on a machine with 16-bit registers, this would be 16.  */
473 #define BITS_PER_WORD 64
474
475 /* Width of a word, in units (bytes).  */
476 #define UNITS_PER_WORD 8
477
478 /* Width in bits of a pointer.
479    See also the macro `Pmode' defined below.  */
480 #define POINTER_SIZE 64
481
482 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
483 #define PARM_BOUNDARY 64
484
485 /* Boundary (in *bits*) on which stack pointer should be aligned.  */
486 #define STACK_BOUNDARY 64
487
488 /* Allocation boundary (in *bits*) for the code of a function.  */
489 #define FUNCTION_BOUNDARY 32
490
491 /* Alignment of field after `int : 0' in a structure.  */
492 #define EMPTY_FIELD_BOUNDARY 64
493
494 /* Every structure's size must be a multiple of this.  */
495 #define STRUCTURE_SIZE_BOUNDARY 8
496
497 /* A bitfield declared as `int' forces `int' alignment for the struct.  */
498 #define PCC_BITFIELD_TYPE_MATTERS 1
499
500 /* No data type wants to be aligned rounder than this.  */
501 #define BIGGEST_ALIGNMENT 128
502
503 /* For atomic access to objects, must have at least 32-bit alignment
504    unless the machine has byte operations.  */
505 #define MINIMUM_ATOMIC_ALIGNMENT ((unsigned int) (TARGET_BWX ? 8 : 32))
506
507 /* Align all constants and variables to at least a word boundary so
508    we can pick up pieces of them faster.  */
509 /* ??? Only if block-move stuff knows about different source/destination
510    alignment.  */
511 #if 0
512 #define CONSTANT_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
513 #define DATA_ALIGNMENT(EXP, ALIGN) MAX ((ALIGN), BITS_PER_WORD)
514 #endif
515
516 /* Set this non-zero if move instructions will actually fail to work
517    when given unaligned data.
518
519    Since we get an error message when we do one, call them invalid.  */
520
521 #define STRICT_ALIGNMENT 1
522
523 /* Set this non-zero if unaligned move instructions are extremely slow.
524
525    On the Alpha, they trap.  */
526
527 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) 1
528 \f
529 /* Standard register usage.  */
530
531 /* Number of actual hardware registers.
532    The hardware registers are assigned numbers for the compiler
533    from 0 to just below FIRST_PSEUDO_REGISTER.
534    All registers that the compiler knows about must be given numbers,
535    even those that are not normally considered general registers.
536
537    We define all 32 integer registers, even though $31 is always zero,
538    and all 32 floating-point registers, even though $f31 is also
539    always zero.  We do not bother defining the FP status register and
540    there are no other registers. 
541
542    Since $31 is always zero, we will use register number 31 as the
543    argument pointer.  It will never appear in the generated code
544    because we will always be eliminating it in favor of the stack
545    pointer or hardware frame pointer.
546
547    Likewise, we use $f31 for the frame pointer, which will always
548    be eliminated in favor of the hardware frame pointer or the
549    stack pointer.  */
550
551 #define FIRST_PSEUDO_REGISTER 64
552
553 /* 1 for registers that have pervasive standard uses
554    and are not available for the register allocator.  */
555
556 #define FIXED_REGISTERS  \
557  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
558   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, \
559   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
560   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }
561
562 /* 1 for registers not available across function calls.
563    These must include the FIXED_REGISTERS and also any
564    registers that can be used without being saved.
565    The latter must include the registers where values are returned
566    and the register where structure-value addresses are passed.
567    Aside from that, you can include as many other registers as you like.  */
568 #define CALL_USED_REGISTERS  \
569  {1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, \
570   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, \
571   1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, \
572   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
573
574 /* List the order in which to allocate registers.  Each register must be
575    listed once, even those in FIXED_REGISTERS.
576
577    We allocate in the following order:
578    $f10-$f15            (nonsaved floating-point register)
579    $f22-$f30            (likewise)
580    $f21-$f16            (likewise, but input args)
581    $f0                  (nonsaved, but return value)
582    $f1                  (nonsaved, but immediate before saved)
583    $f2-$f9              (saved floating-point registers)
584    $1-$8                (nonsaved integer registers)
585    $22-$25              (likewise)
586    $28                  (likewise)
587    $0                   (likewise, but return value)
588    $21-$16              (likewise, but input args)
589    $27                  (procedure value in OSF, nonsaved in NT)
590    $9-$14               (saved integer registers)
591    $26                  (return PC)
592    $15                  (frame pointer)
593    $29                  (global pointer)
594    $30, $31, $f31       (stack pointer and always zero/ap & fp)  */
595
596 #define REG_ALLOC_ORDER         \
597   {42, 43, 44, 45, 46, 47,              \
598    54, 55, 56, 57, 58, 59, 60, 61, 62,  \
599    53, 52, 51, 50, 49, 48,              \
600    32, 33,                              \
601    34, 35, 36, 37, 38, 39, 40, 41,      \
602    1, 2, 3, 4, 5, 6, 7, 8,              \
603    22, 23, 24, 25,                      \
604    28,                                  \
605    0,                                   \
606    21, 20, 19, 18, 17, 16,              \
607    27,                                  \
608    9, 10, 11, 12, 13, 14,               \
609    26,                                  \
610    15,                                  \
611    29,                                  \
612    30, 31, 63 }
613
614 /* Return number of consecutive hard regs needed starting at reg REGNO
615    to hold something of mode MODE.
616    This is ordinarily the length in words of a value of mode MODE
617    but can be less for certain modes in special long registers.  */
618
619 #define HARD_REGNO_NREGS(REGNO, MODE)   \
620   ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
621
622 /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
623    On Alpha, the integer registers can hold any mode.  The floating-point
624    registers can hold 32-bit and 64-bit integers as well, but not 16-bit
625    or 8-bit values.  */
626
627 #define HARD_REGNO_MODE_OK(REGNO, MODE)                                 \
628   ((REGNO) >= 32 && (REGNO) <= 62                                       \
629    ? GET_MODE_UNIT_SIZE (MODE) == 8 || GET_MODE_UNIT_SIZE (MODE) == 4   \
630    : 1)
631
632 /* A C expression that is nonzero if a value of mode
633    MODE1 is accessible in mode MODE2 without copying.
634
635    This asymmetric test is true when MODE1 could be put
636    in an FP register but MODE2 could not.  */
637
638 #define MODES_TIEABLE_P(MODE1, MODE2)                           \
639   (HARD_REGNO_MODE_OK (32, (MODE1))                             \
640    ? HARD_REGNO_MODE_OK (32, (MODE2))                           \
641    : 1)
642
643 /* Specify the registers used for certain standard purposes.
644    The values of these macros are register numbers.  */
645
646 /* Alpha pc isn't overloaded on a register that the compiler knows about.  */
647 /* #define PC_REGNUM  */
648
649 /* Register to use for pushing function arguments.  */
650 #define STACK_POINTER_REGNUM 30
651
652 /* Base register for access to local variables of the function.  */
653 #define HARD_FRAME_POINTER_REGNUM 15
654
655 /* Value should be nonzero if functions must have frame pointers.
656    Zero means the frame pointer need not be set up (and parms
657    may be accessed via the stack pointer) in functions that seem suitable.
658    This is computed in `reload', in reload1.c.  */
659 #define FRAME_POINTER_REQUIRED 0
660
661 /* Base register for access to arguments of the function.  */
662 #define ARG_POINTER_REGNUM 31
663
664 /* Base register for access to local variables of function.  */
665 #define FRAME_POINTER_REGNUM 63
666
667 /* Register in which static-chain is passed to a function. 
668
669    For the Alpha, this is based on an example; the calling sequence
670    doesn't seem to specify this.  */
671 #define STATIC_CHAIN_REGNUM 1
672
673 /* Register in which address to store a structure value
674    arrives in the function.  On the Alpha, the address is passed
675    as a hidden argument.  */
676 #define STRUCT_VALUE 0
677 \f
678 /* Define the classes of registers for register constraints in the
679    machine description.  Also define ranges of constants.
680
681    One of the classes must always be named ALL_REGS and include all hard regs.
682    If there is more than one class, another class must be named NO_REGS
683    and contain no registers.
684
685    The name GENERAL_REGS must be the name of a class (or an alias for
686    another name such as ALL_REGS).  This is the class of registers
687    that is allowed by "g" or "r" in a register constraint.
688    Also, registers outside this class are allocated only when
689    instructions express preferences for them.
690
691    The classes must be numbered in nondecreasing order; that is,
692    a larger-numbered class must never be contained completely
693    in a smaller-numbered class.
694
695    For any two classes, it is very desirable that there be another
696    class that represents their union.  */
697    
698 enum reg_class { NO_REGS, PV_REG, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
699                  LIM_REG_CLASSES };
700
701 #define N_REG_CLASSES (int) LIM_REG_CLASSES
702
703 /* Give names of register classes as strings for dump file.   */
704
705 #define REG_CLASS_NAMES                         \
706  {"NO_REGS", "PV_REG", "GENERAL_REGS", "FLOAT_REGS", "ALL_REGS" }
707
708 /* Define which registers fit in which classes.
709    This is an initializer for a vector of HARD_REG_SET
710    of length N_REG_CLASSES.  */
711
712 #define REG_CLASS_CONTENTS      \
713   { {0, 0}, {0x08000000, 0}, {~0, 0x80000000}, {0, 0x7fffffff}, {~0, ~0} }
714
715 /* The same information, inverted:
716    Return the class number of the smallest class containing
717    reg number REGNO.  This could be a conditional expression
718    or could index an array.  */
719
720 #define REGNO_REG_CLASS(REGNO)                  \
721  ((REGNO) == 27 ? PV_REG                        \
722   : (REGNO) >= 32 && (REGNO) <= 62 ? FLOAT_REGS \
723   : GENERAL_REGS)
724
725 /* The class value for index registers, and the one for base regs.  */
726 #define INDEX_REG_CLASS NO_REGS
727 #define BASE_REG_CLASS GENERAL_REGS
728
729 /* Get reg_class from a letter such as appears in the machine description.  */
730
731 #define REG_CLASS_FROM_LETTER(C)        \
732  ((C) == 'c' ? PV_REG : (C) == 'f' ? FLOAT_REGS : NO_REGS)
733
734 /* Define this macro to change register usage conditional on target flags.  */
735 /* #define CONDITIONAL_REGISTER_USAGE  */
736
737 /* The letters I, J, K, L, M, N, O, and P in a register constraint string
738    can be used to stand for particular ranges of immediate operands.
739    This macro defines what the ranges are.
740    C is the letter, and VALUE is a constant value.
741    Return 1 if VALUE is in the range specified by C.
742
743    For Alpha:
744    `I' is used for the range of constants most insns can contain.
745    `J' is the constant zero.
746    `K' is used for the constant in an LDA insn.
747    `L' is used for the constant in a LDAH insn.
748    `M' is used for the constants that can be AND'ed with using a ZAP insn.
749    `N' is used for complemented 8-bit constants.
750    `O' is used for negated 8-bit constants.
751    `P' is used for the constants 1, 2 and 3.  */
752
753 #define CONST_OK_FOR_LETTER_P(VALUE, C)                         \
754   ((C) == 'I' ? (unsigned HOST_WIDE_INT) (VALUE) < 0x100        \
755    : (C) == 'J' ? (VALUE) == 0                                  \
756    : (C) == 'K' ? (unsigned HOST_WIDE_INT) ((VALUE) + 0x8000) < 0x10000 \
757    : (C) == 'L' ? (((VALUE) & 0xffff) == 0                      \
758                   && (((VALUE)) >> 31 == -1 || (VALUE) >> 31 == 0)) \
759    : (C) == 'M' ? zap_mask (VALUE)                              \
760    : (C) == 'N' ? (unsigned HOST_WIDE_INT) (~ (VALUE)) < 0x100  \
761    : (C) == 'O' ? (unsigned HOST_WIDE_INT) (- (VALUE)) < 0x100  \
762    : (C) == 'P' ? (VALUE) == 1 || (VALUE) == 2 || (VALUE) == 3  \
763    : 0)
764
765 /* Similar, but for floating or large integer constants, and defining letters
766    G and H.   Here VALUE is the CONST_DOUBLE rtx itself.
767
768    For Alpha, `G' is the floating-point constant zero.  `H' is a CONST_DOUBLE
769    that is the operand of a ZAP insn.  */
770
771 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                          \
772   ((C) == 'G' ? (GET_MODE_CLASS (GET_MODE (VALUE)) == MODE_FLOAT        \
773                  && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))           \
774    : (C) == 'H' ? (GET_MODE (VALUE) == VOIDmode                         \
775                    && zap_mask (CONST_DOUBLE_LOW (VALUE))               \
776                    && zap_mask (CONST_DOUBLE_HIGH (VALUE)))             \
777    : 0)
778
779 /* Optional extra constraints for this machine.
780
781    For the Alpha, `Q' means that this is a memory operand but not a
782    reference to an unaligned location.
783
784    `R' is a SYMBOL_REF that has SYMBOL_REF_FLAG set or is the current
785    function.
786
787    'S' is a 6-bit constant (valid for a shift insn).  */
788
789 #define EXTRA_CONSTRAINT(OP, C)                         \
790   ((C) == 'Q' ? normal_memory_operand (OP, VOIDmode)                    \
791    : (C) == 'R' ? current_file_function_operand (OP, Pmode)             \
792    : (C) == 'S' ? (GET_CODE (OP) == CONST_INT                           \
793                    && (unsigned HOST_WIDE_INT) INTVAL (OP) < 64)        \
794    : 0)
795
796 /* Given an rtx X being reloaded into a reg required to be
797    in class CLASS, return the class of reg to actually use.
798    In general this is just CLASS; but on some machines
799    in some cases it is preferable to use a more restrictive class.
800
801    On the Alpha, all constants except zero go into a floating-point
802    register via memory.  */
803
804 #define PREFERRED_RELOAD_CLASS(X, CLASS)                \
805   (CONSTANT_P (X) && (X) != const0_rtx && (X) != CONST0_RTX (GET_MODE (X)) \
806    ? ((CLASS) == FLOAT_REGS || (CLASS) == NO_REGS ? NO_REGS : GENERAL_REGS)\
807    : (CLASS))
808
809 /* Loading and storing HImode or QImode values to and from memory
810    usually requires a scratch register.  The exceptions are loading
811    QImode and HImode from an aligned address to a general register
812    unless byte instructions are permitted.
813    We also cannot load an unaligned address or a paradoxical SUBREG into an
814    FP register.   */
815
816 #define SECONDARY_INPUT_RELOAD_CLASS(CLASS,MODE,IN) \
817   secondary_reload_class((CLASS), (MODE), (IN), 1)
818
819 #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS,MODE,OUT) \
820   secondary_reload_class((CLASS), (MODE), (OUT), 0)
821
822 /* If we are copying between general and FP registers, we need a memory
823    location unless the FIX extension is available.  */
824
825 #define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) \
826  (! TARGET_FIX && (CLASS1) != (CLASS2))
827
828 /* Specify the mode to be used for memory when a secondary memory
829    location is needed.  If MODE is floating-point, use it.  Otherwise,
830    widen to a word like the default.  This is needed because we always
831    store integers in FP registers in quadword format.  This whole
832    area is very tricky! */
833 #define SECONDARY_MEMORY_NEEDED_MODE(MODE)              \
834   (GET_MODE_CLASS (MODE) == MODE_FLOAT ? (MODE)         \
835    : GET_MODE_SIZE (MODE) >= 4 ? (MODE)                 \
836    : mode_for_size (BITS_PER_WORD, GET_MODE_CLASS (MODE), 0))
837
838 /* Return the maximum number of consecutive registers
839    needed to represent mode MODE in a register of class CLASS.  */
840
841 #define CLASS_MAX_NREGS(CLASS, MODE)                            \
842  ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
843
844 /* If defined, gives a class of registers that cannot be used as the
845    operand of a SUBREG that changes the mode of the object illegally.  */
846
847 #define CLASS_CANNOT_CHANGE_MODE        FLOAT_REGS
848
849 /* Defines illegal mode changes for CLASS_CANNOT_CHANGE_MODE.  */
850
851 #define CLASS_CANNOT_CHANGE_MODE_P(FROM,TO) \
852   (GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO))
853
854 /* Define the cost of moving between registers of various classes.  Moving
855    between FLOAT_REGS and anything else except float regs is expensive. 
856    In fact, we make it quite expensive because we really don't want to
857    do these moves unless it is clearly worth it.  Optimizations may
858    reduce the impact of not being able to allocate a pseudo to a
859    hard register.  */
860
861 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2)        \
862   (((CLASS1) == FLOAT_REGS) == ((CLASS2) == FLOAT_REGS) \
863    ? 2                                                  \
864    : TARGET_FIX ? 3 : 4+2*alpha_memory_latency)
865
866 /* A C expressions returning the cost of moving data of MODE from a register to
867    or from memory.
868
869    On the Alpha, bump this up a bit.  */
870
871 extern int alpha_memory_latency;
872 #define MEMORY_MOVE_COST(MODE,CLASS,IN)  (2*alpha_memory_latency)
873
874 /* Provide the cost of a branch.  Exact meaning under development.  */
875 #define BRANCH_COST 5
876
877 /* Adjust the cost of dependencies.  */
878
879 #define ADJUST_COST(INSN,LINK,DEP,COST) \
880   (COST) = alpha_adjust_cost (INSN, LINK, DEP, COST)
881 \f
882 /* Stack layout; function entry, exit and calling.  */
883
884 /* Define this if pushing a word on the stack
885    makes the stack pointer a smaller address.  */
886 #define STACK_GROWS_DOWNWARD
887
888 /* Define this if the nominal address of the stack frame
889    is at the high-address end of the local variables;
890    that is, each additional local variable allocated
891    goes at a more negative offset in the frame.  */
892 /* #define FRAME_GROWS_DOWNWARD */
893
894 /* Offset within stack frame to start allocating local variables at.
895    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
896    first local allocated.  Otherwise, it is the offset to the BEGINNING
897    of the first local allocated.  */
898
899 #define STARTING_FRAME_OFFSET 0
900
901 /* If we generate an insn to push BYTES bytes,
902    this says how many the stack pointer really advances by.
903    On Alpha, don't define this because there are no push insns.  */
904 /*  #define PUSH_ROUNDING(BYTES) */
905
906 /* Define this to be nonzero if stack checking is built into the ABI.  */
907 #define STACK_CHECK_BUILTIN 1
908
909 /* Define this if the maximum size of all the outgoing args is to be
910    accumulated and pushed during the prologue.  The amount can be
911    found in the variable current_function_outgoing_args_size.  */
912 #define ACCUMULATE_OUTGOING_ARGS 1
913
914 /* Offset of first parameter from the argument pointer register value.  */
915
916 #define FIRST_PARM_OFFSET(FNDECL) 0
917
918 /* Definitions for register eliminations.
919
920    We have two registers that can be eliminated on the Alpha.  First, the
921    frame pointer register can often be eliminated in favor of the stack
922    pointer register.  Secondly, the argument pointer register can always be
923    eliminated; it is replaced with either the stack or frame pointer. */
924
925 /* This is an array of structures.  Each structure initializes one pair
926    of eliminable registers.  The "from" register number is given first,
927    followed by "to".  Eliminations of the same "from" register are listed
928    in order of preference.  */
929
930 #define ELIMINABLE_REGS                              \
931 {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},        \
932  { ARG_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM},   \
933  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},      \
934  { FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
935
936 /* Given FROM and TO register numbers, say whether this elimination is allowed.
937    Frame pointer elimination is automatically handled.
938
939    All eliminations are valid since the cases where FP can't be
940    eliminated are already handled.  */
941
942 #define CAN_ELIMINATE(FROM, TO) 1
943
944 /* Round up to a multiple of 16 bytes.  */
945 #define ALPHA_ROUND(X) (((X) + 15) & ~ 15)
946
947 /* Define the offset between two registers, one to be eliminated, and the other
948    its replacement, at the start of a routine.  */
949 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)                    \
950 { if ((FROM) == FRAME_POINTER_REGNUM)                                   \
951     (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size)       \
952                 + alpha_sa_size ());                                    \
953   else if ((FROM) == ARG_POINTER_REGNUM)                                \
954     (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size)       \
955                 + alpha_sa_size ()                                      \
956                 + (ALPHA_ROUND (get_frame_size ()                       \
957                                + current_function_pretend_args_size)    \
958                    - current_function_pretend_args_size));              \
959   else                                                                  \
960     abort ();                                                           \
961 }
962
963 /* Define this if stack space is still allocated for a parameter passed
964    in a register.  */
965 /* #define REG_PARM_STACK_SPACE */
966
967 /* Value is the number of bytes of arguments automatically
968    popped when returning from a subroutine call.
969    FUNDECL is the declaration node of the function (as a tree),
970    FUNTYPE is the data type of the function (as a tree),
971    or for a library call it is an identifier node for the subroutine name.
972    SIZE is the number of bytes of arguments passed on the stack.  */
973
974 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
975
976 /* Define how to find the value returned by a function.
977    VALTYPE is the data type of the value (as a tree).
978    If the precise function being called is known, FUNC is its FUNCTION_DECL;
979    otherwise, FUNC is 0.
980
981    On Alpha the value is found in $0 for integer functions and
982    $f0 for floating-point functions.  */
983
984 #define FUNCTION_VALUE(VALTYPE, FUNC)   \
985   gen_rtx_REG (((INTEGRAL_TYPE_P (VALTYPE)                      \
986                  && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD)   \
987                 || POINTER_TYPE_P (VALTYPE))                    \
988                ? word_mode : TYPE_MODE (VALTYPE),               \
989                ((TARGET_FPREGS                                  \
990                  && (TREE_CODE (VALTYPE) == REAL_TYPE           \
991                      || TREE_CODE (VALTYPE) == COMPLEX_TYPE))   \
992                 ? 32 : 0))
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    gen_rtx_REG (MODE,                                           \
999                 (TARGET_FPREGS                                  \
1000                  && (GET_MODE_CLASS (MODE) == MODE_FLOAT        \
1001                      || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) \
1002                  ? 32 : 0))
1003
1004 /* The definition of this macro implies that there are cases where
1005    a scalar value cannot be returned in registers.
1006
1007    For the Alpha, any structure or union type is returned in memory, as
1008    are integers whose size is larger than 64 bits.  */
1009
1010 #define RETURN_IN_MEMORY(TYPE) \
1011   (TYPE_MODE (TYPE) == BLKmode \
1012    || TYPE_MODE (TYPE) == TFmode \
1013    || TYPE_MODE (TYPE) == TCmode \
1014    || (TREE_CODE (TYPE) == INTEGER_TYPE && TYPE_PRECISION (TYPE) > 64))
1015
1016 /* 1 if N is a possible register number for a function value
1017    as seen by the caller.  */
1018
1019 #define FUNCTION_VALUE_REGNO_P(N)  \
1020   ((N) == 0 || (N) == 1 || (N) == 32 || (N) == 33)
1021
1022 /* 1 if N is a possible register number for function argument passing.
1023    On Alpha, these are $16-$21 and $f16-$f21.  */
1024
1025 #define FUNCTION_ARG_REGNO_P(N) \
1026   (((N) >= 16 && (N) <= 21) || ((N) >= 16 + 32 && (N) <= 21 + 32))
1027 \f
1028 /* Define a data type for recording info about an argument list
1029    during the scan of that argument list.  This data type should
1030    hold all necessary information about the function itself
1031    and about the args processed so far, enough to enable macros
1032    such as FUNCTION_ARG to determine where the next arg should go.
1033
1034    On Alpha, this is a single integer, which is a number of words
1035    of arguments scanned so far.
1036    Thus 6 or more means all following args should go on the stack.  */
1037
1038 #define CUMULATIVE_ARGS int
1039
1040 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1041    for a call to a function whose data type is FNTYPE.
1042    For a library call, FNTYPE is 0.  */
1043
1044 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT)  (CUM) = 0
1045
1046 /* Define intermediate macro to compute the size (in registers) of an argument
1047    for the Alpha.  */
1048
1049 #define ALPHA_ARG_SIZE(MODE, TYPE, NAMED)                               \
1050   ((MODE) == TFmode || (MODE) == TCmode ? 1                             \
1051    : (((MODE) == BLKmode ? int_size_in_bytes (TYPE) : GET_MODE_SIZE (MODE)) \
1052       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1053
1054 /* Update the data in CUM to advance over an argument
1055    of mode MODE and data type TYPE.
1056    (TYPE is null for libcalls where that information may not be available.)  */
1057
1058 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
1059   if (MUST_PASS_IN_STACK (MODE, TYPE))                                  \
1060     (CUM) = 6;                                                          \
1061   else                                                                  \
1062     (CUM) += ALPHA_ARG_SIZE (MODE, TYPE, NAMED)
1063
1064 /* Determine where to put an argument to a function.
1065    Value is zero to push the argument on the stack,
1066    or a hard register in which to store the argument.
1067
1068    MODE is the argument's machine mode.
1069    TYPE is the data type of the argument (as a tree).
1070     This is null for libcalls where that information may
1071     not be available.
1072    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1073     the preceding args and about the function being called.
1074    NAMED is nonzero if this argument is a named parameter
1075     (otherwise it is an extra parameter matching an ellipsis).
1076
1077    On Alpha the first 6 words of args are normally in registers
1078    and the rest are pushed.  */
1079
1080 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)    \
1081   function_arg((CUM), (MODE), (TYPE), (NAMED))
1082
1083 /* A C expression that indicates when an argument must be passed by
1084    reference.  If nonzero for an argument, a copy of that argument is
1085    made in memory and a pointer to the argument is passed instead of
1086    the argument itself.  The pointer is passed in whatever way is
1087    appropriate for passing a pointer to that type. */
1088
1089 #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
1090   ((MODE) == TFmode || (MODE) == TCmode)
1091
1092 /* Specify the padding direction of arguments.
1093
1094    On the Alpha, we must pad upwards in order to be able to pass args in
1095    registers.  */
1096
1097 #define FUNCTION_ARG_PADDING(MODE, TYPE)        upward
1098
1099 /* For an arg passed partly in registers and partly in memory,
1100    this is the number of registers used.
1101    For args passed entirely in registers or entirely in memory, zero.  */
1102
1103 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED)      \
1104 ((CUM) < 6 && 6 < (CUM) + ALPHA_ARG_SIZE (MODE, TYPE, NAMED)    \
1105  ? 6 - (CUM) : 0)
1106
1107 /* Perform any needed actions needed for a function that is receiving a
1108    variable number of arguments. 
1109
1110    CUM is as above.
1111
1112    MODE and TYPE are the mode and type of the current parameter.
1113
1114    PRETEND_SIZE is a variable that should be set to the amount of stack
1115    that must be pushed by the prolog to pretend that our caller pushed
1116    it.
1117
1118    Normally, this macro will push all remaining incoming registers on the
1119    stack and set PRETEND_SIZE to the length of the registers pushed. 
1120
1121    On the Alpha, we allocate space for all 12 arg registers, but only
1122    push those that are remaining.
1123
1124    However, if NO registers need to be saved, don't allocate any space.
1125    This is not only because we won't need the space, but because AP includes
1126    the current_pretend_args_size and we don't want to mess up any
1127    ap-relative addresses already made.
1128
1129    If we are not to use the floating-point registers, save the integer
1130    registers where we would put the floating-point registers.  This is
1131    not the most efficient way to implement varargs with just one register
1132    class, but it isn't worth doing anything more efficient in this rare
1133    case.  */
1134    
1135 #define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL)       \
1136 { if ((CUM) < 6)                                                        \
1137     {                                                                   \
1138       if (! (NO_RTL))                                                   \
1139         {                                                               \
1140           rtx tmp; int set = get_varargs_alias_set ();                  \
1141           tmp = gen_rtx_MEM (BLKmode,                                   \
1142                              plus_constant (virtual_incoming_args_rtx,  \
1143                                             ((CUM) + 6)* UNITS_PER_WORD)); \
1144           MEM_ALIAS_SET (tmp) = set;                                    \
1145           move_block_from_reg                                           \
1146             (16 + CUM, tmp,                                             \
1147              6 - (CUM), (6 - (CUM)) * UNITS_PER_WORD);                  \
1148                                                                         \
1149           tmp = gen_rtx_MEM (BLKmode,                                   \
1150                              plus_constant (virtual_incoming_args_rtx,  \
1151                                             (CUM) * UNITS_PER_WORD));   \
1152           MEM_ALIAS_SET (tmp) = set;                                    \
1153           move_block_from_reg                                           \
1154             (16 + (TARGET_FPREGS ? 32 : 0) + CUM, tmp,                  \
1155              6 - (CUM), (6 - (CUM)) * UNITS_PER_WORD);                  \
1156          }                                                              \
1157       PRETEND_SIZE = 12 * UNITS_PER_WORD;                               \
1158     }                                                                   \
1159 }
1160
1161 /* We do not allow indirect calls to be optimized into sibling calls, nor
1162    can we allow a call to a function in a different compilation unit to
1163    be optimized into a sibcall.  Except if the function is known not to
1164    return, in which case our caller doesn't care what the gp is.  */
1165 #define FUNCTION_OK_FOR_SIBCALL(DECL)                   \
1166   (DECL                                                 \
1167    && ((TREE_ASM_WRITTEN (DECL) && !flag_pic)           \
1168        || ! TREE_PUBLIC (DECL)))
1169
1170 /* Try to output insns to set TARGET equal to the constant C if it can be
1171    done in less than N insns.  Do all computations in MODE.  Returns the place
1172    where the output has been placed if it can be done and the insns have been
1173    emitted.  If it would take more than N insns, zero is returned and no
1174    insns and emitted.  */
1175
1176 /* Define the information needed to generate branch and scc insns.  This is
1177    stored from the compare operation.  Note that we can't use "rtx" here
1178    since it hasn't been defined!  */
1179
1180 struct alpha_compare
1181 {
1182   struct rtx_def *op0, *op1;
1183   int fp_p;
1184 };
1185
1186 extern struct alpha_compare alpha_compare;
1187
1188 /* Machine specific function data.  */
1189
1190 struct machine_function
1191 {
1192   /* If non-null, this rtx holds the return address for the function.  */
1193   struct rtx_def *ra_rtx;
1194
1195   /* If non-null, this rtx holds a saved copy of the GP for the function.  */
1196   struct rtx_def *gp_save_rtx;
1197 };
1198
1199 /* Make (or fake) .linkage entry for function call.
1200    IS_LOCAL is 0 if name is used in call, 1 if name is used in definition.  */
1201
1202 /* This macro defines the start of an assembly comment.  */
1203
1204 #define ASM_COMMENT_START " #"
1205
1206 /* This macro produces the initial definition of a function.  */
1207
1208 #define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL) \
1209   alpha_start_function(FILE,NAME,DECL);
1210
1211 /* This macro closes up a function definition for the assembler.  */
1212
1213 #define ASM_DECLARE_FUNCTION_SIZE(FILE,NAME,DECL) \
1214   alpha_end_function(FILE,NAME,DECL)
1215    
1216 /* This macro notes the end of the prologue.  */
1217
1218 #define FUNCTION_END_PROLOGUE(FILE)  output_end_prologue (FILE)
1219
1220 /* Output any profiling code before the prologue.  */
1221
1222 #define PROFILE_BEFORE_PROLOGUE 1
1223
1224 /* Output assembler code to FILE to increment profiler label # LABELNO
1225    for profiling a function entry.  Under OSF/1, profiling is enabled
1226    by simply passing -pg to the assembler and linker.  */
1227
1228 #define FUNCTION_PROFILER(FILE, LABELNO)
1229
1230 /* Output assembler code to FILE to initialize this source file's
1231    basic block profiling info, if that has not already been done.
1232    This assumes that __bb_init_func doesn't garble a1-a5. */
1233
1234 #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO)                  \
1235     do {                                                        \
1236         ASM_OUTPUT_REG_PUSH (FILE, 16);                         \
1237         fputs ("\tlda $16,$PBX32\n", (FILE));                   \
1238         fputs ("\tldq $26,0($16)\n", (FILE));                   \
1239         fputs ("\tbne $26,1f\n", (FILE));                       \
1240         fputs ("\tlda $27,__bb_init_func\n", (FILE));           \
1241         fputs ("\tjsr $26,($27),__bb_init_func\n", (FILE));     \
1242         fputs ("\tldgp $29,0($26)\n", (FILE));                  \
1243         fputs ("1:\n", (FILE));                                 \
1244         ASM_OUTPUT_REG_POP (FILE, 16);                          \
1245     } while (0);
1246
1247 /* Output assembler code to FILE to increment the entry-count for
1248    the BLOCKNO'th basic block in this source file.  */
1249
1250 #define BLOCK_PROFILER(FILE, BLOCKNO)                           \
1251     do {                                                        \
1252         int blockn = (BLOCKNO);                                 \
1253         fputs ("\tsubq $30,16,$30\n", (FILE));                  \
1254         fputs ("\tstq $26,0($30)\n", (FILE));                   \
1255         fputs ("\tstq $27,8($30)\n", (FILE));                   \
1256         fputs ("\tlda $26,$PBX34\n", (FILE));                   \
1257         fprintf ((FILE), "\tldq $27,%d($26)\n", 8*blockn);      \
1258         fputs ("\taddq $27,1,$27\n", (FILE));                   \
1259         fprintf ((FILE), "\tstq $27,%d($26)\n", 8*blockn);      \
1260         fputs ("\tldq $26,0($30)\n", (FILE));                   \
1261         fputs ("\tldq $27,8($30)\n", (FILE));                   \
1262         fputs ("\taddq $30,16,$30\n", (FILE));                  \
1263     } while (0)
1264
1265
1266 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
1267    the stack pointer does not matter.  The value is tested only in
1268    functions that have frame pointers.
1269    No definition is equivalent to always zero.  */
1270
1271 #define EXIT_IGNORE_STACK 1
1272
1273 /* Define registers used by the epilogue and return instruction.  */
1274
1275 #define EPILOGUE_USES(REGNO)    ((REGNO) == 26)
1276 \f
1277 /* Output assembler code for a block containing the constant parts
1278    of a trampoline, leaving space for the variable parts.
1279
1280    The trampoline should set the static chain pointer to value placed
1281    into the trampoline and should branch to the specified routine.  
1282    Note that $27 has been set to the address of the trampoline, so we can
1283    use it for addressability of the two data items.  Trampolines are always
1284    aligned to FUNCTION_BOUNDARY, which is 64 bits.  */
1285
1286 #define TRAMPOLINE_TEMPLATE(FILE)               \
1287 do {                                            \
1288   fprintf (FILE, "\tldq $1,24($27)\n");         \
1289   fprintf (FILE, "\tldq $27,16($27)\n");        \
1290   fprintf (FILE, "\tjmp $31,($27),0\n");        \
1291   fprintf (FILE, "\tnop\n");                    \
1292   fprintf (FILE, "\t.quad 0,0\n");              \
1293 } while (0)
1294
1295 /* Section in which to place the trampoline.  On Alpha, instructions
1296    may only be placed in a text segment.  */
1297
1298 #define TRAMPOLINE_SECTION text_section
1299
1300 /* Length in units of the trampoline for entering a nested function.  */
1301
1302 #define TRAMPOLINE_SIZE    32
1303
1304 /* Emit RTL insns to initialize the variable parts of a trampoline.
1305    FNADDR is an RTX for the address of the function's pure code.
1306    CXT is an RTX for the static chain value for the function.  */
1307
1308 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
1309   alpha_initialize_trampoline (TRAMP, FNADDR, CXT, 16, 24, 8)
1310
1311 /* A C expression whose value is RTL representing the value of the return
1312    address for the frame COUNT steps up from the current frame.
1313    FRAMEADDR is the frame pointer of the COUNT frame, or the frame pointer of
1314    the COUNT-1 frame if RETURN_ADDR_IN_PREVIOUS_FRAME is defined.  */
1315
1316 #define RETURN_ADDR_RTX  alpha_return_addr
1317
1318 /* Before the prologue, RA lives in $26. */
1319 #define INCOMING_RETURN_ADDR_RTX  gen_rtx_REG (Pmode, 26)
1320 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (26)
1321
1322 /* Describe how we implement __builtin_eh_return.  */
1323 #define EH_RETURN_DATA_REGNO(N) ((N) < 4 ? (N) + 16 : INVALID_REGNUM)
1324 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, 28)
1325 #define EH_RETURN_HANDLER_RTX \
1326   gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, \
1327                                      current_function_outgoing_args_size))
1328 \f
1329 /* Addressing modes, and classification of registers for them.  */
1330
1331 /* #define HAVE_POST_INCREMENT 0 */
1332 /* #define HAVE_POST_DECREMENT 0 */
1333
1334 /* #define HAVE_PRE_DECREMENT 0 */
1335 /* #define HAVE_PRE_INCREMENT 0 */
1336
1337 /* Macros to check register numbers against specific register classes.  */
1338
1339 /* These assume that REGNO is a hard or pseudo reg number.
1340    They give nonzero only if REGNO is a hard reg of the suitable class
1341    or a pseudo reg currently allocated to a suitable hard reg.
1342    Since they use reg_renumber, they are safe only once reg_renumber
1343    has been allocated, which happens in local-alloc.c.  */
1344
1345 #define REGNO_OK_FOR_INDEX_P(REGNO) 0
1346 #define REGNO_OK_FOR_BASE_P(REGNO) \
1347 ((REGNO) < 32 || (unsigned) reg_renumber[REGNO] < 32  \
1348  || (REGNO) == 63 || reg_renumber[REGNO] == 63)
1349 \f
1350 /* Maximum number of registers that can appear in a valid memory address.  */
1351 #define MAX_REGS_PER_ADDRESS 1
1352
1353 /* Recognize any constant value that is a valid address.  For the Alpha,
1354    there are only constants none since we want to use LDA to load any
1355    symbolic addresses into registers.  */
1356
1357 #define CONSTANT_ADDRESS_P(X)   \
1358   (GET_CODE (X) == CONST_INT    \
1359    && (unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000)
1360
1361 /* Include all constant integers and constant doubles, but not
1362    floating-point, except for floating-point zero.  */
1363
1364 #define LEGITIMATE_CONSTANT_P(X)                \
1365   (GET_MODE_CLASS (GET_MODE (X)) != MODE_FLOAT  \
1366    || (X) == CONST0_RTX (GET_MODE (X)))
1367
1368 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1369    and check its validity for a certain class.
1370    We have two alternate definitions for each of them.
1371    The usual definition accepts all pseudo regs; the other rejects
1372    them unless they have been allocated suitable hard regs.
1373    The symbol REG_OK_STRICT causes the latter definition to be used.
1374
1375    Most source files want to accept pseudo regs in the hope that
1376    they will get allocated to the class that the insn wants them to be in.
1377    Source files for reload pass need to be strict.
1378    After reload, it makes no difference, since pseudo regs have
1379    been eliminated by then.  */
1380
1381 #ifndef REG_OK_STRICT
1382
1383 /* Nonzero if X is a hard reg that can be used as an index
1384    or if it is a pseudo reg.  */
1385 #define REG_OK_FOR_INDEX_P(X) 0
1386
1387 /* Nonzero if X is a hard reg that can be used as a base reg
1388    or if it is a pseudo reg.  */
1389 #define REG_OK_FOR_BASE_P(X)  \
1390   (REGNO (X) < 32 || REGNO (X) == 63 || REGNO (X) >= FIRST_PSEUDO_REGISTER)
1391
1392 /* ??? Nonzero if X is the frame pointer, or some virtual register
1393    that may eliminate to the frame pointer.  These will be allowed to
1394    have offsets greater than 32K.  This is done because register
1395    elimination offsets will change the hi/lo split, and if we split
1396    before reload, we will require additional instructions.   */
1397 #define REG_OK_FP_BASE_P(X)                     \
1398   (REGNO (X) == 31 || REGNO (X) == 63           \
1399    || (REGNO (X) >= FIRST_PSEUDO_REGISTER       \
1400        && REGNO (X) < LAST_VIRTUAL_REGISTER))
1401
1402 #else
1403
1404 /* Nonzero if X is a hard reg that can be used as an index.  */
1405 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
1406
1407 /* Nonzero if X is a hard reg that can be used as a base reg.  */
1408 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
1409
1410 #define REG_OK_FP_BASE_P(X) 0
1411
1412 #endif
1413 \f
1414 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
1415    that is a valid memory address for an instruction.
1416    The MODE argument is the machine mode for the MEM expression
1417    that wants to use this address. 
1418
1419    For Alpha, we have either a constant address or the sum of a register
1420    and a constant address, or just a register.  For DImode, any of those
1421    forms can be surrounded with an AND that clear the low-order three bits;
1422    this is an "unaligned" access.
1423
1424    First define the basic valid address.  */
1425
1426 #define GO_IF_LEGITIMATE_SIMPLE_ADDRESS(MODE, X, ADDR)                  \
1427 {                                                                       \
1428   rtx tmp = (X);                                                        \
1429   if (GET_CODE (tmp) == SUBREG                                          \
1430       && (GET_MODE_SIZE (GET_MODE (tmp))                                \
1431           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (tmp)))))               \
1432     tmp = SUBREG_REG (tmp);                                             \
1433   if (REG_P (tmp) && REG_OK_FOR_BASE_P (tmp))                           \
1434     goto ADDR;                                                          \
1435   if (CONSTANT_ADDRESS_P (X))                                           \
1436     goto ADDR;                                                          \
1437   if (GET_CODE (X) == PLUS)                                             \
1438     {                                                                   \
1439       tmp = XEXP (X, 0);                                                \
1440       if (GET_CODE (tmp) == SUBREG                                      \
1441           && (GET_MODE_SIZE (GET_MODE (tmp))                            \
1442               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (tmp)))))           \
1443         tmp = SUBREG_REG (tmp);                                         \
1444       if (REG_P (tmp))                                                  \
1445         {                                                               \
1446           if (REG_OK_FP_BASE_P (tmp)                                    \
1447               && GET_CODE (XEXP (X, 1)) == CONST_INT)                   \
1448             goto ADDR;                                                  \
1449           if (REG_OK_FOR_BASE_P (tmp)                                   \
1450               && CONSTANT_ADDRESS_P (XEXP (X, 1)))                      \
1451             goto ADDR;                                                  \
1452         }                                                               \
1453       else if (GET_CODE (tmp) == ADDRESSOF                              \
1454                && CONSTANT_ADDRESS_P (XEXP (X, 1)))                     \
1455         goto ADDR;                                                      \
1456     }                                                                   \
1457 }
1458
1459 /* Now accept the simple address, or, for DImode only, an AND of a simple
1460    address that turns off the low three bits.  */
1461
1462 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
1463 { GO_IF_LEGITIMATE_SIMPLE_ADDRESS (MODE, X, ADDR); \
1464   if ((MODE) == DImode                          \
1465       && GET_CODE (X) == AND                    \
1466       && GET_CODE (XEXP (X, 1)) == CONST_INT    \
1467       && INTVAL (XEXP (X, 1)) == -8)            \
1468     GO_IF_LEGITIMATE_SIMPLE_ADDRESS (MODE, XEXP (X, 0), ADDR); \
1469 }
1470
1471 /* Try machine-dependent ways of modifying an illegitimate address
1472    to be legitimate.  If we find one, return the new, valid address.
1473    This macro is used in only one place: `memory_address' in explow.c.
1474
1475    OLDX is the address as it was before break_out_memory_refs was called.
1476    In some cases it is useful to look at this to decide what needs to be done.
1477
1478    MODE and WIN are passed so that this macro can use
1479    GO_IF_LEGITIMATE_ADDRESS.
1480
1481    It is always safe for this macro to do nothing.  It exists to recognize
1482    opportunities to optimize the output. 
1483
1484    For the Alpha, there are three cases we handle:
1485
1486    (1) If the address is (plus reg const_int) and the CONST_INT is not a
1487        valid offset, compute the high part of the constant and add it to the
1488        register.  Then our address is (plus temp low-part-const).
1489    (2) If the address is (const (plus FOO const_int)), find the low-order
1490        part of the CONST_INT.  Then load FOO plus any high-order part of the
1491        CONST_INT into a register.  Our address is (plus reg low-part-const).
1492        This is done to reduce the number of GOT entries.
1493    (3) If we have a (plus reg const), emit the load as in (2), then add
1494        the two registers, and finally generate (plus reg low-part-const) as
1495        our address.  */
1496
1497 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)                     \
1498 { if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == REG     \
1499       && GET_CODE (XEXP (X, 1)) == CONST_INT                    \
1500       && ! CONSTANT_ADDRESS_P (XEXP (X, 1)))                    \
1501     {                                                           \
1502       HOST_WIDE_INT val = INTVAL (XEXP (X, 1));                 \
1503       HOST_WIDE_INT lowpart = (val & 0xffff) - 2 * (val & 0x8000); \
1504       HOST_WIDE_INT highpart = val - lowpart;                   \
1505       rtx high = GEN_INT (highpart);                            \
1506       rtx temp = expand_binop (Pmode, add_optab, XEXP (x, 0),   \
1507                                high, NULL_RTX, 1, OPTAB_LIB_WIDEN); \
1508                                                                 \
1509       (X) = plus_constant (temp, lowpart);                      \
1510       goto WIN;                                                 \
1511     }                                                           \
1512   else if (GET_CODE (X) == CONST                                \
1513            && GET_CODE (XEXP (X, 0)) == PLUS                    \
1514            && GET_CODE (XEXP (XEXP (X, 0), 1)) == CONST_INT)    \
1515     {                                                           \
1516       HOST_WIDE_INT val = INTVAL (XEXP (XEXP (X, 0), 1));       \
1517       HOST_WIDE_INT lowpart = (val & 0xffff) - 2 * (val & 0x8000); \
1518       HOST_WIDE_INT highpart = val - lowpart;                   \
1519       rtx high = XEXP (XEXP (X, 0), 0);                         \
1520                                                                 \
1521       if (highpart)                                             \
1522         high = plus_constant (high, highpart);                  \
1523                                                                 \
1524       (X) = plus_constant (force_reg (Pmode, high), lowpart);   \
1525       goto WIN;                                                 \
1526     }                                                           \
1527   else if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == REG \
1528            && GET_CODE (XEXP (X, 1)) == CONST                   \
1529            && GET_CODE (XEXP (XEXP (X, 1), 0)) == PLUS          \
1530            && GET_CODE (XEXP (XEXP (XEXP (X, 1), 0), 1)) == CONST_INT) \
1531     {                                                           \
1532       HOST_WIDE_INT val = INTVAL (XEXP (XEXP (XEXP (X, 1), 0), 1)); \
1533       HOST_WIDE_INT lowpart = (val & 0xffff) - 2 * (val & 0x8000); \
1534       HOST_WIDE_INT highpart = val - lowpart;                   \
1535       rtx high = XEXP (XEXP (XEXP (X, 1), 0), 0);               \
1536                                                                 \
1537       if (highpart)                                             \
1538         high = plus_constant (high, highpart);                  \
1539                                                                 \
1540       high = expand_binop (Pmode, add_optab, XEXP (X, 0),       \
1541                            force_reg (Pmode, high),             \
1542                            high, 1, OPTAB_LIB_WIDEN);           \
1543       (X) = plus_constant (high, lowpart);                      \
1544       goto WIN;                                                 \
1545     }                                                           \
1546 }
1547
1548 /* Try a machine-dependent way of reloading an illegitimate address
1549    operand.  If we find one, push the reload and jump to WIN.  This
1550    macro is used in only one place: `find_reloads_address' in reload.c.
1551
1552    For the Alpha, we wish to handle large displacements off a base
1553    register by splitting the addend across an ldah and the mem insn.
1554    This cuts number of extra insns needed from 3 to 1.  */
1555    
1556 #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_LEVELS,WIN)     \
1557 do {                                                                    \
1558   /* We must recognize output that we have already generated ourselves.  */ \
1559   if (GET_CODE (X) == PLUS                                              \
1560       && GET_CODE (XEXP (X, 0)) == PLUS                                 \
1561       && GET_CODE (XEXP (XEXP (X, 0), 0)) == REG                        \
1562       && GET_CODE (XEXP (XEXP (X, 0), 1)) == CONST_INT                  \
1563       && GET_CODE (XEXP (X, 1)) == CONST_INT)                           \
1564     {                                                                   \
1565       push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL,   \
1566                    BASE_REG_CLASS, GET_MODE (X), VOIDmode, 0, 0,        \
1567                    OPNUM, TYPE);                                        \
1568       goto WIN;                                                         \
1569     }                                                                   \
1570   if (GET_CODE (X) == PLUS                                              \
1571       && GET_CODE (XEXP (X, 0)) == REG                                  \
1572       && REGNO (XEXP (X, 0)) < FIRST_PSEUDO_REGISTER                    \
1573       && REG_MODE_OK_FOR_BASE_P (XEXP (X, 0), MODE)                     \
1574       && GET_CODE (XEXP (X, 1)) == CONST_INT)                           \
1575     {                                                                   \
1576       HOST_WIDE_INT val = INTVAL (XEXP (X, 1));                         \
1577       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;           \
1578       HOST_WIDE_INT high                                                \
1579         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;       \
1580                                                                         \
1581       /* Check for 32-bit overflow.  */                                 \
1582       if (high + low != val)                                            \
1583         break;                                                          \
1584                                                                         \
1585       /* Reload the high part into a base reg; leave the low part       \
1586          in the mem directly.  */                                       \
1587                                                                         \
1588       X = gen_rtx_PLUS (GET_MODE (X),                                   \
1589                         gen_rtx_PLUS (GET_MODE (X), XEXP (X, 0),        \
1590                                       GEN_INT (high)),                  \
1591                         GEN_INT (low));                                 \
1592                                                                         \
1593       push_reload (XEXP (X, 0), NULL_RTX, &XEXP (X, 0), NULL,   \
1594                    BASE_REG_CLASS, GET_MODE (X), VOIDmode, 0, 0,        \
1595                    OPNUM, TYPE);                                        \
1596       goto WIN;                                                         \
1597     }                                                                   \
1598 } while (0)
1599
1600 /* Go to LABEL if ADDR (a legitimate address expression)
1601    has an effect that depends on the machine mode it is used for.
1602    On the Alpha this is true only for the unaligned modes.   We can
1603    simplify this test since we know that the address must be valid.  */
1604
1605 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)  \
1606 { if (GET_CODE (ADDR) == AND) goto LABEL; }
1607
1608 /* Compute the cost of an address.  For the Alpha, all valid addresses are
1609    the same cost.  */
1610
1611 #define ADDRESS_COST(X)  0
1612
1613 /* Machine-dependent reorg pass.   */
1614 #define MACHINE_DEPENDENT_REORG(X)      alpha_reorg(X)
1615 \f
1616 /* Specify the machine mode that this machine uses
1617    for the index in the tablejump instruction.  */
1618 #define CASE_VECTOR_MODE SImode
1619
1620 /* Define as C expression which evaluates to nonzero if the tablejump
1621    instruction expects the table to contain offsets from the address of the
1622    table.
1623
1624    Do not define this if the table should contain absolute addresses.
1625    On the Alpha, the table is really GP-relative, not relative to the PC
1626    of the table, but we pretend that it is PC-relative; this should be OK,
1627    but we should try to find some better way sometime.  */
1628 #define CASE_VECTOR_PC_RELATIVE 1
1629
1630 /* Specify the tree operation to be used to convert reals to integers.  */
1631 #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
1632
1633 /* This is the kind of divide that is easiest to do in the general case.  */
1634 #define EASY_DIV_EXPR TRUNC_DIV_EXPR
1635
1636 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1637 #define DEFAULT_SIGNED_CHAR 1
1638
1639 /* This flag, if defined, says the same insns that convert to a signed fixnum
1640    also convert validly to an unsigned one.
1641
1642    We actually lie a bit here as overflow conditions are different.  But
1643    they aren't being checked anyway.  */
1644
1645 #define FIXUNS_TRUNC_LIKE_FIX_TRUNC
1646
1647 /* Max number of bytes we can move to or from memory
1648    in one reasonably fast instruction.  */
1649
1650 #define MOVE_MAX 8
1651
1652 /* If a memory-to-memory move would take MOVE_RATIO or more simple
1653    move-instruction pairs, we will do a movstr or libcall instead.
1654
1655    Without byte/word accesses, we want no more than four instructions;
1656    with, several single byte accesses are better.   */
1657
1658 #define MOVE_RATIO  (TARGET_BWX ? 7 : 2)
1659
1660 /* Largest number of bytes of an object that can be placed in a register.
1661    On the Alpha we have plenty of registers, so use TImode.  */
1662 #define MAX_FIXED_MODE_SIZE     GET_MODE_BITSIZE (TImode)
1663
1664 /* Nonzero if access to memory by bytes is no faster than for words.
1665    Also non-zero if doing byte operations (specifically shifts) in registers
1666    is undesirable. 
1667
1668    On the Alpha, we want to not use the byte operation and instead use
1669    masking operations to access fields; these will save instructions.  */
1670
1671 #define SLOW_BYTE_ACCESS        1
1672
1673 /* Define if operations between registers always perform the operation
1674    on the full register even if a narrower mode is specified.  */
1675 #define WORD_REGISTER_OPERATIONS
1676
1677 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
1678    will either zero-extend or sign-extend.  The value of this macro should
1679    be the code that says which one of the two operations is implicitly
1680    done, NIL if none.  */
1681 #define LOAD_EXTEND_OP(MODE) ((MODE) == SImode ? SIGN_EXTEND : ZERO_EXTEND)
1682
1683 /* Define if loading short immediate values into registers sign extends.  */
1684 #define SHORT_IMMEDIATES_SIGN_EXTEND
1685
1686 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1687    is done just by pretending it is already truncated.  */
1688 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1689
1690 /* We assume that the store-condition-codes instructions store 0 for false
1691    and some other value for true.  This is the value stored for true.  */
1692
1693 #define STORE_FLAG_VALUE 1
1694
1695 /* Define the value returned by a floating-point comparison instruction.  */
1696
1697 #define FLOAT_STORE_FLAG_VALUE(MODE) \
1698   REAL_VALUE_ATOF ((TARGET_FLOAT_VAX ? "0.5" : "2.0"), (MODE))
1699
1700 /* Canonicalize a comparison from one we don't have to one we do have.  */
1701
1702 #define CANONICALIZE_COMPARISON(CODE,OP0,OP1) \
1703   do {                                                                  \
1704     if (((CODE) == GE || (CODE) == GT || (CODE) == GEU || (CODE) == GTU) \
1705         && (GET_CODE (OP1) == REG || (OP1) == const0_rtx))              \
1706       {                                                                 \
1707         rtx tem = (OP0);                                                \
1708         (OP0) = (OP1);                                                  \
1709         (OP1) = tem;                                                    \
1710         (CODE) = swap_condition (CODE);                                 \
1711       }                                                                 \
1712     if (((CODE) == LT || (CODE) == LTU)                                 \
1713         && GET_CODE (OP1) == CONST_INT && INTVAL (OP1) == 256)          \
1714       {                                                                 \
1715         (CODE) = (CODE) == LT ? LE : LEU;                               \
1716         (OP1) = GEN_INT (255);                                          \
1717       }                                                                 \
1718   } while (0)
1719
1720 /* Specify the machine mode that pointers have.
1721    After generation of rtl, the compiler makes no further distinction
1722    between pointers and any other objects of this machine mode.  */
1723 #define Pmode DImode
1724
1725 /* Mode of a function address in a call instruction (for indexing purposes). */
1726
1727 #define FUNCTION_MODE Pmode
1728
1729 /* Define this if addresses of constant functions
1730    shouldn't be put through pseudo regs where they can be cse'd.
1731    Desirable on machines where ordinary constants are expensive
1732    but a CALL with constant address is cheap.
1733
1734    We define this on the Alpha so that gen_call and gen_call_value
1735    get to see the SYMBOL_REF (for the hint field of the jsr).  It will
1736    then copy it into a register, thus actually letting the address be
1737    cse'ed.  */
1738
1739 #define NO_FUNCTION_CSE
1740
1741 /* Define this to be nonzero if shift instructions ignore all but the low-order
1742    few bits. */
1743 #define SHIFT_COUNT_TRUNCATED 1
1744
1745 /* The EV4 is dual issue; EV5/EV6 are quad issue.  */
1746 #define ISSUE_RATE  (alpha_cpu == PROCESSOR_EV4 ? 2 : 4)
1747
1748 /* Describe the fact that MULTI instructions are multiple instructions
1749    and so to assume they don't pair with anything.  */
1750 #define MD_SCHED_VARIABLE_ISSUE(DUMP, SCHED_VERBOSE, INSN, CAN_ISSUE_MORE) \
1751   if (recog_memoized (INSN) < 0 || get_attr_type (INSN) == TYPE_MULTI)     \
1752      (CAN_ISSUE_MORE) = 0
1753
1754 /* Compute the cost of computing a constant rtl expression RTX
1755    whose rtx-code is CODE.  The body of this macro is a portion
1756    of a switch statement.  If the code is computed here,
1757    return it with a return statement.  Otherwise, break from the switch.
1758
1759    If this is an 8-bit constant, return zero since it can be used
1760    nearly anywhere with no cost.  If it is a valid operand for an
1761    ADD or AND, likewise return 0 if we know it will be used in that
1762    context.  Otherwise, return 2 since it might be used there later.
1763    All other constants take at least two insns.  */
1764
1765 #define CONST_COSTS(RTX,CODE,OUTER_CODE) \
1766   case CONST_INT:                                               \
1767     if (INTVAL (RTX) >= 0 && INTVAL (RTX) < 256)                \
1768       return 0;                                                 \
1769   case CONST_DOUBLE:                                            \
1770     if ((RTX) == CONST0_RTX (GET_MODE (RTX)))                   \
1771       return 0;                                                 \
1772     else if (((OUTER_CODE) == PLUS && add_operand (RTX, VOIDmode)) \
1773         || ((OUTER_CODE) == AND && and_operand (RTX, VOIDmode))) \
1774       return 0;                                                 \
1775     else if (add_operand (RTX, VOIDmode) || and_operand (RTX, VOIDmode)) \
1776       return 2;                                                 \
1777     else                                                        \
1778       return COSTS_N_INSNS (2);                                 \
1779   case CONST:                                                   \
1780   case SYMBOL_REF:                                              \
1781   case LABEL_REF:                                               \
1782   switch (alpha_cpu)                                            \
1783     {                                                           \
1784     case PROCESSOR_EV4:                                         \
1785       return COSTS_N_INSNS (3);                                 \
1786     case PROCESSOR_EV5:                                         \
1787     case PROCESSOR_EV6:                                         \
1788       return COSTS_N_INSNS (2);                                 \
1789     default: abort();                                           \
1790     }
1791     
1792 /* Provide the costs of a rtl expression.  This is in the body of a
1793    switch on CODE.  */
1794    
1795 #define RTX_COSTS(X,CODE,OUTER_CODE)                    \
1796   case PLUS:  case MINUS:                               \
1797     if (FLOAT_MODE_P (GET_MODE (X)))                    \
1798       switch (alpha_cpu)                                \
1799         {                                               \
1800         case PROCESSOR_EV4:                             \
1801           return COSTS_N_INSNS (6);                     \
1802         case PROCESSOR_EV5:                             \
1803         case PROCESSOR_EV6:                             \
1804           return COSTS_N_INSNS (4);                     \
1805         default: abort();                               \
1806         }                                               \
1807     else if (GET_CODE (XEXP (X, 0)) == MULT             \
1808              && const48_operand (XEXP (XEXP (X, 0), 1), VOIDmode)) \
1809       return (2 + rtx_cost (XEXP (XEXP (X, 0), 0), OUTER_CODE)  \
1810               + rtx_cost (XEXP (X, 1), OUTER_CODE));    \
1811     break;                                              \
1812   case MULT:                                            \
1813     switch (alpha_cpu)                                  \
1814       {                                                 \
1815       case PROCESSOR_EV4:                               \
1816         if (FLOAT_MODE_P (GET_MODE (X)))                \
1817           return COSTS_N_INSNS (6);                     \
1818         return COSTS_N_INSNS (23);                      \
1819       case PROCESSOR_EV5:                               \
1820         if (FLOAT_MODE_P (GET_MODE (X)))                \
1821           return COSTS_N_INSNS (4);                     \
1822         else if (GET_MODE (X) == DImode)                \
1823           return COSTS_N_INSNS (12);                    \
1824         else                                            \
1825           return COSTS_N_INSNS (8);                     \
1826       case PROCESSOR_EV6:                               \
1827         if (FLOAT_MODE_P (GET_MODE (X)))                \
1828           return COSTS_N_INSNS (4);                     \
1829         else                                            \
1830           return COSTS_N_INSNS (7);                     \
1831       default: abort();                                 \
1832       }                                                 \
1833   case ASHIFT:                                          \
1834     if (GET_CODE (XEXP (X, 1)) == CONST_INT             \
1835         && INTVAL (XEXP (X, 1)) <= 3)                   \
1836       break;                                            \
1837     /* ... fall through ... */                          \
1838   case ASHIFTRT:  case LSHIFTRT:                        \
1839     switch (alpha_cpu)                                  \
1840       {                                                 \
1841       case PROCESSOR_EV4:                               \
1842         return COSTS_N_INSNS (2);                       \
1843       case PROCESSOR_EV5:                               \
1844       case PROCESSOR_EV6:                               \
1845         return COSTS_N_INSNS (1);                       \
1846       default: abort();                                 \
1847       }                                                 \
1848   case IF_THEN_ELSE:                                    \
1849     switch (alpha_cpu)                                  \
1850       {                                                 \
1851       case PROCESSOR_EV4:                               \
1852       case PROCESSOR_EV6:                               \
1853         return COSTS_N_INSNS (2);                       \
1854       case PROCESSOR_EV5:                               \
1855         return COSTS_N_INSNS (1);                       \
1856       default: abort();                                 \
1857       }                                                 \
1858   case DIV:  case UDIV:  case MOD:  case UMOD:          \
1859     switch (alpha_cpu)                                  \
1860       {                                                 \
1861       case PROCESSOR_EV4:                               \
1862         if (GET_MODE (X) == SFmode)                     \
1863           return COSTS_N_INSNS (34);                    \
1864         else if (GET_MODE (X) == DFmode)                \
1865           return COSTS_N_INSNS (63);                    \
1866         else                                            \
1867           return COSTS_N_INSNS (70);                    \
1868       case PROCESSOR_EV5:                               \
1869         if (GET_MODE (X) == SFmode)                     \
1870           return COSTS_N_INSNS (15);                    \
1871         else if (GET_MODE (X) == DFmode)                \
1872           return COSTS_N_INSNS (22);                    \
1873         else                                            \
1874           return COSTS_N_INSNS (70);    /* ??? */       \
1875       case PROCESSOR_EV6:                               \
1876         if (GET_MODE (X) == SFmode)                     \
1877           return COSTS_N_INSNS (12);                    \
1878         else if (GET_MODE (X) == DFmode)                \
1879           return COSTS_N_INSNS (15);                    \
1880         else                                            \
1881           return COSTS_N_INSNS (70);    /* ??? */       \
1882       default: abort();                                 \
1883       }                                                 \
1884   case MEM:                                             \
1885     switch (alpha_cpu)                                  \
1886       {                                                 \
1887       case PROCESSOR_EV4:                               \
1888       case PROCESSOR_EV6:                               \
1889         return COSTS_N_INSNS (3);                       \
1890       case PROCESSOR_EV5:                               \
1891         return COSTS_N_INSNS (2);                       \
1892       default: abort();                                 \
1893       }                                                 \
1894   case NEG:  case ABS:                                  \
1895     if (! FLOAT_MODE_P (GET_MODE (X)))                  \
1896       break;                                            \
1897     /* ... fall through ... */                          \
1898   case FLOAT:  case UNSIGNED_FLOAT:  case FIX:  case UNSIGNED_FIX: \
1899   case FLOAT_EXTEND:  case FLOAT_TRUNCATE:              \
1900     switch (alpha_cpu)                                  \
1901       {                                                 \
1902       case PROCESSOR_EV4:                               \
1903         return COSTS_N_INSNS (6);                       \
1904       case PROCESSOR_EV5:                               \
1905       case PROCESSOR_EV6:                               \
1906         return COSTS_N_INSNS (4);                       \
1907       default: abort();                                 \
1908       }
1909 \f
1910 /* Control the assembler format that we output.  */
1911
1912 /* Output to assembler file text saying following lines
1913    may contain character constants, extra white space, comments, etc.  */
1914
1915 #define ASM_APP_ON ""
1916
1917 /* Output to assembler file text saying following lines
1918    no longer contain unusual constructs.  */
1919
1920 #define ASM_APP_OFF ""
1921
1922 #define TEXT_SECTION_ASM_OP "\t.text"
1923
1924 /* Output before read-only data.  */
1925
1926 #define READONLY_DATA_SECTION_ASM_OP "\t.rdata"
1927
1928 /* Output before writable data.  */
1929
1930 #define DATA_SECTION_ASM_OP "\t.data"
1931
1932 /* Define an extra section for read-only data, a routine to enter it, and
1933    indicate that it is for read-only data.
1934
1935    The first time we enter the readonly data section for a file, we write
1936    eight bytes of zero.  This works around a bug in DEC's assembler in
1937    some versions of OSF/1 V3.x.  */
1938
1939 #define EXTRA_SECTIONS  readonly_data
1940
1941 #define EXTRA_SECTION_FUNCTIONS                                 \
1942 void                                                            \
1943 literal_section ()                                              \
1944 {                                                               \
1945   if (in_section != readonly_data)                              \
1946     {                                                           \
1947       static int firsttime = 1;                                 \
1948                                                                 \
1949       fprintf (asm_out_file, "%s\n", READONLY_DATA_SECTION_ASM_OP); \
1950       if (firsttime)                                            \
1951         {                                                       \
1952           firsttime = 0;                                        \
1953           ASM_OUTPUT_DOUBLE_INT (asm_out_file, const0_rtx);     \
1954         }                                                       \
1955                                                                 \
1956       in_section = readonly_data;                               \
1957     }                                                           \
1958 }                                                               \
1959
1960 #define READONLY_DATA_SECTION   literal_section
1961
1962 /* If we are referencing a function that is static, make the SYMBOL_REF
1963    special.  We use this to see indicate we can branch to this function
1964    without setting PV or restoring GP.  */
1965
1966 #define ENCODE_SECTION_INFO(DECL)  \
1967   if (TREE_CODE (DECL) == FUNCTION_DECL && ! TREE_PUBLIC (DECL)) \
1968     SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1;
1969
1970 /* How to refer to registers in assembler output.
1971    This sequence is indexed by compiler's hard-register-number (see above).  */
1972
1973 #define REGISTER_NAMES                                          \
1974 {"$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8",          \
1975  "$9", "$10", "$11", "$12", "$13", "$14", "$15",                \
1976  "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",        \
1977  "$24", "$25", "$26", "$27", "$28", "$29", "$30", "AP",         \
1978  "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7", "$f8", \
1979  "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",         \
1980  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",\
1981  "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "FP"}
1982
1983 /* How to renumber registers for dbx and gdb.  */
1984
1985 #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
1986
1987 /* This is how to output the definition of a user-level label named NAME,
1988    such as the label on a static function or variable NAME.  */
1989
1990 #define ASM_OUTPUT_LABEL(FILE,NAME)     \
1991   do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
1992
1993 /* This is how to output a command to make the user-level label named NAME
1994    defined for reference from other files.  */
1995
1996 #define ASM_GLOBALIZE_LABEL(FILE,NAME)  \
1997   do { fputs ("\t.globl ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0)
1998
1999 /* The prefix to add to user-visible assembler symbols. */
2000
2001 #define USER_LABEL_PREFIX ""
2002
2003 /* This is how to output an internal numbered label where
2004    PREFIX is the class of label and NUM is the number within the class.  */
2005
2006 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)      \
2007   fprintf (FILE, "$%s%d:\n", PREFIX, NUM)
2008
2009 /* This is how to output a label for a jump table.  Arguments are the same as
2010    for ASM_OUTPUT_INTERNAL_LABEL, except the insn for the jump table is
2011    passed. */
2012
2013 #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLEINSN)        \
2014 { ASM_OUTPUT_ALIGN (FILE, 2); ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); }
2015
2016 /* This is how to store into the string LABEL
2017    the symbol_ref name of an internal numbered label where
2018    PREFIX is the class of label and NUM is the number within the class.
2019    This is suitable for output with `assemble_name'.  */
2020
2021 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
2022   sprintf ((LABEL), "*$%s%ld", (PREFIX), (long)(NUM))
2023
2024 /* Check a floating-point value for validity for a particular machine mode.  */
2025
2026 #define CHECK_FLOAT_VALUE(MODE, D, OVERFLOW) \
2027   ((OVERFLOW) = check_float_value (MODE, &D, OVERFLOW))
2028
2029 /* This is how to output an assembler line defining a `long double'
2030    constant.  */
2031
2032 #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)                              \
2033   do {                                                                  \
2034     long t[4];                                                          \
2035     REAL_VALUE_TO_TARGET_LONG_DOUBLE ((VALUE), t);                      \
2036     fprintf (FILE, "\t.quad 0x%lx%08lx,0x%lx%08lx\n",                   \
2037              t[1] & 0xffffffff, t[0] & 0xffffffff,                      \
2038              t[3] & 0xffffffff, t[2] & 0xffffffff);                     \
2039   } while (0)
2040
2041 /* This is how to output an assembler line defining a `double' constant.  */
2042
2043 #define ASM_OUTPUT_DOUBLE(FILE,VALUE)                                   \
2044   do {                                                                  \
2045     long t[2];                                                          \
2046     REAL_VALUE_TO_TARGET_DOUBLE ((VALUE), t);                           \
2047     fprintf (FILE, "\t.quad 0x%lx%08lx\n",                              \
2048              t[1] & 0xffffffff, t[0] & 0xffffffff);                     \
2049   } while (0)
2050
2051 /* This is how to output an assembler line defining a `float' constant.  */
2052
2053 #define ASM_OUTPUT_FLOAT(FILE,VALUE)                            \
2054   do {                                                          \
2055     long t;                                                     \
2056     REAL_VALUE_TO_TARGET_SINGLE ((VALUE), t);                   \
2057     fprintf (FILE, "\t.long 0x%lx\n", t & 0xffffffff);          \
2058   } while (0)
2059   
2060 /* This is how to output an assembler line defining an `int' constant.  */
2061
2062 #define ASM_OUTPUT_INT(FILE,VALUE)              \
2063 ( fprintf (FILE, "\t.long "),                   \
2064   output_addr_const (FILE, (VALUE)),            \
2065   fprintf (FILE, "\n"))
2066
2067 /* This is how to output an assembler line defining a `long' constant.  */
2068
2069 #define ASM_OUTPUT_DOUBLE_INT(FILE,VALUE)       \
2070 ( fprintf (FILE, "\t.quad "),                   \
2071   output_addr_const (FILE, (VALUE)),            \
2072   fprintf (FILE, "\n"))
2073
2074 /* Likewise for `char' and `short' constants.  */
2075
2076 #define ASM_OUTPUT_SHORT(FILE,VALUE)  \
2077   fprintf (FILE, "\t.word %d\n",                \
2078     (int)(GET_CODE (VALUE) == CONST_INT         \
2079      ? INTVAL (VALUE) & 0xffff : (abort (), 0)))
2080
2081 #define ASM_OUTPUT_CHAR(FILE,VALUE)             \
2082   fprintf (FILE, "\t.byte %d\n",                \
2083     (int)(GET_CODE (VALUE) == CONST_INT         \
2084      ? INTVAL (VALUE) & 0xff : (abort (), 0)))
2085
2086 /* We use the default ASCII-output routine, except that we don't write more
2087    than 50 characters since the assembler doesn't support very long lines.  */
2088
2089 #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \
2090   do {                                                                        \
2091     FILE *_hide_asm_out_file = (MYFILE);                                      \
2092     const unsigned char *_hide_p = (const unsigned char *) (MYSTRING);        \
2093     int _hide_thissize = (MYLENGTH);                                          \
2094     int _size_so_far = 0;                                                     \
2095     {                                                                         \
2096       FILE *asm_out_file = _hide_asm_out_file;                                \
2097       const unsigned char *p = _hide_p;                                       \
2098       int thissize = _hide_thissize;                                          \
2099       int i;                                                                  \
2100       fprintf (asm_out_file, "\t.ascii \"");                                  \
2101                                                                               \
2102       for (i = 0; i < thissize; i++)                                          \
2103         {                                                                     \
2104           register int c = p[i];                                              \
2105                                                                               \
2106           if (_size_so_far ++ > 50 && i < thissize - 4)                       \
2107             _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \"");      \
2108                                                                               \
2109           if (c == '\"' || c == '\\')                                         \
2110             putc ('\\', asm_out_file);                                        \
2111           if (c >= ' ' && c < 0177)                                           \
2112             putc (c, asm_out_file);                                           \
2113           else                                                                \
2114             {                                                                 \
2115               fprintf (asm_out_file, "\\%o", c);                              \
2116               /* After an octal-escape, if a digit follows,                   \
2117                  terminate one string constant and start another.             \
2118                  The Vax assembler fails to stop reading the escape           \
2119                  after three digits, so this is the only way we               \
2120                  can get it to parse the data properly.  */                   \
2121               if (i < thissize - 1                                            \
2122                   && p[i + 1] >= '0' && p[i + 1] <= '9')                      \
2123                 _size_so_far = 0, fprintf (asm_out_file, "\"\n\t.ascii \"");  \
2124           }                                                                   \
2125         }                                                                     \
2126       fprintf (asm_out_file, "\"\n");                                         \
2127     }                                                                         \
2128   }                                                                           \
2129   while (0)
2130
2131 /* To get unaligned data, we have to turn off auto alignment.  */
2132 #define UNALIGNED_SHORT_ASM_OP          "\t.align 0\n\t.word\t"
2133 #define UNALIGNED_INT_ASM_OP            "\t.align 0\n\t.long\t"
2134 #define UNALIGNED_DOUBLE_INT_ASM_OP     "\t.align 0\n\t.quad\t"
2135
2136 /* This is how to output an insn to push a register on the stack.
2137    It need not be very fast code.  */
2138
2139 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)                                 \
2140  fprintf (FILE, "\tsubq $30,8,$30\n\tst%s $%s%d,0($30)\n",              \
2141           (REGNO) > 32 ? "t" : "q", (REGNO) > 32 ? "f" : "",            \
2142           (REGNO) & 31);
2143
2144 /* This is how to output an insn to pop a register from the stack.
2145    It need not be very fast code.  */
2146
2147 #define ASM_OUTPUT_REG_POP(FILE,REGNO)                                  \
2148   fprintf (FILE, "\tld%s $%s%d,0($30)\n\taddq $30,8,$30\n",             \
2149           (REGNO) > 32 ? "t" : "q", (REGNO) > 32 ? "f" : "",            \
2150           (REGNO) & 31);
2151
2152 /* This is how to output an assembler line for a numeric constant byte.  */
2153
2154 #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
2155   fprintf (FILE, "\t.byte 0x%x\n", (int) ((VALUE) & 0xff))
2156
2157 /* This is how to output an element of a case-vector that is absolute.
2158    (Alpha does not use such vectors, but we must define this macro anyway.)  */
2159
2160 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) abort ()
2161
2162 /* This is how to output an element of a case-vector that is relative.  */
2163
2164 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
2165   fprintf (FILE, "\t.%s $L%d\n", TARGET_WINDOWS_NT ? "long" : "gprel32", \
2166            (VALUE))
2167
2168 /* This is how to output an assembler line
2169    that says to advance the location counter
2170    to a multiple of 2**LOG bytes.  */
2171
2172 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
2173   if ((LOG) != 0)                       \
2174     fprintf (FILE, "\t.align %d\n", LOG);
2175
2176 /* This is how to advance the location counter by SIZE bytes.  */
2177
2178 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
2179   fprintf (FILE, "\t.space %d\n", (SIZE))
2180
2181 /* This says how to output an assembler line
2182    to define a global common symbol.  */
2183
2184 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
2185 ( fputs ("\t.comm ", (FILE)),                   \
2186   assemble_name ((FILE), (NAME)),               \
2187   fprintf ((FILE), ",%d\n", (SIZE)))
2188
2189 /* This says how to output an assembler line
2190    to define a local common symbol.  */
2191
2192 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE,ROUNDED)      \
2193 ( fputs ("\t.lcomm ", (FILE)),                          \
2194   assemble_name ((FILE), (NAME)),                       \
2195   fprintf ((FILE), ",%d\n", (SIZE)))
2196
2197 /* Store in OUTPUT a string (made with alloca) containing
2198    an assembler-name for a local static variable named NAME.
2199    LABELNO is an integer which is different for each call.  */
2200
2201 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
2202 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
2203   sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
2204
2205 /* Define the parentheses used to group arithmetic operations
2206    in assembler code.  */
2207
2208 #define ASM_OPEN_PAREN "("
2209 #define ASM_CLOSE_PAREN ")"
2210
2211 /* Output code to add DELTA to the first argument, and then jump to FUNCTION.
2212    Used for C++ multiple inheritance.  */
2213 /* ??? This is only used with the v2 ABI, and alpha.c makes assumptions
2214    about current_function_is_thunk that are not valid with the v3 ABI.  */
2215 #if 0
2216 #define ASM_OUTPUT_MI_THUNK(FILE, THUNK_FNDECL, DELTA, FUNCTION)        \
2217 do {                                                                    \
2218   const char *fn_name = XSTR (XEXP (DECL_RTL (FUNCTION), 0), 0);        \
2219   int reg;                                                              \
2220                                                                         \
2221   if (! TARGET_OPEN_VMS && ! TARGET_WINDOWS_NT)                         \
2222     fprintf (FILE, "\tldgp $29,0($27)\n");                              \
2223                                                                         \
2224   /* Mark end of prologue.  */                                          \
2225   output_end_prologue (FILE);                                           \
2226                                                                         \
2227   /* Rely on the assembler to macro expand a large delta.  */           \
2228   fprintf (FILE, "\t.set at\n");                                        \
2229   reg = aggregate_value_p (TREE_TYPE (TREE_TYPE (FUNCTION))) ? 17 : 16; \
2230   fprintf (FILE, "\tlda $%d,%ld($%d)\n", reg, (long)(DELTA), reg);      \
2231                                                                         \
2232   if (current_file_function_operand (XEXP (DECL_RTL (FUNCTION), 0),     \
2233                                      VOIDmode))                         \
2234     {                                                                   \
2235       fprintf (FILE, "\tbr $31,$");                                     \
2236       assemble_name (FILE, fn_name);                                    \
2237       fprintf (FILE, "..ng\n");                                         \
2238     }                                                                   \
2239   else                                                                  \
2240     {                                                                   \
2241       fprintf (FILE, "\tjmp $31,");                                     \
2242       assemble_name (FILE, fn_name);                                    \
2243       fputc ('\n', FILE);                                               \
2244     }                                                                   \
2245   fprintf (FILE, "\t.set noat\n");                                      \
2246 } while (0)
2247 #endif
2248 \f
2249
2250 /* Define results of standard character escape sequences.  */
2251 #define TARGET_BELL 007
2252 #define TARGET_BS 010
2253 #define TARGET_TAB 011
2254 #define TARGET_NEWLINE 012
2255 #define TARGET_VT 013
2256 #define TARGET_FF 014
2257 #define TARGET_CR 015
2258
2259 /* Print operand X (an rtx) in assembler syntax to file FILE.
2260    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
2261    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
2262
2263 #define PRINT_OPERAND(FILE, X, CODE)  print_operand (FILE, X, CODE)
2264
2265 /* Determine which codes are valid without a following integer.  These must
2266    not be alphabetic.
2267
2268    ~    Generates the name of the current function.
2269
2270    &    Generates fp-rounding mode suffix: nothing for normal, 'c' for
2271         chopped, 'm' for minus-infinity, and 'd' for dynamic rounding
2272         mode.  alpha_fprm controls which suffix is generated.
2273
2274    '    Generates trap-mode suffix for instructions that accept the
2275         su suffix only (cmpt et al).
2276
2277    `    Generates trap-mode suffix for instructions that accept the
2278         v and sv suffix.  The only instruction that needs this is cvtql.
2279
2280    (    Generates trap-mode suffix for instructions that accept the
2281         v, sv, and svi suffix.  The only instruction that needs this
2282         is cvttq.
2283
2284    )    Generates trap-mode suffix for instructions that accept the
2285         u, su, and sui suffix.  This is the bulk of the IEEE floating
2286         point instructions (addt et al).
2287
2288    +    Generates trap-mode suffix for instructions that accept the
2289         sui suffix (cvtqt and cvtqs).
2290
2291    ,    Generates single precision suffix for floating point
2292         instructions (s for IEEE, f for VAX)
2293
2294    -    Generates double precision suffix for floating point
2295         instructions (t for IEEE, g for VAX)
2296    */
2297
2298 #define PRINT_OPERAND_PUNCT_VALID_P(CODE)                               \
2299   ((CODE) == '&' || (CODE) == '`' || (CODE) == '\'' || (CODE) == '('    \
2300    || (CODE) == ')' || (CODE) == '+' || (CODE) == ',' || (CODE) == '-'  \
2301    || (CODE) == '~')
2302 \f
2303 /* Print a memory address as an operand to reference that memory location.  */
2304
2305 #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
2306   print_operand_address((FILE), (ADDR))
2307
2308 /* Define the codes that are matched by predicates in alpha.c.  */
2309
2310 #define PREDICATE_CODES                                                 \
2311   {"reg_or_0_operand", {SUBREG, REG, CONST_INT}},                       \
2312   {"reg_or_6bit_operand", {SUBREG, REG, CONST_INT}},                    \
2313   {"reg_or_8bit_operand", {SUBREG, REG, CONST_INT}},                    \
2314   {"cint8_operand", {CONST_INT}},                                       \
2315   {"reg_or_cint_operand", {SUBREG, REG, CONST_INT}},                    \
2316   {"add_operand", {SUBREG, REG, CONST_INT}},                            \
2317   {"sext_add_operand", {SUBREG, REG, CONST_INT}},                       \
2318   {"const48_operand", {CONST_INT}},                                     \
2319   {"and_operand", {SUBREG, REG, CONST_INT}},                            \
2320   {"or_operand", {SUBREG, REG, CONST_INT}},                             \
2321   {"mode_mask_operand", {CONST_INT}},                                   \
2322   {"mul8_operand", {CONST_INT}},                                        \
2323   {"mode_width_operand", {CONST_INT}},                                  \
2324   {"reg_or_fp0_operand", {SUBREG, REG, CONST_DOUBLE}},                  \
2325   {"alpha_comparison_operator", {EQ, LE, LT, LEU, LTU}},                \
2326   {"alpha_zero_comparison_operator", {EQ, NE, LE, LT, LEU, LTU}},       \
2327   {"alpha_swapped_comparison_operator", {EQ, GE, GT, GEU, GTU}},        \
2328   {"signed_comparison_operator", {EQ, NE, LE, LT, GE, GT}},             \
2329   {"alpha_fp_comparison_operator", {EQ, LE, LT, UNORDERED}},            \
2330   {"divmod_operator", {DIV, MOD, UDIV, UMOD}},                          \
2331   {"fp0_operand", {CONST_DOUBLE}},                                      \
2332   {"current_file_function_operand", {SYMBOL_REF}},                      \
2333   {"call_operand", {REG, SYMBOL_REF}},                                  \
2334   {"input_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE,         \
2335                      SYMBOL_REF, CONST, LABEL_REF}},                    \
2336   {"some_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE,          \
2337                     SYMBOL_REF, CONST, LABEL_REF}},                     \
2338   {"some_ni_operand", {SUBREG, REG, MEM}},                              \
2339   {"aligned_memory_operand", {MEM}},                                    \
2340   {"unaligned_memory_operand", {MEM}},                                  \
2341   {"reg_or_unaligned_mem_operand", {SUBREG, REG, MEM}},                 \
2342   {"any_memory_operand", {MEM}},                                        \
2343   {"hard_fp_register_operand", {SUBREG, REG}},                          \
2344   {"hard_int_register_operand", {SUBREG, REG}},                         \
2345   {"reg_not_elim_operand", {SUBREG, REG}},                              \
2346   {"reg_no_subreg_operand", {REG}},                                     \
2347   {"addition_operation", {PLUS}},
2348 \f
2349 /* Define the `__builtin_va_list' type for the ABI.  */
2350 #define BUILD_VA_LIST_TYPE(VALIST) \
2351   (VALIST) = alpha_build_va_list ()
2352
2353 /* Implement `va_start' for varargs and stdarg.  */
2354 #define EXPAND_BUILTIN_VA_START(stdarg, valist, nextarg) \
2355   alpha_va_start (stdarg, valist, nextarg)
2356
2357 /* Implement `va_arg'.  */
2358 #define EXPAND_BUILTIN_VA_ARG(valist, type) \
2359   alpha_va_arg (valist, type)
2360 \f
2361 /* Tell collect that the object format is ECOFF.  */
2362 #define OBJECT_FORMAT_COFF
2363 #define EXTENDED_COFF
2364
2365 /* If we use NM, pass -g to it so it only lists globals.  */
2366 #define NM_FLAGS "-pg"
2367
2368 /* Definitions for debugging.  */
2369
2370 #define SDB_DEBUGGING_INFO              /* generate info for mips-tfile */
2371 #define DBX_DEBUGGING_INFO              /* generate embedded stabs */
2372 #define MIPS_DEBUGGING_INFO             /* MIPS specific debugging info */
2373
2374 #ifndef PREFERRED_DEBUGGING_TYPE        /* assume SDB_DEBUGGING_INFO */
2375 #define PREFERRED_DEBUGGING_TYPE  SDB_DEBUG
2376 #endif
2377
2378
2379 /* Correct the offset of automatic variables and arguments.  Note that
2380    the Alpha debug format wants all automatic variables and arguments
2381    to be in terms of two different offsets from the virtual frame pointer,
2382    which is the stack pointer before any adjustment in the function.
2383    The offset for the argument pointer is fixed for the native compiler,
2384    it is either zero (for the no arguments case) or large enough to hold
2385    all argument registers.
2386    The offset for the auto pointer is the fourth argument to the .frame
2387    directive (local_offset).
2388    To stay compatible with the native tools we use the same offsets
2389    from the virtual frame pointer and adjust the debugger arg/auto offsets
2390    accordingly. These debugger offsets are set up in output_prolog.  */
2391
2392 extern long alpha_arg_offset;
2393 extern long alpha_auto_offset;
2394 #define DEBUGGER_AUTO_OFFSET(X) \
2395   ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) + alpha_auto_offset)
2396 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + alpha_arg_offset)
2397
2398
2399 #define ASM_OUTPUT_SOURCE_LINE(STREAM, LINE)                            \
2400   alpha_output_lineno (STREAM, LINE)
2401
2402 #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME)                        \
2403   alpha_output_filename (STREAM, NAME)
2404
2405 /* mips-tfile.c limits us to strings of one page.  We must underestimate this
2406    number, because the real length runs past this up to the next
2407    continuation point.  This is really a dbxout.c bug.  */
2408 #define DBX_CONTIN_LENGTH 3000
2409
2410 /* By default, turn on GDB extensions.  */
2411 #define DEFAULT_GDB_EXTENSIONS 1
2412
2413 /* Stabs-in-ECOFF can't handle dbxout_function_end().  */
2414 #define NO_DBX_FUNCTION_END 1
2415
2416 /* If we are smuggling stabs through the ALPHA ECOFF object
2417    format, put a comment in front of the .stab<x> operation so
2418    that the ALPHA assembler does not choke.  The mips-tfile program
2419    will correctly put the stab into the object file.  */
2420
2421 #define ASM_STABS_OP    ((TARGET_GAS) ? "\t.stabs\t" : " #.stabs\t")
2422 #define ASM_STABN_OP    ((TARGET_GAS) ? "\t.stabn\t" : " #.stabn\t")
2423 #define ASM_STABD_OP    ((TARGET_GAS) ? "\t.stabd\t" : " #.stabd\t")
2424
2425 /* Forward references to tags are allowed.  */
2426 #define SDB_ALLOW_FORWARD_REFERENCES
2427
2428 /* Unknown tags are also allowed.  */
2429 #define SDB_ALLOW_UNKNOWN_REFERENCES
2430
2431 #define PUT_SDB_DEF(a)                                  \
2432 do {                                                    \
2433   fprintf (asm_out_file, "\t%s.def\t",                  \
2434            (TARGET_GAS) ? "" : "#");                    \
2435   ASM_OUTPUT_LABELREF (asm_out_file, a);                \
2436   fputc (';', asm_out_file);                            \
2437 } while (0)
2438
2439 #define PUT_SDB_PLAIN_DEF(a)                            \
2440 do {                                                    \
2441   fprintf (asm_out_file, "\t%s.def\t.%s;",              \
2442            (TARGET_GAS) ? "" : "#", (a));               \
2443 } while (0)
2444
2445 #define PUT_SDB_TYPE(a)                                 \
2446 do {                                                    \
2447   fprintf (asm_out_file, "\t.type\t0x%x;", (a));        \
2448 } while (0)
2449
2450 /* For block start and end, we create labels, so that
2451    later we can figure out where the correct offset is.
2452    The normal .ent/.end serve well enough for functions,
2453    so those are just commented out.  */
2454
2455 extern int sdb_label_count;             /* block start/end next label # */
2456
2457 #define PUT_SDB_BLOCK_START(LINE)                       \
2458 do {                                                    \
2459   fprintf (asm_out_file,                                \
2460            "$Lb%d:\n\t%s.begin\t$Lb%d\t%d\n",           \
2461            sdb_label_count,                             \
2462            (TARGET_GAS) ? "" : "#",                     \
2463            sdb_label_count,                             \
2464            (LINE));                                     \
2465   sdb_label_count++;                                    \
2466 } while (0)
2467
2468 #define PUT_SDB_BLOCK_END(LINE)                         \
2469 do {                                                    \
2470   fprintf (asm_out_file,                                \
2471            "$Le%d:\n\t%s.bend\t$Le%d\t%d\n",            \
2472            sdb_label_count,                             \
2473            (TARGET_GAS) ? "" : "#",                     \
2474            sdb_label_count,                             \
2475            (LINE));                                     \
2476   sdb_label_count++;                                    \
2477 } while (0)
2478
2479 #define PUT_SDB_FUNCTION_START(LINE)
2480
2481 #define PUT_SDB_FUNCTION_END(LINE)
2482
2483 #define PUT_SDB_EPILOGUE_END(NAME) ((void)(NAME))
2484
2485 /* Macros for mips-tfile.c to encapsulate stabs in ECOFF, and for
2486    mips-tdump.c to print them out.
2487
2488    These must match the corresponding definitions in gdb/mipsread.c.
2489    Unfortunately, gcc and gdb do not currently share any directories. */
2490
2491 #define CODE_MASK 0x8F300
2492 #define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK)
2493 #define MIPS_MARK_STAB(code) ((code)+CODE_MASK)
2494 #define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK)
2495
2496 /* Override some mips-tfile definitions.  */
2497
2498 #define SHASH_SIZE 511
2499 #define THASH_SIZE 55
2500
2501 /* Align ecoff symbol tables to avoid OSF1/1.3 nm complaints.  */
2502
2503 #define ALIGN_SYMTABLE_OFFSET(OFFSET) (((OFFSET) + 7) & ~7)
2504
2505 /* The system headers under Alpha systems are generally C++-aware.  */
2506 #define NO_IMPLICIT_EXTERN_C
2507
2508 /* Generate calls to memcpy, etc., not bcopy, etc. */
2509 #define TARGET_MEM_FUNCTIONS 1