OSDN Git Service

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