OSDN Git Service

* pa-protos.h (prefetch_operand): Delete.
[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    `W' is a register indirect memory operand.  We could allow short
1302        displacements but GO_IF_LEGITIMATE_ADDRESS can't tell when a
1303        long displacement is valid.  This is only used for prefetch
1304        instructions with the `sl' completer.  */
1305
1306 #define EXTRA_CONSTRAINT(OP, C) \
1307   ((C) == 'Q' ?                                                         \
1308    (IS_RELOADING_PSEUDO_P (OP)                                          \
1309     || (GET_CODE (OP) == MEM                                            \
1310         && (reload_in_progress                                          \
1311             || memory_address_p (GET_MODE (OP), XEXP (OP, 0)))          \
1312         && !symbolic_memory_operand (OP, VOIDmode)                      \
1313         && !IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0))                         \
1314         && !IS_INDEX_ADDR_P (XEXP (OP, 0))))                            \
1315    : ((C) == 'W' ?                                                      \
1316       (GET_CODE (OP) == MEM                                             \
1317        && REG_P (XEXP (OP, 0))                                          \
1318        && REG_OK_FOR_BASE_P (XEXP (OP, 0)))                             \
1319    : ((C) == 'A' ?                                                      \
1320       (GET_CODE (OP) == MEM                                             \
1321        && IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0)))                          \
1322    : ((C) == 'R' ?                                                      \
1323       (GET_CODE (OP) == MEM                                             \
1324        && IS_INDEX_ADDR_P (XEXP (OP, 0)))                               \
1325    : ((C) == 'T' ?                                                      \
1326       (GET_CODE (OP) == MEM                                             \
1327        && !IS_LO_SUM_DLT_ADDR_P (XEXP (OP, 0))                          \
1328        && !IS_INDEX_ADDR_P (XEXP (OP, 0))                               \
1329        /* Floating-point loads and stores are used to load              \
1330           integer values as well as floating-point values.              \
1331           They don't have the same set of REG+D address modes           \
1332           as integer loads and stores.  PA 1.x supports only            \
1333           short displacements.  PA 2.0 supports long displacements      \
1334           but the base register needs to be aligned.                    \
1335                                                                         \
1336           The checks in GO_IF_LEGITIMATE_ADDRESS for SFmode and         \
1337           DFmode test the validity of an address for use in a           \
1338           floating point load or store.  So, we use SFmode/DFmode       \
1339           to see if the address is valid for a floating-point           \
1340           load/store operation.  */                                     \
1341        && memory_address_p ((GET_MODE_SIZE (GET_MODE (OP)) == 4         \
1342                              ? SFmode                                   \
1343                              : DFmode),                                 \
1344                             XEXP (OP, 0)))                              \
1345    : ((C) == 'S' ?                                                      \
1346       (GET_CODE (OP) == CONST_INT && INTVAL (OP) == 31)                 \
1347    : ((C) == 'U' ?                                                      \
1348       (GET_CODE (OP) == CONST_INT && INTVAL (OP) == 63) : 0)))))))
1349         
1350
1351 /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
1352    and check its validity for a certain class.
1353    We have two alternate definitions for each of them.
1354    The usual definition accepts all pseudo regs; the other rejects
1355    them unless they have been allocated suitable hard regs.
1356    The symbol REG_OK_STRICT causes the latter definition to be used.
1357
1358    Most source files want to accept pseudo regs in the hope that
1359    they will get allocated to the class that the insn wants them to be in.
1360    Source files for reload pass need to be strict.
1361    After reload, it makes no difference, since pseudo regs have
1362    been eliminated by then.  */
1363
1364 #ifndef REG_OK_STRICT
1365
1366 /* Nonzero if X is a hard reg that can be used as an index
1367    or if it is a pseudo reg.  */
1368 #define REG_OK_FOR_INDEX_P(X) \
1369 (REGNO (X) && (REGNO (X) < 32 || REGNO (X) >= FIRST_PSEUDO_REGISTER))
1370 /* Nonzero if X is a hard reg that can be used as a base reg
1371    or if it is a pseudo reg.  */
1372 #define REG_OK_FOR_BASE_P(X) \
1373 (REGNO (X) && (REGNO (X) < 32 || REGNO (X) >= FIRST_PSEUDO_REGISTER))
1374
1375 #else
1376
1377 /* Nonzero if X is a hard reg that can be used as an index.  */
1378 #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
1379 /* Nonzero if X is a hard reg that can be used as a base reg.  */
1380 #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
1381
1382 #endif
1383 \f
1384 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression that is a
1385    valid memory address for an instruction.  The MODE argument is the
1386    machine mode for the MEM expression that wants to use this address.
1387
1388    On HP PA-RISC, the legitimate address forms are REG+SMALLINT,
1389    REG+REG, and REG+(REG*SCALE).  The indexed address forms are only
1390    available with floating point loads and stores, and integer loads.
1391    We get better code by allowing indexed addresses in the initial
1392    RTL generation.
1393
1394    The acceptance of indexed addresses as legitimate implies that we
1395    must provide patterns for doing indexed integer stores, or the move
1396    expanders must force the address of an indexed store to a register.
1397    We have adopted the latter approach.
1398    
1399    Another function of GO_IF_LEGITIMATE_ADDRESS is to ensure that
1400    the base register is a valid pointer for indexed instructions.
1401    On targets that have non-equivalent space registers, we have to
1402    know at the time of assembler output which register in a REG+REG
1403    pair is the base register.  The REG_POINTER flag is sometimes lost
1404    in reload and the following passes, so it can't be relied on during
1405    code generation.  Thus, we either have to canonicalize the order
1406    of the registers in REG+REG indexed addresses, or treat REG+REG
1407    addresses separately and provide patterns for both permutations.
1408
1409    The latter approach requires several hundred additional lines of
1410    code in pa.md.  The downside to canonicalizing is that a PLUS
1411    in the wrong order can't combine to form to make a scaled indexed
1412    memory operand.  As we won't need to canonicalize the operands if
1413    the REG_POINTER lossage can be fixed, it seems better canonicalize.
1414
1415    We initially break out scaled indexed addresses in canonical order
1416    in emit_move_sequence.  LEGITIMIZE_ADDRESS also canonicalizes
1417    scaled indexed addresses during RTL generation.  However, fold_rtx
1418    has its own opinion on how the operands of a PLUS should be ordered.
1419    If one of the operands is equivalent to a constant, it will make
1420    that operand the second operand.  As the base register is likely to
1421    be equivalent to a SYMBOL_REF, we have made it the second operand.
1422
1423    GO_IF_LEGITIMATE_ADDRESS accepts REG+REG as legitimate when the
1424    operands are in the order INDEX+BASE on targets with non-equivalent
1425    space registers, and in any order on targets with equivalent space
1426    registers.  It accepts both MULT+BASE and BASE+MULT for scaled indexing.
1427
1428    We treat a SYMBOL_REF as legitimate if it is part of the current
1429    function's constant-pool, because such addresses can actually be
1430    output as REG+SMALLINT. 
1431
1432    Note we only allow 5 bit immediates for access to a constant address;
1433    doing so avoids losing for loading/storing a FP register at an address
1434    which will not fit in 5 bits.  */
1435
1436 #define VAL_5_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x10 < 0x20)
1437 #define INT_5_BITS(X) VAL_5_BITS_P (INTVAL (X))
1438
1439 #define VAL_U5_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) < 0x20)
1440 #define INT_U5_BITS(X) VAL_U5_BITS_P (INTVAL (X))
1441
1442 #define VAL_11_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x400 < 0x800)
1443 #define INT_11_BITS(X) VAL_11_BITS_P (INTVAL (X))
1444
1445 #define VAL_14_BITS_P(X) ((unsigned HOST_WIDE_INT)(X) + 0x2000 < 0x4000)
1446 #define INT_14_BITS(X) VAL_14_BITS_P (INTVAL (X))
1447
1448 #if HOST_BITS_PER_WIDE_INT > 32
1449 #define VAL_32_BITS_P(X) \
1450   ((unsigned HOST_WIDE_INT)(X) + ((unsigned HOST_WIDE_INT) 1 << 31)    \
1451    < (unsigned HOST_WIDE_INT) 2 << 31)
1452 #else
1453 #define VAL_32_BITS_P(X) 1
1454 #endif
1455 #define INT_32_BITS(X) VAL_32_BITS_P (INTVAL (X))
1456
1457 /* These are the modes that we allow for scaled indexing.  */
1458 #define MODE_OK_FOR_SCALED_INDEXING_P(MODE) \
1459   ((TARGET_64BIT && (MODE) == DImode)                                   \
1460    || (MODE) == SImode                                                  \
1461    || (MODE) == HImode                                                  \
1462    || (!TARGET_SOFT_FLOAT && ((MODE) == DFmode || (MODE) == SFmode)))
1463
1464 /* These are the modes that we allow for unscaled indexing.  */
1465 #define MODE_OK_FOR_UNSCALED_INDEXING_P(MODE) \
1466   ((TARGET_64BIT && (MODE) == DImode)                                   \
1467    || (MODE) == SImode                                                  \
1468    || (MODE) == HImode                                                  \
1469    || (MODE) == QImode                                                  \
1470    || (!TARGET_SOFT_FLOAT && ((MODE) == DFmode || (MODE) == SFmode)))
1471
1472 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \
1473 {                                                                       \
1474   if ((REG_P (X) && REG_OK_FOR_BASE_P (X))                              \
1475       || ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_DEC          \
1476            || GET_CODE (X) == PRE_INC || GET_CODE (X) == POST_INC)      \
1477           && REG_P (XEXP (X, 0))                                        \
1478           && REG_OK_FOR_BASE_P (XEXP (X, 0))))                          \
1479     goto ADDR;                                                          \
1480   else if (GET_CODE (X) == PLUS)                                        \
1481     {                                                                   \
1482       rtx base = 0, index = 0;                                          \
1483       if (REG_P (XEXP (X, 1))                                           \
1484           && REG_OK_FOR_BASE_P (XEXP (X, 1)))                           \
1485         base = XEXP (X, 1), index = XEXP (X, 0);                        \
1486       else if (REG_P (XEXP (X, 0))                                      \
1487                && REG_OK_FOR_BASE_P (XEXP (X, 0)))                      \
1488         base = XEXP (X, 0), index = XEXP (X, 1);                        \
1489       if (base                                                          \
1490           && GET_CODE (index) == CONST_INT                              \
1491           && ((INT_14_BITS (index)                                      \
1492                && (((MODE) != DImode                                    \
1493                     && (MODE) != SFmode                                 \
1494                     && (MODE) != DFmode)                                \
1495                    /* The base register for DImode loads and stores     \
1496                       with long displacements must be aligned because   \
1497                       the lower three bits in the displacement are      \
1498                       assumed to be zero.  */                           \
1499                    || ((MODE) == DImode                                 \
1500                        && (!TARGET_64BIT                                \
1501                            || (INTVAL (index) % 8) == 0))               \
1502                    /* Similarly, the base register for SFmode/DFmode    \
1503                       loads and stores with long displacements must     \
1504                       be aligned.                                       \
1505                                                                         \
1506                       FIXME: the ELF32 linker clobbers the LSB of       \
1507                       the FP register number in PA 2.0 floating-point   \
1508                       insns with long displacements.  This is because   \
1509                       R_PARISC_DPREL14WR and other relocations like     \
1510                       it are not supported.  For now, we reject long    \
1511                       displacements on this target.  */                 \
1512                    || (((MODE) == SFmode || (MODE) == DFmode)           \
1513                        && (TARGET_SOFT_FLOAT                            \
1514                            || (TARGET_PA_20                             \
1515                                && !TARGET_ELF32                         \
1516                                && (INTVAL (index)                       \
1517                                    % GET_MODE_SIZE (MODE)) == 0)))))    \
1518                || INT_5_BITS (index)))                                  \
1519         goto ADDR;                                                      \
1520       if (!TARGET_DISABLE_INDEXING                                      \
1521           /* Only accept the "canonical" INDEX+BASE operand order       \
1522              on targets with non-equivalent space registers.  */        \
1523           && (TARGET_NO_SPACE_REGS                                      \
1524               ? (base && REG_P (index))                                 \
1525               : (base == XEXP (X, 1) && REG_P (index)                   \
1526                  && REG_POINTER (base) && !REG_POINTER (index)))        \
1527           && MODE_OK_FOR_UNSCALED_INDEXING_P (MODE)                     \
1528           && REG_OK_FOR_INDEX_P (index)                                 \
1529           && borx_reg_operand (base, Pmode)                             \
1530           && borx_reg_operand (index, Pmode))                           \
1531         goto ADDR;                                                      \
1532       if (!TARGET_DISABLE_INDEXING                                      \
1533           && base                                                       \
1534           && GET_CODE (index) == MULT                                   \
1535           && MODE_OK_FOR_SCALED_INDEXING_P (MODE)                       \
1536           && REG_P (XEXP (index, 0))                                    \
1537           && GET_MODE (XEXP (index, 0)) == Pmode                        \
1538           && REG_OK_FOR_INDEX_P (XEXP (index, 0))                       \
1539           && GET_CODE (XEXP (index, 1)) == CONST_INT                    \
1540           && INTVAL (XEXP (index, 1))                                   \
1541              == (HOST_WIDE_INT) GET_MODE_SIZE (MODE)                    \
1542           && borx_reg_operand (base, Pmode))                            \
1543         goto ADDR;                                                      \
1544     }                                                                   \
1545   else if (GET_CODE (X) == LO_SUM                                       \
1546            && GET_CODE (XEXP (X, 0)) == REG                             \
1547            && REG_OK_FOR_BASE_P (XEXP (X, 0))                           \
1548            && CONSTANT_P (XEXP (X, 1))                                  \
1549            && (TARGET_SOFT_FLOAT                                        \
1550                /* We can allow symbolic LO_SUM addresses for PA2.0.  */ \
1551                || (TARGET_PA_20                                         \
1552                    && !TARGET_ELF32                                     \
1553                    && GET_CODE (XEXP (X, 1)) != CONST_INT)              \
1554                || ((MODE) != SFmode                                     \
1555                    && (MODE) != DFmode)))                               \
1556     goto ADDR;                                                          \
1557   else if (GET_CODE (X) == LO_SUM                                       \
1558            && GET_CODE (XEXP (X, 0)) == SUBREG                          \
1559            && GET_CODE (SUBREG_REG (XEXP (X, 0))) == REG                \
1560            && REG_OK_FOR_BASE_P (SUBREG_REG (XEXP (X, 0)))              \
1561            && CONSTANT_P (XEXP (X, 1))                                  \
1562            && (TARGET_SOFT_FLOAT                                        \
1563                /* We can allow symbolic LO_SUM addresses for PA2.0.  */ \
1564                || (TARGET_PA_20                                         \
1565                    && !TARGET_ELF32                                     \
1566                    && GET_CODE (XEXP (X, 1)) != CONST_INT)              \
1567                || ((MODE) != SFmode                                     \
1568                    && (MODE) != DFmode)))                               \
1569     goto ADDR;                                                          \
1570   else if (GET_CODE (X) == LABEL_REF                                    \
1571            || (GET_CODE (X) == CONST_INT                                \
1572                && INT_5_BITS (X)))                                      \
1573     goto ADDR;                                                          \
1574   /* Needed for -fPIC */                                                \
1575   else if (GET_CODE (X) == LO_SUM                                       \
1576            && GET_CODE (XEXP (X, 0)) == REG                             \
1577            && REG_OK_FOR_BASE_P (XEXP (X, 0))                           \
1578            && GET_CODE (XEXP (X, 1)) == UNSPEC                          \
1579            && (TARGET_SOFT_FLOAT                                        \
1580                || (TARGET_PA_20 && !TARGET_ELF32)                       \
1581                || ((MODE) != SFmode                                     \
1582                    && (MODE) != DFmode)))                               \
1583     goto ADDR;                                                          \
1584 }
1585
1586 /* Look for machine dependent ways to make the invalid address AD a
1587    valid address.
1588
1589    For the PA, transform:
1590
1591         memory(X + <large int>)
1592
1593    into:
1594
1595         if (<large int> & mask) >= 16
1596           Y = (<large int> & ~mask) + mask + 1  Round up.
1597         else
1598           Y = (<large int> & ~mask)             Round down.
1599         Z = X + Y
1600         memory (Z + (<large int> - Y));
1601
1602    This makes reload inheritance and reload_cse work better since Z
1603    can be reused.
1604
1605    There may be more opportunities to improve code with this hook.  */
1606 #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN)      \
1607 do {                                                                    \
1608   long offset, newoffset, mask;                                         \
1609   rtx new, temp = NULL_RTX;                                             \
1610                                                                         \
1611   mask = (GET_MODE_CLASS (MODE) == MODE_FLOAT                           \
1612           ? (TARGET_PA_20 && !TARGET_ELF32 ? 0x3fff : 0x1f) : 0x3fff);  \
1613                                                                         \
1614   if (optimize && GET_CODE (AD) == PLUS)                                \
1615     temp = simplify_binary_operation (PLUS, Pmode,                      \
1616                                       XEXP (AD, 0), XEXP (AD, 1));      \
1617                                                                         \
1618   new = temp ? temp : AD;                                               \
1619                                                                         \
1620   if (optimize                                                          \
1621       && GET_CODE (new) == PLUS                                         \
1622       && GET_CODE (XEXP (new, 0)) == REG                                \
1623       && GET_CODE (XEXP (new, 1)) == CONST_INT)                         \
1624     {                                                                   \
1625       offset = INTVAL (XEXP ((new), 1));                                \
1626                                                                         \
1627       /* Choose rounding direction.  Round up if we are >= halfway.  */ \
1628       if ((offset & mask) >= ((mask + 1) / 2))                          \
1629         newoffset = (offset & ~mask) + mask + 1;                        \
1630       else                                                              \
1631         newoffset = offset & ~mask;                                     \
1632                                                                         \
1633       /* Ensure that long displacements are aligned.  */                \
1634       if (!VAL_5_BITS_P (newoffset)                                     \
1635           && GET_MODE_CLASS (MODE) == MODE_FLOAT)                       \
1636         newoffset &= ~(GET_MODE_SIZE (MODE) -1);                        \
1637                                                                         \
1638       if (newoffset != 0 && VAL_14_BITS_P (newoffset))                  \
1639         {                                                               \
1640           temp = gen_rtx_PLUS (Pmode, XEXP (new, 0),                    \
1641                                GEN_INT (newoffset));                    \
1642           AD = gen_rtx_PLUS (Pmode, temp, GEN_INT (offset - newoffset));\
1643           push_reload (XEXP (AD, 0), 0, &XEXP (AD, 0), 0,               \
1644                        BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,           \
1645                        (OPNUM), (TYPE));                                \
1646           goto WIN;                                                     \
1647         }                                                               \
1648     }                                                                   \
1649 } while (0)
1650
1651
1652
1653 \f
1654 /* Try machine-dependent ways of modifying an illegitimate address
1655    to be legitimate.  If we find one, return the new, valid address.
1656    This macro is used in only one place: `memory_address' in explow.c.
1657
1658    OLDX is the address as it was before break_out_memory_refs was called.
1659    In some cases it is useful to look at this to decide what needs to be done.
1660
1661    MODE and WIN are passed so that this macro can use
1662    GO_IF_LEGITIMATE_ADDRESS.
1663
1664    It is always safe for this macro to do nothing.  It exists to recognize
1665    opportunities to optimize the output.  */
1666
1667 #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN)  \
1668 { rtx orig_x = (X);                             \
1669   (X) = hppa_legitimize_address (X, OLDX, MODE);        \
1670   if ((X) != orig_x && memory_address_p (MODE, X)) \
1671     goto WIN; }
1672
1673 /* Go to LABEL if ADDR (a legitimate address expression)
1674    has an effect that depends on the machine mode it is used for.  */
1675
1676 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)        \
1677   if (GET_CODE (ADDR) == PRE_DEC        \
1678       || GET_CODE (ADDR) == POST_DEC    \
1679       || GET_CODE (ADDR) == PRE_INC     \
1680       || GET_CODE (ADDR) == POST_INC)   \
1681     goto LABEL
1682 \f
1683 #define TARGET_ASM_SELECT_SECTION  pa_select_section
1684
1685 /* Return a nonzero value if DECL has a section attribute.  */
1686 #define IN_NAMED_SECTION_P(DECL) \
1687   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
1688    && DECL_SECTION_NAME (DECL) != NULL_TREE)
1689
1690 /* The following extra sections and extra section functions are only used
1691    for SOM, but they must be provided unconditionally because pa.c's calls
1692    to the functions might not get optimized out when other object formats
1693    are in use.  */
1694
1695 #define EXTRA_SECTIONS                                                  \
1696   in_som_readonly_data,                                                 \
1697   in_som_one_only_readonly_data,                                        \
1698   in_som_one_only_data
1699
1700 #define EXTRA_SECTION_FUNCTIONS                                         \
1701   SOM_READONLY_DATA_SECTION_FUNCTION                                    \
1702   SOM_ONE_ONLY_READONLY_DATA_SECTION_FUNCTION                           \
1703   SOM_ONE_ONLY_DATA_SECTION_FUNCTION                                    \
1704   FORGET_SECTION_FUNCTION
1705
1706 /* SOM puts readonly data in the default $LIT$ subspace when PIC code
1707    is not being generated.  */
1708 #define SOM_READONLY_DATA_SECTION_FUNCTION                              \
1709 void                                                                    \
1710 som_readonly_data_section (void)                                        \
1711 {                                                                       \
1712   if (!TARGET_SOM)                                                      \
1713     return;                                                             \
1714   if (in_section != in_som_readonly_data)                               \
1715     {                                                                   \
1716       in_section = in_som_readonly_data;                                \
1717       fputs ("\t.SPACE $TEXT$\n\t.SUBSPA $LIT$\n", asm_out_file);       \
1718     }                                                                   \
1719 }
1720
1721 /* When secondary definitions are not supported, SOM makes readonly data one
1722    only by creating a new $LIT$ subspace in $TEXT$ with the comdat flag.  */
1723 #define SOM_ONE_ONLY_READONLY_DATA_SECTION_FUNCTION                     \
1724 void                                                                    \
1725 som_one_only_readonly_data_section (void)                               \
1726 {                                                                       \
1727   if (!TARGET_SOM)                                                      \
1728     return;                                                             \
1729   in_section = in_som_one_only_readonly_data;                           \
1730   fputs ("\t.SPACE $TEXT$\n"                                            \
1731          "\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=0x2c,SORT=16,COMDAT\n",\
1732          asm_out_file);                                                 \
1733 }
1734
1735 /* When secondary definitions are not supported, SOM makes data one only by
1736    creating a new $DATA$ subspace in $PRIVATE$ with the comdat flag.  */
1737 #define SOM_ONE_ONLY_DATA_SECTION_FUNCTION                              \
1738 void                                                                    \
1739 som_one_only_data_section (void)                                        \
1740 {                                                                       \
1741   if (!TARGET_SOM)                                                      \
1742     return;                                                             \
1743   in_section = in_som_one_only_data;                                    \
1744   fputs ("\t.SPACE $PRIVATE$\n"                                         \
1745          "\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31,SORT=24,COMDAT\n", \
1746          asm_out_file);                                                 \
1747 }
1748
1749 #define FORGET_SECTION_FUNCTION                                         \
1750 void                                                                    \
1751 forget_section (void)                                                   \
1752 {                                                                       \
1753   in_section = no_section;                                              \
1754 }
1755
1756 /* Define this macro if references to a symbol must be treated
1757    differently depending on something about the variable or
1758    function named by the symbol (such as what section it is in).
1759
1760    The macro definition, if any, is executed immediately after the
1761    rtl for DECL or other node is created.
1762    The value of the rtl will be a `mem' whose address is a
1763    `symbol_ref'.
1764
1765    The usual thing for this macro to do is to a flag in the
1766    `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
1767    name string in the `symbol_ref' (if one bit is not enough
1768    information).
1769
1770    On the HP-PA we use this to indicate if a symbol is in text or
1771    data space.  Also, function labels need special treatment.  */
1772
1773 #define TEXT_SPACE_P(DECL)\
1774   (TREE_CODE (DECL) == FUNCTION_DECL                                    \
1775    || (TREE_CODE (DECL) == VAR_DECL                                     \
1776        && TREE_READONLY (DECL) && ! TREE_SIDE_EFFECTS (DECL)            \
1777        && (! DECL_INITIAL (DECL) || ! reloc_needed (DECL_INITIAL (DECL))) \
1778        && !flag_pic)                                                    \
1779    || CONSTANT_CLASS_P (DECL))
1780
1781 #define FUNCTION_NAME_P(NAME)  (*(NAME) == '@')
1782
1783 /* Specify the machine mode that this machine uses for the index in the
1784    tablejump instruction.  For small tables, an element consists of a
1785    ia-relative branch and its delay slot.  When -mbig-switch is specified,
1786    we use a 32-bit absolute address for non-pic code, and a 32-bit offset
1787    for both 32 and 64-bit pic code.  */
1788 #define CASE_VECTOR_MODE (TARGET_BIG_SWITCH ? SImode : DImode)
1789
1790 /* Jump tables must be 32-bit aligned, no matter the size of the element.  */
1791 #define ADDR_VEC_ALIGN(ADDR_VEC) 2
1792
1793 /* Define this as 1 if `char' should by default be signed; else as 0.  */
1794 #define DEFAULT_SIGNED_CHAR 1
1795
1796 /* Max number of bytes we can move from memory to memory
1797    in one reasonably fast instruction.  */
1798 #define MOVE_MAX 8
1799
1800 /* Higher than the default as we prefer to use simple move insns
1801    (better scheduling and delay slot filling) and because our
1802    built-in block move is really a 2X unrolled loop. 
1803
1804    Believe it or not, this has to be big enough to allow for copying all
1805    arguments passed in registers to avoid infinite recursion during argument
1806    setup for a function call.  Why?  Consider how we copy the stack slots
1807    reserved for parameters when they may be trashed by a call.  */
1808 #define MOVE_RATIO (TARGET_64BIT ? 8 : 4)
1809
1810 /* Define if operations between registers always perform the operation
1811    on the full register even if a narrower mode is specified.  */
1812 #define WORD_REGISTER_OPERATIONS
1813
1814 /* Define if loading in MODE, an integral mode narrower than BITS_PER_WORD
1815    will either zero-extend or sign-extend.  The value of this macro should
1816    be the code that says which one of the two operations is implicitly
1817    done, UNKNOWN if none.  */
1818 #define LOAD_EXTEND_OP(MODE) ZERO_EXTEND
1819
1820 /* Nonzero if access to memory by bytes is slow and undesirable.  */
1821 #define SLOW_BYTE_ACCESS 1
1822
1823 /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
1824    is done just by pretending it is already truncated.  */
1825 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
1826
1827 /* Specify the machine mode that pointers have.
1828    After generation of rtl, the compiler makes no further distinction
1829    between pointers and any other objects of this machine mode.  */
1830 #define Pmode word_mode
1831
1832 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
1833    return the mode to be used for the comparison.  For floating-point, CCFPmode
1834    should be used.  CC_NOOVmode should be used when the first operand is a
1835    PLUS, MINUS, or NEG.  CCmode should be used when no special processing is
1836    needed.  */
1837 #define SELECT_CC_MODE(OP,X,Y) \
1838   (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT ? CCFPmode : CCmode)    \
1839
1840 /* A function address in a call instruction
1841    is a byte address (for indexing purposes)
1842    so give the MEM rtx a byte's mode.  */
1843 #define FUNCTION_MODE SImode
1844
1845 /* Define this if addresses of constant functions
1846    shouldn't be put through pseudo regs where they can be cse'd.
1847    Desirable on machines where ordinary constants are expensive
1848    but a CALL with constant address is cheap.  */
1849 #define NO_FUNCTION_CSE
1850
1851 /* Define this to be nonzero if shift instructions ignore all but the low-order
1852    few bits.  */
1853 #define SHIFT_COUNT_TRUNCATED 1
1854
1855 /* Compute extra cost of moving data between one register class
1856    and another.
1857
1858    Make moves from SAR so expensive they should never happen.  We used to
1859    have 0xffff here, but that generates overflow in rare cases.
1860
1861    Copies involving a FP register and a non-FP register are relatively
1862    expensive because they must go through memory.
1863
1864    Other copies are reasonably cheap.  */
1865 #define REGISTER_MOVE_COST(MODE, CLASS1, CLASS2) \
1866  (CLASS1 == SHIFT_REGS ? 0x100                                  \
1867   : FP_REG_CLASS_P (CLASS1) && ! FP_REG_CLASS_P (CLASS2) ? 16   \
1868   : FP_REG_CLASS_P (CLASS2) && ! FP_REG_CLASS_P (CLASS1) ? 16   \
1869   : 2)
1870
1871 /* Adjust the cost of branches.  */
1872 #define BRANCH_COST (pa_cpu == PROCESSOR_8000 ? 2 : 1)
1873
1874 /* Handling the special cases is going to get too complicated for a macro,
1875    just call `pa_adjust_insn_length' to do the real work.  */
1876 #define ADJUST_INSN_LENGTH(INSN, LENGTH)        \
1877   LENGTH += pa_adjust_insn_length (INSN, LENGTH);
1878
1879 /* Millicode insns are actually function calls with some special
1880    constraints on arguments and register usage.
1881
1882    Millicode calls always expect their arguments in the integer argument
1883    registers, and always return their result in %r29 (ret1).  They
1884    are expected to clobber their arguments, %r1, %r29, and the return
1885    pointer which is %r31 on 32-bit and %r2 on 64-bit, and nothing else.
1886
1887    This macro tells reorg that the references to arguments and
1888    millicode calls do not appear to happen until after the millicode call.
1889    This allows reorg to put insns which set the argument registers into the
1890    delay slot of the millicode call -- thus they act more like traditional
1891    CALL_INSNs.
1892
1893    Note we cannot consider side effects of the insn to be delayed because
1894    the branch and link insn will clobber the return pointer.  If we happened
1895    to use the return pointer in the delay slot of the call, then we lose.
1896
1897    get_attr_type will try to recognize the given insn, so make sure to
1898    filter out things it will not accept -- SEQUENCE, USE and CLOBBER insns
1899    in particular.  */
1900 #define INSN_REFERENCES_ARE_DELAYED(X) (insn_refs_are_delayed (X))
1901
1902 \f
1903 /* Control the assembler format that we output.  */
1904
1905 /* A C string constant describing how to begin a comment in the target
1906    assembler language.  The compiler assumes that the comment will end at
1907    the end of the line.  */
1908
1909 #define ASM_COMMENT_START ";"
1910
1911 /* Output to assembler file text saying following lines
1912    may contain character constants, extra white space, comments, etc.  */
1913
1914 #define ASM_APP_ON ""
1915
1916 /* Output to assembler file text saying following lines
1917    no longer contain unusual constructs.  */
1918
1919 #define ASM_APP_OFF ""
1920
1921 /* This is how to output the definition of a user-level label named NAME,
1922    such as the label on a static function or variable NAME.  */
1923
1924 #define ASM_OUTPUT_LABEL(FILE, NAME)    \
1925   do { assemble_name (FILE, NAME);      \
1926        fputc ('\n', FILE); } while (0)
1927
1928 /* This is how to output a reference to a user-level label named NAME.
1929    `assemble_name' uses this.  */
1930
1931 #define ASM_OUTPUT_LABELREF(FILE,NAME)  \
1932   do {                                  \
1933     const char *xname = (NAME);         \
1934     if (FUNCTION_NAME_P (NAME))         \
1935       xname += 1;                       \
1936     if (xname[0] == '*')                \
1937       xname += 1;                       \
1938     else                                \
1939       fputs (user_label_prefix, FILE);  \
1940     fputs (xname, FILE);                \
1941   } while (0)
1942
1943 /* This is how to store into the string LABEL
1944    the symbol_ref name of an internal numbered label where
1945    PREFIX is the class of label and NUM is the number within the class.
1946    This is suitable for output with `assemble_name'.  */
1947
1948 #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)   \
1949   sprintf (LABEL, "*%c$%s%04ld", (PREFIX)[0], (PREFIX) + 1, (long)(NUM))
1950
1951 #define TARGET_ASM_GLOBALIZE_LABEL pa_globalize_label
1952
1953 #define ASM_OUTPUT_ASCII(FILE, P, SIZE)  \
1954   output_ascii ((FILE), (P), (SIZE))
1955
1956 /* Jump tables are always placed in the text section.  Technically, it
1957    is possible to put them in the readonly data section when -mbig-switch
1958    is specified.  This has the benefit of getting the table out of .text
1959    and reducing branch lengths as a result.  The downside is that an
1960    additional insn (addil) is needed to access the table when generating
1961    PIC code.  The address difference table also has to use 32-bit
1962    pc-relative relocations.  Currently, GAS does not support these
1963    relocations, although it is easily modified to do this operation.
1964    The table entries need to look like "$L1+(.+8-$L0)-$PIC_pcrel$0"
1965    when using ELF GAS.  A simple difference can be used when using
1966    SOM GAS or the HP assembler.  The final downside is GDB complains
1967    about the nesting of the label for the table when debugging.  */
1968
1969 #define JUMP_TABLES_IN_TEXT_SECTION 1
1970
1971 /* This is how to output an element of a case-vector that is absolute.  */
1972
1973 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
1974   if (TARGET_BIG_SWITCH)                                                \
1975     fprintf (FILE, "\t.word L$%04d\n", VALUE);                          \
1976   else                                                                  \
1977     fprintf (FILE, "\tb L$%04d\n\tnop\n", VALUE)
1978
1979 /* This is how to output an element of a case-vector that is relative. 
1980    Since we always place jump tables in the text section, the difference
1981    is absolute and requires no relocation.  */
1982
1983 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)  \
1984   if (TARGET_BIG_SWITCH)                                                \
1985     fprintf (FILE, "\t.word L$%04d-L$%04d\n", VALUE, REL);              \
1986   else                                                                  \
1987     fprintf (FILE, "\tb L$%04d\n\tnop\n", VALUE)
1988
1989 /* This is how to output an assembler line that says to advance the
1990    location counter to a multiple of 2**LOG bytes.  */
1991
1992 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
1993     fprintf (FILE, "\t.align %d\n", (1<<(LOG)))
1994
1995 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
1996   fprintf (FILE, "\t.blockz "HOST_WIDE_INT_PRINT_UNSIGNED"\n",          \
1997            (unsigned HOST_WIDE_INT)(SIZE))
1998
1999 /* This says how to output an assembler line to define an uninitialized
2000    global variable with size SIZE (in bytes) and alignment ALIGN (in bits).
2001    This macro exists to properly support languages like C++ which do not
2002    have common data.  */
2003
2004 #define ASM_OUTPUT_ALIGNED_BSS(FILE, DECL, NAME, SIZE, ALIGN)           \
2005   pa_asm_output_aligned_bss (FILE, NAME, SIZE, ALIGN)
2006   
2007 /* This says how to output an assembler line to define a global common symbol
2008    with size SIZE (in bytes) and alignment ALIGN (in bits).  */
2009
2010 #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)              \
2011   pa_asm_output_aligned_common (FILE, NAME, SIZE, ALIGN)
2012
2013 /* This says how to output an assembler line to define a local common symbol
2014    with size SIZE (in bytes) and alignment ALIGN (in bits).  This macro
2015    controls how the assembler definitions of uninitialized static variables
2016    are output.  */
2017
2018 #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)               \
2019   pa_asm_output_aligned_local (FILE, NAME, SIZE, ALIGN)
2020   
2021   
2022 #define ASM_PN_FORMAT "%s___%lu"
2023
2024 /* All HP assemblers use "!" to separate logical lines.  */
2025 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == '!')
2026
2027 #define PRINT_OPERAND_PUNCT_VALID_P(CHAR) \
2028   ((CHAR) == '@' || (CHAR) == '#' || (CHAR) == '*' || (CHAR) == '^')
2029
2030 /* Print operand X (an rtx) in assembler syntax to file FILE.
2031    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
2032    For `%' followed by punctuation, CODE is the punctuation and X is null.
2033
2034    On the HP-PA, the CODE can be `r', meaning this is a register-only operand
2035    and an immediate zero should be represented as `r0'.
2036
2037    Several % codes are defined:
2038    O an operation
2039    C compare conditions
2040    N extract conditions
2041    M modifier to handle preincrement addressing for memory refs.
2042    F modifier to handle preincrement addressing for fp memory refs */
2043
2044 #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
2045
2046 \f
2047 /* Print a memory address as an operand to reference that memory location.  */
2048
2049 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
2050 { register rtx addr = ADDR;                                             \
2051   register rtx base;                                                    \
2052   int offset;                                                           \
2053   switch (GET_CODE (addr))                                              \
2054     {                                                                   \
2055     case REG:                                                           \
2056       fprintf (FILE, "0(%s)", reg_names [REGNO (addr)]);                \
2057       break;                                                            \
2058     case PLUS:                                                          \
2059       if (GET_CODE (XEXP (addr, 0)) == CONST_INT)                       \
2060         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);        \
2061       else if (GET_CODE (XEXP (addr, 1)) == CONST_INT)                  \
2062         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);        \
2063       else                                                              \
2064         abort ();                                                       \
2065       fprintf (FILE, "%d(%s)", offset, reg_names [REGNO (base)]);       \
2066       break;                                                            \
2067     case LO_SUM:                                                        \
2068       if (!symbolic_operand (XEXP (addr, 1), VOIDmode))                 \
2069         fputs ("R'", FILE);                                             \
2070       else if (flag_pic == 0)                                           \
2071         fputs ("RR'", FILE);                                            \
2072       else                                                              \
2073         fputs ("RT'", FILE);                                            \
2074       output_global_address (FILE, XEXP (addr, 1), 0);                  \
2075       fputs ("(", FILE);                                                \
2076       output_operand (XEXP (addr, 0), 0);                               \
2077       fputs (")", FILE);                                                \
2078       break;                                                            \
2079     case CONST_INT:                                                     \
2080       fprintf (FILE, HOST_WIDE_INT_PRINT_DEC "(%%r0)", INTVAL (addr));  \
2081       break;                                                            \
2082     default:                                                            \
2083       output_addr_const (FILE, addr);                                   \
2084     }}
2085
2086 \f
2087 /* Find the return address associated with the frame given by
2088    FRAMEADDR.  */
2089 #define RETURN_ADDR_RTX(COUNT, FRAMEADDR)                                \
2090   (return_addr_rtx (COUNT, FRAMEADDR))
2091
2092 /* Used to mask out junk bits from the return address, such as
2093    processor state, interrupt status, condition codes and the like.  */
2094 #define MASK_RETURN_ADDR                                                \
2095   /* The privilege level is in the two low order bits, mask em out      \
2096      of the return address.  */                                         \
2097   (GEN_INT (-4))
2098
2099 /* The number of Pmode words for the setjmp buffer.  */
2100 #define JMP_BUF_SIZE 50
2101
2102 #define PREDICATE_CODES                                                 \
2103   {"reg_or_0_operand", {SUBREG, REG, CONST_INT, CONST_DOUBLE}},         \
2104   {"call_operand_address", {LABEL_REF, SYMBOL_REF, CONST_INT,           \
2105                             CONST_DOUBLE, CONST, HIGH}},                 \
2106   {"indexed_memory_operand", {SUBREG, MEM}},                            \
2107   {"symbolic_operand", {SYMBOL_REF, LABEL_REF, CONST}},                 \
2108   {"symbolic_memory_operand", {SUBREG, MEM}},                           \
2109   {"reg_before_reload_operand", {REG, MEM}},                            \
2110   {"reg_or_0_or_nonsymb_mem_operand", {SUBREG, REG, MEM, CONST_INT,     \
2111                                        CONST_DOUBLE}},                  \
2112   {"move_dest_operand", {SUBREG, REG, MEM}},                            \
2113   {"move_src_operand", {SUBREG, REG, CONST_INT, MEM}},                  \
2114   {"prefetch_cc_operand", {MEM}},                                       \
2115   {"prefetch_nocc_operand", {MEM}},                                     \
2116   {"reg_or_cint_move_operand", {SUBREG, REG, CONST_INT}},               \
2117   {"pic_label_operand", {LABEL_REF, CONST}},                            \
2118   {"fp_reg_operand", {REG}},                                            \
2119   {"arith_operand", {SUBREG, REG, CONST_INT}},                          \
2120   {"arith11_operand", {SUBREG, REG, CONST_INT}},                        \
2121   {"pre_cint_operand", {CONST_INT}},                                    \
2122   {"post_cint_operand", {CONST_INT}},                                   \
2123   {"arith_double_operand", {SUBREG, REG, CONST_DOUBLE}},                \
2124   {"ireg_or_int5_operand", {CONST_INT, REG}},                           \
2125   {"int5_operand", {CONST_INT}},                                        \
2126   {"uint5_operand", {CONST_INT}},                                       \
2127   {"int11_operand", {CONST_INT}},                                       \
2128   {"uint32_operand", {CONST_INT,                                        \
2129    HOST_BITS_PER_WIDE_INT > 32 ? 0 : CONST_DOUBLE}},                    \
2130   {"arith5_operand", {SUBREG, REG, CONST_INT}},                         \
2131   {"and_operand", {SUBREG, REG, CONST_INT}},                            \
2132   {"ior_operand", {CONST_INT}},                                         \
2133   {"lhs_lshift_cint_operand", {CONST_INT}},                             \
2134   {"lhs_lshift_operand", {SUBREG, REG, CONST_INT}},                     \
2135   {"arith32_operand", {SUBREG, REG, CONST_INT}},                        \
2136   {"pc_or_label_operand", {PC, LABEL_REF}},                             \
2137   {"plus_xor_ior_operator", {PLUS, XOR, IOR}},                          \
2138   {"shadd_operand", {CONST_INT}},                                       \
2139   {"div_operand", {REG, CONST_INT}},                                    \
2140   {"ireg_operand", {REG}},                                              \
2141   {"cmpib_comparison_operator", {EQ, NE, LT, LE, LEU,                   \
2142    GT, GTU, GE}},                                                       \
2143   {"movb_comparison_operator", {EQ, NE, LT, GE}},
2144
2145 /* We need a libcall to canonicalize function pointers on TARGET_ELF32.  */
2146 #define CANONICALIZE_FUNCPTR_FOR_COMPARE_LIBCALL \
2147   "__canonicalize_funcptr_for_compare"