OSDN Git Service

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