OSDN Git Service

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