OSDN Git Service

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