OSDN Git Service

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