OSDN Git Service

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