OSDN Git Service

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