OSDN Git Service

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