OSDN Git Service

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