OSDN Git Service

* pa-protos.h (prefetch_operand): Delete.
[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 with a cache-control completer.  */
756 int
757 prefetch_cc_operand (rtx op, enum machine_mode mode)
758 {
759   if (GET_CODE (op) != MEM)
760     return 0;
761
762   op = XEXP (op, 0);
763
764   /* We must reject virtual registers as we don't allow REG+D.  */
765   if (op == virtual_incoming_args_rtx
766       || op == virtual_stack_vars_rtx
767       || op == virtual_stack_dynamic_rtx
768       || op == virtual_outgoing_args_rtx
769       || op == virtual_cfa_rtx)
770     return 0;
771
772   if (!REG_P (op) && !IS_INDEX_ADDR_P (op))
773     return 0;
774
775   /* Until problems with management of the REG_POINTER flag are resolved,
776      we need to delay creating prefetch insns with unscaled indexed addresses
777      until CSE is not expected.  */
778   if (!TARGET_NO_SPACE_REGS
779       && !cse_not_expected
780       && GET_CODE (op) == PLUS
781       && REG_P (XEXP (op, 0)))
782     return 0;
783
784   return memory_address_p (mode, op);
785 }
786
787 /* Accept anything that can be used as the source operand for a prefetch
788    instruction with no cache-control completer.  */
789 int
790 prefetch_nocc_operand (rtx op, enum machine_mode mode)
791 {
792   if (GET_CODE (op) != MEM)
793     return 0;
794
795   op = XEXP (op, 0);
796
797   /* Until problems with management of the REG_POINTER flag are resolved,
798      we need to delay creating prefetch insns with unscaled indexed addresses
799      until CSE is not expected.  */
800   if (!TARGET_NO_SPACE_REGS
801       && !cse_not_expected
802       && GET_CODE (op) == PLUS
803       && REG_P (XEXP (op, 0))
804       && REG_P (XEXP (op, 1)))
805     return 0;
806
807   return memory_address_p (mode, op);
808 }
809
810 /* Accept REG and any CONST_INT that can be moved in one instruction into a
811    general register.  */
812 int
813 reg_or_cint_move_operand (rtx op, enum machine_mode mode)
814 {
815   if (register_operand (op, mode))
816     return 1;
817
818   return (GET_CODE (op) == CONST_INT && cint_ok_for_move (INTVAL (op)));
819 }
820
821 int
822 pic_label_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
823 {
824   if (!flag_pic)
825     return 0;
826
827   switch (GET_CODE (op))
828     {
829     case LABEL_REF:
830       return 1;
831     case CONST:
832       op = XEXP (op, 0);
833       return (GET_CODE (XEXP (op, 0)) == LABEL_REF
834               && GET_CODE (XEXP (op, 1)) == CONST_INT);
835     default:
836       return 0;
837     }
838 }
839
840 int
841 fp_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
842 {
843   return reg_renumber && FP_REG_P (op);
844 }
845
846 \f
847
848 /* Return truth value of whether OP can be used as an operand in a
849    three operand arithmetic insn that accepts registers of mode MODE
850    or 14-bit signed integers.  */
851 int
852 arith_operand (rtx op, enum machine_mode mode)
853 {
854   return (register_operand (op, mode)
855           || (GET_CODE (op) == CONST_INT && INT_14_BITS (op)));
856 }
857
858 /* Return truth value of whether OP can be used as an operand in a
859    three operand arithmetic insn that accepts registers of mode MODE
860    or 11-bit signed integers.  */
861 int
862 arith11_operand (rtx op, enum machine_mode mode)
863 {
864   return (register_operand (op, mode)
865           || (GET_CODE (op) == CONST_INT && INT_11_BITS (op)));
866 }
867
868 /* Return truth value of whether OP can be used as an operand in a
869    adddi3 insn.  */
870 int
871 adddi3_operand (rtx op, enum machine_mode mode)
872 {
873   return (register_operand (op, mode)
874           || (GET_CODE (op) == CONST_INT
875               && (TARGET_64BIT ? INT_14_BITS (op) : INT_11_BITS (op))));
876 }
877
878 /* A constant integer suitable for use in a PRE_MODIFY memory
879    reference.  */
880 int
881 pre_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
882 {
883   return (GET_CODE (op) == CONST_INT
884           && INTVAL (op) >= -0x2000 && INTVAL (op) < 0x10);
885 }
886
887 /* A constant integer suitable for use in a POST_MODIFY memory
888    reference.  */
889 int
890 post_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
891 {
892   return (GET_CODE (op) == CONST_INT
893           && INTVAL (op) < 0x2000 && INTVAL (op) >= -0x10);
894 }
895
896 int
897 arith_double_operand (rtx op, enum machine_mode mode)
898 {
899   return (register_operand (op, mode)
900           || (GET_CODE (op) == CONST_DOUBLE
901               && GET_MODE (op) == mode
902               && VAL_14_BITS_P (CONST_DOUBLE_LOW (op))
903               && ((CONST_DOUBLE_HIGH (op) >= 0)
904                   == ((CONST_DOUBLE_LOW (op) & 0x1000) == 0))));
905 }
906
907 /* Return truth value of whether OP is an integer which fits the
908    range constraining immediate operands in three-address insns, or
909    is an integer register.  */
910
911 int
912 ireg_or_int5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
913 {
914   return ((GET_CODE (op) == CONST_INT && INT_5_BITS (op))
915           || (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32));
916 }
917
918 /* Return nonzero if OP is an integer register, else return zero.  */
919 int
920 ireg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
921 {
922   return (GET_CODE (op) == REG && REGNO (op) > 0 && REGNO (op) < 32);
923 }
924
925 /* Return truth value of whether OP is an integer which fits the
926    range constraining immediate operands in three-address insns.  */
927
928 int
929 int5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
930 {
931   return (GET_CODE (op) == CONST_INT && INT_5_BITS (op));
932 }
933
934 int
935 uint5_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
936 {
937   return (GET_CODE (op) == CONST_INT && INT_U5_BITS (op));
938 }
939
940 int
941 int11_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
942 {
943   return (GET_CODE (op) == CONST_INT && INT_11_BITS (op));
944 }
945
946 int
947 uint32_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
948 {
949 #if HOST_BITS_PER_WIDE_INT > 32
950   /* All allowed constants will fit a CONST_INT.  */
951   return (GET_CODE (op) == CONST_INT
952           && (INTVAL (op) >= 0 && INTVAL (op) < (HOST_WIDE_INT) 1 << 32));
953 #else
954   return (GET_CODE (op) == CONST_INT
955           || (GET_CODE (op) == CONST_DOUBLE
956               && CONST_DOUBLE_HIGH (op) == 0));
957 #endif
958 }
959
960 int
961 arith5_operand (rtx op, enum machine_mode mode)
962 {
963   return register_operand (op, mode) || int5_operand (op, mode);
964 }
965
966 /* True iff zdepi can be used to generate this CONST_INT.
967    zdepi first sign extends a 5 bit signed number to a given field
968    length, then places this field anywhere in a zero.  */
969 int
970 zdepi_cint_p (unsigned HOST_WIDE_INT x)
971 {
972   unsigned HOST_WIDE_INT lsb_mask, t;
973
974   /* This might not be obvious, but it's at least fast.
975      This function is critical; we don't have the time loops would take.  */
976   lsb_mask = x & -x;
977   t = ((x >> 4) + lsb_mask) & ~(lsb_mask - 1);
978   /* Return true iff t is a power of two.  */
979   return ((t & (t - 1)) == 0);
980 }
981
982 /* True iff depi or extru can be used to compute (reg & mask).
983    Accept bit pattern like these:
984    0....01....1
985    1....10....0
986    1..10..01..1  */
987 int
988 and_mask_p (unsigned HOST_WIDE_INT mask)
989 {
990   mask = ~mask;
991   mask += mask & -mask;
992   return (mask & (mask - 1)) == 0;
993 }
994
995 /* True iff depi or extru can be used to compute (reg & OP).  */
996 int
997 and_operand (rtx op, enum machine_mode mode)
998 {
999   return (register_operand (op, mode)
1000           || (GET_CODE (op) == CONST_INT && and_mask_p (INTVAL (op))));
1001 }
1002
1003 /* True iff depi can be used to compute (reg | MASK).  */
1004 int
1005 ior_mask_p (unsigned HOST_WIDE_INT mask)
1006 {
1007   mask += mask & -mask;
1008   return (mask & (mask - 1)) == 0;
1009 }
1010
1011 /* True iff depi can be used to compute (reg | OP).  */
1012 int
1013 ior_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1014 {
1015   return (GET_CODE (op) == CONST_INT && ior_mask_p (INTVAL (op)));
1016 }
1017
1018 int
1019 lhs_lshift_operand (rtx op, enum machine_mode mode)
1020 {
1021   return register_operand (op, mode) || lhs_lshift_cint_operand (op, mode);
1022 }
1023
1024 /* True iff OP is a CONST_INT of the forms 0...0xxxx or 0...01...1xxxx.
1025    Such values can be the left hand side x in (x << r), using the zvdepi
1026    instruction.  */
1027 int
1028 lhs_lshift_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1029 {
1030   unsigned HOST_WIDE_INT x;
1031   if (GET_CODE (op) != CONST_INT)
1032     return 0;
1033   x = INTVAL (op) >> 4;
1034   return (x & (x + 1)) == 0;
1035 }
1036
1037 int
1038 arith32_operand (rtx op, enum machine_mode mode)
1039 {
1040   return register_operand (op, mode) || GET_CODE (op) == CONST_INT;
1041 }
1042
1043 int
1044 pc_or_label_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1045 {
1046   return (GET_CODE (op) == PC || GET_CODE (op) == LABEL_REF);
1047 }
1048 \f
1049 /* Legitimize PIC addresses.  If the address is already
1050    position-independent, we return ORIG.  Newly generated
1051    position-independent addresses go to REG.  If we need more
1052    than one register, we lose.  */
1053
1054 rtx
1055 legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
1056 {
1057   rtx pic_ref = orig;
1058
1059   /* Labels need special handling.  */
1060   if (pic_label_operand (orig, mode))
1061     {
1062       /* We do not want to go through the movXX expanders here since that
1063          would create recursion.
1064
1065          Nor do we really want to call a generator for a named pattern
1066          since that requires multiple patterns if we want to support
1067          multiple word sizes.
1068
1069          So instead we just emit the raw set, which avoids the movXX
1070          expanders completely.  */
1071       mark_reg_pointer (reg, BITS_PER_UNIT);
1072       emit_insn (gen_rtx_SET (VOIDmode, reg, orig));
1073       current_function_uses_pic_offset_table = 1;
1074       return reg;
1075     }
1076   if (GET_CODE (orig) == SYMBOL_REF)
1077     {
1078       rtx insn, tmp_reg;
1079
1080       if (reg == 0)
1081         abort ();
1082
1083       /* Before reload, allocate a temporary register for the intermediate
1084          result.  This allows the sequence to be deleted when the final
1085          result is unused and the insns are trivially dead.  */
1086       tmp_reg = ((reload_in_progress || reload_completed)
1087                  ? reg : gen_reg_rtx (Pmode));
1088
1089       emit_move_insn (tmp_reg,
1090                       gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
1091                                     gen_rtx_HIGH (word_mode, orig)));
1092       pic_ref
1093         = gen_const_mem (Pmode,
1094                          gen_rtx_LO_SUM (Pmode, tmp_reg,
1095                                          gen_rtx_UNSPEC (Pmode,
1096                                                          gen_rtvec (1, orig),
1097                                                          UNSPEC_DLTIND14R)));
1098
1099       current_function_uses_pic_offset_table = 1;
1100       mark_reg_pointer (reg, BITS_PER_UNIT);
1101       insn = emit_move_insn (reg, pic_ref);
1102
1103       /* Put a REG_EQUAL note on this insn, so that it can be optimized.  */
1104       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig, REG_NOTES (insn));
1105
1106       return reg;
1107     }
1108   else if (GET_CODE (orig) == CONST)
1109     {
1110       rtx base;
1111
1112       if (GET_CODE (XEXP (orig, 0)) == PLUS
1113           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
1114         return orig;
1115
1116       if (reg == 0)
1117         abort ();
1118
1119       if (GET_CODE (XEXP (orig, 0)) == PLUS)
1120         {
1121           base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
1122           orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
1123                                          base == reg ? 0 : reg);
1124         }
1125       else
1126         abort ();
1127
1128       if (GET_CODE (orig) == CONST_INT)
1129         {
1130           if (INT_14_BITS (orig))
1131             return plus_constant (base, INTVAL (orig));
1132           orig = force_reg (Pmode, orig);
1133         }
1134       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
1135       /* Likewise, should we set special REG_NOTEs here?  */
1136     }
1137
1138   return pic_ref;
1139 }
1140
1141 /* Try machine-dependent ways of modifying an illegitimate address
1142    to be legitimate.  If we find one, return the new, valid address.
1143    This macro is used in only one place: `memory_address' in explow.c.
1144
1145    OLDX is the address as it was before break_out_memory_refs was called.
1146    In some cases it is useful to look at this to decide what needs to be done.
1147
1148    MODE and WIN are passed so that this macro can use
1149    GO_IF_LEGITIMATE_ADDRESS.
1150
1151    It is always safe for this macro to do nothing.  It exists to recognize
1152    opportunities to optimize the output.
1153
1154    For the PA, transform:
1155
1156         memory(X + <large int>)
1157
1158    into:
1159
1160         if (<large int> & mask) >= 16
1161           Y = (<large int> & ~mask) + mask + 1  Round up.
1162         else
1163           Y = (<large int> & ~mask)             Round down.
1164         Z = X + Y
1165         memory (Z + (<large int> - Y));
1166
1167    This is for CSE to find several similar references, and only use one Z.
1168
1169    X can either be a SYMBOL_REF or REG, but because combine cannot
1170    perform a 4->2 combination we do nothing for SYMBOL_REF + D where
1171    D will not fit in 14 bits.
1172
1173    MODE_FLOAT references allow displacements which fit in 5 bits, so use
1174    0x1f as the mask.
1175
1176    MODE_INT references allow displacements which fit in 14 bits, so use
1177    0x3fff as the mask.
1178
1179    This relies on the fact that most mode MODE_FLOAT references will use FP
1180    registers and most mode MODE_INT references will use integer registers.
1181    (In the rare case of an FP register used in an integer MODE, we depend
1182    on secondary reloads to clean things up.)
1183
1184
1185    It is also beneficial to handle (plus (mult (X) (Y)) (Z)) in a special
1186    manner if Y is 2, 4, or 8.  (allows more shadd insns and shifted indexed
1187    addressing modes to be used).
1188
1189    Put X and Z into registers.  Then put the entire expression into
1190    a register.  */
1191
1192 rtx
1193 hppa_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
1194                          enum machine_mode mode)
1195 {
1196   rtx orig = x;
1197
1198   /* We need to canonicalize the order of operands in unscaled indexed
1199      addresses since the code that checks if an address is valid doesn't
1200      always try both orders.  */
1201   if (!TARGET_NO_SPACE_REGS
1202       && GET_CODE (x) == PLUS
1203       && GET_MODE (x) == Pmode
1204       && REG_P (XEXP (x, 0))
1205       && REG_P (XEXP (x, 1))
1206       && REG_POINTER (XEXP (x, 0))
1207       && !REG_POINTER (XEXP (x, 1)))
1208     return gen_rtx_PLUS (Pmode, XEXP (x, 1), XEXP (x, 0));
1209
1210   if (flag_pic)
1211     return legitimize_pic_address (x, mode, gen_reg_rtx (Pmode));
1212
1213   /* Strip off CONST.  */
1214   if (GET_CODE (x) == CONST)
1215     x = XEXP (x, 0);
1216
1217   /* Special case.  Get the SYMBOL_REF into a register and use indexing.
1218      That should always be safe.  */
1219   if (GET_CODE (x) == PLUS
1220       && GET_CODE (XEXP (x, 0)) == REG
1221       && GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
1222     {
1223       rtx reg = force_reg (Pmode, XEXP (x, 1));
1224       return force_reg (Pmode, gen_rtx_PLUS (Pmode, reg, XEXP (x, 0)));
1225     }
1226
1227   /* Note we must reject symbols which represent function addresses
1228      since the assembler/linker can't handle arithmetic on plabels.  */
1229   if (GET_CODE (x) == PLUS
1230       && GET_CODE (XEXP (x, 1)) == CONST_INT
1231       && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1232            && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0)))
1233           || GET_CODE (XEXP (x, 0)) == REG))
1234     {
1235       rtx int_part, ptr_reg;
1236       int newoffset;
1237       int offset = INTVAL (XEXP (x, 1));
1238       int mask;
1239
1240       mask = (GET_MODE_CLASS (mode) == MODE_FLOAT
1241               ? (TARGET_PA_20 ? 0x3fff : 0x1f) : 0x3fff);
1242
1243       /* Choose which way to round the offset.  Round up if we
1244          are >= halfway to the next boundary.  */
1245       if ((offset & mask) >= ((mask + 1) / 2))
1246         newoffset = (offset & ~ mask) + mask + 1;
1247       else
1248         newoffset = (offset & ~ mask);
1249
1250       /* If the newoffset will not fit in 14 bits (ldo), then
1251          handling this would take 4 or 5 instructions (2 to load
1252          the SYMBOL_REF + 1 or 2 to load the newoffset + 1 to
1253          add the new offset and the SYMBOL_REF.)  Combine can
1254          not handle 4->2 or 5->2 combinations, so do not create
1255          them.  */
1256       if (! VAL_14_BITS_P (newoffset)
1257           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
1258         {
1259           rtx const_part = plus_constant (XEXP (x, 0), newoffset);
1260           rtx tmp_reg
1261             = force_reg (Pmode,
1262                          gen_rtx_HIGH (Pmode, const_part));
1263           ptr_reg
1264             = force_reg (Pmode,
1265                          gen_rtx_LO_SUM (Pmode,
1266                                          tmp_reg, const_part));
1267         }
1268       else
1269         {
1270           if (! VAL_14_BITS_P (newoffset))
1271             int_part = force_reg (Pmode, GEN_INT (newoffset));
1272           else
1273             int_part = GEN_INT (newoffset);
1274
1275           ptr_reg = force_reg (Pmode,
1276                                gen_rtx_PLUS (Pmode,
1277                                              force_reg (Pmode, XEXP (x, 0)),
1278                                              int_part));
1279         }
1280       return plus_constant (ptr_reg, offset - newoffset);
1281     }
1282
1283   /* Handle (plus (mult (a) (shadd_constant)) (b)).  */
1284
1285   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
1286       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1287       && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1)))
1288       && (OBJECT_P (XEXP (x, 1))
1289           || GET_CODE (XEXP (x, 1)) == SUBREG)
1290       && GET_CODE (XEXP (x, 1)) != CONST)
1291     {
1292       int val = INTVAL (XEXP (XEXP (x, 0), 1));
1293       rtx reg1, reg2;
1294
1295       reg1 = XEXP (x, 1);
1296       if (GET_CODE (reg1) != REG)
1297         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1298
1299       reg2 = XEXP (XEXP (x, 0), 0);
1300       if (GET_CODE (reg2) != REG)
1301         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1302
1303       return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1304                                              gen_rtx_MULT (Pmode,
1305                                                            reg2,
1306                                                            GEN_INT (val)),
1307                                              reg1));
1308     }
1309
1310   /* Similarly for (plus (plus (mult (a) (shadd_constant)) (b)) (c)).
1311
1312      Only do so for floating point modes since this is more speculative
1313      and we lose if it's an integer store.  */
1314   if (GET_CODE (x) == PLUS
1315       && GET_CODE (XEXP (x, 0)) == PLUS
1316       && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
1317       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
1318       && shadd_constant_p (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)))
1319       && (mode == SFmode || mode == DFmode))
1320     {
1321
1322       /* First, try and figure out what to use as a base register.  */
1323       rtx reg1, reg2, base, idx, orig_base;
1324
1325       reg1 = XEXP (XEXP (x, 0), 1);
1326       reg2 = XEXP (x, 1);
1327       base = NULL_RTX;
1328       idx = NULL_RTX;
1329
1330       /* Make sure they're both regs.  If one was a SYMBOL_REF [+ const],
1331          then emit_move_sequence will turn on REG_POINTER so we'll know
1332          it's a base register below.  */
1333       if (GET_CODE (reg1) != REG)
1334         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1335
1336       if (GET_CODE (reg2) != REG)
1337         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1338
1339       /* Figure out what the base and index are.  */
1340
1341       if (GET_CODE (reg1) == REG
1342           && REG_POINTER (reg1))
1343         {
1344           base = reg1;
1345           orig_base = XEXP (XEXP (x, 0), 1);
1346           idx = gen_rtx_PLUS (Pmode,
1347                               gen_rtx_MULT (Pmode,
1348                                             XEXP (XEXP (XEXP (x, 0), 0), 0),
1349                                             XEXP (XEXP (XEXP (x, 0), 0), 1)),
1350                               XEXP (x, 1));
1351         }
1352       else if (GET_CODE (reg2) == REG
1353                && REG_POINTER (reg2))
1354         {
1355           base = reg2;
1356           orig_base = XEXP (x, 1);
1357           idx = XEXP (x, 0);
1358         }
1359
1360       if (base == 0)
1361         return orig;
1362
1363       /* If the index adds a large constant, try to scale the
1364          constant so that it can be loaded with only one insn.  */
1365       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1366           && VAL_14_BITS_P (INTVAL (XEXP (idx, 1))
1367                             / INTVAL (XEXP (XEXP (idx, 0), 1)))
1368           && INTVAL (XEXP (idx, 1)) % INTVAL (XEXP (XEXP (idx, 0), 1)) == 0)
1369         {
1370           /* Divide the CONST_INT by the scale factor, then add it to A.  */
1371           int val = INTVAL (XEXP (idx, 1));
1372
1373           val /= INTVAL (XEXP (XEXP (idx, 0), 1));
1374           reg1 = XEXP (XEXP (idx, 0), 0);
1375           if (GET_CODE (reg1) != REG)
1376             reg1 = force_reg (Pmode, force_operand (reg1, 0));
1377
1378           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
1379
1380           /* We can now generate a simple scaled indexed address.  */
1381           return
1382             force_reg
1383               (Pmode, gen_rtx_PLUS (Pmode,
1384                                     gen_rtx_MULT (Pmode, reg1,
1385                                                   XEXP (XEXP (idx, 0), 1)),
1386                                     base));
1387         }
1388
1389       /* If B + C is still a valid base register, then add them.  */
1390       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1391           && INTVAL (XEXP (idx, 1)) <= 4096
1392           && INTVAL (XEXP (idx, 1)) >= -4096)
1393         {
1394           int val = INTVAL (XEXP (XEXP (idx, 0), 1));
1395           rtx reg1, reg2;
1396
1397           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, XEXP (idx, 1)));
1398
1399           reg2 = XEXP (XEXP (idx, 0), 0);
1400           if (GET_CODE (reg2) != CONST_INT)
1401             reg2 = force_reg (Pmode, force_operand (reg2, 0));
1402
1403           return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1404                                                  gen_rtx_MULT (Pmode,
1405                                                                reg2,
1406                                                                GEN_INT (val)),
1407                                                  reg1));
1408         }
1409
1410       /* Get the index into a register, then add the base + index and
1411          return a register holding the result.  */
1412
1413       /* First get A into a register.  */
1414       reg1 = XEXP (XEXP (idx, 0), 0);
1415       if (GET_CODE (reg1) != REG)
1416         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1417
1418       /* And get B into a register.  */
1419       reg2 = XEXP (idx, 1);
1420       if (GET_CODE (reg2) != REG)
1421         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1422
1423       reg1 = force_reg (Pmode,
1424                         gen_rtx_PLUS (Pmode,
1425                                       gen_rtx_MULT (Pmode, reg1,
1426                                                     XEXP (XEXP (idx, 0), 1)),
1427                                       reg2));
1428
1429       /* Add the result to our base register and return.  */
1430       return force_reg (Pmode, gen_rtx_PLUS (Pmode, base, reg1));
1431
1432     }
1433
1434   /* Uh-oh.  We might have an address for x[n-100000].  This needs
1435      special handling to avoid creating an indexed memory address
1436      with x-100000 as the base.
1437
1438      If the constant part is small enough, then it's still safe because
1439      there is a guard page at the beginning and end of the data segment.
1440
1441      Scaled references are common enough that we want to try and rearrange the
1442      terms so that we can use indexing for these addresses too.  Only
1443      do the optimization for floatint point modes.  */
1444
1445   if (GET_CODE (x) == PLUS
1446       && symbolic_expression_p (XEXP (x, 1)))
1447     {
1448       /* Ugly.  We modify things here so that the address offset specified
1449          by the index expression is computed first, then added to x to form
1450          the entire address.  */
1451
1452       rtx regx1, regx2, regy1, regy2, y;
1453
1454       /* Strip off any CONST.  */
1455       y = XEXP (x, 1);
1456       if (GET_CODE (y) == CONST)
1457         y = XEXP (y, 0);
1458
1459       if (GET_CODE (y) == PLUS || GET_CODE (y) == MINUS)
1460         {
1461           /* See if this looks like
1462                 (plus (mult (reg) (shadd_const))
1463                       (const (plus (symbol_ref) (const_int))))
1464
1465              Where const_int is small.  In that case the const
1466              expression is a valid pointer for indexing.
1467
1468              If const_int is big, but can be divided evenly by shadd_const
1469              and added to (reg).  This allows more scaled indexed addresses.  */
1470           if (GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1471               && GET_CODE (XEXP (x, 0)) == MULT
1472               && GET_CODE (XEXP (y, 1)) == CONST_INT
1473               && INTVAL (XEXP (y, 1)) >= -4096
1474               && INTVAL (XEXP (y, 1)) <= 4095
1475               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1476               && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1477             {
1478               int val = INTVAL (XEXP (XEXP (x, 0), 1));
1479               rtx reg1, reg2;
1480
1481               reg1 = XEXP (x, 1);
1482               if (GET_CODE (reg1) != REG)
1483                 reg1 = force_reg (Pmode, force_operand (reg1, 0));
1484
1485               reg2 = XEXP (XEXP (x, 0), 0);
1486               if (GET_CODE (reg2) != REG)
1487                 reg2 = force_reg (Pmode, force_operand (reg2, 0));
1488
1489               return force_reg (Pmode,
1490                                 gen_rtx_PLUS (Pmode,
1491                                               gen_rtx_MULT (Pmode,
1492                                                             reg2,
1493                                                             GEN_INT (val)),
1494                                               reg1));
1495             }
1496           else if ((mode == DFmode || mode == SFmode)
1497                    && GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1498                    && GET_CODE (XEXP (x, 0)) == MULT
1499                    && GET_CODE (XEXP (y, 1)) == CONST_INT
1500                    && INTVAL (XEXP (y, 1)) % INTVAL (XEXP (XEXP (x, 0), 1)) == 0
1501                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1502                    && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1503             {
1504               regx1
1505                 = force_reg (Pmode, GEN_INT (INTVAL (XEXP (y, 1))
1506                                              / INTVAL (XEXP (XEXP (x, 0), 1))));
1507               regx2 = XEXP (XEXP (x, 0), 0);
1508               if (GET_CODE (regx2) != REG)
1509                 regx2 = force_reg (Pmode, force_operand (regx2, 0));
1510               regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1511                                                         regx2, regx1));
1512               return
1513                 force_reg (Pmode,
1514                            gen_rtx_PLUS (Pmode,
1515                                          gen_rtx_MULT (Pmode, regx2,
1516                                                        XEXP (XEXP (x, 0), 1)),
1517                                          force_reg (Pmode, XEXP (y, 0))));
1518             }
1519           else if (GET_CODE (XEXP (y, 1)) == CONST_INT
1520                    && INTVAL (XEXP (y, 1)) >= -4096
1521                    && INTVAL (XEXP (y, 1)) <= 4095)
1522             {
1523               /* This is safe because of the guard page at the
1524                  beginning and end of the data space.  Just
1525                  return the original address.  */
1526               return orig;
1527             }
1528           else
1529             {
1530               /* Doesn't look like one we can optimize.  */
1531               regx1 = force_reg (Pmode, force_operand (XEXP (x, 0), 0));
1532               regy1 = force_reg (Pmode, force_operand (XEXP (y, 0), 0));
1533               regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
1534               regx1 = force_reg (Pmode,
1535                                  gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1536                                                  regx1, regy2));
1537               return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
1538             }
1539         }
1540     }
1541
1542   return orig;
1543 }
1544
1545 /* For the HPPA, REG and REG+CONST is cost 0
1546    and addresses involving symbolic constants are cost 2.
1547
1548    PIC addresses are very expensive.
1549
1550    It is no coincidence that this has the same structure
1551    as GO_IF_LEGITIMATE_ADDRESS.  */
1552
1553 static int
1554 hppa_address_cost (rtx X)
1555 {
1556   switch (GET_CODE (X))
1557     {
1558     case REG:
1559     case PLUS:
1560     case LO_SUM:
1561       return 1;
1562     case HIGH:
1563       return 2;
1564     default:
1565       return 4;
1566     }
1567 }
1568
1569 /* Compute a (partial) cost for rtx X.  Return true if the complete
1570    cost has been computed, and false if subexpressions should be
1571    scanned.  In either case, *TOTAL contains the cost result.  */
1572
1573 static bool
1574 hppa_rtx_costs (rtx x, int code, int outer_code, int *total)
1575 {
1576   switch (code)
1577     {
1578     case CONST_INT:
1579       if (INTVAL (x) == 0)
1580         *total = 0;
1581       else if (INT_14_BITS (x))
1582         *total = 1;
1583       else
1584         *total = 2;
1585       return true;
1586
1587     case HIGH:
1588       *total = 2;
1589       return true;
1590
1591     case CONST:
1592     case LABEL_REF:
1593     case SYMBOL_REF:
1594       *total = 4;
1595       return true;
1596
1597     case CONST_DOUBLE:
1598       if ((x == CONST0_RTX (DFmode) || x == CONST0_RTX (SFmode))
1599           && outer_code != SET)
1600         *total = 0;
1601       else
1602         *total = 8;
1603       return true;
1604
1605     case MULT:
1606       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1607         *total = COSTS_N_INSNS (3);
1608       else if (TARGET_PA_11 && !TARGET_DISABLE_FPREGS && !TARGET_SOFT_FLOAT)
1609         *total = COSTS_N_INSNS (8);
1610       else
1611         *total = COSTS_N_INSNS (20);
1612       return true;
1613
1614     case DIV:
1615       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1616         {
1617           *total = COSTS_N_INSNS (14);
1618           return true;
1619         }
1620       /* FALLTHRU */
1621
1622     case UDIV:
1623     case MOD:
1624     case UMOD:
1625       *total = COSTS_N_INSNS (60);
1626       return true;
1627
1628     case PLUS: /* this includes shNadd insns */
1629     case MINUS:
1630       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1631         *total = COSTS_N_INSNS (3);
1632       else
1633         *total = COSTS_N_INSNS (1);
1634       return true;
1635
1636     case ASHIFT:
1637     case ASHIFTRT:
1638     case LSHIFTRT:
1639       *total = COSTS_N_INSNS (1);
1640       return true;
1641
1642     default:
1643       return false;
1644     }
1645 }
1646
1647 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
1648    new rtx with the correct mode.  */
1649 static inline rtx
1650 force_mode (enum machine_mode mode, rtx orig)
1651 {
1652   if (mode == GET_MODE (orig))
1653     return orig;
1654
1655   if (REGNO (orig) >= FIRST_PSEUDO_REGISTER)
1656     abort ();
1657
1658   return gen_rtx_REG (mode, REGNO (orig));
1659 }
1660
1661 /* Emit insns to move operands[1] into operands[0].
1662
1663    Return 1 if we have written out everything that needs to be done to
1664    do the move.  Otherwise, return 0 and the caller will emit the move
1665    normally.
1666
1667    Note SCRATCH_REG may not be in the proper mode depending on how it
1668    will be used.  This routine is responsible for creating a new copy
1669    of SCRATCH_REG in the proper mode.  */
1670
1671 int
1672 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
1673 {
1674   register rtx operand0 = operands[0];
1675   register rtx operand1 = operands[1];
1676   register rtx tem;
1677
1678   /* We can only handle indexed addresses in the destination operand
1679      of floating point stores.  Thus, we need to break out indexed
1680      addresses from the destination operand.  */
1681   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
1682     {
1683       /* This is only safe up to the beginning of life analysis.  */
1684       if (no_new_pseudos)
1685         abort ();
1686
1687       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
1688       operand0 = replace_equiv_address (operand0, tem);
1689     }
1690
1691   /* On targets with non-equivalent space registers, break out unscaled
1692      indexed addresses from the source operand before the final CSE.
1693      We have to do this because the REG_POINTER flag is not correctly
1694      carried through various optimization passes and CSE may substitute
1695      a pseudo without the pointer set for one with the pointer set.  As
1696      a result, we loose various opportunities to create insns with
1697      unscaled indexed addresses.  */
1698   if (!TARGET_NO_SPACE_REGS
1699       && !cse_not_expected
1700       && GET_CODE (operand1) == MEM
1701       && GET_CODE (XEXP (operand1, 0)) == PLUS
1702       && REG_P (XEXP (XEXP (operand1, 0), 0))
1703       && REG_P (XEXP (XEXP (operand1, 0), 1)))
1704     operand1
1705       = replace_equiv_address (operand1,
1706                                copy_to_mode_reg (Pmode, XEXP (operand1, 0)));
1707
1708   if (scratch_reg
1709       && reload_in_progress && GET_CODE (operand0) == REG
1710       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1711     operand0 = reg_equiv_mem[REGNO (operand0)];
1712   else if (scratch_reg
1713            && reload_in_progress && GET_CODE (operand0) == SUBREG
1714            && GET_CODE (SUBREG_REG (operand0)) == REG
1715            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
1716     {
1717      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1718         the code which tracks sets/uses for delete_output_reload.  */
1719       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
1720                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
1721                                  SUBREG_BYTE (operand0));
1722       operand0 = alter_subreg (&temp);
1723     }
1724
1725   if (scratch_reg
1726       && reload_in_progress && GET_CODE (operand1) == REG
1727       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
1728     operand1 = reg_equiv_mem[REGNO (operand1)];
1729   else if (scratch_reg
1730            && reload_in_progress && GET_CODE (operand1) == SUBREG
1731            && GET_CODE (SUBREG_REG (operand1)) == REG
1732            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
1733     {
1734      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1735         the code which tracks sets/uses for delete_output_reload.  */
1736       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
1737                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
1738                                  SUBREG_BYTE (operand1));
1739       operand1 = alter_subreg (&temp);
1740     }
1741
1742   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
1743       && ((tem = find_replacement (&XEXP (operand0, 0)))
1744           != XEXP (operand0, 0)))
1745     operand0 = gen_rtx_MEM (GET_MODE (operand0), tem);
1746
1747   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
1748       && ((tem = find_replacement (&XEXP (operand1, 0)))
1749           != XEXP (operand1, 0)))
1750     operand1 = gen_rtx_MEM (GET_MODE (operand1), tem);
1751
1752   /* Handle secondary reloads for loads/stores of FP registers from
1753      REG+D addresses where D does not fit in 5 or 14 bits, including
1754      (subreg (mem (addr))) cases.  */
1755   if (scratch_reg
1756       && fp_reg_operand (operand0, mode)
1757       && ((GET_CODE (operand1) == MEM
1758            && !memory_address_p ((GET_MODE_SIZE (mode) == 4 ? SFmode : DFmode),
1759                                  XEXP (operand1, 0)))
1760           || ((GET_CODE (operand1) == SUBREG
1761                && GET_CODE (XEXP (operand1, 0)) == MEM
1762                && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1763                                       ? SFmode : DFmode),
1764                                      XEXP (XEXP (operand1, 0), 0))))))
1765     {
1766       if (GET_CODE (operand1) == SUBREG)
1767         operand1 = XEXP (operand1, 0);
1768
1769       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1770          it in WORD_MODE regardless of what mode it was originally given
1771          to us.  */
1772       scratch_reg = force_mode (word_mode, scratch_reg);
1773
1774       /* D might not fit in 14 bits either; for such cases load D into
1775          scratch reg.  */
1776       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
1777         {
1778           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1779           emit_move_insn (scratch_reg,
1780                           gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
1781                                           Pmode,
1782                                           XEXP (XEXP (operand1, 0), 0),
1783                                           scratch_reg));
1784         }
1785       else
1786         emit_move_insn (scratch_reg, XEXP (operand1, 0));
1787       emit_insn (gen_rtx_SET (VOIDmode, operand0,
1788                               gen_rtx_MEM (mode, scratch_reg)));
1789       return 1;
1790     }
1791   else if (scratch_reg
1792            && fp_reg_operand (operand1, mode)
1793            && ((GET_CODE (operand0) == MEM
1794                 && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1795                                         ? SFmode : DFmode),
1796                                        XEXP (operand0, 0)))
1797                || ((GET_CODE (operand0) == SUBREG)
1798                    && GET_CODE (XEXP (operand0, 0)) == MEM
1799                    && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1800                                           ? SFmode : DFmode),
1801                                          XEXP (XEXP (operand0, 0), 0)))))
1802     {
1803       if (GET_CODE (operand0) == SUBREG)
1804         operand0 = XEXP (operand0, 0);
1805
1806       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1807          it in WORD_MODE regardless of what mode it was originally given
1808          to us.  */
1809       scratch_reg = force_mode (word_mode, scratch_reg);
1810
1811       /* D might not fit in 14 bits either; for such cases load D into
1812          scratch reg.  */
1813       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
1814         {
1815           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
1816           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
1817                                                                         0)),
1818                                                        Pmode,
1819                                                        XEXP (XEXP (operand0, 0),
1820                                                                    0),
1821                                                        scratch_reg));
1822         }
1823       else
1824         emit_move_insn (scratch_reg, XEXP (operand0, 0));
1825       emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_MEM (mode, scratch_reg),
1826                               operand1));
1827       return 1;
1828     }
1829   /* Handle secondary reloads for loads of FP registers from constant
1830      expressions by forcing the constant into memory.
1831
1832      Use scratch_reg to hold the address of the memory location.
1833
1834      The proper fix is to change PREFERRED_RELOAD_CLASS to return
1835      NO_REGS when presented with a const_int and a register class
1836      containing only FP registers.  Doing so unfortunately creates
1837      more problems than it solves.   Fix this for 2.5.  */
1838   else if (scratch_reg
1839            && CONSTANT_P (operand1)
1840            && fp_reg_operand (operand0, mode))
1841     {
1842       rtx xoperands[2];
1843
1844       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1845          it in WORD_MODE regardless of what mode it was originally given
1846          to us.  */
1847       scratch_reg = force_mode (word_mode, scratch_reg);
1848
1849       /* Force the constant into memory and put the address of the
1850          memory location into scratch_reg.  */
1851       xoperands[0] = scratch_reg;
1852       xoperands[1] = XEXP (force_const_mem (mode, operand1), 0);
1853       emit_move_sequence (xoperands, Pmode, 0);
1854
1855       /* Now load the destination register.  */
1856       emit_insn (gen_rtx_SET (mode, operand0,
1857                               gen_rtx_MEM (mode, scratch_reg)));
1858       return 1;
1859     }
1860   /* Handle secondary reloads for SAR.  These occur when trying to load
1861      the SAR from memory, FP register, or with a constant.  */
1862   else if (scratch_reg
1863            && GET_CODE (operand0) == REG
1864            && REGNO (operand0) < FIRST_PSEUDO_REGISTER
1865            && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
1866            && (GET_CODE (operand1) == MEM
1867                || GET_CODE (operand1) == CONST_INT
1868                || (GET_CODE (operand1) == REG
1869                    && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
1870     {
1871       /* D might not fit in 14 bits either; for such cases load D into
1872          scratch reg.  */
1873       if (GET_CODE (operand1) == MEM
1874           && !memory_address_p (Pmode, XEXP (operand1, 0)))
1875         {
1876           /* We are reloading the address into the scratch register, so we
1877              want to make sure the scratch register is a full register.  */
1878           scratch_reg = force_mode (word_mode, scratch_reg);
1879
1880           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1881           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1,
1882                                                                         0)),
1883                                                        Pmode,
1884                                                        XEXP (XEXP (operand1, 0),
1885                                                        0),
1886                                                        scratch_reg));
1887
1888           /* Now we are going to load the scratch register from memory,
1889              we want to load it in the same width as the original MEM,
1890              which must be the same as the width of the ultimate destination,
1891              OPERAND0.  */
1892           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1893
1894           emit_move_insn (scratch_reg, gen_rtx_MEM (GET_MODE (operand0),
1895                                                     scratch_reg));
1896         }
1897       else
1898         {
1899           /* We want to load the scratch register using the same mode as
1900              the ultimate destination.  */
1901           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1902
1903           emit_move_insn (scratch_reg, operand1);
1904         }
1905
1906       /* And emit the insn to set the ultimate destination.  We know that
1907          the scratch register has the same mode as the destination at this
1908          point.  */
1909       emit_move_insn (operand0, scratch_reg);
1910       return 1;
1911     }
1912   /* Handle the most common case: storing into a register.  */
1913   else if (register_operand (operand0, mode))
1914     {
1915       if (register_operand (operand1, mode)
1916           || (GET_CODE (operand1) == CONST_INT
1917               && cint_ok_for_move (INTVAL (operand1)))
1918           || (operand1 == CONST0_RTX (mode))
1919           || (GET_CODE (operand1) == HIGH
1920               && !symbolic_operand (XEXP (operand1, 0), VOIDmode))
1921           /* Only `general_operands' can come here, so MEM is ok.  */
1922           || GET_CODE (operand1) == MEM)
1923         {
1924           /* Various sets are created during RTL generation which don't
1925              have the REG_POINTER flag correctly set.  After the CSE pass,
1926              instruction recognition can fail if we don't consistently
1927              set this flag when performing register copies.  This should
1928              also improve the opportunities for creating insns that use
1929              unscaled indexing.  */
1930           if (REG_P (operand0) && REG_P (operand1))
1931             {
1932               if (REG_POINTER (operand1)
1933                   && !REG_POINTER (operand0)
1934                   && !HARD_REGISTER_P (operand0))
1935                 copy_reg_pointer (operand0, operand1);
1936               else if (REG_POINTER (operand0)
1937                        && !REG_POINTER (operand1)
1938                        && !HARD_REGISTER_P (operand1))
1939                 copy_reg_pointer (operand1, operand0);
1940             }
1941           
1942           /* When MEMs are broken out, the REG_POINTER flag doesn't
1943              get set.  In some cases, we can set the REG_POINTER flag
1944              from the declaration for the MEM.  */
1945           if (REG_P (operand0)
1946               && GET_CODE (operand1) == MEM
1947               && !REG_POINTER (operand0))
1948             {
1949               tree decl = MEM_EXPR (operand1);
1950
1951               /* Set the register pointer flag and register alignment
1952                  if the declaration for this memory reference is a
1953                  pointer type.  Fortran indirect argument references
1954                  are ignored.  */
1955               if (decl
1956                   && !(flag_argument_noalias > 1
1957                        && TREE_CODE (decl) == INDIRECT_REF
1958                        && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL))
1959                 {
1960                   tree type;
1961
1962                   /* If this is a COMPONENT_REF, use the FIELD_DECL from
1963                      tree operand 1.  */
1964                   if (TREE_CODE (decl) == COMPONENT_REF)
1965                     decl = TREE_OPERAND (decl, 1);
1966
1967                   type = TREE_TYPE (decl);
1968                   if (TREE_CODE (type) == ARRAY_TYPE)
1969                     type = get_inner_array_type (type);
1970
1971                   if (POINTER_TYPE_P (type))
1972                     {
1973                       int align;
1974
1975                       type = TREE_TYPE (type);
1976                       /* Using TYPE_ALIGN_OK is rather conservative as
1977                          only the ada frontend actually sets it.  */
1978                       align = (TYPE_ALIGN_OK (type) ? TYPE_ALIGN (type)
1979                                : BITS_PER_UNIT);
1980                       mark_reg_pointer (operand0, align);
1981                     }
1982                 }
1983             }
1984
1985           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1986           return 1;
1987         }
1988     }
1989   else if (GET_CODE (operand0) == MEM)
1990     {
1991       if (mode == DFmode && operand1 == CONST0_RTX (mode)
1992           && !(reload_in_progress || reload_completed))
1993         {
1994           rtx temp = gen_reg_rtx (DFmode);
1995
1996           emit_insn (gen_rtx_SET (VOIDmode, temp, operand1));
1997           emit_insn (gen_rtx_SET (VOIDmode, operand0, temp));
1998           return 1;
1999         }
2000       if (register_operand (operand1, mode) || operand1 == CONST0_RTX (mode))
2001         {
2002           /* Run this case quickly.  */
2003           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
2004           return 1;
2005         }
2006       if (! (reload_in_progress || reload_completed))
2007         {
2008           operands[0] = validize_mem (operand0);
2009           operands[1] = operand1 = force_reg (mode, operand1);
2010         }
2011     }
2012
2013   /* Simplify the source if we need to.
2014      Note we do have to handle function labels here, even though we do
2015      not consider them legitimate constants.  Loop optimizations can
2016      call the emit_move_xxx with one as a source.  */
2017   if ((GET_CODE (operand1) != HIGH && immediate_operand (operand1, mode))
2018       || function_label_operand (operand1, mode)
2019       || (GET_CODE (operand1) == HIGH
2020           && symbolic_operand (XEXP (operand1, 0), mode)))
2021     {
2022       int ishighonly = 0;
2023
2024       if (GET_CODE (operand1) == HIGH)
2025         {
2026           ishighonly = 1;
2027           operand1 = XEXP (operand1, 0);
2028         }
2029       if (symbolic_operand (operand1, mode))
2030         {
2031           /* Argh.  The assembler and linker can't handle arithmetic
2032              involving plabels.
2033
2034              So we force the plabel into memory, load operand0 from
2035              the memory location, then add in the constant part.  */
2036           if ((GET_CODE (operand1) == CONST
2037                && GET_CODE (XEXP (operand1, 0)) == PLUS
2038                && function_label_operand (XEXP (XEXP (operand1, 0), 0), Pmode))
2039               || function_label_operand (operand1, mode))
2040             {
2041               rtx temp, const_part;
2042
2043               /* Figure out what (if any) scratch register to use.  */
2044               if (reload_in_progress || reload_completed)
2045                 {
2046                   scratch_reg = scratch_reg ? scratch_reg : operand0;
2047                   /* SCRATCH_REG will hold an address and maybe the actual
2048                      data.  We want it in WORD_MODE regardless of what mode it
2049                      was originally given to us.  */
2050                   scratch_reg = force_mode (word_mode, scratch_reg);
2051                 }
2052               else if (flag_pic)
2053                 scratch_reg = gen_reg_rtx (Pmode);
2054
2055               if (GET_CODE (operand1) == CONST)
2056                 {
2057                   /* Save away the constant part of the expression.  */
2058                   const_part = XEXP (XEXP (operand1, 0), 1);
2059                   if (GET_CODE (const_part) != CONST_INT)
2060                     abort ();
2061
2062                   /* Force the function label into memory.  */
2063                   temp = force_const_mem (mode, XEXP (XEXP (operand1, 0), 0));
2064                 }
2065               else
2066                 {
2067                   /* No constant part.  */
2068                   const_part = NULL_RTX;
2069
2070                   /* Force the function label into memory.  */
2071                   temp = force_const_mem (mode, operand1);
2072                 }
2073
2074
2075               /* Get the address of the memory location.  PIC-ify it if
2076                  necessary.  */
2077               temp = XEXP (temp, 0);
2078               if (flag_pic)
2079                 temp = legitimize_pic_address (temp, mode, scratch_reg);
2080
2081               /* Put the address of the memory location into our destination
2082                  register.  */
2083               operands[1] = temp;
2084               emit_move_sequence (operands, mode, scratch_reg);
2085
2086               /* Now load from the memory location into our destination
2087                  register.  */
2088               operands[1] = gen_rtx_MEM (Pmode, operands[0]);
2089               emit_move_sequence (operands, mode, scratch_reg);
2090
2091               /* And add back in the constant part.  */
2092               if (const_part != NULL_RTX)
2093                 expand_inc (operand0, const_part);
2094
2095               return 1;
2096             }
2097
2098           if (flag_pic)
2099             {
2100               rtx temp;
2101
2102               if (reload_in_progress || reload_completed)
2103                 {
2104                   temp = scratch_reg ? scratch_reg : operand0;
2105                   /* TEMP will hold an address and maybe the actual
2106                      data.  We want it in WORD_MODE regardless of what mode it
2107                      was originally given to us.  */
2108                   temp = force_mode (word_mode, temp);
2109                 }
2110               else
2111                 temp = gen_reg_rtx (Pmode);
2112
2113               /* (const (plus (symbol) (const_int))) must be forced to
2114                  memory during/after reload if the const_int will not fit
2115                  in 14 bits.  */
2116               if (GET_CODE (operand1) == CONST
2117                        && GET_CODE (XEXP (operand1, 0)) == PLUS
2118                        && GET_CODE (XEXP (XEXP (operand1, 0), 1)) == CONST_INT
2119                        && !INT_14_BITS (XEXP (XEXP (operand1, 0), 1))
2120                        && (reload_completed || reload_in_progress)
2121                        && flag_pic)
2122                 {
2123                   operands[1] = force_const_mem (mode, operand1);
2124                   operands[1] = legitimize_pic_address (XEXP (operands[1], 0),
2125                                                         mode, temp);
2126                   operands[1] = gen_rtx_MEM (mode, operands[1]);
2127                   emit_move_sequence (operands, mode, temp);
2128                 }
2129               else
2130                 {
2131                   operands[1] = legitimize_pic_address (operand1, mode, temp);
2132                   if (REG_P (operand0) && REG_P (operands[1]))
2133                     copy_reg_pointer (operand0, operands[1]);
2134                   emit_insn (gen_rtx_SET (VOIDmode, operand0, operands[1]));
2135                 }
2136             }
2137           /* On the HPPA, references to data space are supposed to use dp,
2138              register 27, but showing it in the RTL inhibits various cse
2139              and loop optimizations.  */
2140           else
2141             {
2142               rtx temp, set;
2143
2144               if (reload_in_progress || reload_completed)
2145                 {
2146                   temp = scratch_reg ? scratch_reg : operand0;
2147                   /* TEMP will hold an address and maybe the actual
2148                      data.  We want it in WORD_MODE regardless of what mode it
2149                      was originally given to us.  */
2150                   temp = force_mode (word_mode, temp);
2151                 }
2152               else
2153                 temp = gen_reg_rtx (mode);
2154
2155               /* Loading a SYMBOL_REF into a register makes that register
2156                  safe to be used as the base in an indexed address.
2157
2158                  Don't mark hard registers though.  That loses.  */
2159               if (GET_CODE (operand0) == REG
2160                   && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
2161                 mark_reg_pointer (operand0, BITS_PER_UNIT);
2162               if (REGNO (temp) >= FIRST_PSEUDO_REGISTER)
2163                 mark_reg_pointer (temp, BITS_PER_UNIT);
2164
2165               if (ishighonly)
2166                 set = gen_rtx_SET (mode, operand0, temp);
2167               else
2168                 set = gen_rtx_SET (VOIDmode,
2169                                    operand0,
2170                                    gen_rtx_LO_SUM (mode, temp, operand1));
2171
2172               emit_insn (gen_rtx_SET (VOIDmode,
2173                                       temp,
2174                                       gen_rtx_HIGH (mode, operand1)));
2175               emit_insn (set);
2176
2177             }
2178           return 1;
2179         }
2180       else if (GET_CODE (operand1) != CONST_INT
2181                || !cint_ok_for_move (INTVAL (operand1)))
2182         {
2183           rtx insn, temp;
2184           rtx op1 = operand1;
2185           HOST_WIDE_INT value = 0;
2186           HOST_WIDE_INT insv = 0;
2187           int insert = 0;
2188
2189           if (GET_CODE (operand1) == CONST_INT)
2190             value = INTVAL (operand1);
2191
2192           if (TARGET_64BIT
2193               && GET_CODE (operand1) == CONST_INT
2194               && HOST_BITS_PER_WIDE_INT > 32
2195               && GET_MODE_BITSIZE (GET_MODE (operand0)) > 32)
2196             {
2197               HOST_WIDE_INT nval;
2198
2199               /* Extract the low order 32 bits of the value and sign extend.
2200                  If the new value is the same as the original value, we can
2201                  can use the original value as-is.  If the new value is
2202                  different, we use it and insert the most-significant 32-bits
2203                  of the original value into the final result.  */
2204               nval = ((value & (((HOST_WIDE_INT) 2 << 31) - 1))
2205                       ^ ((HOST_WIDE_INT) 1 << 31)) - ((HOST_WIDE_INT) 1 << 31);
2206               if (value != nval)
2207                 {
2208 #if HOST_BITS_PER_WIDE_INT > 32
2209                   insv = value >= 0 ? value >> 32 : ~(~value >> 32);
2210 #endif
2211                   insert = 1;
2212                   value = nval;
2213                   operand1 = GEN_INT (nval);
2214                 }
2215             }
2216
2217           if (reload_in_progress || reload_completed)
2218             temp = scratch_reg ? scratch_reg : operand0;
2219           else
2220             temp = gen_reg_rtx (mode);
2221
2222           /* We don't directly split DImode constants on 32-bit targets
2223              because PLUS uses an 11-bit immediate and the insn sequence
2224              generated is not as efficient as the one using HIGH/LO_SUM.  */
2225           if (GET_CODE (operand1) == CONST_INT
2226               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2227               && !insert)
2228             {
2229               /* Directly break constant into high and low parts.  This
2230                  provides better optimization opportunities because various
2231                  passes recognize constants split with PLUS but not LO_SUM.
2232                  We use a 14-bit signed low part except when the addition
2233                  of 0x4000 to the high part might change the sign of the
2234                  high part.  */
2235               HOST_WIDE_INT low = value & 0x3fff;
2236               HOST_WIDE_INT high = value & ~ 0x3fff;
2237
2238               if (low >= 0x2000)
2239                 {
2240                   if (high == 0x7fffc000 || (mode == HImode && high == 0x4000))
2241                     high += 0x2000;
2242                   else
2243                     high += 0x4000;
2244                 }
2245
2246               low = value - high;
2247
2248               emit_insn (gen_rtx_SET (VOIDmode, temp, GEN_INT (high)));
2249               operands[1] = gen_rtx_PLUS (mode, temp, GEN_INT (low));
2250             }
2251           else
2252             {
2253               emit_insn (gen_rtx_SET (VOIDmode, temp,
2254                                       gen_rtx_HIGH (mode, operand1)));
2255               operands[1] = gen_rtx_LO_SUM (mode, temp, operand1);
2256             }
2257
2258           insn = emit_move_insn (operands[0], operands[1]);
2259
2260           /* Now insert the most significant 32 bits of the value
2261              into the register.  When we don't have a second register
2262              available, it could take up to nine instructions to load
2263              a 64-bit integer constant.  Prior to reload, we force
2264              constants that would take more than three instructions
2265              to load to the constant pool.  During and after reload,
2266              we have to handle all possible values.  */
2267           if (insert)
2268             {
2269               /* Use a HIGH/LO_SUM/INSV sequence if we have a second
2270                  register and the value to be inserted is outside the
2271                  range that can be loaded with three depdi instructions.  */
2272               if (temp != operand0 && (insv >= 16384 || insv < -16384))
2273                 {
2274                   operand1 = GEN_INT (insv);
2275
2276                   emit_insn (gen_rtx_SET (VOIDmode, temp,
2277                                           gen_rtx_HIGH (mode, operand1)));
2278                   emit_move_insn (temp, gen_rtx_LO_SUM (mode, temp, operand1));
2279                   emit_insn (gen_insv (operand0, GEN_INT (32),
2280                                        const0_rtx, temp));
2281                 }
2282               else
2283                 {
2284                   int len = 5, pos = 27;
2285
2286                   /* Insert the bits using the depdi instruction.  */
2287                   while (pos >= 0)
2288                     {
2289                       HOST_WIDE_INT v5 = ((insv & 31) ^ 16) - 16;
2290                       HOST_WIDE_INT sign = v5 < 0;
2291
2292                       /* Left extend the insertion.  */
2293                       insv = (insv >= 0 ? insv >> len : ~(~insv >> len));
2294                       while (pos > 0 && (insv & 1) == sign)
2295                         {
2296                           insv = (insv >= 0 ? insv >> 1 : ~(~insv >> 1));
2297                           len += 1;
2298                           pos -= 1;
2299                         }
2300
2301                       emit_insn (gen_insv (operand0, GEN_INT (len),
2302                                            GEN_INT (pos), GEN_INT (v5)));
2303
2304                       len = pos > 0 && pos < 5 ? pos : 5;
2305                       pos -= len;
2306                     }
2307                 }
2308             }
2309
2310           REG_NOTES (insn)
2311             = gen_rtx_EXPR_LIST (REG_EQUAL, op1, REG_NOTES (insn));
2312
2313           return 1;
2314         }
2315     }
2316   /* Now have insn-emit do whatever it normally does.  */
2317   return 0;
2318 }
2319
2320 /* Examine EXP and return nonzero if it contains an ADDR_EXPR (meaning
2321    it will need a link/runtime reloc).  */
2322
2323 int
2324 reloc_needed (tree exp)
2325 {
2326   int reloc = 0;
2327
2328   switch (TREE_CODE (exp))
2329     {
2330     case ADDR_EXPR:
2331       return 1;
2332
2333     case PLUS_EXPR:
2334     case MINUS_EXPR:
2335       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2336       reloc |= reloc_needed (TREE_OPERAND (exp, 1));
2337       break;
2338
2339     case NOP_EXPR:
2340     case CONVERT_EXPR:
2341     case NON_LVALUE_EXPR:
2342       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2343       break;
2344
2345     case CONSTRUCTOR:
2346       {
2347         register tree link;
2348         for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2349           if (TREE_VALUE (link) != 0)
2350             reloc |= reloc_needed (TREE_VALUE (link));
2351       }
2352       break;
2353
2354     case ERROR_MARK:
2355       break;
2356
2357     default:
2358       break;
2359     }
2360   return reloc;
2361 }
2362
2363 /* Does operand (which is a symbolic_operand) live in text space?
2364    If so, SYMBOL_REF_FLAG, which is set by pa_encode_section_info,
2365    will be true.  */
2366
2367 int
2368 read_only_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
2369 {
2370   if (GET_CODE (operand) == CONST)
2371     operand = XEXP (XEXP (operand, 0), 0);
2372   if (flag_pic)
2373     {
2374       if (GET_CODE (operand) == SYMBOL_REF)
2375         return SYMBOL_REF_FLAG (operand) && !CONSTANT_POOL_ADDRESS_P (operand);
2376     }
2377   else
2378     {
2379       if (GET_CODE (operand) == SYMBOL_REF)
2380         return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
2381     }
2382   return 1;
2383 }
2384
2385 \f
2386 /* Return the best assembler insn template
2387    for moving operands[1] into operands[0] as a fullword.  */
2388 const char *
2389 singlemove_string (rtx *operands)
2390 {
2391   HOST_WIDE_INT intval;
2392
2393   if (GET_CODE (operands[0]) == MEM)
2394     return "stw %r1,%0";
2395   if (GET_CODE (operands[1]) == MEM)
2396     return "ldw %1,%0";
2397   if (GET_CODE (operands[1]) == CONST_DOUBLE)
2398     {
2399       long i;
2400       REAL_VALUE_TYPE d;
2401
2402       if (GET_MODE (operands[1]) != SFmode)
2403         abort ();
2404
2405       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
2406          bit pattern.  */
2407       REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
2408       REAL_VALUE_TO_TARGET_SINGLE (d, i);
2409
2410       operands[1] = GEN_INT (i);
2411       /* Fall through to CONST_INT case.  */
2412     }
2413   if (GET_CODE (operands[1]) == CONST_INT)
2414     {
2415       intval = INTVAL (operands[1]);
2416
2417       if (VAL_14_BITS_P (intval))
2418         return "ldi %1,%0";
2419       else if ((intval & 0x7ff) == 0)
2420         return "ldil L'%1,%0";
2421       else if (zdepi_cint_p (intval))
2422         return "{zdepi %Z1,%0|depwi,z %Z1,%0}";
2423       else
2424         return "ldil L'%1,%0\n\tldo R'%1(%0),%0";
2425     }
2426   return "copy %1,%0";
2427 }
2428 \f
2429
2430 /* Compute position (in OP[1]) and width (in OP[2])
2431    useful for copying IMM to a register using the zdepi
2432    instructions.  Store the immediate value to insert in OP[0].  */
2433 static void
2434 compute_zdepwi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2435 {
2436   int lsb, len;
2437
2438   /* Find the least significant set bit in IMM.  */
2439   for (lsb = 0; lsb < 32; lsb++)
2440     {
2441       if ((imm & 1) != 0)
2442         break;
2443       imm >>= 1;
2444     }
2445
2446   /* Choose variants based on *sign* of the 5-bit field.  */
2447   if ((imm & 0x10) == 0)
2448     len = (lsb <= 28) ? 4 : 32 - lsb;
2449   else
2450     {
2451       /* Find the width of the bitstring in IMM.  */
2452       for (len = 5; len < 32; len++)
2453         {
2454           if ((imm & (1 << len)) == 0)
2455             break;
2456         }
2457
2458       /* Sign extend IMM as a 5-bit value.  */
2459       imm = (imm & 0xf) - 0x10;
2460     }
2461
2462   op[0] = imm;
2463   op[1] = 31 - lsb;
2464   op[2] = len;
2465 }
2466
2467 /* Compute position (in OP[1]) and width (in OP[2])
2468    useful for copying IMM to a register using the depdi,z
2469    instructions.  Store the immediate value to insert in OP[0].  */
2470 void
2471 compute_zdepdi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2472 {
2473   HOST_WIDE_INT lsb, len;
2474
2475   /* Find the least significant set bit in IMM.  */
2476   for (lsb = 0; lsb < HOST_BITS_PER_WIDE_INT; lsb++)
2477     {
2478       if ((imm & 1) != 0)
2479         break;
2480       imm >>= 1;
2481     }
2482
2483   /* Choose variants based on *sign* of the 5-bit field.  */
2484   if ((imm & 0x10) == 0)
2485     len = ((lsb <= HOST_BITS_PER_WIDE_INT - 4)
2486            ? 4 : HOST_BITS_PER_WIDE_INT - lsb);
2487   else
2488     {
2489       /* Find the width of the bitstring in IMM.  */
2490       for (len = 5; len < HOST_BITS_PER_WIDE_INT; len++)
2491         {
2492           if ((imm & ((unsigned HOST_WIDE_INT) 1 << len)) == 0)
2493             break;
2494         }
2495
2496       /* Sign extend IMM as a 5-bit value.  */
2497       imm = (imm & 0xf) - 0x10;
2498     }
2499
2500   op[0] = imm;
2501   op[1] = 63 - lsb;
2502   op[2] = len;
2503 }
2504
2505 /* Output assembler code to perform a doubleword move insn
2506    with operands OPERANDS.  */
2507
2508 const char *
2509 output_move_double (rtx *operands)
2510 {
2511   enum { REGOP, OFFSOP, MEMOP, CNSTOP, RNDOP } optype0, optype1;
2512   rtx latehalf[2];
2513   rtx addreg0 = 0, addreg1 = 0;
2514
2515   /* First classify both operands.  */
2516
2517   if (REG_P (operands[0]))
2518     optype0 = REGOP;
2519   else if (offsettable_memref_p (operands[0]))
2520     optype0 = OFFSOP;
2521   else if (GET_CODE (operands[0]) == MEM)
2522     optype0 = MEMOP;
2523   else
2524     optype0 = RNDOP;
2525
2526   if (REG_P (operands[1]))
2527     optype1 = REGOP;
2528   else if (CONSTANT_P (operands[1]))
2529     optype1 = CNSTOP;
2530   else if (offsettable_memref_p (operands[1]))
2531     optype1 = OFFSOP;
2532   else if (GET_CODE (operands[1]) == MEM)
2533     optype1 = MEMOP;
2534   else
2535     optype1 = RNDOP;
2536
2537   /* Check for the cases that the operand constraints are not
2538      supposed to allow to happen.  Abort if we get one,
2539      because generating code for these cases is painful.  */
2540
2541   if (optype0 != REGOP && optype1 != REGOP)
2542     abort ();
2543
2544    /* Handle auto decrementing and incrementing loads and stores
2545      specifically, since the structure of the function doesn't work
2546      for them without major modification.  Do it better when we learn
2547      this port about the general inc/dec addressing of PA.
2548      (This was written by tege.  Chide him if it doesn't work.)  */
2549
2550   if (optype0 == MEMOP)
2551     {
2552       /* We have to output the address syntax ourselves, since print_operand
2553          doesn't deal with the addresses we want to use.  Fix this later.  */
2554
2555       rtx addr = XEXP (operands[0], 0);
2556       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2557         {
2558           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2559
2560           operands[0] = XEXP (addr, 0);
2561           if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
2562             abort ();
2563
2564           if (!reg_overlap_mentioned_p (high_reg, addr))
2565             {
2566               /* No overlap between high target register and address
2567                  register.  (We do this in a non-obvious way to
2568                  save a register file writeback)  */
2569               if (GET_CODE (addr) == POST_INC)
2570                 return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2571               return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2572             }
2573           else
2574             abort ();
2575         }
2576       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2577         {
2578           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2579
2580           operands[0] = XEXP (addr, 0);
2581           if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
2582             abort ();
2583
2584           if (!reg_overlap_mentioned_p (high_reg, addr))
2585             {
2586               /* No overlap between high target register and address
2587                  register.  (We do this in a non-obvious way to
2588                  save a register file writeback)  */
2589               if (GET_CODE (addr) == PRE_INC)
2590                 return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2591               return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2592             }
2593           else
2594             abort ();
2595         }
2596     }
2597   if (optype1 == MEMOP)
2598     {
2599       /* We have to output the address syntax ourselves, since print_operand
2600          doesn't deal with the addresses we want to use.  Fix this later.  */
2601
2602       rtx addr = XEXP (operands[1], 0);
2603       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2604         {
2605           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2606
2607           operands[1] = XEXP (addr, 0);
2608           if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
2609             abort ();
2610
2611           if (!reg_overlap_mentioned_p (high_reg, addr))
2612             {
2613               /* No overlap between high target register and address
2614                  register.  (We do this in a non-obvious way to
2615                  save a register file writeback)  */
2616               if (GET_CODE (addr) == POST_INC)
2617                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2618               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2619             }
2620           else
2621             {
2622               /* This is an undefined situation.  We should load into the
2623                  address register *and* update that register.  Probably
2624                  we don't need to handle this at all.  */
2625               if (GET_CODE (addr) == POST_INC)
2626                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2627               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2628             }
2629         }
2630       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2631         {
2632           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2633
2634           operands[1] = XEXP (addr, 0);
2635           if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
2636             abort ();
2637
2638           if (!reg_overlap_mentioned_p (high_reg, addr))
2639             {
2640               /* No overlap between high target register and address
2641                  register.  (We do this in a non-obvious way to
2642                  save a register file writeback)  */
2643               if (GET_CODE (addr) == PRE_INC)
2644                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2645               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2646             }
2647           else
2648             {
2649               /* This is an undefined situation.  We should load into the
2650                  address register *and* update that register.  Probably
2651                  we don't need to handle this at all.  */
2652               if (GET_CODE (addr) == PRE_INC)
2653                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2654               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2655             }
2656         }
2657       else if (GET_CODE (addr) == PLUS
2658                && GET_CODE (XEXP (addr, 0)) == MULT)
2659         {
2660           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2661
2662           if (!reg_overlap_mentioned_p (high_reg, addr))
2663             {
2664               rtx xoperands[3];
2665
2666               xoperands[0] = high_reg;
2667               xoperands[1] = XEXP (addr, 1);
2668               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2669               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2670               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2671                                xoperands);
2672               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2673             }
2674           else
2675             {
2676               rtx xoperands[3];
2677
2678               xoperands[0] = high_reg;
2679               xoperands[1] = XEXP (addr, 1);
2680               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2681               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2682               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2683                                xoperands);
2684               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2685             }
2686         }
2687     }
2688
2689   /* If an operand is an unoffsettable memory ref, find a register
2690      we can increment temporarily to make it refer to the second word.  */
2691
2692   if (optype0 == MEMOP)
2693     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2694
2695   if (optype1 == MEMOP)
2696     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2697
2698   /* Ok, we can do one word at a time.
2699      Normally we do the low-numbered word first.
2700
2701      In either case, set up in LATEHALF the operands to use
2702      for the high-numbered word and in some cases alter the
2703      operands in OPERANDS to be suitable for the low-numbered word.  */
2704
2705   if (optype0 == REGOP)
2706     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2707   else if (optype0 == OFFSOP)
2708     latehalf[0] = adjust_address (operands[0], SImode, 4);
2709   else
2710     latehalf[0] = operands[0];
2711
2712   if (optype1 == REGOP)
2713     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2714   else if (optype1 == OFFSOP)
2715     latehalf[1] = adjust_address (operands[1], SImode, 4);
2716   else if (optype1 == CNSTOP)
2717     split_double (operands[1], &operands[1], &latehalf[1]);
2718   else
2719     latehalf[1] = operands[1];
2720
2721   /* If the first move would clobber the source of the second one,
2722      do them in the other order.
2723
2724      This can happen in two cases:
2725
2726         mem -> register where the first half of the destination register
2727         is the same register used in the memory's address.  Reload
2728         can create such insns.
2729
2730         mem in this case will be either register indirect or register
2731         indirect plus a valid offset.
2732
2733         register -> register move where REGNO(dst) == REGNO(src + 1)
2734         someone (Tim/Tege?) claimed this can happen for parameter loads.
2735
2736      Handle mem -> register case first.  */
2737   if (optype0 == REGOP
2738       && (optype1 == MEMOP || optype1 == OFFSOP)
2739       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2740                             operands[1], 0))
2741     {
2742       /* Do the late half first.  */
2743       if (addreg1)
2744         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2745       output_asm_insn (singlemove_string (latehalf), latehalf);
2746
2747       /* Then clobber.  */
2748       if (addreg1)
2749         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2750       return singlemove_string (operands);
2751     }
2752
2753   /* Now handle register -> register case.  */
2754   if (optype0 == REGOP && optype1 == REGOP
2755       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2756     {
2757       output_asm_insn (singlemove_string (latehalf), latehalf);
2758       return singlemove_string (operands);
2759     }
2760
2761   /* Normal case: do the two words, low-numbered first.  */
2762
2763   output_asm_insn (singlemove_string (operands), operands);
2764
2765   /* Make any unoffsettable addresses point at high-numbered word.  */
2766   if (addreg0)
2767     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2768   if (addreg1)
2769     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2770
2771   /* Do that word.  */
2772   output_asm_insn (singlemove_string (latehalf), latehalf);
2773
2774   /* Undo the adds we just did.  */
2775   if (addreg0)
2776     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2777   if (addreg1)
2778     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2779
2780   return "";
2781 }
2782 \f
2783 const char *
2784 output_fp_move_double (rtx *operands)
2785 {
2786   if (FP_REG_P (operands[0]))
2787     {
2788       if (FP_REG_P (operands[1])
2789           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2790         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2791       else
2792         output_asm_insn ("fldd%F1 %1,%0", operands);
2793     }
2794   else if (FP_REG_P (operands[1]))
2795     {
2796       output_asm_insn ("fstd%F0 %1,%0", operands);
2797     }
2798   else if (operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2799     {
2800       if (GET_CODE (operands[0]) == REG)
2801         {
2802           rtx xoperands[2];
2803           xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2804           xoperands[0] = operands[0];
2805           output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2806         }
2807       /* This is a pain.  You have to be prepared to deal with an
2808          arbitrary address here including pre/post increment/decrement.
2809
2810          so avoid this in the MD.  */
2811       else
2812         abort ();
2813     }
2814   else abort ();
2815   return "";
2816 }
2817 \f
2818 /* Return a REG that occurs in ADDR with coefficient 1.
2819    ADDR can be effectively incremented by incrementing REG.  */
2820
2821 static rtx
2822 find_addr_reg (rtx addr)
2823 {
2824   while (GET_CODE (addr) == PLUS)
2825     {
2826       if (GET_CODE (XEXP (addr, 0)) == REG)
2827         addr = XEXP (addr, 0);
2828       else if (GET_CODE (XEXP (addr, 1)) == REG)
2829         addr = XEXP (addr, 1);
2830       else if (CONSTANT_P (XEXP (addr, 0)))
2831         addr = XEXP (addr, 1);
2832       else if (CONSTANT_P (XEXP (addr, 1)))
2833         addr = XEXP (addr, 0);
2834       else
2835         abort ();
2836     }
2837   if (GET_CODE (addr) == REG)
2838     return addr;
2839   abort ();
2840 }
2841
2842 /* Emit code to perform a block move.
2843
2844    OPERANDS[0] is the destination pointer as a REG, clobbered.
2845    OPERANDS[1] is the source pointer as a REG, clobbered.
2846    OPERANDS[2] is a register for temporary storage.
2847    OPERANDS[3] is a register for temporary storage.
2848    OPERANDS[4] is the size as a CONST_INT
2849    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2850    OPERANDS[6] is another temporary register.  */
2851
2852 const char *
2853 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2854 {
2855   int align = INTVAL (operands[5]);
2856   unsigned long n_bytes = INTVAL (operands[4]);
2857
2858   /* We can't move more than a word at a time because the PA
2859      has no longer integer move insns.  (Could use fp mem ops?)  */
2860   if (align > (TARGET_64BIT ? 8 : 4))
2861     align = (TARGET_64BIT ? 8 : 4);
2862
2863   /* Note that we know each loop below will execute at least twice
2864      (else we would have open-coded the copy).  */
2865   switch (align)
2866     {
2867       case 8:
2868         /* Pre-adjust the loop counter.  */
2869         operands[4] = GEN_INT (n_bytes - 16);
2870         output_asm_insn ("ldi %4,%2", operands);
2871
2872         /* Copying loop.  */
2873         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2874         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2875         output_asm_insn ("std,ma %3,8(%0)", operands);
2876         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2877         output_asm_insn ("std,ma %6,8(%0)", operands);
2878
2879         /* Handle the residual.  There could be up to 7 bytes of
2880            residual to copy!  */
2881         if (n_bytes % 16 != 0)
2882           {
2883             operands[4] = GEN_INT (n_bytes % 8);
2884             if (n_bytes % 16 >= 8)
2885               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2886             if (n_bytes % 8 != 0)
2887               output_asm_insn ("ldd 0(%1),%6", operands);
2888             if (n_bytes % 16 >= 8)
2889               output_asm_insn ("std,ma %3,8(%0)", operands);
2890             if (n_bytes % 8 != 0)
2891               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2892           }
2893         return "";
2894
2895       case 4:
2896         /* Pre-adjust the loop counter.  */
2897         operands[4] = GEN_INT (n_bytes - 8);
2898         output_asm_insn ("ldi %4,%2", operands);
2899
2900         /* Copying loop.  */
2901         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2902         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2903         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2904         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2905         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2906
2907         /* Handle the residual.  There could be up to 7 bytes of
2908            residual to copy!  */
2909         if (n_bytes % 8 != 0)
2910           {
2911             operands[4] = GEN_INT (n_bytes % 4);
2912             if (n_bytes % 8 >= 4)
2913               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2914             if (n_bytes % 4 != 0)
2915               output_asm_insn ("ldw 0(%1),%6", operands);
2916             if (n_bytes % 8 >= 4)
2917               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2918             if (n_bytes % 4 != 0)
2919               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2920           }
2921         return "";
2922
2923       case 2:
2924         /* Pre-adjust the loop counter.  */
2925         operands[4] = GEN_INT (n_bytes - 4);
2926         output_asm_insn ("ldi %4,%2", operands);
2927
2928         /* Copying loop.  */
2929         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2930         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2931         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2932         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2933         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2934
2935         /* Handle the residual.  */
2936         if (n_bytes % 4 != 0)
2937           {
2938             if (n_bytes % 4 >= 2)
2939               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2940             if (n_bytes % 2 != 0)
2941               output_asm_insn ("ldb 0(%1),%6", operands);
2942             if (n_bytes % 4 >= 2)
2943               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2944             if (n_bytes % 2 != 0)
2945               output_asm_insn ("stb %6,0(%0)", operands);
2946           }
2947         return "";
2948
2949       case 1:
2950         /* Pre-adjust the loop counter.  */
2951         operands[4] = GEN_INT (n_bytes - 2);
2952         output_asm_insn ("ldi %4,%2", operands);
2953
2954         /* Copying loop.  */
2955         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2956         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2957         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2958         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2959         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2960
2961         /* Handle the residual.  */
2962         if (n_bytes % 2 != 0)
2963           {
2964             output_asm_insn ("ldb 0(%1),%3", operands);
2965             output_asm_insn ("stb %3,0(%0)", operands);
2966           }
2967         return "";
2968
2969       default:
2970         abort ();
2971     }
2972 }
2973
2974 /* Count the number of insns necessary to handle this block move.
2975
2976    Basic structure is the same as emit_block_move, except that we
2977    count insns rather than emit them.  */
2978
2979 static int
2980 compute_movmem_length (rtx insn)
2981 {
2982   rtx pat = PATTERN (insn);
2983   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2984   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2985   unsigned int n_insns = 0;
2986
2987   /* We can't move more than four bytes at a time because the PA
2988      has no longer integer move insns.  (Could use fp mem ops?)  */
2989   if (align > (TARGET_64BIT ? 8 : 4))
2990     align = (TARGET_64BIT ? 8 : 4);
2991
2992   /* The basic copying loop.  */
2993   n_insns = 6;
2994
2995   /* Residuals.  */
2996   if (n_bytes % (2 * align) != 0)
2997     {
2998       if ((n_bytes % (2 * align)) >= align)
2999         n_insns += 2;
3000
3001       if ((n_bytes % align) != 0)
3002         n_insns += 2;
3003     }
3004
3005   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
3006   return n_insns * 4;
3007 }
3008
3009 /* Emit code to perform a block clear.
3010
3011    OPERANDS[0] is the destination pointer as a REG, clobbered.
3012    OPERANDS[1] is a register for temporary storage.
3013    OPERANDS[2] is the size as a CONST_INT
3014    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
3015
3016 const char *
3017 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
3018 {
3019   int align = INTVAL (operands[3]);
3020   unsigned long n_bytes = INTVAL (operands[2]);
3021
3022   /* We can't clear more than a word at a time because the PA
3023      has no longer integer move insns.  */
3024   if (align > (TARGET_64BIT ? 8 : 4))
3025     align = (TARGET_64BIT ? 8 : 4);
3026
3027   /* Note that we know each loop below will execute at least twice
3028      (else we would have open-coded the copy).  */
3029   switch (align)
3030     {
3031       case 8:
3032         /* Pre-adjust the loop counter.  */
3033         operands[2] = GEN_INT (n_bytes - 16);
3034         output_asm_insn ("ldi %2,%1", operands);
3035
3036         /* Loop.  */
3037         output_asm_insn ("std,ma %%r0,8(%0)", operands);
3038         output_asm_insn ("addib,>= -16,%1,.-4", operands);
3039         output_asm_insn ("std,ma %%r0,8(%0)", operands);
3040
3041         /* Handle the residual.  There could be up to 7 bytes of
3042            residual to copy!  */
3043         if (n_bytes % 16 != 0)
3044           {
3045             operands[2] = GEN_INT (n_bytes % 8);
3046             if (n_bytes % 16 >= 8)
3047               output_asm_insn ("std,ma %%r0,8(%0)", operands);
3048             if (n_bytes % 8 != 0)
3049               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
3050           }
3051         return "";
3052
3053       case 4:
3054         /* Pre-adjust the loop counter.  */
3055         operands[2] = GEN_INT (n_bytes - 8);
3056         output_asm_insn ("ldi %2,%1", operands);
3057
3058         /* Loop.  */
3059         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3060         output_asm_insn ("addib,>= -8,%1,.-4", operands);
3061         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3062
3063         /* Handle the residual.  There could be up to 7 bytes of
3064            residual to copy!  */
3065         if (n_bytes % 8 != 0)
3066           {
3067             operands[2] = GEN_INT (n_bytes % 4);
3068             if (n_bytes % 8 >= 4)
3069               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
3070             if (n_bytes % 4 != 0)
3071               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
3072           }
3073         return "";
3074
3075       case 2:
3076         /* Pre-adjust the loop counter.  */
3077         operands[2] = GEN_INT (n_bytes - 4);
3078         output_asm_insn ("ldi %2,%1", operands);
3079
3080         /* Loop.  */
3081         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3082         output_asm_insn ("addib,>= -4,%1,.-4", operands);
3083         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3084
3085         /* Handle the residual.  */
3086         if (n_bytes % 4 != 0)
3087           {
3088             if (n_bytes % 4 >= 2)
3089               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
3090             if (n_bytes % 2 != 0)
3091               output_asm_insn ("stb %%r0,0(%0)", operands);
3092           }
3093         return "";
3094
3095       case 1:
3096         /* Pre-adjust the loop counter.  */
3097         operands[2] = GEN_INT (n_bytes - 2);
3098         output_asm_insn ("ldi %2,%1", operands);
3099
3100         /* Loop.  */
3101         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
3102         output_asm_insn ("addib,>= -2,%1,.-4", operands);
3103         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
3104
3105         /* Handle the residual.  */
3106         if (n_bytes % 2 != 0)
3107           output_asm_insn ("stb %%r0,0(%0)", operands);
3108
3109         return "";
3110
3111       default:
3112         abort ();
3113     }
3114 }
3115
3116 /* Count the number of insns necessary to handle this block move.
3117
3118    Basic structure is the same as emit_block_move, except that we
3119    count insns rather than emit them.  */
3120
3121 static int
3122 compute_clrmem_length (rtx insn)
3123 {
3124   rtx pat = PATTERN (insn);
3125   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
3126   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
3127   unsigned int n_insns = 0;
3128
3129   /* We can't clear more than a word at a time because the PA
3130      has no longer integer move insns.  */
3131   if (align > (TARGET_64BIT ? 8 : 4))
3132     align = (TARGET_64BIT ? 8 : 4);
3133
3134   /* The basic loop.  */
3135   n_insns = 4;
3136
3137   /* Residuals.  */
3138   if (n_bytes % (2 * align) != 0)
3139     {
3140       if ((n_bytes % (2 * align)) >= align)
3141         n_insns++;
3142
3143       if ((n_bytes % align) != 0)
3144         n_insns++;
3145     }
3146
3147   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
3148   return n_insns * 4;
3149 }
3150 \f
3151
3152 const char *
3153 output_and (rtx *operands)
3154 {
3155   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
3156     {
3157       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3158       int ls0, ls1, ms0, p, len;
3159
3160       for (ls0 = 0; ls0 < 32; ls0++)
3161         if ((mask & (1 << ls0)) == 0)
3162           break;
3163
3164       for (ls1 = ls0; ls1 < 32; ls1++)
3165         if ((mask & (1 << ls1)) != 0)
3166           break;
3167
3168       for (ms0 = ls1; ms0 < 32; ms0++)
3169         if ((mask & (1 << ms0)) == 0)
3170           break;
3171
3172       if (ms0 != 32)
3173         abort ();
3174
3175       if (ls1 == 32)
3176         {
3177           len = ls0;
3178
3179           if (len == 0)
3180             abort ();
3181
3182           operands[2] = GEN_INT (len);
3183           return "{extru|extrw,u} %1,31,%2,%0";
3184         }
3185       else
3186         {
3187           /* We could use this `depi' for the case above as well, but `depi'
3188              requires one more register file access than an `extru'.  */
3189
3190           p = 31 - ls0;
3191           len = ls1 - ls0;
3192
3193           operands[2] = GEN_INT (p);
3194           operands[3] = GEN_INT (len);
3195           return "{depi|depwi} 0,%2,%3,%0";
3196         }
3197     }
3198   else
3199     return "and %1,%2,%0";
3200 }
3201
3202 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
3203    storing the result in operands[0].  */
3204 const char *
3205 output_64bit_and (rtx *operands)
3206 {
3207   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
3208     {
3209       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3210       int ls0, ls1, ms0, p, len;
3211
3212       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
3213         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
3214           break;
3215
3216       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
3217         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
3218           break;
3219
3220       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
3221         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
3222           break;
3223
3224       if (ms0 != HOST_BITS_PER_WIDE_INT)
3225         abort ();
3226
3227       if (ls1 == HOST_BITS_PER_WIDE_INT)
3228         {
3229           len = ls0;
3230
3231           if (len == 0)
3232             abort ();
3233
3234           operands[2] = GEN_INT (len);
3235           return "extrd,u %1,63,%2,%0";
3236         }
3237       else
3238         {
3239           /* We could use this `depi' for the case above as well, but `depi'
3240              requires one more register file access than an `extru'.  */
3241
3242           p = 63 - ls0;
3243           len = ls1 - ls0;
3244
3245           operands[2] = GEN_INT (p);
3246           operands[3] = GEN_INT (len);
3247           return "depdi 0,%2,%3,%0";
3248         }
3249     }
3250   else
3251     return "and %1,%2,%0";
3252 }
3253
3254 const char *
3255 output_ior (rtx *operands)
3256 {
3257   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3258   int bs0, bs1, p, len;
3259
3260   if (INTVAL (operands[2]) == 0)
3261     return "copy %1,%0";
3262
3263   for (bs0 = 0; bs0 < 32; bs0++)
3264     if ((mask & (1 << bs0)) != 0)
3265       break;
3266
3267   for (bs1 = bs0; bs1 < 32; bs1++)
3268     if ((mask & (1 << bs1)) == 0)
3269       break;
3270
3271   if (bs1 != 32 && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
3272     abort ();
3273
3274   p = 31 - bs0;
3275   len = bs1 - bs0;
3276
3277   operands[2] = GEN_INT (p);
3278   operands[3] = GEN_INT (len);
3279   return "{depi|depwi} -1,%2,%3,%0";
3280 }
3281
3282 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
3283    storing the result in operands[0].  */
3284 const char *
3285 output_64bit_ior (rtx *operands)
3286 {
3287   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3288   int bs0, bs1, p, len;
3289
3290   if (INTVAL (operands[2]) == 0)
3291     return "copy %1,%0";
3292
3293   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
3294     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
3295       break;
3296
3297   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
3298     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
3299       break;
3300
3301   if (bs1 != HOST_BITS_PER_WIDE_INT
3302       && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
3303     abort ();
3304
3305   p = 63 - bs0;
3306   len = bs1 - bs0;
3307
3308   operands[2] = GEN_INT (p);
3309   operands[3] = GEN_INT (len);
3310   return "depdi -1,%2,%3,%0";
3311 }
3312 \f
3313 /* Target hook for assembling integer objects.  This code handles
3314    aligned SI and DI integers specially, since function references must
3315    be preceded by P%.  */
3316
3317 static bool
3318 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
3319 {
3320   if (size == UNITS_PER_WORD && aligned_p
3321       && function_label_operand (x, VOIDmode))
3322     {
3323       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
3324       output_addr_const (asm_out_file, x);
3325       fputc ('\n', asm_out_file);
3326       return true;
3327     }
3328   return default_assemble_integer (x, size, aligned_p);
3329 }
3330 \f
3331 /* Output an ascii string.  */
3332 void
3333 output_ascii (FILE *file, const char *p, int size)
3334 {
3335   int i;
3336   int chars_output;
3337   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
3338
3339   /* The HP assembler can only take strings of 256 characters at one
3340      time.  This is a limitation on input line length, *not* the
3341      length of the string.  Sigh.  Even worse, it seems that the
3342      restriction is in number of input characters (see \xnn &
3343      \whatever).  So we have to do this very carefully.  */
3344
3345   fputs ("\t.STRING \"", file);
3346
3347   chars_output = 0;
3348   for (i = 0; i < size; i += 4)
3349     {
3350       int co = 0;
3351       int io = 0;
3352       for (io = 0, co = 0; io < MIN (4, size - i); io++)
3353         {
3354           register unsigned int c = (unsigned char) p[i + io];
3355
3356           if (c == '\"' || c == '\\')
3357             partial_output[co++] = '\\';
3358           if (c >= ' ' && c < 0177)
3359             partial_output[co++] = c;
3360           else
3361             {
3362               unsigned int hexd;
3363               partial_output[co++] = '\\';
3364               partial_output[co++] = 'x';
3365               hexd =  c  / 16 - 0 + '0';
3366               if (hexd > '9')
3367                 hexd -= '9' - 'a' + 1;
3368               partial_output[co++] = hexd;
3369               hexd =  c % 16 - 0 + '0';
3370               if (hexd > '9')
3371                 hexd -= '9' - 'a' + 1;
3372               partial_output[co++] = hexd;
3373             }
3374         }
3375       if (chars_output + co > 243)
3376         {
3377           fputs ("\"\n\t.STRING \"", file);
3378           chars_output = 0;
3379         }
3380       fwrite (partial_output, 1, (size_t) co, file);
3381       chars_output += co;
3382       co = 0;
3383     }
3384   fputs ("\"\n", file);
3385 }
3386
3387 /* Try to rewrite floating point comparisons & branches to avoid
3388    useless add,tr insns.
3389
3390    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3391    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3392    first attempt to remove useless add,tr insns.  It is zero
3393    for the second pass as reorg sometimes leaves bogus REG_DEAD
3394    notes lying around.
3395
3396    When CHECK_NOTES is zero we can only eliminate add,tr insns
3397    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3398    instructions.  */
3399 static void
3400 remove_useless_addtr_insns (int check_notes)
3401 {
3402   rtx insn;
3403   static int pass = 0;
3404
3405   /* This is fairly cheap, so always run it when optimizing.  */
3406   if (optimize > 0)
3407     {
3408       int fcmp_count = 0;
3409       int fbranch_count = 0;
3410
3411       /* Walk all the insns in this function looking for fcmp & fbranch
3412          instructions.  Keep track of how many of each we find.  */
3413       for (insn = get_insns (); insn; insn = next_insn (insn))
3414         {
3415           rtx tmp;
3416
3417           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3418           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3419             continue;
3420
3421           tmp = PATTERN (insn);
3422
3423           /* It must be a set.  */
3424           if (GET_CODE (tmp) != SET)
3425  &nb