OSDN Git Service

58642d10f288e7bcceee0f4b1efaf87879a087d2
[pf3gnuchains/gcc-fork.git] / gcc / config / pa / pa.c
1 /* Subroutines for insn-output.c for HPPA.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004 Free Software Foundation, Inc.
4    Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.c
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
34 #include "flags.h"
35 #include "tree.h"
36 #include "output.h"
37 #include "except.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "reload.h"
41 #include "integrate.h"
42 #include "function.h"
43 #include "toplev.h"
44 #include "ggc.h"
45 #include "recog.h"
46 #include "predict.h"
47 #include "tm_p.h"
48 #include "target.h"
49 #include "target-def.h"
50
51 /* Return nonzero if there is a bypass for the output of 
52    OUT_INSN and the fp store IN_INSN.  */
53 int
54 hppa_fpstore_bypass_p (rtx out_insn, rtx in_insn)
55 {
56   enum machine_mode store_mode;
57   enum machine_mode other_mode;
58   rtx set;
59
60   if (recog_memoized (in_insn) < 0
61       || get_attr_type (in_insn) != TYPE_FPSTORE
62       || recog_memoized (out_insn) < 0)
63     return 0;
64
65   store_mode = GET_MODE (SET_SRC (PATTERN (in_insn)));
66
67   set = single_set (out_insn);
68   if (!set)
69     return 0;
70
71   other_mode = GET_MODE (SET_SRC (set));
72
73   return (GET_MODE_SIZE (store_mode) == GET_MODE_SIZE (other_mode));
74 }
75   
76
77 #ifndef DO_FRAME_NOTES
78 #ifdef INCOMING_RETURN_ADDR_RTX
79 #define DO_FRAME_NOTES 1
80 #else
81 #define DO_FRAME_NOTES 0
82 #endif
83 #endif
84
85 static void copy_reg_pointer (rtx, rtx);
86 static void fix_range (const char *);
87 static int hppa_address_cost (rtx);
88 static bool hppa_rtx_costs (rtx, int, int, int *);
89 static inline rtx force_mode (enum machine_mode, rtx);
90 static void pa_reorg (void);
91 static void pa_combine_instructions (void);
92 static int pa_can_combine_p (rtx, rtx, rtx, int, rtx, rtx, rtx);
93 static int forward_branch_p (rtx);
94 static int shadd_constant_p (int);
95 static void compute_zdepwi_operands (unsigned HOST_WIDE_INT, unsigned *);
96 static int compute_movmem_length (rtx);
97 static int compute_clrmem_length (rtx);
98 static bool pa_assemble_integer (rtx, unsigned int, int);
99 static void remove_useless_addtr_insns (int);
100 static void store_reg (int, HOST_WIDE_INT, int);
101 static void store_reg_modify (int, int, HOST_WIDE_INT);
102 static void load_reg (int, HOST_WIDE_INT, int);
103 static void set_reg_plus_d (int, int, HOST_WIDE_INT, int);
104 static void pa_output_function_prologue (FILE *, HOST_WIDE_INT);
105 static void update_total_code_bytes (int);
106 static void pa_output_function_epilogue (FILE *, HOST_WIDE_INT);
107 static int pa_adjust_cost (rtx, rtx, rtx, int);
108 static int pa_adjust_priority (rtx, int);
109 static int pa_issue_rate (void);
110 static void pa_select_section (tree, int, unsigned HOST_WIDE_INT)
111      ATTRIBUTE_UNUSED;
112 static void pa_encode_section_info (tree, rtx, int);
113 static const char *pa_strip_name_encoding (const char *);
114 static bool pa_function_ok_for_sibcall (tree, tree);
115 static void pa_globalize_label (FILE *, const char *)
116      ATTRIBUTE_UNUSED;
117 static void pa_asm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
118                                     HOST_WIDE_INT, tree);
119 #if !defined(USE_COLLECT2)
120 static void pa_asm_out_constructor (rtx, int);
121 static void pa_asm_out_destructor (rtx, int);
122 #endif
123 static void pa_init_builtins (void);
124 static rtx hppa_builtin_saveregs (void);
125 static tree hppa_gimplify_va_arg_expr (tree, tree, tree *, tree *);
126 static void copy_fp_args (rtx) ATTRIBUTE_UNUSED;
127 static int length_fp_args (rtx) ATTRIBUTE_UNUSED;
128 static struct deferred_plabel *get_plabel (const char *)
129      ATTRIBUTE_UNUSED;
130 static inline void pa_file_start_level (void) ATTRIBUTE_UNUSED;
131 static inline void pa_file_start_space (int) ATTRIBUTE_UNUSED;
132 static inline void pa_file_start_file (int) ATTRIBUTE_UNUSED;
133 static inline void pa_file_start_mcount (const char*) ATTRIBUTE_UNUSED;
134 static void pa_elf_file_start (void) ATTRIBUTE_UNUSED;
135 static void pa_som_file_start (void) ATTRIBUTE_UNUSED;
136 static void pa_linux_file_start (void) ATTRIBUTE_UNUSED;
137 static void pa_hpux64_gas_file_start (void) ATTRIBUTE_UNUSED;
138 static void pa_hpux64_hpas_file_start (void) ATTRIBUTE_UNUSED;
139 static void output_deferred_plabels (void);
140 #ifdef HPUX_LONG_DOUBLE_LIBRARY
141 static void pa_hpux_init_libfuncs (void);
142 #endif
143 static rtx pa_struct_value_rtx (tree, int);
144 static bool pa_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
145                                   tree, bool);
146 static int pa_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
147                                  tree, bool);
148 static struct machine_function * pa_init_machine_status (void);
149
150
151 /* Save the operands last given to a compare for use when we
152    generate a scc or bcc insn.  */
153 rtx hppa_compare_op0, hppa_compare_op1;
154 enum cmp_type hppa_branch_type;
155
156 /* Which architecture we are generating code for.  */
157 enum architecture_type pa_arch;
158
159 /* String to hold which architecture we are generating code for.  */
160 const char *pa_arch_string;
161
162 /* String used with the -mfixed-range= option.  */
163 const char *pa_fixed_range_string;
164
165 /* Which cpu we are scheduling for.  */
166 enum processor_type pa_cpu;
167
168 /* String to hold which cpu we are scheduling for.  */
169 const char *pa_cpu_string;
170
171 /* String used with the -munix= option.  */
172 const char *pa_unix_string;
173
174 /* The UNIX standard to use for predefines and linking.  */
175 int flag_pa_unix;
176
177 /* Counts for the number of callee-saved general and floating point
178    registers which were saved by the current function's prologue.  */
179 static int gr_saved, fr_saved;
180
181 static rtx find_addr_reg (rtx);
182
183 /* Keep track of the number of bytes we have output in the CODE subspace
184    during this compilation so we'll know when to emit inline long-calls.  */
185 unsigned long total_code_bytes;
186
187 /* The last address of the previous function plus the number of bytes in
188    associated thunks that have been output.  This is used to determine if
189    a thunk can use an IA-relative branch to reach its target function.  */
190 static int last_address;
191
192 /* Variables to handle plabels that we discover are necessary at assembly
193    output time.  They are output after the current function.  */
194 struct deferred_plabel GTY(())
195 {
196   rtx internal_label;
197   const char *name;
198 };
199 static GTY((length ("n_deferred_plabels"))) struct deferred_plabel *
200   deferred_plabels;
201 static size_t n_deferred_plabels = 0;
202
203 \f
204 /* Initialize the GCC target structure.  */
205
206 #undef TARGET_ASM_ALIGNED_HI_OP
207 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
208 #undef TARGET_ASM_ALIGNED_SI_OP
209 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
210 #undef TARGET_ASM_ALIGNED_DI_OP
211 #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t"
212 #undef TARGET_ASM_UNALIGNED_HI_OP
213 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
214 #undef TARGET_ASM_UNALIGNED_SI_OP
215 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
216 #undef TARGET_ASM_UNALIGNED_DI_OP
217 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
218 #undef TARGET_ASM_INTEGER
219 #define TARGET_ASM_INTEGER pa_assemble_integer
220
221 #undef TARGET_ASM_FUNCTION_PROLOGUE
222 #define TARGET_ASM_FUNCTION_PROLOGUE pa_output_function_prologue
223 #undef TARGET_ASM_FUNCTION_EPILOGUE
224 #define TARGET_ASM_FUNCTION_EPILOGUE pa_output_function_epilogue
225
226 #undef TARGET_SCHED_ADJUST_COST
227 #define TARGET_SCHED_ADJUST_COST pa_adjust_cost
228 #undef TARGET_SCHED_ADJUST_PRIORITY
229 #define TARGET_SCHED_ADJUST_PRIORITY pa_adjust_priority
230 #undef TARGET_SCHED_ISSUE_RATE
231 #define TARGET_SCHED_ISSUE_RATE pa_issue_rate
232
233 #undef TARGET_ENCODE_SECTION_INFO
234 #define TARGET_ENCODE_SECTION_INFO pa_encode_section_info
235 #undef TARGET_STRIP_NAME_ENCODING
236 #define TARGET_STRIP_NAME_ENCODING pa_strip_name_encoding
237
238 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
239 #define TARGET_FUNCTION_OK_FOR_SIBCALL pa_function_ok_for_sibcall
240
241 #undef TARGET_ASM_OUTPUT_MI_THUNK
242 #define TARGET_ASM_OUTPUT_MI_THUNK pa_asm_output_mi_thunk
243 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
244 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
245
246 #undef TARGET_ASM_FILE_END
247 #define TARGET_ASM_FILE_END output_deferred_plabels
248
249 #if !defined(USE_COLLECT2)
250 #undef TARGET_ASM_CONSTRUCTOR
251 #define TARGET_ASM_CONSTRUCTOR pa_asm_out_constructor
252 #undef TARGET_ASM_DESTRUCTOR
253 #define TARGET_ASM_DESTRUCTOR pa_asm_out_destructor
254 #endif
255
256 #undef TARGET_INIT_BUILTINS
257 #define TARGET_INIT_BUILTINS pa_init_builtins
258
259 #undef TARGET_RTX_COSTS
260 #define TARGET_RTX_COSTS hppa_rtx_costs
261 #undef TARGET_ADDRESS_COST
262 #define TARGET_ADDRESS_COST hppa_address_cost
263
264 #undef TARGET_MACHINE_DEPENDENT_REORG
265 #define TARGET_MACHINE_DEPENDENT_REORG pa_reorg
266
267 #ifdef HPUX_LONG_DOUBLE_LIBRARY
268 #undef TARGET_INIT_LIBFUNCS
269 #define TARGET_INIT_LIBFUNCS pa_hpux_init_libfuncs
270 #endif
271
272 #undef TARGET_PROMOTE_FUNCTION_RETURN
273 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
274 #undef TARGET_PROMOTE_PROTOTYPES
275 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
276
277 #undef TARGET_STRUCT_VALUE_RTX
278 #define TARGET_STRUCT_VALUE_RTX pa_struct_value_rtx
279 #undef TARGET_RETURN_IN_MEMORY
280 #define TARGET_RETURN_IN_MEMORY pa_return_in_memory
281 #undef TARGET_MUST_PASS_IN_STACK
282 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
283 #undef TARGET_PASS_BY_REFERENCE
284 #define TARGET_PASS_BY_REFERENCE pa_pass_by_reference
285 #undef TARGET_CALLEE_COPIES
286 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
287 #undef TARGET_ARG_PARTIAL_BYTES
288 #define TARGET_ARG_PARTIAL_BYTES pa_arg_partial_bytes
289
290 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
291 #define TARGET_EXPAND_BUILTIN_SAVEREGS hppa_builtin_saveregs
292 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
293 #define TARGET_GIMPLIFY_VA_ARG_EXPR hppa_gimplify_va_arg_expr
294
295 struct gcc_target targetm = TARGET_INITIALIZER;
296 \f
297 /* Parse the -mfixed-range= option string.  */
298
299 static void
300 fix_range (const char *const_str)
301 {
302   int i, first, last;
303   char *str, *dash, *comma;
304
305   /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
306      REG2 are either register names or register numbers.  The effect
307      of this option is to mark the registers in the range from REG1 to
308      REG2 as ``fixed'' so they won't be used by the compiler.  This is
309      used, e.g., to ensure that kernel mode code doesn't use f32-f127.  */
310
311   i = strlen (const_str);
312   str = (char *) alloca (i + 1);
313   memcpy (str, const_str, i + 1);
314
315   while (1)
316     {
317       dash = strchr (str, '-');
318       if (!dash)
319         {
320           warning ("value of -mfixed-range must have form REG1-REG2");
321           return;
322         }
323       *dash = '\0';
324
325       comma = strchr (dash + 1, ',');
326       if (comma)
327         *comma = '\0';
328
329       first = decode_reg_name (str);
330       if (first < 0)
331         {
332           warning ("unknown register name: %s", str);
333           return;
334         }
335
336       last = decode_reg_name (dash + 1);
337       if (last < 0)
338         {
339           warning ("unknown register name: %s", dash + 1);
340           return;
341         }
342
343       *dash = '-';
344
345       if (first > last)
346         {
347           warning ("%s-%s is an empty range", str, dash + 1);
348           return;
349         }
350
351       for (i = first; i <= last; ++i)
352         fixed_regs[i] = call_used_regs[i] = 1;
353
354       if (!comma)
355         break;
356
357       *comma = ',';
358       str = comma + 1;
359     }
360
361   /* Check if all floating point registers have been fixed.  */
362   for (i = FP_REG_FIRST; i <= FP_REG_LAST; i++)
363     if (!fixed_regs[i])
364       break;
365
366   if (i > FP_REG_LAST)
367     target_flags |= MASK_DISABLE_FPREGS;
368 }
369
370 void
371 override_options (void)
372 {
373   if (pa_cpu_string == NULL)
374     pa_cpu_string = TARGET_SCHED_DEFAULT;
375
376   if (! strcmp (pa_cpu_string, "8000"))
377     {
378       pa_cpu_string = "8000";
379       pa_cpu = PROCESSOR_8000;
380     }
381   else if (! strcmp (pa_cpu_string, "7100"))
382     {
383       pa_cpu_string = "7100";
384       pa_cpu = PROCESSOR_7100;
385     }
386   else if (! strcmp (pa_cpu_string, "700"))
387     {
388       pa_cpu_string = "700";
389       pa_cpu = PROCESSOR_700;
390     }
391   else if (! strcmp (pa_cpu_string, "7100LC"))
392     {
393       pa_cpu_string = "7100LC";
394       pa_cpu = PROCESSOR_7100LC;
395     }
396   else if (! strcmp (pa_cpu_string, "7200"))
397     {
398       pa_cpu_string = "7200";
399       pa_cpu = PROCESSOR_7200;
400     }
401   else if (! strcmp (pa_cpu_string, "7300"))
402     {
403       pa_cpu_string = "7300";
404       pa_cpu = PROCESSOR_7300;
405     }
406   else
407     {
408       warning ("unknown -mschedule= option (%s).\nValid options are 700, 7100, 7100LC, 7200, 7300, and 8000\n", pa_cpu_string);
409     }
410
411   /* Set the instruction architecture.  */
412   if (pa_arch_string && ! strcmp (pa_arch_string, "1.0"))
413     {
414       pa_arch_string = "1.0";
415       pa_arch = ARCHITECTURE_10;
416       target_flags &= ~(MASK_PA_11 | MASK_PA_20);
417     }
418   else if (pa_arch_string && ! strcmp (pa_arch_string, "1.1"))
419     {
420       pa_arch_string = "1.1";
421       pa_arch = ARCHITECTURE_11;
422       target_flags &= ~MASK_PA_20;
423       target_flags |= MASK_PA_11;
424     }
425   else if (pa_arch_string && ! strcmp (pa_arch_string, "2.0"))
426     {
427       pa_arch_string = "2.0";
428       pa_arch = ARCHITECTURE_20;
429       target_flags |= MASK_PA_11 | MASK_PA_20;
430     }
431   else if (pa_arch_string)
432     {
433       warning ("unknown -march= option (%s).\nValid options are 1.0, 1.1, and 2.0\n", pa_arch_string);
434     }
435
436   if (TARGET_HPUX)
437     {
438       /* Set the default UNIX standard for HP-UX.  This affects the
439          predefines and startfiles used for the target.  */
440       if (pa_unix_string == NULL)
441         pa_unix_string
442           = TARGET_HPUX_11_11 ? "98" : (TARGET_HPUX_10_10 ? "95" : "93");
443
444       if (!strcmp (pa_unix_string, "93"))
445         flag_pa_unix = 1993;
446       else if (!strcmp (pa_unix_string, "95"))
447         flag_pa_unix = 1995;
448       else if (TARGET_HPUX_11_11)
449         {
450           if (!strcmp (pa_unix_string, "98"))
451             flag_pa_unix = 1998;
452           else
453             warning ("unknown -munix= option (%s).\n"
454                      "Valid options are 93, 95 and 98.\n",
455                      pa_unix_string);
456         }
457       else if (TARGET_HPUX_10_10)
458         warning ("unknown -munix= option (%s)."
459                  "\nValid options are 93 and 95.\n",
460                  pa_unix_string);
461       else
462         warning ("unknown -munix= option (%s).\nValid option is 93.\n",
463                  pa_unix_string);
464     }
465
466   if (pa_fixed_range_string)
467     fix_range (pa_fixed_range_string);
468
469   /* Unconditional branches in the delay slot are not compatible with dwarf2
470      call frame information.  There is no benefit in using this optimization
471      on PA8000 and later processors.  */
472   if (pa_cpu >= PROCESSOR_8000
473       || (! USING_SJLJ_EXCEPTIONS && flag_exceptions)
474       || flag_unwind_tables)
475     target_flags &= ~MASK_JUMP_IN_DELAY;
476
477   if (flag_pic && TARGET_PORTABLE_RUNTIME)
478     {
479       warning ("PIC code generation is not supported in the portable runtime model\n");
480     }
481
482   if (flag_pic && TARGET_FAST_INDIRECT_CALLS)
483    {
484       warning ("PIC code generation is not compatible with fast indirect calls\n");
485    }
486
487   if (! TARGET_GAS && write_symbols != NO_DEBUG)
488     {
489       warning ("-g is only supported when using GAS on this processor,");
490       warning ("-g option disabled");
491       write_symbols = NO_DEBUG;
492     }
493
494   /* We only support the "big PIC" model now.  And we always generate PIC
495      code when in 64bit mode.  */
496   if (flag_pic == 1 || TARGET_64BIT)
497     flag_pic = 2;
498
499   /* We can't guarantee that .dword is available for 32-bit targets.  */
500   if (UNITS_PER_WORD == 4)
501     targetm.asm_out.aligned_op.di = NULL;
502
503   /* The unaligned ops are only available when using GAS.  */
504   if (!TARGET_GAS)
505     {
506       targetm.asm_out.unaligned_op.hi = NULL;
507       targetm.asm_out.unaligned_op.si = NULL;
508       targetm.asm_out.unaligned_op.di = NULL;
509     }
510
511   init_machine_status = pa_init_machine_status;
512 }
513
514 static void
515 pa_init_builtins (void)
516 {
517 #ifdef DONT_HAVE_FPUTC_UNLOCKED
518   built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED] = NULL_TREE;
519   implicit_built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED] = NULL_TREE;
520 #endif
521 }
522
523 /* Function to init struct machine_function.
524    This will be called, via a pointer variable,
525    from push_function_context.  */
526
527 static struct machine_function *
528 pa_init_machine_status (void)
529 {
530   return ggc_alloc_cleared (sizeof (machine_function));
531 }
532
533 /* If FROM is a probable pointer register, mark TO as a probable
534    pointer register with the same pointer alignment as FROM.  */
535
536 static void
537 copy_reg_pointer (rtx to, rtx from)
538 {
539   if (REG_POINTER (from))
540     mark_reg_pointer (to, REGNO_POINTER_ALIGN (REGNO (from)));
541 }
542
543 /* Return nonzero only if OP is a register of mode MODE,
544    or CONST0_RTX.  */
545 int
546 reg_or_0_operand (rtx op, enum machine_mode mode)
547 {
548   return (op == CONST0_RTX (mode) || register_operand (op, mode));
549 }
550
551 /* Return nonzero if OP is suitable for use in a call to a named
552    function.
553
554    For 2.5 try to eliminate either call_operand_address or
555    function_label_operand, they perform very similar functions.  */
556 int
557 call_operand_address (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
558 {
559   return (GET_MODE (op) == word_mode
560           && CONSTANT_P (op) && ! TARGET_PORTABLE_RUNTIME);
561 }
562
563 /* Return 1 if X contains a symbolic expression.  We know these
564    expressions will have one of a few well defined forms, so
565    we need only check those forms.  */
566 int
567 symbolic_expression_p (rtx x)
568 {
569
570   /* Strip off any HIGH.  */
571   if (GET_CODE (x) == HIGH)
572     x = XEXP (x, 0);
573
574   return (symbolic_operand (x, VOIDmode));
575 }
576
577 int
578 symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
579 {
580   switch (GET_CODE (op))
581     {
582     case SYMBOL_REF:
583     case LABEL_REF:
584       return 1;
585     case CONST:
586       op = XEXP (op, 0);
587       return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
588                || GET_CODE (XEXP (op, 0)) == LABEL_REF)
589               && GET_CODE (XEXP (op, 1)) == CONST_INT);
590     default:
591       return 0;
592     }
593 }
594
595 /* Return truth value of statement that OP is a symbolic memory
596    operand of mode MODE.  */
597
598 int
599 symbolic_memory_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
600 {
601   if (GET_CODE (op) == SUBREG)
602     op = SUBREG_REG (op);
603   if (GET_CODE (op) != MEM)
604     return 0;
605   op = XEXP (op, 0);
606   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST
607           || GET_CODE (op) == HIGH || GET_CODE (op) == LABEL_REF);
608 }
609
610 /* Return 1 if the operand is either a register, zero, or a memory operand
611    that is not symbolic.  */
612
613 int
614 reg_or_0_or_nonsymb_mem_operand (rtx op, enum machine_mode mode)
615 {
616   if (register_operand (op, mode))
617     return 1;
618
619   if (op == CONST0_RTX (mode))
620     return 1;
621
622   if (GET_CODE (op) == SUBREG)
623     op = SUBREG_REG (op);
624
625   if (GET_CODE (op) != MEM)
626     return 0;
627
628   /* Until problems with management of the REG_POINTER flag are resolved,
629      we need to delay creating move insns with unscaled indexed addresses
630      until CSE is not expected.  */
631   if (!TARGET_NO_SPACE_REGS
632       && !cse_not_expected
633       && GET_CODE (XEXP (op, 0)) == PLUS
634       && REG_P (XEXP (XEXP (op, 0), 0))
635       && REG_P (XEXP (XEXP (op, 0), 1)))
636     return 0;
637
638   return (!symbolic_memory_operand (op, mode)
639           && memory_address_p (mode, XEXP (op, 0)));
640 }
641
642 /* Return 1 if the operand is a register operand or a non-symbolic memory
643    operand after reload.  This predicate is used for branch patterns that
644    internally handle register reloading.  We need to accept non-symbolic
645    memory operands after reload to ensure that the pattern is still valid
646    if reload didn't find a hard register for the operand.  */
647
648 int
649 reg_before_reload_operand (rtx op, enum machine_mode mode)
650 {
651   /* Don't accept a SUBREG since it will need a reload.  */
652   if (GET_CODE (op) == SUBREG)
653     return 0;
654
655   if (register_operand (op, mode))
656     return 1;
657
658   if (reload_completed
659       && memory_operand (op, mode)
660       && !symbolic_memory_operand (op, mode))
661     return 1;
662
663   return 0;
664 }
665
666 /* Accept any constant that can be moved in one instruction into a
667    general register.  */
668 int
669 cint_ok_for_move (HOST_WIDE_INT intval)
670 {
671   /* OK if ldo, ldil, or zdepi, can be used.  */
672   return (CONST_OK_FOR_LETTER_P (intval, 'J')
673           || CONST_OK_FOR_LETTER_P (intval, 'N')
674           || CONST_OK_FOR_LETTER_P (intval, 'K'));
675 }
676
677 /* Return 1 iff OP is an indexed memory operand.  */
678 int
679 indexed_memory_operand (rtx op, enum machine_mode mode)
680 {
681   if (GET_MODE (op) != mode)
682     return 0;
683
684   /* Before reload, a (SUBREG (MEM...)) forces reloading into a register.  */
685   if (reload_completed && GET_CODE (op) == SUBREG)
686     op = SUBREG_REG (op);
687
688   if (GET_CODE (op) != MEM || symbolic_memory_operand (op, mode))
689     return 0;
690
691   op = XEXP (op, 0);
692
693   return (memory_address_p (mode, op) && IS_INDEX_ADDR_P (op));
694 }
695
696 /* Accept anything that can be used as a destination operand for a
697    move instruction.  We don't accept indexed memory operands since
698    they are supported only for floating point stores.  */
699 int
700 move_dest_operand (rtx op, enum machine_mode mode)
701 {
702   if (register_operand (op, mode))
703     return 1;
704
705   if (GET_MODE (op) != mode)
706     return 0;
707
708   if (GET_CODE (op) == SUBREG)
709     op = SUBREG_REG (op);
710
711   if (GET_CODE (op) != MEM || symbolic_memory_operand (op, mode))
712     return 0;
713
714   op = XEXP (op, 0);
715
716   return (memory_address_p (mode, op)
717           && !IS_INDEX_ADDR_P (op)
718           && !IS_LO_SUM_DLT_ADDR_P (op));
719 }
720
721 /* Accept anything that can be used as a source operand for a move
722    instruction.  */
723 int
724 move_src_operand (rtx op, enum machine_mode mode)
725 {
726   if (register_operand (op, mode))
727     return 1;
728
729   if (GET_CODE (op) == CONST_INT)
730     return cint_ok_for_move (INTVAL (op));
731
732   if (GET_MODE (op) != mode)
733     return 0;
734
735   if (GET_CODE (op) == SUBREG)
736     op = SUBREG_REG (op);
737
738   if (GET_CODE (op) != MEM)
739     return 0;
740
741   /* Until problems with management of the REG_POINTER flag are resolved,
742      we need to delay creating move insns with unscaled indexed addresses
743      until CSE is not expected.  */
744   if (!TARGET_NO_SPACE_REGS
745       && !cse_not_expected
746       && GET_CODE (XEXP (op, 0)) == PLUS
747       && REG_P (XEXP (XEXP (op, 0), 0))
748       && REG_P (XEXP (XEXP (op, 0), 1)))
749     return 0;
750
751   return memory_address_p (mode, XEXP (op, 0));
752 }
753
754 /* Accept anything that can be used as the source operand for a prefetch
755    instruction.  */
756 int
757 prefetch_operand (rtx op, enum machine_mode mode)
758 {
759   if (GET_CODE (op) != MEM)
760     return 0;
761
762   /* Until problems with management of the REG_POINTER flag are resolved,
763      we need to delay creating prefetch insns with unscaled indexed addresses
764      until CSE is not expected.  */
765   if (!TARGET_NO_SPACE_REGS
766       && !cse_not_expected
767       && GET_CODE (XEXP (op, 0)) == PLUS
768       && REG_P (XEXP (XEXP (op, 0), 0))
769       && REG_P (XEXP (XEXP (op, 0), 1)))
770     return 0;
771
772   return memory_address_p (mode, XEXP (op, 0));
773 }
774
775 /* Accept REG and any CONST_INT that can be moved in one instruction into a
776    general register.  */
777 int
778 reg_or_cint_move_operand (rtx op, enum machine_mode mode)
779 {
780   if (register_operand (op, mode))
781     return 1;
782
783   return (GET_CODE (op) == CONST_INT && cint_ok_for_move (INTVAL (op)));
784 }
785
786 int
787 pic_label_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
788 {
789   if (!flag_pic)
790     return 0;
791
792   switch (GET_CODE (op))
793     {
794     case LABEL_REF:
795       return 1;
796     case CONST:
797       op = XEXP (op, 0);
798       return (GET_CODE (XEXP (op, 0)) == LABEL_REF
799               && GET_CODE (XEXP (op, 1)) == CONST_INT);
800     default:
801       return 0;
802     }
803 }
804
805 int
806 fp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
807 {
808   return reg_renumber && FP_REG_P (op);
809 }
810
811 \f
812
813 /* Return truth value of whether OP can be used as an operand in a
814    three operand arithmetic insn that accepts registers of mode MODE
815    or 14-bit signed integers.  */
816 int
817 arith_operand (rtx op, enum machine_mode mode)
818 {
819   return (register_operand (op, mode)
820           || (GET_CODE (op) == CONST_INT && INT_14_BITS (op)));
821 }
822
823 /* Return truth value of whether OP can be used as an operand in a
824    three operand arithmetic insn that accepts registers of mode MODE
825    or 11-bit signed integers.  */
826 int
827 arith11_operand (rtx op, enum machine_mode mode)
828 {
829   return (register_operand (op, mode)
830           || (GET_CODE (op) == CONST_INT && INT_11_BITS (op)));
831 }
832
833 /* Return truth value of whether OP can be used as an operand in a
834    adddi3 insn.  */
835 int
836 adddi3_operand (rtx op, enum machine_mode mode)
837 {
838   return (register_operand (op, mode)
839           || (GET_CODE (op) == CONST_INT
840               && (TARGET_64BIT ? INT_14_BITS (op) : INT_11_BITS (op))));
841 }
842
843 /* A constant integer suitable for use in a PRE_MODIFY memory
844    reference.  */
845 int
846 pre_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
847 {
848   return (GET_CODE (op) == CONST_INT
849           && INTVAL (op) >= -0x2000 && INTVAL (op) < 0x10);
850 }
851
852 /* A constant integer suitable for use in a POST_MODIFY memory
853    reference.  */
854 int
855 post_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
856 {
857   return (GET_CODE (op) == CONST_INT
858           && INTVAL (op) < 0x2000 && INTVAL (op) >= -0x10);
859 }
860
861 int
862 arith_double_operand (rtx op, enum machine_mode mode)
863 {
864   return (register_operand (op, mode)
865           || (GET_CODE (op) == CONST_DOUBLE
866               && GET_MODE (op) == mode
867               && VAL_14_BITS_P (CONST_DOUBLE_LOW (op))
868               && ((CONST_DOUBLE_HIGH (op) >= 0)
869                   == ((CONST_DOUBLE_LOW (op) & 0x1000) == 0))));
870 }
871
872 /* Return truth value of whether OP is an integer which fits the
873    range constraining immediate operands in three-address insns, or
874    is an integer register.  */
875
876 int
877 ireg_or_int5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
878 {
879   return ((GET_CODE (op) == CONST_INT && INT_5_BITS (op))
880           || (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32));
881 }
882
883 /* Return nonzero if OP is an integer register, else return zero.  */
884 int
885 ireg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
886 {
887   return (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32);
888 }
889
890 /* Return truth value of whether OP is an integer which fits the
891    range constraining immediate operands in three-address insns.  */
892
893 int
894 int5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
895 {
896   return (GET_CODE (op) == CONST_INT && INT_5_BITS (op));
897 }
898
899 int
900 uint5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
901 {
902   return (GET_CODE (op) == CONST_INT && INT_U5_BITS (op));
903 }
904
905 int
906 int11_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
907 {
908   return (GET_CODE (op) == CONST_INT && INT_11_BITS (op));
909 }
910
911 int
912 uint32_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
913 {
914 #if HOST_BITS_PER_WIDE_INT > 32
915   /* All allowed constants will fit a CONST_INT.  */
916   return (GET_CODE (op) == CONST_INT
917           && (INTVAL (op) >= 0 && INTVAL (op) < (HOST_WIDE_INT) 1 << 32));
918 #else
919   return (GET_CODE (op) == CONST_INT
920           || (GET_CODE (op) == CONST_DOUBLE
921               && CONST_DOUBLE_HIGH (op) == 0));
922 #endif
923 }
924
925 int
926 arith5_operand (rtx op, enum machine_mode mode)
927 {
928   return register_operand (op, mode) || int5_operand (op, mode);
929 }
930
931 /* True iff zdepi can be used to generate this CONST_INT.
932    zdepi first sign extends a 5 bit signed number to a given field
933    length, then places this field anywhere in a zero.  */
934 int
935 zdepi_cint_p (unsigned HOST_WIDE_INT x)
936 {
937   unsigned HOST_WIDE_INT lsb_mask, t;
938
939   /* This might not be obvious, but it's at least fast.
940      This function is critical; we don't have the time loops would take.  */
941   lsb_mask = x & -x;
942   t = ((x >> 4) + lsb_mask) & ~(lsb_mask - 1);
943   /* Return true iff t is a power of two.  */
944   return ((t & (t - 1)) == 0);
945 }
946
947 /* True iff depi or extru can be used to compute (reg & mask).
948    Accept bit pattern like these:
949    0....01....1
950    1....10....0
951    1..10..01..1  */
952 int
953 and_mask_p (unsigned HOST_WIDE_INT mask)
954 {
955   mask = ~mask;
956   mask += mask & -mask;
957   return (mask & (mask - 1)) == 0;
958 }
959
960 /* True iff depi or extru can be used to compute (reg & OP).  */
961 int
962 and_operand (rtx op, enum machine_mode mode)
963 {
964   return (register_operand (op, mode)
965           || (GET_CODE (op) == CONST_INT && and_mask_p (INTVAL (op))));
966 }
967
968 /* True iff depi can be used to compute (reg | MASK).  */
969 int
970 ior_mask_p (unsigned HOST_WIDE_INT mask)
971 {
972   mask += mask & -mask;
973   return (mask & (mask - 1)) == 0;
974 }
975
976 /* True iff depi can be used to compute (reg | OP).  */
977 int
978 ior_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
979 {
980   return (GET_CODE (op) == CONST_INT && ior_mask_p (INTVAL (op)));
981 }
982
983 int
984 lhs_lshift_operand (rtx op, enum machine_mode mode)
985 {
986   return register_operand (op, mode) || lhs_lshift_cint_operand (op, mode);
987 }
988
989 /* True iff OP is a CONST_INT of the forms 0...0xxxx or 0...01...1xxxx.
990    Such values can be the left hand side x in (x << r), using the zvdepi
991    instruction.  */
992 int
993 lhs_lshift_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
994 {
995   unsigned HOST_WIDE_INT x;
996   if (GET_CODE (op) != CONST_INT)
997     return 0;
998   x = INTVAL (op) >> 4;
999   return (x & (x + 1)) == 0;
1000 }
1001
1002 int
1003 arith32_operand (rtx op, enum machine_mode mode)
1004 {
1005   return register_operand (op, mode) || GET_CODE (op) == CONST_INT;
1006 }
1007
1008 int
1009 pc_or_label_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1010 {
1011   return (GET_CODE (op) == PC || GET_CODE (op) == LABEL_REF);
1012 }
1013 \f
1014 /* Legitimize PIC addresses.  If the address is already
1015    position-independent, we return ORIG.  Newly generated
1016    position-independent addresses go to REG.  If we need more
1017    than one register, we lose.  */
1018
1019 rtx
1020 legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
1021 {
1022   rtx pic_ref = orig;
1023
1024   /* Labels need special handling.  */
1025   if (pic_label_operand (orig, mode))
1026     {
1027       /* We do not want to go through the movXX expanders here since that
1028          would create recursion.
1029
1030          Nor do we really want to call a generator for a named pattern
1031          since that requires multiple patterns if we want to support
1032          multiple word sizes.
1033
1034          So instead we just emit the raw set, which avoids the movXX
1035          expanders completely.  */
1036       mark_reg_pointer (reg, BITS_PER_UNIT);
1037       emit_insn (gen_rtx_SET (VOIDmode, reg, orig));
1038       current_function_uses_pic_offset_table = 1;
1039       return reg;
1040     }
1041   if (GET_CODE (orig) == SYMBOL_REF)
1042     {
1043       rtx insn, tmp_reg;
1044
1045       if (reg == 0)
1046         abort ();
1047
1048       /* Before reload, allocate a temporary register for the intermediate
1049          result.  This allows the sequence to be deleted when the final
1050          result is unused and the insns are trivially dead.  */
1051       tmp_reg = ((reload_in_progress || reload_completed)
1052                  ? reg : gen_reg_rtx (Pmode));
1053
1054       emit_move_insn (tmp_reg,
1055                       gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
1056                                     gen_rtx_HIGH (word_mode, orig)));
1057       pic_ref
1058         = gen_const_mem (Pmode,
1059                          gen_rtx_LO_SUM (Pmode, tmp_reg,
1060                                          gen_rtx_UNSPEC (Pmode,
1061                                                          gen_rtvec (1, orig),
1062                                                          UNSPEC_DLTIND14R)));
1063
1064       current_function_uses_pic_offset_table = 1;
1065       mark_reg_pointer (reg, BITS_PER_UNIT);
1066       insn = emit_move_insn (reg, pic_ref);
1067
1068       /* Put a REG_EQUAL note on this insn, so that it can be optimized.  */
1069       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig, REG_NOTES (insn));
1070
1071       return reg;
1072     }
1073   else if (GET_CODE (orig) == CONST)
1074     {
1075       rtx base;
1076
1077       if (GET_CODE (XEXP (orig, 0)) == PLUS
1078           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
1079         return orig;
1080
1081       if (reg == 0)
1082         abort ();
1083
1084       if (GET_CODE (XEXP (orig, 0)) == PLUS)
1085         {
1086           base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
1087           orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
1088                                          base == reg ? 0 : reg);
1089         }
1090       else
1091         abort ();
1092
1093       if (GET_CODE (orig) == CONST_INT)
1094         {
1095           if (INT_14_BITS (orig))
1096             return plus_constant (base, INTVAL (orig));
1097           orig = force_reg (Pmode, orig);
1098         }
1099       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
1100       /* Likewise, should we set special REG_NOTEs here?  */
1101     }
1102
1103   return pic_ref;
1104 }
1105
1106 /* Try machine-dependent ways of modifying an illegitimate address
1107    to be legitimate.  If we find one, return the new, valid address.
1108    This macro is used in only one place: `memory_address' in explow.c.
1109
1110    OLDX is the address as it was before break_out_memory_refs was called.
1111    In some cases it is useful to look at this to decide what needs to be done.
1112
1113    MODE and WIN are passed so that this macro can use
1114    GO_IF_LEGITIMATE_ADDRESS.
1115
1116    It is always safe for this macro to do nothing.  It exists to recognize
1117    opportunities to optimize the output.
1118
1119    For the PA, transform:
1120
1121         memory(X + <large int>)
1122
1123    into:
1124
1125         if (<large int> & mask) >= 16
1126           Y = (<large int> & ~mask) + mask + 1  Round up.
1127         else
1128           Y = (<large int> & ~mask)             Round down.
1129         Z = X + Y
1130         memory (Z + (<large int> - Y));
1131
1132    This is for CSE to find several similar references, and only use one Z.
1133
1134    X can either be a SYMBOL_REF or REG, but because combine cannot
1135    perform a 4->2 combination we do nothing for SYMBOL_REF + D where
1136    D will not fit in 14 bits.
1137
1138    MODE_FLOAT references allow displacements which fit in 5 bits, so use
1139    0x1f as the mask.
1140
1141    MODE_INT references allow displacements which fit in 14 bits, so use
1142    0x3fff as the mask.
1143
1144    This relies on the fact that most mode MODE_FLOAT references will use FP
1145    registers and most mode MODE_INT references will use integer registers.
1146    (In the rare case of an FP register used in an integer MODE, we depend
1147    on secondary reloads to clean things up.)
1148
1149
1150    It is also beneficial to handle (plus (mult (X) (Y)) (Z)) in a special
1151    manner if Y is 2, 4, or 8.  (allows more shadd insns and shifted indexed
1152    addressing modes to be used).
1153
1154    Put X and Z into registers.  Then put the entire expression into
1155    a register.  */
1156
1157 rtx
1158 hppa_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
1159                          enum machine_mode mode)
1160 {
1161   rtx orig = x;
1162
1163   /* We need to canonicalize the order of operands in unscaled indexed
1164      addresses since the code that checks if an address is valid doesn't
1165      always try both orders.  */
1166   if (!TARGET_NO_SPACE_REGS
1167       && GET_CODE (x) == PLUS
1168       && GET_MODE (x) == Pmode
1169       && REG_P (XEXP (x, 0))
1170       && REG_P (XEXP (x, 1))
1171       && REG_POINTER (XEXP (x, 0))
1172       && !REG_POINTER (XEXP (x, 1)))
1173     return gen_rtx_PLUS (Pmode, XEXP (x, 1), XEXP (x, 0));
1174
1175   if (flag_pic)
1176     return legitimize_pic_address (x, mode, gen_reg_rtx (Pmode));
1177
1178   /* Strip off CONST.  */
1179   if (GET_CODE (x) == CONST)
1180     x = XEXP (x, 0);
1181
1182   /* Special case.  Get the SYMBOL_REF into a register and use indexing.
1183      That should always be safe.  */
1184   if (GET_CODE (x) == PLUS
1185       && GET_CODE (XEXP (x, 0)) == REG
1186       && GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
1187     {
1188       rtx reg = force_reg (Pmode, XEXP (x, 1));
1189       return force_reg (Pmode, gen_rtx_PLUS (Pmode, reg, XEXP (x, 0)));
1190     }
1191
1192   /* Note we must reject symbols which represent function addresses
1193      since the assembler/linker can't handle arithmetic on plabels.  */
1194   if (GET_CODE (x) == PLUS
1195       && GET_CODE (XEXP (x, 1)) == CONST_INT
1196       && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1197            && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0)))
1198           || GET_CODE (XEXP (x, 0)) == REG))
1199     {
1200       rtx int_part, ptr_reg;
1201       int newoffset;
1202       int offset = INTVAL (XEXP (x, 1));
1203       int mask;
1204
1205       mask = (GET_MODE_CLASS (mode) == MODE_FLOAT
1206               ? (TARGET_PA_20 ? 0x3fff : 0x1f) : 0x3fff);
1207
1208       /* Choose which way to round the offset.  Round up if we
1209          are >= halfway to the next boundary.  */
1210       if ((offset & mask) >= ((mask + 1) / 2))
1211         newoffset = (offset & ~ mask) + mask + 1;
1212       else
1213         newoffset = (offset & ~ mask);
1214
1215       /* If the newoffset will not fit in 14 bits (ldo), then
1216          handling this would take 4 or 5 instructions (2 to load
1217          the SYMBOL_REF + 1 or 2 to load the newoffset + 1 to
1218          add the new offset and the SYMBOL_REF.)  Combine can
1219          not handle 4->2 or 5->2 combinations, so do not create
1220          them.  */
1221       if (! VAL_14_BITS_P (newoffset)
1222           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
1223         {
1224           rtx const_part = plus_constant (XEXP (x, 0), newoffset);
1225           rtx tmp_reg
1226             = force_reg (Pmode,
1227                          gen_rtx_HIGH (Pmode, const_part));
1228           ptr_reg
1229             = force_reg (Pmode,
1230                          gen_rtx_LO_SUM (Pmode,
1231                                          tmp_reg, const_part));
1232         }
1233       else
1234         {
1235           if (! VAL_14_BITS_P (newoffset))
1236             int_part = force_reg (Pmode, GEN_INT (newoffset));
1237           else
1238             int_part = GEN_INT (newoffset);
1239
1240           ptr_reg = force_reg (Pmode,
1241                                gen_rtx_PLUS (Pmode,
1242                                              force_reg (Pmode, XEXP (x, 0)),
1243                                              int_part));
1244         }
1245       return plus_constant (ptr_reg, offset - newoffset);
1246     }
1247
1248   /* Handle (plus (mult (a) (shadd_constant)) (b)).  */
1249
1250   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
1251       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1252       && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1)))
1253       && (OBJECT_P (XEXP (x, 1))
1254           || GET_CODE (XEXP (x, 1)) == SUBREG)
1255       && GET_CODE (XEXP (x, 1)) != CONST)
1256     {
1257       int val = INTVAL (XEXP (XEXP (x, 0), 1));
1258       rtx reg1, reg2;
1259
1260       reg1 = XEXP (x, 1);
1261       if (GET_CODE (reg1) != REG)
1262         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1263
1264       reg2 = XEXP (XEXP (x, 0), 0);
1265       if (GET_CODE (reg2) != REG)
1266         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1267
1268       return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1269                                              gen_rtx_MULT (Pmode,
1270                                                            reg2,
1271                                                            GEN_INT (val)),
1272                                              reg1));
1273     }
1274
1275   /* Similarly for (plus (plus (mult (a) (shadd_constant)) (b)) (c)).
1276
1277      Only do so for floating point modes since this is more speculative
1278      and we lose if it's an integer store.  */
1279   if (GET_CODE (x) == PLUS
1280       && GET_CODE (XEXP (x, 0)) == PLUS
1281       && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
1282       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
1283       && shadd_constant_p (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)))
1284       && (mode == SFmode || mode == DFmode))
1285     {
1286
1287       /* First, try and figure out what to use as a base register.  */
1288       rtx reg1, reg2, base, idx, orig_base;
1289
1290       reg1 = XEXP (XEXP (x, 0), 1);
1291       reg2 = XEXP (x, 1);
1292       base = NULL_RTX;
1293       idx = NULL_RTX;
1294
1295       /* Make sure they're both regs.  If one was a SYMBOL_REF [+ const],
1296          then emit_move_sequence will turn on REG_POINTER so we'll know
1297          it's a base register below.  */
1298       if (GET_CODE (reg1) != REG)
1299         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1300
1301       if (GET_CODE (reg2) != REG)
1302         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1303
1304       /* Figure out what the base and index are.  */
1305
1306       if (GET_CODE (reg1) == REG
1307           && REG_POINTER (reg1))
1308         {
1309           base = reg1;
1310           orig_base = XEXP (XEXP (x, 0), 1);
1311           idx = gen_rtx_PLUS (Pmode,
1312                               gen_rtx_MULT (Pmode,
1313                                             XEXP (XEXP (XEXP (x, 0), 0), 0),
1314                                             XEXP (XEXP (XEXP (x, 0), 0), 1)),
1315                               XEXP (x, 1));
1316         }
1317       else if (GET_CODE (reg2) == REG
1318                && REG_POINTER (reg2))
1319         {
1320           base = reg2;
1321           orig_base = XEXP (x, 1);
1322           idx = XEXP (x, 0);
1323         }
1324
1325       if (base == 0)
1326         return orig;
1327
1328       /* If the index adds a large constant, try to scale the
1329          constant so that it can be loaded with only one insn.  */
1330       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1331           && VAL_14_BITS_P (INTVAL (XEXP (idx, 1))
1332                             / INTVAL (XEXP (XEXP (idx, 0), 1)))
1333           && INTVAL (XEXP (idx, 1)) % INTVAL (XEXP (XEXP (idx, 0), 1)) == 0)
1334         {
1335           /* Divide the CONST_INT by the scale factor, then add it to A.  */
1336           int val = INTVAL (XEXP (idx, 1));
1337
1338           val /= INTVAL (XEXP (XEXP (idx, 0), 1));
1339           reg1 = XEXP (XEXP (idx, 0), 0);
1340           if (GET_CODE (reg1) != REG)
1341             reg1 = force_reg (Pmode, force_operand (reg1, 0));
1342
1343           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
1344
1345           /* We can now generate a simple scaled indexed address.  */
1346           return
1347             force_reg
1348               (Pmode, gen_rtx_PLUS (Pmode,
1349                                     gen_rtx_MULT (Pmode, reg1,
1350                                                   XEXP (XEXP (idx, 0), 1)),
1351                                     base));
1352         }
1353
1354       /* If B + C is still a valid base register, then add them.  */
1355       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1356           && INTVAL (XEXP (idx, 1)) <= 4096
1357           && INTVAL (XEXP (idx, 1)) >= -4096)
1358         {
1359           int val = INTVAL (XEXP (XEXP (idx, 0), 1));
1360           rtx reg1, reg2;
1361
1362           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, XEXP (idx, 1)));
1363
1364           reg2 = XEXP (XEXP (idx, 0), 0);
1365           if (GET_CODE (reg2) != CONST_INT)
1366             reg2 = force_reg (Pmode, force_operand (reg2, 0));
1367
1368           return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1369                                                  gen_rtx_MULT (Pmode,
1370                                                                reg2,
1371                                                                GEN_INT (val)),
1372                                                  reg1));
1373         }
1374
1375       /* Get the index into a register, then add the base + index and
1376          return a register holding the result.  */
1377
1378       /* First get A into a register.  */
1379       reg1 = XEXP (XEXP (idx, 0), 0);
1380       if (GET_CODE (reg1) != REG)
1381         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1382
1383       /* And get B into a register.  */
1384       reg2 = XEXP (idx, 1);
1385       if (GET_CODE (reg2) != REG)
1386         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1387
1388       reg1 = force_reg (Pmode,
1389                         gen_rtx_PLUS (Pmode,
1390                                       gen_rtx_MULT (Pmode, reg1,
1391                                                     XEXP (XEXP (idx, 0), 1)),
1392                                       reg2));
1393
1394       /* Add the result to our base register and return.  */
1395       return force_reg (Pmode, gen_rtx_PLUS (Pmode, base, reg1));
1396
1397     }
1398
1399   /* Uh-oh.  We might have an address for x[n-100000].  This needs
1400      special handling to avoid creating an indexed memory address
1401      with x-100000 as the base.
1402
1403      If the constant part is small enough, then it's still safe because
1404      there is a guard page at the beginning and end of the data segment.
1405
1406      Scaled references are common enough that we want to try and rearrange the
1407      terms so that we can use indexing for these addresses too.  Only
1408      do the optimization for floatint point modes.  */
1409
1410   if (GET_CODE (x) == PLUS
1411       && symbolic_expression_p (XEXP (x, 1)))
1412     {
1413       /* Ugly.  We modify things here so that the address offset specified
1414          by the index expression is computed first, then added to x to form
1415          the entire address.  */
1416
1417       rtx regx1, regx2, regy1, regy2, y;
1418
1419       /* Strip off any CONST.  */
1420       y = XEXP (x, 1);
1421       if (GET_CODE (y) == CONST)
1422         y = XEXP (y, 0);
1423
1424       if (GET_CODE (y) == PLUS || GET_CODE (y) == MINUS)
1425         {
1426           /* See if this looks like
1427                 (plus (mult (reg) (shadd_const))
1428                       (const (plus (symbol_ref) (const_int))))
1429
1430              Where const_int is small.  In that case the const
1431              expression is a valid pointer for indexing.
1432
1433              If const_int is big, but can be divided evenly by shadd_const
1434              and added to (reg).  This allows more scaled indexed addresses.  */
1435           if (GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1436               && GET_CODE (XEXP (x, 0)) == MULT
1437               && GET_CODE (XEXP (y, 1)) == CONST_INT
1438               && INTVAL (XEXP (y, 1)) >= -4096
1439               && INTVAL (XEXP (y, 1)) <= 4095
1440               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1441               && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1442             {
1443               int val = INTVAL (XEXP (XEXP (x, 0), 1));
1444               rtx reg1, reg2;
1445
1446               reg1 = XEXP (x, 1);
1447               if (GET_CODE (reg1) != REG)
1448                 reg1 = force_reg (Pmode, force_operand (reg1, 0));
1449
1450               reg2 = XEXP (XEXP (x, 0), 0);
1451               if (GET_CODE (reg2) != REG)
1452                 reg2 = force_reg (Pmode, force_operand (reg2, 0));
1453
1454               return force_reg (Pmode,
1455                                 gen_rtx_PLUS (Pmode,
1456                                               gen_rtx_MULT (Pmode,
1457                                                             reg2,
1458                                                             GEN_INT (val)),
1459                                               reg1));
1460             }
1461           else if ((mode == DFmode || mode == SFmode)
1462                    && GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1463                    && GET_CODE (XEXP (x, 0)) == MULT
1464                    && GET_CODE (XEXP (y, 1)) == CONST_INT
1465                    && INTVAL (XEXP (y, 1)) % INTVAL (XEXP (XEXP (x, 0), 1)) == 0
1466                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1467                    && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1468             {
1469               regx1
1470                 = force_reg (Pmode, GEN_INT (INTVAL (XEXP (y, 1))
1471                                              / INTVAL (XEXP (XEXP (x, 0), 1))));
1472               regx2 = XEXP (XEXP (x, 0), 0);
1473               if (GET_CODE (regx2) != REG)
1474                 regx2 = force_reg (Pmode, force_operand (regx2, 0));
1475               regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1476                                                         regx2, regx1));
1477               return
1478                 force_reg (Pmode,
1479                            gen_rtx_PLUS (Pmode,
1480                                          gen_rtx_MULT (Pmode, regx2,
1481                                                        XEXP (XEXP (x, 0), 1)),
1482                                          force_reg (Pmode, XEXP (y, 0))));
1483             }
1484           else if (GET_CODE (XEXP (y, 1)) == CONST_INT
1485                    && INTVAL (XEXP (y, 1)) >= -4096
1486                    && INTVAL (XEXP (y, 1)) <= 4095)
1487             {
1488               /* This is safe because of the guard page at the
1489                  beginning and end of the data space.  Just
1490                  return the original address.  */
1491               return orig;
1492             }
1493           else
1494             {
1495               /* Doesn't look like one we can optimize.  */
1496               regx1 = force_reg (Pmode, force_operand (XEXP (x, 0), 0));
1497               regy1 = force_reg (Pmode, force_operand (XEXP (y, 0), 0));
1498               regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
1499               regx1 = force_reg (Pmode,
1500                                  gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1501                                                  regx1, regy2));
1502               return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
1503             }
1504         }
1505     }
1506
1507   return orig;
1508 }
1509
1510 /* For the HPPA, REG and REG+CONST is cost 0
1511    and addresses involving symbolic constants are cost 2.
1512
1513    PIC addresses are very expensive.
1514
1515    It is no coincidence that this has the same structure
1516    as GO_IF_LEGITIMATE_ADDRESS.  */
1517
1518 static int
1519 hppa_address_cost (rtx X)
1520 {
1521   switch (GET_CODE (X))
1522     {
1523     case REG:
1524     case PLUS:
1525     case LO_SUM:
1526       return 1;
1527     case HIGH:
1528       return 2;
1529     default:
1530       return 4;
1531     }
1532 }
1533
1534 /* Compute a (partial) cost for rtx X.  Return true if the complete
1535    cost has been computed, and false if subexpressions should be
1536    scanned.  In either case, *TOTAL contains the cost result.  */
1537
1538 static bool
1539 hppa_rtx_costs (rtx x, int code, int outer_code, int *total)
1540 {
1541   switch (code)
1542     {
1543     case CONST_INT:
1544       if (INTVAL (x) == 0)
1545         *total = 0;
1546       else if (INT_14_BITS (x))
1547         *total = 1;
1548       else
1549         *total = 2;
1550       return true;
1551
1552     case HIGH:
1553       *total = 2;
1554       return true;
1555
1556     case CONST:
1557     case LABEL_REF:
1558     case SYMBOL_REF:
1559       *total = 4;
1560       return true;
1561
1562     case CONST_DOUBLE:
1563       if ((x == CONST0_RTX (DFmode) || x == CONST0_RTX (SFmode))
1564           && outer_code != SET)
1565         *total = 0;
1566       else
1567         *total = 8;
1568       return true;
1569
1570     case MULT:
1571       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1572         *total = COSTS_N_INSNS (3);
1573       else if (TARGET_PA_11 && !TARGET_DISABLE_FPREGS && !TARGET_SOFT_FLOAT)
1574         *total = COSTS_N_INSNS (8);
1575       else
1576         *total = COSTS_N_INSNS (20);
1577       return true;
1578
1579     case DIV:
1580       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1581         {
1582           *total = COSTS_N_INSNS (14);
1583           return true;
1584         }
1585       /* FALLTHRU */
1586
1587     case UDIV:
1588     case MOD:
1589     case UMOD:
1590       *total = COSTS_N_INSNS (60);
1591       return true;
1592
1593     case PLUS: /* this includes shNadd insns */
1594     case MINUS:
1595       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1596         *total = COSTS_N_INSNS (3);
1597       else
1598         *total = COSTS_N_INSNS (1);
1599       return true;
1600
1601     case ASHIFT:
1602     case ASHIFTRT:
1603     case LSHIFTRT:
1604       *total = COSTS_N_INSNS (1);
1605       return true;
1606
1607     default:
1608       return false;
1609     }
1610 }
1611
1612 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
1613    new rtx with the correct mode.  */
1614 static inline rtx
1615 force_mode (enum machine_mode mode, rtx orig)
1616 {
1617   if (mode == GET_MODE (orig))
1618     return orig;
1619
1620   if (REGNO (orig) >= FIRST_PSEUDO_REGISTER)
1621     abort ();
1622
1623   return gen_rtx_REG (mode, REGNO (orig));
1624 }
1625
1626 /* Emit insns to move operands[1] into operands[0].
1627
1628    Return 1 if we have written out everything that needs to be done to
1629    do the move.  Otherwise, return 0 and the caller will emit the move
1630    normally.
1631
1632    Note SCRATCH_REG may not be in the proper mode depending on how it
1633    will be used.  This routine is responsible for creating a new copy
1634    of SCRATCH_REG in the proper mode.  */
1635
1636 int
1637 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
1638 {
1639   register rtx operand0 = operands[0];
1640   register rtx operand1 = operands[1];
1641   register rtx tem;
1642
1643   /* We can only handle indexed addresses in the destination operand
1644      of floating point stores.  Thus, we need to break out indexed
1645      addresses from the destination operand.  */
1646   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
1647     {
1648       /* This is only safe up to the beginning of life analysis.  */
1649       if (no_new_pseudos)
1650         abort ();
1651
1652       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
1653       operand0 = replace_equiv_address (operand0, tem);
1654     }
1655
1656   /* On targets with non-equivalent space registers, break out unscaled
1657      indexed addresses from the source operand before the final CSE.
1658      We have to do this because the REG_POINTER flag is not correctly
1659      carried through various optimization passes and CSE may substitute
1660      a pseudo without the pointer set for one with the pointer set.  As
1661      a result, we loose various opportunities to create insns with
1662      unscaled indexed addresses.  */
1663   if (!TARGET_NO_SPACE_REGS
1664       && !cse_not_expected
1665       && GET_CODE (operand1) == MEM
1666       && GET_CODE (XEXP (operand1, 0)) == PLUS
1667       && REG_P (XEXP (XEXP (operand1, 0), 0))
1668       && REG_P (XEXP (XEXP (operand1, 0), 1)))
1669     operand1
1670       = replace_equiv_address (operand1,
1671                                copy_to_mode_reg (Pmode, XEXP (operand1, 0)));
1672
1673   if (scratch_reg
1674       && reload_in_progress && GET_CODE (operand0) == REG
1675       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1676     operand0 = reg_equiv_mem[REGNO (operand0)];
1677   else if (scratch_reg
1678            && reload_in_progress && GET_CODE (operand0) == SUBREG
1679            && GET_CODE (SUBREG_REG (operand0)) == REG
1680            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
1681     {
1682      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1683         the code which tracks sets/uses for delete_output_reload.  */
1684       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
1685                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
1686                                  SUBREG_BYTE (operand0));
1687       operand0 = alter_subreg (&temp);
1688     }
1689
1690   if (scratch_reg
1691       && reload_in_progress && GET_CODE (operand1) == REG
1692       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
1693     operand1 = reg_equiv_mem[REGNO (operand1)];
1694   else if (scratch_reg
1695            && reload_in_progress && GET_CODE (operand1) == SUBREG
1696            && GET_CODE (SUBREG_REG (operand1)) == REG
1697            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
1698     {
1699      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1700         the code which tracks sets/uses for delete_output_reload.  */
1701       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
1702                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
1703                                  SUBREG_BYTE (operand1));
1704       operand1 = alter_subreg (&temp);
1705     }
1706
1707   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
1708       && ((tem = find_replacement (&XEXP (operand0, 0)))
1709           != XEXP (operand0, 0)))
1710     operand0 = gen_rtx_MEM (GET_MODE (operand0), tem);
1711
1712   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
1713       && ((tem = find_replacement (&XEXP (operand1, 0)))
1714           != XEXP (operand1, 0)))
1715     operand1 = gen_rtx_MEM (GET_MODE (operand1), tem);
1716
1717   /* Handle secondary reloads for loads/stores of FP registers from
1718      REG+D addresses where D does not fit in 5 or 14 bits, including
1719      (subreg (mem (addr))) cases.  */
1720   if (scratch_reg
1721       && fp_reg_operand (operand0, mode)
1722       && ((GET_CODE (operand1) == MEM
1723            && !memory_address_p ((GET_MODE_SIZE (mode) == 4 ? SFmode : DFmode),
1724                                  XEXP (operand1, 0)))
1725           || ((GET_CODE (operand1) == SUBREG
1726                && GET_CODE (XEXP (operand1, 0)) == MEM
1727                && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1728                                       ? SFmode : DFmode),
1729                                      XEXP (XEXP (operand1, 0), 0))))))
1730     {
1731       if (GET_CODE (operand1) == SUBREG)
1732         operand1 = XEXP (operand1, 0);
1733
1734       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1735          it in WORD_MODE regardless of what mode it was originally given
1736          to us.  */
1737       scratch_reg = force_mode (word_mode, scratch_reg);
1738
1739       /* D might not fit in 14 bits either; for such cases load D into
1740          scratch reg.  */
1741       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
1742         {
1743           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1744           emit_move_insn (scratch_reg,
1745                           gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
1746                                           Pmode,
1747                                           XEXP (XEXP (operand1, 0), 0),
1748                                           scratch_reg));
1749         }
1750       else
1751         emit_move_insn (scratch_reg, XEXP (operand1, 0));
1752       emit_insn (gen_rtx_SET (VOIDmode, operand0,
1753                               gen_rtx_MEM (mode, scratch_reg)));
1754       return 1;
1755     }
1756   else if (scratch_reg
1757            && fp_reg_operand (operand1, mode)
1758            && ((GET_CODE (operand0) == MEM
1759                 && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1760                                         ? SFmode : DFmode),
1761                                        XEXP (operand0, 0)))
1762                || ((GET_CODE (operand0) == SUBREG)
1763                    && GET_CODE (XEXP (operand0, 0)) == MEM
1764                    && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1765                                           ? SFmode : DFmode),
1766                                          XEXP (XEXP (operand0, 0), 0)))))
1767     {
1768       if (GET_CODE (operand0) == SUBREG)
1769         operand0 = XEXP (operand0, 0);
1770
1771       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1772          it in WORD_MODE regardless of what mode it was originally given
1773          to us.  */
1774       scratch_reg = force_mode (word_mode, scratch_reg);
1775
1776       /* D might not fit in 14 bits either; for such cases load D into
1777          scratch reg.  */
1778       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
1779         {
1780           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
1781           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
1782                                                                         0)),
1783                                                        Pmode,
1784                                                        XEXP (XEXP (operand0, 0),
1785                                                                    0),
1786                                                        scratch_reg));
1787         }
1788       else
1789         emit_move_insn (scratch_reg, XEXP (operand0, 0));
1790       emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_MEM (mode, scratch_reg),
1791                               operand1));
1792       return 1;
1793     }
1794   /* Handle secondary reloads for loads of FP registers from constant
1795      expressions by forcing the constant into memory.
1796
1797      Use scratch_reg to hold the address of the memory location.
1798
1799      The proper fix is to change PREFERRED_RELOAD_CLASS to return
1800      NO_REGS when presented with a const_int and a register class
1801      containing only FP registers.  Doing so unfortunately creates
1802      more problems than it solves.   Fix this for 2.5.  */
1803   else if (scratch_reg
1804            && CONSTANT_P (operand1)
1805            && fp_reg_operand (operand0, mode))
1806     {
1807       rtx xoperands[2];
1808
1809       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1810          it in WORD_MODE regardless of what mode it was originally given
1811          to us.  */
1812       scratch_reg = force_mode (word_mode, scratch_reg);
1813
1814       /* Force the constant into memory and put the address of the
1815          memory location into scratch_reg.  */
1816       xoperands[0] = scratch_reg;
1817       xoperands[1] = XEXP (force_const_mem (mode, operand1), 0);
1818       emit_move_sequence (xoperands, Pmode, 0);
1819
1820       /* Now load the destination register.  */
1821       emit_insn (gen_rtx_SET (mode, operand0,
1822                               gen_rtx_MEM (mode, scratch_reg)));
1823       return 1;
1824     }
1825   /* Handle secondary reloads for SAR.  These occur when trying to load
1826      the SAR from memory, FP register, or with a constant.  */
1827   else if (scratch_reg
1828            && GET_CODE (operand0) == REG
1829            && REGNO (operand0) < FIRST_PSEUDO_REGISTER
1830            && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
1831            && (GET_CODE (operand1) == MEM
1832                || GET_CODE (operand1) == CONST_INT
1833                || (GET_CODE (operand1) == REG
1834                    && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
1835     {
1836       /* D might not fit in 14 bits either; for such cases load D into
1837          scratch reg.  */
1838       if (GET_CODE (operand1) == MEM
1839           && !memory_address_p (Pmode, XEXP (operand1, 0)))
1840         {
1841           /* We are reloading the address into the scratch register, so we
1842              want to make sure the scratch register is a full register.  */
1843           scratch_reg = force_mode (word_mode, scratch_reg);
1844
1845           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1846           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1,
1847                                                                         0)),
1848                                                        Pmode,
1849                                                        XEXP (XEXP (operand1, 0),
1850                                                        0),
1851                                                        scratch_reg));
1852
1853           /* Now we are going to load the scratch register from memory,
1854              we want to load it in the same width as the original MEM,
1855              which must be the same as the width of the ultimate destination,
1856              OPERAND0.  */
1857           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1858
1859           emit_move_insn (scratch_reg, gen_rtx_MEM (GET_MODE (operand0),
1860                                                     scratch_reg));
1861         }
1862       else
1863         {
1864           /* We want to load the scratch register using the same mode as
1865              the ultimate destination.  */
1866           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1867
1868           emit_move_insn (scratch_reg, operand1);
1869         }
1870
1871       /* And emit the insn to set the ultimate destination.  We know that
1872          the scratch register has the same mode as the destination at this
1873          point.  */
1874       emit_move_insn (operand0, scratch_reg);
1875       return 1;
1876     }
1877   /* Handle the most common case: storing into a register.  */
1878   else if (register_operand (operand0, mode))
1879     {
1880       if (register_operand (operand1, mode)
1881           || (GET_CODE (operand1) == CONST_INT
1882               && cint_ok_for_move (INTVAL (operand1)))
1883           || (operand1 == CONST0_RTX (mode))
1884           || (GET_CODE (operand1) == HIGH
1885               && !symbolic_operand (XEXP (operand1, 0), VOIDmode))
1886           /* Only `general_operands' can come here, so MEM is ok.  */
1887           || GET_CODE (operand1) == MEM)
1888         {
1889           /* Various sets are created during RTL generation which don't
1890              have the REG_POINTER flag correctly set.  After the CSE pass,
1891              instruction recognition can fail if we don't consistently
1892              set this flag when performing register copies.  This should
1893              also improve the opportunities for creating insns that use
1894              unscaled indexing.  */
1895           if (REG_P (operand0) && REG_P (operand1))
1896             {
1897               if (REG_POINTER (operand1)
1898                   && !REG_POINTER (operand0)
1899                   && !HARD_REGISTER_P (operand0))
1900                 copy_reg_pointer (operand0, operand1);
1901               else if (REG_POINTER (operand0)
1902                        && !REG_POINTER (operand1)
1903                        && !HARD_REGISTER_P (operand1))
1904                 copy_reg_pointer (operand1, operand0);
1905             }
1906           
1907           /* When MEMs are broken out, the REG_POINTER flag doesn't
1908              get set.  In some cases, we can set the REG_POINTER flag
1909              from the declaration for the MEM.  */
1910           if (REG_P (operand0)
1911               && GET_CODE (operand1) == MEM
1912               && !REG_POINTER (operand0))
1913             {
1914               tree decl = MEM_EXPR (operand1);
1915
1916               /* Set the register pointer flag and register alignment
1917                  if the declaration for this memory reference is a
1918                  pointer type.  Fortran indirect argument references
1919                  are ignored.  */
1920               if (decl
1921                   && !(flag_argument_noalias > 1
1922                        && TREE_CODE (decl) == INDIRECT_REF
1923                        && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL))
1924                 {
1925                   tree type;
1926
1927                   /* If this is a COMPONENT_REF, use the FIELD_DECL from
1928                      tree operand 1.  */
1929                   if (TREE_CODE (decl) == COMPONENT_REF)
1930                     decl = TREE_OPERAND (decl, 1);
1931
1932                   type = TREE_TYPE (decl);
1933                   if (TREE_CODE (type) == ARRAY_TYPE)
1934                     type = get_inner_array_type (type);
1935
1936                   if (POINTER_TYPE_P (type))
1937                     {
1938                       int align;
1939
1940                       type = TREE_TYPE (type);
1941                       /* Using TYPE_ALIGN_OK is rather conservative as
1942                          only the ada frontend actually sets it.  */
1943                       align = (TYPE_ALIGN_OK (type) ? TYPE_ALIGN (type)
1944                                : BITS_PER_UNIT);
1945                       mark_reg_pointer (operand0, align);
1946                     }
1947                 }
1948             }
1949
1950           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1951           return 1;
1952         }
1953     }
1954   else if (GET_CODE (operand0) == MEM)
1955     {
1956       if (mode == DFmode && operand1 == CONST0_RTX (mode)
1957           && !(reload_in_progress || reload_completed))
1958         {
1959           rtx temp = gen_reg_rtx (DFmode);
1960
1961           emit_insn (gen_rtx_SET (VOIDmode, temp, operand1));
1962           emit_insn (gen_rtx_SET (VOIDmode, operand0, temp));
1963           return 1;
1964         }
1965       if (register_operand (operand1, mode) || operand1 == CONST0_RTX (mode))
1966         {
1967           /* Run this case quickly.  */
1968           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1969           return 1;
1970         }
1971       if (! (reload_in_progress || reload_completed))
1972         {
1973           operands[0] = validize_mem (operand0);
1974           operands[1] = operand1 = force_reg (mode, operand1);
1975         }
1976     }
1977
1978   /* Simplify the source if we need to.
1979      Note we do have to handle function labels here, even though we do
1980      not consider them legitimate constants.  Loop optimizations can
1981      call the emit_move_xxx with one as a source.  */
1982   if ((GET_CODE (operand1) != HIGH && immediate_operand (operand1, mode))
1983       || function_label_operand (operand1, mode)
1984       || (GET_CODE (operand1) == HIGH
1985           && symbolic_operand (XEXP (operand1, 0), mode)))
1986     {
1987       int ishighonly = 0;
1988
1989       if (GET_CODE (operand1) == HIGH)
1990         {
1991           ishighonly = 1;
1992           operand1 = XEXP (operand1, 0);
1993         }
1994       if (symbolic_operand (operand1, mode))
1995         {
1996           /* Argh.  The assembler and linker can't handle arithmetic
1997              involving plabels.
1998
1999              So we force the plabel into memory, load operand0 from
2000              the memory location, then add in the constant part.  */
2001           if ((GET_CODE (operand1) == CONST
2002                && GET_CODE (XEXP (operand1, 0)) == PLUS
2003                && function_label_operand (XEXP (XEXP (operand1, 0), 0), Pmode))
2004               || function_label_operand (operand1, mode))
2005             {
2006               rtx temp, const_part;
2007
2008               /* Figure out what (if any) scratch register to use.  */
2009               if (reload_in_progress || reload_completed)
2010                 {
2011                   scratch_reg = scratch_reg ? scratch_reg : operand0;
2012                   /* SCRATCH_REG will hold an address and maybe the actual
2013                      data.  We want it in WORD_MODE regardless of what mode it
2014                      was originally given to us.  */
2015                   scratch_reg = force_mode (word_mode, scratch_reg);
2016                 }
2017               else if (flag_pic)
2018                 scratch_reg = gen_reg_rtx (Pmode);
2019
2020               if (GET_CODE (operand1) == CONST)
2021                 {
2022                   /* Save away the constant part of the expression.  */
2023                   const_part = XEXP (XEXP (operand1, 0), 1);
2024                   if (GET_CODE (const_part) != CONST_INT)
2025                     abort ();
2026
2027                   /* Force the function label into memory.  */
2028                   temp = force_const_mem (mode, XEXP (XEXP (operand1, 0), 0));
2029                 }
2030               else
2031                 {
2032                   /* No constant part.  */
2033                   const_part = NULL_RTX;
2034
2035                   /* Force the function label into memory.  */
2036                   temp = force_const_mem (mode, operand1);
2037                 }
2038
2039
2040               /* Get the address of the memory location.  PIC-ify it if
2041                  necessary.  */
2042               temp = XEXP (temp, 0);
2043               if (flag_pic)
2044                 temp = legitimize_pic_address (temp, mode, scratch_reg);
2045
2046               /* Put the address of the memory location into our destination
2047                  register.  */
2048               operands[1] = temp;
2049               emit_move_sequence (operands, mode, scratch_reg);
2050
2051               /* Now load from the memory location into our destination
2052                  register.  */
2053               operands[1] = gen_rtx_MEM (Pmode, operands[0]);
2054               emit_move_sequence (operands, mode, scratch_reg);
2055
2056               /* And add back in the constant part.  */
2057               if (const_part != NULL_RTX)
2058                 expand_inc (operand0, const_part);
2059
2060               return 1;
2061             }
2062
2063           if (flag_pic)
2064             {
2065               rtx temp;
2066
2067               if (reload_in_progress || reload_completed)
2068                 {
2069                   temp = scratch_reg ? scratch_reg : operand0;
2070                   /* TEMP will hold an address and maybe the actual
2071                      data.  We want it in WORD_MODE regardless of what mode it
2072                      was originally given to us.  */
2073                   temp = force_mode (word_mode, temp);
2074                 }
2075               else
2076                 temp = gen_reg_rtx (Pmode);
2077
2078               /* (const (plus (symbol) (const_int))) must be forced to
2079                  memory during/after reload if the const_int will not fit
2080                  in 14 bits.  */
2081               if (GET_CODE (operand1) == CONST
2082                        && GET_CODE (XEXP (operand1, 0)) == PLUS
2083                        && GET_CODE (XEXP (XEXP (operand1, 0), 1)) == CONST_INT
2084                        && !INT_14_BITS (XEXP (XEXP (operand1, 0), 1))
2085                        && (reload_completed || reload_in_progress)
2086                        && flag_pic)
2087                 {
2088                   operands[1] = force_const_mem (mode, operand1);
2089                   operands[1] = legitimize_pic_address (XEXP (operands[1], 0),
2090                                                         mode, temp);
2091                   operands[1] = gen_rtx_MEM (mode, operands[1]);
2092                   emit_move_sequence (operands, mode, temp);
2093                 }
2094               else
2095                 {
2096                   operands[1] = legitimize_pic_address (operand1, mode, temp);
2097                   if (REG_P (operand0) && REG_P (operands[1]))
2098                     copy_reg_pointer (operand0, operands[1]);
2099                   emit_insn (gen_rtx_SET (VOIDmode, operand0, operands[1]));
2100                 }
2101             }
2102           /* On the HPPA, references to data space are supposed to use dp,
2103              register 27, but showing it in the RTL inhibits various cse
2104              and loop optimizations.  */
2105           else
2106             {
2107               rtx temp, set;
2108
2109               if (reload_in_progress || reload_completed)
2110                 {
2111                   temp = scratch_reg ? scratch_reg : operand0;
2112                   /* TEMP will hold an address and maybe the actual
2113                      data.  We want it in WORD_MODE regardless of what mode it
2114                      was originally given to us.  */
2115                   temp = force_mode (word_mode, temp);
2116                 }
2117               else
2118                 temp = gen_reg_rtx (mode);
2119
2120               /* Loading a SYMBOL_REF into a register makes that register
2121                  safe to be used as the base in an indexed address.
2122
2123                  Don't mark hard registers though.  That loses.  */
2124               if (GET_CODE (operand0) == REG
2125                   && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
2126                 mark_reg_pointer (operand0, BITS_PER_UNIT);
2127               if (REGNO (temp) >= FIRST_PSEUDO_REGISTER)
2128                 mark_reg_pointer (temp, BITS_PER_UNIT);
2129
2130               if (ishighonly)
2131                 set = gen_rtx_SET (mode, operand0, temp);
2132               else
2133                 set = gen_rtx_SET (VOIDmode,
2134                                    operand0,
2135                                    gen_rtx_LO_SUM (mode, temp, operand1));
2136
2137               emit_insn (gen_rtx_SET (VOIDmode,
2138                                       temp,
2139                                       gen_rtx_HIGH (mode, operand1)));
2140               emit_insn (set);
2141
2142             }
2143           return 1;
2144         }
2145       else if (GET_CODE (operand1) != CONST_INT
2146                || !cint_ok_for_move (INTVAL (operand1)))
2147         {
2148           rtx insn, temp;
2149           rtx op1 = operand1;
2150           HOST_WIDE_INT value = 0;
2151           HOST_WIDE_INT insv = 0;
2152           int insert = 0;
2153
2154           if (GET_CODE (operand1) == CONST_INT)
2155             value = INTVAL (operand1);
2156
2157           if (TARGET_64BIT
2158               && GET_CODE (operand1) == CONST_INT
2159               && HOST_BITS_PER_WIDE_INT > 32
2160               && GET_MODE_BITSIZE (GET_MODE (operand0)) > 32)
2161             {
2162               HOST_WIDE_INT nval;
2163
2164               /* Extract the low order 32 bits of the value and sign extend.
2165                  If the new value is the same as the original value, we can
2166                  can use the original value as-is.  If the new value is
2167                  different, we use it and insert the most-significant 32-bits
2168                  of the original value into the final result.  */
2169               nval = ((value & (((HOST_WIDE_INT) 2 << 31) - 1))
2170                       ^ ((HOST_WIDE_INT) 1 << 31)) - ((HOST_WIDE_INT) 1 << 31);
2171               if (value != nval)
2172                 {
2173 #if HOST_BITS_PER_WIDE_INT > 32
2174                   insv = value >= 0 ? value >> 32 : ~(~value >> 32);
2175 #endif
2176                   insert = 1;
2177                   value = nval;
2178                   operand1 = GEN_INT (nval);
2179                 }
2180             }
2181
2182           if (reload_in_progress || reload_completed)
2183             temp = scratch_reg ? scratch_reg : operand0;
2184           else
2185             temp = gen_reg_rtx (mode);
2186
2187           /* We don't directly split DImode constants on 32-bit targets
2188              because PLUS uses an 11-bit immediate and the insn sequence
2189              generated is not as efficient as the one using HIGH/LO_SUM.  */
2190           if (GET_CODE (operand1) == CONST_INT
2191               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2192               && !insert)
2193             {
2194               /* Directly break constant into high and low parts.  This
2195                  provides better optimization opportunities because various
2196                  passes recognize constants split with PLUS but not LO_SUM.
2197                  We use a 14-bit signed low part except when the addition
2198                  of 0x4000 to the high part might change the sign of the
2199                  high part.  */
2200               HOST_WIDE_INT low = value & 0x3fff;
2201               HOST_WIDE_INT high = value & ~ 0x3fff;
2202
2203               if (low >= 0x2000)
2204                 {
2205                   if (high == 0x7fffc000 || (mode == HImode && high == 0x4000))
2206                     high += 0x2000;
2207                   else
2208                     high += 0x4000;
2209                 }
2210
2211               low = value - high;
2212
2213               emit_insn (gen_rtx_SET (VOIDmode, temp, GEN_INT (high)));
2214               operands[1] = gen_rtx_PLUS (mode, temp, GEN_INT (low));
2215             }
2216           else
2217             {
2218               emit_insn (gen_rtx_SET (VOIDmode, temp,
2219                                       gen_rtx_HIGH (mode, operand1)));
2220               operands[1] = gen_rtx_LO_SUM (mode, temp, operand1);
2221             }
2222
2223           insn = emit_move_insn (operands[0], operands[1]);
2224
2225           /* Now insert the most significant 32 bits of the value
2226              into the register.  When we don't have a second register
2227              available, it could take up to nine instructions to load
2228              a 64-bit integer constant.  Prior to reload, we force
2229              constants that would take more than three instructions
2230              to load to the constant pool.  During and after reload,
2231              we have to handle all possible values.  */
2232           if (insert)
2233             {
2234               /* Use a HIGH/LO_SUM/INSV sequence if we have a second
2235                  register and the value to be inserted is outside the
2236                  range that can be loaded with three depdi instructions.  */
2237               if (temp != operand0 && (insv >= 16384 || insv < -16384))
2238                 {
2239                   operand1 = GEN_INT (insv);
2240
2241                   emit_insn (gen_rtx_SET (VOIDmode, temp,
2242                                           gen_rtx_HIGH (mode, operand1)));
2243                   emit_move_insn (temp, gen_rtx_LO_SUM (mode, temp, operand1));
2244                   emit_insn (gen_insv (operand0, GEN_INT (32),
2245                                        const0_rtx, temp));
2246                 }
2247               else
2248                 {
2249                   int len = 5, pos = 27;
2250
2251                   /* Insert the bits using the depdi instruction.  */
2252                   while (pos >= 0)
2253                     {
2254                       HOST_WIDE_INT v5 = ((insv & 31) ^ 16) - 16;
2255                       HOST_WIDE_INT sign = v5 < 0;
2256
2257                       /* Left extend the insertion.  */
2258                       insv = (insv >= 0 ? insv >> len : ~(~insv >> len));
2259                       while (pos > 0 && (insv & 1) == sign)
2260                         {
2261                           insv = (insv >= 0 ? insv >> 1 : ~(~insv >> 1));
2262                           len += 1;
2263                           pos -= 1;
2264                         }
2265
2266                       emit_insn (gen_insv (operand0, GEN_INT (len),
2267                                            GEN_INT (pos), GEN_INT (v5)));
2268
2269                       len = pos > 0 && pos < 5 ? pos : 5;
2270                       pos -= len;
2271                     }
2272                 }
2273             }
2274
2275           REG_NOTES (insn)
2276             = gen_rtx_EXPR_LIST (REG_EQUAL, op1, REG_NOTES (insn));
2277
2278           return 1;
2279         }
2280     }
2281   /* Now have insn-emit do whatever it normally does.  */
2282   return 0;
2283 }
2284
2285 /* Examine EXP and return nonzero if it contains an ADDR_EXPR (meaning
2286    it will need a link/runtime reloc).  */
2287
2288 int
2289 reloc_needed (tree exp)
2290 {
2291   int reloc = 0;
2292
2293   switch (TREE_CODE (exp))
2294     {
2295     case ADDR_EXPR:
2296       return 1;
2297
2298     case PLUS_EXPR:
2299     case MINUS_EXPR:
2300       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2301       reloc |= reloc_needed (TREE_OPERAND (exp, 1));
2302       break;
2303
2304     case NOP_EXPR:
2305     case CONVERT_EXPR:
2306     case NON_LVALUE_EXPR:
2307       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2308       break;
2309
2310     case CONSTRUCTOR:
2311       {
2312         register tree link;
2313         for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2314           if (TREE_VALUE (link) != 0)
2315             reloc |= reloc_needed (TREE_VALUE (link));
2316       }
2317       break;
2318
2319     case ERROR_MARK:
2320       break;
2321
2322     default:
2323       break;
2324     }
2325   return reloc;
2326 }
2327
2328 /* Does operand (which is a symbolic_operand) live in text space?
2329    If so, SYMBOL_REF_FLAG, which is set by pa_encode_section_info,
2330    will be true.  */
2331
2332 int
2333 read_only_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
2334 {
2335   if (GET_CODE (operand) == CONST)
2336     operand = XEXP (XEXP (operand, 0), 0);
2337   if (flag_pic)
2338     {
2339       if (GET_CODE (operand) == SYMBOL_REF)
2340         return SYMBOL_REF_FLAG (operand) && !CONSTANT_POOL_ADDRESS_P (operand);
2341     }
2342   else
2343     {
2344       if (GET_CODE (operand) == SYMBOL_REF)
2345         return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
2346     }
2347   return 1;
2348 }
2349
2350 \f
2351 /* Return the best assembler insn template
2352    for moving operands[1] into operands[0] as a fullword.  */
2353 const char *
2354 singlemove_string (rtx *operands)
2355 {
2356   HOST_WIDE_INT intval;
2357
2358   if (GET_CODE (operands[0]) == MEM)
2359     return "stw %r1,%0";
2360   if (GET_CODE (operands[1]) == MEM)
2361     return "ldw %1,%0";
2362   if (GET_CODE (operands[1]) == CONST_DOUBLE)
2363     {
2364       long i;
2365       REAL_VALUE_TYPE d;
2366
2367       if (GET_MODE (operands[1]) != SFmode)
2368         abort ();
2369
2370       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
2371          bit pattern.  */
2372       REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
2373       REAL_VALUE_TO_TARGET_SINGLE (d, i);
2374
2375       operands[1] = GEN_INT (i);
2376       /* Fall through to CONST_INT case.  */
2377     }
2378   if (GET_CODE (operands[1]) == CONST_INT)
2379     {
2380       intval = INTVAL (operands[1]);
2381
2382       if (VAL_14_BITS_P (intval))
2383         return "ldi %1,%0";
2384       else if ((intval & 0x7ff) == 0)
2385         return "ldil L'%1,%0";
2386       else if (zdepi_cint_p (intval))
2387         return "{zdepi %Z1,%0|depwi,z %Z1,%0}";
2388       else
2389         return "ldil L'%1,%0\n\tldo R'%1(%0),%0";
2390     }
2391   return "copy %1,%0";
2392 }
2393 \f
2394
2395 /* Compute position (in OP[1]) and width (in OP[2])
2396    useful for copying IMM to a register using the zdepi
2397    instructions.  Store the immediate value to insert in OP[0].  */
2398 static void
2399 compute_zdepwi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2400 {
2401   int lsb, len;
2402
2403   /* Find the least significant set bit in IMM.  */
2404   for (lsb = 0; lsb < 32; lsb++)
2405     {
2406       if ((imm & 1) != 0)
2407         break;
2408       imm >>= 1;
2409     }
2410
2411   /* Choose variants based on *sign* of the 5-bit field.  */
2412   if ((imm & 0x10) == 0)
2413     len = (lsb <= 28) ? 4 : 32 - lsb;
2414   else
2415     {
2416       /* Find the width of the bitstring in IMM.  */
2417       for (len = 5; len < 32; len++)
2418         {
2419           if ((imm & (1 << len)) == 0)
2420             break;
2421         }
2422
2423       /* Sign extend IMM as a 5-bit value.  */
2424       imm = (imm & 0xf) - 0x10;
2425     }
2426
2427   op[0] = imm;
2428   op[1] = 31 - lsb;
2429   op[2] = len;
2430 }
2431
2432 /* Compute position (in OP[1]) and width (in OP[2])
2433    useful for copying IMM to a register using the depdi,z
2434    instructions.  Store the immediate value to insert in OP[0].  */
2435 void
2436 compute_zdepdi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2437 {
2438   HOST_WIDE_INT lsb, len;
2439
2440   /* Find the least significant set bit in IMM.  */
2441   for (lsb = 0; lsb < HOST_BITS_PER_WIDE_INT; lsb++)
2442     {
2443       if ((imm & 1) != 0)
2444         break;
2445       imm >>= 1;
2446     }
2447
2448   /* Choose variants based on *sign* of the 5-bit field.  */
2449   if ((imm & 0x10) == 0)
2450     len = ((lsb <= HOST_BITS_PER_WIDE_INT - 4)
2451            ? 4 : HOST_BITS_PER_WIDE_INT - lsb);
2452   else
2453     {
2454       /* Find the width of the bitstring in IMM.  */
2455       for (len = 5; len < HOST_BITS_PER_WIDE_INT; len++)
2456         {
2457           if ((imm & ((unsigned HOST_WIDE_INT) 1 << len)) == 0)
2458             break;
2459         }
2460
2461       /* Sign extend IMM as a 5-bit value.  */
2462       imm = (imm & 0xf) - 0x10;
2463     }
2464
2465   op[0] = imm;
2466   op[1] = 63 - lsb;
2467   op[2] = len;
2468 }
2469
2470 /* Output assembler code to perform a doubleword move insn
2471    with operands OPERANDS.  */
2472
2473 const char *
2474 output_move_double (rtx *operands)
2475 {
2476   enum { REGOP, OFFSOP, MEMOP, CNSTOP, RNDOP } optype0, optype1;
2477   rtx latehalf[2];
2478   rtx addreg0 = 0, addreg1 = 0;
2479
2480   /* First classify both operands.  */
2481
2482   if (REG_P (operands[0]))
2483     optype0 = REGOP;
2484   else if (offsettable_memref_p (operands[0]))
2485     optype0 = OFFSOP;
2486   else if (GET_CODE (operands[0]) == MEM)
2487     optype0 = MEMOP;
2488   else
2489     optype0 = RNDOP;
2490
2491   if (REG_P (operands[1]))
2492     optype1 = REGOP;
2493   else if (CONSTANT_P (operands[1]))
2494     optype1 = CNSTOP;
2495   else if (offsettable_memref_p (operands[1]))
2496     optype1 = OFFSOP;
2497   else if (GET_CODE (operands[1]) == MEM)
2498     optype1 = MEMOP;
2499   else
2500     optype1 = RNDOP;
2501
2502   /* Check for the cases that the operand constraints are not
2503      supposed to allow to happen.  Abort if we get one,
2504      because generating code for these cases is painful.  */
2505
2506   if (optype0 != REGOP && optype1 != REGOP)
2507     abort ();
2508
2509    /* Handle auto decrementing and incrementing loads and stores
2510      specifically, since the structure of the function doesn't work
2511      for them without major modification.  Do it better when we learn
2512      this port about the general inc/dec addressing of PA.
2513      (This was written by tege.  Chide him if it doesn't work.)  */
2514
2515   if (optype0 == MEMOP)
2516     {
2517       /* We have to output the address syntax ourselves, since print_operand
2518          doesn't deal with the addresses we want to use.  Fix this later.  */
2519
2520       rtx addr = XEXP (operands[0], 0);
2521       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2522         {
2523           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2524
2525           operands[0] = XEXP (addr, 0);
2526           if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
2527             abort ();
2528
2529           if (!reg_overlap_mentioned_p (high_reg, addr))
2530             {
2531               /* No overlap between high target register and address
2532                  register.  (We do this in a non-obvious way to
2533                  save a register file writeback)  */
2534               if (GET_CODE (addr) == POST_INC)
2535                 return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2536               return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2537             }
2538           else
2539             abort ();
2540         }
2541       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2542         {
2543           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2544
2545           operands[0] = XEXP (addr, 0);
2546           if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
2547             abort ();
2548
2549           if (!reg_overlap_mentioned_p (high_reg, addr))
2550             {
2551               /* No overlap between high target register and address
2552                  register.  (We do this in a non-obvious way to
2553                  save a register file writeback)  */
2554               if (GET_CODE (addr) == PRE_INC)
2555                 return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2556               return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2557             }
2558           else
2559             abort ();
2560         }
2561     }
2562   if (optype1 == MEMOP)
2563     {
2564       /* We have to output the address syntax ourselves, since print_operand
2565          doesn't deal with the addresses we want to use.  Fix this later.  */
2566
2567       rtx addr = XEXP (operands[1], 0);
2568       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2569         {
2570           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2571
2572           operands[1] = XEXP (addr, 0);
2573           if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
2574             abort ();
2575
2576           if (!reg_overlap_mentioned_p (high_reg, addr))
2577             {
2578               /* No overlap between high target register and address
2579                  register.  (We do this in a non-obvious way to
2580                  save a register file writeback)  */
2581               if (GET_CODE (addr) == POST_INC)
2582                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2583               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2584             }
2585           else
2586             {
2587               /* This is an undefined situation.  We should load into the
2588                  address register *and* update that register.  Probably
2589                  we don't need to handle this at all.  */
2590               if (GET_CODE (addr) == POST_INC)
2591                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2592               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2593             }
2594         }
2595       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2596         {
2597           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2598
2599           operands[1] = XEXP (addr, 0);
2600           if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
2601             abort ();
2602
2603           if (!reg_overlap_mentioned_p (high_reg, addr))
2604             {
2605               /* No overlap between high target register and address
2606                  register.  (We do this in a non-obvious way to
2607                  save a register file writeback)  */
2608               if (GET_CODE (addr) == PRE_INC)
2609                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2610               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2611             }
2612           else
2613             {
2614               /* This is an undefined situation.  We should load into the
2615                  address register *and* update that register.  Probably
2616                  we don't need to handle this at all.  */
2617               if (GET_CODE (addr) == PRE_INC)
2618                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2619               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2620             }
2621         }
2622       else if (GET_CODE (addr) == PLUS
2623                && GET_CODE (XEXP (addr, 0)) == MULT)
2624         {
2625           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2626
2627           if (!reg_overlap_mentioned_p (high_reg, addr))
2628             {
2629               rtx xoperands[3];
2630
2631               xoperands[0] = high_reg;
2632               xoperands[1] = XEXP (addr, 1);
2633               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2634               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2635               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2636                                xoperands);
2637               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2638             }
2639           else
2640             {
2641               rtx xoperands[3];
2642
2643               xoperands[0] = high_reg;
2644               xoperands[1] = XEXP (addr, 1);
2645               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2646               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2647               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2648                                xoperands);
2649               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2650             }
2651         }
2652     }
2653
2654   /* If an operand is an unoffsettable memory ref, find a register
2655      we can increment temporarily to make it refer to the second word.  */
2656
2657   if (optype0 == MEMOP)
2658     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2659
2660   if (optype1 == MEMOP)
2661     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2662
2663   /* Ok, we can do one word at a time.
2664      Normally we do the low-numbered word first.
2665
2666      In either case, set up in LATEHALF the operands to use
2667      for the high-numbered word and in some cases alter the
2668      operands in OPERANDS to be suitable for the low-numbered word.  */
2669
2670   if (optype0 == REGOP)
2671     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2672   else if (optype0 == OFFSOP)
2673     latehalf[0] = adjust_address (operands[0], SImode, 4);
2674   else
2675     latehalf[0] = operands[0];
2676
2677   if (optype1 == REGOP)
2678     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2679   else if (optype1 == OFFSOP)
2680     latehalf[1] = adjust_address (operands[1], SImode, 4);
2681   else if (optype1 == CNSTOP)
2682     split_double (operands[1], &operands[1], &latehalf[1]);
2683   else
2684     latehalf[1] = operands[1];
2685
2686   /* If the first move would clobber the source of the second one,
2687      do them in the other order.
2688
2689      This can happen in two cases:
2690
2691         mem -> register where the first half of the destination register
2692         is the same register used in the memory's address.  Reload
2693         can create such insns.
2694
2695         mem in this case will be either register indirect or register
2696         indirect plus a valid offset.
2697
2698         register -> register move where REGNO(dst) == REGNO(src + 1)
2699         someone (Tim/Tege?) claimed this can happen for parameter loads.
2700
2701      Handle mem -> register case first.  */
2702   if (optype0 == REGOP
2703       && (optype1 == MEMOP || optype1 == OFFSOP)
2704       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2705                             operands[1], 0))
2706     {
2707       /* Do the late half first.  */
2708       if (addreg1)
2709         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2710       output_asm_insn (singlemove_string (latehalf), latehalf);
2711
2712       /* Then clobber.  */
2713       if (addreg1)
2714         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2715       return singlemove_string (operands);
2716     }
2717
2718   /* Now handle register -> register case.  */
2719   if (optype0 == REGOP && optype1 == REGOP
2720       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2721     {
2722       output_asm_insn (singlemove_string (latehalf), latehalf);
2723       return singlemove_string (operands);
2724     }
2725
2726   /* Normal case: do the two words, low-numbered first.  */
2727
2728   output_asm_insn (singlemove_string (operands), operands);
2729
2730   /* Make any unoffsettable addresses point at high-numbered word.  */
2731   if (addreg0)
2732     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2733   if (addreg1)
2734     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2735
2736   /* Do that word.  */
2737   output_asm_insn (singlemove_string (latehalf), latehalf);
2738
2739   /* Undo the adds we just did.  */
2740   if (addreg0)
2741     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2742   if (addreg1)
2743     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2744
2745   return "";
2746 }
2747 \f
2748 const char *
2749 output_fp_move_double (rtx *operands)
2750 {
2751   if (FP_REG_P (operands[0]))
2752     {
2753       if (FP_REG_P (operands[1])
2754           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2755         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2756       else
2757         output_asm_insn ("fldd%F1 %1,%0", operands);
2758     }
2759   else if (FP_REG_P (operands[1]))
2760     {
2761       output_asm_insn ("fstd%F0 %1,%0", operands);
2762     }
2763   else if (operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2764     {
2765       if (GET_CODE (operands[0]) == REG)
2766         {
2767           rtx xoperands[2];
2768           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2769           xoperands[0] = operands[0];
2770           output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2771         }
2772       /* This is a pain.  You have to be prepared to deal with an
2773          arbitrary address here including pre/post increment/decrement.
2774
2775          so avoid this in the MD.  */
2776       else
2777         abort ();
2778     }
2779   else abort ();
2780   return "";
2781 }
2782 \f
2783 /* Return a REG that occurs in ADDR with coefficient 1.
2784    ADDR can be effectively incremented by incrementing REG.  */
2785
2786 static rtx
2787 find_addr_reg (rtx addr)
2788 {
2789   while (GET_CODE (addr) == PLUS)
2790     {
2791       if (GET_CODE (XEXP (addr, 0)) == REG)
2792         addr = XEXP (addr, 0);
2793       else if (GET_CODE (XEXP (addr, 1)) == REG)
2794         addr = XEXP (addr, 1);
2795       else if (CONSTANT_P (XEXP (addr, 0)))
2796         addr = XEXP (addr, 1);
2797       else if (CONSTANT_P (XEXP (addr, 1)))
2798         addr = XEXP (addr, 0);
2799       else
2800         abort ();
2801     }
2802   if (GET_CODE (addr) == REG)
2803     return addr;
2804   abort ();
2805 }
2806
2807 /* Emit code to perform a block move.
2808
2809    OPERANDS[0] is the destination pointer as a REG, clobbered.
2810    OPERANDS[1] is the source pointer as a REG, clobbered.
2811    OPERANDS[2] is a register for temporary storage.
2812    OPERANDS[3] is a register for temporary storage.
2813    OPERANDS[4] is the size as a CONST_INT
2814    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2815    OPERANDS[6] is another temporary register.  */
2816
2817 const char *
2818 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2819 {
2820   int align = INTVAL (operands[5]);
2821   unsigned long n_bytes = INTVAL (operands[4]);
2822
2823   /* We can't move more than a word at a time because the PA
2824      has no longer integer move insns.  (Could use fp mem ops?)  */
2825   if (align > (TARGET_64BIT ? 8 : 4))
2826     align = (TARGET_64BIT ? 8 : 4);
2827
2828   /* Note that we know each loop below will execute at least twice
2829      (else we would have open-coded the copy).  */
2830   switch (align)
2831     {
2832       case 8:
2833         /* Pre-adjust the loop counter.  */
2834         operands[4] = GEN_INT (n_bytes - 16);
2835         output_asm_insn ("ldi %4,%2", operands);
2836
2837         /* Copying loop.  */
2838         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2839         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2840         output_asm_insn ("std,ma %3,8(%0)", operands);
2841         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2842         output_asm_insn ("std,ma %6,8(%0)", operands);
2843
2844         /* Handle the residual.  There could be up to 7 bytes of
2845            residual to copy!  */
2846         if (n_bytes % 16 != 0)
2847           {
2848             operands[4] = GEN_INT (n_bytes % 8);
2849             if (n_bytes % 16 >= 8)
2850               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2851             if (n_bytes % 8 != 0)
2852               output_asm_insn ("ldd 0(%1),%6", operands);
2853             if (n_bytes % 16 >= 8)
2854               output_asm_insn ("std,ma %3,8(%0)", operands);
2855             if (n_bytes % 8 != 0)
2856               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2857           }
2858         return "";
2859
2860       case 4:
2861         /* Pre-adjust the loop counter.  */
2862         operands[4] = GEN_INT (n_bytes - 8);
2863         output_asm_insn ("ldi %4,%2", operands);
2864
2865         /* Copying loop.  */
2866         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2867         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2868         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2869         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2870         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2871
2872         /* Handle the residual.  There could be up to 7 bytes of
2873            residual to copy!  */
2874         if (n_bytes % 8 != 0)
2875           {
2876             operands[4] = GEN_INT (n_bytes % 4);
2877             if (n_bytes % 8 >= 4)
2878               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2879             if (n_bytes % 4 != 0)
2880               output_asm_insn ("ldw 0(%1),%6", operands);
2881             if (n_bytes % 8 >= 4)
2882               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2883             if (n_bytes % 4 != 0)
2884               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2885           }
2886         return "";
2887
2888       case 2:
2889         /* Pre-adjust the loop counter.  */
2890         operands[4] = GEN_INT (n_bytes - 4);
2891         output_asm_insn ("ldi %4,%2", operands);
2892
2893         /* Copying loop.  */
2894         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2895         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2896         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2897         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2898         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2899
2900         /* Handle the residual.  */
2901         if (n_bytes % 4 != 0)
2902           {
2903             if (n_bytes % 4 >= 2)
2904               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2905             if (n_bytes % 2 != 0)
2906               output_asm_insn ("ldb 0(%1),%6", operands);
2907             if (n_bytes % 4 >= 2)
2908               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2909             if (n_bytes % 2 != 0)
2910               output_asm_insn ("stb %6,0(%0)", operands);
2911           }
2912         return "";
2913
2914       case 1:
2915         /* Pre-adjust the loop counter.  */
2916         operands[4] = GEN_INT (n_bytes - 2);
2917         output_asm_insn ("ldi %4,%2", operands);
2918
2919         /* Copying loop.  */
2920         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2921         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2922         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2923         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2924         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2925
2926         /* Handle the residual.  */
2927         if (n_bytes % 2 != 0)
2928           {
2929             output_asm_insn ("ldb 0(%1),%3", operands);
2930             output_asm_insn ("stb %3,0(%0)", operands);
2931           }
2932         return "";
2933
2934       default:
2935         abort ();
2936     }
2937 }
2938
2939 /* Count the number of insns necessary to handle this block move.
2940
2941    Basic structure is the same as emit_block_move, except that we
2942    count insns rather than emit them.  */
2943
2944 static int
2945 compute_movmem_length (rtx insn)
2946 {
2947   rtx pat = PATTERN (insn);
2948   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2949   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2950   unsigned int n_insns = 0;
2951
2952   /* We can't move more than four bytes at a time because the PA
2953      has no longer integer move insns.  (Could use fp mem ops?)  */
2954   if (align > (TARGET_64BIT ? 8 : 4))
2955     align = (TARGET_64BIT ? 8 : 4);
2956
2957   /* The basic copying loop.  */
2958   n_insns = 6;
2959
2960   /* Residuals.  */
2961   if (n_bytes % (2 * align) != 0)
2962     {
2963       if ((n_bytes % (2 * align)) >= align)
2964         n_insns += 2;
2965
2966       if ((n_bytes % align) != 0)
2967         n_insns += 2;
2968     }
2969
2970   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2971   return n_insns * 4;
2972 }
2973
2974 /* Emit code to perform a block clear.
2975
2976    OPERANDS[0] is the destination pointer as a REG, clobbered.
2977    OPERANDS[1] is a register for temporary storage.
2978    OPERANDS[2] is the size as a CONST_INT
2979    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
2980
2981 const char *
2982 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2983 {
2984   int align = INTVAL (operands[3]);
2985   unsigned long n_bytes = INTVAL (operands[2]);
2986
2987   /* We can't clear more than a word at a time because the PA
2988      has no longer integer move insns.  */
2989   if (align > (TARGET_64BIT ? 8 : 4))
2990     align = (TARGET_64BIT ? 8 : 4);
2991
2992   /* Note that we know each loop below will execute at least twice
2993      (else we would have open-coded the copy).  */
2994   switch (align)
2995     {
2996       case 8:
2997         /* Pre-adjust the loop counter.  */
2998         operands[2] = GEN_INT (n_bytes - 16);
2999         output_asm_insn ("ldi %2,%1", operands);
3000
3001         /* Loop.  */
3002         output_asm_insn ("std,ma %%r0,8(%0)", operands);
3003         output_asm_insn ("addib,>= -16,%1,.-4", operands);
3004         output_asm_insn ("std,ma %%r0,8(%0)", operands);
3005
3006         /* Handle the residual.  There could be up to 7 bytes of
3007            residual to copy!  */
3008         if (n_bytes % 16 != 0)
3009           {
3010             operands[2] = GEN_INT (n_bytes % 8);
3011             if (n_bytes % 16 >= 8)
3012               output_asm_insn ("std,ma %%r0,8(%0)", operands);
3013             if (n_bytes % 8 != 0)
3014               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
3015           }
3016         return "";
3017
3018       case 4:
3019         /* Pre-adjust the loop counter.  */
3020         operands[2] = GEN_INT (n_bytes - 8);
3021         output_asm_insn ("ldi %2,%1", operands);
3022
3023         /* Loop.  */
3024         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3025         output_asm_insn ("addib,>= -8,%1,.-4", operands);
3026         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3027
3028         /* Handle the residual.  There could be up to 7 bytes of
3029            residual to copy!  */
3030         if (n_bytes % 8 != 0)
3031           {
3032             operands[2] = GEN_INT (n_bytes % 4);
3033             if (n_bytes % 8 >= 4)
3034               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3035             if (n_bytes % 4 != 0)
3036               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
3037           }
3038         return "";
3039
3040       case 2:
3041         /* Pre-adjust the loop counter.  */
3042         operands[2] = GEN_INT (n_bytes - 4);
3043         output_asm_insn ("ldi %2,%1", operands);
3044
3045         /* Loop.  */
3046         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3047         output_asm_insn ("addib,>= -4,%1,.-4", operands);
3048         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3049
3050         /* Handle the residual.  */
3051         if (n_bytes % 4 != 0)
3052           {
3053             if (n_bytes % 4 >= 2)
3054               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3055             if (n_bytes % 2 != 0)
3056               output_asm_insn ("stb %%r0,0(%0)", operands);
3057           }
3058         return "";
3059
3060       case 1:
3061         /* Pre-adjust the loop counter.  */
3062         operands[2] = GEN_INT (n_bytes - 2);
3063         output_asm_insn ("ldi %2,%1", operands);
3064
3065         /* Loop.  */
3066         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
3067         output_asm_insn ("addib,>= -2,%1,.-4", operands);
3068         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
3069
3070         /* Handle the residual.  */
3071         if (n_bytes % 2 != 0)
3072           output_asm_insn ("stb %%r0,0(%0)", operands);
3073
3074         return "";
3075
3076       default:
3077         abort ();
3078     }
3079 }
3080
3081 /* Count the number of insns necessary to handle this block move.
3082
3083    Basic structure is the same as emit_block_move, except that we
3084    count insns rather than emit them.  */
3085
3086 static int
3087 compute_clrmem_length (rtx insn)
3088 {
3089   rtx pat = PATTERN (insn);
3090   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
3091   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
3092   unsigned int n_insns = 0;
3093
3094   /* We can't clear more than a word at a time because the PA
3095      has no longer integer move insns.  */
3096   if (align > (TARGET_64BIT ? 8 : 4))
3097     align = (TARGET_64BIT ? 8 : 4);
3098
3099   /* The basic loop.  */
3100   n_insns = 4;
3101
3102   /* Residuals.  */
3103   if (n_bytes % (2 * align) != 0)
3104     {
3105       if ((n_bytes % (2 * align)) >= align)
3106         n_insns++;
3107
3108       if ((n_bytes % align) != 0)
3109         n_insns++;
3110     }
3111
3112   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
3113   return n_insns * 4;
3114 }
3115 \f
3116
3117 const char *
3118 output_and (rtx *operands)
3119 {
3120   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
3121     {
3122       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3123       int ls0, ls1, ms0, p, len;
3124
3125       for (ls0 = 0; ls0 < 32; ls0++)
3126         if ((mask & (1 << ls0)) == 0)
3127           break;
3128
3129       for (ls1 = ls0; ls1 < 32; ls1++)
3130         if ((mask & (1 << ls1)) != 0)
3131           break;
3132
3133       for (ms0 = ls1; ms0 < 32; ms0++)
3134         if ((mask & (1 << ms0)) == 0)
3135           break;
3136
3137       if (ms0 != 32)
3138         abort ();
3139
3140       if (ls1 == 32)
3141         {
3142           len = ls0;
3143
3144           if (len == 0)
3145             abort ();
3146
3147           operands[2] = GEN_INT (len);
3148           return "{extru|extrw,u} %1,31,%2,%0";
3149         }
3150       else
3151         {
3152           /* We could use this `depi' for the case above as well, but `depi'
3153              requires one more register file access than an `extru'.  */
3154
3155           p = 31 - ls0;
3156           len = ls1 - ls0;
3157
3158           operands[2] = GEN_INT (p);
3159           operands[3] = GEN_INT (len);
3160           return "{depi|depwi} 0,%2,%3,%0";
3161         }
3162     }
3163   else
3164     return "and %1,%2,%0";
3165 }
3166
3167 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
3168    storing the result in operands[0].  */
3169 const char *
3170 output_64bit_and (rtx *operands)
3171 {
3172   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
3173     {
3174       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3175       int ls0, ls1, ms0, p, len;
3176
3177       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
3178         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
3179           break;
3180
3181       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
3182         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
3183           break;
3184
3185       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
3186         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
3187           break;
3188
3189       if (ms0 != HOST_BITS_PER_WIDE_INT)
3190         abort ();
3191
3192       if (ls1 == HOST_BITS_PER_WIDE_INT)
3193         {
3194           len = ls0;
3195
3196           if (len == 0)
3197             abort ();
3198
3199           operands[2] = GEN_INT (len);
3200           return "extrd,u %1,63,%2,%0";
3201         }
3202       else
3203         {
3204           /* We could use this `depi' for the case above as well, but `depi'
3205              requires one more register file access than an `extru'.  */
3206
3207           p = 63 - ls0;
3208           len = ls1 - ls0;
3209
3210           operands[2] = GEN_INT (p);
3211           operands[3] = GEN_INT (len);
3212           return "depdi 0,%2,%3,%0";
3213         }
3214     }
3215   else
3216     return "and %1,%2,%0";
3217 }
3218
3219 const char *
3220 output_ior (rtx *operands)
3221 {
3222   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3223   int bs0, bs1, p, len;
3224
3225   if (INTVAL (operands[2]) == 0)
3226     return "copy %1,%0";
3227
3228   for (bs0 = 0; bs0 < 32; bs0++)
3229     if ((mask & (1 << bs0)) != 0)
3230       break;
3231
3232   for (bs1 = bs0; bs1 < 32; bs1++)
3233     if ((mask & (1 << bs1)) == 0)
3234       break;
3235
3236   if (bs1 != 32 && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
3237     abort ();
3238
3239   p = 31 - bs0;
3240   len = bs1 - bs0;
3241
3242   operands[2] = GEN_INT (p);
3243   operands[3] = GEN_INT (len);
3244   return "{depi|depwi} -1,%2,%3,%0";
3245 }
3246
3247 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
3248    storing the result in operands[0].  */
3249 const char *
3250 output_64bit_ior (rtx *operands)
3251 {
3252   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3253   int bs0, bs1, p, len;
3254
3255   if (INTVAL (operands[2]) == 0)
3256     return "copy %1,%0";
3257
3258   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
3259     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
3260       break;
3261
3262   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
3263     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
3264       break;
3265
3266   if (bs1 != HOST_BITS_PER_WIDE_INT
3267       && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
3268     abort ();
3269
3270   p = 63 - bs0;
3271   len = bs1 - bs0;
3272
3273   operands[2] = GEN_INT (p);
3274   operands[3] = GEN_INT (len);
3275   return "depdi -1,%2,%3,%0";
3276 }
3277 \f
3278 /* Target hook for assembling integer objects.  This code handles
3279    aligned SI and DI integers specially, since function references must
3280    be preceded by P%.  */
3281
3282 static bool
3283 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
3284 {
3285   if (size == UNITS_PER_WORD && aligned_p
3286       && function_label_operand (x, VOIDmode))
3287     {
3288       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
3289       output_addr_const (asm_out_file, x);
3290       fputc ('\n', asm_out_file);
3291       return true;
3292     }
3293   return default_assemble_integer (x, size, aligned_p);
3294 }
3295 \f
3296 /* Output an ascii string.  */
3297 void
3298 output_ascii (FILE *file, const char *p, int size)
3299 {
3300   int i;
3301   int chars_output;
3302   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
3303
3304   /* The HP assembler can only take strings of 256 characters at one
3305      time.  This is a limitation on input line length, *not* the
3306      length of the string.  Sigh.  Even worse, it seems that the
3307      restriction is in number of input characters (see \xnn &
3308      \whatever).  So we have to do this very carefully.  */
3309
3310   fputs ("\t.STRING \"", file);
3311
3312   chars_output = 0;
3313   for (i = 0; i < size; i += 4)
3314     {
3315       int co = 0;
3316       int io = 0;
3317       for (io = 0, co = 0; io < MIN (4, size - i); io++)
3318         {
3319           register unsigned int c = (unsigned char) p[i + io];
3320
3321           if (c == '\"' || c == '\\')
3322             partial_output[co++] = '\\';
3323           if (c >= ' ' && c < 0177)
3324             partial_output[co++] = c;
3325           else
3326             {
3327               unsigned int hexd;
3328               partial_output[co++] = '\\';
3329               partial_output[co++] = 'x';
3330               hexd =  c  / 16 - 0 + '0';
3331               if (hexd > '9')
3332                 hexd -= '9' - 'a' + 1;
3333               partial_output[co++] = hexd;
3334               hexd =  c % 16 - 0 + '0';
3335               if (hexd > '9')
3336                 hexd -= '9' - 'a' + 1;
3337               partial_output[co++] = hexd;
3338             }
3339         }
3340       if (chars_output + co > 243)
3341         {
3342           fputs ("\"\n\t.STRING \"", file);
3343           chars_output = 0;
3344         }
3345       fwrite (partial_output, 1, (size_t) co, file);
3346       chars_output += co;
3347       co = 0;
3348     }
3349   fputs ("\"\n", file);
3350 }
3351
3352 /* Try to rewrite floating point comparisons & branches to avoid
3353    useless add,tr insns.
3354
3355    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3356    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3357    first attempt to remove useless add,tr insns.  It is zero
3358    for the second pass as reorg sometimes leaves bogus REG_DEAD
3359    notes lying around.
3360
3361    When CHECK_NOTES is zero we can only eliminate add,tr insns
3362    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3363    instructions.  */
3364 static void
3365 remove_useless_addtr_insns (int check_notes)
3366 {
3367   rtx insn;
3368   static int pass = 0;
3369
3370   /* This is fairly cheap, so always run it when optimizing.  */
3371   if (optimize > 0)
3372     {
3373       int fcmp_count = 0;
3374       int fbranch_count = 0;
3375
3376       /* Walk all the insns in this function looking for fcmp & fbranch
3377          instructions.  Keep track of how many of each we find.  */
3378       for (insn = get_insns (); insn; insn = next_insn (insn))
3379         {
3380           rtx tmp;
3381
3382           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3383           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3384             continue;
3385
3386           tmp = PATTERN (insn);
3387
3388           /* It must be a set.  */
3389           if (GET_CODE (tmp) != SET)
3390             continue;
3391
3392           /* If the destination is CCFP, then we've found an fcmp insn.  */
3393           tmp = SET_DEST (tmp);
3394           if (GET_CODE (tmp) == REG && REGNO (tmp) == 0)
3395             {
3396               fcmp_count++;
3397               continue;
3398             }
3399
3400           tmp = PATTERN (insn);
3401           /* If this is an fbranch instruction, bump the fbranch counter.  */
3402           if (GET_CODE (tmp) == SET
3403               && SET_DEST (tmp) == pc_rtx
3404               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
3405               && GET_CODE (XEXP (SET_SRC (tmp), 0)) == NE
3406               && GET_CODE (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == REG
3407               && REGNO (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == 0)
3408             {
3409               fbranch_count++;
3410               continue;
3411             }
3412         }
3413
3414
3415       /* Find all floating point compare + branch insns.  If possible,
3416          reverse the comparison & the branch to avoid add,tr insns.  */
3417       for (insn = get_insns (); insn; insn = next_insn (insn))
3418         {
3419           rtx tmp, next;
3420
3421           /* Ignore anything that isn't an INSN.  */
3422           if (GET_CODE (insn) != INSN)
3423             continue;
3424
3425           tmp = PATTERN (insn);
3426
3427           /* It must be a set.  */
3428           if (GET_CODE (tmp) != SET)
3429             continue;
3430
3431           /* The destination must be CCFP, which is register zero.  */
3432           tmp = SET_DEST (tmp);
3433           if (GET_CODE (tmp) != REG || REGNO (tmp) != 0)
3434             continue;
3435
3436           /* INSN should be a set of CCFP.
3437
3438              See if the result of this insn is used in a reversed FP
3439              conditional branch.  If so, reverse our condition and
3440              the branch.  Doing so avoids useless add,tr insns.  */
3441           next = next_insn (insn);
3442           while (next)
3443             {
3444               /* Jumps, calls and labels stop our search.  */
3445               if (GET_CODE (next) == JUMP_INSN
3446                   || GET_CODE (next) == CALL_INSN
3447                   || GET_CODE (next) == CODE_LABEL)
3448                 break;
3449
3450               /* As does another fcmp insn.  */
3451               if (GET_CODE (next) == INSN
3452                   && GET_CODE (PATTERN (next)) == SET
3453                   && GET_CODE (SET_DEST (PATTERN (next))) == REG
3454                   && REGNO (SET_DEST (PATTERN (next))) == 0)
3455                 break;
3456
3457               next = next_insn (next);
3458             }
3459
3460           /* Is NEXT_INSN a branch?  */
3461           if (next
3462               && GET_CODE (next) == JUMP_INSN)
3463             {
3464               rtx pattern = PATTERN (next);
3465
3466               /* If it a reversed fp conditional branch (e.g. uses add,tr)
3467                  and CCFP dies, then reverse our conditional and the branch
3468                  to avoid the add,tr.  */
3469               if (GET_CODE (pattern) == SET
3470                   && SET_DEST (pattern) == pc_rtx
3471                   && GET_CODE (SET_SRC (pattern)) == IF_THEN_ELSE
3472                   && GET_CODE (XEXP (SET_SRC (pattern), 0)) == NE
3473                   && GET_CODE (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == REG
3474                   && REGNO (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == 0
3475                   && GET_CODE (XEXP (SET_SRC (pattern), 1)) == PC
3476                   && (fcmp_count == fbranch_count
3477                       || (check_notes
3478                           && find_regno_note (next, REG_DEAD, 0))))
3479                 {
3480                   /* Reverse the branch.  */
3481                   tmp = XEXP (SET_SRC (pattern), 1);
3482                   XEXP (SET_SRC (pattern), 1) = XEXP (SET_SRC (pattern), 2);
3483                   XEXP (SET_SRC (pattern), 2) = tmp;
3484                   INSN_CODE (next) = -1;
3485
3486                   /* Reverse our condition.  */
3487                   tmp = PATTERN (insn);
3488                   PUT_CODE (XEXP (tmp, 1),
3489                             (reverse_condition_maybe_unordered
3490                              (GET_CODE (XEXP (tmp, 1)))));
3491                 }
3492             }
3493         }
3494     }
3495
3496   pass = !pass;
3497
3498 }
3499 \f
3500 /* You may have trouble believing this, but this is the 32 bit HP-PA
3501    stack layout.  Wow.
3502
3503    Offset               Contents
3504
3505    Variable arguments   (optional; any number may be allocated)
3506
3507    SP-(4*(N+9))         arg word N
3508         :                   :
3509       SP-56             arg word 5
3510       SP-52             arg word 4
3511
3512    Fixed arguments      (must be allocated; may remain unused)
3513
3514       SP-48             arg word 3
3515       SP-44             arg word 2
3516       SP-40             arg word 1
3517       SP-36             arg word 0
3518
3519    Frame Marker
3520
3521       SP-32             External Data Pointer (DP)
3522       SP-28             External sr4
3523       SP-24             External/stub RP (RP')
3524       SP-20             Current RP
3525       SP-16             Static Link
3526       SP-12             Clean up
3527       SP-8              Calling Stub RP (RP'')
3528       SP-4              Previous SP
3529
3530    Top of Frame
3531
3532       SP-0              Stack Pointer (points to next available address)
3533
3534 */
3535
3536 /* This function saves registers as follows.  Registers marked with ' are
3537    this function's registers (as opposed to the previous function's).
3538    If a frame_pointer isn't needed, r4 is saved as a general register;
3539    the space for the frame pointer is still allocated, though, to keep
3540    things simple.
3541
3542
3543    Top of Frame
3544
3545        SP (FP')         Previous FP
3546        SP + 4           Alignment filler (sigh)
3547        SP + 8           Space for locals reserved here.
3548        .
3549        .
3550        .
3551        SP + n           All call saved register used.
3552        .
3553        .
3554        .
3555        SP + o           All call saved fp registers used.
3556        .
3557        .
3558        .
3559        SP + p (SP')     points to next available address.
3560
3561 */
3562
3563 /* Global variables set by output_function_prologue().  */
3564 /* Size of frame.  Need to know this to emit return insns from
3565    leaf procedures.  */
3566 static HOST_WIDE_INT actual_fsize, local_fsize;
3567 static int save_fregs;
3568
3569 /* Emit RTL to store REG at the memory location specified by BASE+DISP.
3570    Handle case where DISP > 8k by using the add_high_const patterns.
3571
3572    Note in DISP > 8k case, we will leave the high part of the address
3573    in %r1.  There is code in expand_hppa_{prologue,epilogue} that knows this.*/
3574
3575 static void
3576 store_reg (int reg, HOST_WIDE_INT disp, int base)
3577 {
3578   rtx insn, dest, src, basereg;
3579
3580   src = gen_rtx_REG (word_mode, reg);
3581   basereg = gen_rtx_REG (Pmode, base);
3582   if (VAL_14_BITS_P (disp))
3583     {
3584       dest = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3585       insn = emit_move_insn (dest, src);
3586     }
3587   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3588     {
3589       rtx delta = GEN_INT (disp);
3590       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3591
3592       emit_move_insn (tmpreg, delta);
3593       emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3594       dest = gen_rtx_MEM (word_mode, tmpreg);
3595       insn = emit_move_insn (dest, src);
3596       if (DO_FRAME_NOTES)
3597         {
3598           REG_NOTES (insn)
3599             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3600                 gen_rtx_SET (VOIDmode,
3601                              gen_rtx_MEM (word_mode,
3602                                           gen_rtx_PLUS (word_mode, basereg,
3603                                                         delta)),
3604                              src),
3605                 REG_NOTES (insn));
3606         }
3607     }
3608   else
3609     {
3610       rtx delta = GEN_INT (disp);
3611       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3612       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3613
3614       emit_move_insn (tmpreg, high);
3615       dest = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3616       insn = emit_move_insn (dest, src);
3617       if (DO_FRAME_NOTES)
3618         {
3619           REG_NOTES (insn)
3620             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3621                 gen_rtx_SET (VOIDmode,
3622                              gen_rtx_MEM (word_mode,
3623                                           gen_rtx_PLUS (word_mode, basereg,
3624                                                         delta)),
3625                              src),
3626                 REG_NOTES (insn));
3627         }
3628     }
3629
3630   if (DO_FRAME_NOTES)
3631     RTX_FRAME_RELATED_P (insn) = 1;
3632 }
3633
3634 /* Emit RTL to store REG at the memory location specified by BASE and then
3635    add MOD to BASE.  MOD must be <= 8k.  */
3636
3637 static void
3638 store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
3639 {
3640   rtx insn, basereg, srcreg, delta;
3641
3642   if (!VAL_14_BITS_P (mod))
3643     abort ();
3644
3645   basereg = gen_rtx_REG (Pmode, base);
3646   srcreg = gen_rtx_REG (word_mode, reg);
3647   delta = GEN_INT (mod);
3648
3649   insn = emit_insn (gen_post_store (basereg, srcreg, delta));
3650   if (DO_FRAME_NOTES)
3651     {
3652       RTX_FRAME_RELATED_P (insn) = 1;
3653
3654       /* RTX_FRAME_RELATED_P must be set on each frame related set
3655          in a parallel with more than one element.  Don't set
3656          RTX_FRAME_RELATED_P in the first set if reg is temporary
3657          register 1. The effect of this operation is recorded in
3658          the initial copy.  */
3659       if (reg != 1)
3660         {
3661           RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 0)) = 1;
3662           RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 1)) = 1;
3663         }
3664       else
3665         {
3666           /* The first element of a PARALLEL is always processed if it is
3667              a SET.  Thus, we need an expression list for this case.  */
3668           REG_NOTES (insn)
3669             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3670                 gen_rtx_SET (VOIDmode, basereg,
3671                              gen_rtx_PLUS (word_mode, basereg, delta)),
3672                 REG_NOTES (insn));
3673         }
3674     }
3675 }
3676
3677 /* Emit RTL to set REG to the value specified by BASE+DISP.  Handle case
3678    where DISP > 8k by using the add_high_const patterns.  NOTE indicates
3679    whether to add a frame note or not.
3680
3681    In the DISP > 8k case, we leave the high part of the address in %r1.
3682    There is code in expand_hppa_{prologue,epilogue} that knows about this.  */
3683
3684 static void
3685 set_reg_plus_d (int reg, int base, HOST_WIDE_INT disp, int note)
3686 {
3687   rtx insn;
3688
3689   if (VAL_14_BITS_P (disp))
3690     {
3691       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3692                              plus_constant (gen_rtx_REG (Pmode, base), disp));
3693     }
3694   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3695     {
3696       rtx basereg = gen_rtx_REG (Pmode, base);
3697       rtx delta = GEN_INT (disp);
3698       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3699
3700       emit_move_insn (tmpreg, delta);
3701       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3702                              gen_rtx_PLUS (Pmode, tmpreg, basereg));
3703     }
3704   else
3705     {
3706       rtx basereg = gen_rtx_REG (Pmode, base);
3707       rtx delta = GEN_INT (disp);
3708       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3709
3710       emit_move_insn (tmpreg,
3711                       gen_rtx_PLUS (Pmode, basereg,
3712                                     gen_rtx_HIGH (Pmode, delta)));
3713       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3714                              gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3715     }
3716
3717   if (DO_FRAME_NOTES && note)
3718     RTX_FRAME_RELATED_P (insn) = 1;
3719 }
3720
3721 HOST_WIDE_INT
3722 compute_frame_size (HOST_WIDE_INT size, int *fregs_live)
3723 {
3724   int freg_saved = 0;
3725   int i, j;
3726
3727   /* The code in hppa_expand_prologue and hppa_expand_epilogue must
3728      be consistent with the rounding and size calculation done here.
3729      Change them at the same time.  */
3730
3731   /* We do our own stack alignment.  First, round the size of the
3732      stack locals up to a word boundary.  */
3733   size = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3734
3735   /* Space for previous frame pointer + filler.  If any frame is
3736      allocated, we need to add in the STARTING_FRAME_OFFSET.  We
3737      waste some space here for the sake of HP compatibility.  The
3738      first slot is only used when the frame pointer is needed.  */
3739   if (size || frame_pointer_needed)
3740     size += STARTING_FRAME_OFFSET;
3741   
3742   /* If the current function calls __builtin_eh_return, then we need
3743      to allocate stack space for registers that will hold data for
3744      the exception handler.  */
3745   if (DO_FRAME_NOTES && current_function_calls_eh_return)
3746     {
3747       unsigned int i;
3748
3749       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
3750         continue;
3751       size += i * UNITS_PER_WORD;
3752     }
3753
3754   /* Account for space used by the callee general register saves.  */
3755   for (i = 18, j = frame_pointer_needed ? 4 : 3; i >= j; i--)
3756     if (regs_ever_live[i])
3757       size += UNITS_PER_WORD;
3758
3759   /* Account for space used by the callee floating point register saves.  */
3760   for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3761     if (regs_ever_live[i]
3762         || (!TARGET_64BIT && regs_ever_live[i + 1]))
3763       {
3764         freg_saved = 1;
3765
3766         /* We always save both halves of the FP register, so always
3767            increment the frame size by 8 bytes.  */
3768         size += 8;
3769       }
3770
3771   /* If any of the floating registers are saved, account for the
3772      alignment needed for the floating point register save block.  */
3773   if (freg_saved)
3774     {
3775       size = (size + 7) & ~7;
3776       if (fregs_live)
3777         *fregs_live = 1;
3778     }
3779
3780   /* The various ABIs include space for the outgoing parameters in the
3781      size of the current function's stack frame.  We don't need to align
3782      for the outgoing arguments as their alignment is set by the final
3783      rounding for the frame as a whole.  */
3784   size += current_function_outgoing_args_size;
3785
3786   /* Allocate space for the fixed frame marker.  This space must be
3787      allocated for any function that makes calls or allocates
3788      stack space.  */
3789   if (!current_function_is_leaf || size)
3790     size += TARGET_64BIT ? 48 : 32;
3791
3792   /* Finally, round to the preferred stack boundary.  */
3793   return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
3794           & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
3795 }
3796
3797 /* Generate the assembly code for function entry.  FILE is a stdio
3798    stream to output the code to.  SIZE is an int: how many units of
3799    temporary storage to allocate.
3800
3801    Refer to the array `regs_ever_live' to determine which registers to
3802    save; `regs_ever_live[I]' is nonzero if register number I is ever
3803    used in the function.  This function is responsible for knowing
3804    which registers should not be saved even if used.  */
3805
3806 /* On HP-PA, move-double insns between fpu and cpu need an 8-byte block
3807    of memory.  If any fpu reg is used in the function, we allocate
3808    such a block here, at the bottom of the frame, just in case it's needed.
3809
3810    If this function is a leaf procedure, then we may choose not
3811    to do a "save" insn.  The decision about whether or not
3812    to do this is made in regclass.c.  */
3813
3814 static void
3815 pa_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3816 {
3817   /* The function's label and associated .PROC must never be
3818      separated and must be output *after* any profiling declarations
3819      to avoid changing spaces/subspaces within a procedure.  */
3820   ASM_OUTPUT_LABEL (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
3821   fputs ("\t.PROC\n", file);
3822
3823   /* hppa_expand_prologue does the dirty work now.  We just need
3824      to output the assembler directives which denote the start
3825      of a function.  */
3826   fprintf (file, "\t.CALLINFO FRAME=" HOST_WIDE_INT_PRINT_DEC, actual_fsize);
3827   if (regs_ever_live[2])
3828     fputs (",CALLS,SAVE_RP", file);
3829   else
3830     fputs (",NO_CALLS", file);
3831
3832   /* The SAVE_SP flag is used to indicate that register %r3 is stored
3833      at the beginning of the frame and that it is used as the frame
3834      pointer for the frame.  We do this because our current frame
3835      layout doesn't conform to that specified in the the HP runtime
3836      documentation and we need a way to indicate to programs such as
3837      GDB where %r3 is saved.  The SAVE_SP flag was chosen because it
3838      isn't used by HP compilers but is supported by the assembler.
3839      However, SAVE_SP is supposed to indicate that the previous stack
3840      pointer has been saved in the frame marker.  */
3841   if (frame_pointer_needed)
3842     fputs (",SAVE_SP", file);
3843
3844   /* Pass on information about the number of callee register saves
3845      performed in the prologue.
3846
3847      The compiler is supposed to pass the highest register number
3848      saved, the assembler then has to adjust that number before
3849      entering it into the unwind descriptor (to account for any
3850      caller saved registers with lower register numbers than the
3851      first callee saved register).  */
3852   if (gr_saved)
3853     fprintf (file, ",ENTRY_GR=%d", gr_saved + 2);
3854
3855   if (fr_saved)
3856     fprintf (file, ",ENTRY_FR=%d", fr_saved + 11);
3857
3858   fputs ("\n\t.ENTRY\n", file);
3859
3860   remove_useless_addtr_insns (0);
3861 }
3862
3863 void
3864 hppa_expand_prologue (void)
3865 {
3866   int merge_sp_adjust_with_store = 0;
3867   HOST_WIDE_INT size = get_frame_size ();
3868   HOST_WIDE_INT offset;
3869   int i;
3870   rtx insn, tmpreg;
3871
3872   gr_saved = 0;
3873   fr_saved = 0;
3874   save_fregs = 0;
3875
3876   /* Compute total size for frame pointer, filler, locals and rounding to
3877      the next word boundary.  Similar code appears in compute_frame_size
3878      and must be changed in tandem with this code.  */
3879   local_fsize = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3880   if (local_fsize || frame_pointer_needed)
3881     local_fsize += STARTING_FRAME_OFFSET;
3882
3883   actual_fsize = compute_frame_size (size, &save_fregs);
3884
3885   /* Compute a few things we will use often.  */
3886   tmpreg = gen_rtx_REG (word_mode, 1);
3887
3888   /* Save RP first.  The calling conventions manual states RP will
3889      always be stored into the caller's frame at sp - 20 or sp - 16
3890      depending on which ABI is in use.  */
3891   if (regs_ever_live[2] || current_function_calls_eh_return)
3892     store_reg (2, TARGET_64BIT ? -16 : -20, STACK_POINTER_REGNUM);
3893
3894   /* Allocate the local frame and set up the frame pointer if needed.  */
3895   if (actual_fsize != 0)
3896     {
3897       if (frame_pointer_needed)
3898         {
3899           /* Copy the old frame pointer temporarily into %r1.  Set up the
3900              new stack pointer, then store away the saved old frame pointer
3901              into the stack at sp and at the same time update the stack
3902              pointer by actual_fsize bytes.  Two versions, first
3903              handles small (<8k) frames.  The second handles large (>=8k)
3904              frames.  */
3905           insn = emit_move_insn (tmpreg, frame_pointer_rtx);
3906           if (DO_FRAME_NOTES)
3907             {
3908               /* We need to record the frame pointer save here since the
3909                  new frame pointer is set in the following insn.  */
3910               RTX_FRAME_RELATED_P (insn) = 1;
3911               REG_NOTES (insn)
3912                 = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3913                     gen_rtx_SET (VOIDmode,
3914                                  gen_rtx_MEM (word_mode, stack_pointer_rtx),
3915                                  frame_pointer_rtx),
3916                     REG_NOTES (insn));
3917             }
3918
3919           insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
3920           if (DO_FRAME_NOTES)
3921             RTX_FRAME_RELATED_P (insn) = 1;
3922
3923           if (VAL_14_BITS_P (actual_fsize))
3924             store_reg_modify (STACK_POINTER_REGNUM, 1, actual_fsize);
3925           else
3926             {
3927               /* It is incorrect to store the saved frame pointer at *sp,
3928                  then increment sp (writes beyond the current stack boundary).
3929
3930                  So instead use stwm to store at *sp and post-increment the
3931                  stack pointer as an atomic operation.  Then increment sp to
3932                  finish allocating the new frame.  */
3933               HOST_WIDE_INT adjust1 = 8192 - 64;
3934               HOST_WIDE_INT adjust2 = actual_fsize - adjust1;
3935
3936               store_reg_modify (STACK_POINTER_REGNUM, 1, adjust1);
3937               set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3938                               adjust2, 1);
3939             }
3940
3941           /* We set SAVE_SP in frames that need a frame pointer.  Thus,
3942              we need to store the previous stack pointer (frame pointer)
3943              into the frame marker on targets that use the HP unwind
3944              library.  This allows the HP unwind library to be used to
3945              unwind GCC frames.  However, we are not fully compatible
3946              with the HP library because our frame layout differs from
3947              that specified in the HP runtime specification.
3948
3949              We don't want a frame note on this instruction as the frame
3950              marker moves during dynamic stack allocation.
3951
3952              This instruction also serves as a blockage to prevent
3953              register spills from being scheduled before the stack
3954              pointer is raised.  This is necessary as we store
3955              registers using the frame pointer as a base register,
3956              and the frame pointer is set before sp is raised.  */
3957           if (TARGET_HPUX_UNWIND_LIBRARY)
3958             {
3959               rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx,
3960                                        GEN_INT (TARGET_64BIT ? -8 : -4));
3961
3962               emit_move_insn (gen_rtx_MEM (word_mode, addr),
3963                               frame_pointer_rtx);
3964             }
3965           else
3966             emit_insn (gen_blockage ());
3967         }
3968       /* no frame pointer needed.  */
3969       else
3970         {
3971           /* In some cases we can perform the first callee register save
3972              and allocating the stack frame at the same time.   If so, just
3973              make a note of it and defer allocating the frame until saving
3974              the callee registers.  */
3975           if (VAL_14_BITS_P (actual_fsize) && local_fsize == 0)
3976             merge_sp_adjust_with_store = 1;
3977           /* Can not optimize.  Adjust the stack frame by actual_fsize