OSDN Git Service

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