OSDN Git Service

2008-04-03 Jan Hubicka <jh@suse.cz>
[pf3gnuchains/gcc-fork.git] / gcc / config / ia64 / ia64.c
1 /* Definitions of target machine for GNU compiler.
2    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3    Free Software Foundation, Inc.
4    Contributed by James E. Wilson <wilson@cygnus.com> and
5                   David Mosberger <davidm@hpl.hp.com>.
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "tree.h"
29 #include "regs.h"
30 #include "hard-reg-set.h"
31 #include "real.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "output.h"
35 #include "insn-attr.h"
36 #include "flags.h"
37 #include "recog.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "except.h"
41 #include "function.h"
42 #include "ggc.h"
43 #include "basic-block.h"
44 #include "toplev.h"
45 #include "sched-int.h"
46 #include "timevar.h"
47 #include "target.h"
48 #include "target-def.h"
49 #include "tm_p.h"
50 #include "hashtab.h"
51 #include "langhooks.h"
52 #include "cfglayout.h"
53 #include "tree-gimple.h"
54 #include "intl.h"
55 #include "df.h"
56 #include "debug.h"
57 #include "params.h"
58 #include "dbgcnt.h"
59 #include "tm-constrs.h"
60
61 /* This is used for communication between ASM_OUTPUT_LABEL and
62    ASM_OUTPUT_LABELREF.  */
63 int ia64_asm_output_label = 0;
64
65 /* Define the information needed to generate branch and scc insns.  This is
66    stored from the compare operation.  */
67 struct rtx_def * ia64_compare_op0;
68 struct rtx_def * ia64_compare_op1;
69
70 /* Register names for ia64_expand_prologue.  */
71 static const char * const ia64_reg_numbers[96] =
72 { "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
73   "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
74   "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
75   "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
76   "r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
77   "r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
78   "r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
79   "r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
80   "r96", "r97", "r98", "r99", "r100","r101","r102","r103",
81   "r104","r105","r106","r107","r108","r109","r110","r111",
82   "r112","r113","r114","r115","r116","r117","r118","r119",
83   "r120","r121","r122","r123","r124","r125","r126","r127"};
84
85 /* ??? These strings could be shared with REGISTER_NAMES.  */
86 static const char * const ia64_input_reg_names[8] =
87 { "in0",  "in1",  "in2",  "in3",  "in4",  "in5",  "in6",  "in7" };
88
89 /* ??? These strings could be shared with REGISTER_NAMES.  */
90 static const char * const ia64_local_reg_names[80] =
91 { "loc0", "loc1", "loc2", "loc3", "loc4", "loc5", "loc6", "loc7",
92   "loc8", "loc9", "loc10","loc11","loc12","loc13","loc14","loc15",
93   "loc16","loc17","loc18","loc19","loc20","loc21","loc22","loc23",
94   "loc24","loc25","loc26","loc27","loc28","loc29","loc30","loc31",
95   "loc32","loc33","loc34","loc35","loc36","loc37","loc38","loc39",
96   "loc40","loc41","loc42","loc43","loc44","loc45","loc46","loc47",
97   "loc48","loc49","loc50","loc51","loc52","loc53","loc54","loc55",
98   "loc56","loc57","loc58","loc59","loc60","loc61","loc62","loc63",
99   "loc64","loc65","loc66","loc67","loc68","loc69","loc70","loc71",
100   "loc72","loc73","loc74","loc75","loc76","loc77","loc78","loc79" };
101
102 /* ??? These strings could be shared with REGISTER_NAMES.  */
103 static const char * const ia64_output_reg_names[8] =
104 { "out0", "out1", "out2", "out3", "out4", "out5", "out6", "out7" };
105
106 /* Which cpu are we scheduling for.  */
107 enum processor_type ia64_tune = PROCESSOR_ITANIUM2;
108
109 /* Determines whether we run our final scheduling pass or not.  We always
110    avoid the normal second scheduling pass.  */
111 static int ia64_flag_schedule_insns2;
112
113 /* Determines whether we run variable tracking in machine dependent
114    reorganization.  */
115 static int ia64_flag_var_tracking;
116
117 /* Variables which are this size or smaller are put in the sdata/sbss
118    sections.  */
119
120 unsigned int ia64_section_threshold;
121
122 /* The following variable is used by the DFA insn scheduler.  The value is
123    TRUE if we do insn bundling instead of insn scheduling.  */
124 int bundling_p = 0;
125
126 enum ia64_frame_regs
127 {
128    reg_fp,
129    reg_save_b0,
130    reg_save_pr,
131    reg_save_ar_pfs,
132    reg_save_ar_unat,
133    reg_save_ar_lc,
134    reg_save_gp,
135    number_of_ia64_frame_regs
136 };
137
138 /* Structure to be filled in by ia64_compute_frame_size with register
139    save masks and offsets for the current function.  */
140
141 struct ia64_frame_info
142 {
143   HOST_WIDE_INT total_size;     /* size of the stack frame, not including
144                                    the caller's scratch area.  */
145   HOST_WIDE_INT spill_cfa_off;  /* top of the reg spill area from the cfa.  */
146   HOST_WIDE_INT spill_size;     /* size of the gr/br/fr spill area.  */
147   HOST_WIDE_INT extra_spill_size;  /* size of spill area for others.  */
148   HARD_REG_SET mask;            /* mask of saved registers.  */
149   unsigned int gr_used_mask;    /* mask of registers in use as gr spill
150                                    registers or long-term scratches.  */
151   int n_spilled;                /* number of spilled registers.  */
152   int r[number_of_ia64_frame_regs];  /* Frame related registers.  */
153   int n_input_regs;             /* number of input registers used.  */
154   int n_local_regs;             /* number of local registers used.  */
155   int n_output_regs;            /* number of output registers used.  */
156   int n_rotate_regs;            /* number of rotating registers used.  */
157
158   char need_regstk;             /* true if a .regstk directive needed.  */
159   char initialized;             /* true if the data is finalized.  */
160 };
161
162 /* Current frame information calculated by ia64_compute_frame_size.  */
163 static struct ia64_frame_info current_frame_info;
164 /* The actual registers that are emitted.  */
165 static int emitted_frame_related_regs[number_of_ia64_frame_regs];
166 \f
167 static int ia64_first_cycle_multipass_dfa_lookahead (void);
168 static void ia64_dependencies_evaluation_hook (rtx, rtx);
169 static void ia64_init_dfa_pre_cycle_insn (void);
170 static rtx ia64_dfa_pre_cycle_insn (void);
171 static int ia64_first_cycle_multipass_dfa_lookahead_guard (rtx);
172 static bool ia64_first_cycle_multipass_dfa_lookahead_guard_spec (const_rtx);
173 static int ia64_dfa_new_cycle (FILE *, int, rtx, int, int, int *);
174 static void ia64_h_i_d_extended (void);
175 static int ia64_mode_to_int (enum machine_mode);
176 static void ia64_set_sched_flags (spec_info_t);
177 static int ia64_speculate_insn (rtx, ds_t, rtx *);
178 static rtx ia64_gen_spec_insn (rtx, ds_t, int, bool, bool);
179 static bool ia64_needs_block_p (const_rtx);
180 static rtx ia64_gen_check (rtx, rtx, bool);
181 static int ia64_spec_check_p (rtx);
182 static int ia64_spec_check_src_p (rtx);
183 static rtx gen_tls_get_addr (void);
184 static rtx gen_thread_pointer (void);
185 static int find_gr_spill (enum ia64_frame_regs, int);
186 static int next_scratch_gr_reg (void);
187 static void mark_reg_gr_used_mask (rtx, void *);
188 static void ia64_compute_frame_size (HOST_WIDE_INT);
189 static void setup_spill_pointers (int, rtx, HOST_WIDE_INT);
190 static void finish_spill_pointers (void);
191 static rtx spill_restore_mem (rtx, HOST_WIDE_INT);
192 static void do_spill (rtx (*)(rtx, rtx, rtx), rtx, HOST_WIDE_INT, rtx);
193 static void do_restore (rtx (*)(rtx, rtx, rtx), rtx, HOST_WIDE_INT);
194 static rtx gen_movdi_x (rtx, rtx, rtx);
195 static rtx gen_fr_spill_x (rtx, rtx, rtx);
196 static rtx gen_fr_restore_x (rtx, rtx, rtx);
197
198 static enum machine_mode hfa_element_mode (const_tree, bool);
199 static void ia64_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
200                                          tree, int *, int);
201 static int ia64_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
202                                    tree, bool);
203 static bool ia64_function_ok_for_sibcall (tree, tree);
204 static bool ia64_return_in_memory (const_tree, const_tree);
205 static bool ia64_rtx_costs (rtx, int, int, int *);
206 static int ia64_unspec_may_trap_p (const_rtx, unsigned);
207 static void fix_range (const char *);
208 static bool ia64_handle_option (size_t, const char *, int);
209 static struct machine_function * ia64_init_machine_status (void);
210 static void emit_insn_group_barriers (FILE *);
211 static void emit_all_insn_group_barriers (FILE *);
212 static void final_emit_insn_group_barriers (FILE *);
213 static void emit_predicate_relation_info (void);
214 static void ia64_reorg (void);
215 static bool ia64_in_small_data_p (const_tree);
216 static void process_epilogue (FILE *, rtx, bool, bool);
217 static int process_set (FILE *, rtx, rtx, bool, bool);
218
219 static bool ia64_assemble_integer (rtx, unsigned int, int);
220 static void ia64_output_function_prologue (FILE *, HOST_WIDE_INT);
221 static void ia64_output_function_epilogue (FILE *, HOST_WIDE_INT);
222 static void ia64_output_function_end_prologue (FILE *);
223
224 static int ia64_issue_rate (void);
225 static int ia64_adjust_cost (rtx, rtx, rtx, int);
226 static void ia64_sched_init (FILE *, int, int);
227 static void ia64_sched_init_global (FILE *, int, int);
228 static void ia64_sched_finish_global (FILE *, int);
229 static void ia64_sched_finish (FILE *, int);
230 static int ia64_dfa_sched_reorder (FILE *, int, rtx *, int *, int, int);
231 static int ia64_sched_reorder (FILE *, int, rtx *, int *, int);
232 static int ia64_sched_reorder2 (FILE *, int, rtx *, int *, int);
233 static int ia64_variable_issue (FILE *, int, rtx, int);
234
235 static struct bundle_state *get_free_bundle_state (void);
236 static void free_bundle_state (struct bundle_state *);
237 static void initiate_bundle_states (void);
238 static void finish_bundle_states (void);
239 static unsigned bundle_state_hash (const void *);
240 static int bundle_state_eq_p (const void *, const void *);
241 static int insert_bundle_state (struct bundle_state *);
242 static void initiate_bundle_state_table (void);
243 static void finish_bundle_state_table (void);
244 static int try_issue_nops (struct bundle_state *, int);
245 static int try_issue_insn (struct bundle_state *, rtx);
246 static void issue_nops_and_insn (struct bundle_state *, int, rtx, int, int);
247 static int get_max_pos (state_t);
248 static int get_template (state_t, int);
249
250 static rtx get_next_important_insn (rtx, rtx);
251 static void bundling (FILE *, int, rtx, rtx);
252
253 static void ia64_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
254                                   HOST_WIDE_INT, tree);
255 static void ia64_file_start (void);
256 static void ia64_globalize_decl_name (FILE *, tree);
257
258 static int ia64_hpux_reloc_rw_mask (void) ATTRIBUTE_UNUSED;
259 static int ia64_reloc_rw_mask (void) ATTRIBUTE_UNUSED;
260 static section *ia64_select_rtx_section (enum machine_mode, rtx,
261                                          unsigned HOST_WIDE_INT);
262 static void ia64_output_dwarf_dtprel (FILE *, int, rtx)
263      ATTRIBUTE_UNUSED;
264 static unsigned int ia64_section_type_flags (tree, const char *, int);
265 static void ia64_init_libfuncs (void)
266      ATTRIBUTE_UNUSED;
267 static void ia64_hpux_init_libfuncs (void)
268      ATTRIBUTE_UNUSED;
269 static void ia64_sysv4_init_libfuncs (void)
270      ATTRIBUTE_UNUSED;
271 static void ia64_vms_init_libfuncs (void)
272      ATTRIBUTE_UNUSED;
273
274 static tree ia64_handle_model_attribute (tree *, tree, tree, int, bool *);
275 static tree ia64_handle_version_id_attribute (tree *, tree, tree, int, bool *);
276 static void ia64_encode_section_info (tree, rtx, int);
277 static rtx ia64_struct_value_rtx (tree, int);
278 static tree ia64_gimplify_va_arg (tree, tree, tree *, tree *);
279 static bool ia64_scalar_mode_supported_p (enum machine_mode mode);
280 static bool ia64_vector_mode_supported_p (enum machine_mode mode);
281 static bool ia64_cannot_force_const_mem (rtx);
282 static const char *ia64_mangle_type (const_tree);
283 static const char *ia64_invalid_conversion (const_tree, const_tree);
284 static const char *ia64_invalid_unary_op (int, const_tree);
285 static const char *ia64_invalid_binary_op (int, const_tree, const_tree);
286 static enum machine_mode ia64_c_mode_for_suffix (char);
287 \f
288 /* Table of valid machine attributes.  */
289 static const struct attribute_spec ia64_attribute_table[] =
290 {
291   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
292   { "syscall_linkage", 0, 0, false, true,  true,  NULL },
293   { "model",           1, 1, true, false, false, ia64_handle_model_attribute },
294   { "version_id",      1, 1, true, false, false,
295     ia64_handle_version_id_attribute },
296   { NULL,              0, 0, false, false, false, NULL }
297 };
298
299 /* Initialize the GCC target structure.  */
300 #undef TARGET_ATTRIBUTE_TABLE
301 #define TARGET_ATTRIBUTE_TABLE ia64_attribute_table
302
303 #undef TARGET_INIT_BUILTINS
304 #define TARGET_INIT_BUILTINS ia64_init_builtins
305
306 #undef TARGET_EXPAND_BUILTIN
307 #define TARGET_EXPAND_BUILTIN ia64_expand_builtin
308
309 #undef TARGET_ASM_BYTE_OP
310 #define TARGET_ASM_BYTE_OP "\tdata1\t"
311 #undef TARGET_ASM_ALIGNED_HI_OP
312 #define TARGET_ASM_ALIGNED_HI_OP "\tdata2\t"
313 #undef TARGET_ASM_ALIGNED_SI_OP
314 #define TARGET_ASM_ALIGNED_SI_OP "\tdata4\t"
315 #undef TARGET_ASM_ALIGNED_DI_OP
316 #define TARGET_ASM_ALIGNED_DI_OP "\tdata8\t"
317 #undef TARGET_ASM_UNALIGNED_HI_OP
318 #define TARGET_ASM_UNALIGNED_HI_OP "\tdata2.ua\t"
319 #undef TARGET_ASM_UNALIGNED_SI_OP
320 #define TARGET_ASM_UNALIGNED_SI_OP "\tdata4.ua\t"
321 #undef TARGET_ASM_UNALIGNED_DI_OP
322 #define TARGET_ASM_UNALIGNED_DI_OP "\tdata8.ua\t"
323 #undef TARGET_ASM_INTEGER
324 #define TARGET_ASM_INTEGER ia64_assemble_integer
325
326 #undef TARGET_ASM_FUNCTION_PROLOGUE
327 #define TARGET_ASM_FUNCTION_PROLOGUE ia64_output_function_prologue
328 #undef TARGET_ASM_FUNCTION_END_PROLOGUE
329 #define TARGET_ASM_FUNCTION_END_PROLOGUE ia64_output_function_end_prologue
330 #undef TARGET_ASM_FUNCTION_EPILOGUE
331 #define TARGET_ASM_FUNCTION_EPILOGUE ia64_output_function_epilogue
332
333 #undef TARGET_IN_SMALL_DATA_P
334 #define TARGET_IN_SMALL_DATA_P  ia64_in_small_data_p
335
336 #undef TARGET_SCHED_ADJUST_COST
337 #define TARGET_SCHED_ADJUST_COST ia64_adjust_cost
338 #undef TARGET_SCHED_ISSUE_RATE
339 #define TARGET_SCHED_ISSUE_RATE ia64_issue_rate
340 #undef TARGET_SCHED_VARIABLE_ISSUE
341 #define TARGET_SCHED_VARIABLE_ISSUE ia64_variable_issue
342 #undef TARGET_SCHED_INIT
343 #define TARGET_SCHED_INIT ia64_sched_init
344 #undef TARGET_SCHED_FINISH
345 #define TARGET_SCHED_FINISH ia64_sched_finish
346 #undef TARGET_SCHED_INIT_GLOBAL
347 #define TARGET_SCHED_INIT_GLOBAL ia64_sched_init_global
348 #undef TARGET_SCHED_FINISH_GLOBAL
349 #define TARGET_SCHED_FINISH_GLOBAL ia64_sched_finish_global
350 #undef TARGET_SCHED_REORDER
351 #define TARGET_SCHED_REORDER ia64_sched_reorder
352 #undef TARGET_SCHED_REORDER2
353 #define TARGET_SCHED_REORDER2 ia64_sched_reorder2
354
355 #undef TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK
356 #define TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK ia64_dependencies_evaluation_hook
357
358 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
359 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ia64_first_cycle_multipass_dfa_lookahead
360
361 #undef TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN
362 #define TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN ia64_init_dfa_pre_cycle_insn
363 #undef TARGET_SCHED_DFA_PRE_CYCLE_INSN
364 #define TARGET_SCHED_DFA_PRE_CYCLE_INSN ia64_dfa_pre_cycle_insn
365
366 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
367 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD\
368   ia64_first_cycle_multipass_dfa_lookahead_guard
369
370 #undef TARGET_SCHED_DFA_NEW_CYCLE
371 #define TARGET_SCHED_DFA_NEW_CYCLE ia64_dfa_new_cycle
372
373 #undef TARGET_SCHED_H_I_D_EXTENDED
374 #define TARGET_SCHED_H_I_D_EXTENDED ia64_h_i_d_extended
375
376 #undef TARGET_SCHED_SET_SCHED_FLAGS
377 #define TARGET_SCHED_SET_SCHED_FLAGS ia64_set_sched_flags
378
379 #undef TARGET_SCHED_SPECULATE_INSN
380 #define TARGET_SCHED_SPECULATE_INSN ia64_speculate_insn
381
382 #undef TARGET_SCHED_NEEDS_BLOCK_P
383 #define TARGET_SCHED_NEEDS_BLOCK_P ia64_needs_block_p
384
385 #undef TARGET_SCHED_GEN_CHECK
386 #define TARGET_SCHED_GEN_CHECK ia64_gen_check
387
388 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC
389 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC\
390   ia64_first_cycle_multipass_dfa_lookahead_guard_spec
391
392 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
393 #define TARGET_FUNCTION_OK_FOR_SIBCALL ia64_function_ok_for_sibcall
394 #undef TARGET_ARG_PARTIAL_BYTES
395 #define TARGET_ARG_PARTIAL_BYTES ia64_arg_partial_bytes
396
397 #undef TARGET_ASM_OUTPUT_MI_THUNK
398 #define TARGET_ASM_OUTPUT_MI_THUNK ia64_output_mi_thunk
399 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
400 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
401
402 #undef TARGET_ASM_FILE_START
403 #define TARGET_ASM_FILE_START ia64_file_start
404
405 #undef TARGET_ASM_GLOBALIZE_DECL_NAME
406 #define TARGET_ASM_GLOBALIZE_DECL_NAME ia64_globalize_decl_name
407
408 #undef TARGET_RTX_COSTS
409 #define TARGET_RTX_COSTS ia64_rtx_costs
410 #undef TARGET_ADDRESS_COST
411 #define TARGET_ADDRESS_COST hook_int_rtx_0
412
413 #undef TARGET_UNSPEC_MAY_TRAP_P
414 #define TARGET_UNSPEC_MAY_TRAP_P ia64_unspec_may_trap_p
415
416 #undef TARGET_MACHINE_DEPENDENT_REORG
417 #define TARGET_MACHINE_DEPENDENT_REORG ia64_reorg
418
419 #undef TARGET_ENCODE_SECTION_INFO
420 #define TARGET_ENCODE_SECTION_INFO ia64_encode_section_info
421
422 #undef  TARGET_SECTION_TYPE_FLAGS
423 #define TARGET_SECTION_TYPE_FLAGS  ia64_section_type_flags
424
425 #ifdef HAVE_AS_TLS
426 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
427 #define TARGET_ASM_OUTPUT_DWARF_DTPREL ia64_output_dwarf_dtprel
428 #endif
429
430 /* ??? ABI doesn't allow us to define this.  */
431 #if 0
432 #undef TARGET_PROMOTE_FUNCTION_ARGS
433 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
434 #endif
435
436 /* ??? ABI doesn't allow us to define this.  */
437 #if 0
438 #undef TARGET_PROMOTE_FUNCTION_RETURN
439 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
440 #endif
441
442 /* ??? Investigate.  */
443 #if 0
444 #undef TARGET_PROMOTE_PROTOTYPES
445 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
446 #endif
447
448 #undef TARGET_STRUCT_VALUE_RTX
449 #define TARGET_STRUCT_VALUE_RTX ia64_struct_value_rtx
450 #undef TARGET_RETURN_IN_MEMORY
451 #define TARGET_RETURN_IN_MEMORY ia64_return_in_memory
452 #undef TARGET_SETUP_INCOMING_VARARGS
453 #define TARGET_SETUP_INCOMING_VARARGS ia64_setup_incoming_varargs
454 #undef TARGET_STRICT_ARGUMENT_NAMING
455 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
456 #undef TARGET_MUST_PASS_IN_STACK
457 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
458
459 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
460 #define TARGET_GIMPLIFY_VA_ARG_EXPR ia64_gimplify_va_arg
461
462 #undef TARGET_UNWIND_EMIT
463 #define TARGET_UNWIND_EMIT process_for_unwind_directive
464
465 #undef TARGET_SCALAR_MODE_SUPPORTED_P
466 #define TARGET_SCALAR_MODE_SUPPORTED_P ia64_scalar_mode_supported_p
467 #undef TARGET_VECTOR_MODE_SUPPORTED_P
468 #define TARGET_VECTOR_MODE_SUPPORTED_P ia64_vector_mode_supported_p
469
470 /* ia64 architecture manual 4.4.7: ... reads, writes, and flushes may occur
471    in an order different from the specified program order.  */
472 #undef TARGET_RELAXED_ORDERING
473 #define TARGET_RELAXED_ORDERING true
474
475 #undef TARGET_DEFAULT_TARGET_FLAGS
476 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | TARGET_CPU_DEFAULT)
477 #undef TARGET_HANDLE_OPTION
478 #define TARGET_HANDLE_OPTION ia64_handle_option
479
480 #undef TARGET_CANNOT_FORCE_CONST_MEM
481 #define TARGET_CANNOT_FORCE_CONST_MEM ia64_cannot_force_const_mem
482
483 #undef TARGET_MANGLE_TYPE
484 #define TARGET_MANGLE_TYPE ia64_mangle_type
485
486 #undef TARGET_INVALID_CONVERSION
487 #define TARGET_INVALID_CONVERSION ia64_invalid_conversion
488 #undef TARGET_INVALID_UNARY_OP
489 #define TARGET_INVALID_UNARY_OP ia64_invalid_unary_op
490 #undef TARGET_INVALID_BINARY_OP
491 #define TARGET_INVALID_BINARY_OP ia64_invalid_binary_op
492
493 #undef TARGET_C_MODE_FOR_SUFFIX
494 #define TARGET_C_MODE_FOR_SUFFIX ia64_c_mode_for_suffix
495
496 struct gcc_target targetm = TARGET_INITIALIZER;
497 \f
498 typedef enum
499   {
500     ADDR_AREA_NORMAL,   /* normal address area */
501     ADDR_AREA_SMALL     /* addressable by "addl" (-2MB < addr < 2MB) */
502   }
503 ia64_addr_area;
504
505 static GTY(()) tree small_ident1;
506 static GTY(()) tree small_ident2;
507
508 static void
509 init_idents (void)
510 {
511   if (small_ident1 == 0)
512     {
513       small_ident1 = get_identifier ("small");
514       small_ident2 = get_identifier ("__small__");
515     }
516 }
517
518 /* Retrieve the address area that has been chosen for the given decl.  */
519
520 static ia64_addr_area
521 ia64_get_addr_area (tree decl)
522 {
523   tree model_attr;
524
525   model_attr = lookup_attribute ("model", DECL_ATTRIBUTES (decl));
526   if (model_attr)
527     {
528       tree id;
529
530       init_idents ();
531       id = TREE_VALUE (TREE_VALUE (model_attr));
532       if (id == small_ident1 || id == small_ident2)
533         return ADDR_AREA_SMALL;
534     }
535   return ADDR_AREA_NORMAL;
536 }
537
538 static tree
539 ia64_handle_model_attribute (tree *node, tree name, tree args,
540                              int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
541 {
542   ia64_addr_area addr_area = ADDR_AREA_NORMAL;
543   ia64_addr_area area;
544   tree arg, decl = *node;
545
546   init_idents ();
547   arg = TREE_VALUE (args);
548   if (arg == small_ident1 || arg == small_ident2)
549     {
550       addr_area = ADDR_AREA_SMALL;
551     }
552   else
553     {
554       warning (OPT_Wattributes, "invalid argument of %qs attribute",
555                IDENTIFIER_POINTER (name));
556       *no_add_attrs = true;
557     }
558
559   switch (TREE_CODE (decl))
560     {
561     case VAR_DECL:
562       if ((DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl))
563            == FUNCTION_DECL)
564           && !TREE_STATIC (decl))
565         {
566           error ("%Jan address area attribute cannot be specified for "
567                  "local variables", decl);
568           *no_add_attrs = true;
569         }
570       area = ia64_get_addr_area (decl);
571       if (area != ADDR_AREA_NORMAL && addr_area != area)
572         {
573           error ("address area of %q+D conflicts with previous "
574                  "declaration", decl);
575           *no_add_attrs = true;
576         }
577       break;
578
579     case FUNCTION_DECL:
580       error ("%Jaddress area attribute cannot be specified for functions",
581              decl);
582       *no_add_attrs = true;
583       break;
584
585     default:
586       warning (OPT_Wattributes, "%qs attribute ignored",
587                IDENTIFIER_POINTER (name));
588       *no_add_attrs = true;
589       break;
590     }
591
592   return NULL_TREE;
593 }
594
595 static void
596 ia64_encode_addr_area (tree decl, rtx symbol)
597 {
598   int flags;
599
600   flags = SYMBOL_REF_FLAGS (symbol);
601   switch (ia64_get_addr_area (decl))
602     {
603     case ADDR_AREA_NORMAL: break;
604     case ADDR_AREA_SMALL: flags |= SYMBOL_FLAG_SMALL_ADDR; break;
605     default: gcc_unreachable ();
606     }
607   SYMBOL_REF_FLAGS (symbol) = flags;
608 }
609
610 static void
611 ia64_encode_section_info (tree decl, rtx rtl, int first)
612 {
613   default_encode_section_info (decl, rtl, first);
614
615   /* Careful not to prod global register variables.  */
616   if (TREE_CODE (decl) == VAR_DECL
617       && GET_CODE (DECL_RTL (decl)) == MEM
618       && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF
619       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
620     ia64_encode_addr_area (decl, XEXP (rtl, 0));
621 }
622 \f
623 /* Return 1 if the operands of a move are ok.  */
624
625 int
626 ia64_move_ok (rtx dst, rtx src)
627 {
628   /* If we're under init_recog_no_volatile, we'll not be able to use
629      memory_operand.  So check the code directly and don't worry about
630      the validity of the underlying address, which should have been
631      checked elsewhere anyway.  */
632   if (GET_CODE (dst) != MEM)
633     return 1;
634   if (GET_CODE (src) == MEM)
635     return 0;
636   if (register_operand (src, VOIDmode))
637     return 1;
638
639   /* Otherwise, this must be a constant, and that either 0 or 0.0 or 1.0.  */
640   if (INTEGRAL_MODE_P (GET_MODE (dst)))
641     return src == const0_rtx;
642   else
643     return satisfies_constraint_G (src);
644 }
645
646 /* Return 1 if the operands are ok for a floating point load pair.  */
647
648 int
649 ia64_load_pair_ok (rtx dst, rtx src)
650 {
651   if (GET_CODE (dst) != REG || !FP_REGNO_P (REGNO (dst)))
652     return 0;
653   if (GET_CODE (src) != MEM || MEM_VOLATILE_P (src))
654     return 0;
655   switch (GET_CODE (XEXP (src, 0)))
656     {
657     case REG:
658     case POST_INC:
659       break;
660     case POST_DEC:
661       return 0;
662     case POST_MODIFY:
663       {
664         rtx adjust = XEXP (XEXP (XEXP (src, 0), 1), 1);
665
666         if (GET_CODE (adjust) != CONST_INT
667             || INTVAL (adjust) != GET_MODE_SIZE (GET_MODE (src)))
668           return 0;
669       }
670       break;
671     default:
672       abort ();
673     }
674   return 1;
675 }
676
677 int
678 addp4_optimize_ok (rtx op1, rtx op2)
679 {
680   return (basereg_operand (op1, GET_MODE(op1)) !=
681           basereg_operand (op2, GET_MODE(op2)));
682 }
683
684 /* Check if OP is a mask suitable for use with SHIFT in a dep.z instruction.
685    Return the length of the field, or <= 0 on failure.  */
686
687 int
688 ia64_depz_field_mask (rtx rop, rtx rshift)
689 {
690   unsigned HOST_WIDE_INT op = INTVAL (rop);
691   unsigned HOST_WIDE_INT shift = INTVAL (rshift);
692
693   /* Get rid of the zero bits we're shifting in.  */
694   op >>= shift;
695
696   /* We must now have a solid block of 1's at bit 0.  */
697   return exact_log2 (op + 1);
698 }
699
700 /* Return the TLS model to use for ADDR.  */
701
702 static enum tls_model
703 tls_symbolic_operand_type (rtx addr)
704 {
705   enum tls_model tls_kind = 0;
706
707   if (GET_CODE (addr) == CONST)
708     {
709       if (GET_CODE (XEXP (addr, 0)) == PLUS
710           && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF)
711         tls_kind = SYMBOL_REF_TLS_MODEL (XEXP (XEXP (addr, 0), 0));
712     }
713   else if (GET_CODE (addr) == SYMBOL_REF)
714     tls_kind = SYMBOL_REF_TLS_MODEL (addr);
715
716   return tls_kind;
717 }
718
719 /* Return true if X is a constant that is valid for some immediate
720    field in an instruction.  */
721
722 bool
723 ia64_legitimate_constant_p (rtx x)
724 {
725   switch (GET_CODE (x))
726     {
727     case CONST_INT:
728     case LABEL_REF:
729       return true;
730
731     case CONST_DOUBLE:
732       if (GET_MODE (x) == VOIDmode)
733         return true;
734       return satisfies_constraint_G (x);
735
736     case CONST:
737     case SYMBOL_REF:
738       /* ??? Short term workaround for PR 28490.  We must make the code here
739          match the code in ia64_expand_move and move_operand, even though they
740          are both technically wrong.  */
741       if (tls_symbolic_operand_type (x) == 0)
742         {
743           HOST_WIDE_INT addend = 0;
744           rtx op = x;
745
746           if (GET_CODE (op) == CONST
747               && GET_CODE (XEXP (op, 0)) == PLUS
748               && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
749             {
750               addend = INTVAL (XEXP (XEXP (op, 0), 1));
751               op = XEXP (XEXP (op, 0), 0);
752             }
753
754           if (any_offset_symbol_operand (op, GET_MODE (op))
755               || function_operand (op, GET_MODE (op)))
756             return true;
757           if (aligned_offset_symbol_operand (op, GET_MODE (op)))
758             return (addend & 0x3fff) == 0;
759           return false;
760         }
761       return false;
762
763     case CONST_VECTOR:
764       {
765         enum machine_mode mode = GET_MODE (x);
766
767         if (mode == V2SFmode)
768           return satisfies_constraint_Y (x);
769
770         return (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
771                 && GET_MODE_SIZE (mode) <= 8);
772       }
773
774     default:
775       return false;
776     }
777 }
778
779 /* Don't allow TLS addresses to get spilled to memory.  */
780
781 static bool
782 ia64_cannot_force_const_mem (rtx x)
783 {
784   return tls_symbolic_operand_type (x) != 0;
785 }
786
787 /* Expand a symbolic constant load.  */
788
789 bool
790 ia64_expand_load_address (rtx dest, rtx src)
791 {
792   gcc_assert (GET_CODE (dest) == REG);
793
794   /* ILP32 mode still loads 64-bits of data from the GOT.  This avoids
795      having to pointer-extend the value afterward.  Other forms of address
796      computation below are also more natural to compute as 64-bit quantities.
797      If we've been given an SImode destination register, change it.  */
798   if (GET_MODE (dest) != Pmode)
799     dest = gen_rtx_REG_offset (dest, Pmode, REGNO (dest),
800                                byte_lowpart_offset (Pmode, GET_MODE (dest)));
801
802   if (TARGET_NO_PIC)
803     return false;
804   if (small_addr_symbolic_operand (src, VOIDmode))
805     return false;
806
807   if (TARGET_AUTO_PIC)
808     emit_insn (gen_load_gprel64 (dest, src));
809   else if (GET_CODE (src) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P (src))
810     emit_insn (gen_load_fptr (dest, src));
811   else if (sdata_symbolic_operand (src, VOIDmode))
812     emit_insn (gen_load_gprel (dest, src));
813   else
814     {
815       HOST_WIDE_INT addend = 0;
816       rtx tmp;
817
818       /* We did split constant offsets in ia64_expand_move, and we did try
819          to keep them split in move_operand, but we also allowed reload to
820          rematerialize arbitrary constants rather than spill the value to
821          the stack and reload it.  So we have to be prepared here to split
822          them apart again.  */
823       if (GET_CODE (src) == CONST)
824         {
825           HOST_WIDE_INT hi, lo;
826
827           hi = INTVAL (XEXP (XEXP (src, 0), 1));
828           lo = ((hi & 0x3fff) ^ 0x2000) - 0x2000;
829           hi = hi - lo;
830
831           if (lo != 0)
832             {
833               addend = lo;
834               src = plus_constant (XEXP (XEXP (src, 0), 0), hi);
835             }
836         }
837
838       tmp = gen_rtx_HIGH (Pmode, src);
839       tmp = gen_rtx_PLUS (Pmode, tmp, pic_offset_table_rtx);
840       emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
841
842       tmp = gen_rtx_LO_SUM (Pmode, dest, src);
843       emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
844
845       if (addend)
846         {
847           tmp = gen_rtx_PLUS (Pmode, dest, GEN_INT (addend));
848           emit_insn (gen_rtx_SET (VOIDmode, dest, tmp));
849         }
850     }
851
852   return true;
853 }
854
855 static GTY(()) rtx gen_tls_tga;
856 static rtx
857 gen_tls_get_addr (void)
858 {
859   if (!gen_tls_tga)
860     gen_tls_tga = init_one_libfunc ("__tls_get_addr");
861   return gen_tls_tga;
862 }
863
864 static GTY(()) rtx thread_pointer_rtx;
865 static rtx
866 gen_thread_pointer (void)
867 {
868   if (!thread_pointer_rtx)
869     thread_pointer_rtx = gen_rtx_REG (Pmode, 13);
870   return thread_pointer_rtx;
871 }
872
873 static rtx
874 ia64_expand_tls_address (enum tls_model tls_kind, rtx op0, rtx op1,
875                          rtx orig_op1, HOST_WIDE_INT addend)
876 {
877   rtx tga_op1, tga_op2, tga_ret, tga_eqv, tmp, insns;
878   rtx orig_op0 = op0;
879   HOST_WIDE_INT addend_lo, addend_hi;
880
881   switch (tls_kind)
882     {
883     case TLS_MODEL_GLOBAL_DYNAMIC:
884       start_sequence ();
885
886       tga_op1 = gen_reg_rtx (Pmode);
887       emit_insn (gen_load_dtpmod (tga_op1, op1));
888
889       tga_op2 = gen_reg_rtx (Pmode);
890       emit_insn (gen_load_dtprel (tga_op2, op1));
891
892       tga_ret = emit_library_call_value (gen_tls_get_addr (), NULL_RTX,
893                                          LCT_CONST, Pmode, 2, tga_op1,
894                                          Pmode, tga_op2, Pmode);
895
896       insns = get_insns ();
897       end_sequence ();
898
899       if (GET_MODE (op0) != Pmode)
900         op0 = tga_ret;
901       emit_libcall_block (insns, op0, tga_ret, op1);
902       break;
903
904     case TLS_MODEL_LOCAL_DYNAMIC:
905       /* ??? This isn't the completely proper way to do local-dynamic
906          If the call to __tls_get_addr is used only by a single symbol,
907          then we should (somehow) move the dtprel to the second arg
908          to avoid the extra add.  */
909       start_sequence ();
910
911       tga_op1 = gen_reg_rtx (Pmode);
912       emit_insn (gen_load_dtpmod (tga_op1, op1));
913
914       tga_op2 = const0_rtx;
915
916       tga_ret = emit_library_call_value (gen_tls_get_addr (), NULL_RTX,
917                                          LCT_CONST, Pmode, 2, tga_op1,
918                                          Pmode, tga_op2, Pmode);
919
920       insns = get_insns ();
921       end_sequence ();
922
923       tga_eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
924                                 UNSPEC_LD_BASE);
925       tmp = gen_reg_rtx (Pmode);
926       emit_libcall_block (insns, tmp, tga_ret, tga_eqv);
927
928       if (!register_operand (op0, Pmode))
929         op0 = gen_reg_rtx (Pmode);
930       if (TARGET_TLS64)
931         {
932           emit_insn (gen_load_dtprel (op0, op1));
933           emit_insn (gen_adddi3 (op0, tmp, op0));
934         }
935       else
936         emit_insn (gen_add_dtprel (op0, op1, tmp));
937       break;
938
939     case TLS_MODEL_INITIAL_EXEC:
940       addend_lo = ((addend & 0x3fff) ^ 0x2000) - 0x2000;
941       addend_hi = addend - addend_lo;
942
943       op1 = plus_constant (op1, addend_hi);
944       addend = addend_lo;
945
946       tmp = gen_reg_rtx (Pmode);
947       emit_insn (gen_load_tprel (tmp, op1));
948
949       if (!register_operand (op0, Pmode))
950         op0 = gen_reg_rtx (Pmode);
951       emit_insn (gen_adddi3 (op0, tmp, gen_thread_pointer ()));
952       break;
953
954     case TLS_MODEL_LOCAL_EXEC:
955       if (!register_operand (op0, Pmode))
956         op0 = gen_reg_rtx (Pmode);
957
958       op1 = orig_op1;
959       addend = 0;
960       if (TARGET_TLS64)
961         {
962           emit_insn (gen_load_tprel (op0, op1));
963           emit_insn (gen_adddi3 (op0, op0, gen_thread_pointer ()));
964         }
965       else
966         emit_insn (gen_add_tprel (op0, op1, gen_thread_pointer ()));
967       break;
968
969     default:
970       gcc_unreachable ();
971     }
972
973   if (addend)
974     op0 = expand_simple_binop (Pmode, PLUS, op0, GEN_INT (addend),
975                                orig_op0, 1, OPTAB_DIRECT);
976   if (orig_op0 == op0)
977     return NULL_RTX;
978   if (GET_MODE (orig_op0) == Pmode)
979     return op0;
980   return gen_lowpart (GET_MODE (orig_op0), op0);
981 }
982
983 rtx
984 ia64_expand_move (rtx op0, rtx op1)
985 {
986   enum machine_mode mode = GET_MODE (op0);
987
988   if (!reload_in_progress && !reload_completed && !ia64_move_ok (op0, op1))
989     op1 = force_reg (mode, op1);
990
991   if ((mode == Pmode || mode == ptr_mode) && symbolic_operand (op1, VOIDmode))
992     {
993       HOST_WIDE_INT addend = 0;
994       enum tls_model tls_kind;
995       rtx sym = op1;
996
997       if (GET_CODE (op1) == CONST
998           && GET_CODE (XEXP (op1, 0)) == PLUS
999           && GET_CODE (XEXP (XEXP (op1, 0), 1)) == CONST_INT)
1000         {
1001           addend = INTVAL (XEXP (XEXP (op1, 0), 1));
1002           sym = XEXP (XEXP (op1, 0), 0);
1003         }
1004
1005       tls_kind = tls_symbolic_operand_type (sym);
1006       if (tls_kind)
1007         return ia64_expand_tls_address (tls_kind, op0, sym, op1, addend);
1008
1009       if (any_offset_symbol_operand (sym, mode))
1010         addend = 0;
1011       else if (aligned_offset_symbol_operand (sym, mode))
1012         {
1013           HOST_WIDE_INT addend_lo, addend_hi;
1014               
1015           addend_lo = ((addend & 0x3fff) ^ 0x2000) - 0x2000;
1016           addend_hi = addend - addend_lo;
1017
1018           if (addend_lo != 0)
1019             {
1020               op1 = plus_constant (sym, addend_hi);
1021               addend = addend_lo;
1022             }
1023           else
1024             addend = 0;
1025         }
1026       else
1027         op1 = sym;
1028
1029       if (reload_completed)
1030         {
1031           /* We really should have taken care of this offset earlier.  */
1032           gcc_assert (addend == 0);
1033           if (ia64_expand_load_address (op0, op1))
1034             return NULL_RTX;
1035         }
1036
1037       if (addend)
1038         {
1039           rtx subtarget = !can_create_pseudo_p () ? op0 : gen_reg_rtx (mode);
1040
1041           emit_insn (gen_rtx_SET (VOIDmode, subtarget, op1));
1042
1043           op1 = expand_simple_binop (mode, PLUS, subtarget,
1044                                      GEN_INT (addend), op0, 1, OPTAB_DIRECT);
1045           if (op0 == op1)
1046             return NULL_RTX;
1047         }
1048     }
1049
1050   return op1;
1051 }
1052
1053 /* Split a move from OP1 to OP0 conditional on COND.  */
1054
1055 void
1056 ia64_emit_cond_move (rtx op0, rtx op1, rtx cond)
1057 {
1058   rtx insn, first = get_last_insn ();
1059
1060   emit_move_insn (op0, op1);
1061
1062   for (insn = get_last_insn (); insn != first; insn = PREV_INSN (insn))
1063     if (INSN_P (insn))
1064       PATTERN (insn) = gen_rtx_COND_EXEC (VOIDmode, copy_rtx (cond),
1065                                           PATTERN (insn));
1066 }
1067
1068 /* Split a post-reload TImode or TFmode reference into two DImode
1069    components.  This is made extra difficult by the fact that we do
1070    not get any scratch registers to work with, because reload cannot
1071    be prevented from giving us a scratch that overlaps the register
1072    pair involved.  So instead, when addressing memory, we tweak the
1073    pointer register up and back down with POST_INCs.  Or up and not
1074    back down when we can get away with it.
1075
1076    REVERSED is true when the loads must be done in reversed order
1077    (high word first) for correctness.  DEAD is true when the pointer
1078    dies with the second insn we generate and therefore the second
1079    address must not carry a postmodify.
1080
1081    May return an insn which is to be emitted after the moves.  */
1082
1083 static rtx
1084 ia64_split_tmode (rtx out[2], rtx in, bool reversed, bool dead)
1085 {
1086   rtx fixup = 0;
1087
1088   switch (GET_CODE (in))
1089     {
1090     case REG:
1091       out[reversed] = gen_rtx_REG (DImode, REGNO (in));
1092       out[!reversed] = gen_rtx_REG (DImode, REGNO (in) + 1);
1093       break;
1094
1095     case CONST_INT:
1096     case CONST_DOUBLE:
1097       /* Cannot occur reversed.  */
1098       gcc_assert (!reversed);
1099       
1100       if (GET_MODE (in) != TFmode)
1101         split_double (in, &out[0], &out[1]);
1102       else
1103         /* split_double does not understand how to split a TFmode
1104            quantity into a pair of DImode constants.  */
1105         {
1106           REAL_VALUE_TYPE r;
1107           unsigned HOST_WIDE_INT p[2];
1108           long l[4];  /* TFmode is 128 bits */
1109
1110           REAL_VALUE_FROM_CONST_DOUBLE (r, in);
1111           real_to_target (l, &r, TFmode);
1112
1113           if (FLOAT_WORDS_BIG_ENDIAN)
1114             {
1115               p[0] = (((unsigned HOST_WIDE_INT) l[0]) << 32) + l[1];
1116               p[1] = (((unsigned HOST_WIDE_INT) l[2]) << 32) + l[3];
1117             }
1118           else
1119             {
1120               p[0] = (((unsigned HOST_WIDE_INT) l[3]) << 32) + l[2];
1121               p[1] = (((unsigned HOST_WIDE_INT) l[1]) << 32) + l[0];
1122             }
1123           out[0] = GEN_INT (p[0]);
1124           out[1] = GEN_INT (p[1]);
1125         }
1126       break;
1127
1128     case MEM:
1129       {
1130         rtx base = XEXP (in, 0);
1131         rtx offset;
1132
1133         switch (GET_CODE (base))
1134           {
1135           case REG:
1136             if (!reversed)
1137               {
1138                 out[0] = adjust_automodify_address
1139                   (in, DImode, gen_rtx_POST_INC (Pmode, base), 0);
1140                 out[1] = adjust_automodify_address
1141                   (in, DImode, dead ? 0 : gen_rtx_POST_DEC (Pmode, base), 8);
1142               }
1143             else
1144               {
1145                 /* Reversal requires a pre-increment, which can only
1146                    be done as a separate insn.  */
1147                 emit_insn (gen_adddi3 (base, base, GEN_INT (8)));
1148                 out[0] = adjust_automodify_address
1149                   (in, DImode, gen_rtx_POST_DEC (Pmode, base), 8);
1150                 out[1] = adjust_address (in, DImode, 0);
1151               }
1152             break;
1153
1154           case POST_INC:
1155             gcc_assert (!reversed && !dead);
1156             
1157             /* Just do the increment in two steps.  */
1158             out[0] = adjust_automodify_address (in, DImode, 0, 0);
1159             out[1] = adjust_automodify_address (in, DImode, 0, 8);
1160             break;
1161
1162           case POST_DEC:
1163             gcc_assert (!reversed && !dead);
1164             
1165             /* Add 8, subtract 24.  */
1166             base = XEXP (base, 0);
1167             out[0] = adjust_automodify_address
1168               (in, DImode, gen_rtx_POST_INC (Pmode, base), 0);
1169             out[1] = adjust_automodify_address
1170               (in, DImode,
1171                gen_rtx_POST_MODIFY (Pmode, base, plus_constant (base, -24)),
1172                8);
1173             break;
1174
1175           case POST_MODIFY:
1176             gcc_assert (!reversed && !dead);
1177
1178             /* Extract and adjust the modification.  This case is
1179                trickier than the others, because we might have an
1180                index register, or we might have a combined offset that
1181                doesn't fit a signed 9-bit displacement field.  We can
1182                assume the incoming expression is already legitimate.  */
1183             offset = XEXP (base, 1);
1184             base = XEXP (base, 0);
1185
1186             out[0] = adjust_automodify_address
1187               (in, DImode, gen_rtx_POST_INC (Pmode, base), 0);
1188
1189             if (GET_CODE (XEXP (offset, 1)) == REG)
1190               {
1191                 /* Can't adjust the postmodify to match.  Emit the
1192                    original, then a separate addition insn.  */
1193                 out[1] = adjust_automodify_address (in, DImode, 0, 8);
1194                 fixup = gen_adddi3 (base, base, GEN_INT (-8));
1195               }
1196             else
1197               {
1198                 gcc_assert (GET_CODE (XEXP (offset, 1)) == CONST_INT);
1199                 if (INTVAL (XEXP (offset, 1)) < -256 + 8)
1200                   {
1201                     /* Again the postmodify cannot be made to match,
1202                        but in this case it's more efficient to get rid
1203                        of the postmodify entirely and fix up with an
1204                        add insn.  */
1205                     out[1] = adjust_automodify_address (in, DImode, base, 8);
1206                     fixup = gen_adddi3
1207                       (base, base, GEN_INT (INTVAL (XEXP (offset, 1)) - 8));
1208                   }
1209                 else
1210                   {
1211                     /* Combined offset still fits in the displacement field.
1212                        (We cannot overflow it at the high end.)  */
1213                     out[1] = adjust_automodify_address
1214                       (in, DImode, gen_rtx_POST_MODIFY
1215                        (Pmode, base, gen_rtx_PLUS
1216                         (Pmode, base,
1217                          GEN_INT (INTVAL (XEXP (offset, 1)) - 8))),
1218                        8);
1219                   }
1220               }
1221             break;
1222
1223           default:
1224             gcc_unreachable ();
1225           }
1226         break;
1227       }
1228
1229     default:
1230       gcc_unreachable ();
1231     }
1232
1233   return fixup;
1234 }
1235
1236 /* Split a TImode or TFmode move instruction after reload.
1237    This is used by *movtf_internal and *movti_internal.  */
1238 void
1239 ia64_split_tmode_move (rtx operands[])
1240 {
1241   rtx in[2], out[2], insn;
1242   rtx fixup[2];
1243   bool dead = false;
1244   bool reversed = false;
1245
1246   /* It is possible for reload to decide to overwrite a pointer with
1247      the value it points to.  In that case we have to do the loads in
1248      the appropriate order so that the pointer is not destroyed too
1249      early.  Also we must not generate a postmodify for that second
1250      load, or rws_access_regno will die.  */
1251   if (GET_CODE (operands[1]) == MEM
1252       && reg_overlap_mentioned_p (operands[0], operands[1]))
1253     {
1254       rtx base = XEXP (operands[1], 0);
1255       while (GET_CODE (base) != REG)
1256         base = XEXP (base, 0);
1257
1258       if (REGNO (base) == REGNO (operands[0]))
1259         reversed = true;
1260       dead = true;
1261     }
1262   /* Another reason to do the moves in reversed order is if the first
1263      element of the target register pair is also the second element of
1264      the source register pair.  */
1265   if (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG
1266       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
1267     reversed = true;
1268
1269   fixup[0] = ia64_split_tmode (in, operands[1], reversed, dead);
1270   fixup[1] = ia64_split_tmode (out, operands[0], reversed, dead);
1271
1272 #define MAYBE_ADD_REG_INC_NOTE(INSN, EXP)                               \
1273   if (GET_CODE (EXP) == MEM                                             \
1274       && (GET_CODE (XEXP (EXP, 0)) == POST_MODIFY                       \
1275           || GET_CODE (XEXP (EXP, 0)) == POST_INC                       \
1276           || GET_CODE (XEXP (EXP, 0)) == POST_DEC))                     \
1277     REG_NOTES (INSN) = gen_rtx_EXPR_LIST (REG_INC,                      \
1278                                           XEXP (XEXP (EXP, 0), 0),      \
1279                                           REG_NOTES (INSN))
1280
1281   insn = emit_insn (gen_rtx_SET (VOIDmode, out[0], in[0]));
1282   MAYBE_ADD_REG_INC_NOTE (insn, in[0]);
1283   MAYBE_ADD_REG_INC_NOTE (insn, out[0]);
1284
1285   insn = emit_insn (gen_rtx_SET (VOIDmode, out[1], in[1]));
1286   MAYBE_ADD_REG_INC_NOTE (insn, in[1]);
1287   MAYBE_ADD_REG_INC_NOTE (insn, out[1]);
1288
1289   if (fixup[0])
1290     emit_insn (fixup[0]);
1291   if (fixup[1])
1292     emit_insn (fixup[1]);
1293
1294 #undef MAYBE_ADD_REG_INC_NOTE
1295 }
1296
1297 /* ??? Fixing GR->FR XFmode moves during reload is hard.  You need to go
1298    through memory plus an extra GR scratch register.  Except that you can
1299    either get the first from SECONDARY_MEMORY_NEEDED or the second from
1300    SECONDARY_RELOAD_CLASS, but not both.
1301
1302    We got into problems in the first place by allowing a construct like
1303    (subreg:XF (reg:TI)), which we got from a union containing a long double.
1304    This solution attempts to prevent this situation from occurring.  When
1305    we see something like the above, we spill the inner register to memory.  */
1306
1307 static rtx
1308 spill_xfmode_rfmode_operand (rtx in, int force, enum machine_mode mode)
1309 {
1310   if (GET_CODE (in) == SUBREG
1311       && GET_MODE (SUBREG_REG (in)) == TImode
1312       && GET_CODE (SUBREG_REG (in)) == REG)
1313     {
1314       rtx memt = assign_stack_temp (TImode, 16, 0);
1315       emit_move_insn (memt, SUBREG_REG (in));
1316       return adjust_address (memt, mode, 0);
1317     }
1318   else if (force && GET_CODE (in) == REG)
1319     {
1320       rtx memx = assign_stack_temp (mode, 16, 0);
1321       emit_move_insn (memx, in);
1322       return memx;
1323     }
1324   else
1325     return in;
1326 }
1327
1328 /* Expand the movxf or movrf pattern (MODE says which) with the given
1329    OPERANDS, returning true if the pattern should then invoke
1330    DONE.  */
1331
1332 bool
1333 ia64_expand_movxf_movrf (enum machine_mode mode, rtx operands[])
1334 {
1335   rtx op0 = operands[0];
1336
1337   if (GET_CODE (op0) == SUBREG)
1338     op0 = SUBREG_REG (op0);
1339
1340   /* We must support XFmode loads into general registers for stdarg/vararg,
1341      unprototyped calls, and a rare case where a long double is passed as
1342      an argument after a float HFA fills the FP registers.  We split them into
1343      DImode loads for convenience.  We also need to support XFmode stores
1344      for the last case.  This case does not happen for stdarg/vararg routines,
1345      because we do a block store to memory of unnamed arguments.  */
1346
1347   if (GET_CODE (op0) == REG && GR_REGNO_P (REGNO (op0)))
1348     {
1349       rtx out[2];
1350
1351       /* We're hoping to transform everything that deals with XFmode
1352          quantities and GR registers early in the compiler.  */
1353       gcc_assert (can_create_pseudo_p ());
1354
1355       /* Struct to register can just use TImode instead.  */
1356       if ((GET_CODE (operands[1]) == SUBREG
1357            && GET_MODE (SUBREG_REG (operands[1])) == TImode)
1358           || (GET_CODE (operands[1]) == REG
1359               && GR_REGNO_P (REGNO (operands[1]))))
1360         {
1361           rtx op1 = operands[1];
1362
1363           if (GET_CODE (op1) == SUBREG)
1364             op1 = SUBREG_REG (op1);
1365           else
1366             op1 = gen_rtx_REG (TImode, REGNO (op1));
1367
1368           emit_move_insn (gen_rtx_REG (TImode, REGNO (op0)), op1);
1369           return true;
1370         }
1371
1372       if (GET_CODE (operands[1]) == CONST_DOUBLE)
1373         {
1374           /* Don't word-swap when reading in the constant.  */
1375           emit_move_insn (gen_rtx_REG (DImode, REGNO (op0)),
1376                           operand_subword (operands[1], WORDS_BIG_ENDIAN,
1377                                            0, mode));
1378           emit_move_insn (gen_rtx_REG (DImode, REGNO (op0) + 1),
1379                           operand_subword (operands[1], !WORDS_BIG_ENDIAN,
1380                                            0, mode));
1381           return true;
1382         }
1383
1384       /* If the quantity is in a register not known to be GR, spill it.  */
1385       if (register_operand (operands[1], mode))
1386         operands[1] = spill_xfmode_rfmode_operand (operands[1], 1, mode);
1387
1388       gcc_assert (GET_CODE (operands[1]) == MEM);
1389
1390       /* Don't word-swap when reading in the value.  */
1391       out[0] = gen_rtx_REG (DImode, REGNO (op0));
1392       out[1] = gen_rtx_REG (DImode, REGNO (op0) + 1);
1393
1394       emit_move_insn (out[0], adjust_address (operands[1], DImode, 0));
1395       emit_move_insn (out[1], adjust_address (operands[1], DImode, 8));
1396       return true;
1397     }
1398
1399   if (GET_CODE (operands[1]) == REG && GR_REGNO_P (REGNO (operands[1])))
1400     {
1401       /* We're hoping to transform everything that deals with XFmode
1402          quantities and GR registers early in the compiler.  */
1403       gcc_assert (can_create_pseudo_p ());
1404
1405       /* Op0 can't be a GR_REG here, as that case is handled above.
1406          If op0 is a register, then we spill op1, so that we now have a
1407          MEM operand.  This requires creating an XFmode subreg of a TImode reg
1408          to force the spill.  */
1409       if (register_operand (operands[0], mode))
1410         {
1411           rtx op1 = gen_rtx_REG (TImode, REGNO (operands[1]));
1412           op1 = gen_rtx_SUBREG (mode, op1, 0);
1413           operands[1] = spill_xfmode_rfmode_operand (op1, 0, mode);
1414         }
1415
1416       else
1417         {
1418           rtx in[2];
1419
1420           gcc_assert (GET_CODE (operands[0]) == MEM);
1421
1422           /* Don't word-swap when writing out the value.  */
1423           in[0] = gen_rtx_REG (DImode, REGNO (operands[1]));
1424           in[1] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
1425
1426           emit_move_insn (adjust_address (operands[0], DImode, 0), in[0]);
1427           emit_move_insn (adjust_address (operands[0], DImode, 8), in[1]);
1428           return true;
1429         }
1430     }
1431
1432   if (!reload_in_progress && !reload_completed)
1433     {
1434       operands[1] = spill_xfmode_rfmode_operand (operands[1], 0, mode);
1435
1436       if (GET_MODE (op0) == TImode && GET_CODE (op0) == REG)
1437         {
1438           rtx memt, memx, in = operands[1];
1439           if (CONSTANT_P (in))
1440             in = validize_mem (force_const_mem (mode, in));
1441           if (GET_CODE (in) == MEM)
1442             memt = adjust_address (in, TImode, 0);
1443           else
1444             {
1445               memt = assign_stack_temp (TImode, 16, 0);
1446               memx = adjust_address (memt, mode, 0);
1447               emit_move_insn (memx, in);
1448             }
1449           emit_move_insn (op0, memt);
1450           return true;
1451         }
1452
1453       if (!ia64_move_ok (operands[0], operands[1]))
1454         operands[1] = force_reg (mode, operands[1]);
1455     }
1456
1457   return false;
1458 }
1459
1460 /* Emit comparison instruction if necessary, returning the expression
1461    that holds the compare result in the proper mode.  */
1462
1463 static GTY(()) rtx cmptf_libfunc;
1464
1465 rtx
1466 ia64_expand_compare (enum rtx_code code, enum machine_mode mode)
1467 {
1468   rtx op0 = ia64_compare_op0, op1 = ia64_compare_op1;
1469   rtx cmp;
1470
1471   /* If we have a BImode input, then we already have a compare result, and
1472      do not need to emit another comparison.  */
1473   if (GET_MODE (op0) == BImode)
1474     {
1475       gcc_assert ((code == NE || code == EQ) && op1 == const0_rtx);
1476       cmp = op0;
1477     }
1478   /* HPUX TFmode compare requires a library call to _U_Qfcmp, which takes a
1479      magic number as its third argument, that indicates what to do.
1480      The return value is an integer to be compared against zero.  */
1481   else if (GET_MODE (op0) == TFmode)
1482     {
1483       enum qfcmp_magic {
1484         QCMP_INV = 1,   /* Raise FP_INVALID on SNaN as a side effect.  */
1485         QCMP_UNORD = 2,
1486         QCMP_EQ = 4,
1487         QCMP_LT = 8,
1488         QCMP_GT = 16
1489       } magic;
1490       enum rtx_code ncode;
1491       rtx ret, insns;
1492       
1493       gcc_assert (cmptf_libfunc && GET_MODE (op1) == TFmode);
1494       switch (code)
1495         {
1496           /* 1 = equal, 0 = not equal.  Equality operators do
1497              not raise FP_INVALID when given an SNaN operand.  */
1498         case EQ:        magic = QCMP_EQ;                  ncode = NE; break;
1499         case NE:        magic = QCMP_EQ;                  ncode = EQ; break;
1500           /* isunordered() from C99.  */
1501         case UNORDERED: magic = QCMP_UNORD;               ncode = NE; break;
1502         case ORDERED:   magic = QCMP_UNORD;               ncode = EQ; break;
1503           /* Relational operators raise FP_INVALID when given
1504              an SNaN operand.  */
1505         case LT:        magic = QCMP_LT        |QCMP_INV; ncode = NE; break;
1506         case LE:        magic = QCMP_LT|QCMP_EQ|QCMP_INV; ncode = NE; break;
1507         case GT:        magic = QCMP_GT        |QCMP_INV; ncode = NE; break;
1508         case GE:        magic = QCMP_GT|QCMP_EQ|QCMP_INV; ncode = NE; break;
1509           /* FUTURE: Implement UNEQ, UNLT, UNLE, UNGT, UNGE, LTGT.
1510              Expanders for buneq etc. weuld have to be added to ia64.md
1511              for this to be useful.  */
1512         default: gcc_unreachable ();
1513         }
1514
1515       start_sequence ();
1516
1517       ret = emit_library_call_value (cmptf_libfunc, 0, LCT_CONST, DImode, 3,
1518                                      op0, TFmode, op1, TFmode,
1519                                      GEN_INT (magic), DImode);
1520       cmp = gen_reg_rtx (BImode);
1521       emit_insn (gen_rtx_SET (VOIDmode, cmp,
1522                               gen_rtx_fmt_ee (ncode, BImode,
1523                                               ret, const0_rtx)));
1524
1525       insns = get_insns ();
1526       end_sequence ();
1527
1528       emit_libcall_block (insns, cmp, cmp,
1529                           gen_rtx_fmt_ee (code, BImode, op0, op1));
1530       code = NE;
1531     }
1532   else
1533     {
1534       cmp = gen_reg_rtx (BImode);
1535       emit_insn (gen_rtx_SET (VOIDmode, cmp,
1536                               gen_rtx_fmt_ee (code, BImode, op0, op1)));
1537       code = NE;
1538     }
1539
1540   return gen_rtx_fmt_ee (code, mode, cmp, const0_rtx);
1541 }
1542
1543 /* Generate an integral vector comparison.  Return true if the condition has
1544    been reversed, and so the sense of the comparison should be inverted.  */
1545
1546 static bool
1547 ia64_expand_vecint_compare (enum rtx_code code, enum machine_mode mode,
1548                             rtx dest, rtx op0, rtx op1)
1549 {
1550   bool negate = false;
1551   rtx x;
1552
1553   /* Canonicalize the comparison to EQ, GT, GTU.  */
1554   switch (code)
1555     {
1556     case EQ:
1557     case GT:
1558     case GTU:
1559       break;
1560
1561     case NE:
1562     case LE:
1563     case LEU:
1564       code = reverse_condition (code);
1565       negate = true;
1566       break;
1567
1568     case GE:
1569     case GEU:
1570       code = reverse_condition (code);
1571       negate = true;
1572       /* FALLTHRU */
1573
1574     case LT:
1575     case LTU:
1576       code = swap_condition (code);
1577       x = op0, op0 = op1, op1 = x;
1578       break;
1579
1580     default:
1581       gcc_unreachable ();
1582     }
1583
1584   /* Unsigned parallel compare is not supported by the hardware.  Play some
1585      tricks to turn this into a signed comparison against 0.  */
1586   if (code == GTU)
1587     {
1588       switch (mode)
1589         {
1590         case V2SImode:
1591           {
1592             rtx t1, t2, mask;
1593
1594             /* Perform a parallel modulo subtraction.  */
1595             t1 = gen_reg_rtx (V2SImode);
1596             emit_insn (gen_subv2si3 (t1, op0, op1));
1597
1598             /* Extract the original sign bit of op0.  */
1599             mask = GEN_INT (-0x80000000);
1600             mask = gen_rtx_CONST_VECTOR (V2SImode, gen_rtvec (2, mask, mask));
1601             mask = force_reg (V2SImode, mask);
1602             t2 = gen_reg_rtx (V2SImode);
1603             emit_insn (gen_andv2si3 (t2, op0, mask));
1604
1605             /* XOR it back into the result of the subtraction.  This results
1606                in the sign bit set iff we saw unsigned underflow.  */
1607             x = gen_reg_rtx (V2SImode);
1608             emit_insn (gen_xorv2si3 (x, t1, t2));
1609
1610             code = GT;
1611             op0 = x;
1612             op1 = CONST0_RTX (mode);
1613           }
1614           break;
1615
1616         case V8QImode:
1617         case V4HImode:
1618           /* Perform a parallel unsigned saturating subtraction.  */
1619           x = gen_reg_rtx (mode);
1620           emit_insn (gen_rtx_SET (VOIDmode, x,
1621                                   gen_rtx_US_MINUS (mode, op0, op1)));
1622
1623           code = EQ;
1624           op0 = x;
1625           op1 = CONST0_RTX (mode);
1626           negate = !negate;
1627           break;
1628
1629         default:
1630           gcc_unreachable ();
1631         }
1632     }
1633
1634   x = gen_rtx_fmt_ee (code, mode, op0, op1);
1635   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
1636
1637   return negate;
1638 }
1639
1640 /* Emit an integral vector conditional move.  */
1641
1642 void
1643 ia64_expand_vecint_cmov (rtx operands[])
1644 {
1645   enum machine_mode mode = GET_MODE (operands[0]);
1646   enum rtx_code code = GET_CODE (operands[3]);
1647   bool negate;
1648   rtx cmp, x, ot, of;
1649
1650   cmp = gen_reg_rtx (mode);
1651   negate = ia64_expand_vecint_compare (code, mode, cmp,
1652                                        operands[4], operands[5]);
1653
1654   ot = operands[1+negate];
1655   of = operands[2-negate];
1656
1657   if (ot == CONST0_RTX (mode))
1658     {
1659       if (of == CONST0_RTX (mode))
1660         {
1661           emit_move_insn (operands[0], ot);
1662           return;
1663         }
1664
1665       x = gen_rtx_NOT (mode, cmp);
1666       x = gen_rtx_AND (mode, x, of);
1667       emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
1668     }
1669   else if (of == CONST0_RTX (mode))
1670     {
1671       x = gen_rtx_AND (mode, cmp, ot);
1672       emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
1673     }
1674   else
1675     {
1676       rtx t, f;
1677
1678       t = gen_reg_rtx (mode);
1679       x = gen_rtx_AND (mode, cmp, operands[1+negate]);
1680       emit_insn (gen_rtx_SET (VOIDmode, t, x));
1681
1682       f = gen_reg_rtx (mode);
1683       x = gen_rtx_NOT (mode, cmp);
1684       x = gen_rtx_AND (mode, x, operands[2-negate]);
1685       emit_insn (gen_rtx_SET (VOIDmode, f, x));
1686
1687       x = gen_rtx_IOR (mode, t, f);
1688       emit_insn (gen_rtx_SET (VOIDmode, operands[0], x));
1689     }
1690 }
1691
1692 /* Emit an integral vector min or max operation.  Return true if all done.  */
1693
1694 bool
1695 ia64_expand_vecint_minmax (enum rtx_code code, enum machine_mode mode,
1696                            rtx operands[])
1697 {
1698   rtx xops[6];
1699
1700   /* These four combinations are supported directly.  */
1701   if (mode == V8QImode && (code == UMIN || code == UMAX))
1702     return false;
1703   if (mode == V4HImode && (code == SMIN || code == SMAX))
1704     return false;
1705
1706   /* This combination can be implemented with only saturating subtraction.  */
1707   if (mode == V4HImode && code == UMAX)
1708     {
1709       rtx x, tmp = gen_reg_rtx (mode);
1710
1711       x = gen_rtx_US_MINUS (mode, operands[1], operands[2]);
1712       emit_insn (gen_rtx_SET (VOIDmode, tmp, x));
1713
1714       emit_insn (gen_addv4hi3 (operands[0], tmp, operands[2]));
1715       return true;
1716     }
1717
1718   /* Everything else implemented via vector comparisons.  */
1719   xops[0] = operands[0];
1720   xops[4] = xops[1] = operands[1];
1721   xops[5] = xops[2] = operands[2];
1722
1723   switch (code)
1724     {
1725     case UMIN:
1726       code = LTU;
1727       break;
1728     case UMAX:
1729       code = GTU;
1730       break;
1731     case SMIN:
1732       code = LT;
1733       break;
1734     case SMAX:
1735       code = GT;
1736       break;
1737     default:
1738       gcc_unreachable ();
1739     }
1740   xops[3] = gen_rtx_fmt_ee (code, VOIDmode, operands[1], operands[2]);
1741
1742   ia64_expand_vecint_cmov (xops);
1743   return true;
1744 }
1745
1746 /* Emit an integral vector widening sum operations.  */
1747
1748 void
1749 ia64_expand_widen_sum (rtx operands[3], bool unsignedp)
1750 {
1751   rtx l, h, x, s;
1752   enum machine_mode wmode, mode;
1753   rtx (*unpack_l) (rtx, rtx, rtx);
1754   rtx (*unpack_h) (rtx, rtx, rtx);
1755   rtx (*plus) (rtx, rtx, rtx);
1756
1757   wmode = GET_MODE (operands[0]);
1758   mode = GET_MODE (operands[1]);
1759
1760   switch (mode)
1761     {
1762     case V8QImode:
1763       unpack_l = gen_unpack1_l;
1764       unpack_h = gen_unpack1_h;
1765       plus = gen_addv4hi3;
1766       break;
1767     case V4HImode:
1768       unpack_l = gen_unpack2_l;
1769       unpack_h = gen_unpack2_h;
1770       plus = gen_addv2si3;
1771       break;
1772     default:
1773       gcc_unreachable ();
1774     }
1775
1776   /* Fill in x with the sign extension of each element in op1.  */
1777   if (unsignedp)
1778     x = CONST0_RTX (mode);
1779   else
1780     {
1781       bool neg;
1782
1783       x = gen_reg_rtx (mode);
1784
1785       neg = ia64_expand_vecint_compare (LT, mode, x, operands[1],
1786                                         CONST0_RTX (mode));
1787       gcc_assert (!neg);
1788     }
1789
1790   l = gen_reg_rtx (wmode);
1791   h = gen_reg_rtx (wmode);
1792   s = gen_reg_rtx (wmode);
1793
1794   emit_insn (unpack_l (gen_lowpart (mode, l), operands[1], x));
1795   emit_insn (unpack_h (gen_lowpart (mode, h), operands[1], x));
1796   emit_insn (plus (s, l, operands[2]));
1797   emit_insn (plus (operands[0], h, s));
1798 }
1799
1800 /* Emit a signed or unsigned V8QI dot product operation.  */
1801
1802 void
1803 ia64_expand_dot_prod_v8qi (rtx operands[4], bool unsignedp)
1804 {
1805   rtx l1, l2, h1, h2, x1, x2, p1, p2, p3, p4, s1, s2, s3;
1806
1807   /* Fill in x1 and x2 with the sign extension of each element.  */
1808   if (unsignedp)
1809     x1 = x2 = CONST0_RTX (V8QImode);
1810   else
1811     {
1812       bool neg;
1813
1814       x1 = gen_reg_rtx (V8QImode);
1815       x2 = gen_reg_rtx (V8QImode);
1816
1817       neg = ia64_expand_vecint_compare (LT, V8QImode, x1, operands[1],
1818                                         CONST0_RTX (V8QImode));
1819       gcc_assert (!neg);
1820       neg = ia64_expand_vecint_compare (LT, V8QImode, x2, operands[2],
1821                                         CONST0_RTX (V8QImode));
1822       gcc_assert (!neg);
1823     }
1824
1825   l1 = gen_reg_rtx (V4HImode);
1826   l2 = gen_reg_rtx (V4HImode);
1827   h1 = gen_reg_rtx (V4HImode);
1828   h2 = gen_reg_rtx (V4HImode);
1829
1830   emit_insn (gen_unpack1_l (gen_lowpart (V8QImode, l1), operands[1], x1));
1831   emit_insn (gen_unpack1_l (gen_lowpart (V8QImode, l2), operands[2], x2));
1832   emit_insn (gen_unpack1_h (gen_lowpart (V8QImode, h1), operands[1], x1));
1833   emit_insn (gen_unpack1_h (gen_lowpart (V8QImode, h2), operands[2], x2));
1834
1835   p1 = gen_reg_rtx (V2SImode);
1836   p2 = gen_reg_rtx (V2SImode);
1837   p3 = gen_reg_rtx (V2SImode);
1838   p4 = gen_reg_rtx (V2SImode);
1839   emit_insn (gen_pmpy2_r (p1, l1, l2));
1840   emit_insn (gen_pmpy2_l (p2, l1, l2));
1841   emit_insn (gen_pmpy2_r (p3, h1, h2));
1842   emit_insn (gen_pmpy2_l (p4, h1, h2));
1843
1844   s1 = gen_reg_rtx (V2SImode);
1845   s2 = gen_reg_rtx (V2SImode);
1846   s3 = gen_reg_rtx (V2SImode);
1847   emit_insn (gen_addv2si3 (s1, p1, p2));
1848   emit_insn (gen_addv2si3 (s2, p3, p4));
1849   emit_insn (gen_addv2si3 (s3, s1, operands[3]));
1850   emit_insn (gen_addv2si3 (operands[0], s2, s3));
1851 }
1852
1853 /* Emit the appropriate sequence for a call.  */
1854
1855 void
1856 ia64_expand_call (rtx retval, rtx addr, rtx nextarg ATTRIBUTE_UNUSED,
1857                   int sibcall_p)
1858 {
1859   rtx insn, b0;
1860
1861   addr = XEXP (addr, 0);
1862   addr = convert_memory_address (DImode, addr);
1863   b0 = gen_rtx_REG (DImode, R_BR (0));
1864
1865   /* ??? Should do this for functions known to bind local too.  */
1866   if (TARGET_NO_PIC || TARGET_AUTO_PIC)
1867     {
1868       if (sibcall_p)
1869         insn = gen_sibcall_nogp (addr);
1870       else if (! retval)
1871         insn = gen_call_nogp (addr, b0);
1872       else
1873         insn = gen_call_value_nogp (retval, addr, b0);
1874       insn = emit_call_insn (insn);
1875     }
1876   else
1877     {
1878       if (sibcall_p)
1879         insn = gen_sibcall_gp (addr);
1880       else if (! retval)
1881         insn = gen_call_gp (addr, b0);
1882       else
1883         insn = gen_call_value_gp (retval, addr, b0);
1884       insn = emit_call_insn (insn);
1885
1886       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
1887     }
1888
1889   if (sibcall_p)
1890     use_reg (&CALL_INSN_FUNCTION_USAGE (insn), b0);
1891 }
1892
1893 static void
1894 reg_emitted (enum ia64_frame_regs r)
1895 {
1896   if (emitted_frame_related_regs[r] == 0)
1897     emitted_frame_related_regs[r] = current_frame_info.r[r];
1898   else
1899     gcc_assert (emitted_frame_related_regs[r] == current_frame_info.r[r]);
1900 }
1901
1902 static int
1903 get_reg (enum ia64_frame_regs r)
1904 {
1905   reg_emitted (r);
1906   return current_frame_info.r[r];
1907 }
1908
1909 static bool
1910 is_emitted (int regno)
1911 {
1912   enum ia64_frame_regs r;
1913
1914   for (r = reg_fp; r < number_of_ia64_frame_regs; r++)
1915     if (emitted_frame_related_regs[r] == regno)
1916       return true;
1917   return false;
1918 }
1919
1920 void
1921 ia64_reload_gp (void)
1922 {
1923   rtx tmp;
1924
1925   if (current_frame_info.r[reg_save_gp])
1926     {
1927       tmp = gen_rtx_REG (DImode, get_reg (reg_save_gp));
1928     }
1929   else
1930     {
1931       HOST_WIDE_INT offset;
1932       rtx offset_r;
1933
1934       offset = (current_frame_info.spill_cfa_off
1935                 + current_frame_info.spill_size);
1936       if (frame_pointer_needed)
1937         {
1938           tmp = hard_frame_pointer_rtx;
1939           offset = -offset;
1940         }
1941       else
1942         {
1943           tmp = stack_pointer_rtx;
1944           offset = current_frame_info.total_size - offset;
1945         }
1946
1947       offset_r = GEN_INT (offset);
1948       if (satisfies_constraint_I (offset_r))
1949         emit_insn (gen_adddi3 (pic_offset_table_rtx, tmp, offset_r));
1950       else
1951         {
1952           emit_move_insn (pic_offset_table_rtx, offset_r);
1953           emit_insn (gen_adddi3 (pic_offset_table_rtx,
1954                                  pic_offset_table_rtx, tmp));
1955         }
1956
1957       tmp = gen_rtx_MEM (DImode, pic_offset_table_rtx);
1958     }
1959
1960   emit_move_insn (pic_offset_table_rtx, tmp);
1961 }
1962
1963 void
1964 ia64_split_call (rtx retval, rtx addr, rtx retaddr, rtx scratch_r,
1965                  rtx scratch_b, int noreturn_p, int sibcall_p)
1966 {
1967   rtx insn;
1968   bool is_desc = false;
1969
1970   /* If we find we're calling through a register, then we're actually
1971      calling through a descriptor, so load up the values.  */
1972   if (REG_P (addr) && GR_REGNO_P (REGNO (addr)))
1973     {
1974       rtx tmp;
1975       bool addr_dead_p;
1976
1977       /* ??? We are currently constrained to *not* use peep2, because
1978          we can legitimately change the global lifetime of the GP
1979          (in the form of killing where previously live).  This is
1980          because a call through a descriptor doesn't use the previous
1981          value of the GP, while a direct call does, and we do not
1982          commit to either form until the split here.
1983
1984          That said, this means that we lack precise life info for
1985          whether ADDR is dead after this call.  This is not terribly
1986          important, since we can fix things up essentially for free
1987          with the POST_DEC below, but it's nice to not use it when we
1988          can immediately tell it's not necessary.  */
1989       addr_dead_p = ((noreturn_p || sibcall_p
1990                       || TEST_HARD_REG_BIT (regs_invalidated_by_call,
1991                                             REGNO (addr)))
1992                      && !FUNCTION_ARG_REGNO_P (REGNO (addr)));
1993
1994       /* Load the code address into scratch_b.  */
1995       tmp = gen_rtx_POST_INC (Pmode, addr);
1996       tmp = gen_rtx_MEM (Pmode, tmp);
1997       emit_move_insn (scratch_r, tmp);
1998       emit_move_insn (scratch_b, scratch_r);
1999
2000       /* Load the GP address.  If ADDR is not dead here, then we must
2001          revert the change made above via the POST_INCREMENT.  */
2002       if (!addr_dead_p)
2003         tmp = gen_rtx_POST_DEC (Pmode, addr);
2004       else
2005         tmp = addr;
2006       tmp = gen_rtx_MEM (Pmode, tmp);
2007       emit_move_insn (pic_offset_table_rtx, tmp);
2008
2009       is_desc = true;
2010       addr = scratch_b;
2011     }
2012
2013   if (sibcall_p)
2014     insn = gen_sibcall_nogp (addr);
2015   else if (retval)
2016     insn = gen_call_value_nogp (retval, addr, retaddr);
2017   else
2018     insn = gen_call_nogp (addr, retaddr);
2019   emit_call_insn (insn);
2020
2021   if ((!TARGET_CONST_GP || is_desc) && !noreturn_p && !sibcall_p)
2022     ia64_reload_gp ();
2023 }
2024
2025 /* Expand an atomic operation.  We want to perform MEM <CODE>= VAL atomically.
2026
2027    This differs from the generic code in that we know about the zero-extending
2028    properties of cmpxchg, and the zero-extending requirements of ar.ccv.  We
2029    also know that ld.acq+cmpxchg.rel equals a full barrier.
2030
2031    The loop we want to generate looks like
2032
2033         cmp_reg = mem;
2034       label:
2035         old_reg = cmp_reg;
2036         new_reg = cmp_reg op val;
2037         cmp_reg = compare-and-swap(mem, old_reg, new_reg)
2038         if (cmp_reg != old_reg)
2039           goto label;
2040
2041    Note that we only do the plain load from memory once.  Subsequent
2042    iterations use the value loaded by the compare-and-swap pattern.  */
2043
2044 void
2045 ia64_expand_atomic_op (enum rtx_code code, rtx mem, rtx val,
2046                        rtx old_dst, rtx new_dst)
2047 {
2048   enum machine_mode mode = GET_MODE (mem);
2049   rtx old_reg, new_reg, cmp_reg, ar_ccv, label;
2050   enum insn_code icode;
2051
2052   /* Special case for using fetchadd.  */
2053   if ((mode == SImode || mode == DImode)
2054       && (code == PLUS || code == MINUS)
2055       && fetchadd_operand (val, mode))
2056     {
2057       if (code == MINUS)
2058         val = GEN_INT (-INTVAL (val));
2059
2060       if (!old_dst)
2061         old_dst = gen_reg_rtx (mode);
2062
2063       emit_insn (gen_memory_barrier ());
2064
2065       if (mode == SImode)
2066         icode = CODE_FOR_fetchadd_acq_si;
2067       else
2068         icode = CODE_FOR_fetchadd_acq_di;
2069       emit_insn (GEN_FCN (icode) (old_dst, mem, val));
2070
2071       if (new_dst)
2072         {
2073           new_reg = expand_simple_binop (mode, PLUS, old_dst, val, new_dst,
2074                                          true, OPTAB_WIDEN);
2075           if (new_reg != new_dst)
2076             emit_move_insn (new_dst, new_reg);
2077         }
2078       return;
2079     }
2080
2081   /* Because of the volatile mem read, we get an ld.acq, which is the
2082      front half of the full barrier.  The end half is the cmpxchg.rel.  */
2083   gcc_assert (MEM_VOLATILE_P (mem));
2084
2085   old_reg = gen_reg_rtx (DImode);
2086   cmp_reg = gen_reg_rtx (DImode);
2087   label = gen_label_rtx ();
2088
2089   if (mode != DImode)
2090     {
2091       val = simplify_gen_subreg (DImode, val, mode, 0);
2092       emit_insn (gen_extend_insn (cmp_reg, mem, DImode, mode, 1));
2093     }
2094   else
2095     emit_move_insn (cmp_reg, mem);
2096
2097   emit_label (label);
2098
2099   ar_ccv = gen_rtx_REG (DImode, AR_CCV_REGNUM);
2100   emit_move_insn (old_reg, cmp_reg);
2101   emit_move_insn (ar_ccv, cmp_reg);
2102
2103   if (old_dst)
2104     emit_move_insn (old_dst, gen_lowpart (mode, cmp_reg));
2105
2106   new_reg = cmp_reg;
2107   if (code == NOT)
2108     {
2109       new_reg = expand_simple_unop (DImode, NOT, new_reg, NULL_RTX, true);
2110       code = AND;
2111     }
2112   new_reg = expand_simple_binop (DImode, code, new_reg, val, NULL_RTX,
2113                                  true, OPTAB_DIRECT);
2114
2115   if (mode != DImode)
2116     new_reg = gen_lowpart (mode, new_reg);
2117   if (new_dst)
2118     emit_move_insn (new_dst, new_reg);
2119
2120   switch (mode)
2121     {
2122     case QImode:  icode = CODE_FOR_cmpxchg_rel_qi;  break;
2123     case HImode:  icode = CODE_FOR_cmpxchg_rel_hi;  break;
2124     case SImode:  icode = CODE_FOR_cmpxchg_rel_si;  break;
2125     case DImode:  icode = CODE_FOR_cmpxchg_rel_di;  break;
2126     default:
2127       gcc_unreachable ();
2128     }
2129
2130   emit_insn (GEN_FCN (icode) (cmp_reg, mem, ar_ccv, new_reg));
2131
2132   emit_cmp_and_jump_insns (cmp_reg, old_reg, NE, NULL, DImode, true, label);
2133 }
2134 \f
2135 /* Begin the assembly file.  */
2136
2137 static void
2138 ia64_file_start (void)
2139 {
2140   /* Variable tracking should be run after all optimizations which change order
2141      of insns.  It also needs a valid CFG.  This can't be done in
2142      ia64_override_options, because flag_var_tracking is finalized after
2143      that.  */
2144   ia64_flag_var_tracking = flag_var_tracking;
2145   flag_var_tracking = 0;
2146
2147   default_file_start ();
2148   emit_safe_across_calls ();
2149 }
2150
2151 void
2152 emit_safe_across_calls (void)
2153 {
2154   unsigned int rs, re;
2155   int out_state;
2156
2157   rs = 1;
2158   out_state = 0;
2159   while (1)
2160     {
2161       while (rs < 64 && call_used_regs[PR_REG (rs)])
2162         rs++;
2163       if (rs >= 64)
2164         break;
2165       for (re = rs + 1; re < 64 && ! call_used_regs[PR_REG (re)]; re++)
2166         continue;
2167       if (out_state == 0)
2168         {
2169           fputs ("\t.pred.safe_across_calls ", asm_out_file);
2170           out_state = 1;
2171         }
2172       else
2173         fputc (',', asm_out_file);
2174       if (re == rs + 1)
2175         fprintf (asm_out_file, "p%u", rs);
2176       else
2177         fprintf (asm_out_file, "p%u-p%u", rs, re - 1);
2178       rs = re + 1;
2179     }
2180   if (out_state)
2181     fputc ('\n', asm_out_file);
2182 }
2183
2184 /* Globalize a declaration.  */
2185
2186 static void
2187 ia64_globalize_decl_name (FILE * stream, tree decl)
2188 {
2189   const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
2190   tree version_attr = lookup_attribute ("version_id", DECL_ATTRIBUTES (decl));
2191   if (version_attr)
2192     {
2193       tree v = TREE_VALUE (TREE_VALUE (version_attr));
2194       const char *p = TREE_STRING_POINTER (v);
2195       fprintf (stream, "\t.alias %s#, \"%s{%s}\"\n", name, name, p);
2196     }
2197   targetm.asm_out.globalize_label (stream, name);
2198   if (TREE_CODE (decl) == FUNCTION_DECL)
2199     ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "function");
2200 }
2201
2202 /* Helper function for ia64_compute_frame_size: find an appropriate general
2203    register to spill some special register to.  SPECIAL_SPILL_MASK contains
2204    bits in GR0 to GR31 that have already been allocated by this routine.
2205    TRY_LOCALS is true if we should attempt to locate a local regnum.  */
2206
2207 static int
2208 find_gr_spill (enum ia64_frame_regs r, int try_locals)
2209 {
2210   int regno;
2211
2212   if (emitted_frame_related_regs[r] != 0)
2213     {
2214       regno = emitted_frame_related_regs[r];
2215       if (regno >= LOC_REG (0) && regno < LOC_REG (80 - frame_pointer_needed)
2216           && current_frame_info.n_local_regs < regno - LOC_REG (0) + 1)
2217         current_frame_info.n_local_regs = regno - LOC_REG (0) + 1;
2218       else if (current_function_is_leaf 
2219                && regno >= GR_REG (1) && regno <= GR_REG (31))
2220         current_frame_info.gr_used_mask |= 1 << regno;
2221
2222       return regno;
2223     }
2224
2225   /* If this is a leaf function, first try an otherwise unused
2226      call-clobbered register.  */
2227   if (current_function_is_leaf)
2228     {
2229       for (regno = GR_REG (1); regno <= GR_REG (31); regno++)
2230         if (! df_regs_ever_live_p (regno)
2231             && call_used_regs[regno]
2232             && ! fixed_regs[regno]
2233             && ! global_regs[regno]
2234             && ((current_frame_info.gr_used_mask >> regno) & 1) == 0
2235             && ! is_emitted (regno))
2236           {
2237             current_frame_info.gr_used_mask |= 1 << regno;
2238             return regno;
2239           }
2240     }
2241
2242   if (try_locals)
2243     {
2244       regno = current_frame_info.n_local_regs;
2245       /* If there is a frame pointer, then we can't use loc79, because
2246          that is HARD_FRAME_POINTER_REGNUM.  In particular, see the
2247          reg_name switching code in ia64_expand_prologue.  */
2248       while (regno < (80 - frame_pointer_needed))
2249         if (! is_emitted (LOC_REG (regno++)))
2250           {
2251             current_frame_info.n_local_regs = regno;
2252             return LOC_REG (regno - 1);
2253           }
2254     }
2255
2256   /* Failed to find a general register to spill to.  Must use stack.  */
2257   return 0;
2258 }
2259
2260 /* In order to make for nice schedules, we try to allocate every temporary
2261    to a different register.  We must of course stay away from call-saved,
2262    fixed, and global registers.  We must also stay away from registers
2263    allocated in current_frame_info.gr_used_mask, since those include regs
2264    used all through the prologue.
2265
2266    Any register allocated here must be used immediately.  The idea is to
2267    aid scheduling, not to solve data flow problems.  */
2268
2269 static int last_scratch_gr_reg;
2270
2271 static int
2272 next_scratch_gr_reg (void)
2273 {
2274   int i, regno;
2275
2276   for (i = 0; i < 32; ++i)
2277     {
2278       regno = (last_scratch_gr_reg + i + 1) & 31;
2279       if (call_used_regs[regno]
2280           && ! fixed_regs[regno]
2281           && ! global_regs[regno]
2282           && ((current_frame_info.gr_used_mask >> regno) & 1) == 0)
2283         {
2284           last_scratch_gr_reg = regno;
2285           return regno;
2286         }
2287     }
2288
2289   /* There must be _something_ available.  */
2290   gcc_unreachable ();
2291 }
2292
2293 /* Helper function for ia64_compute_frame_size, called through
2294    diddle_return_value.  Mark REG in current_frame_info.gr_used_mask.  */
2295
2296 static void
2297 mark_reg_gr_used_mask (rtx reg, void *data ATTRIBUTE_UNUSED)
2298 {
2299   unsigned int regno = REGNO (reg);
2300   if (regno < 32)
2301     {
2302       unsigned int i, n = hard_regno_nregs[regno][GET_MODE (reg)];
2303       for (i = 0; i < n; ++i)
2304         current_frame_info.gr_used_mask |= 1 << (regno + i);
2305     }
2306 }
2307
2308
2309 /* Returns the number of bytes offset between the frame pointer and the stack
2310    pointer for the current function.  SIZE is the number of bytes of space
2311    needed for local variables.  */
2312
2313 static void
2314 ia64_compute_frame_size (HOST_WIDE_INT size)
2315 {
2316   HOST_WIDE_INT total_size;
2317   HOST_WIDE_INT spill_size = 0;
2318   HOST_WIDE_INT extra_spill_size = 0;
2319   HOST_WIDE_INT pretend_args_size;
2320   HARD_REG_SET mask;
2321   int n_spilled = 0;
2322   int spilled_gr_p = 0;
2323   int spilled_fr_p = 0;
2324   unsigned int regno;
2325   int min_regno;
2326   int max_regno;
2327   int i;
2328
2329   if (current_frame_info.initialized)
2330     return;
2331
2332   memset (&current_frame_info, 0, sizeof current_frame_info);
2333   CLEAR_HARD_REG_SET (mask);
2334
2335   /* Don't allocate scratches to the return register.  */
2336   diddle_return_value (mark_reg_gr_used_mask, NULL);
2337
2338   /* Don't allocate scratches to the EH scratch registers.  */
2339   if (cfun->machine->ia64_eh_epilogue_sp)
2340     mark_reg_gr_used_mask (cfun->machine->ia64_eh_epilogue_sp, NULL);
2341   if (cfun->machine->ia64_eh_epilogue_bsp)
2342     mark_reg_gr_used_mask (cfun->machine->ia64_eh_epilogue_bsp, NULL);
2343
2344   /* Find the size of the register stack frame.  We have only 80 local
2345      registers, because we reserve 8 for the inputs and 8 for the
2346      outputs.  */
2347
2348   /* Skip HARD_FRAME_POINTER_REGNUM (loc79) when frame_pointer_needed,
2349      since we'll be adjusting that down later.  */
2350   regno = LOC_REG (78) + ! frame_pointer_needed;
2351   for (; regno >= LOC_REG (0); regno--)
2352     if (df_regs_ever_live_p (regno) && !is_emitted (regno))
2353       break;
2354   current_frame_info.n_local_regs = regno - LOC_REG (0) + 1;
2355
2356   /* For functions marked with the syscall_linkage attribute, we must mark
2357      all eight input registers as in use, so that locals aren't visible to
2358      the caller.  */
2359
2360   if (cfun->machine->n_varargs > 0
2361       || lookup_attribute ("syscall_linkage",
2362                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2363     current_frame_info.n_input_regs = 8;
2364   else
2365     {
2366       for (regno = IN_REG (7); regno >= IN_REG (0); regno--)
2367         if (df_regs_ever_live_p (regno))
2368           break;
2369       current_frame_info.n_input_regs = regno - IN_REG (0) + 1;
2370     }
2371
2372   for (regno = OUT_REG (7); regno >= OUT_REG (0); regno--)
2373     if (df_regs_ever_live_p (regno))
2374       break;
2375   i = regno - OUT_REG (0) + 1;
2376
2377 #ifndef PROFILE_HOOK
2378   /* When -p profiling, we need one output register for the mcount argument.
2379      Likewise for -a profiling for the bb_init_func argument.  For -ax
2380      profiling, we need two output registers for the two bb_init_trace_func
2381      arguments.  */
2382   if (current_function_profile)
2383     i = MAX (i, 1);
2384 #endif
2385   current_frame_info.n_output_regs = i;
2386
2387   /* ??? No rotating register support yet.  */
2388   current_frame_info.n_rotate_regs = 0;
2389
2390   /* Discover which registers need spilling, and how much room that
2391      will take.  Begin with floating point and general registers,
2392      which will always wind up on the stack.  */
2393
2394   for (regno = FR_REG (2); regno <= FR_REG (127); regno++)
2395     if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2396       {
2397         SET_HARD_REG_BIT (mask, regno);
2398         spill_size += 16;
2399         n_spilled += 1;
2400         spilled_fr_p = 1;
2401       }
2402
2403   for (regno = GR_REG (1); regno <= GR_REG (31); regno++)
2404     if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2405       {
2406         SET_HARD_REG_BIT (mask, regno);
2407         spill_size += 8;
2408         n_spilled += 1;
2409         spilled_gr_p = 1;
2410       }
2411
2412   for (regno = BR_REG (1); regno <= BR_REG (7); regno++)
2413     if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2414       {
2415         SET_HARD_REG_BIT (mask, regno);
2416         spill_size += 8;
2417         n_spilled += 1;
2418       }
2419
2420   /* Now come all special registers that might get saved in other
2421      general registers.  */
2422
2423   if (frame_pointer_needed)
2424     {
2425       current_frame_info.r[reg_fp] = find_gr_spill (reg_fp, 1);
2426       /* If we did not get a register, then we take LOC79.  This is guaranteed
2427          to be free, even if regs_ever_live is already set, because this is
2428          HARD_FRAME_POINTER_REGNUM.  This requires incrementing n_local_regs,
2429          as we don't count loc79 above.  */
2430       if (current_frame_info.r[reg_fp] == 0)
2431         {
2432           current_frame_info.r[reg_fp] = LOC_REG (79);
2433           current_frame_info.n_local_regs = LOC_REG (79) - LOC_REG (0) + 1;
2434         }
2435     }
2436
2437   if (! current_function_is_leaf)
2438     {
2439       /* Emit a save of BR0 if we call other functions.  Do this even
2440          if this function doesn't return, as EH depends on this to be
2441          able to unwind the stack.  */
2442       SET_HARD_REG_BIT (mask, BR_REG (0));
2443
2444       current_frame_info.r[reg_save_b0] = find_gr_spill (reg_save_b0, 1);
2445       if (current_frame_info.r[reg_save_b0] == 0)
2446         {
2447           extra_spill_size += 8;
2448           n_spilled += 1;
2449         }
2450
2451       /* Similarly for ar.pfs.  */
2452       SET_HARD_REG_BIT (mask, AR_PFS_REGNUM);
2453       current_frame_info.r[reg_save_ar_pfs] = find_gr_spill (reg_save_ar_pfs, 1);
2454       if (current_frame_info.r[reg_save_ar_pfs] == 0)
2455         {
2456           extra_spill_size += 8;
2457           n_spilled += 1;
2458         }
2459
2460       /* Similarly for gp.  Note that if we're calling setjmp, the stacked
2461          registers are clobbered, so we fall back to the stack.  */
2462       current_frame_info.r[reg_save_gp]
2463         = (current_function_calls_setjmp ? 0 : find_gr_spill (reg_save_gp, 1));
2464       if (current_frame_info.r[reg_save_gp] == 0)
2465         {
2466           SET_HARD_REG_BIT (mask, GR_REG (1));
2467           spill_size += 8;
2468           n_spilled += 1;
2469         }
2470     }
2471   else
2472     {
2473       if (df_regs_ever_live_p (BR_REG (0)) && ! call_used_regs[BR_REG (0)])
2474         {
2475           SET_HARD_REG_BIT (mask, BR_REG (0));
2476           extra_spill_size += 8;
2477           n_spilled += 1;
2478         }
2479
2480       if (df_regs_ever_live_p (AR_PFS_REGNUM))
2481         {
2482           SET_HARD_REG_BIT (mask, AR_PFS_REGNUM);
2483           current_frame_info.r[reg_save_ar_pfs] 
2484             = find_gr_spill (reg_save_ar_pfs, 1);
2485           if (current_frame_info.r[reg_save_ar_pfs] == 0)
2486             {
2487               extra_spill_size += 8;
2488               n_spilled += 1;
2489             }
2490         }
2491     }
2492
2493   /* Unwind descriptor hackery: things are most efficient if we allocate
2494      consecutive GR save registers for RP, PFS, FP in that order. However,
2495      it is absolutely critical that FP get the only hard register that's
2496      guaranteed to be free, so we allocated it first.  If all three did
2497      happen to be allocated hard regs, and are consecutive, rearrange them
2498      into the preferred order now.  
2499      
2500      If we have already emitted code for any of those registers,
2501      then it's already too late to change.  */
2502   min_regno = MIN (current_frame_info.r[reg_fp],
2503                    MIN (current_frame_info.r[reg_save_b0],
2504                         current_frame_info.r[reg_save_ar_pfs]));
2505   max_regno = MAX (current_frame_info.r[reg_fp],
2506                    MAX (current_frame_info.r[reg_save_b0],
2507                         current_frame_info.r[reg_save_ar_pfs]));
2508   if (min_regno > 0
2509       && min_regno + 2 == max_regno
2510       && (current_frame_info.r[reg_fp] == min_regno + 1
2511           || current_frame_info.r[reg_save_b0] == min_regno + 1
2512           || current_frame_info.r[reg_save_ar_pfs] == min_regno + 1)
2513       && (emitted_frame_related_regs[reg_save_b0] == 0
2514           || emitted_frame_related_regs[reg_save_b0] == min_regno)
2515       && (emitted_frame_related_regs[reg_save_ar_pfs] == 0
2516           || emitted_frame_related_regs[reg_save_ar_pfs] == min_regno + 1)
2517       && (emitted_frame_related_regs[reg_fp] == 0
2518           || emitted_frame_related_regs[reg_fp] == min_regno + 2))
2519     {
2520       current_frame_info.r[reg_save_b0] = min_regno;
2521       current_frame_info.r[reg_save_ar_pfs] = min_regno + 1;
2522       current_frame_info.r[reg_fp] = min_regno + 2;
2523     }
2524
2525   /* See if we need to store the predicate register block.  */
2526   for (regno = PR_REG (0); regno <= PR_REG (63); regno++)
2527     if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2528       break;
2529   if (regno <= PR_REG (63))
2530     {
2531       SET_HARD_REG_BIT (mask, PR_REG (0));
2532       current_frame_info.r[reg_save_pr] = find_gr_spill (reg_save_pr, 1);
2533       if (current_frame_info.r[reg_save_pr] == 0)
2534         {
2535           extra_spill_size += 8;
2536           n_spilled += 1;
2537         }
2538
2539       /* ??? Mark them all as used so that register renaming and such
2540          are free to use them.  */
2541       for (regno = PR_REG (0); regno <= PR_REG (63); regno++)
2542         df_set_regs_ever_live (regno, true);
2543     }
2544
2545   /* If we're forced to use st8.spill, we're forced to save and restore
2546      ar.unat as well.  The check for existing liveness allows inline asm
2547      to touch ar.unat.  */
2548   if (spilled_gr_p || cfun->machine->n_varargs
2549       || df_regs_ever_live_p (AR_UNAT_REGNUM))
2550     {
2551       df_set_regs_ever_live (AR_UNAT_REGNUM, true);
2552       SET_HARD_REG_BIT (mask, AR_UNAT_REGNUM);
2553       current_frame_info.r[reg_save_ar_unat] 
2554         = find_gr_spill (reg_save_ar_unat, spill_size == 0);
2555       if (current_frame_info.r[reg_save_ar_unat] == 0)
2556         {
2557           extra_spill_size += 8;
2558           n_spilled += 1;
2559         }
2560     }
2561
2562   if (df_regs_ever_live_p (AR_LC_REGNUM))
2563     {
2564       SET_HARD_REG_BIT (mask, AR_LC_REGNUM);
2565       current_frame_info.r[reg_save_ar_lc] 
2566         = find_gr_spill (reg_save_ar_lc, spill_size == 0);
2567       if (current_frame_info.r[reg_save_ar_lc] == 0)
2568         {
2569           extra_spill_size += 8;
2570           n_spilled += 1;
2571         }
2572     }
2573
2574   /* If we have an odd number of words of pretend arguments written to
2575      the stack, then the FR save area will be unaligned.  We round the
2576      size of this area up to keep things 16 byte aligned.  */
2577   if (spilled_fr_p)
2578     pretend_args_size = IA64_STACK_ALIGN (current_function_pretend_args_size);
2579   else
2580     pretend_args_size = current_function_pretend_args_size;
2581
2582   total_size = (spill_size + extra_spill_size + size + pretend_args_size
2583                 + current_function_outgoing_args_size);
2584   total_size = IA64_STACK_ALIGN (total_size);
2585
2586   /* We always use the 16-byte scratch area provided by the caller, but
2587      if we are a leaf function, there's no one to which we need to provide
2588      a scratch area.  */
2589   if (current_function_is_leaf)
2590     total_size = MAX (0, total_size - 16);
2591
2592   current_frame_info.total_size = total_size;
2593   current_frame_info.spill_cfa_off = pretend_args_size - 16;
2594   current_frame_info.spill_size = spill_size;
2595   current_frame_info.extra_spill_size = extra_spill_size;
2596   COPY_HARD_REG_SET (current_frame_info.mask, mask);
2597   current_frame_info.n_spilled = n_spilled;
2598   current_frame_info.initialized = reload_completed;
2599 }
2600
2601 /* Compute the initial difference between the specified pair of registers.  */
2602
2603 HOST_WIDE_INT
2604 ia64_initial_elimination_offset (int from, int to)
2605 {
2606   HOST_WIDE_INT offset;
2607
2608   ia64_compute_frame_size (get_frame_size ());
2609   switch (from)
2610     {
2611     case FRAME_POINTER_REGNUM:
2612       switch (to)
2613         {
2614         case HARD_FRAME_POINTER_REGNUM:
2615           if (current_function_is_leaf)
2616             offset = -current_frame_info.total_size;
2617           else
2618             offset = -(current_frame_info.total_size
2619                        - current_function_outgoing_args_size - 16);
2620           break;
2621
2622         case STACK_POINTER_REGNUM:
2623           if (current_function_is_leaf)
2624             offset = 0;
2625           else
2626             offset = 16 + current_function_outgoing_args_size;
2627           break;
2628
2629         default:
2630           gcc_unreachable ();
2631         }
2632       break;
2633
2634     case ARG_POINTER_REGNUM:
2635       /* Arguments start above the 16 byte save area, unless stdarg
2636          in which case we store through the 16 byte save area.  */
2637       switch (to)
2638         {
2639         case HARD_FRAME_POINTER_REGNUM:
2640           offset = 16 - current_function_pretend_args_size;
2641           break;
2642
2643         case STACK_POINTER_REGNUM:
2644           offset = (current_frame_info.total_size
2645                     + 16 - current_function_pretend_args_size);
2646           break;
2647
2648         default:
2649           gcc_unreachable ();
2650         }
2651       break;
2652
2653     default:
2654       gcc_unreachable ();
2655     }
2656
2657   return offset;
2658 }
2659
2660 /* If there are more than a trivial number of register spills, we use
2661    two interleaved iterators so that we can get two memory references
2662    per insn group.
2663
2664    In order to simplify things in the prologue and epilogue expanders,
2665    we use helper functions to fix up the memory references after the
2666    fact with the appropriate offsets to a POST_MODIFY memory mode.
2667    The following data structure tracks the state of the two iterators
2668    while insns are being emitted.  */
2669
2670 struct spill_fill_data
2671 {
2672   rtx init_after;               /* point at which to emit initializations */
2673   rtx init_reg[2];              /* initial base register */
2674   rtx iter_reg[2];              /* the iterator registers */
2675   rtx *prev_addr[2];            /* address of last memory use */
2676   rtx prev_insn[2];             /* the insn corresponding to prev_addr */
2677   HOST_WIDE_INT prev_off[2];    /* last offset */
2678   int n_iter;                   /* number of iterators in use */
2679   int next_iter;                /* next iterator to use */
2680   unsigned int save_gr_used_mask;
2681 };
2682
2683 static struct spill_fill_data spill_fill_data;
2684
2685 static void
2686 setup_spill_pointers (int n_spills, rtx init_reg, HOST_WIDE_INT cfa_off)
2687 {
2688   int i;
2689
2690   spill_fill_data.init_after = get_last_insn ();
2691   spill_fill_data.init_reg[0] = init_reg;
2692   spill_fill_data.init_reg[1] = init_reg;
2693   spill_fill_data.prev_addr[0] = NULL;
2694   spill_fill_data.prev_addr[1] = NULL;
2695   spill_fill_data.prev_insn[0] = NULL;
2696   spill_fill_data.prev_insn[1] = NULL;
2697   spill_fill_data.prev_off[0] = cfa_off;
2698   spill_fill_data.prev_off[1] = cfa_off;
2699   spill_fill_data.next_iter = 0;
2700   spill_fill_data.save_gr_used_mask = current_frame_info.gr_used_mask;
2701
2702   spill_fill_data.n_iter = 1 + (n_spills > 2);
2703   for (i = 0; i < spill_fill_data.n_iter; ++i)
2704     {
2705       int regno = next_scratch_gr_reg ();
2706       spill_fill_data.iter_reg[i] = gen_rtx_REG (DImode, regno);
2707       current_frame_info.gr_used_mask |= 1 << regno;
2708     }
2709 }
2710
2711 static void
2712 finish_spill_pointers (void)
2713 {
2714   current_frame_info.gr_used_mask = spill_fill_data.save_gr_used_mask;
2715 }
2716
2717 static rtx
2718 spill_restore_mem (rtx reg, HOST_WIDE_INT cfa_off)
2719 {
2720   int iter = spill_fill_data.next_iter;
2721   HOST_WIDE_INT disp = spill_fill_data.prev_off[iter] - cfa_off;
2722   rtx disp_rtx = GEN_INT (disp);
2723   rtx mem;
2724
2725   if (spill_fill_data.prev_addr[iter])
2726     {
2727       if (satisfies_constraint_N (disp_rtx))
2728         {
2729           *spill_fill_data.prev_addr[iter]
2730             = gen_rtx_POST_MODIFY (DImode, spill_fill_data.iter_reg[iter],
2731                                    gen_rtx_PLUS (DImode,
2732                                                  spill_fill_data.iter_reg[iter],
2733                                                  disp_rtx));
2734           REG_NOTES (spill_fill_data.prev_insn[iter])
2735             = gen_rtx_EXPR_LIST (REG_INC, spill_fill_data.iter_reg[iter],
2736                                  REG_NOTES (spill_fill_data.prev_insn[iter]));
2737         }
2738       else
2739         {
2740           /* ??? Could use register post_modify for loads.  */
2741           if (!satisfies_constraint_I (disp_rtx))
2742             {
2743               rtx tmp = gen_rtx_REG (DImode, next_scratch_gr_reg ());
2744               emit_move_insn (tmp, disp_rtx);
2745               disp_rtx = tmp;
2746             }
2747           emit_insn (gen_adddi3 (spill_fill_data.iter_reg[iter],
2748                                  spill_fill_data.iter_reg[iter], disp_rtx));
2749         }
2750     }
2751   /* Micro-optimization: if we've created a frame pointer, it's at
2752      CFA 0, which may allow the real iterator to be initialized lower,
2753      slightly increasing parallelism.  Also, if there are few saves
2754      it may eliminate the iterator entirely.  */
2755   else if (disp == 0
2756            && spill_fill_data.init_reg[iter] == stack_pointer_rtx
2757            && frame_pointer_needed)
2758     {
2759       mem = gen_rtx_MEM (GET_MODE (reg), hard_frame_pointer_rtx);
2760       set_mem_alias_set (mem, get_varargs_alias_set ());
2761       return mem;
2762     }
2763   else
2764     {
2765       rtx seq, insn;
2766
2767       if (disp == 0)
2768         seq = gen_movdi (spill_fill_data.iter_reg[iter],
2769                          spill_fill_data.init_reg[iter]);
2770       else
2771         {
2772           start_sequence ();
2773
2774           if (!satisfies_constraint_I (disp_rtx))
2775             {
2776               rtx tmp = gen_rtx_REG (DImode, next_scratch_gr_reg ());
2777               emit_move_insn (tmp, disp_rtx);
2778               disp_rtx = tmp;
2779             }
2780
2781           emit_insn (gen_adddi3 (spill_fill_data.iter_reg[iter],
2782                                  spill_fill_data.init_reg[iter],
2783                                  disp_rtx));
2784
2785           seq = get_insns ();
2786           end_sequence ();
2787         }
2788
2789       /* Careful for being the first insn in a sequence.  */
2790       if (spill_fill_data.init_after)
2791         insn = emit_insn_after (seq, spill_fill_data.init_after);
2792       else
2793         {
2794           rtx first = get_insns ();
2795           if (first)
2796             insn = emit_insn_before (seq, first);
2797           else
2798             insn = emit_insn (seq);
2799         }
2800       spill_fill_data.init_after = insn;
2801     }
2802
2803   mem = gen_rtx_MEM (GET_MODE (reg), spill_fill_data.iter_reg[iter]);
2804
2805   /* ??? Not all of the spills are for varargs, but some of them are.
2806      The rest of the spills belong in an alias set of their own.  But
2807      it doesn't actually hurt to include them here.  */
2808   set_mem_alias_set (mem, get_varargs_alias_set ());
2809
2810   spill_fill_data.prev_addr[iter] = &XEXP (mem, 0);
2811   spill_fill_data.prev_off[iter] = cfa_off;
2812
2813   if (++iter >= spill_fill_data.n_iter)
2814     iter = 0;
2815   spill_fill_data.next_iter = iter;
2816
2817   return mem;
2818 }
2819
2820 static void
2821 do_spill (rtx (*move_fn) (rtx, rtx, rtx), rtx reg, HOST_WIDE_INT cfa_off,
2822           rtx frame_reg)
2823 {
2824   int iter = spill_fill_data.next_iter;
2825   rtx mem, insn;
2826
2827   mem = spill_restore_mem (reg, cfa_off);
2828   insn = emit_insn ((*move_fn) (mem, reg, GEN_INT (cfa_off)));
2829   spill_fill_data.prev_insn[iter] = insn;
2830
2831   if (frame_reg)
2832     {
2833       rtx base;
2834       HOST_WIDE_INT off;
2835
2836       RTX_FRAME_RELATED_P (insn) = 1;
2837
2838       /* Don't even pretend that the unwind code can intuit its way
2839          through a pair of interleaved post_modify iterators.  Just
2840          provide the correct answer.  */
2841
2842       if (frame_pointer_needed)
2843         {
2844           base = hard_frame_pointer_rtx;
2845           off = - cfa_off;
2846         }
2847       else
2848         {
2849           base = stack_pointer_rtx;
2850           off = current_frame_info.total_size - cfa_off;
2851         }
2852
2853       REG_NOTES (insn)
2854         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2855                 gen_rtx_SET (VOIDmode,
2856                              gen_rtx_MEM (GET_MODE (reg),
2857                                           plus_constant (base, off)),
2858                              frame_reg),
2859                 REG_NOTES (insn));
2860     }
2861 }
2862
2863 static void
2864 do_restore (rtx (*move_fn) (rtx, rtx, rtx), rtx reg, HOST_WIDE_INT cfa_off)
2865 {
2866   int iter = spill_fill_data.next_iter;
2867   rtx insn;
2868
2869   insn = emit_insn ((*move_fn) (reg, spill_restore_mem (reg, cfa_off),
2870                                 GEN_INT (cfa_off)));
2871   spill_fill_data.prev_insn[iter] = insn;
2872 }
2873
2874 /* Wrapper functions that discards the CONST_INT spill offset.  These
2875    exist so that we can give gr_spill/gr_fill the offset they need and
2876    use a consistent function interface.  */
2877
2878 static rtx
2879 gen_movdi_x (rtx dest, rtx src, rtx offset ATTRIBUTE_UNUSED)
2880 {
2881   return gen_movdi (dest, src);
2882 }
2883
2884 static rtx
2885 gen_fr_spill_x (rtx dest, rtx src, rtx offset ATTRIBUTE_UNUSED)
2886 {
2887   return gen_fr_spill (dest, src);
2888 }
2889
2890 static rtx
2891 gen_fr_restore_x (rtx dest, rtx src, rtx offset ATTRIBUTE_UNUSED)
2892 {
2893   return gen_fr_restore (dest, src);
2894 }
2895
2896 /* Called after register allocation to add any instructions needed for the
2897    prologue.  Using a prologue insn is favored compared to putting all of the
2898    instructions in output_function_prologue(), since it allows the scheduler
2899    to intermix instructions with the saves of the caller saved registers.  In
2900    some cases, it might be necessary to emit a barrier instruction as the last
2901    insn to prevent such scheduling.
2902
2903    Also any insns generated here should have RTX_FRAME_RELATED_P(insn) = 1
2904    so that the debug info generation code can handle them properly.
2905
2906    The register save area is layed out like so:
2907    cfa+16
2908         [ varargs spill area ]
2909         [ fr register spill area ]
2910         [ br register spill area ]
2911         [ ar register spill area ]
2912         [ pr register spill area ]
2913         [ gr register spill area ] */
2914
2915 /* ??? Get inefficient code when the frame size is larger than can fit in an
2916    adds instruction.  */
2917
2918 void
2919 ia64_expand_prologue (void)
2920 {
2921   rtx insn, ar_pfs_save_reg, ar_unat_save_reg;
2922   int i, epilogue_p, regno, alt_regno, cfa_off, n_varargs;
2923   rtx reg, alt_reg;
2924
2925   ia64_compute_frame_size (get_frame_size ());
2926   last_scratch_gr_reg = 15;
2927
2928   if (dump_file) 
2929     {
2930       fprintf (dump_file, "ia64 frame related registers "
2931                "recorded in current_frame_info.r[]:\n");
2932 #define PRINTREG(a) if (current_frame_info.r[a]) \
2933         fprintf(dump_file, "%s = %d\n", #a, current_frame_info.r[a])
2934       PRINTREG(reg_fp);
2935       PRINTREG(reg_save_b0);
2936       PRINTREG(reg_save_pr);
2937       PRINTREG(reg_save_ar_pfs);
2938       PRINTREG(reg_save_ar_unat);
2939       PRINTREG(reg_save_ar_lc);
2940       PRINTREG(reg_save_gp);
2941 #undef PRINTREG
2942     }
2943
2944   /* If there is no epilogue, then we don't need some prologue insns.
2945      We need to avoid emitting the dead prologue insns, because flow
2946      will complain about them.  */
2947   if (optimize)
2948     {
2949       edge e;
2950       edge_iterator ei;
2951
2952       FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds)
2953         if ((e->flags & EDGE_FAKE) == 0
2954             && (e->flags & EDGE_FALLTHRU) != 0)
2955           break;
2956       epilogue_p = (e != NULL);
2957     }
2958   else
2959     epilogue_p = 1;
2960
2961   /* Set the local, input, and output register names.  We need to do this
2962      for GNU libc, which creates crti.S/crtn.S by splitting initfini.c in
2963      half.  If we use in/loc/out register names, then we get assembler errors
2964      in crtn.S because there is no alloc insn or regstk directive in there.  */
2965   if (! TARGET_REG_NAMES)
2966     {
2967       int inputs = current_frame_info.n_input_regs;
2968       int locals = current_frame_info.n_local_regs;
2969       int outputs = current_frame_info.n_output_regs;
2970
2971       for (i = 0; i < inputs; i++)
2972         reg_names[IN_REG (i)] = ia64_reg_numbers[i];
2973       for (i = 0; i < locals; i++)
2974         reg_names[LOC_REG (i)] = ia64_reg_numbers[inputs + i];
2975       for (i = 0; i < outputs; i++)
2976         reg_names[OUT_REG (i)] = ia64_reg_numbers[inputs + locals + i];
2977     }
2978
2979   /* Set the frame pointer register name.  The regnum is logically loc79,
2980      but of course we'll not have allocated that many locals.  Rather than
2981      worrying about renumbering the existing rtxs, we adjust the name.  */
2982   /* ??? This code means that we can never use one local register when
2983      there is a frame pointer.  loc79 gets wasted in this case, as it is
2984      renamed to a register that will never be used.  See also the try_locals
2985      code in find_gr_spill.  */
2986   if (current_frame_info.r[reg_fp])
2987     {
2988       const char *tmp = reg_names[HARD_FRAME_POINTER_REGNUM];
2989       reg_names[HARD_FRAME_POINTER_REGNUM]
2990         = reg_names[current_frame_info.r[reg_fp]];
2991       reg_names[current_frame_info.r[reg_fp]] = tmp;
2992     }
2993
2994   /* We don't need an alloc instruction if we've used no outputs or locals.  */
2995   if (current_frame_info.n_local_regs == 0
2996       && current_frame_info.n_output_regs == 0
2997       && current_frame_info.n_input_regs <= current_function_args_info.int_regs
2998       && !TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM))
2999     {
3000       /* If there is no alloc, but there are input registers used, then we
3001          need a .regstk directive.  */
3002       current_frame_info.need_regstk = (TARGET_REG_NAMES != 0);
3003       ar_pfs_save_reg = NULL_RTX;
3004     }
3005   else
3006     {
3007       current_frame_info.need_regstk = 0;
3008
3009       if (current_frame_info.r[reg_save_ar_pfs])
3010         {
3011           regno = current_frame_info.r[reg_save_ar_pfs];
3012           reg_emitted (reg_save_ar_pfs);
3013         }
3014       else
3015         regno = next_scratch_gr_reg ();
3016       ar_pfs_save_reg = gen_rtx_REG (DImode, regno);
3017
3018       insn = emit_insn (gen_alloc (ar_pfs_save_reg,
3019                                    GEN_INT (current_frame_info.n_input_regs),
3020                                    GEN_INT (current_frame_info.n_local_regs),
3021                                    GEN_INT (current_frame_info.n_output_regs),
3022                                    GEN_INT (current_frame_info.n_rotate_regs)));
3023       RTX_FRAME_RELATED_P (insn) = (current_frame_info.r[reg_save_ar_pfs] != 0);
3024     }
3025
3026   /* Set up frame pointer, stack pointer, and spill iterators.  */
3027
3028   n_varargs = cfun->machine->n_varargs;
3029   setup_spill_pointers (current_frame_info.n_spilled + n_varargs,
3030                         stack_pointer_rtx, 0);
3031
3032   if (frame_pointer_needed)
3033     {
3034       insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
3035       RTX_FRAME_RELATED_P (insn) = 1;
3036     }
3037
3038   if (current_frame_info.total_size != 0)
3039     {
3040       rtx frame_size_rtx = GEN_INT (- current_frame_info.total_size);
3041       rtx offset;
3042
3043       if (satisfies_constraint_I (frame_size_rtx))
3044         offset = frame_size_rtx;
3045       else
3046         {
3047           regno = next_scratch_gr_reg ();
3048           offset = gen_rtx_REG (DImode, regno);
3049           emit_move_insn (offset, frame_size_rtx);
3050         }
3051
3052       insn = emit_insn (gen_adddi3 (stack_pointer_rtx,
3053                                     stack_pointer_rtx, offset));
3054
3055       if (! frame_pointer_needed)
3056         {
3057           RTX_FRAME_RELATED_P (insn) = 1;
3058           if (GET_CODE (offset) != CONST_INT)
3059             {
3060               REG_NOTES (insn)
3061                 = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3062                         gen_rtx_SET (VOIDmode,
3063                                      stack_pointer_rtx,
3064                                      gen_rtx_PLUS (DImode,
3065                                                    stack_pointer_rtx,
3066                                                    frame_size_rtx)),
3067                         REG_NOTES (insn));
3068             }
3069         }
3070
3071       /* ??? At this point we must generate a magic insn that appears to
3072          modify the stack pointer, the frame pointer, and all spill
3073          iterators.  This would allow the most scheduling freedom.  For
3074          now, just hard stop.  */
3075       emit_insn (gen_blockage ());
3076     }
3077
3078   /* Must copy out ar.unat before doing any integer spills.  */
3079   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
3080     {
3081       if (current_frame_info.r[reg_save_ar_unat])
3082         {
3083           ar_unat_save_reg
3084             = gen_rtx_REG (DImode, current_frame_info.r[reg_save_ar_unat]);
3085           reg_emitted (reg_save_ar_unat);
3086         }
3087       else
3088         {
3089           alt_regno = next_scratch_gr_reg ();
3090           ar_unat_save_reg = gen_rtx_REG (DImode, alt_regno);
3091           current_frame_info.gr_used_mask |= 1 << alt_regno;
3092         }
3093
3094       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
3095       insn = emit_move_insn (ar_unat_save_reg, reg);
3096       RTX_FRAME_RELATED_P (insn) = (current_frame_info.r[reg_save_ar_unat] != 0);
3097
3098       /* Even if we're not going to generate an epilogue, we still
3099          need to save the register so that EH works.  */
3100       if (! epilogue_p && current_frame_info.r[reg_save_ar_unat])
3101         emit_insn (gen_prologue_use (ar_unat_save_reg));
3102     }
3103   else
3104     ar_unat_save_reg = NULL_RTX;
3105
3106   /* Spill all varargs registers.  Do this before spilling any GR registers,
3107      since we want the UNAT bits for the GR registers to override the UNAT
3108      bits from varargs, which we don't care about.  */
3109
3110   cfa_off = -16;
3111   for (regno = GR_ARG_FIRST + 7; n_varargs > 0; --n_varargs, --regno)
3112     {
3113       reg = gen_rtx_REG (DImode, regno);
3114       do_spill (gen_gr_spill, reg, cfa_off += 8, NULL_RTX);
3115     }
3116
3117   /* Locate the bottom of the register save area.  */
3118   cfa_off = (current_frame_info.spill_cfa_off
3119              + current_frame_info.spill_size
3120              + current_frame_info.extra_spill_size);
3121
3122   /* Save the predicate register block either in a register or in memory.  */
3123   if (TEST_HARD_REG_BIT (current_frame_info.mask, PR_REG (0)))
3124     {
3125       reg = gen_rtx_REG (DImode, PR_REG (0));
3126       if (current_frame_info.r[reg_save_pr] != 0)
3127         {
3128           alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_pr]);
3129           reg_emitted (reg_save_pr);
3130           insn = emit_move_insn (alt_reg, reg);
3131
3132           /* ??? Denote pr spill/fill by a DImode move that modifies all
3133              64 hard registers.  */
3134           RTX_FRAME_RELATED_P (insn) = 1;
3135           REG_NOTES (insn)
3136             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3137                         gen_rtx_SET (VOIDmode, alt_reg, reg),
3138                         REG_NOTES (insn));
3139
3140           /* Even if we're not going to generate an epilogue, we still
3141              need to save the register so that EH works.  */
3142           if (! epilogue_p)
3143             emit_insn (gen_prologue_use (alt_reg));
3144         }
3145       else
3146         {
3147           alt_regno = next_scratch_gr_reg ();
3148           alt_reg = gen_rtx_REG (DImode, alt_regno);
3149           insn = emit_move_insn (alt_reg, reg);
3150           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
3151           cfa_off -= 8;
3152         }
3153     }
3154
3155   /* Handle AR regs in numerical order.  All of them get special handling.  */
3156   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM)
3157       && current_frame_info.r[reg_save_ar_unat] == 0)
3158     {
3159       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
3160       do_spill (gen_movdi_x, ar_unat_save_reg, cfa_off, reg);
3161       cfa_off -= 8;
3162     }
3163
3164   /* The alloc insn already copied ar.pfs into a general register.  The
3165      only thing we have to do now is copy that register to a stack slot
3166      if we'd not allocated a local register for the job.  */
3167   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM)
3168       && current_frame_info.r[reg_save_ar_pfs] == 0)
3169     {
3170       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
3171       do_spill (gen_movdi_x, ar_pfs_save_reg, cfa_off, reg);
3172       cfa_off -= 8;
3173     }
3174
3175   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_LC_REGNUM))
3176     {
3177       reg = gen_rtx_REG (DImode, AR_LC_REGNUM);
3178       if (current_frame_info.r[reg_save_ar_lc] != 0)
3179         {
3180           alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_ar_lc]);
3181           reg_emitted (reg_save_ar_lc);
3182           insn = emit_move_insn (alt_reg, reg);
3183           RTX_FRAME_RELATED_P (insn) = 1;
3184
3185           /* Even if we're not going to generate an epilogue, we still
3186              need to save the register so that EH works.  */
3187           if (! epilogue_p)
3188             emit_insn (gen_prologue_use (alt_reg));
3189         }
3190       else
3191         {
3192           alt_regno = next_scratch_gr_reg ();
3193           alt_reg = gen_rtx_REG (DImode, alt_regno);
3194           emit_move_insn (alt_reg, reg);
3195           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
3196           cfa_off -= 8;
3197         }
3198     }
3199
3200   /* Save the return pointer.  */
3201   if (TEST_HARD_REG_BIT (current_frame_info.mask, BR_REG (0)))
3202     {
3203       reg = gen_rtx_REG (DImode, BR_REG (0));
3204       if (current_frame_info.r[reg_save_b0] != 0)
3205         {
3206           alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_b0]);
3207           reg_emitted (reg_save_b0);
3208           insn = emit_move_insn (alt_reg, reg);
3209           RTX_FRAME_RELATED_P (insn) = 1;
3210
3211           /* Even if we're not going to generate an epilogue, we still
3212              need to save the register so that EH works.  */
3213           if (! epilogue_p)
3214             emit_insn (gen_prologue_use (alt_reg));
3215         }
3216       else
3217         {
3218           alt_regno = next_scratch_gr_reg ();
3219           alt_reg = gen_rtx_REG (DImode, alt_regno);
3220           emit_move_insn (alt_reg, reg);
3221           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
3222           cfa_off -= 8;
3223         }
3224     }
3225
3226   if (current_frame_info.r[reg_save_gp])
3227     {
3228       reg_emitted (reg_save_gp);
3229       insn = emit_move_insn (gen_rtx_REG (DImode,
3230                                           current_frame_info.r[reg_save_gp]),
3231                              pic_offset_table_rtx);
3232     }
3233
3234   /* We should now be at the base of the gr/br/fr spill area.  */
3235   gcc_assert (cfa_off == (current_frame_info.spill_cfa_off
3236                           + current_frame_info.spill_size));
3237
3238   /* Spill all general registers.  */
3239   for (regno = GR_REG (1); regno <= GR_REG (31); ++regno)
3240     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3241       {
3242         reg = gen_rtx_REG (DImode, regno);
3243         do_spill (gen_gr_spill, reg, cfa_off, reg);
3244         cfa_off -= 8;
3245       }
3246
3247   /* Spill the rest of the BR registers.  */
3248   for (regno = BR_REG (1); regno <= BR_REG (7); ++regno)
3249     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3250       {
3251         alt_regno = next_scratch_gr_reg ();
3252         alt_reg = gen_rtx_REG (DImode, alt_regno);
3253         reg = gen_rtx_REG (DImode, regno);
3254         emit_move_insn (alt_reg, reg);
3255         do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
3256         cfa_off -= 8;
3257       }
3258
3259   /* Align the frame and spill all FR registers.  */
3260   for (regno = FR_REG (2); regno <= FR_REG (127); ++regno)
3261     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3262       {
3263         gcc_assert (!(cfa_off & 15));
3264         reg = gen_rtx_REG (XFmode, regno);
3265         do_spill (gen_fr_spill_x, reg, cfa_off, reg);
3266         cfa_off -= 16;
3267       }
3268
3269   gcc_assert (cfa_off == current_frame_info.spill_cfa_off);
3270
3271   finish_spill_pointers ();
3272 }
3273
3274 /* Called after register allocation to add any instructions needed for the
3275    epilogue.  Using an epilogue insn is favored compared to putting all of the
3276    instructions in output_function_prologue(), since it allows the scheduler
3277    to intermix instructions with the saves of the caller saved registers.  In
3278    some cases, it might be necessary to emit a barrier instruction as the last
3279    insn to prevent such scheduling.  */
3280
3281 void
3282 ia64_expand_epilogue (int sibcall_p)
3283 {
3284   rtx insn, reg, alt_reg, ar_unat_save_reg;
3285   int regno, alt_regno, cfa_off;
3286
3287   ia64_compute_frame_size (get_frame_size ());
3288
3289   /* If there is a frame pointer, then we use it instead of the stack
3290      pointer, so that the stack pointer does not need to be valid when
3291      the epilogue starts.  See EXIT_IGNORE_STACK.  */
3292   if (frame_pointer_needed)
3293     setup_spill_pointers (current_frame_info.n_spilled,
3294                           hard_frame_pointer_rtx, 0);
3295   else
3296     setup_spill_pointers (current_frame_info.n_spilled, stack_pointer_rtx,
3297                           current_frame_info.total_size);
3298
3299   if (current_frame_info.total_size != 0)
3300     {
3301       /* ??? At this point we must generate a magic insn that appears to
3302          modify the spill iterators and the frame pointer.  This would
3303          allow the most scheduling freedom.  For now, just hard stop.  */
3304       emit_insn (gen_blockage ());
3305     }
3306
3307   /* Locate the bottom of the register save area.  */
3308   cfa_off = (current_frame_info.spill_cfa_off
3309              + current_frame_info.spill_size
3310              + current_frame_info.extra_spill_size);
3311
3312   /* Restore the predicate registers.  */
3313   if (TEST_HARD_REG_BIT (current_frame_info.mask, PR_REG (0)))
3314     {
3315       if (current_frame_info.r[reg_save_pr] != 0)
3316         {
3317           alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_pr]);
3318           reg_emitted (reg_save_pr);
3319         }
3320       else
3321         {
3322           alt_regno = next_scratch_gr_reg ();
3323           alt_reg = gen_rtx_REG (DImode, alt_regno);
3324           do_restore (gen_movdi_x, alt_reg, cfa_off);
3325           cfa_off -= 8;
3326         }
3327       reg = gen_rtx_REG (DImode, PR_REG (0));
3328       emit_move_insn (reg, alt_reg);
3329     }
3330
3331   /* Restore the application registers.  */
3332
3333   /* Load the saved unat from the stack, but do not restore it until
3334      after the GRs have been restored.  */
3335   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
3336     {
3337       if (current_frame_info.r[reg_save_ar_unat] != 0)
3338         {
3339           ar_unat_save_reg
3340             = gen_rtx_REG (DImode, current_frame_info.r[reg_save_ar_unat]);
3341           reg_emitted (reg_save_ar_unat);
3342         }
3343       else
3344         {
3345           alt_regno = next_scratch_gr_reg ();
3346           ar_unat_save_reg = gen_rtx_REG (DImode, alt_regno);
3347           current_frame_info.gr_used_mask |= 1 << alt_regno;
3348           do_restore (gen_movdi_x, ar_unat_save_reg, cfa_off);
3349           cfa_off -= 8;
3350         }
3351     }
3352   else
3353     ar_unat_save_reg = NULL_RTX;
3354
3355   if (current_frame_info.r[reg_save_ar_pfs] != 0)
3356     {
3357       reg_emitted (reg_save_ar_pfs);
3358       alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_ar_pfs]);
3359       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
3360       emit_move_insn (reg, alt_reg);
3361     }
3362   else if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM))
3363     {
3364       alt_regno = next_scratch_gr_reg ();
3365       alt_reg = gen_rtx_REG (DImode, alt_regno);
3366       do_restore (gen_movdi_x, alt_reg, cfa_off);
3367       cfa_off -= 8;
3368       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
3369       emit_move_insn (reg, alt_reg);
3370     }
3371
3372   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_LC_REGNUM))
3373     {
3374       if (current_frame_info.r[reg_save_ar_lc] != 0)
3375         {
3376           alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_ar_lc]);
3377           reg_emitted (reg_save_ar_lc);
3378         }
3379       else
3380         {
3381           alt_regno = next_scratch_gr_reg ();
3382           alt_reg = gen_rtx_REG (DImode, alt_regno);
3383           do_restore (gen_movdi_x, alt_reg, cfa_off);
3384           cfa_off -= 8;
3385         }
3386       reg = gen_rtx_REG (DImode, AR_LC_REGNUM);
3387       emit_move_insn (reg, alt_reg);
3388     }
3389
3390   /* Restore the return pointer.  */
3391   if (TEST_HARD_REG_BIT (current_frame_info.mask, BR_REG (0)))
3392     {
3393       if (current_frame_info.r[reg_save_b0] != 0)
3394         {
3395          alt_reg = gen_rtx_REG (DImode, current_frame_info.r[reg_save_b0]);
3396          reg_emitted (reg_save_b0);
3397         }
3398       else
3399         {
3400           alt_regno = next_scratch_gr_reg ();
3401           alt_reg = gen_rtx_REG (DImode, alt_regno);
3402           do_restore (gen_movdi_x, alt_reg, cfa_off);
3403           cfa_off -= 8;
3404         }
3405       reg = gen_rtx_REG (DImode, BR_REG (0));
3406       emit_move_insn (reg, alt_reg);
3407     }
3408
3409   /* We should now be at the base of the gr/br/fr spill area.  */
3410   gcc_assert (cfa_off == (current_frame_info.spill_cfa_off
3411                           + current_frame_info.spill_size));
3412
3413   /* The GP may be stored on the stack in the prologue, but it's
3414      never restored in the epilogue.  Skip the stack slot.  */
3415   if (TEST_HARD_REG_BIT (current_frame_info.mask, GR_REG (1)))
3416     cfa_off -= 8;
3417
3418   /* Restore all general registers.  */
3419   for (regno = GR_REG (2); regno <= GR_REG (31); ++regno)
3420     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3421       {
3422         reg = gen_rtx_REG (DImode, regno);
3423         do_restore (gen_gr_restore, reg, cfa_off);
3424         cfa_off -= 8;
3425       }
3426
3427   /* Restore the branch registers.  */
3428   for (regno = BR_REG (1); regno <= BR_REG (7); ++regno)
3429     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3430       {
3431         alt_regno = next_scratch_gr_reg ();
3432         alt_reg = gen_rtx_REG (DImode, alt_regno);
3433         do_restore (gen_movdi_x, alt_reg, cfa_off);
3434         cfa_off -= 8;
3435         reg = gen_rtx_REG (DImode, regno);
3436         emit_move_insn (reg, alt_reg);
3437       }
3438
3439   /* Restore floating point registers.  */
3440   for (regno = FR_REG (2); regno <= FR_REG (127); ++regno)
3441     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
3442       {
3443         gcc_assert (!(cfa_off & 15));
3444         reg = gen_rtx_REG (XFmode, regno);
3445         do_restore (gen_fr_restore_x, reg, cfa_off);
3446         cfa_off -= 16;
3447       }
3448
3449   /* Restore ar.unat for real.  */
3450   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
3451     {
3452       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
3453       emit_move_insn (reg, ar_unat_save_reg);
3454     }
3455
3456   gcc_assert (cfa_off == current_frame_info.spill_cfa_off);
3457
3458   finish_spill_pointers ();
3459
3460   if (current_frame_info.total_size
3461       || cfun->machine->ia64_eh_epilogue_sp
3462       || frame_pointer_needed)
3463     {
3464       /* ??? At this point we must generate a magic insn that appears to
3465          modify the spill iterators, the stack pointer, and the frame
3466          pointer.  This would allow the most scheduling freedom.  For now,
3467          just hard stop.  */
3468       emit_insn (gen_blockage ());
3469     }
3470
3471   if (cfun->machine->ia64_eh_epilogue_sp)
3472     emit_move_insn (stack_pointer_rtx, cfun->machine->ia64_eh_epilogue_sp);
3473   else if (frame_pointer_needed)
3474     {
3475       insn = emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
3476       RTX_FRAME_RELATED_P (insn) = 1;
3477     }
3478   else if (current_frame_info.total_size)
3479     {
3480       rtx offset, frame_size_rtx;
3481
3482       frame_size_rtx = GEN_INT (current_frame_info.total_size);
3483       if (satisfies_constraint_I (frame_size_rtx))