OSDN Git Service

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