OSDN Git Service

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