OSDN Git Service

d4800fee44e58913f149f0a58e95686c20089988
[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 auto decrementing and incrementing loads and stores
2213      specifically, since the structure of the function doesn't work
2214      for them without major modification.  Do it better when we learn
2215      this port about the general inc/dec addressing of PA.
2216      (This was written by tege.  Chide him if it doesn't work.)  */
2217
2218   if (optype0 == MEMOP)
2219     {
2220       /* We have to output the address syntax ourselves, since print_operand
2221          doesn't deal with the addresses we want to use.  Fix this later.  */
2222
2223       rtx addr = XEXP (operands[0], 0);
2224       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2225         {
2226           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2227
2228           operands[0] = XEXP (addr, 0);
2229           gcc_assert (GET_CODE (operands[1]) == REG
2230                       && GET_CODE (operands[0]) == REG);
2231
2232           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2233           
2234           /* No overlap between high target register and address
2235              register.  (We do this in a non-obvious way to
2236              save a register file writeback)  */
2237           if (GET_CODE (addr) == POST_INC)
2238             return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2239           return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2240         }
2241       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2242         {
2243           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2244
2245           operands[0] = XEXP (addr, 0);
2246           gcc_assert (GET_CODE (operands[1]) == REG
2247                       && GET_CODE (operands[0]) == REG);
2248           
2249           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2250           /* No overlap between high target register and address
2251              register.  (We do this in a non-obvious way to save a
2252              register file writeback)  */
2253           if (GET_CODE (addr) == PRE_INC)
2254             return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2255           return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2256         }
2257     }
2258   if (optype1 == MEMOP)
2259     {
2260       /* We have to output the address syntax ourselves, since print_operand
2261          doesn't deal with the addresses we want to use.  Fix this later.  */
2262
2263       rtx addr = XEXP (operands[1], 0);
2264       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2265         {
2266           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2267
2268           operands[1] = XEXP (addr, 0);
2269           gcc_assert (GET_CODE (operands[0]) == REG
2270                       && GET_CODE (operands[1]) == REG);
2271
2272           if (!reg_overlap_mentioned_p (high_reg, addr))
2273             {
2274               /* No overlap between high target register and address
2275                  register.  (We do this in a non-obvious way to
2276                  save a register file writeback)  */
2277               if (GET_CODE (addr) == POST_INC)
2278                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2279               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2280             }
2281           else
2282             {
2283               /* This is an undefined situation.  We should load into the
2284                  address register *and* update that register.  Probably
2285                  we don't need to handle this at all.  */
2286               if (GET_CODE (addr) == POST_INC)
2287                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2288               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2289             }
2290         }
2291       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2292         {
2293           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2294
2295           operands[1] = XEXP (addr, 0);
2296           gcc_assert (GET_CODE (operands[0]) == REG
2297                       && GET_CODE (operands[1]) == REG);
2298
2299           if (!reg_overlap_mentioned_p (high_reg, addr))
2300             {
2301               /* No overlap between high target register and address
2302                  register.  (We do this in a non-obvious way to
2303                  save a register file writeback)  */
2304               if (GET_CODE (addr) == PRE_INC)
2305                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2306               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2307             }
2308           else
2309             {
2310               /* This is an undefined situation.  We should load into the
2311                  address register *and* update that register.  Probably
2312                  we don't need to handle this at all.  */
2313               if (GET_CODE (addr) == PRE_INC)
2314                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2315               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2316             }
2317         }
2318       else if (GET_CODE (addr) == PLUS
2319                && GET_CODE (XEXP (addr, 0)) == MULT)
2320         {
2321           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2322
2323           if (!reg_overlap_mentioned_p (high_reg, addr))
2324             {
2325               rtx xoperands[3];
2326
2327               xoperands[0] = high_reg;
2328               xoperands[1] = XEXP (addr, 1);
2329               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2330               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2331               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2332                                xoperands);
2333               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2334             }
2335           else
2336             {
2337               rtx xoperands[3];
2338
2339               xoperands[0] = high_reg;
2340               xoperands[1] = XEXP (addr, 1);
2341               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2342               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2343               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2344                                xoperands);
2345               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2346             }
2347         }
2348     }
2349
2350   /* If an operand is an unoffsettable memory ref, find a register
2351      we can increment temporarily to make it refer to the second word.  */
2352
2353   if (optype0 == MEMOP)
2354     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2355
2356   if (optype1 == MEMOP)
2357     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2358
2359   /* Ok, we can do one word at a time.
2360      Normally we do the low-numbered word first.
2361
2362      In either case, set up in LATEHALF the operands to use
2363      for the high-numbered word and in some cases alter the
2364      operands in OPERANDS to be suitable for the low-numbered word.  */
2365
2366   if (optype0 == REGOP)
2367     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2368   else if (optype0 == OFFSOP)
2369     latehalf[0] = adjust_address (operands[0], SImode, 4);
2370   else
2371     latehalf[0] = operands[0];
2372
2373   if (optype1 == REGOP)
2374     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2375   else if (optype1 == OFFSOP)
2376     latehalf[1] = adjust_address (operands[1], SImode, 4);
2377   else if (optype1 == CNSTOP)
2378     split_double (operands[1], &operands[1], &latehalf[1]);
2379   else
2380     latehalf[1] = operands[1];
2381
2382   /* If the first move would clobber the source of the second one,
2383      do them in the other order.
2384
2385      This can happen in two cases:
2386
2387         mem -> register where the first half of the destination register
2388         is the same register used in the memory's address.  Reload
2389         can create such insns.
2390
2391         mem in this case will be either register indirect or register
2392         indirect plus a valid offset.
2393
2394         register -> register move where REGNO(dst) == REGNO(src + 1)
2395         someone (Tim/Tege?) claimed this can happen for parameter loads.
2396
2397      Handle mem -> register case first.  */
2398   if (optype0 == REGOP
2399       && (optype1 == MEMOP || optype1 == OFFSOP)
2400       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2401                             operands[1], 0))
2402     {
2403       /* Do the late half first.  */
2404       if (addreg1)
2405         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2406       output_asm_insn (singlemove_string (latehalf), latehalf);
2407
2408       /* Then clobber.  */
2409       if (addreg1)
2410         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2411       return singlemove_string (operands);
2412     }
2413
2414   /* Now handle register -> register case.  */
2415   if (optype0 == REGOP && optype1 == REGOP
2416       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2417     {
2418       output_asm_insn (singlemove_string (latehalf), latehalf);
2419       return singlemove_string (operands);
2420     }
2421
2422   /* Normal case: do the two words, low-numbered first.  */
2423
2424   output_asm_insn (singlemove_string (operands), operands);
2425
2426   /* Make any unoffsettable addresses point at high-numbered word.  */
2427   if (addreg0)
2428     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2429   if (addreg1)
2430     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2431
2432   /* Do that word.  */
2433   output_asm_insn (singlemove_string (latehalf), latehalf);
2434
2435   /* Undo the adds we just did.  */
2436   if (addreg0)
2437     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2438   if (addreg1)
2439     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2440
2441   return "";
2442 }
2443 \f
2444 const char *
2445 output_fp_move_double (rtx *operands)
2446 {
2447   if (FP_REG_P (operands[0]))
2448     {
2449       if (FP_REG_P (operands[1])
2450           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2451         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2452       else
2453         output_asm_insn ("fldd%F1 %1,%0", operands);
2454     }
2455   else if (FP_REG_P (operands[1]))
2456     {
2457       output_asm_insn ("fstd%F0 %1,%0", operands);
2458     }
2459   else
2460     {
2461       rtx xoperands[2];
2462       
2463       gcc_assert (operands[1] == CONST0_RTX (GET_MODE (operands[0])));
2464       
2465       /* This is a pain.  You have to be prepared to deal with an
2466          arbitrary address here including pre/post increment/decrement.
2467
2468          so avoid this in the MD.  */
2469       gcc_assert (GET_CODE (operands[0]) == REG);
2470       
2471       xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2472       xoperands[0] = operands[0];
2473       output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2474     }
2475   return "";
2476 }
2477 \f
2478 /* Return a REG that occurs in ADDR with coefficient 1.
2479    ADDR can be effectively incremented by incrementing REG.  */
2480
2481 static rtx
2482 find_addr_reg (rtx addr)
2483 {
2484   while (GET_CODE (addr) == PLUS)
2485     {
2486       if (GET_CODE (XEXP (addr, 0)) == REG)
2487         addr = XEXP (addr, 0);
2488       else if (GET_CODE (XEXP (addr, 1)) == REG)
2489         addr = XEXP (addr, 1);
2490       else if (CONSTANT_P (XEXP (addr, 0)))
2491         addr = XEXP (addr, 1);
2492       else if (CONSTANT_P (XEXP (addr, 1)))
2493         addr = XEXP (addr, 0);
2494       else
2495         gcc_unreachable ();
2496     }
2497   gcc_assert (GET_CODE (addr) == REG);
2498   return addr;
2499 }
2500
2501 /* Emit code to perform a block move.
2502
2503    OPERANDS[0] is the destination pointer as a REG, clobbered.
2504    OPERANDS[1] is the source pointer as a REG, clobbered.
2505    OPERANDS[2] is a register for temporary storage.
2506    OPERANDS[3] is a register for temporary storage.
2507    OPERANDS[4] is the size as a CONST_INT
2508    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2509    OPERANDS[6] is another temporary register.  */
2510
2511 const char *
2512 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2513 {
2514   int align = INTVAL (operands[5]);
2515   unsigned long n_bytes = INTVAL (operands[4]);
2516
2517   /* We can't move more than a word at a time because the PA
2518      has no longer integer move insns.  (Could use fp mem ops?)  */
2519   if (align > (TARGET_64BIT ? 8 : 4))
2520     align = (TARGET_64BIT ? 8 : 4);
2521
2522   /* Note that we know each loop below will execute at least twice
2523      (else we would have open-coded the copy).  */
2524   switch (align)
2525     {
2526       case 8:
2527         /* Pre-adjust the loop counter.  */
2528         operands[4] = GEN_INT (n_bytes - 16);
2529         output_asm_insn ("ldi %4,%2", operands);
2530
2531         /* Copying loop.  */
2532         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2533         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2534         output_asm_insn ("std,ma %3,8(%0)", operands);
2535         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2536         output_asm_insn ("std,ma %6,8(%0)", operands);
2537
2538         /* Handle the residual.  There could be up to 7 bytes of
2539            residual to copy!  */
2540         if (n_bytes % 16 != 0)
2541           {
2542             operands[4] = GEN_INT (n_bytes % 8);
2543             if (n_bytes % 16 >= 8)
2544               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2545             if (n_bytes % 8 != 0)
2546               output_asm_insn ("ldd 0(%1),%6", operands);
2547             if (n_bytes % 16 >= 8)
2548               output_asm_insn ("std,ma %3,8(%0)", operands);
2549             if (n_bytes % 8 != 0)
2550               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2551           }
2552         return "";
2553
2554       case 4:
2555         /* Pre-adjust the loop counter.  */
2556         operands[4] = GEN_INT (n_bytes - 8);
2557         output_asm_insn ("ldi %4,%2", operands);
2558
2559         /* Copying loop.  */
2560         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2561         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2562         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2563         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2564         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2565
2566         /* Handle the residual.  There could be up to 7 bytes of
2567            residual to copy!  */
2568         if (n_bytes % 8 != 0)
2569           {
2570             operands[4] = GEN_INT (n_bytes % 4);
2571             if (n_bytes % 8 >= 4)
2572               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2573             if (n_bytes % 4 != 0)
2574               output_asm_insn ("ldw 0(%1),%6", operands);
2575             if (n_bytes % 8 >= 4)
2576               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2577             if (n_bytes % 4 != 0)
2578               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2579           }
2580         return "";
2581
2582       case 2:
2583         /* Pre-adjust the loop counter.  */
2584         operands[4] = GEN_INT (n_bytes - 4);
2585         output_asm_insn ("ldi %4,%2", operands);
2586
2587         /* Copying loop.  */
2588         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2589         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2590         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2591         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2592         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2593
2594         /* Handle the residual.  */
2595         if (n_bytes % 4 != 0)
2596           {
2597             if (n_bytes % 4 >= 2)
2598               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2599             if (n_bytes % 2 != 0)
2600               output_asm_insn ("ldb 0(%1),%6", operands);
2601             if (n_bytes % 4 >= 2)
2602               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2603             if (n_bytes % 2 != 0)
2604               output_asm_insn ("stb %6,0(%0)", operands);
2605           }
2606         return "";
2607
2608       case 1:
2609         /* Pre-adjust the loop counter.  */
2610         operands[4] = GEN_INT (n_bytes - 2);
2611         output_asm_insn ("ldi %4,%2", operands);
2612
2613         /* Copying loop.  */
2614         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2615         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2616         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2617         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2618         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2619
2620         /* Handle the residual.  */
2621         if (n_bytes % 2 != 0)
2622           {
2623             output_asm_insn ("ldb 0(%1),%3", operands);
2624             output_asm_insn ("stb %3,0(%0)", operands);
2625           }
2626         return "";
2627
2628       default:
2629         gcc_unreachable ();
2630     }
2631 }
2632
2633 /* Count the number of insns necessary to handle this block move.
2634
2635    Basic structure is the same as emit_block_move, except that we
2636    count insns rather than emit them.  */
2637
2638 static int
2639 compute_movmem_length (rtx insn)
2640 {
2641   rtx pat = PATTERN (insn);
2642   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2643   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2644   unsigned int n_insns = 0;
2645
2646   /* We can't move more than four bytes at a time because the PA
2647      has no longer integer move insns.  (Could use fp mem ops?)  */
2648   if (align > (TARGET_64BIT ? 8 : 4))
2649     align = (TARGET_64BIT ? 8 : 4);
2650
2651   /* The basic copying loop.  */
2652   n_insns = 6;
2653
2654   /* Residuals.  */
2655   if (n_bytes % (2 * align) != 0)
2656     {
2657       if ((n_bytes % (2 * align)) >= align)
2658         n_insns += 2;
2659
2660       if ((n_bytes % align) != 0)
2661         n_insns += 2;
2662     }
2663
2664   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2665   return n_insns * 4;
2666 }
2667
2668 /* Emit code to perform a block clear.
2669
2670    OPERANDS[0] is the destination pointer as a REG, clobbered.
2671    OPERANDS[1] is a register for temporary storage.
2672    OPERANDS[2] is the size as a CONST_INT
2673    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
2674
2675 const char *
2676 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2677 {
2678   int align = INTVAL (operands[3]);
2679   unsigned long n_bytes = INTVAL (operands[2]);
2680
2681   /* We can't clear more than a word at a time because the PA
2682      has no longer integer move insns.  */
2683   if (align > (TARGET_64BIT ? 8 : 4))
2684     align = (TARGET_64BIT ? 8 : 4);
2685
2686   /* Note that we know each loop below will execute at least twice
2687      (else we would have open-coded the copy).  */
2688   switch (align)
2689     {
2690       case 8:
2691         /* Pre-adjust the loop counter.  */
2692         operands[2] = GEN_INT (n_bytes - 16);
2693         output_asm_insn ("ldi %2,%1", operands);
2694
2695         /* Loop.  */
2696         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2697         output_asm_insn ("addib,>= -16,%1,.-4", operands);
2698         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2699
2700         /* Handle the residual.  There could be up to 7 bytes of
2701            residual to copy!  */
2702         if (n_bytes % 16 != 0)
2703           {
2704             operands[2] = GEN_INT (n_bytes % 8);
2705             if (n_bytes % 16 >= 8)
2706               output_asm_insn ("std,ma %%r0,8(%0)", operands);
2707             if (n_bytes % 8 != 0)
2708               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
2709           }
2710         return "";
2711
2712       case 4:
2713         /* Pre-adjust the loop counter.  */
2714         operands[2] = GEN_INT (n_bytes - 8);
2715         output_asm_insn ("ldi %2,%1", operands);
2716
2717         /* Loop.  */
2718         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2719         output_asm_insn ("addib,>= -8,%1,.-4", operands);
2720         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2721
2722         /* Handle the residual.  There could be up to 7 bytes of
2723            residual to copy!  */
2724         if (n_bytes % 8 != 0)
2725           {
2726             operands[2] = GEN_INT (n_bytes % 4);
2727             if (n_bytes % 8 >= 4)
2728               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2729             if (n_bytes % 4 != 0)
2730               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
2731           }
2732         return "";
2733
2734       case 2:
2735         /* Pre-adjust the loop counter.  */
2736         operands[2] = GEN_INT (n_bytes - 4);
2737         output_asm_insn ("ldi %2,%1", operands);
2738
2739         /* Loop.  */
2740         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2741         output_asm_insn ("addib,>= -4,%1,.-4", operands);
2742         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2743
2744         /* Handle the residual.  */
2745         if (n_bytes % 4 != 0)
2746           {
2747             if (n_bytes % 4 >= 2)
2748               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2749             if (n_bytes % 2 != 0)
2750               output_asm_insn ("stb %%r0,0(%0)", operands);
2751           }
2752         return "";
2753
2754       case 1:
2755         /* Pre-adjust the loop counter.  */
2756         operands[2] = GEN_INT (n_bytes - 2);
2757         output_asm_insn ("ldi %2,%1", operands);
2758
2759         /* Loop.  */
2760         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2761         output_asm_insn ("addib,>= -2,%1,.-4", operands);
2762         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2763
2764         /* Handle the residual.  */
2765         if (n_bytes % 2 != 0)
2766           output_asm_insn ("stb %%r0,0(%0)", operands);
2767
2768         return "";
2769
2770       default:
2771         gcc_unreachable ();
2772     }
2773 }
2774
2775 /* Count the number of insns necessary to handle this block move.
2776
2777    Basic structure is the same as emit_block_move, except that we
2778    count insns rather than emit them.  */
2779
2780 static int
2781 compute_clrmem_length (rtx insn)
2782 {
2783   rtx pat = PATTERN (insn);
2784   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
2785   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
2786   unsigned int n_insns = 0;
2787
2788   /* We can't clear more than a word at a time because the PA
2789      has no longer integer move insns.  */
2790   if (align > (TARGET_64BIT ? 8 : 4))
2791     align = (TARGET_64BIT ? 8 : 4);
2792
2793   /* The basic loop.  */
2794   n_insns = 4;
2795
2796   /* Residuals.  */
2797   if (n_bytes % (2 * align) != 0)
2798     {
2799       if ((n_bytes % (2 * align)) >= align)
2800         n_insns++;
2801
2802       if ((n_bytes % align) != 0)
2803         n_insns++;
2804     }
2805
2806   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2807   return n_insns * 4;
2808 }
2809 \f
2810
2811 const char *
2812 output_and (rtx *operands)
2813 {
2814   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2815     {
2816       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2817       int ls0, ls1, ms0, p, len;
2818
2819       for (ls0 = 0; ls0 < 32; ls0++)
2820         if ((mask & (1 << ls0)) == 0)
2821           break;
2822
2823       for (ls1 = ls0; ls1 < 32; ls1++)
2824         if ((mask & (1 << ls1)) != 0)
2825           break;
2826
2827       for (ms0 = ls1; ms0 < 32; ms0++)
2828         if ((mask & (1 << ms0)) == 0)
2829           break;
2830
2831       gcc_assert (ms0 == 32);
2832
2833       if (ls1 == 32)
2834         {
2835           len = ls0;
2836
2837           gcc_assert (len);
2838
2839           operands[2] = GEN_INT (len);
2840           return "{extru|extrw,u} %1,31,%2,%0";
2841         }
2842       else
2843         {
2844           /* We could use this `depi' for the case above as well, but `depi'
2845              requires one more register file access than an `extru'.  */
2846
2847           p = 31 - ls0;
2848           len = ls1 - ls0;
2849
2850           operands[2] = GEN_INT (p);
2851           operands[3] = GEN_INT (len);
2852           return "{depi|depwi} 0,%2,%3,%0";
2853         }
2854     }
2855   else
2856     return "and %1,%2,%0";
2857 }
2858
2859 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2860    storing the result in operands[0].  */
2861 const char *
2862 output_64bit_and (rtx *operands)
2863 {
2864   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2865     {
2866       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2867       int ls0, ls1, ms0, p, len;
2868
2869       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
2870         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
2871           break;
2872
2873       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
2874         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
2875           break;
2876
2877       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
2878         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
2879           break;
2880
2881       gcc_assert (ms0 == HOST_BITS_PER_WIDE_INT);
2882
2883       if (ls1 == HOST_BITS_PER_WIDE_INT)
2884         {
2885           len = ls0;
2886
2887           gcc_assert (len);
2888
2889           operands[2] = GEN_INT (len);
2890           return "extrd,u %1,63,%2,%0";
2891         }
2892       else
2893         {
2894           /* We could use this `depi' for the case above as well, but `depi'
2895              requires one more register file access than an `extru'.  */
2896
2897           p = 63 - ls0;
2898           len = ls1 - ls0;
2899
2900           operands[2] = GEN_INT (p);
2901           operands[3] = GEN_INT (len);
2902           return "depdi 0,%2,%3,%0";
2903         }
2904     }
2905   else
2906     return "and %1,%2,%0";
2907 }
2908
2909 const char *
2910 output_ior (rtx *operands)
2911 {
2912   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2913   int bs0, bs1, p, len;
2914
2915   if (INTVAL (operands[2]) == 0)
2916     return "copy %1,%0";
2917
2918   for (bs0 = 0; bs0 < 32; bs0++)
2919     if ((mask & (1 << bs0)) != 0)
2920       break;
2921
2922   for (bs1 = bs0; bs1 < 32; bs1++)
2923     if ((mask & (1 << bs1)) == 0)
2924       break;
2925
2926   gcc_assert (bs1 == 32 || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2927
2928   p = 31 - bs0;
2929   len = bs1 - bs0;
2930
2931   operands[2] = GEN_INT (p);
2932   operands[3] = GEN_INT (len);
2933   return "{depi|depwi} -1,%2,%3,%0";
2934 }
2935
2936 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2937    storing the result in operands[0].  */
2938 const char *
2939 output_64bit_ior (rtx *operands)
2940 {
2941   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2942   int bs0, bs1, p, len;
2943
2944   if (INTVAL (operands[2]) == 0)
2945     return "copy %1,%0";
2946
2947   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
2948     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
2949       break;
2950
2951   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
2952     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
2953       break;
2954
2955   gcc_assert (bs1 == HOST_BITS_PER_WIDE_INT
2956               || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2957
2958   p = 63 - bs0;
2959   len = bs1 - bs0;
2960
2961   operands[2] = GEN_INT (p);
2962   operands[3] = GEN_INT (len);
2963   return "depdi -1,%2,%3,%0";
2964 }
2965 \f
2966 /* Target hook for assembling integer objects.  This code handles
2967    aligned SI and DI integers specially since function references
2968    must be preceded by P%.  */
2969
2970 static bool
2971 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
2972 {
2973   if (size == UNITS_PER_WORD
2974       && aligned_p
2975       && function_label_operand (x, VOIDmode))
2976     {
2977       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
2978       output_addr_const (asm_out_file, x);
2979       fputc ('\n', asm_out_file);
2980       return true;
2981     }
2982   return default_assemble_integer (x, size, aligned_p);
2983 }
2984 \f
2985 /* Output an ascii string.  */
2986 void
2987 output_ascii (FILE *file, const char *p, int size)
2988 {
2989   int i;
2990   int chars_output;
2991   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
2992
2993   /* The HP assembler can only take strings of 256 characters at one
2994      time.  This is a limitation on input line length, *not* the
2995      length of the string.  Sigh.  Even worse, it seems that the
2996      restriction is in number of input characters (see \xnn &
2997      \whatever).  So we have to do this very carefully.  */
2998
2999   fputs ("\t.STRING \"", file);
3000
3001   chars_output = 0;
3002   for (i = 0; i < size; i += 4)
3003     {
3004       int co = 0;
3005       int io = 0;
3006       for (io = 0, co = 0; io < MIN (4, size - i); io++)
3007         {
3008           register unsigned int c = (unsigned char) p[i + io];
3009
3010           if (c == '\"' || c == '\\')
3011             partial_output[co++] = '\\';
3012           if (c >= ' ' && c < 0177)
3013             partial_output[co++] = c;
3014           else
3015             {
3016               unsigned int hexd;
3017               partial_output[co++] = '\\';
3018               partial_output[co++] = 'x';
3019               hexd =  c  / 16 - 0 + '0';
3020               if (hexd > '9')
3021                 hexd -= '9' - 'a' + 1;
3022               partial_output[co++] = hexd;
3023               hexd =  c % 16 - 0 + '0';
3024               if (hexd > '9')
3025                 hexd -= '9' - 'a' + 1;
3026               partial_output[co++] = hexd;
3027             }
3028         }
3029       if (chars_output + co > 243)
3030         {
3031           fputs ("\"\n\t.STRING \"", file);
3032           chars_output = 0;
3033         }
3034       fwrite (partial_output, 1, (size_t) co, file);
3035       chars_output += co;
3036       co = 0;
3037     }
3038   fputs ("\"\n", file);
3039 }
3040
3041 /* Try to rewrite floating point comparisons & branches to avoid
3042    useless add,tr insns.
3043
3044    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3045    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3046    first attempt to remove useless add,tr insns.  It is zero
3047    for the second pass as reorg sometimes leaves bogus REG_DEAD
3048    notes lying around.
3049
3050    When CHECK_NOTES is zero we can only eliminate add,tr insns
3051    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3052    instructions.  */
3053 static void
3054 remove_useless_addtr_insns (int check_notes)
3055 {
3056   rtx insn;
3057   static int pass = 0;
3058
3059   /* This is fairly cheap, so always run it when optimizing.  */
3060   if (optimize > 0)
3061     {
3062       int fcmp_count = 0;
3063       int fbranch_count = 0;
3064
3065       /* Walk all the insns in this function looking for fcmp & fbranch
3066          instructions.  Keep track of how many of each we find.  */
3067       for (insn = get_insns (); insn; insn = next_insn (insn))
3068         {
3069           rtx tmp;
3070
3071           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3072           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3073             continue;
3074
3075           tmp = PATTERN (insn);
3076
3077           /* It must be a set.  */
3078           if (GET_CODE (tmp) != SET)
3079             continue;
3080
3081           /* If the destination is CCFP, then we've found an fcmp insn.  */
3082           tmp = SET_DEST (tmp);
3083           if (GET_CODE (tmp) == REG && REGNO (tmp) == 0)
3084             {
3085               fcmp_count++;
3086               continue;
3087             }
3088
3089           tmp = PATTERN (insn);
3090           /* If this is an fbranch instruction, bump the fbranch counter.  */
3091           if (GET_CODE (tmp) == SET
3092               && SET_DEST (tmp) == pc_rtx
3093               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
3094               && GET_CODE (XEXP (SET_SRC (tmp), 0)) == NE
3095               && GET_CODE (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == REG
3096               && REGNO (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == 0)
3097             {
3098               fbranch_count++;
3099               continue;
3100             }
3101         }
3102
3103
3104       /* Find all floating point compare + branch insns.  If possible,
3105          reverse the comparison & the branch to avoid add,tr insns.  */
3106       for (insn = get_insns (); insn; insn = next_insn (insn))
3107         {
3108           rtx tmp, next;
3109
3110           /* Ignore anything that isn't an INSN.  */
3111           if (GET_CODE (insn) != INSN)
3112             continue;
3113
3114           tmp = PATTERN (insn);
3115
3116           /* It must be a set.  */
3117           if (GET_CODE (tmp) != SET)
3118             continue;
3119
3120           /* The destination must be CCFP, which is register zero.  */
3121           tmp = SET_DEST (tmp);
3122           if (GET_CODE (tmp) != REG || REGNO (tmp) != 0)
3123             continue;
3124
3125           /* INSN should be a set of CCFP.
3126
3127              See if the result of this insn is used in a reversed FP
3128              conditional branch.  If so, reverse our condition and
3129              the branch.  Doing so avoids useless add,tr insns.  */
3130           next = next_insn (insn);
3131           while (next)
3132             {
3133               /* Jumps, calls and labels stop our search.  */
3134               if (GET_CODE (next) == JUMP_INSN
3135                   || GET_CODE (next) == CALL_INSN
3136                   || GET_CODE (next) == CODE_LABEL)
3137                 break;
3138
3139               /* As does another fcmp insn.  */
3140               if (GET_CODE (next) == INSN
3141                   && GET_CODE (PATTERN (next)) == SET
3142                   && GET_CODE (SET_DEST (PATTERN (next))) == REG
3143                   && REGNO (SET_DEST (PATTERN (next))) == 0)
3144                 break;
3145
3146               next = next_insn (next);
3147             }
3148
3149           /* Is NEXT_INSN a branch?  */
3150           if (next
3151               && GET_CODE (next) == JUMP_INSN)
3152             {
3153               rtx pattern = PATTERN (next);
3154
3155               /* If it a reversed fp conditional branch (e.g. uses add,tr)
3156                  and CCFP dies, then reverse our conditional and the branch
3157                  to avoid the add,tr.  */
3158               if (GET_CODE (pattern) == SET
3159                   && SET_DEST (pattern) == pc_rtx
3160                   && GET_CODE (SET_SRC (pattern)) == IF_THEN_ELSE
3161                   && GET_CODE (XEXP (SET_SRC (pattern), 0)) == NE
3162                   && GET_CODE (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == REG
3163                   && REGNO (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == 0
3164                   && GET_CODE (XEXP (SET_SRC (pattern), 1)) == PC
3165                   && (fcmp_count == fbranch_count
3166                       || (check_notes
3167                           && find_regno_note (next, REG_DEAD, 0))))
3168                 {
3169                   /* Reverse the branch.  */
3170                   tmp = XEXP (SET_SRC (pattern), 1);
3171                   XEXP (SET_SRC (pattern), 1) = XEXP (SET_SRC (pattern), 2);
3172                   XEXP (SET_SRC (pattern), 2) = tmp;
3173                   INSN_CODE (next) = -1;
3174
3175                   /* Reverse our condition.  */
3176                   tmp = PATTERN (insn);
3177                   PUT_CODE (XEXP (tmp, 1),
3178                             (reverse_condition_maybe_unordered
3179                              (GET_CODE (XEXP (tmp, 1)))));
3180                 }
3181             }
3182         }
3183     }
3184
3185   pass = !pass;
3186
3187 }
3188 \f
3189 /* You may have trouble believing this, but this is the 32 bit HP-PA
3190    stack layout.  Wow.
3191
3192    Offset               Contents
3193
3194    Variable arguments   (optional; any number may be allocated)
3195
3196    SP-(4*(N+9))         arg word N
3197         :                   :
3198       SP-56             arg word 5
3199       SP-52             arg word 4
3200
3201    Fixed arguments      (must be allocated; may remain unused)
3202
3203       SP-48             arg word 3
3204       SP-44             arg word 2
3205       SP-40             arg word 1
3206       SP-36             arg word 0
3207
3208    Frame Marker
3209
3210       SP-32             External Data Pointer (DP)
3211       SP-28             External sr4
3212       SP-24             External/stub RP (RP')
3213       SP-20             Current RP
3214       SP-16             Static Link
3215       SP-12             Clean up
3216       SP-8              Calling Stub RP (RP'')
3217       SP-4              Previous SP
3218
3219    Top of Frame
3220
3221       SP-0              Stack Pointer (points to next available address)
3222
3223 */
3224
3225 /* This function saves registers as follows.  Registers marked with ' are
3226    this function's registers (as opposed to the previous function's).
3227    If a frame_pointer isn't needed, r4 is saved as a general register;
3228    the space for the frame pointer is still allocated, though, to keep
3229    things simple.
3230
3231
3232    Top of Frame
3233
3234        SP (FP')         Previous FP
3235        SP + 4           Alignment filler (sigh)
3236        SP + 8           Space for locals reserved here.
3237        .
3238        .
3239        .
3240        SP + n           All call saved register used.
3241        .
3242        .
3243        .
3244        SP + o           All call saved fp registers used.
3245        .
3246        .
3247        .
3248        SP + p (SP')     points to next available address.
3249
3250 */
3251
3252 /* Global variables set by output_function_prologue().  */
3253 /* Size of frame.  Need to know this to emit return insns from
3254    leaf procedures.  */
3255 static HOST_WIDE_INT actual_fsize, local_fsize;
3256 static int save_fregs;
3257
3258 /* Emit RTL to store REG at the memory location specified by BASE+DISP.
3259    Handle case where DISP > 8k by using the add_high_const patterns.
3260
3261    Note in DISP > 8k case, we will leave the high part of the address
3262    in %r1.  There is code in expand_hppa_{prologue,epilogue} that knows this.*/
3263
3264 static void
3265 store_reg (int reg, HOST_WIDE_INT disp, int base)
3266 {
3267   rtx insn, dest, src, basereg;
3268
3269   src = gen_rtx_REG (word_mode, reg);
3270   basereg = gen_rtx_REG (Pmode, base);
3271   if (VAL_14_BITS_P (disp))
3272     {
3273       dest = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3274       insn = emit_move_insn (dest, src);
3275     }
3276   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3277     {
3278       rtx delta = GEN_INT (disp);
3279       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3280
3281       emit_move_insn (tmpreg, delta);
3282       insn = emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3283       if (DO_FRAME_NOTES)
3284         {
3285           REG_NOTES (insn)
3286             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3287                 gen_rtx_SET (VOIDmode, tmpreg,
3288                              gen_rtx_PLUS (Pmode, basereg, delta)),
3289                 REG_NOTES (insn));
3290           RTX_FRAME_RELATED_P (insn) = 1;
3291         }
3292       dest = gen_rtx_MEM (word_mode, tmpreg);
3293       insn = emit_move_insn (dest, src);
3294     }
3295   else
3296     {
3297       rtx delta = GEN_INT (disp);
3298       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3299       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3300
3301       emit_move_insn (tmpreg, high);
3302       dest = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3303       insn = emit_move_insn (dest, src);
3304       if (DO_FRAME_NOTES)
3305         {
3306           REG_NOTES (insn)
3307             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3308                 gen_rtx_SET (VOIDmode,
3309                              gen_rtx_MEM (word_mode,
3310                                           gen_rtx_PLUS (word_mode, basereg,
3311                                                         delta)),
3312                              src),
3313                 REG_NOTES (insn));
3314         }
3315     }
3316
3317   if (DO_FRAME_NOTES)
3318     RTX_FRAME_RELATED_P (insn) = 1;
3319 }
3320
3321 /* Emit RTL to store REG at the memory location specified by BASE and then
3322    add MOD to BASE.  MOD must be <= 8k.  */
3323
3324 static void
3325 store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
3326 {
3327   rtx insn, basereg, srcreg, delta;
3328
3329   gcc_assert (VAL_14_BITS_P (mod));
3330
3331   basereg = gen_rtx_REG (Pmode, base);
3332   srcreg = gen_rtx_REG (word_mode, reg);
3333   delta = GEN_INT (mod);
3334
3335   insn = emit_insn (gen_post_store (basereg, srcreg, delta));
3336   if (DO_FRAME_NOTES)
3337     {
3338       RTX_FRAME_RELATED_P (insn) = 1;
3339
3340       /* RTX_FRAME_RELATED_P must be set on each frame related set
3341          in a parallel with more than one element.  */
3342       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 0)) = 1;
3343       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 1)) = 1;
3344     }
3345 }
3346
3347 /* Emit RTL to set REG to the value specified by BASE+DISP.  Handle case
3348    where DISP > 8k by using the add_high_const patterns.  NOTE indicates
3349    whether to add a frame note or not.
3350
3351    In the DISP > 8k case, we leave the high part of the address in %r1.
3352    There is code in expand_hppa_{prologue,epilogue} that knows about this.  */
3353
3354 static void
3355 set_reg_plus_d (int reg, int base, HOST_WIDE_INT disp, int note)
3356 {
3357   rtx insn;
3358
3359   if (VAL_14_BITS_P (disp))
3360     {
3361       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3362                              plus_constant (gen_rtx_REG (Pmode, base), disp));
3363     }
3364   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3365     {
3366       rtx basereg = gen_rtx_REG (Pmode, base);
3367       rtx delta = GEN_INT (disp);
3368       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3369
3370       emit_move_insn (tmpreg, delta);
3371       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3372                              gen_rtx_PLUS (Pmode, tmpreg, basereg));
3373       if (DO_FRAME_NOTES)
3374         REG_NOTES (insn)
3375           = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3376               gen_rtx_SET (VOIDmode, tmpreg,
3377                            gen_rtx_PLUS (Pmode, basereg, delta)),
3378               REG_NOTES (insn));
3379     }
3380   else
3381     {
3382       rtx basereg = gen_rtx_REG (Pmode, base);
3383       rtx delta = GEN_INT (disp);
3384       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3385
3386       emit_move_insn (tmpreg,
3387                       gen_rtx_PLUS (Pmode, basereg,
3388                                     gen_rtx_HIGH (Pmode, delta)));
3389       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3390                              gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3391     }
3392
3393   if (DO_FRAME_NOTES && note)
3394     RTX_FRAME_RELATED_P (insn) = 1;
3395 }
3396
3397 HOST_WIDE_INT
3398 compute_frame_size (HOST_WIDE_INT size, int *fregs_live)
3399 {
3400   int freg_saved = 0;
3401   int i, j;
3402
3403   /* The code in hppa_expand_prologue and hppa_expand_epilogue must
3404      be consistent with the rounding and size calculation done here.
3405      Change them at the same time.  */
3406
3407   /* We do our own stack alignment.  First, round the size of the
3408      stack locals up to a word boundary.  */
3409   size = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3410
3411   /* Space for previous frame pointer + filler.  If any frame is
3412      allocated, we need to add in the STARTING_FRAME_OFFSET.  We
3413      waste some space here for the sake of HP compatibility.  The
3414      first slot is only used when the frame pointer is needed.  */
3415   if (size || frame_pointer_needed)
3416     size += STARTING_FRAME_OFFSET;
3417   
3418   /* If the current function calls __builtin_eh_return, then we need
3419      to allocate stack space for registers that will hold data for
3420      the exception handler.  */
3421   if (DO_FRAME_NOTES && current_function_calls_eh_return)
3422     {
3423       unsigned int i;
3424
3425       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
3426         continue;
3427       size += i * UNITS_PER_WORD;
3428     }
3429
3430   /* Account for space used by the callee general register saves.  */
3431   for (i = 18, j = frame_pointer_needed ? 4 : 3; i >= j; i--)
3432     if (regs_ever_live[i])
3433       size += UNITS_PER_WORD;
3434
3435   /* Account for space used by the callee floating point register saves.  */
3436   for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3437     if (regs_ever_live[i]
3438         || (!TARGET_64BIT && regs_ever_live[i + 1]))
3439       {
3440         freg_saved = 1;
3441
3442         /* We always save both halves of the FP register, so always
3443            increment the frame size by 8 bytes.  */
3444         size += 8;
3445       }
3446
3447   /* If any of the floating registers are saved, account for the
3448      alignment needed for the floating point register save block.  */
3449   if (freg_saved)
3450     {
3451       size = (size + 7) & ~7;
3452       if (fregs_live)
3453         *fregs_live = 1;
3454     }
3455
3456   /* The various ABIs include space for the outgoing parameters in the
3457      size of the current function's stack frame.  We don't need to align
3458      for the outgoing arguments as their alignment is set by the final
3459      rounding for the frame as a whole.  */
3460   size += current_function_outgoing_args_size;
3461
3462   /* Allocate space for the fixed frame marker.  This space must be
3463      allocated for any function that makes calls or allocates
3464      stack space.  */
3465   if (!current_function_is_leaf || size)
3466     size += TARGET_64BIT ? 48 : 32;
3467
3468   /* Finally, round to the preferred stack boundary.  */
3469   return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
3470           & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
3471 }
3472
3473 /* Generate the assembly code for function entry.  FILE is a stdio
3474    stream to output the code to.  SIZE is an int: how many units of
3475    temporary storage to allocate.
3476
3477    Refer to the array `regs_ever_live' to determine which registers to
3478    save; `regs_ever_live[I]' is nonzero if register number I is ever
3479    used in the function.  This function is responsible for knowing
3480    which registers should not be saved even if used.  */
3481
3482 /* On HP-PA, move-double insns between fpu and cpu need an 8-byte block
3483    of memory.  If any fpu reg is used in the function, we allocate
3484    such a block here, at the bottom of the frame, just in case it's needed.
3485
3486    If this function is a leaf procedure, then we may choose not
3487    to do a "save" insn.  The decision about whether or not
3488    to do this is made in regclass.c.  */
3489
3490 static void
3491 pa_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3492 {
3493   /* The function's label and associated .PROC must never be
3494      separated and must be output *after* any profiling declarations
3495      to avoid changing spaces/subspaces within a procedure.  */
3496   ASM_OUTPUT_LABEL (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
3497   fputs ("\t.PROC\n", file);
3498
3499   /* hppa_expand_prologue does the dirty work now.  We just need
3500      to output the assembler directives which denote the start
3501      of a function.  */
3502   fprintf (file, "\t.CALLINFO FRAME=" HOST_WIDE_INT_PRINT_DEC, actual_fsize);
3503   if (regs_ever_live[2])
3504     fputs (",CALLS,SAVE_RP", file);
3505   else
3506     fputs (",NO_CALLS", file);
3507
3508   /* The SAVE_SP flag is used to indicate that register %r3 is stored
3509      at the beginning of the frame and that it is used as the frame
3510      pointer for the frame.  We do this because our current frame
3511      layout doesn't conform to that specified in the HP runtime
3512      documentation and we need a way to indicate to programs such as
3513      GDB where %r3 is saved.  The SAVE_SP flag was chosen because it
3514      isn't used by HP compilers but is supported by the assembler.
3515      However, SAVE_SP is supposed to indicate that the previous stack
3516      pointer has been saved in the frame marker.  */
3517   if (frame_pointer_needed)
3518     fputs (",SAVE_SP", file);
3519
3520   /* Pass on information about the number of callee register saves
3521      performed in the prologue.
3522
3523      The compiler is supposed to pass the highest register number
3524      saved, the assembler then has to adjust that number before
3525      entering it into the unwind descriptor (to account for any
3526      caller saved registers with lower register numbers than the
3527      first callee saved register).  */
3528   if (gr_saved)
3529     fprintf (file, ",ENTRY_GR=%d", gr_saved + 2);
3530
3531   if (fr_saved)
3532     fprintf (file, ",ENTRY_FR=%d", fr_saved + 11);
3533
3534   fputs ("\n\t.ENTRY\n", file);
3535
3536   remove_useless_addtr_insns (0);
3537 }
3538
3539 void
3540 hppa_expand_prologue (void)
3541 {
3542   int merge_sp_adjust_with_store = 0;
3543   HOST_WIDE_INT size = get_frame_size ();
3544   HOST_WIDE_INT offset;
3545   int i;
3546   rtx insn, tmpreg;
3547
3548   gr_saved = 0;
3549   fr_saved = 0;
3550   save_fregs = 0;
3551
3552   /* Compute total size for frame pointer, filler, locals and rounding to
3553      the next word boundary.  Similar code appears in compute_frame_size
3554      and must be changed in tandem with this code.  */
3555   local_fsize = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3556   if (local_fsize || frame_pointer_needed)
3557     local_fsize += STARTING_FRAME_OFFSET;
3558
3559   actual_fsize = compute_frame_size (size, &save_fregs);
3560
3561   /* Compute a few things we will use often.  */
3562   tmpreg = gen_rtx_REG (word_mode, 1);
3563
3564   /* Save RP first.  The calling conventions manual states RP will
3565      always be stored into the caller's frame at sp - 20 or sp - 16
3566      depending on which ABI is in use.  */
3567   if (regs_ever_live[2] || current_function_calls_eh_return)
3568     store_reg (2, TARGET_64BIT ? -16 : -20, STACK_POINTER_REGNUM);
3569
3570   /* Allocate the local frame and set up the frame pointer if needed.  */
3571   if (actual_fsize != 0)
3572     {
3573       if (frame_pointer_needed)
3574         {
3575           /* Copy the old frame pointer temporarily into %r1.  Set up the
3576              new stack pointer, then store away the saved old frame pointer
3577              into the stack at sp and at the same time update the stack
3578              pointer by actual_fsize bytes.  Two versions, first
3579              handles small (<8k) frames.  The second handles large (>=8k)
3580              frames.  */
3581           insn = emit_move_insn (tmpreg, frame_pointer_rtx);
3582           if (DO_FRAME_NOTES)
3583             RTX_FRAME_RELATED_P (insn) = 1;
3584
3585           insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
3586           if (DO_FRAME_NOTES)
3587             RTX_FRAME_RELATED_P (insn) = 1;
3588
3589           if (VAL_14_BITS_P (actual_fsize))
3590             store_reg_modify (STACK_POINTER_REGNUM, 1, actual_fsize);
3591           else
3592             {
3593               /* It is incorrect to store the saved frame pointer at *sp,
3594                  then increment sp (writes beyond the current stack boundary).
3595
3596                  So instead use stwm to store at *sp and post-increment the
3597                  stack pointer as an atomic operation.  Then increment sp to
3598                  finish allocating the new frame.  */
3599               HOST_WIDE_INT adjust1 = 8192 - 64;
3600               HOST_WIDE_INT adjust2 = actual_fsize - adjust1;
3601
3602               store_reg_modify (STACK_POINTER_REGNUM, 1, adjust1);
3603               set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3604                               adjust2, 1);
3605             }
3606
3607           /* We set SAVE_SP in frames that need a frame pointer.  Thus,
3608              we need to store the previous stack pointer (frame pointer)
3609              into the frame marker on targets that use the HP unwind
3610              library.  This allows the HP unwind library to be used to
3611              unwind GCC frames.  However, we are not fully compatible
3612              with the HP library because our frame layout differs from
3613              that specified in the HP runtime specification.
3614
3615              We don't want a frame note on this instruction as the frame
3616              marker moves during dynamic stack allocation.
3617
3618              This instruction also serves as a blockage to prevent
3619              register spills from being scheduled before the stack
3620              pointer is raised.  This is necessary as we store
3621              registers using the frame pointer as a base register,
3622              and the frame pointer is set before sp is raised.  */
3623           if (TARGET_HPUX_UNWIND_LIBRARY)
3624             {
3625               rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx,
3626                                        GEN_INT (TARGET_64BIT ? -8 : -4));
3627
3628               emit_move_insn (gen_rtx_MEM (word_mode, addr),
3629                               frame_pointer_rtx);
3630             }
3631           else
3632             emit_insn (gen_blockage ());
3633         }
3634       /* no frame pointer needed.  */
3635       else
3636         {
3637           /* In some cases we can perform the first callee register save
3638              and allocating the stack frame at the same time.   If so, just
3639              make a note of it and defer allocating the frame until saving
3640              the callee registers.  */
3641           if (VAL_14_BITS_P (actual_fsize) && local_fsize == 0)
3642             merge_sp_adjust_with_store = 1;
3643           /* Can not optimize.  Adjust the stack frame by actual_fsize
3644              bytes.  */
3645           else
3646             set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3647                             actual_fsize, 1);
3648         }
3649     }
3650
3651   /* Normal register save.
3652
3653      Do not save the frame pointer in the frame_pointer_needed case.  It
3654      was done earlier.  */
3655   if (frame_pointer_needed)
3656     {
3657       offset = local_fsize;
3658
3659       /* Saving the EH return data registers in the frame is the simplest
3660          way to get the frame unwind information emitted.  We put them
3661          just before the general registers.  */
3662       if (DO_FRAME_NOTES && current_function_calls_eh_return)
3663         {
3664           unsigned int i, regno;
3665
3666           for (i = 0; ; ++i)
3667             {
3668               regno = EH_RETURN_DATA_REGNO (i);
3669               if (regno == INVALID_REGNUM)
3670                 break;
3671
3672               store_reg (regno, offset, FRAME_POINTER_REGNUM);
3673               offset += UNITS_PER_WORD;
3674             }
3675         }
3676
3677       for (i = 18; i >= 4; i--)
3678         if (regs_ever_live[i] && ! call_used_regs[i])
3679           {
3680             store_reg (i, offset, FRAME_POINTER_REGNUM);
3681             offset += UNITS_PER_WORD;
3682             gr_saved++;
3683           }
3684       /* Account for %r3 which is saved in a special place.  */
3685       gr_saved++;
3686     }
3687   /* No frame pointer needed.  */
3688   else
3689     {
3690       offset = local_fsize - actual_fsize;
3691
3692       /* Saving the EH return data registers in the frame is the simplest
3693          way to get the frame unwind information emitted.  */
3694       if (DO_FRAME_NOTES && current_function_calls_eh_return)
3695         {
3696           unsigned int i, regno;
3697
3698           for (i = 0; ; ++i)
3699             {
3700               regno = EH_RETURN_DATA_REGNO (i);
3701               if (regno == INVALID_REGNUM)
3702                 break;
3703
3704               /* If merge_sp_adjust_with_store is nonzero, then we can
3705                  optimize the first save.  */
3706               if (merge_sp_adjust_with_store)
3707                 {
3708                   store_reg_modify (STACK_POINTER_REGNUM, regno, -offset);
3709                   merge_sp_adjust_with_store = 0;
3710                 }
3711               else
3712                 store_reg (regno, offset, STACK_POINTER_REGNUM);
3713               offset += UNITS_PER_WORD;
3714             }
3715         }
3716
3717       for (i = 18; i >= 3; i--)
3718         if (regs_ever_live[i] && ! call_used_regs[i])
3719           {
3720             /* If merge_sp_adjust_with_store is nonzero, then we can
3721                optimize the first GR save.  */
3722             if (merge_sp_adjust_with_store)
3723               {
3724                 store_reg_modify (STACK_POINTER_REGNUM, i, -offset);
3725                 merge_sp_adjust_with_store = 0;
3726               }
3727             else
3728               store_reg (i, offset, STACK_POINTER_REGNUM);
3729             offset += UNITS_PER_WORD;
3730             gr_saved++;
3731           }
3732
3733       /* If we wanted to merge the SP adjustment with a GR save, but we never
3734          did any GR saves, then just emit the adjustment here.  */
3735       if (merge_sp_adjust_with_store)
3736         set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3737                         actual_fsize, 1);
3738     }
3739
3740   /* The hppa calling conventions say that %r19, the pic offset
3741      register, is saved at sp - 32 (in this function's frame)
3742      when generating PIC code.  FIXME:  What is the correct thing
3743      to do for functions which make no calls and allocate no
3744      frame?  Do we need to allocate a frame, or can we just omit
3745      the save?   For now we'll just omit the save.
3746      
3747      We don't want a note on this insn as the frame marker can
3748      move if there is a dynamic stack allocation.  */
3749   if (flag_pic && actual_fsize != 0 && !TARGET_64BIT)
3750     {
3751       rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx, GEN_INT (-32));
3752
3753       emit_move_insn (gen_rtx_MEM (word_mode, addr), pic_offset_table_rtx);
3754
3755     }
3756
3757   /* Align pointer properly (doubleword boundary).  */
3758   offset = (offset + 7) & ~7;
3759
3760   /* Floating point register store.  */
3761   if (save_fregs)
3762     {
3763       rtx base;
3764
3765       /* First get the frame or stack pointer to the start of the FP register
3766          save area.  */
3767       if (frame_pointer_needed)
3768         {
3769           set_reg_plus_d (1, FRAME_POINTER_REGNUM, offset, 0);
3770           base = frame_pointer_rtx;
3771         }
3772       else
3773         {
3774           set_reg_plus_d (1, STACK_POINTER_REGNUM, offset, 0);
3775           base = stack_pointer_rtx;
3776         }
3777
3778       /* Now actually save the FP registers.  */
3779       for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3780         {
3781           if (regs_ever_live[i]
3782               || (! TARGET_64BIT && regs_ever_live[i + 1]))
3783             {
3784               rtx addr, insn, reg;
3785               addr = gen_rtx_MEM (DFmode, gen_rtx_POST_INC (DFmode, tmpreg));
3786               reg = gen_rtx_REG (DFmode, i);
3787               insn = emit_move_insn (addr, reg);
3788               if (DO_FRAME_NOTES)
3789                 {
3790                   RTX_FRAME_RELATED_P (insn) = 1;
3791                   if (TARGET_64BIT)
3792                     {
3793                       rtx mem = gen_rtx_MEM (DFmode,
3794                                              plus_constant (base, offset));
3795                       REG_NOTES (insn)
3796                         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3797                                              gen_rtx_SET (VOIDmode, mem, reg),
3798                                              REG_NOTES (insn));
3799                     }
3800                   else
3801                     {
3802                       rtx meml = gen_rtx_MEM (SFmode,
3803                                               plus_constant (base, offset));
3804                       rtx memr = gen_rtx_MEM (SFmode,
3805                                               plus_constant (base, offset + 4));
3806                       rtx regl = gen_rtx_REG (SFmode, i);
3807                       rtx regr = gen_rtx_REG (SFmode, i + 1);
3808                       rtx setl = gen_rtx_SET (VOIDmode, meml, regl);
3809                       rtx setr = gen_rtx_SET (VOIDmode, memr, regr);
3810                       rtvec vec;
3811
3812                       RTX_FRAME_RELATED_P (setl) = 1;
3813                       RTX_FRAME_RELATED_P (setr) = 1;
3814                       vec = gen_rtvec (2, setl, setr);
3815                       REG_NOTES (insn)
3816                         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3817                                              gen_rtx_SEQUENCE (VOIDmode, vec),
3818                                              REG_NOTES (insn));
3819                     }
3820                 }
3821               offset += GET_MODE_SIZE (DFmode);
3822               fr_saved++;
3823             }
3824         }
3825     }
3826 }
3827
3828 /* Emit RTL to load REG from the memory location specified by BASE+DISP.
3829    Handle case where DISP > 8k by using the add_high_const patterns.  */
3830
3831 static void
3832 load_reg (int reg, HOST_WIDE_INT disp, int base)
3833 {
3834   rtx dest = gen_rtx_REG (word_mode, reg);
3835   rtx basereg = gen_rtx_REG (Pmode, base);
3836   rtx src;
3837
3838   if (VAL_14_BITS_P (disp))
3839     src = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3840   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3841     {
3842       rtx delta = GEN_INT (disp);
3843       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3844
3845       emit_move_insn (tmpreg, delta);
3846       if (TARGET_DISABLE_INDEXING)
3847         {
3848           emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3849           src = gen_rtx_MEM (word_mode, tmpreg);
3850         }
3851       else
3852         src = gen_rtx_MEM (word_mode, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3853     }
3854   else
3855     {
3856       rtx delta = GEN_INT (disp);
3857       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3858       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3859
3860       emit_move_insn (tmpreg, high);
3861       src = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3862     }
3863
3864   emit_move_insn (dest, src);
3865 }
3866
3867 /* Update the total code bytes output to the text section.  */
3868
3869 static void
3870 update_total_code_bytes (int nbytes)
3871 {
3872   if ((TARGET_PORTABLE_RUNTIME || !TARGET_GAS || !TARGET_SOM)
3873       && !IN_NAMED_SECTION_P (cfun->decl))
3874     {
3875       if (INSN_ADDRESSES_SET_P ())
3876         {
3877           unsigned long old_total = total_code_bytes;
3878
3879           total_code_bytes += nbytes;
3880
3881           /* Be prepared to handle overflows.  */
3882           if (old_total > total_code_bytes)
3883             total_code_bytes = -1;
3884         }
3885       else
3886         total_code_bytes = -1;
3887     }
3888 }
3889
3890 /* This function generates the assembly code for function exit.
3891    Args are as for output_function_prologue ().
3892
3893    The function epilogue should not depend on the current stack
3894    pointer!  It should use the frame pointer only.  This is mandatory
3895    because of alloca; we also take advantage of it to omit stack
3896    adjustments before returning.  */
3897
3898 static void
3899 pa_output_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3900 {
3901   rtx insn = get_last_insn ();
3902
3903   last_address = 0;
3904
3905   /* hppa_expand_epilogue does the dirty work now.  We just need
3906      to output the assembler directives which denote the end
3907      of a function.
3908
3909      To make debuggers happy, emit a nop if the epilogue was completely
3910      eliminated due to a volatile call as the last insn in the
3911      current function.  That way the return address (in %r2) will
3912      always point to a valid instruction in the current function.  */
3913
3914   /* Get the last real insn.  */
3915   if (GET_CODE (insn) == NOTE)
3916     insn = prev_real_insn (insn);
3917
3918   /* If it is a sequence, then look inside.  */
3919   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
3920     insn = XVECEXP (PATTERN (insn), 0, 0);
3921
3922   /* If insn is a CALL_INSN, then it must be a call to a volatile
3923      function (otherwise there would be epilogue insns).  */
3924   if (insn && GET_CODE (insn) == CALL_INSN)
3925     {
3926       fputs ("\tnop\n", file);
3927       last_address += 4;
3928     }
3929
3930   fputs ("\t.EXIT\n\t.PROCEND\n", file);
3931
3932   if (TARGET_SOM && TARGET_GAS)
3933     {
3934       /* We done with this subspace except possibly for some additional
3935          debug information.  Forget that we are in this subspace to ensure
3936          that the next function is output in its own subspace.  */
3937       in_section = NULL;
3938       cfun->machine->in_nsubspa = 2;
3939     }
3940
3941   if (INSN_ADDRESSES_SET_P ())
3942     {
3943       insn = get_last_nonnote_insn ();
3944       last_address += INSN_ADDRESSES