OSDN Git Service

450775910efaa7eacf6c798e2617bc027fa93eaa
[pf3gnuchains/gcc-fork.git] / gcc / config / pa / pa.h
1 /* Definitions of target machine for GNU compiler, for the HP Spectrum.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3    2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4    Contributed by Michael Tiemann (tiemann@cygnus.com) of Cygnus Support
5    and Tim Moore (moore@defmacro.cs.utah.edu) of the Center for
6    Software Science at the University of Utah.
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 GCC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING.  If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA.  */
24
25 enum cmp_type                           /* comparison type */
26 {
27   CMP_SI,                               /* compare integers */
28   CMP_SF,                               /* compare single precision floats */
29   CMP_DF,                               /* compare double precision floats */
30   CMP_MAX                               /* max comparison type */
31 };
32
33 /* For long call handling.  */
34 extern unsigned long total_code_bytes;
35
36 /* Which processor to schedule for.  */
37
38 enum processor_type
39 {
40   PROCESSOR_700,
41   PROCESSOR_7100,
42   PROCESSOR_7100LC,
43   PROCESSOR_7200,
44   PROCESSOR_7300,
45   PROCESSOR_8000
46 };
47
48 /* Which architecture to generate code for.  */
49
50 enum architecture_type
51 {
52   ARCHITECTURE_10,
53   ARCHITECTURE_11,
54   ARCHITECTURE_20
55 };
56
57 struct rtx_def;
58
59 /* For -march= option.  */
60 extern const char *pa_arch_string;
61 extern enum architecture_type pa_arch;
62
63 /* For -mfixed-range= option.  */
64 extern const char *pa_fixed_range_string;
65
66 /* For -mschedule= option.  */
67 extern const char *pa_cpu_string;
68 extern enum processor_type pa_cpu;
69
70 /* For -munix= option.  */
71 extern const char *pa_unix_string;
72 extern int flag_pa_unix;
73
74 #define pa_cpu_attr ((enum attr_cpu)pa_cpu)
75
76 /* Print subsidiary information on the compiler version in use.  */
77
78 #define TARGET_VERSION fputs (" (hppa)", stderr);
79
80 /* Run-time compilation parameters selecting different hardware subsets.  */
81
82 extern int target_flags;
83
84 /* compile code for HP-PA 1.1 ("Snake").  */
85
86 #define MASK_PA_11 1
87
88 /* Disable all FP registers (they all become fixed).  This may be necessary
89    for compiling kernels which perform lazy context switching of FP regs.
90    Note if you use this option and try to perform floating point operations
91    the compiler will abort!  */
92
93 #define MASK_DISABLE_FPREGS 2
94 #define TARGET_DISABLE_FPREGS (target_flags & MASK_DISABLE_FPREGS)
95
96 /* Generate code which assumes that all space register are equivalent.
97    Triggers aggressive unscaled index addressing and faster
98    builtin_return_address.  */
99 #define MASK_NO_SPACE_REGS 4
100 #define TARGET_NO_SPACE_REGS (target_flags & MASK_NO_SPACE_REGS)
101
102 /* Allow unconditional jumps in the delay slots of call instructions.  */
103 #define MASK_JUMP_IN_DELAY 8
104 #define TARGET_JUMP_IN_DELAY (target_flags & MASK_JUMP_IN_DELAY)
105
106 /* Disable indexed addressing modes.  */
107 #define MASK_DISABLE_INDEXING 32
108 #define TARGET_DISABLE_INDEXING (target_flags & MASK_DISABLE_INDEXING)
109
110 /* Emit code which follows the new portable runtime calling conventions
111    HP wants everyone to use for ELF objects.  If at all possible you want
112    to avoid this since it's a performance loss for non-prototyped code.
113
114    Note TARGET_PORTABLE_RUNTIME also forces all calls to use inline
115    long-call stubs which is quite expensive.  */
116 #define MASK_PORTABLE_RUNTIME 64
117 #define TARGET_PORTABLE_RUNTIME (target_flags & MASK_PORTABLE_RUNTIME)
118
119 /* Emit directives only understood by GAS.  This allows parameter
120    relocations to work for static functions.  There is no way
121    to make them work the HP assembler at this time.  */
122 #define MASK_GAS 128
123 #define TARGET_GAS (target_flags & MASK_GAS)
124
125 /* Emit code for processors which do not have an FPU.  */
126 #define MASK_SOFT_FLOAT 256
127 #define TARGET_SOFT_FLOAT (target_flags & MASK_SOFT_FLOAT)
128
129 /* Use 3-insn load/store sequences for access to large data segments
130    in shared libraries on hpux10.  */
131 #define MASK_LONG_LOAD_STORE 512
132 #define TARGET_LONG_LOAD_STORE (target_flags & MASK_LONG_LOAD_STORE)
133
134 /* Use a faster sequence for indirect calls.  This assumes that calls
135    through function pointers will never cross a space boundary, and
136    that the executable is not dynamically linked.  Such assumptions
137    are generally safe for building kernels and statically linked
138    executables.  Code compiled with this option will fail miserably if
139    the executable is dynamically linked or uses nested functions!  */
140 #define MASK_FAST_INDIRECT_CALLS 1024
141 #define TARGET_FAST_INDIRECT_CALLS (target_flags & MASK_FAST_INDIRECT_CALLS)
142
143 /* Generate code with big switch statements to avoid out of range branches
144    occurring within the switch table.  */
145 #define MASK_BIG_SWITCH 2048
146 #define TARGET_BIG_SWITCH (target_flags & MASK_BIG_SWITCH)
147
148 /* Generate code for the HPPA 2.0 architecture.  TARGET_PA_11 should also be
149    true when this is true.  */
150 #define MASK_PA_20 4096
151
152 /* Generate cpp defines for server I/O.  */
153 #define MASK_SIO 8192
154 #define TARGET_SIO (target_flags & MASK_SIO)
155
156 /* Assume GNU linker by default.  */
157 #define MASK_GNU_LD 16384
158 #ifndef TARGET_GNU_LD
159 #define TARGET_GNU_LD (target_flags & MASK_GNU_LD)
160 #endif
161
162 /* Force generation of long calls.  */
163 #define MASK_LONG_CALLS 32768
164 #ifndef TARGET_LONG_CALLS
165 #define TARGET_LONG_CALLS (target_flags & MASK_LONG_CALLS)
166 #endif
167
168 #ifndef TARGET_PA_10
169 #define TARGET_PA_10 (target_flags & (MASK_PA_11 | MASK_PA_20) == 0)
170 #endif
171
172 #ifndef TARGET_PA_11
173 #define TARGET_PA_11 (target_flags & MASK_PA_11)
174 #endif
175
176 #ifndef TARGET_PA_20
177 #define TARGET_PA_20 (target_flags & MASK_PA_20)
178 #endif
179
180 /* Generate code for the HPPA 2.0 architecture in 64bit mode.  */
181 #ifndef TARGET_64BIT
182 #define TARGET_64BIT 0
183 #endif
184
185 /* Generate code for ELF32 ABI.  */
186 #ifndef TARGET_ELF32
187 #define TARGET_ELF32 0
188 #endif
189
190 /* Generate code for SOM 32bit ABI.  */
191 #ifndef TARGET_SOM
192 #define TARGET_SOM 0
193 #endif
194
195 /* HP-UX UNIX features.  */
196 #ifndef TARGET_HPUX
197 #define TARGET_HPUX 0
198 #endif
199
200 /* HP-UX 10.10 UNIX 95 features.  */
201 #ifndef TARGET_HPUX_10_10
202 #define TARGET_HPUX_10_10 0
203 #endif
204
205 /* HP-UX 11i multibyte and UNIX 98 extensions.  */
206 #ifndef TARGET_HPUX_11_11
207 #define TARGET_HPUX_11_11 0
208 #endif
209
210 /* The following three defines are potential target switches.  The current
211    defines are optimal given the current capabilities of GAS and GNU ld.  */
212
213 /* Define to a C expression evaluating to true to use long absolute calls.
214    Currently, only the HP assembler and SOM linker support long absolute
215    calls.  They are used only in non-pic code.  */
216 #define TARGET_LONG_ABS_CALL (TARGET_SOM && !TARGET_GAS)
217
218 /* Define to a C expression evaluating to true to use long pic symbol
219    difference calls.  This is a call variant similar to the long pic
220    pc-relative call.  Long pic symbol difference calls are only used with
221    the HP SOM linker.  Currently, only the HP assembler supports these
222    calls.  GAS doesn't allow an arbitrary difference of two symbols.  */
223 #define TARGET_LONG_PIC_SDIFF_CALL (!TARGET_GAS)
224
225 /* Define to a C expression evaluating to true to use long pic
226    pc-relative calls.  Long pic pc-relative calls are only used with
227    GAS.  Currently, they are usable for calls within a module but
228    not for external calls.  */
229 #define TARGET_LONG_PIC_PCREL_CALL 0
230
231 /* Define to a C expression evaluating to true to use SOM secondary
232    definition symbols for weak support.  Linker support for secondary
233    definition symbols is buggy prior to HP-UX 11.X.  */
234 #define TARGET_SOM_SDEF 0
235
236 /* Define to a C expression evaluating to true to save the entry value
237    of SP in the current frame marker.  This is normally unnecessary.
238    However, the HP-UX unwind library looks at the SAVE_SP callinfo flag.
239    HP compilers don't use this flag but it is supported by the assembler.
240    We set this flag to indicate that register %r3 has been saved at the
241    start of the frame.  Thus, when the HP unwind library is used, we
242    need to generate additional code to save SP into the frame marker.  */
243 #define TARGET_HPUX_UNWIND_LIBRARY 0
244
245 /* Macro to define tables used to set the flags.  This is a
246    list in braces of target switches with each switch being
247    { "NAME", VALUE, "HELP_STRING" }.  VALUE is the bits to set,
248    or minus the bits to clear.  An empty string NAME is used to
249    identify the default VALUE.  Do not mark empty strings for
250    translation.  */
251
252 #define TARGET_SWITCHES \
253   {{ "snake",                    MASK_PA_11,                            \
254      N_("Generate PA1.1 code") },                                       \
255    { "nosnake",                 -(MASK_PA_11 | MASK_PA_20),             \
256      N_("Generate PA1.0 code") },                                       \
257    { "pa-risc-1-0",             -(MASK_PA_11 | MASK_PA_20),             \
258      N_("Generate PA1.0 code") },                                       \
259    { "pa-risc-1-1",              MASK_PA_11,                            \
260      N_("Generate PA1.1 code") },                                       \
261    { "pa-risc-2-0",              MASK_PA_20,                            \
262      N_("Generate PA2.0 code (requires binutils 2.10 or later)") },     \
263    { "disable-fpregs",           MASK_DISABLE_FPREGS,                   \
264      N_("Disable FP regs") },                                           \
265    { "no-disable-fpregs",       -MASK_DISABLE_FPREGS,                   \
266      N_("Do not disable FP regs") },                                    \
267    { "no-space-regs",            MASK_NO_SPACE_REGS,                    \
268      N_("Disable space regs") },                                        \
269    { "space-regs",              -MASK_NO_SPACE_REGS,                    \
270      N_("Do not disable space regs") },                                 \
271    { "jump-in-delay",            MASK_JUMP_IN_DELAY,                    \
272      N_("Put jumps in call delay slots") },                             \
273    { "no-jump-in-delay",        -MASK_JUMP_IN_DELAY,                    \
274      N_("Do not put jumps in call delay slots") },                      \
275    { "disable-indexing",         MASK_DISABLE_INDEXING,                 \
276      N_("Disable indexed addressing") },                                \
277    { "no-disable-indexing",     -MASK_DISABLE_INDEXING,                 \
278      N_("Do not disable indexed addressing") },                         \
279    { "portable-runtime",         MASK_PORTABLE_RUNTIME,                 \
280      N_("Use portable calling conventions") },                          \
281    { "no-portable-runtime",     -MASK_PORTABLE_RUNTIME,                 \
282      N_("Do not use portable calling conventions") },                   \
283    { "gas",                      MASK_GAS,                              \
284      N_("Assume code will be assembled by GAS") },                      \
285    { "no-gas",                  -MASK_GAS,                              \
286      N_("Do not assume code will be assembled by GAS") },               \
287    { "soft-float",               MASK_SOFT_FLOAT,                       \
288      N_("Use software floating point") },                               \
289    { "no-soft-float",           -MASK_SOFT_FLOAT,                       \
290      N_("Do not use software floating point") },                        \
291    { "long-load-store",          MASK_LONG_LOAD_STORE,                  \
292      N_("Emit long load/store sequences") },                            \
293    { "no-long-load-store",      -MASK_LONG_LOAD_STORE,                  \
294      N_("Do not emit long load/store sequences") },                     \
295    { "fast-indirect-calls",      MASK_FAST_INDIRECT_CALLS,              \
296      N_("Generate fast indirect calls") },                              \
297    { "no-fast-indirect-calls",  -MASK_FAST_INDIRECT_CALLS,              \
298      N_("Do not generate fast indirect calls") },                       \
299    { "big-switch",               MASK_BIG_SWITCH,                       \
300      N_("Generate code for huge switch statements") },                  \
301    { "no-big-switch",           -MASK_BIG_SWITCH,                       \
302      N_("Do not generate code for huge switch statements") },           \
303    { "long-calls",               MASK_LONG_CALLS,                       \
304      N_("Always generate long calls") },                                \
305    { "no-long-calls",           -MASK_LONG_CALLS,                       \
306      N_("Generate long calls only when needed") },                      \
307    { "linker-opt",               0,                                     \
308      N_("Enable linker optimizations") },                               \
309    SUBTARGET_SWITCHES                                                   \
310    { "",                         TARGET_DEFAULT | TARGET_CPU_DEFAULT,   \
311      NULL }}
312
313 #ifndef TARGET_DEFAULT
314 #define TARGET_DEFAULT (MASK_GAS | MASK_JUMP_IN_DELAY | MASK_BIG_SWITCH)
315 #endif
316
317 #ifndef TARGET_CPU_DEFAULT
318 #define TARGET_CPU_DEFAULT 0
319 #endif
320
321 #ifndef SUBTARGET_SWITCHES
322 #define SUBTARGET_SWITCHES
323 #endif
324
325 #ifndef TARGET_SCHED_DEFAULT
326 #define TARGET_SCHED_DEFAULT "8000"
327 #endif
328
329 #define TARGET_OPTIONS                                                  \
330 {                                                                       \
331   { "arch=",                    &pa_arch_string,                        \
332     N_("Specify PA-RISC architecture for code generation.\n"            \
333        "Values are 1.0, 1.1 and 2.0."), 0},                             \
334   { "fixed-range=",             &pa_fixed_range_string,                 \
335     N_("Specify range of registers to make fixed."), 0},                \
336   { "schedule=",                &pa_cpu_string,                         \
337     N_("Specify CPU for scheduling purposes."), 0},                     \
338   SUBTARGET_OPTIONS                                                     \
339 }
340
341 #ifndef SUBTARGET_OPTIONS
342 #define SUBTARGET_OPTIONS
343 #endif
344
345 /* Support for a compile-time default CPU, et cetera.  The rules are:
346    --with-schedule is ignored if -mschedule is specified.
347    --with-arch is ignored if -march is specified.  */
348 #define OPTION_DEFAULT_SPECS \
349   {"arch", "%{!march=*:-march=%(VALUE)}" }, \
350   {"schedule", "%{!mschedule=*:-mschedule=%(VALUE)}" }
351
352 /* Specify the dialect of assembler to use.  New mnemonics is dialect one
353    and the old mnemonics are dialect zero.  */
354 #define ASSEMBLER_DIALECT (TARGET_PA_20 ? 1 : 0)
355
356 #define OVERRIDE_OPTIONS override_options ()
357
358 /* Override some settings from dbxelf.h.  */
359
360 /* We do not have to be compatible with dbx, so we enable gdb extensions
361    by default.  */
362 #define DEFAULT_GDB_EXTENSIONS 1
363
364 /* This used to be zero (no max length), but big enums and such can
365    cause huge strings which killed gas.
366
367    We also have to avoid lossage in dbxout.c -- it does not compute the
368    string size accurately, so we are real conservative here.  */
369 #undef DBX_CONTIN_LENGTH
370 #define DBX_CONTIN_LENGTH 3000
371
372 /* GDB always assumes the current function's frame begins at the value
373    of the stack pointer upon entry to the current function.  Accessing
374    local variables and parameters passed on the stack is done using the
375    base of the frame + an offset provided by GCC.
376
377    For functions which have frame pointers this method works fine;
378    the (frame pointer) == (stack pointer at function entry) and GCC provides
379    an offset relative to the frame pointer.
380
381    This loses for functions without a frame pointer; GCC provides an offset
382    which is relative to the stack pointer after adjusting for the function's
383    frame size.  GDB would prefer the offset to be relative to the value of
384    the stack pointer at the function's entry.  Yuk!  */
385 #define DEBUGGER_AUTO_OFFSET(X) \
386   ((GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) \
387     + (frame_pointer_needed ? 0 : compute_frame_size (get_frame_size (), 0)))
388
389 #define DEBUGGER_ARG_OFFSET(OFFSET, X) \
390   ((GET_CODE (X) == PLUS ? OFFSET : 0) \
391     + (frame_pointer_needed ? 0 : compute_frame_size (get_frame_size (), 0)))
392
393 #define TARGET_CPU_CPP_BUILTINS()                               \
394 do {                                                            \
395      builtin_assert("cpu=hppa");                                \
396      builtin_assert("machine=hppa");                            \
397      builtin_define("__hppa");                                  \
398      builtin_define("__hppa__");                                \
399      if (TARGET_PA_20)                                          \
400        builtin_define("_PA_RISC2_0");                           \
401      else if (TARGET_PA_11)                                     \
402        builtin_define("_PA_RISC1_1");                           \
403      else                                                       \
404        builtin_define("_PA_RISC1_0");                           \
405 } while (0)
406
407 /* An old set of OS defines for various BSD-like systems.  */
408 #define TARGET_OS_CPP_BUILTINS()                                \
409   do                                                            \
410     {                                                           \
411         builtin_define_std ("REVARGV");                         \
412         builtin_define_std ("hp800");                           \
413         builtin_define_std ("hp9000");                          \
414         builtin_define_std ("hp9k8");                           \
415         if (!c_dialect_cxx () && !flag_iso)                     \
416           builtin_define ("hppa");                              \
417         builtin_define_std ("spectrum");                        \
418         builtin_define_std ("unix");                            \
419         builtin_assert ("system=bsd");                          \
420         builtin_assert ("system=unix");                         \
421     }                                                           \
422   while (0)
423
424 #define CC1_SPEC "%{pg:} %{p:}"
425
426 #define LINK_SPEC "%{mlinker-opt:-O} %{!shared:-u main} %{shared:-b}"
427
428 /* We don't want -lg.  */
429 #ifndef LIB_SPEC
430 #define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
431 #endif
432
433 /* This macro defines command-line switches that modify the default
434    target name.
435
436    The definition is be an initializer for an array of structures.  Each
437    array element has have three elements: the switch name, one of the
438    enumeration codes ADD or DELETE to indicate whether the string should be
439    inserted or deleted, and the string to be inserted or deleted.  */
440 #define MODIFY_TARGET_NAME {{"-32", DELETE, "64"}, {"-64", ADD, "64"}}
441
442 /* Make gcc agree with <machine/ansi.h> */
443
444 #define SIZE_TYPE "unsigned int"
445 #define PTRDIFF_TYPE "int"
446 #define WCHAR_TYPE "unsigned int"
447 #define WCHAR_TYPE_SIZE 32
448
449 /* Show we can debug even without a frame pointer.  */
450 #define CAN_DEBUG_WITHOUT_FP
451 \f
452 /* target machine storage layout */
453 typedef struct machine_function GTY(())
454 {
455   /* Flag indicating that a .NSUBSPA directive has been output for
456      this function.  */
457   int in_nsubspa;
458 } machine_function;
459
460 /* Define this macro if it is advisable to hold scalars in registers
461    in a wider mode than that declared by the program.  In such cases, 
462    the value is constrained to be within the bounds of the declared
463    type, but kept valid in the wider mode.  The signedness of the
464    extension may differ from that of the type.  */
465
466 #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)  \
467   if (GET_MODE_CLASS (MODE) == MODE_INT \
468       && GET_MODE_SIZE (MODE) < UNITS_PER_WORD)         \
469     (MODE) = word_mode;
470
471 /* Define this if most significant bit is lowest numbered
472    in instructions that operate on numbered bit-fields.  */
473 #define BITS_BIG_ENDIAN 1
474
475 /* Define this if most significant byte of a word is the lowest numbered.  */
476 /* That is true on the HP-PA.  */
477 #define BYTES_BIG_ENDIAN 1
478
479 /* Define this if most significant word of a multiword number is lowest
480    numbered.  */
481 #define WORDS_BIG_ENDIAN 1
482
483 #define MAX_BITS_PER_WORD 64
484
485 /* Width of a word, in units (bytes).  */
486 #define UNITS_PER_WORD (TARGET_64BIT ? 8 : 4)
487 #define MIN_UNITS_PER_WORD 4
488
489 /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
490 #define PARM_BOUNDARY BITS_PER_WORD
491
492 /* Largest alignment required for any stack parameter, in bits.
493    Don't define this if it is equal to PARM_BOUNDARY */
494 #define MAX_PARM_BOUNDARY BIGGEST_ALIGNMENT
495
496 /* Boundary (in *bits*) on which stack pointer is always aligned;
497    certain optimizations in combine depend on this.
498
499    The HP-UX runtime documents mandate 64-byte and 16-byte alignment for
500    the stack on the 32 and 64-bit ports, respectively.  However, we
501    are only guaranteed that the stack is aligned to BIGGEST_ALIGNMENT
502    in main.  Thus, we treat the former as the preferred alignment.  */
503 #define STACK_BOUNDARY BIGGEST_ALIGNMENT
504 #define PREFERRED_STACK_BOUNDARY (TARGET_64BIT ? 128 : 512)
505
506 /* Allocation boundary (in *bits*) for the code of a function.  */
507 #define FUNCTION_BOUNDARY BITS_PER_WORD
508
509 /* Alignment of field after `int : 0' in a structure.  */
510 #define EMPTY_FIELD_BOUNDARY 32
511
512 /* Every structure's size must be a multiple of this.  */
513 #define STRUCTURE_SIZE_BOUNDARY 8
514
515 /* A bit-field declared as `int' forces `int' alignment for the struct.  */
516 #define PCC_BITFIELD_TYPE_MATTERS 1
517
518 /* No data type wants to be aligned rounder than this.  */
519 #define BIGGEST_ALIGNMENT (2 * BITS_PER_WORD)
520
521 /* Get around hp-ux assembler bug, and make strcpy of constants fast.  */
522 #define CONSTANT_ALIGNMENT(CODE, TYPEALIGN) \
523   ((TYPEALIGN) < 32 ? 32 : (TYPEALIGN))
524
525 /* Make arrays of chars word-aligned for the same reasons.  */
526 #define DATA_ALIGNMENT(TYPE, ALIGN)             \
527   (TREE_CODE (TYPE) == ARRAY_TYPE               \
528    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
529    && (ALIGN) < BITS_PER_WORD ? BITS_PER_WORD : (ALIGN))
530
531 /* Set this nonzero if move instructions will actually fail to work
532    when given unaligned data.  */
533 #define STRICT_ALIGNMENT 1
534
535 /* Value is 1 if it is a good idea to tie two pseudo registers
536    when one has mode MODE1 and one has mode MODE2.
537    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
538    for any hard reg, then this must be 0 for correct output.  */
539 #define MODES_TIEABLE_P(MODE1, MODE2) \
540   (GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2))
541
542 /* Specify the registers used for certain standard purposes.
543    The values of these macros are register numbers.  */
544
545 /* The HP-PA pc isn't overloaded on a register that the compiler knows about.  */
546 /* #define PC_REGNUM  */
547
548 /* Register to use for pushing function arguments.  */
549 #define STACK_POINTER_REGNUM 30
550
551 /* Base register for access to local variables of the function.  */
552 #define FRAME_POINTER_REGNUM 3
553
554 /* Value should be nonzero if functions must have frame pointers.  */
555 #define FRAME_POINTER_REQUIRED \
556   (current_function_calls_alloca)
557
558 /* C statement to store the difference between the frame pointer
559    and the stack pointer values immediately after the function prologue.
560
561    Note, we always pretend that this is a leaf function because if
562    it's not, there's no point in trying to eliminate the
563    frame pointer.  If it is a leaf function, we guessed right!  */
564 #define INITIAL_FRAME_POINTER_OFFSET(VAR) \
565   do {(VAR) = - compute_frame_size (get_frame_size (), 0);} while (0)
566
567 /* Base register for access to arguments of the function.  */
568 #define ARG_POINTER_REGNUM (TARGET_64BIT ? 29 : 3)
569
570 /* Register in which static-chain is passed to a function.  */
571 #define STATIC_CHAIN_REGNUM (TARGET_64BIT ? 31 : 29)
572
573 /* Register used to address the offset table for position-independent
574    data references.  */
575 #define PIC_OFFSET_TABLE_REGNUM \
576   (flag_pic ? (TARGET_64BIT ? 27 : 19) : INVALID_REGNUM)
577
578 #define PIC_OFFSET_TABLE_REG_CALL_CLOBBERED 1
579
580 /* Function to return the rtx used to save the pic offset table register
581    across function calls.  */
582 extern struct rtx_def *hppa_pic_save_rtx (void);
583
584 #define DEFAULT_PCC_STRUCT_RETURN 0
585
586 /* Register in which address to store a structure value
587    is passed to a function.  */
588 #define PA_STRUCT_VALUE_REGNUM 28
589
590 /* Describe how we implement __builtin_eh_return.  */
591 #define EH_RETURN_DATA_REGNO(N) \
592   ((N) < 3 ? (N) + 20 : (N) == 3 ? 31 : INVALID_REGNUM)
593 #define EH_RETURN_STACKADJ_RTX  gen_rtx_REG (Pmode, 29)
594 #define EH_RETURN_HANDLER_RTX \
595   gen_rtx_MEM (word_mode,                                               \
596                gen_rtx_PLUS (word_mode, frame_pointer_rtx,              \
597                              TARGET_64BIT ? GEN_INT (-16) : GEN_INT (-20)))
598                                 
599
600 /* Offset from the argument pointer register value to the top of
601    stack.  This is different from FIRST_PARM_OFFSET because of the
602    frame marker.  */
603 #define ARG_POINTER_CFA_OFFSET(FNDECL) 0
604 \f
605 /* The letters I, J, K, L and M in a register constraint string
606    can be used to stand for particular ranges of immediate operands.
607    This macro defines what the ranges are.
608    C is the letter, and VALUE is a constant value.
609    Return 1 if VALUE is in the range specified by C.
610
611    `I' is used for the 11 bit constants.
612    `J' is used for the 14 bit constants.
613    `K' is used for values that can be moved with a zdepi insn.
614    `L' is used for the 5 bit constants.
615    `M' is used for 0.
616    `N' is used for values with the least significant 11 bits equal to zero
617                           and when sign extended from 32 to 64 bits the
618                           value does not change.
619    `O' is used for numbers n such that n+1 is a power of 2.
620    */
621
622 #define CONST_OK_FOR_LETTER_P(VALUE, C)  \
623   ((C) == 'I' ? VAL_11_BITS_P (VALUE)                                   \
624    : (C) == 'J' ? VAL_14_BITS_P (VALUE)                                 \
625    : (C) == 'K' ? zdepi_cint_p (VALUE)                                  \
626    : (C) == 'L' ? VAL_5_BITS_P (VALUE)                                  \
627    : (C) == 'M' ? (VALUE) == 0                                          \
628    : (C) == 'N' ? (((VALUE) & (((HOST_WIDE_INT) -1 << 31) | 0x7ff)) == 0 \
629                    || (((VALUE) & (((HOST_WIDE_INT) -1 << 31) | 0x7ff)) \
630                        == (HOST_WIDE_INT) -1 << 31))                    \
631    : (C) == 'O' ? (((VALUE) & ((VALUE) + 1)) == 0)                      \
632    : (C) == 'P' ? and_mask_p (VALUE)                                    \
633    : 0)
634
635 /* Similar, but for floating or large integer constants, and defining letters
636    G and H.   Here VALUE is the CONST_DOUBLE rtx itself.
637
638    For PA, `G' is the floating-point constant zero.  `H' is undefined.  */
639
640 #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                          \
641   ((C) == 'G' ? (GET_MODE_CLASS (GET_MODE (VALUE)) == MODE_FLOAT        \
642                  && (VALUE) == CONST0_RTX (GET_MODE (VALUE)))           \
643    : 0)
644
645 /* The class value for index registers, and the one for base regs.  */
646 #define INDEX_REG_CLASS GENERAL_REGS
647 #define BASE_REG_CLASS GENERAL_REGS
648
649 #define FP_REG_CLASS_P(CLASS) \
650   ((CLASS) == FP_REGS || (CLASS) == FPUPPER_REGS)
651
652 /* True if register is floating-point.  */
653 #define FP_REGNO_P(N) ((N) >= FP_REG_FIRST && (N) <= FP_REG_LAST)
654
655 /* Given an rtx X being reloaded into a reg required to be
656    in class CLASS, return the class of reg to actually use.
657    In general this is just CLASS; but on some machines
658    in some cases it is preferable to use a more restrictive class.  */
659 #define PREFERRED_RELOAD_CLASS(X,CLASS) (CLASS)
660
661 /* Return the register class of a scratch register needed to copy
662    IN into a register in CLASS in MODE, or a register in CLASS in MODE
663    to IN.  If it can be done directly NO_REGS is returned. 
664
665   Avoid doing any work for the common case calls.  */
666 #define SECONDARY_RELOAD_CLASS(CLASS,MODE,IN) \
667   ((CLASS == BASE_REG_CLASS && GET_CODE (IN) == REG             \
668     && REGNO (IN) < FIRST_PSEUDO_REGISTER)                      \
669    ? NO_REGS : secondary_reload_class (CLASS, MODE, IN))
670
671 #define MAYBE_FP_REG_CLASS_P(CLASS) \
672   reg_classes_intersect_p ((CLASS), FP_REGS)
673
674 /* On the PA it is not possible to directly move data between
675    GENERAL_REGS and FP_REGS.  */
676 #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE)           \
677   (MAYBE_FP_REG_CLASS_P (CLASS1) != FP_REG_CLASS_P (CLASS2)     \
678    || MAYBE_FP_REG_CLASS_P (CLASS2) != FP_REG_CLASS_P (CLASS1))
679
680 /* Return the stack location to use for secondary memory needed reloads.  */
681 #define SECONDARY_MEMORY_NEEDED_RTX(MODE) \
682   gen_rtx_MEM (MODE, gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (-16)))
683
684 \f
685 /* Stack layout; function entry, exit and calling.  */
686
687 /* Define this if pushing a word on the stack
688    makes the stack pointer a smaller address.  */
689 /* #define STACK_GROWS_DOWNWARD */
690
691 /* Believe it or not.  */
692 #define ARGS_GROW_DOWNWARD
693
694 /* Define this if the nominal address of the stack frame
695    is at the high-address end of the local variables;
696    that is, each additional local variable allocated
697    goes at a more negative offset in the frame.  */
698 /* #define FRAME_GROWS_DOWNWARD */
699
700 /* Offset within stack frame to start allocating local variables at.
701    If FRAME_GROWS_DOWNWARD, this is the offset to the END of the
702    first local allocated.  Otherwise, it is the offset to the BEGINNING
703    of the first local allocated.
704
705    On the 32-bit ports, we reserve one slot for the previous frame
706    pointer and one fill slot.  The fill slot is for compatibility
707    with HP compiled programs.  On the 64-bit ports, we reserve one
708    slot for the previous frame pointer.  */
709 #define STARTING_FRAME_OFFSET 8
710
711 /* Define STACK_ALIGNMENT_NEEDED to zero to disable final alignment
712    of the stack.  The default is to align it to STACK_BOUNDARY.  */
713 #define STACK_ALIGNMENT_NEEDED 0
714
715 /* If we generate an insn to push BYTES bytes,
716    this says how many the stack pointer really advances by.
717    On the HP-PA, don't define this because there are no push insns.  */
718 /*  #define PUSH_ROUNDING(BYTES) */
719
720 /* Offset of first parameter from the argument pointer register value.
721    This value will be negated because the arguments grow down.
722    Also note that on STACK_GROWS_UPWARD machines (such as this one)
723    this is the distance from the frame pointer to the end of the first
724    argument, not it's beginning.  To get the real offset of the first
725    argument, the size of the argument must be added.  */
726
727 #define FIRST_PARM_OFFSET(FNDECL) (TARGET_64BIT ? -64 : -32)
728
729 /* When a parameter is passed in a register, stack space is still
730    allocated for it.  */
731 #define REG_PARM_STACK_SPACE(DECL) (TARGET_64BIT ? 64 : 16)
732
733 /* Define this if the above stack space is to be considered part of the
734    space allocated by the caller.  */
735 #define OUTGOING_REG_PARM_STACK_SPACE
736
737 /* Keep the stack pointer constant throughout the function.
738    This is both an optimization and a necessity: longjmp
739    doesn't behave itself when the stack pointer moves within
740    the function!  */
741 #define ACCUMULATE_OUTGOING_ARGS 1
742
743 /* The weird HPPA calling conventions require a minimum of 48 bytes on
744    the stack: 16 bytes for register saves, and 32 bytes for magic.
745    This is the difference between the logical top of stack and the
746    actual sp.
747
748    On the 64-bit port, the HP C compiler allocates a 48-byte frame
749    marker, although the runtime documentation only describes a 16
750    byte marker.  For compatibility, we allocate 48 bytes.  */
751 #define STACK_POINTER_OFFSET \
752   (TARGET_64BIT ? -(current_function_outgoing_args_size + 48): -32)
753
754 #define STACK_DYNAMIC_OFFSET(FNDECL)    \
755   (TARGET_64BIT                         \
756    ? (STACK_POINTER_OFFSET)             \
757    : ((STACK_POINTER_OFFSET) - current_function_outgoing_args_size))
758
759 /* Value is 1 if returning from a function call automatically
760    pops the arguments described by the number-of-args field in the call.
761    FUNDECL is the declaration node of the function (as a tree),
762    FUNTYPE is the data type of the function (as a tree),
763    or for a library call it is an identifier node for the subroutine name.  */
764
765 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) 0
766
767 /* Define how to find the value returned by a function.
768    VALTYPE is the data type of the value (as a tree).
769    If the precise function being called is known, FUNC is its FUNCTION_DECL;
770    otherwise, FUNC is 0.  */
771
772 #define FUNCTION_VALUE(VALTYPE, FUNC) function_value (VALTYPE, FUNC)
773
774 /* Define how to find the value returned by a library function
775    assuming the value has mode MODE.  */
776
777 #define LIBCALL_VALUE(MODE)     \
778   gen_rtx_REG (MODE,                                                    \
779                (! TARGET_SOFT_FLOAT                                     \
780                 && ((MODE) == SFmode || (MODE) == DFmode) ? 32 : 28))
781
782 /* 1 if N is a possible register number for a function value
783    as seen by the caller.  */
784
785 #define FUNCTION_VALUE_REGNO_P(N) \
786   ((N) == 28 || (! TARGET_SOFT_FLOAT && (N) == 32))
787
788 \f
789 /* Define a data type for recording info about an argument list
790    during the scan of that argument list.  This data type should
791    hold all necessary information about the function itself
792    and about the args processed so far, enough to enable macros
793    such as FUNCTION_ARG to determine where the next arg should go.
794
795    On the HP-PA, the WORDS field holds the number of words
796    of arguments scanned so far (including the invisible argument,
797    if any, which holds the structure-value-address).  Thus, 4 or
798    more means all following args should go on the stack.
799    
800    The INCOMING field tracks whether this is an "incoming" or
801    "outgoing" argument.
802    
803    The INDIRECT field indicates whether this is is an indirect
804    call or not.
805    
806    The NARGS_PROTOTYPE field indicates that an argument does not
807    have a prototype when it less than or equal to 0.  */
808
809 struct hppa_args {int words, nargs_prototype, incoming, indirect; };
810
811 #define CUMULATIVE_ARGS struct hppa_args
812
813 /* Initialize a variable CUM of type CUMULATIVE_ARGS
814    for a call to a function whose data type is FNTYPE.
815    For a library call, FNTYPE is 0.  */
816
817 #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \
818   (CUM).words = 0,                                                      \
819   (CUM).incoming = 0,                                                   \
820   (CUM).indirect = (FNTYPE) && !(FNDECL),                               \
821   (CUM).nargs_prototype = (FNTYPE && TYPE_ARG_TYPES (FNTYPE)            \
822                            ? (list_length (TYPE_ARG_TYPES (FNTYPE)) - 1 \
823                               + (TYPE_MODE (TREE_TYPE (FNTYPE)) == BLKmode \
824                                  || pa_return_in_memory (TREE_TYPE (FNTYPE), 0))) \
825                            : 0)
826
827
828
829 /* Similar, but when scanning the definition of a procedure.  We always
830    set NARGS_PROTOTYPE large so we never return a PARALLEL.  */
831
832 #define INIT_CUMULATIVE_INCOMING_ARGS(CUM,FNTYPE,IGNORE) \
833   (CUM).words = 0,                              \
834   (CUM).incoming = 1,                           \
835   (CUM).indirect = 0,                           \
836   (CUM).nargs_prototype = 1000
837
838 /* Figure out the size in words of the function argument.  The size
839    returned by this macro should always be greater than zero because
840    we pass variable and zero sized objects by reference.  */
841
842 #define FUNCTION_ARG_SIZE(MODE, TYPE)   \
843   ((((MODE) != BLKmode \
844      ? (HOST_WIDE_INT) GET_MODE_SIZE (MODE) \
845      : int_size_in_bytes (TYPE)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
846
847 /* Update the data in CUM to advance over an argument
848    of mode MODE and data type TYPE.
849    (TYPE is null for libcalls where that information may not be available.)  */
850
851 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)                    \
852 { (CUM).nargs_prototype--;                                              \
853   (CUM).words += FUNCTION_ARG_SIZE(MODE, TYPE)                          \
854     + (((CUM).words & 01) && (TYPE) != 0                                \
855         && FUNCTION_ARG_SIZE(MODE, TYPE) > 1);                          \
856 }
857
858 /* Determine where to put an argument to a function.
859    Value is zero to push the argument on the stack,
860    or a hard register in which to store the argument.
861
862    MODE is the argument's machine mode.
863    TYPE is the data type of the argument (as a tree).
864     This is null for libcalls where that information may
865     not be available.
866    CUM is a variable of type CUMULATIVE_ARGS which gives info about
867     the preceding args and about the function being called.
868    NAMED is nonzero if this argument is a named parameter
869     (otherwise it is an extra parameter matching an ellipsis).
870
871    On the HP-PA the first four words of args are normally in registers
872    and the rest are pushed.  But any arg that won't entirely fit in regs
873    is pushed.
874
875    Arguments passed in registers are either 1 or 2 words long.
876
877    The caller must make a distinction between calls to explicitly named
878    functions and calls through pointers to functions -- the conventions
879    are different!  Calls through pointers to functions only use general
880    registers for the first four argument words.
881
882    Of course all this is different for the portable runtime model
883    HP wants everyone to use for ELF.  Ugh.  Here's a quick description
884    of how it's supposed to work.
885
886    1) callee side remains unchanged.  It expects integer args to be
887    in the integer registers, float args in the float registers and
888    unnamed args in integer registers.
889
890    2) caller side now depends on if the function being called has
891    a prototype in scope (rather than if it's being called indirectly).
892
893       2a) If there is a prototype in scope, then arguments are passed
894       according to their type (ints in integer registers, floats in float
895       registers, unnamed args in integer registers.
896
897       2b) If there is no prototype in scope, then floating point arguments
898       are passed in both integer and float registers.  egad.
899
900   FYI: The portable parameter passing conventions are almost exactly like
901   the standard parameter passing conventions on the RS6000.  That's why
902   you'll see lots of similar code in rs6000.h.  */
903
904 /* If defined, a C expression which determines whether, and in which
905    direction, to pad out an argument with extra space.  */
906 #define FUNCTION_ARG_PADDING(MODE, TYPE) function_arg_padding ((MODE), (TYPE))
907
908 /* Specify padding for the last element of a block move between registers
909    and memory.
910
911    The 64-bit runtime specifies that objects need to be left justified
912    (i.e., the normal justification for a big endian target).  The 32-bit
913    runtime specifies right justification for objects smaller than 64 bits.
914    We use a DImode register in the parallel for 5 to 7 byte structures
915    so that there is only one element.  This allows the object to be
916    correctly padded.  */
917 #define BLOCK_REG_PADDING(MODE, TYPE, FIRST) \
918   function_arg_padding ((MODE), (TYPE))
919
920 /* Do not expect to understand this without reading it several times.  I'm
921    tempted to try and simply it, but I worry about breaking something.  */
922
923 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
924   function_arg (&CUM, MODE, TYPE, NAMED)
925
926 /* If defined, a C expression that gives the alignment boundary, in
927    bits, of an argument with the specified mode and type.  If it is
928    not defined,  `PARM_BOUNDARY' is used for all arguments.  */
929
930 /* Arguments larger than one word are double word aligned.  */
931
932 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE)                               \
933   (((TYPE)                                                              \
934     ? (integer_zerop (TYPE_SIZE (TYPE))                                 \
935        || !TREE_CONSTANT (TYPE_SIZE (TYPE))                             \
936        || int_size_in_bytes (TYPE) <= UNITS_PER_WORD)                   \
937     : GET_MODE_SIZE(MODE) <= UNITS_PER_WORD)                            \
938    ? PARM_BOUNDARY : MAX_PARM_BOUNDARY)
939
940 \f
941 extern GTY(()) rtx hppa_compare_op0;
942 extern GTY(()) rtx hppa_compare_op1;
943 extern enum cmp_type hppa_branch_type;
944
945 /* On HPPA, we emit profiling code as rtl via PROFILE_HOOK rather than
946    as assembly via FUNCTION_PROFILER.  Just output a local label.
947    We can't use the function label because the GAS SOM target can't
948    handle the difference of a global symbol and a local symbol.  */
949
950 #ifndef FUNC_BEGIN_PROLOG_LABEL
951 #define FUNC_BEGIN_PROLOG_LABEL        "LFBP"
952 #endif
953
954 #define FUNCTION_PROFILER(FILE, LABEL) \
955   (*targetm.asm_out.internal_label) (FILE, FUNC_BEGIN_PROLOG_LABEL, LABEL)
956
957 #define PROFILE_HOOK(label_no) hppa_profile_hook (label_no)
958 void hppa_profile_hook (int label_no);
959
960 /* The profile counter if emitted must come before the prologue.  */
961 #define PROFILE_BEFORE_PROLOGUE 1
962
963 /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
964    the stack pointer does not matter.  The value is tested only in
965    functions that have frame pointers.
966    No definition is equivalent to always zero.  */
967
968 extern int may_call_alloca;
969
970 #define EXIT_IGNORE_STACK       \
971  (get_frame_size () != 0        \
972   || current_function_calls_alloca || current_function_outgoing_args_size)
973
974 /* Output assembler code for a block containing the constant parts
975    of a trampoline, leaving space for the variable parts.\
976
977    The trampoline sets the static chain pointer to STATIC_CHAIN_REGNUM
978    and then branches to the specified routine.
979
980    This code template is copied from text segment to stack location
981    and then patched with INITIALIZE_TRAMPOLINE to contain
982    valid values, and then entered as a subroutine.
983
984    It is best to keep this as small as possible to avoid having to
985    flush multiple lines in the cache.  */
986
987 #define TRAMPOLINE_TEMPLATE(FILE)                                       \
988   {                                                                     \
989     if (!TARGET_64BIT)                                                  \
990       {                                                                 \
991         fputs ("\tldw   36(%r22),%r21\n", FILE);                        \
992         fputs ("\tbb,>=,n       %r21,30,.+16\n", FILE);                 \
993         if (ASSEMBLER_DIALECT == 0)                                     \
994           fputs ("\tdepi        0,31,2,%r21\n", FILE);                  \
995         else                                                            \
996           fputs ("\tdepwi       0,31,2,%r21\n", FILE);                  \
997         fputs ("\tldw   4(%r21),%r19\n", FILE);                         \
998         fputs ("\tldw   0(%r21),%r21\n", FILE);                         \
999         if (TARGET_PA_20)                                               \
1000           {                                                             \
1001             fputs ("\tbve       (%r21)\n", FILE);                       \
1002             fputs ("\tldw       40(%r22),%r29\n", FILE);                \
1003             fputs ("\t.word     0\n", FILE);                            \
1004             fputs ("\t.word     0\n", FILE);                            \
1005           }                                                             \
1006         else                                                            \
1007           {                                                             \
1008             fputs ("\tldsid     (%r21),%r1\n", FILE);                   \
1009             fputs ("\tmtsp      %r1,%sr0\n", FILE);                     \
1010             fputs ("\tbe        0(%sr0,%r21)\n", FILE);                 \
1011             fputs ("\tldw       40(%r22),%r29\n", FILE);                \
1012           }                                                             \
1013         fputs ("\t.word 0\n", FILE);                                    \
1014         fputs ("\t.word 0\n", FILE);                                    \
1015         fputs ("\t.word 0\n", FILE);                                    \
1016         fputs ("\t.word 0\n", FILE);                                    \
1017       }                                                                 \
1018     else                                                                \
1019       {                                                                 \
1020         fputs ("\t.dword 0\n", FILE);                                   \
1021         fputs ("\t.dword 0\n", FILE);                                   \
1022         fputs ("\t.dword 0\n", FILE);                                   \
1023         fputs ("\t.dword 0\n", FILE);                                   \
1024         fputs ("\tmfia  %r31\n", FILE);                                 \
1025         fputs ("\tldd   24(%r31),%r1\n", FILE);                         \
1026         fputs ("\tldd   24(%r1),%r27\n", FILE);                         \
1027         fputs ("\tldd   16(%r1),%r1\n", FILE);                          \
1028         fputs ("\tbve   (%r1)\n", FILE);                                \
1029         fputs ("\tldd   32(%r31),%r31\n", FILE);                        \
1030         fputs ("\t.dword 0  ; fptr\n", FILE);                           \
1031         fputs ("\t.dword 0  ; static link\n", FILE);                    \
1032       }                                                                 \
1033   }
1034
1035 /* Length in units of the trampoline for entering a nested function.  */
1036
1037 #define TRAMPOLINE_SIZE (TARGET_64BIT ? 72 : 52)
1038
1039 /* Length in units of the trampoline instruction code.  */
1040
1041 #define TRAMPOLINE_CODE_SIZE (TARGET_64BIT ? 24 : (TARGET_PA_20 ? 32 : 40))
1042
1043 /* Minimum length of a cache line.  A length of 16 will work on all
1044    PA-RISC processors.  All PA 1.1 processors have a cache line of
1045    32 bytes.  Most but not all PA 2.0 processors have a cache line
1046    of 64 bytes.  As cache flushes are expensive and we don't support
1047    PA 1.0, we use a minimum length of 32.  */
1048
1049 #define MIN_CACHELINE_SIZE 32
1050
1051 /* Emit RTL insns to initialize the variable parts of a trampoline.
1052    FNADDR is an RTX for the address of the function's pure code.
1053    CXT is an RTX for the static chain value for the function.
1054
1055    Move the function address to the trampoline template at offset 36.
1056    Move the static chain value to trampoline template at offset 40.
1057    Move the trampoline address to trampoline template at offset 44.
1058    Move r19 to trampoline template at offset 48.  The latter two
1059    words create a plabel for the indirect call to the trampoline.
1060
1061    A similar sequence is used for the 64-bit port but the plabel is
1062    at the beginning of the trampoline.
1063
1064    Finally, the cache entries for the trampoline code are flushed.
1065    This is necessary to ensure that the trampoline instruction sequence
1066    is written to memory prior to any attempts at prefetching the code
1067    sequence.  */
1068
1069 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                       \
1070 {                                                                       \
1071   rtx start_addr = gen_reg_rtx (Pmode);                                 \
1072   rtx end_addr = gen_reg_rtx (Pmode);                                   \
1073   rtx line_length = gen_reg_rtx (Pmode);                                \
1074   rtx tmp;                                                              \
1075                                                                         \
1076   if (!TARGET_64BIT)                                                    \
1077     {                                                                   \
1078       tmp = memory_address (Pmode, plus_constant ((TRAMP), 36));        \
1079       emit_move_insn (gen_rtx_MEM (Pmode, tmp), (FNADDR));              \
1080       tmp = memory_address (Pmode, plus_constant ((TRAMP), 40));        \
1081       emit_move_insn (gen_rtx_MEM (Pmode, tmp), (CXT));                 \
1082                                                                         \
1083       /* Create a fat pointer for the trampoline.  */                   \
1084       tmp = memory_address (Pmode, plus_constant ((TRAMP), 44));        \
1085       emit_move_insn (gen_rtx_MEM (Pmode, tmp), (TRAMP));               \
1086       tmp = memory_address (Pmode, plus_constant ((TRAMP), 48));        \
1087       emit_move_insn (gen_rtx_MEM (Pmode, tmp),                         \
1088                       gen_rtx_REG (Pmode, 19));                         \
1089                                                                         \
1090       /* fdc and fic only use registers for the address to flush,       \
1091          they do not accept integer displacements.  We align the        \
1092          start and end addresses to the beginning of their respective   \
1093          cache lines to minimize the number of lines flushed.  */       \
1094       tmp = force_reg (Pmode, (TRAMP));                                 \
1095       emit_insn (gen_andsi3 (start_addr, tmp,                           \
1096                              GEN_INT (-MIN_CACHELINE_SIZE)));           \
1097       tmp = force_reg (Pmode,                                           \
1098                        plus_constant (tmp, TRAMPOLINE_CODE_SIZE - 1));  \
1099       emit_insn (gen_andsi3 (end_addr, tmp,                             \
1100                              GEN_INT (-MIN_CACHELINE_SIZE)));           \
1101       emit_move_insn (line_length, GEN_INT (MIN_CACHELINE_SIZE));       \
1102       emit_insn (gen_dcacheflush (start_addr, end_addr, line_length));  \
1103       emit_insn (gen_icacheflush (start_addr, end_addr, line_length,    \
1104                                   gen_reg_rtx (Pmode),                  \
1105                                   gen_reg_rtx (Pmode)));                \
1106     }                                                                   \
1107   else                                                                  \
1108     {                                                                   \
1109       tmp = memory_address (Pmode, plus_constant ((TRAMP), 56));        \
1110       emit_move_insn (gen_rtx_MEM (Pmode, tmp), (FNADDR));              \
1111       tmp = memory_address (Pmode, plus_constant ((TRAMP), 64));        \
1112       emit_move_insn (gen_rtx_MEM (Pmode, tmp), (CXT));                 \
1113                                                                         \
1114       /* Create a fat pointer for the trampoline.  */                   \
1115       tmp = memory_address (Pmode, plus_constant ((TRAMP), 16));        \
1116       emit_move_insn (gen_rtx_MEM (Pmode, tmp),                         \
1117                       force_reg (Pmode, plus_constant ((TRAMP), 32)));  \
1118       tmp = memory_address (Pmode, plus_constant ((TRAMP), 24));        \
1119       emit_move_insn (gen_rtx_MEM (Pmode, tmp),                         \
1120                       gen_rtx_REG (Pmode, 27));                         \
1121                                                                         \
1122       /* fdc and fic only use registers for the address to flush,       \
1123          they do not accept integer displacements.  We align the        \
1124          start and end addresses to the beginning of their respective   \
1125          cache lines to minimize the number of lines flushed.  */       \
1126       tmp = force_reg (Pmode, plus_constant ((TRAMP), 32));             \
1127       emit_insn (gen_anddi3 (start_addr, tmp,                           \
1128                              GEN_INT (-MIN_CACHELINE_SIZE)));           \
1129       tmp = force_reg (Pmode,                                           \
1130                        plus_constant (tmp, TRAMPOLINE_CODE_SIZE - 1));  \
1131       emit_insn (gen_anddi3 (end_addr, tmp,                             \
1132                              GEN_INT (-MIN_CACHELINE_SIZE)));           \
1133       emit_move_insn (line_length, GEN_INT (MIN_CACHELINE_SIZE));       \
1134       emit_insn (gen_dcacheflush (start_addr, end_addr, line_length));  \
1135       emit_insn (gen_icacheflush (start_addr, end_addr, line_length,    \
1136                                   gen_reg_rtx (Pmode),                  \
1137                                   gen_reg_rtx (Pmode)));                \
1138     }                                                                   \
1139 }
1140
1141 /* Perform any machine-specific adjustment in the address of the trampoline.
1142    ADDR contains the address that was passed to INITIALIZE_TRAMPOLINE.
1143    Adjust the trampoline address to point to the plabel at offset 44.  */
1144    
1145 #define TRAMPOLINE_ADJUST_ADDRESS(ADDR) \
1146   if (!TARGET_64BIT) (ADDR) = memory_address (Pmode, plus_constant ((ADDR), 46))
1147
1148 /* Implement `va_start' for varargs and stdarg.  */
1149
1150 #define EXPAND_BUILTIN_VA_START(valist, nextarg) \
1151   hppa_va_start (valist, nextarg)
1152 \f
1153 /* Addressing modes, and classification of registers for them. 
1154
1155    Using autoincrement addressing modes on PA8000 class machines is
1156    not profitable.  */
1157
1158 #define HAVE_POST_INCREMENT (pa_cpu < PROCESSOR_8000)
1159 #define HAVE_POST_DECREMENT (pa_cpu < PROCESSOR_8000)
1160
1161 #define HAVE_PRE_DECREMENT (pa_cpu < PROCESSOR_8000)
1162 #define HAVE_PRE_INCREMENT (pa_cpu < PROCESSOR_8000)
1163
1164 /* Macros to check register numbers against specific register classes.  */
1165
1166 /* The following macros assume that X is a hard or pseudo reg number.
1167    They give nonzero only if X is a hard reg of the suitable class
1168    or a pseudo reg currently allocated to a suitable hard reg.
1169    Since they use reg_renumber, they are safe only once reg_renumber
1170    has been allocated, which happens in local-alloc.c.  */
1171
1172 #define REGNO_OK_FOR_INDEX_P(X) \
1173   ((X) && ((X) < 32                                                     \
1174    || (X >= FIRST_PSEUDO_REGISTER                                       \
1175        && reg_renumber                                                  \
1176        && (unsigned) reg_renumber[X] < 32)))
1177 #define REGNO_OK_FOR_BASE_P(X) \
1178   ((X) && ((X) < 32                                                     \
1179    || (X >= FIRST_PSEUDO_REGISTER                                       \
1180        && reg_renumber                                                  \
1181        && (unsigned) reg_renumber[X] < 32)))
1182 #define REGNO_OK_FOR_FP_P(X) \
1183   (FP_REGNO_P (X)                                                       \
1184    || (X >= FIRST_PSEUDO_REGISTER                                       \
1185        && reg_renumber                                                  \
1186        && FP_REGNO_P (reg_renumber[X])))
1187
1188 /* Now macros that check whether X is a register and also,
1189    strictly, whether it is in a specified class.
1190
1191    These macros are specific to the HP-PA, and may be used only
1192    in code for printing assembler insns and in conditions for
1193    define_optimization.  */
1194
1195 /* 1 if X is an fp register.  */
1196
1197 #define FP_REG_P(X) (REG_P (X) && REGNO_OK_FOR_FP_P (REGNO (X)))
1198 \f
1199 /* Maximum number of registers that can appear in a valid memory address.  */
1200
1201 #define MAX_REGS_PER_ADDRESS 2
1202
1203 /* Recognize any constant value that is a valid address except
1204    for symbolic addresses.  We get better CSE by rejecting them
1205    here and allowing hppa_legitimize_address to break them up.  We
1206    use most of the constants accepted by CONSTANT_P, except CONST_DOUBLE.  */
1207
1208 #define CONSTANT_ADDRESS_P(X) \
1209   ((GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF             \
1210    || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST                \
1211    || GET_CODE (X) == HIGH)                                             \
1212    && (reload_in_progress || reload_completed || ! symbolic_expression_p (X)))
1213
1214 /* A C expression that is nonzero if we are using the new HP assembler.  */
1215
1216 #ifndef NEW_HP_ASSEMBLER
1217 #define NEW_HP_ASSEMBLER 0
1218 #endif
1219
1220 /* The macros below define the immediate range for CONST_INTS on
1221    the 64-bit port.  Constants in this range can be loaded in three
1222    instructions using a ldil/ldo/depdi sequence.  Constants outside
1223    this range are forced to the constant pool prior to reload.  */
1224
1225 #define MAX_LEGIT_64BIT_CONST_INT ((HOST_WIDE_INT) 32 << 31)
1226 #define MIN_LEGIT_64BIT_CONST_INT ((HOST_WIDE_INT) -32 << 31)
1227 #define LEGITIMATE_64BIT_CONST_INT_P(X) \
1228   ((X) >= MIN_LEGIT_64BIT_CONST_INT && (X) < MAX_LEGIT_64BIT_CONST_INT)
1229
1230 /* A C expression that is nonzero if X is a legitimate constant for an
1231    immediate operand.
1232
1233    We include all constant integers and constant doubles, but not
1234    floating-point, except for floating-point zero.  We reject LABEL_REFs
1235    if we're not using gas or the new HP assembler. 
1236
1237    In 64-bit mode, we reject CONST_DOUBLES.  We also reject CONST_INTS
1238    that need more than three instructions to load prior to reload.  This
1239    limit is somewhat arbitrary.  It takes three instructions to load a
1240    CONST_INT from memory but two are memory accesses.  It may be better
1241    to increase the allowed range for CONST_INTS.  We may also be able
1242    to handle CONST_DOUBLES.  */
1243
1244 #define LEGITIMATE_CONSTANT_P(X)                                \
1245   ((GET_MODE_CLASS (GET_MODE (X)) != MODE_FLOAT                 \
1246     || (X) == CONST0_RTX (GET_MODE (X)))                        \
1247    && (NEW_HP_ASSEMBLER || TARGET_GAS || GET_CODE (X) != LABEL_REF)     \
1248    && !(TARGET_64BIT && GET_CODE (X) == CONST_DOUBLE)           \
1249    && !(TARGET_64BIT && GET_CODE (X) == CONST_INT               \
1250         && !(HOST_BITS_PER_WIDE_INT <= 32                       \
1251              || (reload_in_progress || reload_completed)        \
1252              || LEGITIMATE_64BIT_CONST_INT_P (INTVAL (X))       \
1253              || cint_ok_for_move (INTVAL (X))))                 \
1254    && !function_label_operand (X, VOIDmode))
1255
1256 /* Subroutines for EXTRA_CONSTRAINT.
1257
1258    Return 1 iff OP is a pseudo which did not get a hard register and
1259    we are running the reload pass.  */
1260 #define IS_RELOADING_PSEUDO_P(OP) \
1261   ((reload_in_progress                                  \
1262     && GET_CODE (OP) == REG                             \
1263     && REGNO (OP) >= FIRST_PSEUDO_REGISTER              \
1264     && reg_renumber [REGNO (OP)] < 0))
1265
1266 /* Return 1 iff OP is a scaled or unscaled index address.  */
1267 #define IS_INDEX_ADDR_P(OP) \
1268   (GET_CODE (OP) == PLUS                                \
1269    && GET_MODE (OP) == Pmode                            \
1270    && (GET_CODE (XEXP (OP, 0)) == MULT                  \
1271        || GET_CODE (XEXP (OP, 1)) == MULT               \
1272        || (REG_P (XEXP (OP, 0))                         \
1273            && REG_P (XEXP (OP, 1)))))
1274
1275 /* Return 1 iff OP is a LO_SUM DLT address.  */
1276 #define IS_LO_SUM_DLT_ADDR_P(OP) \
1277   (GET_CODE (OP) == LO_SUM                              \
1278    && GET_MODE (OP) == Pmode                            \
1279    && REG_P (XEXP (OP, 0))                              \
1280    && REG_OK_FOR_BASE_P (XEXP (OP, 0))                  \
1281    && GET_CODE (XEXP (OP, 1)) == UNSPEC)
1282
1283 /* Optional extra constraints for this machine. Borrowed from sparc.h.
1284
1285    `A' is a LO_SUM DLT memory operand.
1286
1287    `Q' is any memory operand that isn't a symbolic, indexed or lo_sum
1288        memory operand.  Note that an unassigned pseudo register is such a
1289        memory operand.  Needed because reload will generate these things
1290        and then not re-recognize the insn, causing constrain_operands to
1291        fail.
1292
1293    `R' is a scaled/unscaled indexed memory operand.
1294
1295    `S' is the constant 31.
1296
1297    `T' is for floating-point loads and stores.
1298
1299    `U' is the constant 63.  */
1300
1301 #define EXTRA_CONSTRAINT(OP, C) \
1302   ((C) == 'Q' ?                                                         \
1303    (IS_RELOADING_PSEUDO_P (OP)                                          \
1304     || (GET_CODE (OP) == MEM                                            \
1305         && (reload_in_progress                                          \
1306             || memory_address_p (GET_MODE (OP), XEXP (OP, 0)))          \
1307         && !symbolic_memory_operand (OP, VOIDmode)                      \
1308         && !IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0))                         \
1309         && !IS_INDEX_ADDR_P (XEXP (OP, 0))))                            \
1310    : ((C) == 'A' ?                                                      \
1311       (GET_CODE (OP) == MEM                                             \
1312        && IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0)))                          \
1313    : ((C) == 'R' ?                                                      \
1314       (GET_CODE (OP) == MEM                                             \
1315        && IS_INDEX_ADDR_P (XEXP (OP, 0)))                               \
1316    : ((C) == 'T' ?                                                      \
1317       (GET_CODE (OP) == MEM                                             \
1318        && !IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0))                          \
1319        && !IS_INDEX_ADDR_P (XEXP (OP, 0))                               \
1320        /* Floating-point loads and stores are used to load              \
1321           integer values as well as floating-point values.              \
1322           They don't have the same set of REG+D address modes           \
1323           as integer loads and stores.  PA 1.x supports only            \
1324           short displacements.  PA 2.0 supports long displacements      \
1325           but the base register needs to be aligned.                    \
1326                                                                         \
1327           The checks in GO_IF_LEGITIMATE_ADDRESS for SFmode and         \
1328           DFmode test the validity of an address for use in a           \
1329           floating point load or store.  So, we use SFmode/DFmode       \
1330           to see if the address is valid for a floating-point           \
1331           load/store operation.  */                                     \
1332        && memory_address_p ((GET_MODE_SIZE (GET_MODE (OP)) == 4         \
1333                              ? SFmode                                   \
1334                              : DFmode),                                 \
1335                             XEXP (OP, 0)))                              \
1336    : ((C) == 'S' ?                                                      \
1337       (GET_CODE (OP) == CONST_INT && INTVAL (OP) == 31)                 \
1338    : ((C) == 'U' ?                                                      \
1339       (GET_CODE (OP) == CONST_INT && INTVAL (OP) == 63) : 0))))))
1340         
1341
1342 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1343    and check its validity for a certain class.
1344    We have two alternate definitions for each of them.
1345    The usual definition accepts all pseudo regs; the other rejects
1346    them unless they have been allocated suitable hard regs.
1347    The symbol REG_OK_STRICT causes the latter definition to be used.
1348
1349    Most source files want to accept pseudo regs in the hope that
1350    they will get allocated to the class that the insn wants them to be in.
1351    Source files for reload pass need to be strict.
1352    After reload, it makes no difference, since pseudo regs have
1353    been eliminated by then.  */
1354
1355 #ifndef REG_OK_STRICT
1356
1357 /* Nonzero if X is a hard reg that can be used as an index
1358    or if it is a pseudo reg.  */
1359 #define REG_OK_FOR_INDEX_P(X) \
1360 (REGNO (X) && (REGNO (X) < 32 || REGNO (X) >= FIRST_PSEUDO_REGISTER))
1361 /* Nonzero if X is a hard reg that can be used as a base reg
1362    or if it is a pseudo reg.  */
1363 #define REG_OK_FOR_BASE_P(X) \
1364 (REGNO (X) && (REGNO (X) < 32 || REGNO (X) >= FIRST_PSEUDO_REGISTER))
1365
1366 #else
1367
1368 /* Nonzero if X is a hard reg that can be used as an index.  */
1369 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
1370 /* Nonzero if X is a hard reg that can be used as a base reg.  */
1371 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
1372
1373 #endif
1374 \f
1375 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression that is a
1376    valid memory address for an instruction.  The MODE argument is the
1377    machine mode for the MEM expression that wants to use this address.
1378
1379    On HP PA-RISC, the legitimate address forms are REG+SMALLINT,
1380    REG+REG, and REG+(REG*SCALE).  The indexed address forms are only
1381    available with floating point loads and stores, and integer loads.
1382    We get better code by allowing indexed addresses in the initial
1383    RTL generation.
1384
1385    The acceptance of indexed addresses as legitimate implies that we
1386    must provide patterns for doing indexed integer stores, or the move
1387    expanders must force the address of an indexed store to a register.
1388    We have adopted the latter approach.
1389    
1390    Another function of GO_IF_LEGITIMATE_ADDRESS is to ensure that
1391    the base register is a valid pointer for indexed instructions.
1392    On targets that have non-equivalent space registers, we have to
1393    know at the time of assembler output which register in a REG+REG
1394    pair is the base register.  The REG_POINTER flag is sometimes lost
1395    in reload and the following passes, so it can't be relied on during
1396    code generation.  Thus, we either have to canonicalize the order
1397    of the registers in REG+REG indexed addresses, or treat REG+REG
1398    addresses separately and provide patterns for both permutations.
1399
1400    The latter approach requires several hundred additional lines of
1401    code in pa.md.  The downside to canonicalizing is that a PLUS
1402    in the wrong order can't combine to form to make a scaled indexed
1403    memory operand.  As we won't need to canonicalize the operands if
1404    the REG_POINTER lossage can be fixed, it seems better canonicalize.
1405
1406    We initially break out scaled indexed addresses in canonical order
1407    in emit_move_sequence.  LEGITIMIZE_ADDRESS also canonicalizes
1408    scaled indexed addresses during RTL generation.  However, fold_rtx
1409    has its own opinion on how the operands of a PLUS should be ordered.
1410    If one of the operands is equivalent to a constant, it will make
1411    that operand the second operand.  As the base register is likely to
1412    be equivalent to a SYMBOL_REF, we have made it the second operand.
1413
1414    GO_IF_LEGITIMATE_ADDRESS accepts REG+REG as legitimate when the
1415    operands are in the order INDEX+BASE on targets with non-equivalent
1416    space registers, and in any order on targets with equivalent space
1417    registers.  It accepts both MULT+BASE and BASE+MULT for scaled indexing.
1418
1419    We treat a SYMBOL_REF as legitimate if it is part of the current
1420    function's constant-pool, because such addresses can actually be
1421    output as REG+SMALLINT. 
1422
1423    Note we only allow 5 bit immediates for access to a constant address;
1424    doing so avoids losing for loading/storing a FP register at an address
1425    which will not fit in 5 bits.  */
1426
1427 #define VAL_5_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x10 < 0x20)
1428 #define INT_5_BITS(X) VAL_5_BITS_P (INTVAL (X))
1429
1430 #define VAL_U5_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) < 0x20)
1431 #define INT_U5_BITS(X) VAL_U5_BITS_P (INTVAL (X))
1432
1433 #define VAL_11_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x400 < 0x800)
1434 #define INT_11_BITS(X) VAL_11_BITS_P (INTVAL (X))
1435
1436 #define VAL_14_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x2000 < 0x4000)
1437 #define INT_14_BITS(X) VAL_14_BITS_P (INTVAL (X))
1438
1439 #if HOST_BITS_PER_WIDE_INT > 32
1440 #define VAL_32_BITS_P(X) \
1441   ((unsigned HOST_WIDE_INT)(X) + ((unsigned HOST_WIDE_INT) 1 << 31)    \
1442    < (unsigned HOST_WIDE_INT) 2 << 31)
1443 #else
1444 #define VAL_32_BITS_P(X) 1
1445 #endif
1446 #define INT_32_BITS(X) VAL_32_BITS_P (INTVAL (X))
1447
1448 /* These are the modes that we allow for scaled indexing.  */
1449 #define MODE_OK_FOR_SCALED_INDEXING_P(MODE) \
1450   ((TARGET_64BIT && (MODE) == DImode)                                   \
1451    || (MODE) == SImode                                                  \
1452    || (MODE) == HImode                                                  \
1453    || (!TARGET_SOFT_FLOAT && ((MODE) == DFmode || (MODE) == SFmode)))
1454
1455 /* These are the modes that we allow for unscaled indexing.  */
1456 #define MODE_OK_FOR_UNSCALED_INDEXING_P(MODE) \
1457   ((TARGET_64BIT && (MODE) == DImode)                                   \
1458    || (MODE) == SImode                                                  \
1459    || (MODE) == HImode                                                  \
1460    || (MODE) == QImode                                                  \
1461    || (!TARGET_SOFT_FLOAT && ((MODE) == DFmode || (MODE) == SFmode)))
1462
1463 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
1464 {                                                                       \
1465   if ((REG_P (X) && REG_OK_FOR_BASE_P (X))                              \
1466       || ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_DEC          \
1467            || GET_CODE (X) == PRE_INC || GET_CODE (X) == POST_INC)      \
1468           && REG_P (XEXP (X, 0))                                        \
1469           && REG_OK_FOR_BASE_P (XEXP (X, 0))))                          \
1470     goto ADDR;                                                          \
1471   else if (GET_CODE (X) == PLUS)                                        \
1472     {                                                                   \
1473       rtx base = 0, index = 0;                                          \
1474       if (REG_P (XEXP (X, 1))                                           \
1475           && REG_OK_FOR_BASE_P (XEXP (X, 1)))                           \
1476         base = XEXP (X, 1), index = XEXP (X, 0);                        \
1477       else if (REG_P (XEXP (X, 0))                                      \
1478                && REG_OK_FOR_BASE_P (XEXP (X, 0)))                      \
1479         base = XEXP (X, 0), index = XEXP (X, 1);                        \
1480       if (base                                                          \
1481           && GET_CODE (index) == CONST_INT                              \
1482           && ((INT_14_BITS (index)                                      \
1483                && (((MODE) != DImode                                    \
1484                     && (MODE) != SFmode                                 \
1485                     && (MODE) != DFmode)                                \
1486                    /* The base register for DImode loads and stores     \
1487                       with long displacements must be aligned because   \
1488                       the lower three bits in the displacement are      \
1489                       assumed to be zero.  */                           \
1490                    || ((MODE) == DImode                                 \
1491                        && (!TARGET_64BIT                                \
1492                            || (INTVAL (index) % 8) == 0))               \
1493                    /* Similarly, the base register for SFmode/DFmode    \
1494                       loads and stores with long displacements must     \
1495                       be aligned.                                       \
1496                                                                         \
1497                       FIXME: the ELF32 linker clobbers the LSB of       \
1498                       the FP register number in PA 2.0 floating-point   \
1499                       insns with long displacements.  This is because   \
1500                       R_PARISC_DPREL14WR and other relocations like     \
1501                       it are not supported.  For now, we reject long    \
1502                       displacements on this target.  */                 \
1503                    || (((MODE) == SFmode || (MODE) == DFmode)           \
1504                        && (TARGET_SOFT_FLOAT                            \
1505                            || (TARGET_PA_20                             \
1506                                && !TARGET_ELF32                         \
1507                                && (INTVAL (index)                       \
1508                                    % GET_MODE_SIZE (MODE)) == 0)))))    \
1509                || INT_5_BITS (index)))                                  \
1510         goto ADDR;                                                      \
1511       if (!TARGET_DISABLE_INDEXING                                      \
1512           /* Only accept the "canonical" INDEX+BASE operand order       \
1513              on targets with non-equivalent space registers.  */        \
1514           && (TARGET_NO_SPACE_REGS                                      \
1515               ? (base && REG_P (index))                                 \
1516               : (base == XEXP (X, 1) && REG_P (index)                   \
1517                  && REG_POINTER (base) && !REG_POINTER (index)))        \
1518           && MODE_OK_FOR_UNSCALED_INDEXING_P (MODE)                     \
1519           && REG_OK_FOR_INDEX_P (index)                                 \
1520           && borx_reg_operand (base, Pmode)                             \
1521           && borx_reg_operand (index, Pmode))                           \
1522         goto ADDR;                                                      \
1523       if (!TARGET_DISABLE_INDEXING                                      \
1524           && base                                                       \
1525           && GET_CODE (index) == MULT                                   \
1526           && MODE_OK_FOR_SCALED_INDEXING_P (MODE)                       \
1527           && REG_P (XEXP (index, 0))                                    \
1528           && GET_MODE (XEXP (index, 0)) == Pmode                        \
1529           && REG_OK_FOR_INDEX_P (XEXP (index, 0))                       \
1530           && GET_CODE (XEXP (index, 1)) == CONST_INT                    \
1531           && INTVAL (XEXP (index, 1))                                   \
1532              == (HOST_WIDE_INT) GET_MODE_SIZE (MODE)                    \
1533           && borx_reg_operand (base, Pmode))                            \
1534         goto ADDR;                                                      \
1535     }                                                                   \
1536   else if (GET_CODE (X) == LO_SUM                                       \
1537            && GET_CODE (XEXP (X, 0)) == REG                             \
1538            && REG_OK_FOR_BASE_P (XEXP (X, 0))                           \
1539            && CONSTANT_P (XEXP (X, 1))                                  \
1540            && (TARGET_SOFT_FLOAT                                        \
1541                /* We can allow symbolic LO_SUM addresses for PA2.0.  */ \
1542                || (TARGET_PA_20                                         \
1543                    && !TARGET_ELF32                                     \
1544                    && GET_CODE (XEXP (X, 1)) != CONST_INT)              \
1545                || ((MODE) != SFmode                                     \
1546                    && (MODE) != DFmode)))                               \
1547     goto ADDR;                                                          \
1548   else if (GET_CODE (X) == LO_SUM                                       \
1549            && GET_CODE (XEXP (X, 0)) == SUBREG                          \
1550            && GET_CODE (SUBREG_REG (XEXP (X, 0))) == REG                \
1551            && REG_OK_FOR_BASE_P (SUBREG_REG (XEXP (X, 0)))              \
1552            && CONSTANT_P (XEXP (X, 1))                                  \
1553            && (TARGET_SOFT_FLOAT                                        \
1554                /* We can allow symbolic LO_SUM addresses for PA2.0.  */ \
1555                || (TARGET_PA_20                                         \
1556                    && !TARGET_ELF32                                     \
1557                    && GET_CODE (XEXP (X, 1)) != CONST_INT)              \
1558                || ((MODE) != SFmode                                     \
1559                    && (MODE) != DFmode)))                               \
1560     goto ADDR;                                                          \
1561   else if (GET_CODE (X) == LABEL_REF                                    \
1562            || (GET_CODE (X) == CONST_INT                                \
1563                && INT_5_BITS (X)))                                      \
1564     goto ADDR;                                                          \
1565   /* Needed for -fPIC */                                                \
1566   else if (GET_CODE (X) == LO_SUM                                       \
1567            && GET_CODE (XEXP (X, 0)) == REG                             \
1568            && REG_OK_FOR_BASE_P (XEXP (X, 0))                           \
1569            && GET_CODE (XEXP (X, 1)) == UNSPEC                          \
1570            && (TARGET_SOFT_FLOAT                                        \
1571                || (TARGET_PA_20 && !TARGET_ELF32)                       \
1572                || ((MODE) != SFmode                                     \
1573                    && (MODE) != DFmode)))                               \
1574     goto ADDR;                                                          \
1575 }
1576
1577 /* Look for machine dependent ways to make the invalid address AD a
1578    valid address.
1579
1580    For the PA, transform:
1581
1582         memory(X + <large int>)
1583
1584    into:
1585
1586         if (<large int> & mask) >= 16
1587           Y = (<large int> & ~mask) + mask + 1  Round up.
1588         else
1589           Y = (<large int> & ~mask)             Round down.
1590         Z = X + Y
1591         memory (Z + (<large int> - Y));
1592
1593    This makes reload inheritance and reload_cse work better since Z
1594    can be reused.
1595
1596    There may be more opportunities to improve code with this hook.  */
1597 #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN)      \
1598 do {                                                                    \
1599   long offset, newoffset, mask;                                         \
1600   rtx new, temp = NULL_RTX;                                             \
1601                                                                         \
1602   mask = (GET_MODE_CLASS (MODE) == MODE_FLOAT                           \
1603           ? (TARGET_PA_20 && !TARGET_ELF32 ? 0x3fff : 0x1f) : 0x3fff);  \
1604                                                                         \
1605   if (optimize && GET_CODE (AD) == PLUS)                                \
1606     temp = simplify_binary_operation (PLUS, Pmode,                      \
1607                                       XEXP (AD, 0), XEXP (AD, 1));      \
1608                                                                         \
1609   new = temp ? temp : AD;                                               \
1610                                                                         \
1611   if (optimize                                                          \
1612       && GET_CODE (new) == PLUS                                         \
1613       && GET_CODE (XEXP (new, 0)) == REG                                \
1614       && GET_CODE (XEXP (new, 1)) == CONST_INT)                         \
1615     {                                                                   \
1616       offset = INTVAL (XEXP ((new), 1));                                \
1617                                                                         \
1618       /* Choose rounding direction.  Round up if we are >= halfway.  */ \
1619       if ((offset & mask) >= ((mask + 1) / 2))                          \
1620         newoffset = (offset & ~mask) + mask + 1;                        \
1621       else                                                              \
1622         newoffset = offset & ~mask;                                     \
1623                                                                         \
1624       /* Ensure that long displacements are aligned.  */                \
1625       if (!VAL_5_BITS_P (newoffset)                                     \
1626           && GET_MODE_CLASS (MODE) == MODE_FLOAT)                       \
1627         newoffset &= ~(GET_MODE_SIZE (MODE) -1);                        \
1628                                                                         \
1629       if (newoffset != 0 && VAL_14_BITS_P (newoffset))                  \
1630         {                                                               \
1631           temp = gen_rtx_PLUS (Pmode, XEXP (new, 0),                    \
1632                                GEN_INT (newoffset));                    \
1633           AD = gen_rtx_PLUS (Pmode, temp, GEN_INT (offset - newoffset));\
1634           push_reload (XEXP (AD, 0), 0, &XEXP (AD, 0), 0,               \
1635                        BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,           \
1636                        (OPNUM), (TYPE));                                \
1637           goto WIN;                                                     \
1638         }                                                               \
1639     }                                                                   \
1640 } while (0)
1641
1642
1643
1644 \f
1645 /* Try machine-dependent ways of modifying an illegitimate address
1646    to be legitimate.  If we find one, return the new, valid address.
1647    This macro is used in only one place: `memory_address' in explow.c.
1648
1649    OLDX is the address as it was before break_out_memory_refs was called.
1650    In some cases it is useful to look at this to decide what needs to be done.
1651
1652    MODE and WIN are passed so that this macro can use
1653    GO_IF_LEGITIMATE_ADDRESS.
1654
1655    It is always safe for this macro to do nothing.  It exists to recognize
1656    opportunities to optimize the output.  */
1657
1658 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)  \
1659 { rtx orig_x = (X);                             \
1660   (X) = hppa_legitimize_address (X, OLDX, MODE);        \
1661   if ((X) != orig_x && memory_address_p (MODE, X)) \
1662     goto WIN; }
1663
1664 /* Go to LABEL if ADDR (a legitimate address expression)
1665    has an effect that depends on the machine mode it is used for.  */
1666
1667 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)        \
1668   if (GET_CODE (ADDR) == PRE_DEC        \
1669       || GET_CODE (ADDR) == POST_DEC    \
1670       || GET_CODE (ADDR) == PRE_INC     \
1671       || GET_CODE (ADDR) == POST_INC)   \
1672     goto LABEL
1673 \f
1674 #define TARGET_ASM_SELECT_SECTION  pa_select_section
1675
1676 /* Return a nonzero value if DECL has a section attribute.  */
1677 #define IN_NAMED_SECTION_P(DECL) \
1678   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
1679    && DECL_SECTION_NAME (DECL) != NULL_TREE)
1680
1681 /* The following extra sections and extra section functions are only used
1682    for SOM, but they must be provided unconditionally because pa.c's calls
1683    to the functions might not get optimized out when other object formats
1684    are in use.  */
1685
1686 #define EXTRA_SECTIONS                                                  \
1687   in_som_readonly_data,                                                 \
1688   in_som_one_only_readonly_data,                                        \
1689   in_som_one_only_data
1690
1691 #define EXTRA_SECTION_FUNCTIONS                                         \
1692   SOM_READONLY_DATA_SECTION_FUNCTION                                    \
1693   SOM_ONE_ONLY_READONLY_DATA_SECTION_FUNCTION                           \
1694   SOM_ONE_ONLY_DATA_SECTION_FUNCTION                                    \
1695   FORGET_SECTION_FUNCTION
1696
1697 /* SOM puts readonly data in the default $LIT$ subspace when PIC code
1698    is not being generated.  */
1699 #define SOM_READONLY_DATA_SECTION_FUNCTION                              \
1700 void                                                                    \
1701 som_readonly_data_section (void)                                        \
1702 {                                                                       \
1703   if (!TARGET_SOM)                                                      \
1704     return;                                                             \
1705   if (in_section != in_som_readonly_data)                               \
1706     {                                                                   \
1707       in_section = in_som_readonly_data;                                \
1708       fputs ("\t.SPACE $TEXT$\n\t.SUBSPA $LIT$\n", asm_out_file);       \
1709     }                                                                   \
1710 }
1711
1712 /* When secondary definitions are not supported, SOM makes readonly data one
1713    only by creating a new $LIT$ subspace in $TEXT$ with the comdat flag.  */
1714 #define SOM_ONE_ONLY_READONLY_DATA_SECTION_FUNCTION                     \
1715 void                                                                    \
1716 som_one_only_readonly_data_section (void)                               \
1717 {                                                                       \
1718   if (!TARGET_SOM)                                                      \
1719     return;                                                             \
1720   in_section = in_som_one_only_readonly_data;                           \
1721   fputs ("\t.SPACE $TEXT$\n"                                            \
1722          "\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=0x2c,SORT=16,COMDAT\n",\
1723          asm_out_file);                                                 \
1724 }
1725
1726 /* When secondary definitions are not supported, SOM makes data one only by
1727    creating a new $DATA$ subspace in $PRIVATE$ with the comdat flag.  */
1728 #define SOM_ONE_ONLY_DATA_SECTION_FUNCTION                              \
1729 void                                                                    \
1730 som_one_only_data_section (void)                                        \
1731 {                                                                       \
1732   if (!TARGET_SOM)                                                      \
1733     return;                                                             \
1734   in_section = in_som_one_only_data;                                    \
1735   fputs ("\t.SPACE $PRIVATE$\n"                                         \
1736          "\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31,SORT=24,COMDAT\n", \
1737          asm_out_file);                                                 \
1738 }
1739
1740 #define FORGET_SECTION_FUNCTION                                         \
1741 void                                                                    \
1742 forget_section (void)                                                   \
1743 {                                                                       \
1744   in_section = no_section;                                              \
1745 }
1746
1747 /* Define this macro if references to a symbol must be treated
1748    differently depending on something about the variable or
1749    function named by the symbol (such as what section it is in).
1750
1751    The macro definition, if any, is executed immediately after the
1752    rtl for DECL or other node is created.
1753    The value of the rtl will be a `mem' whose address is a
1754    `symbol_ref'.
1755
1756    The usual thing for this macro to do is to a flag in the
1757    `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
1758    name string in the `symbol_ref' (if one bit is not enough
1759    information).
1760
1761    On the HP-PA we use this to indicate if a symbol is in text or
1762    data space.  Also, function labels need special treatment.  */
1763
1764 #define TEXT_SPACE_P(DECL)\
1765   (TREE_CODE (DECL) == FUNCTION_DECL                                    \
1766    || (TREE_CODE (DECL) == VAR_DECL                                     \
1767        && TREE_READONLY (DECL) && ! TREE_SIDE_EFFECTS (DECL)            \
1768        && (! DECL_INITIAL (DECL) || ! reloc_needed (DECL_INITIAL (DECL))) \
1769        && !flag_pic)                                                    \
1770    || CONSTANT_CLASS_P (DECL))
1771
1772 #define FUNCTION_NAME_P(NAME)  (*(NAME) == '@')
1773
1774 /* Specify the machine mode that this machine uses for the index in the
1775    tablejump instruction.  For small tables, an element consists of a
1776    ia-relative branch and its delay slot.  When -mbig-switch is specified,
1777    we use a 32-bit absolute address for non-pic code, and a 32-bit offset
1778    for both 32 and 64-bit pic code.  */
1779 #define CASE_VECTOR_MODE (TARGET_BIG_SWITCH ? SImode : DImode)
1780
1781 /* Jump tables must be 32-bit aligned, no matter the size of the element.  */
1782 #define ADDR_VEC_ALIGN(ADDR_VEC) 2
1783
1784 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1785 #define DEFAULT_SIGNED_CHAR 1
1786
1787 /* Max number of bytes we can move from memory to memory
1788    in one reasonably fast instruction.  */
1789 #define MOVE_MAX 8
1790
1791 /* Higher than the default as we prefer to use simple move insns
1792    (better scheduling and delay slot filling) and because our
1793    built-in block move is really a 2X unrolled loop. 
1794
1795    Believe it or not, this has to be big enough to allow for copying all
1796    arguments passed in registers to avoid infinite recursion during argument
1797    setup for a function call.  Why?  Consider how we copy the stack slots
1798    reserved for parameters when they may be trashed by a call.  */
1799 #define MOVE_RATIO (TARGET_64BIT ? 8 : 4)
1800
1801 /* Define if operations between registers always perform the operation
1802    on the full register even if a narrower mode is specified.  */
1803 #define WORD_REGISTER_OPERATIONS
1804
1805 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
1806    will either zero-extend or sign-extend.  The value of this macro should
1807    be the code that says which one of the two operations is implicitly
1808    done, UNKNOWN if none.  */
1809 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
1810
1811 /* Nonzero if access to memory by bytes is slow and undesirable.  */
1812 #define SLOW_BYTE_ACCESS 1
1813
1814 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1815    is done just by pretending it is already truncated.  */
1816 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1817
1818 /* Specify the machine mode that pointers have.
1819    After generation of rtl, the compiler makes no further distinction
1820    between pointers and any other objects of this machine mode.  */
1821 #define Pmode word_mode
1822
1823 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
1824    return the mode to be used for the comparison.  For floating-point, CCFPmode
1825    should be used.  CC_NOOVmode should be used when the first operand is a
1826    PLUS, MINUS, or NEG.  CCmode should be used when no special processing is
1827    needed.  */
1828 #define SELECT_CC_MODE(OP,X,Y) \
1829   (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT ? CCFPmode : CCmode)    \
1830
1831 /* A function address in a call instruction
1832    is a byte address (for indexing purposes)
1833    so give the MEM rtx a byte's mode.  */
1834 #define FUNCTION_MODE SImode
1835
1836 /* Define this if addresses of constant functions
1837    shouldn't be put through pseudo regs where they can be cse'd.
1838    Desirable on machines where ordinary constants are expensive
1839    but a CALL with constant address is cheap.  */
1840 #define NO_FUNCTION_CSE
1841
1842 /* Define this to be nonzero if shift instructions ignore all but the low-order
1843    few bits.  */
1844 #define SHIFT_COUNT_TRUNCATED 1
1845
1846 /* Compute extra cost of moving data between one register class
1847    and another.
1848
1849    Make moves from SAR so expensive they should never happen.  We used to
1850    have 0xffff here, but that generates overflow in rare cases.
1851
1852    Copies involving a FP register and a non-FP register are relatively
1853    expensive because they must go through memory.
1854
1855    Other copies are reasonably cheap.  */
1856 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
1857  (CLASS1 == SHIFT_REGS ? 0x100                                  \
1858   : FP_REG_CLASS_P (CLASS1) && ! FP_REG_CLASS_P (CLASS2) ? 16   \
1859   : FP_REG_CLASS_P (CLASS2) && ! FP_REG_CLASS_P (CLASS1) ? 16   \
1860   : 2)
1861
1862 /* Adjust the cost of branches.  */
1863 #define BRANCH_COST (pa_cpu == PROCESSOR_8000 ? 2 : 1)
1864
1865 /* Handling the special cases is going to get too complicated for a macro,
1866    just call `pa_adjust_insn_length' to do the real work.  */
1867 #define ADJUST_INSN_LENGTH(INSN, LENGTH)        \
1868   LENGTH += pa_adjust_insn_length (INSN, LENGTH);
1869
1870 /* Millicode insns are actually function calls with some special
1871    constraints on arguments and register usage.
1872
1873    Millicode calls always expect their arguments in the integer argument
1874    registers, and always return their result in %r29 (ret1).  They
1875    are expected to clobber their arguments, %r1, %r29, and the return
1876    pointer which is %r31 on 32-bit and %r2 on 64-bit, and nothing else.
1877
1878    This macro tells reorg that the references to arguments and
1879    millicode calls do not appear to happen until after the millicode call.
1880    This allows reorg to put insns which set the argument registers into the
1881    delay slot of the millicode call -- thus they act more like traditional
1882    CALL_INSNs.
1883
1884    Note we cannot consider side effects of the insn to be delayed because
1885    the branch and link insn will clobber the return pointer.  If we happened
1886    to use the return pointer in the delay slot of the call, then we lose.
1887
1888    get_attr_type will try to recognize the given insn, so make sure to
1889    filter out things it will not accept -- SEQUENCE, USE and CLOBBER insns
1890    in particular.  */
1891 #define INSN_REFERENCES_ARE_DELAYED(X) (insn_refs_are_delayed (X))
1892
1893 \f
1894 /* Control the assembler format that we output.  */
1895
1896 /* A C string constant describing how to begin a comment in the target
1897    assembler language.  The compiler assumes that the comment will end at
1898    the end of the line.  */
1899
1900 #define ASM_COMMENT_START ";"
1901
1902 /* Output to assembler file text saying following lines
1903    may contain character constants, extra white space, comments, etc.  */
1904
1905 #define ASM_APP_ON ""
1906
1907 /* Output to assembler file text saying following lines
1908    no longer contain unusual constructs.  */
1909
1910 #define ASM_APP_OFF ""
1911
1912 /* This is how to output the definition of a user-level label named NAME,
1913    such as the label on a static function or variable NAME.  */
1914
1915 #define ASM_OUTPUT_LABEL(FILE, NAME)    \
1916   do { assemble_name (FILE, NAME);      \
1917        fputc ('\n', FILE); } while (0)
1918
1919 /* This is how to output a reference to a user-level label named NAME.
1920    `assemble_name' uses this.  */
1921
1922 #define ASM_OUTPUT_LABELREF(FILE,NAME)  \
1923   do {                                  \
1924     const char *xname = (NAME);         \
1925     if (FUNCTION_NAME_P (NAME))         \
1926       xname += 1;                       \
1927     if (xname[0] == '*')                \
1928       xname += 1;                       \
1929     else                                \
1930       fputs (user_label_prefix, FILE);  \
1931     fputs (xname, FILE);                \
1932   } while (0)
1933
1934 /* This is how to store into the string LABEL
1935    the symbol_ref name of an internal numbered label where
1936    PREFIX is the class of label and NUM is the number within the class.
1937    This is suitable for output with `assemble_name'.  */
1938
1939 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
1940   sprintf (LABEL, "*%c$%s%04ld", (PREFIX)[0], (PREFIX) + 1, (long)(NUM))
1941
1942 #define TARGET_ASM_GLOBALIZE_LABEL pa_globalize_label
1943
1944 #define ASM_OUTPUT_ASCII(FILE, P, SIZE)  \
1945   output_ascii ((FILE), (P), (SIZE))
1946
1947 /* Jump tables are always placed in the text section.  Technically, it
1948    is possible to put them in the readonly data section when -mbig-switch
1949    is specified.  This has the benefit of getting the table out of .text
1950    and reducing branch lengths as a result.  The downside is that an
1951    additional insn (addil) is needed to access the table when generating
1952    PIC code.  The address difference table also has to use 32-bit
1953    pc-relative relocations.  Currently, GAS does not support these
1954    relocations, although it is easily modified to do this operation.
1955    The table entries need to look like "$L1+(.+8-$L0)-$PIC_pcrel$0"
1956    when using ELF GAS.  A simple difference can be used when using
1957    SOM GAS or the HP assembler.  The final downside is GDB complains
1958    about the nesting of the label for the table when debugging.  */
1959
1960 #define JUMP_TABLES_IN_TEXT_SECTION 1
1961
1962 /* This is how to output an element of a case-vector that is absolute.  */
1963
1964 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
1965   if (TARGET_BIG_SWITCH)                                                \
1966     fprintf (FILE, "\t.word L$%04d\n", VALUE);                          \
1967   else                                                                  \
1968     fprintf (FILE, "\tb L$%04d\n\tnop\n", VALUE)
1969
1970 /* This is how to output an element of a case-vector that is relative. 
1971    Since we always place jump tables in the text section, the difference
1972    is absolute and requires no relocation.  */
1973
1974 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)  \
1975   if (TARGET_BIG_SWITCH)                                                \
1976     fprintf (FILE, "\t.word L$%04d-L$%04d\n", VALUE, REL);              \
1977   else                                                                  \
1978     fprintf (FILE, "\tb L$%04d\n\tnop\n", VALUE)
1979
1980 /* This is how to output an assembler line that says to advance the
1981    location counter to a multiple of 2**LOG bytes.  */
1982
1983 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
1984     fprintf (FILE, "\t.align %d\n", (1<<(LOG)))
1985
1986 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
1987   fprintf (FILE, "\t.blockz "HOST_WIDE_INT_PRINT_UNSIGNED"\n",          \
1988            (unsigned HOST_WIDE_INT)(SIZE))
1989
1990 /* This says how to output an assembler line to define an uninitialized
1991    global variable with size SIZE (in bytes) and alignment ALIGN (in bits).
1992    This macro exists to properly support languages like C++ which do not
1993    have common data.  */
1994
1995 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN)           \
1996   pa_asm_output_aligned_bss (FILE, NAME, SIZE, ALIGN)
1997   
1998 /* This says how to output an assembler line to define a global common symbol
1999    with size SIZE (in bytes) and alignment ALIGN (in bits).  */
2000
2001 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
2002   pa_asm_output_aligned_common (FILE, NAME, SIZE, ALIGN)
2003
2004 /* This says how to output an assembler line to define a local common symbol
2005    with size SIZE (in bytes) and alignment ALIGN (in bits).  This macro
2006    controls how the assembler definitions of uninitialized static variables
2007    are output.  */
2008
2009 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
2010   pa_asm_output_aligned_local (FILE, NAME, SIZE, ALIGN)
2011   
2012   
2013 #define ASM_PN_FORMAT "%s___%lu"
2014
2015 /* All HP assemblers use "!" to separate logical lines.  */
2016 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '!')
2017
2018 #define PRINT_OPERAND_PUNCT_VALID_P(CHAR) \
2019   ((CHAR) == '@' || (CHAR) == '#' || (CHAR) == '*' || (CHAR) == '^')
2020
2021 /* Print operand X (an rtx) in assembler syntax to file FILE.
2022    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
2023    For `%' followed by punctuation, CODE is the punctuation and X is null.
2024
2025    On the HP-PA, the CODE can be `r', meaning this is a register-only operand
2026    and an immediate zero should be represented as `r0'.
2027
2028    Several % codes are defined:
2029    O an operation
2030    C compare conditions
2031    N extract conditions
2032    M modifier to handle preincrement addressing for memory refs.
2033    F modifier to handle preincrement addressing for fp memory refs */
2034
2035 #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
2036
2037 \f
2038 /* Print a memory address as an operand to reference that memory location.  */
2039
2040 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
2041 { register rtx addr = ADDR;                                             \
2042   register rtx base;                                                    \
2043   int offset;                                                           \
2044   switch (GET_CODE (addr))                                              \
2045     {                                                                   \
2046     case REG:                                                           \
2047       fprintf (FILE, "0(%s)", reg_names [REGNO (addr)]);                \
2048       break;                                                            \
2049     case PLUS:                                                          \
2050       if (GET_CODE (XEXP (addr, 0)) == CONST_INT)                       \
2051         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);        \
2052       else if (GET_CODE (XEXP (addr, 1)) == CONST_INT)                  \
2053         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);        \
2054       else                                                              \
2055         abort ();                                                       \
2056       fprintf (FILE, "%d(%s)", offset, reg_names [REGNO (base)]);       \
2057       break;                                                            \
2058     case LO_SUM:                                                        \
2059       if (!symbolic_operand (XEXP (addr, 1), VOIDmode))                 \
2060         fputs ("R'", FILE);                                             \
2061       else if (flag_pic == 0)                                           \
2062         fputs ("RR'", FILE);                                            \
2063       else                                                              \
2064         fputs ("RT'", FILE);                                            \
2065       output_global_address (FILE, XEXP (addr, 1), 0);                  \
2066       fputs ("(", FILE);                                                \
2067       output_operand (XEXP (addr, 0), 0);                               \
2068       fputs (")", FILE);                                                \
2069       break;                                                            \
2070     case CONST_INT:                                                     \
2071       fprintf (FILE, HOST_WIDE_INT_PRINT_DEC "(%%r0)", INTVAL (addr));  \
2072       break;                                                            \
2073     default:                                                            \
2074       output_addr_const (FILE, addr);                                   \
2075     }}
2076
2077 \f
2078 /* Find the return address associated with the frame given by
2079    FRAMEADDR.  */
2080 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)                                \
2081   (return_addr_rtx (COUNT, FRAMEADDR))
2082
2083 /* Used to mask out junk bits from the return address, such as
2084    processor state, interrupt status, condition codes and the like.  */
2085 #define MASK_RETURN_ADDR                                                \
2086   /* The privilege level is in the two low order bits, mask em out      \
2087      of the return address.  */                                         \
2088   (GEN_INT (-4))
2089
2090 /* The number of Pmode words for the setjmp buffer.  */
2091 #define JMP_BUF_SIZE 50
2092
2093 #define PREDICATE_CODES                                                 \
2094   {"reg_or_0_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE}},         \
2095   {"call_operand_address", {LABEL_REF, SYMBOL_REF, CONST_INT,           \
2096                             CONST_DOUBLE, CONST, HIGH}},                 \
2097   {"indexed_memory_operand", {SUBREG, MEM}},                            \
2098   {"symbolic_operand", {SYMBOL_REF, LABEL_REF, CONST}},                 \
2099   {"symbolic_memory_operand", {SUBREG, MEM}},                           \
2100   {"reg_before_reload_operand", {REG, MEM}},                            \
2101   {"reg_or_0_or_nonsymb_mem_operand", {SUBREG, REG, MEM, CONST_INT,     \
2102                                        CONST_DOUBLE}},                  \
2103   {"move_dest_operand", {SUBREG, REG, MEM}},                            \
2104   {"move_src_operand", {SUBREG, REG, CONST_INT, MEM}},                  \
2105   {"prefetch_operand", {MEM}},                                          \
2106   {"reg_or_cint_move_operand", {SUBREG, REG, CONST_INT}},               \
2107   {"pic_label_operand", {LABEL_REF, CONST}},                            \
2108   {"fp_reg_operand", {REG}},                                            \
2109   {"arith_operand", {SUBREG, REG, CONST_INT}},                          \
2110   {"arith11_operand", {SUBREG, REG, CONST_INT}},                        \
2111   {"pre_cint_operand", {CONST_INT}},                                    \
2112   {"post_cint_operand", {CONST_INT}},                                   \
2113   {"arith_double_operand", {SUBREG, REG, CONST_DOUBLE}},                \
2114   {"ireg_or_int5_operand", {CONST_INT, REG}},                           \
2115   {"int5_operand", {CONST_INT}},                                        \
2116   {"uint5_operand", {CONST_INT}},                                       \
2117   {"int11_operand", {CONST_INT}},                                       \
2118   {"uint32_operand", {CONST_INT,                                        \
2119    HOST_BITS_PER_WIDE_INT > 32 ? 0 : CONST_DOUBLE}},                    \
2120   {"arith5_operand", {SUBREG, REG, CONST_INT}},                         \
2121   {"and_operand", {SUBREG, REG, CONST_INT}},                            \
2122   {"ior_operand", {CONST_INT}},                                         \
2123   {"lhs_lshift_cint_operand", {CONST_INT}},                             \
2124   {"lhs_lshift_operand", {SUBREG, REG, CONST_INT}},                     \
2125   {"arith32_operand", {SUBREG, REG, CONST_INT}},                        \
2126   {"pc_or_label_operand", {PC, LABEL_REF}},                             \
2127   {"plus_xor_ior_operator", {PLUS, XOR, IOR}},                          \
2128   {"shadd_operand", {CONST_INT}},                                       \
2129   {"div_operand", {REG, CONST_INT}},                                    \
2130   {"ireg_operand", {REG}},                                              \
2131   {"cmpib_comparison_operator", {EQ, NE, LT, LE, LEU,                   \
2132    GT, GTU, GE}},                                                       \
2133   {"movb_comparison_operator", {EQ, NE, LT, GE}},
2134
2135 /* We need a libcall to canonicalize function pointers on TARGET_ELF32.  */
2136 #define CANONICALIZE_FUNCPTR_FOR_COMPARE_LIBCALL \
2137   "__canonicalize_funcptr_for_compare"