OSDN Git Service

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