OSDN Git Service

960814f65d776595318849f8410ed9abacaf2076
[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, 2008 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, bool);
90 static bool hppa_rtx_costs (rtx, int, int, int *, bool);
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, gimple_seq *, gimple_seq *);
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_CNEW (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           add_reg_note (insn, REG_LABEL_OPERAND, orig);
698           LABEL_NUSES (orig)++;
699         }
700       crtl->uses_pic_offset_table = 1;
701       return reg;
702     }
703   if (GET_CODE (orig) == SYMBOL_REF)
704     {
705       rtx insn, tmp_reg;
706
707       gcc_assert (reg);
708
709       /* Before reload, allocate a temporary register for the intermediate
710          result.  This allows the sequence to be deleted when the final
711          result is unused and the insns are trivially dead.  */
712       tmp_reg = ((reload_in_progress || reload_completed)
713                  ? reg : gen_reg_rtx (Pmode));
714
715       if (function_label_operand (orig, mode))
716         {
717           /* Force function label into memory in word mode.  */
718           orig = XEXP (force_const_mem (word_mode, orig), 0);
719           /* Load plabel address from DLT.  */
720           emit_move_insn (tmp_reg,
721                           gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
722                                         gen_rtx_HIGH (word_mode, orig)));
723           pic_ref
724             = gen_const_mem (Pmode,
725                              gen_rtx_LO_SUM (Pmode, tmp_reg,
726                                              gen_rtx_UNSPEC (Pmode,
727                                                          gen_rtvec (1, orig),
728                                                          UNSPEC_DLTIND14R)));
729           emit_move_insn (reg, pic_ref);
730           /* Now load address of function descriptor.  */
731           pic_ref = gen_rtx_MEM (Pmode, reg);
732         }
733       else
734         {
735           /* Load symbol reference from DLT.  */
736           emit_move_insn (tmp_reg,
737                           gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
738                                         gen_rtx_HIGH (word_mode, orig)));
739           pic_ref
740             = gen_const_mem (Pmode,
741                              gen_rtx_LO_SUM (Pmode, tmp_reg,
742                                              gen_rtx_UNSPEC (Pmode,
743                                                          gen_rtvec (1, orig),
744                                                          UNSPEC_DLTIND14R)));
745         }
746
747       crtl->uses_pic_offset_table = 1;
748       mark_reg_pointer (reg, BITS_PER_UNIT);
749       insn = emit_move_insn (reg, pic_ref);
750
751       /* Put a REG_EQUAL note on this insn, so that it can be optimized.  */
752       set_unique_reg_note (insn, REG_EQUAL, orig);
753
754       return reg;
755     }
756   else if (GET_CODE (orig) == CONST)
757     {
758       rtx base;
759
760       if (GET_CODE (XEXP (orig, 0)) == PLUS
761           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
762         return orig;
763
764       gcc_assert (reg);
765       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
766       
767       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
768       orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
769                                      base == reg ? 0 : reg);
770
771       if (GET_CODE (orig) == CONST_INT)
772         {
773           if (INT_14_BITS (orig))
774             return plus_constant (base, INTVAL (orig));
775           orig = force_reg (Pmode, orig);
776         }
777       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
778       /* Likewise, should we set special REG_NOTEs here?  */
779     }
780
781   return pic_ref;
782 }
783
784 static GTY(()) rtx gen_tls_tga;
785
786 static rtx
787 gen_tls_get_addr (void)
788 {
789   if (!gen_tls_tga)
790     gen_tls_tga = init_one_libfunc ("__tls_get_addr");
791   return gen_tls_tga;
792 }
793
794 static rtx
795 hppa_tls_call (rtx arg)
796 {
797   rtx ret;
798
799   ret = gen_reg_rtx (Pmode);
800   emit_library_call_value (gen_tls_get_addr (), ret,
801                            LCT_CONST, Pmode, 1, arg, Pmode);
802
803   return ret;
804 }
805
806 static rtx
807 legitimize_tls_address (rtx addr)
808 {
809   rtx ret, insn, tmp, t1, t2, tp;
810   enum tls_model model = SYMBOL_REF_TLS_MODEL (addr);
811
812   switch (model) 
813     {
814       case TLS_MODEL_GLOBAL_DYNAMIC:
815         tmp = gen_reg_rtx (Pmode);
816         if (flag_pic)
817           emit_insn (gen_tgd_load_pic (tmp, addr));
818         else
819           emit_insn (gen_tgd_load (tmp, addr));
820         ret = hppa_tls_call (tmp);
821         break;
822
823       case TLS_MODEL_LOCAL_DYNAMIC:
824         ret = gen_reg_rtx (Pmode);
825         tmp = gen_reg_rtx (Pmode);
826         start_sequence ();
827         if (flag_pic)
828           emit_insn (gen_tld_load_pic (tmp, addr));
829         else
830           emit_insn (gen_tld_load (tmp, addr));
831         t1 = hppa_tls_call (tmp);
832         insn = get_insns ();
833         end_sequence ();
834         t2 = gen_reg_rtx (Pmode);
835         emit_libcall_block (insn, t2, t1, 
836                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
837                                             UNSPEC_TLSLDBASE));
838         emit_insn (gen_tld_offset_load (ret, addr, t2));
839         break;
840
841       case TLS_MODEL_INITIAL_EXEC:
842         tp = gen_reg_rtx (Pmode);
843         tmp = gen_reg_rtx (Pmode);
844         ret = gen_reg_rtx (Pmode);
845         emit_insn (gen_tp_load (tp));
846         if (flag_pic)
847           emit_insn (gen_tie_load_pic (tmp, addr));
848         else
849           emit_insn (gen_tie_load (tmp, addr));
850         emit_move_insn (ret, gen_rtx_PLUS (Pmode, tp, tmp));
851         break;
852
853       case TLS_MODEL_LOCAL_EXEC:
854         tp = gen_reg_rtx (Pmode);
855         ret = gen_reg_rtx (Pmode);
856         emit_insn (gen_tp_load (tp));
857         emit_insn (gen_tle_load (ret, addr, tp));
858         break;
859
860       default:
861         gcc_unreachable ();
862     }
863
864   return ret;
865 }
866
867 /* Try machine-dependent ways of modifying an illegitimate address
868    to be legitimate.  If we find one, return the new, valid address.
869    This macro is used in only one place: `memory_address' in explow.c.
870
871    OLDX is the address as it was before break_out_memory_refs was called.
872    In some cases it is useful to look at this to decide what needs to be done.
873
874    MODE and WIN are passed so that this macro can use
875    GO_IF_LEGITIMATE_ADDRESS.
876
877    It is always safe for this macro to do nothing.  It exists to recognize
878    opportunities to optimize the output.
879
880    For the PA, transform:
881
882         memory(X + <large int>)
883
884    into:
885
886         if (<large int> & mask) >= 16
887           Y = (<large int> & ~mask) + mask + 1  Round up.
888         else
889           Y = (<large int> & ~mask)             Round down.
890         Z = X + Y
891         memory (Z + (<large int> - Y));
892
893    This is for CSE to find several similar references, and only use one Z.
894
895    X can either be a SYMBOL_REF or REG, but because combine cannot
896    perform a 4->2 combination we do nothing for SYMBOL_REF + D where
897    D will not fit in 14 bits.
898
899    MODE_FLOAT references allow displacements which fit in 5 bits, so use
900    0x1f as the mask.
901
902    MODE_INT references allow displacements which fit in 14 bits, so use
903    0x3fff as the mask.
904
905    This relies on the fact that most mode MODE_FLOAT references will use FP
906    registers and most mode MODE_INT references will use integer registers.
907    (In the rare case of an FP register used in an integer MODE, we depend
908    on secondary reloads to clean things up.)
909
910
911    It is also beneficial to handle (plus (mult (X) (Y)) (Z)) in a special
912    manner if Y is 2, 4, or 8.  (allows more shadd insns and shifted indexed
913    addressing modes to be used).
914
915    Put X and Z into registers.  Then put the entire expression into
916    a register.  */
917
918 rtx
919 hppa_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
920                          enum machine_mode mode)
921 {
922   rtx orig = x;
923
924   /* We need to canonicalize the order of operands in unscaled indexed
925      addresses since the code that checks if an address is valid doesn't
926      always try both orders.  */
927   if (!TARGET_NO_SPACE_REGS
928       && GET_CODE (x) == PLUS
929       && GET_MODE (x) == Pmode
930       && REG_P (XEXP (x, 0))
931       && REG_P (XEXP (x, 1))
932       && REG_POINTER (XEXP (x, 0))
933       && !REG_POINTER (XEXP (x, 1)))
934     return gen_rtx_PLUS (Pmode, XEXP (x, 1), XEXP (x, 0));
935
936   if (PA_SYMBOL_REF_TLS_P (x))
937     return legitimize_tls_address (x);
938   else if (flag_pic)
939     return legitimize_pic_address (x, mode, gen_reg_rtx (Pmode));
940
941   /* Strip off CONST.  */
942   if (GET_CODE (x) == CONST)
943     x = XEXP (x, 0);
944
945   /* Special case.  Get the SYMBOL_REF into a register and use indexing.
946      That should always be safe.  */
947   if (GET_CODE (x) == PLUS
948       && GET_CODE (XEXP (x, 0)) == REG
949       && GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
950     {
951       rtx reg = force_reg (Pmode, XEXP (x, 1));
952       return force_reg (Pmode, gen_rtx_PLUS (Pmode, reg, XEXP (x, 0)));
953     }
954
955   /* Note we must reject symbols which represent function addresses
956      since the assembler/linker can't handle arithmetic on plabels.  */
957   if (GET_CODE (x) == PLUS
958       && GET_CODE (XEXP (x, 1)) == CONST_INT
959       && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF
960            && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0)))
961           || GET_CODE (XEXP (x, 0)) == REG))
962     {
963       rtx int_part, ptr_reg;
964       int newoffset;
965       int offset = INTVAL (XEXP (x, 1));
966       int mask;
967
968       mask = (GET_MODE_CLASS (mode) == MODE_FLOAT
969               ? (INT14_OK_STRICT ? 0x3fff : 0x1f) : 0x3fff);
970
971       /* Choose which way to round the offset.  Round up if we
972          are >= halfway to the next boundary.  */
973       if ((offset & mask) >= ((mask + 1) / 2))
974         newoffset = (offset & ~ mask) + mask + 1;
975       else
976         newoffset = (offset & ~ mask);
977
978       /* If the newoffset will not fit in 14 bits (ldo), then
979          handling this would take 4 or 5 instructions (2 to load
980          the SYMBOL_REF + 1 or 2 to load the newoffset + 1 to
981          add the new offset and the SYMBOL_REF.)  Combine can
982          not handle 4->2 or 5->2 combinations, so do not create
983          them.  */
984       if (! VAL_14_BITS_P (newoffset)
985           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
986         {
987           rtx const_part = plus_constant (XEXP (x, 0), newoffset);
988           rtx tmp_reg
989             = force_reg (Pmode,
990                          gen_rtx_HIGH (Pmode, const_part));
991           ptr_reg
992             = force_reg (Pmode,
993                          gen_rtx_LO_SUM (Pmode,
994                                          tmp_reg, const_part));
995         }
996       else
997         {
998           if (! VAL_14_BITS_P (newoffset))
999             int_part = force_reg (Pmode, GEN_INT (newoffset));
1000           else
1001             int_part = GEN_INT (newoffset);
1002
1003           ptr_reg = force_reg (Pmode,
1004                                gen_rtx_PLUS (Pmode,
1005                                              force_reg (Pmode, XEXP (x, 0)),
1006                                              int_part));
1007         }
1008       return plus_constant (ptr_reg, offset - newoffset);
1009     }
1010
1011   /* Handle (plus (mult (a) (shadd_constant)) (b)).  */
1012
1013   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
1014       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1015       && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1)))
1016       && (OBJECT_P (XEXP (x, 1))
1017           || GET_CODE (XEXP (x, 1)) == SUBREG)
1018       && GET_CODE (XEXP (x, 1)) != CONST)
1019     {
1020       int val = INTVAL (XEXP (XEXP (x, 0), 1));
1021       rtx reg1, reg2;
1022
1023       reg1 = XEXP (x, 1);
1024       if (GET_CODE (reg1) != REG)
1025         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1026
1027       reg2 = XEXP (XEXP (x, 0), 0);
1028       if (GET_CODE (reg2) != REG)
1029         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1030
1031       return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1032                                              gen_rtx_MULT (Pmode,
1033                                                            reg2,
1034                                                            GEN_INT (val)),
1035                                              reg1));
1036     }
1037
1038   /* Similarly for (plus (plus (mult (a) (shadd_constant)) (b)) (c)).
1039
1040      Only do so for floating point modes since this is more speculative
1041      and we lose if it's an integer store.  */
1042   if (GET_CODE (x) == PLUS
1043       && GET_CODE (XEXP (x, 0)) == PLUS
1044       && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
1045       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
1046       && shadd_constant_p (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)))
1047       && (mode == SFmode || mode == DFmode))
1048     {
1049
1050       /* First, try and figure out what to use as a base register.  */
1051       rtx reg1, reg2, base, idx, orig_base;
1052
1053       reg1 = XEXP (XEXP (x, 0), 1);
1054       reg2 = XEXP (x, 1);
1055       base = NULL_RTX;
1056       idx = NULL_RTX;
1057
1058       /* Make sure they're both regs.  If one was a SYMBOL_REF [+ const],
1059          then emit_move_sequence will turn on REG_POINTER so we'll know
1060          it's a base register below.  */
1061       if (GET_CODE (reg1) != REG)
1062         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1063
1064       if (GET_CODE (reg2) != REG)
1065         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1066
1067       /* Figure out what the base and index are.  */
1068
1069       if (GET_CODE (reg1) == REG
1070           && REG_POINTER (reg1))
1071         {
1072           base = reg1;
1073           orig_base = XEXP (XEXP (x, 0), 1);
1074           idx = gen_rtx_PLUS (Pmode,
1075                               gen_rtx_MULT (Pmode,
1076                                             XEXP (XEXP (XEXP (x, 0), 0), 0),
1077                                             XEXP (XEXP (XEXP (x, 0), 0), 1)),
1078                               XEXP (x, 1));
1079         }
1080       else if (GET_CODE (reg2) == REG
1081                && REG_POINTER (reg2))
1082         {
1083           base = reg2;
1084           orig_base = XEXP (x, 1);
1085           idx = XEXP (x, 0);
1086         }
1087
1088       if (base == 0)
1089         return orig;
1090
1091       /* If the index adds a large constant, try to scale the
1092          constant so that it can be loaded with only one insn.  */
1093       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1094           && VAL_14_BITS_P (INTVAL (XEXP (idx, 1))
1095                             / INTVAL (XEXP (XEXP (idx, 0), 1)))
1096           && INTVAL (XEXP (idx, 1)) % INTVAL (XEXP (XEXP (idx, 0), 1)) == 0)
1097         {
1098           /* Divide the CONST_INT by the scale factor, then add it to A.  */
1099           int val = INTVAL (XEXP (idx, 1));
1100
1101           val /= INTVAL (XEXP (XEXP (idx, 0), 1));
1102           reg1 = XEXP (XEXP (idx, 0), 0);
1103           if (GET_CODE (reg1) != REG)
1104             reg1 = force_reg (Pmode, force_operand (reg1, 0));
1105
1106           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
1107
1108           /* We can now generate a simple scaled indexed address.  */
1109           return
1110             force_reg
1111               (Pmode, gen_rtx_PLUS (Pmode,
1112                                     gen_rtx_MULT (Pmode, reg1,
1113                                                   XEXP (XEXP (idx, 0), 1)),
1114                                     base));
1115         }
1116
1117       /* If B + C is still a valid base register, then add them.  */
1118       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1119           && INTVAL (XEXP (idx, 1)) <= 4096
1120           && INTVAL (XEXP (idx, 1)) >= -4096)
1121         {
1122           int val = INTVAL (XEXP (XEXP (idx, 0), 1));
1123           rtx reg1, reg2;
1124
1125           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, XEXP (idx, 1)));
1126
1127           reg2 = XEXP (XEXP (idx, 0), 0);
1128           if (GET_CODE (reg2) != CONST_INT)
1129             reg2 = force_reg (Pmode, force_operand (reg2, 0));
1130
1131           return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1132                                                  gen_rtx_MULT (Pmode,
1133                                                                reg2,
1134                                                                GEN_INT (val)),
1135                                                  reg1));
1136         }
1137
1138       /* Get the index into a register, then add the base + index and
1139          return a register holding the result.  */
1140
1141       /* First get A into a register.  */
1142       reg1 = XEXP (XEXP (idx, 0), 0);
1143       if (GET_CODE (reg1) != REG)
1144         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1145
1146       /* And get B into a register.  */
1147       reg2 = XEXP (idx, 1);
1148       if (GET_CODE (reg2) != REG)
1149         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1150
1151       reg1 = force_reg (Pmode,
1152                         gen_rtx_PLUS (Pmode,
1153                                       gen_rtx_MULT (Pmode, reg1,
1154                                                     XEXP (XEXP (idx, 0), 1)),
1155                                       reg2));
1156
1157       /* Add the result to our base register and return.  */
1158       return force_reg (Pmode, gen_rtx_PLUS (Pmode, base, reg1));
1159
1160     }
1161
1162   /* Uh-oh.  We might have an address for x[n-100000].  This needs
1163      special handling to avoid creating an indexed memory address
1164      with x-100000 as the base.
1165
1166      If the constant part is small enough, then it's still safe because
1167      there is a guard page at the beginning and end of the data segment.
1168
1169      Scaled references are common enough that we want to try and rearrange the
1170      terms so that we can use indexing for these addresses too.  Only
1171      do the optimization for floatint point modes.  */
1172
1173   if (GET_CODE (x) == PLUS
1174       && symbolic_expression_p (XEXP (x, 1)))
1175     {
1176       /* Ugly.  We modify things here so that the address offset specified
1177          by the index expression is computed first, then added to x to form
1178          the entire address.  */
1179
1180       rtx regx1, regx2, regy1, regy2, y;
1181
1182       /* Strip off any CONST.  */
1183       y = XEXP (x, 1);
1184       if (GET_CODE (y) == CONST)
1185         y = XEXP (y, 0);
1186
1187       if (GET_CODE (y) == PLUS || GET_CODE (y) == MINUS)
1188         {
1189           /* See if this looks like
1190                 (plus (mult (reg) (shadd_const))
1191                       (const (plus (symbol_ref) (const_int))))
1192
1193              Where const_int is small.  In that case the const
1194              expression is a valid pointer for indexing.
1195
1196              If const_int is big, but can be divided evenly by shadd_const
1197              and added to (reg).  This allows more scaled indexed addresses.  */
1198           if (GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1199               && GET_CODE (XEXP (x, 0)) == MULT
1200               && GET_CODE (XEXP (y, 1)) == CONST_INT
1201               && INTVAL (XEXP (y, 1)) >= -4096
1202               && INTVAL (XEXP (y, 1)) <= 4095
1203               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1204               && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1205             {
1206               int val = INTVAL (XEXP (XEXP (x, 0), 1));
1207               rtx reg1, reg2;
1208
1209               reg1 = XEXP (x, 1);
1210               if (GET_CODE (reg1) != REG)
1211                 reg1 = force_reg (Pmode, force_operand (reg1, 0));
1212
1213               reg2 = XEXP (XEXP (x, 0), 0);
1214               if (GET_CODE (reg2) != REG)
1215                 reg2 = force_reg (Pmode, force_operand (reg2, 0));
1216
1217               return force_reg (Pmode,
1218                                 gen_rtx_PLUS (Pmode,
1219                                               gen_rtx_MULT (Pmode,
1220                                                             reg2,
1221                                                             GEN_INT (val)),
1222                                               reg1));
1223             }
1224           else if ((mode == DFmode || mode == SFmode)
1225                    && GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1226                    && GET_CODE (XEXP (x, 0)) == MULT
1227                    && GET_CODE (XEXP (y, 1)) == CONST_INT
1228                    && INTVAL (XEXP (y, 1)) % INTVAL (XEXP (XEXP (x, 0), 1)) == 0
1229                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1230                    && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1231             {
1232               regx1
1233                 = force_reg (Pmode, GEN_INT (INTVAL (XEXP (y, 1))
1234                                              / INTVAL (XEXP (XEXP (x, 0), 1))));
1235               regx2 = XEXP (XEXP (x, 0), 0);
1236               if (GET_CODE (regx2) != REG)
1237                 regx2 = force_reg (Pmode, force_operand (regx2, 0));
1238               regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1239                                                         regx2, regx1));
1240               return
1241                 force_reg (Pmode,
1242                            gen_rtx_PLUS (Pmode,
1243                                          gen_rtx_MULT (Pmode, regx2,
1244                                                        XEXP (XEXP (x, 0), 1)),
1245                                          force_reg (Pmode, XEXP (y, 0))));
1246             }
1247           else if (GET_CODE (XEXP (y, 1)) == CONST_INT
1248                    && INTVAL (XEXP (y, 1)) >= -4096
1249                    && INTVAL (XEXP (y, 1)) <= 4095)
1250             {
1251               /* This is safe because of the guard page at the
1252                  beginning and end of the data space.  Just
1253                  return the original address.  */
1254               return orig;
1255             }
1256           else
1257             {
1258               /* Doesn't look like one we can optimize.  */
1259               regx1 = force_reg (Pmode, force_operand (XEXP (x, 0), 0));
1260               regy1 = force_reg (Pmode, force_operand (XEXP (y, 0), 0));
1261               regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
1262               regx1 = force_reg (Pmode,
1263                                  gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1264                                                  regx1, regy2));
1265               return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
1266             }
1267         }
1268     }
1269
1270   return orig;
1271 }
1272
1273 /* For the HPPA, REG and REG+CONST is cost 0
1274    and addresses involving symbolic constants are cost 2.
1275
1276    PIC addresses are very expensive.
1277
1278    It is no coincidence that this has the same structure
1279    as GO_IF_LEGITIMATE_ADDRESS.  */
1280
1281 static int
1282 hppa_address_cost (rtx X,
1283                    bool speed ATTRIBUTE_UNUSED)
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                 bool speed ATTRIBUTE_UNUSED)
1305 {
1306   switch (code)
1307     {
1308     case CONST_INT:
1309       if (INTVAL (x) == 0)
1310         *total = 0;
1311       else if (INT_14_BITS (x))
1312         *total = 1;
1313       else
1314         *total = 2;
1315       return true;
1316
1317     case HIGH:
1318       *total = 2;
1319       return true;
1320
1321     case CONST:
1322     case LABEL_REF:
1323     case SYMBOL_REF:
1324       *total = 4;
1325       return true;
1326
1327     case CONST_DOUBLE:
1328       if ((x == CONST0_RTX (DFmode) || x == CONST0_RTX (SFmode))
1329           && outer_code != SET)
1330         *total = 0;
1331       else
1332         *total = 8;
1333       return true;
1334
1335     case MULT:
1336       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1337         *total = COSTS_N_INSNS (3);
1338       else if (TARGET_PA_11 && !TARGET_DISABLE_FPREGS && !TARGET_SOFT_FLOAT)
1339         *total = COSTS_N_INSNS (8);
1340       else
1341         *total = COSTS_N_INSNS (20);
1342       return true;
1343
1344     case DIV:
1345       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1346         {
1347           *total = COSTS_N_INSNS (14);
1348           return true;
1349         }
1350       /* FALLTHRU */
1351
1352     case UDIV:
1353     case MOD:
1354     case UMOD:
1355       *total = COSTS_N_INSNS (60);
1356       return true;
1357
1358     case PLUS: /* this includes shNadd insns */
1359     case MINUS:
1360       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1361         *total = COSTS_N_INSNS (3);
1362       else
1363         *total = COSTS_N_INSNS (1);
1364       return true;
1365
1366     case ASHIFT:
1367     case ASHIFTRT:
1368     case LSHIFTRT:
1369       *total = COSTS_N_INSNS (1);
1370       return true;
1371
1372     default:
1373       return false;
1374     }
1375 }
1376
1377 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
1378    new rtx with the correct mode.  */
1379 static inline rtx
1380 force_mode (enum machine_mode mode, rtx orig)
1381 {
1382   if (mode == GET_MODE (orig))
1383     return orig;
1384
1385   gcc_assert (REGNO (orig) < FIRST_PSEUDO_REGISTER);
1386
1387   return gen_rtx_REG (mode, REGNO (orig));
1388 }
1389
1390 /* Return 1 if *X is a thread-local symbol.  */
1391
1392 static int
1393 pa_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1394 {
1395   return PA_SYMBOL_REF_TLS_P (*x);
1396 }
1397
1398 /* Return 1 if X contains a thread-local symbol.  */
1399
1400 bool
1401 pa_tls_referenced_p (rtx x)
1402 {
1403   if (!TARGET_HAVE_TLS)
1404     return false;
1405
1406   return for_each_rtx (&x, &pa_tls_symbol_ref_1, 0);
1407 }
1408
1409 /* Emit insns to move operands[1] into operands[0].
1410
1411    Return 1 if we have written out everything that needs to be done to
1412    do the move.  Otherwise, return 0 and the caller will emit the move
1413    normally.
1414
1415    Note SCRATCH_REG may not be in the proper mode depending on how it
1416    will be used.  This routine is responsible for creating a new copy
1417    of SCRATCH_REG in the proper mode.  */
1418
1419 int
1420 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
1421 {
1422   register rtx operand0 = operands[0];
1423   register rtx operand1 = operands[1];
1424   register rtx tem;
1425
1426   /* We can only handle indexed addresses in the destination operand
1427      of floating point stores.  Thus, we need to break out indexed
1428      addresses from the destination operand.  */
1429   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
1430     {
1431       gcc_assert (can_create_pseudo_p ());
1432
1433       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
1434       operand0 = replace_equiv_address (operand0, tem);
1435     }
1436
1437   /* On targets with non-equivalent space registers, break out unscaled
1438      indexed addresses from the source operand before the final CSE.
1439      We have to do this because the REG_POINTER flag is not correctly
1440      carried through various optimization passes and CSE may substitute
1441      a pseudo without the pointer set for one with the pointer set.  As
1442      a result, we loose various opportunities to create insns with
1443      unscaled indexed addresses.  */
1444   if (!TARGET_NO_SPACE_REGS
1445       && !cse_not_expected
1446       && GET_CODE (operand1) == MEM
1447       && GET_CODE (XEXP (operand1, 0)) == PLUS
1448       && REG_P (XEXP (XEXP (operand1, 0), 0))
1449       && REG_P (XEXP (XEXP (operand1, 0), 1)))
1450     operand1
1451       = replace_equiv_address (operand1,
1452                                copy_to_mode_reg (Pmode, XEXP (operand1, 0)));
1453
1454   if (scratch_reg
1455       && reload_in_progress && GET_CODE (operand0) == REG
1456       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1457     operand0 = reg_equiv_mem[REGNO (operand0)];
1458   else if (scratch_reg
1459            && reload_in_progress && GET_CODE (operand0) == SUBREG
1460            && GET_CODE (SUBREG_REG (operand0)) == REG
1461            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
1462     {
1463      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1464         the code which tracks sets/uses for delete_output_reload.  */
1465       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
1466                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
1467                                  SUBREG_BYTE (operand0));
1468       operand0 = alter_subreg (&temp);
1469     }
1470
1471   if (scratch_reg
1472       && reload_in_progress && GET_CODE (operand1) == REG
1473       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
1474     operand1 = reg_equiv_mem[REGNO (operand1)];
1475   else if (scratch_reg
1476            && reload_in_progress && GET_CODE (operand1) == SUBREG
1477            && GET_CODE (SUBREG_REG (operand1)) == REG
1478            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
1479     {
1480      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1481         the code which tracks sets/uses for delete_output_reload.  */
1482       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
1483                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
1484                                  SUBREG_BYTE (operand1));
1485       operand1 = alter_subreg (&temp);
1486     }
1487
1488   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
1489       && ((tem = find_replacement (&XEXP (operand0, 0)))
1490           != XEXP (operand0, 0)))
1491     operand0 = replace_equiv_address (operand0, tem);
1492
1493   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
1494       && ((tem = find_replacement (&XEXP (operand1, 0)))
1495           != XEXP (operand1, 0)))
1496     operand1 = replace_equiv_address (operand1, tem);
1497
1498   /* Handle secondary reloads for loads/stores of FP registers from
1499      REG+D addresses where D does not fit in 5 or 14 bits, including
1500      (subreg (mem (addr))) cases.  */
1501   if (scratch_reg
1502       && fp_reg_operand (operand0, mode)
1503       && ((GET_CODE (operand1) == MEM
1504            && !memory_address_p ((GET_MODE_SIZE (mode) == 4 ? SFmode : DFmode),
1505                                  XEXP (operand1, 0)))
1506           || ((GET_CODE (operand1) == SUBREG
1507                && GET_CODE (XEXP (operand1, 0)) == MEM
1508                && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1509                                       ? SFmode : DFmode),
1510                                      XEXP (XEXP (operand1, 0), 0))))))
1511     {
1512       if (GET_CODE (operand1) == SUBREG)
1513         operand1 = XEXP (operand1, 0);
1514
1515       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1516          it in WORD_MODE regardless of what mode it was originally given
1517          to us.  */
1518       scratch_reg = force_mode (word_mode, scratch_reg);
1519
1520       /* D might not fit in 14 bits either; for such cases load D into
1521          scratch reg.  */
1522       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
1523         {
1524           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1525           emit_move_insn (scratch_reg,
1526                           gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
1527                                           Pmode,
1528                                           XEXP (XEXP (operand1, 0), 0),
1529                                           scratch_reg));
1530         }
1531       else
1532         emit_move_insn (scratch_reg, XEXP (operand1, 0));
1533       emit_insn (gen_rtx_SET (VOIDmode, operand0,
1534                               replace_equiv_address (operand1, scratch_reg)));
1535       return 1;
1536     }
1537   else if (scratch_reg
1538            && fp_reg_operand (operand1, mode)
1539            && ((GET_CODE (operand0) == MEM
1540                 && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1541                                         ? SFmode : DFmode),
1542                                        XEXP (operand0, 0)))
1543                || ((GET_CODE (operand0) == SUBREG)
1544                    && GET_CODE (XEXP (operand0, 0)) == MEM
1545                    && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1546                                           ? SFmode : DFmode),
1547                                          XEXP (XEXP (operand0, 0), 0)))))
1548     {
1549       if (GET_CODE (operand0) == SUBREG)
1550         operand0 = XEXP (operand0, 0);
1551
1552       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1553          it in WORD_MODE regardless of what mode it was originally given
1554          to us.  */
1555       scratch_reg = force_mode (word_mode, scratch_reg);
1556
1557       /* D might not fit in 14 bits either; for such cases load D into
1558          scratch reg.  */
1559       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
1560         {
1561           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
1562           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
1563                                                                         0)),
1564                                                        Pmode,
1565                                                        XEXP (XEXP (operand0, 0),
1566                                                                    0),
1567                                                        scratch_reg));
1568         }
1569       else
1570         emit_move_insn (scratch_reg, XEXP (operand0, 0));
1571       emit_insn (gen_rtx_SET (VOIDmode,
1572                               replace_equiv_address (operand0, scratch_reg),
1573                               operand1));
1574       return 1;
1575     }
1576   /* Handle secondary reloads for loads of FP registers from constant
1577      expressions by forcing the constant into memory.
1578
1579      Use scratch_reg to hold the address of the memory location.
1580
1581      The proper fix is to change PREFERRED_RELOAD_CLASS to return
1582      NO_REGS when presented with a const_int and a register class
1583      containing only FP registers.  Doing so unfortunately creates
1584      more problems than it solves.   Fix this for 2.5.  */
1585   else if (scratch_reg
1586            && CONSTANT_P (operand1)
1587            && fp_reg_operand (operand0, mode))
1588     {
1589       rtx const_mem, xoperands[2];
1590
1591       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1592          it in WORD_MODE regardless of what mode it was originally given
1593          to us.  */
1594       scratch_reg = force_mode (word_mode, scratch_reg);
1595
1596       /* Force the constant into memory and put the address of the
1597          memory location into scratch_reg.  */
1598       const_mem = force_const_mem (mode, operand1);
1599       xoperands[0] = scratch_reg;
1600       xoperands[1] = XEXP (const_mem, 0);
1601       emit_move_sequence (xoperands, Pmode, 0);
1602
1603       /* Now load the destination register.  */
1604       emit_insn (gen_rtx_SET (mode, operand0,
1605                               replace_equiv_address (const_mem, scratch_reg)));
1606       return 1;
1607     }
1608   /* Handle secondary reloads for SAR.  These occur when trying to load
1609      the SAR from memory, FP register, or with a constant.  */
1610   else if (scratch_reg
1611            && GET_CODE (operand0) == REG
1612            && REGNO (operand0) < FIRST_PSEUDO_REGISTER
1613            && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
1614            && (GET_CODE (operand1) == MEM
1615                || GET_CODE (operand1) == CONST_INT
1616                || (GET_CODE (operand1) == REG
1617                    && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
1618     {
1619       /* D might not fit in 14 bits either; for such cases load D into
1620          scratch reg.  */
1621       if (GET_CODE (operand1) == MEM
1622           && !memory_address_p (Pmode, XEXP (operand1, 0)))
1623         {
1624           /* We are reloading the address into the scratch register, so we
1625              want to make sure the scratch register is a full register.  */
1626           scratch_reg = force_mode (word_mode, scratch_reg);
1627
1628           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1629           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1,
1630                                                                         0)),
1631                                                        Pmode,
1632                                                        XEXP (XEXP (operand1, 0),
1633                                                        0),
1634                                                        scratch_reg));
1635
1636           /* Now we are going to load the scratch register from memory,
1637              we want to load it in the same width as the original MEM,
1638              which must be the same as the width of the ultimate destination,
1639              OPERAND0.  */
1640           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1641
1642           emit_move_insn (scratch_reg,
1643                           replace_equiv_address (operand1, scratch_reg));
1644         }
1645       else
1646         {
1647           /* We want to load the scratch register using the same mode as
1648              the ultimate destination.  */
1649           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1650
1651           emit_move_insn (scratch_reg, operand1);
1652         }
1653
1654       /* And emit the insn to set the ultimate destination.  We know that
1655          the scratch register has the same mode as the destination at this
1656          point.  */
1657       emit_move_insn (operand0, scratch_reg);
1658       return 1;
1659     }
1660   /* Handle the most common case: storing into a register.  */
1661   else if (register_operand (operand0, mode))
1662     {
1663       if (register_operand (operand1, mode)
1664           || (GET_CODE (operand1) == CONST_INT
1665               && cint_ok_for_move (INTVAL (operand1)))
1666           || (operand1 == CONST0_RTX (mode))
1667           || (GET_CODE (operand1) == HIGH
1668               && !symbolic_operand (XEXP (operand1, 0), VOIDmode))
1669           /* Only `general_operands' can come here, so MEM is ok.  */
1670           || GET_CODE (operand1) == MEM)
1671         {
1672           /* Various sets are created during RTL generation which don't
1673              have the REG_POINTER flag correctly set.  After the CSE pass,
1674              instruction recognition can fail if we don't consistently
1675              set this flag when performing register copies.  This should
1676              also improve the opportunities for creating insns that use
1677              unscaled indexing.  */
1678           if (REG_P (operand0) && REG_P (operand1))
1679             {
1680               if (REG_POINTER (operand1)
1681                   && !REG_POINTER (operand0)
1682                   && !HARD_REGISTER_P (operand0))
1683                 copy_reg_pointer (operand0, operand1);
1684               else if (REG_POINTER (operand0)
1685                        && !REG_POINTER (operand1)
1686                        && !HARD_REGISTER_P (operand1))
1687                 copy_reg_pointer (operand1, operand0);
1688             }
1689           
1690           /* When MEMs are broken out, the REG_POINTER flag doesn't
1691              get set.  In some cases, we can set the REG_POINTER flag
1692              from the declaration for the MEM.  */
1693           if (REG_P (operand0)
1694               && GET_CODE (operand1) == MEM
1695               && !REG_POINTER (operand0))
1696             {
1697               tree decl = MEM_EXPR (operand1);
1698
1699               /* Set the register pointer flag and register alignment
1700                  if the declaration for this memory reference is a
1701                  pointer type.  Fortran indirect argument references
1702                  are ignored.  */
1703               if (decl
1704                   && !(flag_argument_noalias > 1
1705                        && TREE_CODE (decl) == INDIRECT_REF
1706                        && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL))
1707                 {
1708                   tree type;
1709
1710                   /* If this is a COMPONENT_REF, use the FIELD_DECL from
1711                      tree operand 1.  */
1712                   if (TREE_CODE (decl) == COMPONENT_REF)
1713                     decl = TREE_OPERAND (decl, 1);
1714
1715                   type = TREE_TYPE (decl);
1716                   type = strip_array_types (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_CONVERT:
2107     case NON_LVALUE_EXPR:
2108       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2109       break;
2110
2111     case CONSTRUCTOR:
2112       {
2113         tree value;
2114         unsigned HOST_WIDE_INT ix;
2115
2116         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), ix, value)
2117           if (value)
2118             reloc |= reloc_needed (value);
2119       }
2120       break;
2121
2122     case ERROR_MARK:
2123       break;
2124
2125     default:
2126       break;
2127     }
2128   return reloc;
2129 }
2130
2131 /* Does operand (which is a symbolic_operand) live in text space?
2132    If so, SYMBOL_REF_FLAG, which is set by pa_encode_section_info,
2133    will be true.  */
2134
2135 int
2136 read_only_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
2137 {
2138   if (GET_CODE (operand) == CONST)
2139     operand = XEXP (XEXP (operand, 0), 0);
2140   if (flag_pic)
2141     {
2142       if (GET_CODE (operand) == SYMBOL_REF)
2143         return SYMBOL_REF_FLAG (operand) && !CONSTANT_POOL_ADDRESS_P (operand);
2144     }
2145   else
2146     {
2147       if (GET_CODE (operand) == SYMBOL_REF)
2148         return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
2149     }
2150   return 1;
2151 }
2152
2153 \f
2154 /* Return the best assembler insn template
2155    for moving operands[1] into operands[0] as a fullword.  */
2156 const char *
2157 singlemove_string (rtx *operands)
2158 {
2159   HOST_WIDE_INT intval;
2160
2161   if (GET_CODE (operands[0]) == MEM)
2162     return "stw %r1,%0";
2163   if (GET_CODE (operands[1]) == MEM)
2164     return "ldw %1,%0";
2165   if (GET_CODE (operands[1]) == CONST_DOUBLE)
2166     {
2167       long i;
2168       REAL_VALUE_TYPE d;
2169
2170       gcc_assert (GET_MODE (operands[1]) == SFmode);
2171
2172       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
2173          bit pattern.  */
2174       REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
2175       REAL_VALUE_TO_TARGET_SINGLE (d, i);
2176
2177       operands[1] = GEN_INT (i);
2178       /* Fall through to CONST_INT case.  */
2179     }
2180   if (GET_CODE (operands[1]) == CONST_INT)
2181     {
2182       intval = INTVAL (operands[1]);
2183
2184       if (VAL_14_BITS_P (intval))
2185         return "ldi %1,%0";
2186       else if ((intval & 0x7ff) == 0)
2187         return "ldil L'%1,%0";
2188       else if (zdepi_cint_p (intval))
2189         return "{zdepi %Z1,%0|depwi,z %Z1,%0}";
2190       else
2191         return "ldil L'%1,%0\n\tldo R'%1(%0),%0";
2192     }
2193   return "copy %1,%0";
2194 }
2195 \f
2196
2197 /* Compute position (in OP[1]) and width (in OP[2])
2198    useful for copying IMM to a register using the zdepi
2199    instructions.  Store the immediate value to insert in OP[0].  */
2200 static void
2201 compute_zdepwi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2202 {
2203   int lsb, len;
2204
2205   /* Find the least significant set bit in IMM.  */
2206   for (lsb = 0; lsb < 32; lsb++)
2207     {
2208       if ((imm & 1) != 0)
2209         break;
2210       imm >>= 1;
2211     }
2212
2213   /* Choose variants based on *sign* of the 5-bit field.  */
2214   if ((imm & 0x10) == 0)
2215     len = (lsb <= 28) ? 4 : 32 - lsb;
2216   else
2217     {
2218       /* Find the width of the bitstring in IMM.  */
2219       for (len = 5; len < 32; len++)
2220         {
2221           if ((imm & (1 << len)) == 0)
2222             break;
2223         }
2224
2225       /* Sign extend IMM as a 5-bit value.  */
2226       imm = (imm & 0xf) - 0x10;
2227     }
2228
2229   op[0] = imm;
2230   op[1] = 31 - lsb;
2231   op[2] = len;
2232 }
2233
2234 /* Compute position (in OP[1]) and width (in OP[2])
2235    useful for copying IMM to a register using the depdi,z
2236    instructions.  Store the immediate value to insert in OP[0].  */
2237 void
2238 compute_zdepdi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2239 {
2240   HOST_WIDE_INT lsb, len;
2241
2242   /* Find the least significant set bit in IMM.  */
2243   for (lsb = 0; lsb < HOST_BITS_PER_WIDE_INT; lsb++)
2244     {
2245       if ((imm & 1) != 0)
2246         break;
2247       imm >>= 1;
2248     }
2249
2250   /* Choose variants based on *sign* of the 5-bit field.  */
2251   if ((imm & 0x10) == 0)
2252     len = ((lsb <= HOST_BITS_PER_WIDE_INT - 4)
2253            ? 4 : HOST_BITS_PER_WIDE_INT - lsb);
2254   else
2255     {
2256       /* Find the width of the bitstring in IMM.  */
2257       for (len = 5; len < HOST_BITS_PER_WIDE_INT; len++)
2258         {
2259           if ((imm & ((unsigned HOST_WIDE_INT) 1 << len)) == 0)
2260             break;
2261         }
2262
2263       /* Sign extend IMM as a 5-bit value.  */
2264       imm = (imm & 0xf) - 0x10;
2265     }
2266
2267   op[0] = imm;
2268   op[1] = 63 - lsb;
2269   op[2] = len;
2270 }
2271
2272 /* Output assembler code to perform a doubleword move insn
2273    with operands OPERANDS.  */
2274
2275 const char *
2276 output_move_double (rtx *operands)
2277 {
2278   enum { REGOP, OFFSOP, MEMOP, CNSTOP, RNDOP } optype0, optype1;
2279   rtx latehalf[2];
2280   rtx addreg0 = 0, addreg1 = 0;
2281
2282   /* First classify both operands.  */
2283
2284   if (REG_P (operands[0]))
2285     optype0 = REGOP;
2286   else if (offsettable_memref_p (operands[0]))
2287     optype0 = OFFSOP;
2288   else if (GET_CODE (operands[0]) == MEM)
2289     optype0 = MEMOP;
2290   else
2291     optype0 = RNDOP;
2292
2293   if (REG_P (operands[1]))
2294     optype1 = REGOP;
2295   else if (CONSTANT_P (operands[1]))
2296     optype1 = CNSTOP;
2297   else if (offsettable_memref_p (operands[1]))
2298     optype1 = OFFSOP;
2299   else if (GET_CODE (operands[1]) == MEM)
2300     optype1 = MEMOP;
2301   else
2302     optype1 = RNDOP;
2303
2304   /* Check for the cases that the operand constraints are not
2305      supposed to allow to happen.  */
2306   gcc_assert (optype0 == REGOP || optype1 == REGOP);
2307
2308   /* Handle copies between general and floating registers.  */
2309
2310   if (optype0 == REGOP && optype1 == REGOP
2311       && FP_REG_P (operands[0]) ^ FP_REG_P (operands[1]))
2312     {
2313       if (FP_REG_P (operands[0]))
2314         {
2315           output_asm_insn ("{stws|stw} %1,-16(%%sp)", operands);
2316           output_asm_insn ("{stws|stw} %R1,-12(%%sp)", operands);
2317           return "{fldds|fldd} -16(%%sp),%0";
2318         }
2319       else
2320         {
2321           output_asm_insn ("{fstds|fstd} %1,-16(%%sp)", operands);
2322           output_asm_insn ("{ldws|ldw} -16(%%sp),%0", operands);
2323           return "{ldws|ldw} -12(%%sp),%R0";
2324         }
2325     }
2326
2327    /* Handle auto decrementing and incrementing loads and stores
2328      specifically, since the structure of the function doesn't work
2329      for them without major modification.  Do it better when we learn
2330      this port about the general inc/dec addressing of PA.
2331      (This was written by tege.  Chide him if it doesn't work.)  */
2332
2333   if (optype0 == MEMOP)
2334     {
2335       /* We have to output the address syntax ourselves, since print_operand
2336          doesn't deal with the addresses we want to use.  Fix this later.  */
2337
2338       rtx addr = XEXP (operands[0], 0);
2339       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2340         {
2341           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2342
2343           operands[0] = XEXP (addr, 0);
2344           gcc_assert (GET_CODE (operands[1]) == REG
2345                       && GET_CODE (operands[0]) == REG);
2346
2347           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2348           
2349           /* No overlap between high target register and address
2350              register.  (We do this in a non-obvious way to
2351              save a register file writeback)  */
2352           if (GET_CODE (addr) == POST_INC)
2353             return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2354           return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2355         }
2356       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2357         {
2358           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2359
2360           operands[0] = XEXP (addr, 0);
2361           gcc_assert (GET_CODE (operands[1]) == REG
2362                       && GET_CODE (operands[0]) == REG);
2363           
2364           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2365           /* No overlap between high target register and address
2366              register.  (We do this in a non-obvious way to save a
2367              register file writeback)  */
2368           if (GET_CODE (addr) == PRE_INC)
2369             return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2370           return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2371         }
2372     }
2373   if (optype1 == MEMOP)
2374     {
2375       /* We have to output the address syntax ourselves, since print_operand
2376          doesn't deal with the addresses we want to use.  Fix this later.  */
2377
2378       rtx addr = XEXP (operands[1], 0);
2379       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2380         {
2381           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2382
2383           operands[1] = XEXP (addr, 0);
2384           gcc_assert (GET_CODE (operands[0]) == REG
2385                       && GET_CODE (operands[1]) == REG);
2386
2387           if (!reg_overlap_mentioned_p (high_reg, addr))
2388             {
2389               /* No overlap between high target register and address
2390                  register.  (We do this in a non-obvious way to
2391                  save a register file writeback)  */
2392               if (GET_CODE (addr) == POST_INC)
2393                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2394               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2395             }
2396           else
2397             {
2398               /* This is an undefined situation.  We should load into the
2399                  address register *and* update that register.  Probably
2400                  we don't need to handle this at all.  */
2401               if (GET_CODE (addr) == POST_INC)
2402                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2403               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2404             }
2405         }
2406       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2407         {
2408           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2409
2410           operands[1] = XEXP (addr, 0);
2411           gcc_assert (GET_CODE (operands[0]) == REG
2412                       && GET_CODE (operands[1]) == REG);
2413
2414           if (!reg_overlap_mentioned_p (high_reg, addr))
2415             {
2416               /* No overlap between high target register and address
2417                  register.  (We do this in a non-obvious way to
2418                  save a register file writeback)  */
2419               if (GET_CODE (addr) == PRE_INC)
2420                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2421               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2422             }
2423           else
2424             {
2425               /* This is an undefined situation.  We should load into the
2426                  address register *and* update that register.  Probably
2427                  we don't need to handle this at all.  */
2428               if (GET_CODE (addr) == PRE_INC)
2429                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2430               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2431             }
2432         }
2433       else if (GET_CODE (addr) == PLUS
2434                && GET_CODE (XEXP (addr, 0)) == MULT)
2435         {
2436           rtx xoperands[4];
2437           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2438
2439           if (!reg_overlap_mentioned_p (high_reg, addr))
2440             {
2441               xoperands[0] = high_reg;
2442               xoperands[1] = XEXP (addr, 1);
2443               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2444               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2445               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2446                                xoperands);
2447               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2448             }
2449           else
2450             {
2451               xoperands[0] = high_reg;
2452               xoperands[1] = XEXP (addr, 1);
2453               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2454               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2455               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2456                                xoperands);
2457               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2458             }
2459         }
2460     }
2461
2462   /* If an operand is an unoffsettable memory ref, find a register
2463      we can increment temporarily to make it refer to the second word.  */
2464
2465   if (optype0 == MEMOP)
2466     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2467
2468   if (optype1 == MEMOP)
2469     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2470
2471   /* Ok, we can do one word at a time.
2472      Normally we do the low-numbered word first.
2473
2474      In either case, set up in LATEHALF the operands to use
2475      for the high-numbered word and in some cases alter the
2476      operands in OPERANDS to be suitable for the low-numbered word.  */
2477
2478   if (optype0 == REGOP)
2479     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2480   else if (optype0 == OFFSOP)
2481     latehalf[0] = adjust_address (operands[0], SImode, 4);
2482   else
2483     latehalf[0] = operands[0];
2484
2485   if (optype1 == REGOP)
2486     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2487   else if (optype1 == OFFSOP)
2488     latehalf[1] = adjust_address (operands[1], SImode, 4);
2489   else if (optype1 == CNSTOP)
2490     split_double (operands[1], &operands[1], &latehalf[1]);
2491   else
2492     latehalf[1] = operands[1];
2493
2494   /* If the first move would clobber the source of the second one,
2495      do them in the other order.
2496
2497      This can happen in two cases:
2498
2499         mem -> register where the first half of the destination register
2500         is the same register used in the memory's address.  Reload
2501         can create such insns.
2502
2503         mem in this case will be either register indirect or register
2504         indirect plus a valid offset.
2505
2506         register -> register move where REGNO(dst) == REGNO(src + 1)
2507         someone (Tim/Tege?) claimed this can happen for parameter loads.
2508
2509      Handle mem -> register case first.  */
2510   if (optype0 == REGOP
2511       && (optype1 == MEMOP || optype1 == OFFSOP)
2512       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2513                             operands[1], 0))
2514     {
2515       /* Do the late half first.  */
2516       if (addreg1)
2517         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2518       output_asm_insn (singlemove_string (latehalf), latehalf);
2519
2520       /* Then clobber.  */
2521       if (addreg1)
2522         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2523       return singlemove_string (operands);
2524     }
2525
2526   /* Now handle register -> register case.  */
2527   if (optype0 == REGOP && optype1 == REGOP
2528       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2529     {
2530       output_asm_insn (singlemove_string (latehalf), latehalf);
2531       return singlemove_string (operands);
2532     }
2533
2534   /* Normal case: do the two words, low-numbered first.  */
2535
2536   output_asm_insn (singlemove_string (operands), operands);
2537
2538   /* Make any unoffsettable addresses point at high-numbered word.  */
2539   if (addreg0)
2540     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2541   if (addreg1)
2542     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2543
2544   /* Do that word.  */
2545   output_asm_insn (singlemove_string (latehalf), latehalf);
2546
2547   /* Undo the adds we just did.  */
2548   if (addreg0)
2549     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2550   if (addreg1)
2551     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2552
2553   return "";
2554 }
2555 \f
2556 const char *
2557 output_fp_move_double (rtx *operands)
2558 {
2559   if (FP_REG_P (operands[0]))
2560     {
2561       if (FP_REG_P (operands[1])
2562           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2563         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2564       else
2565         output_asm_insn ("fldd%F1 %1,%0", operands);
2566     }
2567   else if (FP_REG_P (operands[1]))
2568     {
2569       output_asm_insn ("fstd%F0 %1,%0", operands);
2570     }
2571   else
2572     {
2573       rtx xoperands[2];
2574       
2575       gcc_assert (operands[1] == CONST0_RTX (GET_MODE (operands[0])));
2576       
2577       /* This is a pain.  You have to be prepared to deal with an
2578          arbitrary address here including pre/post increment/decrement.
2579
2580          so avoid this in the MD.  */
2581       gcc_assert (GET_CODE (operands[0]) == REG);
2582       
2583       xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2584       xoperands[0] = operands[0];
2585       output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2586     }
2587   return "";
2588 }
2589 \f
2590 /* Return a REG that occurs in ADDR with coefficient 1.
2591    ADDR can be effectively incremented by incrementing REG.  */
2592
2593 static rtx
2594 find_addr_reg (rtx addr)
2595 {
2596   while (GET_CODE (addr) == PLUS)
2597     {
2598       if (GET_CODE (XEXP (addr, 0)) == REG)
2599         addr = XEXP (addr, 0);
2600       else if (GET_CODE (XEXP (addr, 1)) == REG)
2601         addr = XEXP (addr, 1);
2602       else if (CONSTANT_P (XEXP (addr, 0)))
2603         addr = XEXP (addr, 1);
2604       else if (CONSTANT_P (XEXP (addr, 1)))
2605         addr = XEXP (addr, 0);
2606       else
2607         gcc_unreachable ();
2608     }
2609   gcc_assert (GET_CODE (addr) == REG);
2610   return addr;
2611 }
2612
2613 /* Emit code to perform a block move.
2614
2615    OPERANDS[0] is the destination pointer as a REG, clobbered.
2616    OPERANDS[1] is the source pointer as a REG, clobbered.
2617    OPERANDS[2] is a register for temporary storage.
2618    OPERANDS[3] is a register for temporary storage.
2619    OPERANDS[4] is the size as a CONST_INT
2620    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2621    OPERANDS[6] is another temporary register.  */
2622
2623 const char *
2624 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2625 {
2626   int align = INTVAL (operands[5]);
2627   unsigned long n_bytes = INTVAL (operands[4]);
2628
2629   /* We can't move more than a word at a time because the PA
2630      has no longer integer move insns.  (Could use fp mem ops?)  */
2631   if (align > (TARGET_64BIT ? 8 : 4))
2632     align = (TARGET_64BIT ? 8 : 4);
2633
2634   /* Note that we know each loop below will execute at least twice
2635      (else we would have open-coded the copy).  */
2636   switch (align)
2637     {
2638       case 8:
2639         /* Pre-adjust the loop counter.  */
2640         operands[4] = GEN_INT (n_bytes - 16);
2641         output_asm_insn ("ldi %4,%2", operands);
2642
2643         /* Copying loop.  */
2644         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2645         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2646         output_asm_insn ("std,ma %3,8(%0)", operands);
2647         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2648         output_asm_insn ("std,ma %6,8(%0)", operands);
2649
2650         /* Handle the residual.  There could be up to 7 bytes of
2651            residual to copy!  */
2652         if (n_bytes % 16 != 0)
2653           {
2654             operands[4] = GEN_INT (n_bytes % 8);
2655             if (n_bytes % 16 >= 8)
2656               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2657             if (n_bytes % 8 != 0)
2658               output_asm_insn ("ldd 0(%1),%6", operands);
2659             if (n_bytes % 16 >= 8)
2660               output_asm_insn ("std,ma %3,8(%0)", operands);
2661             if (n_bytes % 8 != 0)
2662               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2663           }
2664         return "";
2665
2666       case 4:
2667         /* Pre-adjust the loop counter.  */
2668         operands[4] = GEN_INT (n_bytes - 8);
2669         output_asm_insn ("ldi %4,%2", operands);
2670
2671         /* Copying loop.  */
2672         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2673         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2674         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2675         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2676         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2677
2678         /* Handle the residual.  There could be up to 7 bytes of
2679            residual to copy!  */
2680         if (n_bytes % 8 != 0)
2681           {
2682             operands[4] = GEN_INT (n_bytes % 4);
2683             if (n_bytes % 8 >= 4)
2684               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2685             if (n_bytes % 4 != 0)
2686               output_asm_insn ("ldw 0(%1),%6", operands);
2687             if (n_bytes % 8 >= 4)
2688               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2689             if (n_bytes % 4 != 0)
2690               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2691           }
2692         return "";
2693
2694       case 2:
2695         /* Pre-adjust the loop counter.  */
2696         operands[4] = GEN_INT (n_bytes - 4);
2697         output_asm_insn ("ldi %4,%2", operands);
2698
2699         /* Copying loop.  */
2700         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2701         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2702         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2703         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2704         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2705
2706         /* Handle the residual.  */
2707         if (n_bytes % 4 != 0)
2708           {
2709             if (n_bytes % 4 >= 2)
2710               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2711             if (n_bytes % 2 != 0)
2712               output_asm_insn ("ldb 0(%1),%6", operands);
2713             if (n_bytes % 4 >= 2)
2714               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2715             if (n_bytes % 2 != 0)
2716               output_asm_insn ("stb %6,0(%0)", operands);
2717           }
2718         return "";
2719
2720       case 1:
2721         /* Pre-adjust the loop counter.  */
2722         operands[4] = GEN_INT (n_bytes - 2);
2723         output_asm_insn ("ldi %4,%2", operands);
2724
2725         /* Copying loop.  */
2726         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2727         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2728         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2729         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2730         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2731
2732         /* Handle the residual.  */
2733         if (n_bytes % 2 != 0)
2734           {
2735             output_asm_insn ("ldb 0(%1),%3", operands);
2736             output_asm_insn ("stb %3,0(%0)", operands);
2737           }
2738         return "";
2739
2740       default:
2741         gcc_unreachable ();
2742     }
2743 }
2744
2745 /* Count the number of insns necessary to handle this block move.
2746
2747    Basic structure is the same as emit_block_move, except that we
2748    count insns rather than emit them.  */
2749
2750 static int
2751 compute_movmem_length (rtx insn)
2752 {
2753   rtx pat = PATTERN (insn);
2754   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2755   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2756   unsigned int n_insns = 0;
2757
2758   /* We can't move more than four bytes at a time because the PA
2759      has no longer integer move insns.  (Could use fp mem ops?)  */
2760   if (align > (TARGET_64BIT ? 8 : 4))
2761     align = (TARGET_64BIT ? 8 : 4);
2762
2763   /* The basic copying loop.  */
2764   n_insns = 6;
2765
2766   /* Residuals.  */
2767   if (n_bytes % (2 * align) != 0)
2768     {
2769       if ((n_bytes % (2 * align)) >= align)
2770         n_insns += 2;
2771
2772       if ((n_bytes % align) != 0)
2773         n_insns += 2;
2774     }
2775
2776   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2777   return n_insns * 4;
2778 }
2779
2780 /* Emit code to perform a block clear.
2781
2782    OPERANDS[0] is the destination pointer as a REG, clobbered.
2783    OPERANDS[1] is a register for temporary storage.
2784    OPERANDS[2] is the size as a CONST_INT
2785    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
2786
2787 const char *
2788 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2789 {
2790   int align = INTVAL (operands[3]);
2791   unsigned long n_bytes = INTVAL (operands[2]);
2792
2793   /* We can't clear more than a word at a time because the PA
2794      has no longer integer move insns.  */
2795   if (align > (TARGET_64BIT ? 8 : 4))
2796     align = (TARGET_64BIT ? 8 : 4);
2797
2798   /* Note that we know each loop below will execute at least twice
2799      (else we would have open-coded the copy).  */
2800   switch (align)
2801     {
2802       case 8:
2803         /* Pre-adjust the loop counter.  */
2804         operands[2] = GEN_INT (n_bytes - 16);
2805         output_asm_insn ("ldi %2,%1", operands);
2806
2807         /* Loop.  */
2808         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2809         output_asm_insn ("addib,>= -16,%1,.-4", operands);
2810         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2811
2812         /* Handle the residual.  There could be up to 7 bytes of
2813            residual to copy!  */
2814         if (n_bytes % 16 != 0)
2815           {
2816             operands[2] = GEN_INT (n_bytes % 8);
2817             if (n_bytes % 16 >= 8)
2818               output_asm_insn ("std,ma %%r0,8(%0)", operands);
2819             if (n_bytes % 8 != 0)
2820               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
2821           }
2822         return "";
2823
2824       case 4:
2825         /* Pre-adjust the loop counter.  */
2826         operands[2] = GEN_INT (n_bytes - 8);
2827         output_asm_insn ("ldi %2,%1", operands);
2828
2829         /* Loop.  */
2830         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2831         output_asm_insn ("addib,>= -8,%1,.-4", operands);
2832         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2833
2834         /* Handle the residual.  There could be up to 7 bytes of
2835            residual to copy!  */
2836         if (n_bytes % 8 != 0)
2837           {
2838             operands[2] = GEN_INT (n_bytes % 4);
2839             if (n_bytes % 8 >= 4)
2840               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2841             if (n_bytes % 4 != 0)
2842               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
2843           }
2844         return "";
2845
2846       case 2:
2847         /* Pre-adjust the loop counter.  */
2848         operands[2] = GEN_INT (n_bytes - 4);
2849         output_asm_insn ("ldi %2,%1", operands);
2850
2851         /* Loop.  */
2852         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2853         output_asm_insn ("addib,>= -4,%1,.-4", operands);
2854         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2855
2856         /* Handle the residual.  */
2857         if (n_bytes % 4 != 0)
2858           {
2859             if (n_bytes % 4 >= 2)
2860               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2861             if (n_bytes % 2 != 0)
2862               output_asm_insn ("stb %%r0,0(%0)", operands);
2863           }
2864         return "";
2865
2866       case 1:
2867         /* Pre-adjust the loop counter.  */
2868         operands[2] = GEN_INT (n_bytes - 2);
2869         output_asm_insn ("ldi %2,%1", operands);
2870
2871         /* Loop.  */
2872         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2873         output_asm_insn ("addib,>= -2,%1,.-4", operands);
2874         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2875
2876         /* Handle the residual.  */
2877         if (n_bytes % 2 != 0)
2878           output_asm_insn ("stb %%r0,0(%0)", operands);
2879
2880         return "";
2881
2882       default:
2883         gcc_unreachable ();
2884     }
2885 }
2886
2887 /* Count the number of insns necessary to handle this block move.
2888
2889    Basic structure is the same as emit_block_move, except that we
2890    count insns rather than emit them.  */
2891
2892 static int
2893 compute_clrmem_length (rtx insn)
2894 {
2895   rtx pat = PATTERN (insn);
2896   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
2897   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
2898   unsigned int n_insns = 0;
2899
2900   /* We can't clear more than a word at a time because the PA
2901      has no longer integer move insns.  */
2902   if (align > (TARGET_64BIT ? 8 : 4))
2903     align = (TARGET_64BIT ? 8 : 4);
2904
2905   /* The basic loop.  */
2906   n_insns = 4;
2907
2908   /* Residuals.  */
2909   if (n_bytes % (2 * align) != 0)
2910     {
2911       if ((n_bytes % (2 * align)) >= align)
2912         n_insns++;
2913
2914       if ((n_bytes % align) != 0)
2915         n_insns++;
2916     }
2917
2918   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2919   return n_insns * 4;
2920 }
2921 \f
2922
2923 const char *
2924 output_and (rtx *operands)
2925 {
2926   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2927     {
2928       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2929       int ls0, ls1, ms0, p, len;
2930
2931       for (ls0 = 0; ls0 < 32; ls0++)
2932         if ((mask & (1 << ls0)) == 0)
2933           break;
2934
2935       for (ls1 = ls0; ls1 < 32; ls1++)
2936         if ((mask & (1 << ls1)) != 0)
2937           break;
2938
2939       for (ms0 = ls1; ms0 < 32; ms0++)
2940         if ((mask & (1 << ms0)) == 0)
2941           break;
2942
2943       gcc_assert (ms0 == 32);
2944
2945       if (ls1 == 32)
2946         {
2947           len = ls0;
2948
2949           gcc_assert (len);
2950
2951           operands[2] = GEN_INT (len);
2952           return "{extru|extrw,u} %1,31,%2,%0";
2953         }
2954       else
2955         {
2956           /* We could use this `depi' for the case above as well, but `depi'
2957              requires one more register file access than an `extru'.  */
2958
2959           p = 31 - ls0;
2960           len = ls1 - ls0;
2961
2962           operands[2] = GEN_INT (p);
2963           operands[3] = GEN_INT (len);
2964           return "{depi|depwi} 0,%2,%3,%0";
2965         }
2966     }
2967   else
2968     return "and %1,%2,%0";
2969 }
2970
2971 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2972    storing the result in operands[0].  */
2973 const char *
2974 output_64bit_and (rtx *operands)
2975 {
2976   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2977     {
2978       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2979       int ls0, ls1, ms0, p, len;
2980
2981       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
2982         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
2983           break;
2984
2985       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
2986         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
2987           break;
2988
2989       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
2990         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
2991           break;
2992
2993       gcc_assert (ms0 == HOST_BITS_PER_WIDE_INT);
2994
2995       if (ls1 == HOST_BITS_PER_WIDE_INT)
2996         {
2997           len = ls0;
2998
2999           gcc_assert (len);
3000
3001           operands[2] = GEN_INT (len);
3002           return "extrd,u %1,63,%2,%0";
3003         }
3004       else
3005         {
3006           /* We could use this `depi' for the case above as well, but `depi'
3007              requires one more register file access than an `extru'.  */
3008
3009           p = 63 - ls0;
3010           len = ls1 - ls0;
3011
3012           operands[2] = GEN_INT (p);
3013           operands[3] = GEN_INT (len);
3014           return "depdi 0,%2,%3,%0";
3015         }
3016     }
3017   else
3018     return "and %1,%2,%0";
3019 }
3020
3021 const char *
3022 output_ior (rtx *operands)
3023 {
3024   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3025   int bs0, bs1, p, len;
3026
3027   if (INTVAL (operands[2]) == 0)
3028     return "copy %1,%0";
3029
3030   for (bs0 = 0; bs0 < 32; bs0++)
3031     if ((mask & (1 << bs0)) != 0)
3032       break;
3033
3034   for (bs1 = bs0; bs1 < 32; bs1++)
3035     if ((mask & (1 << bs1)) == 0)
3036       break;
3037
3038   gcc_assert (bs1 == 32 || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
3039
3040   p = 31 - bs0;
3041   len = bs1 - bs0;
3042
3043   operands[2] = GEN_INT (p);
3044   operands[3] = GEN_INT (len);
3045   return "{depi|depwi} -1,%2,%3,%0";
3046 }
3047
3048 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
3049    storing the result in operands[0].  */
3050 const char *
3051 output_64bit_ior (rtx *operands)
3052 {
3053   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
3054   int bs0, bs1, p, len;
3055
3056   if (INTVAL (operands[2]) == 0)
3057     return "copy %1,%0";
3058
3059   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
3060     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
3061       break;
3062
3063   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
3064     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
3065       break;
3066
3067   gcc_assert (bs1 == HOST_BITS_PER_WIDE_INT
3068               || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
3069
3070   p = 63 - bs0;
3071   len = bs1 - bs0;
3072
3073   operands[2] = GEN_INT (p);
3074   operands[3] = GEN_INT (len);
3075   return "depdi -1,%2,%3,%0";
3076 }
3077 \f
3078 /* Target hook for assembling integer objects.  This code handles
3079    aligned SI and DI integers specially since function references
3080    must be preceded by P%.  */
3081
3082 static bool
3083 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
3084 {
3085   if (size == UNITS_PER_WORD
3086       && aligned_p
3087       && function_label_operand (x, VOIDmode))
3088     {
3089       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
3090       output_addr_const (asm_out_file, x);
3091       fputc ('\n', asm_out_file);
3092       return true;
3093     }
3094   return default_assemble_integer (x, size, aligned_p);
3095 }
3096 \f
3097 /* Output an ascii string.  */
3098 void
3099 output_ascii (FILE *file, const char *p, int size)
3100 {
3101   int i;
3102   int chars_output;
3103   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
3104
3105   /* The HP assembler can only take strings of 256 characters at one
3106      time.  This is a limitation on input line length, *not* the
3107      length of the string.  Sigh.  Even worse, it seems that the
3108      restriction is in number of input characters (see \xnn &
3109      \whatever).  So we have to do this very carefully.  */
3110
3111   fputs ("\t.STRING \"", file);
3112
3113   chars_output = 0;
3114   for (i = 0; i < size; i += 4)
3115     {
3116       int co = 0;
3117       int io = 0;
3118       for (io = 0, co = 0; io < MIN (4, size - i); io++)
3119         {
3120           register unsigned int c = (unsigned char) p[i + io];
3121
3122           if (c == '\"' || c == '\\')
3123             partial_output[co++] = '\\';
3124           if (c >= ' ' && c < 0177)
3125             partial_output[co++] = c;
3126           else
3127             {
3128               unsigned int hexd;
3129               partial_output[co++] = '\\';
3130               partial_output[co++] = 'x';
3131               hexd =  c  / 16 - 0 + '0';
3132               if (hexd > '9')
3133                 hexd -= '9' - 'a' + 1;
3134               partial_output[co++] = hexd;
3135               hexd =  c % 16 - 0 + '0';
3136               if (hexd > '9')
3137                 hexd -= '9' - 'a' + 1;
3138               partial_output[co++] = hexd;
3139             }
3140         }
3141       if (chars_output + co > 243)
3142         {
3143           fputs ("\"\n\t.STRING \"", file);
3144           chars_output = 0;
3145         }
3146       fwrite (partial_output, 1, (size_t) co, file);
3147       chars_output += co;
3148       co = 0;
3149     }
3150   fputs ("\"\n", file);
3151 }
3152
3153 /* Try to rewrite floating point comparisons & branches to avoid
3154    useless add,tr insns.
3155
3156    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3157    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3158    first attempt to remove useless add,tr insns.  It is zero
3159    for the second pass as reorg sometimes leaves bogus REG_DEAD
3160    notes lying around.
3161
3162    When CHECK_NOTES is zero we can only eliminate add,tr insns
3163    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3164    instructions.  */
3165 static void
3166 remove_useless_addtr_insns (int check_notes)
3167 {
3168   rtx insn;
3169   static int pass = 0;
3170
3171   /* This is fairly cheap, so always run it when optimizing.  */
3172   if (optimize > 0)
3173     {
3174       int fcmp_count = 0;
3175       int fbranch_count = 0;
3176
3177       /* Walk all the insns in this function looking for fcmp & fbranch
3178          instructions.  Keep track of how many of each we find.  */
3179       for (insn = get_insns (); insn; insn = next_insn (insn))
3180         {
3181           rtx tmp;
3182
3183           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3184           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3185             continue;
3186
3187           tmp = PATTERN (insn);
3188
3189           /* It must be a set.  */
3190           if (GET_CODE (tmp) != SET)
3191             continue;
3192
3193           /* If the destination is CCFP, then we've found an fcmp insn.  */
3194           tmp = SET_DEST (tmp);
3195           if (GET_CODE (tmp) == REG && REGNO (tmp) == 0)
3196             {
3197               fcmp_count++;
3198               continue;
3199             }
3200
3201           tmp = PATTERN (insn);
3202           /* If this is an fbranch instruction, bump the fbranch counter.  */
3203           if (GET_CODE (tmp) == SET
3204               && SET_DEST (tmp) == pc_rtx
3205               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
3206               && GET_CODE (XEXP (SET_SRC (tmp), 0)) == NE
3207               && GET_CODE (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == REG
3208               && REGNO (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == 0)
3209             {
3210               fbranch_count++;
3211               continue;
3212             }
3213         }
3214
3215
3216       /* Find all floating point compare + branch insns.  If possible,
3217          reverse the comparison & the branch to avoid add,tr insns.  */
3218       for (insn = get_insns (); insn; insn = next_insn (insn))
3219         {
3220           rtx tmp, next;
3221
3222           /* Ignore anything that isn't an INSN.  */
3223           if (GET_CODE (insn) != INSN)
3224             continue;
3225
3226           tmp = PATTERN (insn);
3227
3228           /* It must be a set.  */
3229           if (GET_CODE (tmp) != SET)
3230             continue;
3231
3232           /* The destination must be CCFP, which is register zero.  */
3233           tmp = SET_DEST (tmp);
3234           if (GET_CODE (tmp) != REG || REGNO (tmp) != 0)
3235             continue;
3236
3237           /* INSN should be a set of CCFP.
3238
3239              See if the result of this insn is used in a reversed FP
3240              conditional branch.  If so, reverse our condition and
3241              the branch.  Doing so avoids useless add,tr insns.  */
3242           next = next_insn (insn);
3243           while (next)
3244             {
3245               /* Jumps, calls and labels stop our search.  */
3246               if (GET_CODE (next) == JUMP_INSN
3247                   || GET_CODE (next) == CALL_INSN
3248                   || GET_CODE (next) == CODE_LABEL)
3249                 break;
3250
3251               /* As does another fcmp insn.  */
3252               if (GET_CODE (next) == INSN
3253                   && GET_CODE (PATTERN (next)) == SET
3254                   && GET_CODE (SET_DEST (PATTERN (next))) == REG
3255                   && REGNO (SET_DEST (PATTERN (next))) == 0)
3256                 break;
3257
3258               next = next_insn (next);
3259             }
3260
3261           /* Is NEXT_INSN a branch?  */
3262           if (next
3263               && GET_CODE (next) == JUMP_INSN)
3264             {
3265               rtx pattern = PATTERN (next);
3266
3267               /* If it a reversed fp conditional branch (e.g. uses add,tr)
3268                  and CCFP dies, then reverse our conditional and the branch
3269                  to avoid the add,tr.  */
3270               if (GET_CODE (pattern) == SET
3271                   && SET_DEST (pattern) == pc_rtx
3272                   && GET_CODE (SET_SRC (pattern)) == IF_THEN_ELSE
3273                   && GET_CODE (XEXP (SET_SRC (pattern), 0)) == NE
3274                   && GET_CODE (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == REG
3275                   && REGNO (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == 0
3276                   && GET_CODE (XEXP (SET_SRC (pattern), 1)) == PC
3277                   && (fcmp_count == fbranch_count
3278                       || (check_notes
3279                           && find_regno_note (next, REG_DEAD, 0))))
3280                 {
3281                   /* Reverse the branch.  */
3282                   tmp = XEXP (SET_SRC (pattern), 1);
3283                   XEXP (SET_SRC (pattern), 1) = XEXP (SET_SRC (pattern), 2);
3284                   XEXP (SET_SRC (pattern), 2) = tmp;
3285                   INSN_CODE (next) = -1;
3286
3287                   /* Reverse our condition.  */
3288                   tmp = PATTERN (insn);
3289                   PUT_CODE (XEXP (tmp, 1),
3290                             (reverse_condition_maybe_unordered
3291                              (GET_CODE (XEXP (tmp, 1)))));
3292                 }
3293             }
3294         }
3295     }
3296
3297   pass = !pass;
3298
3299 }
3300 \f
3301 /* You may have trouble believing this, but this is the 32 bit HP-PA
3302    stack layout.  Wow.
3303
3304    Offset               Contents
3305
3306    Variable arguments   (optional; any number may be allocated)
3307
3308    SP-(4*(N+9))         arg word N
3309         :                   :
3310       SP-56             arg word 5
3311       SP-52             arg word 4
3312
3313    Fixed arguments      (must be allocated; may remain unused)
3314
3315       SP-48             arg word 3
3316       SP-44             arg word 2
3317       SP-40             arg word 1
3318       SP-36             arg word 0
3319
3320    Frame Marker
3321
3322       SP-32             External Data Pointer (DP)
3323       SP-28             External sr4
3324       SP-24             External/stub RP (RP')
3325       SP-20             Current RP
3326       SP-16             Static Link
3327       SP-12             Clean up
3328       SP-8              Calling Stub RP (RP'')
3329       SP-4              Previous SP
3330
3331    Top of Frame
3332
3333       SP-0              Stack Pointer (points to next available address)
3334
3335 */
3336
3337 /* This function saves registers as follows.  Registers marked with ' are
3338    this function's registers (as opposed to the previous function's).
3339    If a frame_pointer isn't needed, r4 is saved as a general register;
3340    the space for the frame pointer is still allocated, though, to keep
3341    things simple.
3342
3343
3344    Top of Frame
3345
3346        SP (FP')         Previous FP
3347        SP + 4           Alignment filler (sigh)
3348        SP + 8           Space for locals reserved here.
3349        .
3350        .
3351        .
3352        SP + n           All call saved register used.
3353        .
3354        .
3355        .
3356        SP + o           All call saved fp registers used.
3357        .
3358        .
3359        .
3360        SP + p (SP')     points to next available address.
3361
3362 */
3363
3364 /* Global variables set by output_function_prologue().  */
3365 /* Size of frame.  Need to know this to emit return insns from
3366    leaf procedures.  */
3367 static HOST_WIDE_INT actual_fsize, local_fsize;
3368 static int save_fregs;
3369
3370 /* Emit RTL to store REG at the memory location specified by BASE+DISP.
3371    Handle case where DISP > 8k by using the add_high_const patterns.
3372
3373    Note in DISP > 8k case, we will leave the high part of the address
3374    in %r1.  There is code in expand_hppa_{prologue,epilogue} that knows this.*/
3375
3376 static void
3377 store_reg (int reg, HOST_WIDE_INT disp, int base)
3378 {
3379   rtx insn, dest, src, basereg;
3380
3381   src = gen_rtx_REG (word_mode, reg);
3382   basereg = gen_rtx_REG (Pmode, base);
3383   if (VAL_14_BITS_P (disp))
3384     {
3385       dest = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3386       insn = emit_move_insn (dest, src);
3387     }
3388   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3389     {
3390       rtx delta = GEN_INT (disp);
3391       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3392
3393       emit_move_insn (tmpreg, delta);
3394       insn = emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3395       if (DO_FRAME_NOTES)
3396         {
3397           REG_NOTES (insn)
3398             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3399                 gen_rtx_SET (VOIDmode, tmpreg,
3400                              gen_rtx_PLUS (Pmode, basereg, delta)),
3401                 REG_NOTES (insn));
3402           RTX_FRAME_RELATED_P (insn) = 1;
3403         }
3404       dest = gen_rtx_MEM (word_mode, tmpreg);
3405       insn = emit_move_insn (dest, src);
3406     }
3407   else
3408     {
3409       rtx delta = GEN_INT (disp);
3410       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3411       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3412
3413       emit_move_insn (tmpreg, high);
3414       dest = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3415       insn = emit_move_insn (dest, src);
3416       if (DO_FRAME_NOTES)
3417         {
3418           REG_NOTES (insn)
3419             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3420                 gen_rtx_SET (VOIDmode,
3421                              gen_rtx_MEM (word_mode,
3422                                           gen_rtx_PLUS (word_mode, basereg,
3423                                                         delta)),
3424                              src),
3425                 REG_NOTES (insn));
3426         }
3427     }
3428
3429   if (DO_FRAME_NOTES)
3430     RTX_FRAME_RELATED_P (insn) = 1;
3431 }
3432
3433 /* Emit RTL to store REG at the memory location specified by BASE and then
3434    add MOD to BASE.  MOD must be <= 8k.  */
3435
3436 static void
3437 store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
3438 {
3439   rtx insn, basereg, srcreg, delta;
3440
3441   gcc_assert (VAL_14_BITS_P (mod));
3442
3443   basereg = gen_rtx_REG (Pmode, base);
3444   srcreg = gen_rtx_REG (word_mode, reg);
3445   delta = GEN_INT (mod);
3446
3447   insn = emit_insn (gen_post_store (basereg, srcreg, delta));
3448   if (DO_FRAME_NOTES)
3449     {
3450       RTX_FRAME_RELATED_P (insn) = 1;
3451
3452       /* RTX_FRAME_RELATED_P must be set on each frame related set
3453          in a parallel with more than one element.  */
3454       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 0)) = 1;
3455       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 1)) = 1;
3456     }
3457 }
3458
3459 /* Emit RTL to set REG to the value specified by BASE+DISP.  Handle case
3460    where DISP > 8k by using the add_high_const patterns.  NOTE indicates
3461    whether to add a frame note or not.
3462
3463    In the DISP > 8k case, we leave the high part of the address in %r1.
3464    There is code in expand_hppa_{prologue,epilogue} that knows about this.  */
3465
3466 static void
3467 set_reg_plus_d (int reg, int base, HOST_WIDE_INT disp, int note)
3468 {
3469   rtx insn;
3470
3471   if (VAL_14_BITS_P (disp))
3472     {
3473       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3474                              plus_constant (gen_rtx_REG (Pmode, base), disp));
3475     }
3476   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3477     {
3478       rtx basereg = gen_rtx_REG (Pmode, base);
3479       rtx delta = GEN_INT (disp);
3480       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3481
3482       emit_move_insn (tmpreg, delta);
3483       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3484                              gen_rtx_PLUS (Pmode, tmpreg, basereg));
3485       if (DO_FRAME_NOTES)
3486         REG_NOTES (insn)
3487           = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3488               gen_rtx_SET (VOIDmode, tmpreg,
3489                            gen_rtx_PLUS (Pmode, basereg, delta)),
3490               REG_NOTES (insn));
3491     }
3492   else
3493     {
3494       rtx basereg = gen_rtx_REG (Pmode, base);
3495       rtx delta = GEN_INT (disp);
3496       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3497
3498       emit_move_insn (tmpreg,
3499                       gen_rtx_PLUS (Pmode, basereg,
3500                                     gen_rtx_HIGH (Pmode, delta)));
3501       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3502                              gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3503     }
3504
3505   if (DO_FRAME_NOTES && note)
3506     RTX_FRAME_RELATED_P (insn) = 1;
3507 }
3508
3509 HOST_WIDE_INT
3510 compute_frame_size (HOST_WIDE_INT size, int *fregs_live)
3511 {
3512   int freg_saved = 0;
3513   int i, j;
3514
3515   /* The code in hppa_expand_prologue and hppa_expand_epilogue must
3516      be consistent with the rounding and size calculation done here.
3517      Change them at the same time.  */
3518
3519   /* We do our own stack alignment.  First, round the size of the
3520      stack locals up to a word boundary.  */
3521   size = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3522
3523   /* Space for previous frame pointer + filler.  If any frame is
3524      allocated, we need to add in the STARTING_FRAME_OFFSET.  We
3525      waste some space here for the sake of HP compatibility.  The
3526      first slot is only used when the frame pointer is needed.  */
3527   if (size || frame_pointer_needed)
3528     size += STARTING_FRAME_OFFSET;
3529   
3530   /* If the current function calls __builtin_eh_return, then we need
3531      to allocate stack space for registers that will hold data for
3532      the exception handler.  */
3533   if (DO_FRAME_NOTES && crtl->calls_eh_return)
3534     {
3535       unsigned int i;
3536
3537       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
3538         continue;
3539       size += i * UNITS_PER_WORD;
3540     }
3541
3542   /* Account for space used by the callee general register saves.  */
3543   for (i = 18, j = frame_pointer_needed ? 4 : 3; i >= j; i--)
3544     if (df_regs_ever_live_p (i))
3545       size += UNITS_PER_WORD;
3546
3547   /* Account for space used by the callee floating point register saves.  */
3548   for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3549     if (df_regs_ever_live_p (i)
3550         || (!TARGET_64BIT && df_regs_ever_live_p (i + 1)))
3551       {
3552         freg_saved = 1;
3553
3554         /* We always save both halves of the FP register, so always
3555            increment the frame size by 8 bytes.  */
3556         size += 8;
3557       }
3558
3559   /* If any of the floating registers are saved, account for the
3560      alignment needed for the floating point register save block.  */
3561   if (freg_saved)
3562     {
3563       size = (size + 7) & ~7;
3564       if (fregs_live)
3565         *fregs_live = 1;
3566     }
3567
3568   /* The various ABIs include space for the outgoing parameters in the
3569      size of the current function's stack frame.  We don't need to align
3570      for the outgoing arguments as their alignment is set by the final
3571      rounding for the frame as a whole.  */
3572   size += crtl->outgoing_args_size;
3573
3574   /* Allocate space for the fixed frame marker.  This space must be
3575      allocated for any function that makes calls or allocates
3576      stack space.  */
3577   if (!current_function_is_leaf || size)
3578     size += TARGET_64BIT ? 48 : 32;
3579
3580   /* Finally, round to the preferred stack boundary.  */
3581   return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
3582           & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
3583 }
3584
3585 /* Generate the assembly code for function entry.  FILE is a stdio
3586    stream to output the code to.  SIZE is an int: how many units of
3587    temporary storage to allocate.
3588
3589    Refer to the array `regs_ever_live' to determine which registers to
3590    save; `regs_ever_live[I]' is nonzero if register number I is ever
3591    used in the function.  This function is responsible for knowing
3592    which registers should not be saved even if used.  */
3593
3594 /* On HP-PA, move-double insns between fpu and cpu need an 8-byte block
3595    of memory.  If any fpu reg is used in the function, we allocate
3596    such a block here, at the bottom of the frame, just in case it's needed.
3597
3598    If this function is a leaf procedure, then we may choose not
3599    to do a "save" insn.  The decision about whether or not
3600    to do this is made in regclass.c.  */
3601
3602 static void
3603 pa_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3604 {
3605   /* The function's label and associated .PROC must never be
3606      separated and must be output *after* any profiling declarations
3607      to avoid changing spaces/subspaces within a procedure.  */
3608   ASM_OUTPUT_LABEL (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
3609   fputs ("\t.PROC\n", file);
3610
3611   /* hppa_expand_prologue does the dirty work now.  We just need
3612      to output the assembler directives which denote the start
3613      of a function.  */
3614   fprintf (file, "\t.CALLINFO FRAME=" HOST_WIDE_INT_PRINT_DEC, actual_fsize);
3615   if (current_function_is_leaf)
3616     fputs (",NO_CALLS", file);
3617   else
3618     fputs (",CALLS", file);
3619   if (rp_saved)
3620     fputs (",SAVE_RP", file);
3621
3622   /* The SAVE_SP flag is used to indicate that register %r3 is stored
3623      at the beginning of the frame and that it is used as the frame
3624      pointer for the frame.  We do this because our current frame
3625      layout doesn't conform to that specified in the HP runtime
3626      documentation and we need a way to indicate to programs such as
3627      GDB where %r3 is saved.  The SAVE_SP flag was chosen because it
3628      isn't used by HP compilers but is supported by the assembler.
3629      However, SAVE_SP is supposed to indicate that the previous stack
3630      pointer has been saved in the frame marker.  */
3631   if (frame_pointer_needed)
3632     fputs (",SAVE_SP", file);
3633
3634   /* Pass on information about the number of callee register saves
3635      performed in the prologue.
3636
3637      The compiler is supposed to pass the highest register number
3638      saved, the assembler then has to adjust that number before
3639      entering it into the unwind descriptor (to account for any
3640      caller saved registers with lower register numbers than the
3641      first callee saved register).  */
3642   if (gr_saved)
3643     fprintf (file, ",ENTRY_GR=%d", gr_saved + 2);
3644
3645   if (fr_saved)
3646     fprintf (file, ",ENTRY_FR=%d", fr_saved + 11);
3647
3648   fputs ("\n\t.ENTRY\n", file);
3649
3650   remove_useless_addtr_insns (0);
3651 }
3652
3653 void
3654 hppa_expand_prologue (void)
3655 {
3656   int merge_sp_adjust_with_store = 0;
3657   HOST_WIDE_INT size = get_frame_size ();
3658   HOST_WIDE_INT offset;
3659   int i;
3660   rtx insn, tmpreg;
3661
3662   gr_saved = 0;
3663   fr_saved = 0;
3664   save_fregs = 0;
3665
3666   /* Compute total size for frame pointer, filler, locals and rounding to
3667      the next word boundary.  Similar code appears in compute_frame_size
3668      and must be changed in tandem with this code.  */
3669   local_fsize = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3670   if (local_fsize || frame_pointer_needed)
3671     local_fsize += STARTING_FRAME_OFFSET;
3672
3673   actual_fsize = compute_frame_size (size, &save_fregs);
3674
3675   /* Compute a few things we will use often.  */
3676   tmpreg = gen_rtx_REG (word_mode, 1);
3677
3678   /* Save RP first.  The calling conventions manual states RP will
3679      always be stored into the caller's frame at sp - 20 or sp - 16
3680      depending on which ABI is in use.  */
3681   if (df_regs_ever_live_p (2) || crtl->calls_eh_return)
3682     {
3683       store_reg (2, TARGET_64BIT ? -16 : -20, STACK_POINTER_REGNUM);
3684       rp_saved = true;
3685     }
3686   else
3687     rp_saved = false;
3688
3689   /* Allocate the local frame and set up the frame pointer if needed.  */
3690   if (actual_fsize != 0)
3691     {
3692       if (frame_pointer_needed)
3693         {
3694           /* Copy the old frame pointer temporarily into %r1.  Set up the
3695              new stack pointer, then store away the saved old frame pointer
3696              into the stack at sp and at the same time update the stack
3697              pointer by actual_fsize bytes.  Two versions, first
3698              handles small (<8k) frames.  The second handles large (>=8k)
3699              frames.  */
3700           insn = emit_move_insn (tmpreg, frame_pointer_rtx);
3701           if (DO_FRAME_NOTES)
3702             RTX_FRAME_RELATED_P (insn) = 1;
3703
3704           insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
3705           if (DO_FRAME_NOTES)
3706             RTX_FRAME_RELATED_P (insn) = 1;
3707
3708           if (VAL_14_BITS_P (actual_fsize))
3709             store_reg_modify (STACK_POINTER_REGNUM, 1, actual_fsize);
3710           else
3711             {
3712               /* It is incorrect to store the saved frame pointer at *sp,
3713                  then increment sp (writes beyond the current stack boundary).
3714
3715                  So instead use stwm to store at *sp and post-increment the
3716                  stack pointer as an atomic operation.  Then increment sp to
3717                  finish allocating the new frame.  */
3718               HOST_WIDE_INT adjust1 = 8192 - 64;
3719               HOST_WIDE_INT adjust2 = actual_fsize - adjust1;
3720
3721               store_reg_modify (STACK_POINTER_REGNUM, 1, adjust1);
3722               set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3723                               adjust2, 1);
3724             }
3725
3726           /* We set SAVE_SP in frames that need a frame pointer.  Thus,
3727              we need to store the previous stack pointer (frame pointer)
3728              into the frame marker on targets that use the HP unwind
3729              library.  This allows the HP unwind library to be used to
3730              unwind GCC frames.  However, we are not fully compatible
3731              with the HP library because our frame layout differs from
3732              that specified in the HP runtime specification.
3733
3734              We don't want a frame note on this instruction as the frame
3735              marker moves during dynamic stack allocation.
3736
3737              This instruction also serves as a blockage to prevent
3738              register spills from being scheduled before the stack
3739              pointer is raised.  This is necessary as we store
3740              registers using the frame pointer as a base register,
3741              and the frame pointer is set before sp is raised.  */
3742           if (TARGET_HPUX_UNWIND_LIBRARY)
3743             {
3744               rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx,
3745                                        GEN_INT (TARGET_64BIT ? -8 : -4));
3746
3747               emit_move_insn (gen_rtx_MEM (word_mode, addr),
3748                               frame_pointer_rtx);
3749             }
3750           else
3751             emit_insn (gen_blockage ());
3752         }
3753       /* no frame pointer needed.  */
3754       else
3755         {
3756           /* In some cases we can perform the first callee register save
3757              and allocating the stack frame at the same time.   If so, just
3758              make a note of it and defer allocating the frame until saving
3759              the callee registers.  */
3760           if (VAL_14_BITS_P (actual_fsize) && local_fsize == 0)
3761             merge_sp_adjust_with_store = 1;
3762           /* Can not optimize.  Adjust the stack frame by actual_fsize
3763              bytes.  */
3764           else
3765             set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3766                             actual_fsize, 1);
3767         }
3768     }
3769
3770   /* Normal register save.
3771
3772      Do not save the frame pointer in the frame_pointer_needed case.  It
3773      was done earlier.  */
3774   if (frame_pointer_needed)
3775     {
3776       offset = local_fsize;
3777
3778       /* Saving the EH return data registers in the frame is the simplest
3779          way to get the frame unwind information emitted.  We put them
3780          just before the general registers.  */
3781       if (DO_FRAME_NOTES && crtl->calls_eh_return)
3782         {
3783           unsigned int i, regno;
3784
3785           for (i = 0; ; ++i)
3786             {
3787               regno = EH_RETURN_DATA_REGNO (i);
3788               if (regno == INVALID_REGNUM)
3789                 break;
3790
3791               store_reg (regno, offset, FRAME_POINTER_REGNUM);
3792               offset += UNITS_PER_WORD;
3793             }
3794         }
3795
3796       for (i = 18; i >= 4; i--)
3797         if (df_regs_ever_live_p (i) && ! call_used_regs[i])
3798           {
3799             store_reg (i, offset, FRAME_POINTER_REGNUM);
3800             offset += UNITS_PER_WORD;
3801             gr_saved++;
3802           }
3803       /* Account for %r3 which is saved in a special place.  */
3804       gr_saved++;
3805     }
3806   /* No frame pointer needed.  */
3807   else
3808     {
3809       offset = local_fsize - actual_fsize;
3810
3811       /* Saving the EH return data registers in the frame is the simplest
3812          way to get the frame unwind information emitted.  */
3813       if (DO_FRAME_NOTES && crtl->calls_eh_return)
3814         {
3815           unsigned int i, regno;
3816
3817           for (i = 0; ; ++i)
3818             {
3819               regno = EH_RETURN_DATA_REGNO (i);
3820               if (regno == INVALID_REGNUM)
3821                 break;
3822
3823               /* If merge_sp_adjust_with_store is nonzero, then we can
3824                  optimize the first save.  */
3825               if (merge_sp_adjust_with_store)
3826                 {
3827                   store_reg_modify (STACK_POINTER_REGNUM, regno, -offset);
3828                   merge_sp_adjust_with_store = 0;
3829                 }
3830               else
3831                 store_reg (regno, offset, STACK_POINTER_REGNUM);
3832               offset += UNITS_PER_WORD;
3833             }
3834         }
3835
3836       for (i = 18; i >= 3; i--)
3837         if (df_regs_ever_live_p (i) && ! call_used_regs[i])
3838           {
3839             /* If merge_sp_adjust_with_store is nonzero, then we can
3840                optimize the first GR save.  */
3841             if (merge_sp_adjust_with_store)
3842               {
3843                 store_reg_modify (STACK_POINTER_REGNUM, i, -offset);
3844                 merge_sp_adjust_with_store = 0;
3845               }
3846             else
3847               store_reg (i, offset, STACK_POINTER_REGNUM);
3848             offset += UNITS_PER_WORD;
3849             gr_saved++;
3850           }
3851
3852       /* If we wanted to merge the SP adjustment with a GR save, but we never
3853          did any GR saves, then just emit the adjustment here.  */
3854       if (merge_sp_adjust_with_store)
3855         set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3856                         actual_fsize, 1);
3857     }
3858
3859   /* The hppa calling conventions say that %r19, the pic offset
3860      register, is saved at sp - 32 (in this function's frame)
3861      when generating PIC code.  FIXME:  What is the correct thing
3862      to do for functions which make no calls and allocate no
3863      frame?  Do we need to allocate a frame, or can we just omit
3864      the save?   For now we'll just omit the save.
3865      
3866      We don't want a note on this insn as the frame marker can
3867      move if there is a dynamic stack allocation.  */
3868   if (flag_pic && actual_fsize != 0 && !TARGET_64BIT)
3869     {
3870       rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx, GEN_INT (-32));
3871
3872       emit_move_insn (gen_rtx_MEM (word_mode, addr), pic_offset_table_rtx);
3873
3874     }
3875
3876   /* Align pointer properly (doubleword boundary).  */
3877   offset = (offset + 7) & ~7;
3878
3879   /* Floating point register store.  */
3880   if (save_fregs)
3881     {
3882       rtx base;
3883
3884       /* First get the frame or stack pointer to the start of the FP register
3885          save area.  */
3886       if (frame_pointer_needed)
3887         {
3888           set_reg_plus_d (1, FRAME_POINTER_REGNUM, offset, 0);
3889           base = frame_pointer_rtx;
3890         }
3891       else
3892         {
3893           set_reg_plus_d (1, STACK_POINTER_REGNUM, offset, 0);
3894           base = stack_pointer_rtx;
3895         }
3896
3897       /* Now actually save the FP registers.  */
3898       for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3899         {
3900           if (df_regs_ever_live_p (i)
3901               || (! TARGET_64BIT && df_regs_ever_live_p (i + 1)))
3902             {
3903               rtx addr, insn, reg;
3904               addr = gen_rtx_MEM (DFmode, gen_rtx_POST_INC (DFmode, tmpreg));
3905               reg = gen_rtx_REG (DFmode, i);
3906               insn = emit_move_insn (addr, reg);
3907               if (DO_FRAME_NOTES)
3908                 {
3909                   RTX_FRAME_RELATED_P (insn) = 1;
3910                   if (TARGET_64BIT)
3911                     {
3912                       rtx mem = gen_rtx_MEM (DFmode,
3913                                              plus_constant (base, offset));
3914                       REG_NOTES (insn)
3915                         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3916                                              gen_rtx_SET (VOIDmode, mem, reg),
3917                                              REG_NOTES (insn));
3918                     }
3919                   else
3920                     {
3921                       rtx meml = gen_rtx_MEM (SFmode,
3922                                               plus_constant (base, offset));
3923                       rtx memr = gen_rtx_MEM (SFmode,
3924                                               plus_constant (base, offset + 4));
3925                       rtx regl = gen_rtx_REG (SFmode, i);
3926                       rtx regr = gen_rtx_REG (SFmode, i + 1);
3927                       rtx setl = gen_rtx_SET (VOIDmode, meml, regl);
3928                       rtx setr = gen_rtx_SET (VOIDmode, memr, regr);
3929                       rtvec vec;
3930
3931                       RTX_FRAME_RELATED_P (setl) = 1;
3932                       RTX_FRAME_RELATED_P (setr) = 1;
3933                       vec = gen_rtvec (2, setl, setr);
3934  &