OSDN Git Service

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