OSDN Git Service

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