OSDN Git Service

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