OSDN Git Service

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