OSDN Git Service

3fb27dd50d0a5bdc9022d050e0c063a078c72ffa
[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, int,
201                                                  tree, rtx));
202 static rtx ia64_expand_lock_test_and_set PARAMS ((enum machine_mode,
203                                                   tree, rtx));
204 static rtx ia64_expand_lock_release PARAMS ((enum machine_mode, tree, rtx));
205 static bool ia64_assemble_integer PARAMS ((rtx, unsigned int, int));
206 static void ia64_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
207 static void ia64_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
208 static void ia64_output_function_end_prologue PARAMS ((FILE *));
209
210 static int ia64_issue_rate PARAMS ((void));
211 static int ia64_adjust_cost PARAMS ((rtx, rtx, rtx, int));
212 static void ia64_sched_init PARAMS ((FILE *, int, int));
213 static void ia64_sched_finish PARAMS ((FILE *, int));
214 static int ia64_dfa_sched_reorder PARAMS ((FILE *, int, rtx *, int *,
215                                            int, int));
216 static int ia64_sched_reorder PARAMS ((FILE *, int, rtx *, int *, int));
217 static int ia64_sched_reorder2 PARAMS ((FILE *, int, rtx *, int *, int));
218 static int ia64_variable_issue PARAMS ((FILE *, int, rtx, int));
219
220 static struct bundle_state *get_free_bundle_state PARAMS ((void));
221 static void free_bundle_state PARAMS ((struct bundle_state *));
222 static void initiate_bundle_states PARAMS ((void));
223 static void finish_bundle_states PARAMS ((void));
224 static unsigned bundle_state_hash PARAMS ((const void *));
225 static int bundle_state_eq_p PARAMS ((const void *, const void *));
226 static int insert_bundle_state PARAMS ((struct bundle_state *));
227 static void initiate_bundle_state_table PARAMS ((void));
228 static void finish_bundle_state_table PARAMS ((void));
229 static int try_issue_nops PARAMS ((struct bundle_state *, int));
230 static int try_issue_insn PARAMS ((struct bundle_state *, rtx));
231 static void issue_nops_and_insn PARAMS ((struct bundle_state *, int,
232                                          rtx, int, int));
233 static int get_max_pos PARAMS ((state_t));
234 static int get_template PARAMS ((state_t, int));
235
236 static rtx get_next_important_insn PARAMS ((rtx, rtx));
237 static void bundling PARAMS ((FILE *, int, rtx, rtx));
238
239 static void ia64_output_mi_thunk PARAMS ((FILE *, tree, HOST_WIDE_INT,
240                                           HOST_WIDE_INT, tree));
241
242 static void ia64_select_rtx_section PARAMS ((enum machine_mode, rtx,
243                                              unsigned HOST_WIDE_INT));
244 static void ia64_rwreloc_select_section PARAMS ((tree, int,
245                                                  unsigned HOST_WIDE_INT))
246      ATTRIBUTE_UNUSED;
247 static void ia64_rwreloc_unique_section PARAMS ((tree, int))
248      ATTRIBUTE_UNUSED;
249 static void ia64_rwreloc_select_rtx_section PARAMS ((enum machine_mode, rtx,
250                                                      unsigned HOST_WIDE_INT))
251      ATTRIBUTE_UNUSED;
252 static unsigned int ia64_rwreloc_section_type_flags
253      PARAMS ((tree, const char *, int))
254      ATTRIBUTE_UNUSED;
255
256 static void ia64_hpux_add_extern_decl PARAMS ((const char *name))
257      ATTRIBUTE_UNUSED;
258 \f
259 /* Table of valid machine attributes.  */
260 static const struct attribute_spec ia64_attribute_table[] =
261 {
262   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
263   { "syscall_linkage", 0, 0, false, true,  true,  NULL },
264   { NULL,              0, 0, false, false, false, NULL }
265 };
266
267 /* Initialize the GCC target structure.  */
268 #undef TARGET_ATTRIBUTE_TABLE
269 #define TARGET_ATTRIBUTE_TABLE ia64_attribute_table
270
271 #undef TARGET_INIT_BUILTINS
272 #define TARGET_INIT_BUILTINS ia64_init_builtins
273
274 #undef TARGET_EXPAND_BUILTIN
275 #define TARGET_EXPAND_BUILTIN ia64_expand_builtin
276
277 #undef TARGET_ASM_BYTE_OP
278 #define TARGET_ASM_BYTE_OP "\tdata1\t"
279 #undef TARGET_ASM_ALIGNED_HI_OP
280 #define TARGET_ASM_ALIGNED_HI_OP "\tdata2\t"
281 #undef TARGET_ASM_ALIGNED_SI_OP
282 #define TARGET_ASM_ALIGNED_SI_OP "\tdata4\t"
283 #undef TARGET_ASM_ALIGNED_DI_OP
284 #define TARGET_ASM_ALIGNED_DI_OP "\tdata8\t"
285 #undef TARGET_ASM_UNALIGNED_HI_OP
286 #define TARGET_ASM_UNALIGNED_HI_OP "\tdata2.ua\t"
287 #undef TARGET_ASM_UNALIGNED_SI_OP
288 #define TARGET_ASM_UNALIGNED_SI_OP "\tdata4.ua\t"
289 #undef TARGET_ASM_UNALIGNED_DI_OP
290 #define TARGET_ASM_UNALIGNED_DI_OP "\tdata8.ua\t"
291 #undef TARGET_ASM_INTEGER
292 #define TARGET_ASM_INTEGER ia64_assemble_integer
293
294 #undef TARGET_ASM_FUNCTION_PROLOGUE
295 #define TARGET_ASM_FUNCTION_PROLOGUE ia64_output_function_prologue
296 #undef TARGET_ASM_FUNCTION_END_PROLOGUE
297 #define TARGET_ASM_FUNCTION_END_PROLOGUE ia64_output_function_end_prologue
298 #undef TARGET_ASM_FUNCTION_EPILOGUE
299 #define TARGET_ASM_FUNCTION_EPILOGUE ia64_output_function_epilogue
300
301 #undef TARGET_IN_SMALL_DATA_P
302 #define TARGET_IN_SMALL_DATA_P  ia64_in_small_data_p
303
304 #undef TARGET_SCHED_ADJUST_COST
305 #define TARGET_SCHED_ADJUST_COST ia64_adjust_cost
306 #undef TARGET_SCHED_ISSUE_RATE
307 #define TARGET_SCHED_ISSUE_RATE ia64_issue_rate
308 #undef TARGET_SCHED_VARIABLE_ISSUE
309 #define TARGET_SCHED_VARIABLE_ISSUE ia64_variable_issue
310 #undef TARGET_SCHED_INIT
311 #define TARGET_SCHED_INIT ia64_sched_init
312 #undef TARGET_SCHED_FINISH
313 #define TARGET_SCHED_FINISH ia64_sched_finish
314 #undef TARGET_SCHED_REORDER
315 #define TARGET_SCHED_REORDER ia64_sched_reorder
316 #undef TARGET_SCHED_REORDER2
317 #define TARGET_SCHED_REORDER2 ia64_sched_reorder2
318
319 #undef TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK
320 #define TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK ia64_dependencies_evaluation_hook
321
322 #undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
323 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE ia64_use_dfa_pipeline_interface
324
325 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
326 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ia64_first_cycle_multipass_dfa_lookahead
327
328 #undef TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN
329 #define TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN ia64_init_dfa_pre_cycle_insn
330 #undef TARGET_SCHED_DFA_PRE_CYCLE_INSN
331 #define TARGET_SCHED_DFA_PRE_CYCLE_INSN ia64_dfa_pre_cycle_insn
332
333 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
334 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD\
335   ia64_first_cycle_multipass_dfa_lookahead_guard
336
337 #undef TARGET_SCHED_DFA_NEW_CYCLE
338 #define TARGET_SCHED_DFA_NEW_CYCLE ia64_dfa_new_cycle
339
340 #ifdef HAVE_AS_TLS
341 #undef TARGET_HAVE_TLS
342 #define TARGET_HAVE_TLS true
343 #endif
344
345 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
346 #define TARGET_FUNCTION_OK_FOR_SIBCALL ia64_function_ok_for_sibcall
347
348 #undef TARGET_ASM_OUTPUT_MI_THUNK
349 #define TARGET_ASM_OUTPUT_MI_THUNK ia64_output_mi_thunk
350 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
351 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
352
353 #undef TARGET_RTX_COSTS
354 #define TARGET_RTX_COSTS ia64_rtx_costs
355 #undef TARGET_ADDRESS_COST
356 #define TARGET_ADDRESS_COST hook_int_rtx_0
357
358 struct gcc_target targetm = TARGET_INITIALIZER;
359 \f
360 /* Return 1 if OP is a valid operand for the MEM of a CALL insn.  */
361
362 int
363 call_operand (op, mode)
364      rtx op;
365      enum machine_mode mode;
366 {
367   if (mode != GET_MODE (op) && mode != VOIDmode)
368     return 0;
369
370   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == REG
371           || (GET_CODE (op) == SUBREG && GET_CODE (XEXP (op, 0)) == REG));
372 }
373
374 /* Return 1 if OP refers to a symbol in the sdata section.  */
375
376 int
377 sdata_symbolic_operand (op, mode)
378      rtx op;
379      enum machine_mode mode ATTRIBUTE_UNUSED;
380 {
381   switch (GET_CODE (op))
382     {
383     case CONST:
384       if (GET_CODE (XEXP (op, 0)) != PLUS
385           || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF)
386         break;
387       op = XEXP (XEXP (op, 0), 0);
388       /* FALLTHRU */
389
390     case SYMBOL_REF:
391       if (CONSTANT_POOL_ADDRESS_P (op))
392         return GET_MODE_SIZE (get_pool_mode (op)) <= ia64_section_threshold;
393       else
394         return SYMBOL_REF_LOCAL_P (op) && SYMBOL_REF_SMALL_P (op);
395
396     default:
397       break;
398     }
399
400   return 0;
401 }
402
403 /* Return 1 if OP refers to a symbol, and is appropriate for a GOT load.  */
404
405 int
406 got_symbolic_operand (op, mode)
407      rtx op;
408      enum machine_mode mode ATTRIBUTE_UNUSED;
409 {
410   switch (GET_CODE (op))
411     {
412     case CONST:
413       op = XEXP (op, 0);
414       if (GET_CODE (op) != PLUS)
415         return 0;
416       if (GET_CODE (XEXP (op, 0)) != SYMBOL_REF)
417         return 0;
418       op = XEXP (op, 1);
419       if (GET_CODE (op) != CONST_INT)
420         return 0;
421
422         return 1;
423
424       /* Ok if we're not using GOT entries at all.  */
425       if (TARGET_NO_PIC || TARGET_AUTO_PIC)
426         return 1;
427
428       /* "Ok" while emitting rtl, since otherwise we won't be provided
429          with the entire offset during emission, which makes it very
430          hard to split the offset into high and low parts.  */
431       if (rtx_equal_function_value_matters)
432         return 1;
433
434       /* Force the low 14 bits of the constant to zero so that we do not
435          use up so many GOT entries.  */
436       return (INTVAL (op) & 0x3fff) == 0;
437
438     case SYMBOL_REF:
439     case LABEL_REF:
440       return 1;
441
442     default:
443       break;
444     }
445   return 0;
446 }
447
448 /* Return 1 if OP refers to a symbol.  */
449
450 int
451 symbolic_operand (op, mode)
452      rtx op;
453      enum machine_mode mode ATTRIBUTE_UNUSED;
454 {
455   switch (GET_CODE (op))
456     {
457     case CONST:
458     case SYMBOL_REF:
459     case LABEL_REF:
460       return 1;
461
462     default:
463       break;
464     }
465   return 0;
466 }
467
468 /* Return tls_model if OP refers to a TLS symbol.  */
469
470 int
471 tls_symbolic_operand (op, mode)
472      rtx op;
473      enum machine_mode mode ATTRIBUTE_UNUSED;
474 {
475   if (GET_CODE (op) != SYMBOL_REF)
476     return 0;
477   return SYMBOL_REF_TLS_MODEL (op);
478 }
479
480
481 /* Return 1 if OP refers to a function.  */
482
483 int
484 function_operand (op, mode)
485      rtx op;
486      enum machine_mode mode ATTRIBUTE_UNUSED;
487 {
488   if (GET_CODE (op) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P (op))
489     return 1;
490   else
491     return 0;
492 }
493
494 /* Return 1 if OP is setjmp or a similar function.  */
495
496 /* ??? This is an unsatisfying solution.  Should rethink.  */
497
498 int
499 setjmp_operand (op, mode)
500      rtx op;
501      enum machine_mode mode ATTRIBUTE_UNUSED;
502 {
503   const char *name;
504   int retval = 0;
505
506   if (GET_CODE (op) != SYMBOL_REF)
507     return 0;
508
509   name = XSTR (op, 0);
510
511   /* The following code is borrowed from special_function_p in calls.c.  */
512
513   /* Disregard prefix _, __ or __x.  */
514   if (name[0] == '_')
515     {
516       if (name[1] == '_' && name[2] == 'x')
517         name += 3;
518       else if (name[1] == '_')
519         name += 2;
520       else
521         name += 1;
522     }
523
524   if (name[0] == 's')
525     {
526       retval
527         = ((name[1] == 'e'
528             && (! strcmp (name, "setjmp")
529                 || ! strcmp (name, "setjmp_syscall")))
530            || (name[1] == 'i'
531                && ! strcmp (name, "sigsetjmp"))
532            || (name[1] == 'a'
533                && ! strcmp (name, "savectx")));
534     }
535   else if ((name[0] == 'q' && name[1] == 's'
536             && ! strcmp (name, "qsetjmp"))
537            || (name[0] == 'v' && name[1] == 'f'
538                && ! strcmp (name, "vfork")))
539     retval = 1;
540
541   return retval;
542 }
543
544 /* Return 1 if OP is a general operand, excluding tls symbolic operands.  */
545
546 int
547 move_operand (op, mode)
548      rtx op;
549      enum machine_mode mode;
550 {
551   return general_operand (op, mode) && !tls_symbolic_operand (op, mode);
552 }
553
554 /* Return 1 if OP is a register operand that is (or could be) a GR reg.  */
555
556 int
557 gr_register_operand (op, mode)
558      rtx op;
559      enum machine_mode mode;
560 {
561   if (! register_operand (op, mode))
562     return 0;
563   if (GET_CODE (op) == SUBREG)
564     op = SUBREG_REG (op);
565   if (GET_CODE (op) == REG)
566     {
567       unsigned int regno = REGNO (op);
568       if (regno < FIRST_PSEUDO_REGISTER)
569         return GENERAL_REGNO_P (regno);
570     }
571   return 1;
572 }
573
574 /* Return 1 if OP is a register operand that is (or could be) an FR reg.  */
575
576 int
577 fr_register_operand (op, mode)
578      rtx op;
579      enum machine_mode mode;
580 {
581   if (! register_operand (op, mode))
582     return 0;
583   if (GET_CODE (op) == SUBREG)
584     op = SUBREG_REG (op);
585   if (GET_CODE (op) == REG)
586     {
587       unsigned int regno = REGNO (op);
588       if (regno < FIRST_PSEUDO_REGISTER)
589         return FR_REGNO_P (regno);
590     }
591   return 1;
592 }
593
594 /* Return 1 if OP is a register operand that is (or could be) a GR/FR reg.  */
595
596 int
597 grfr_register_operand (op, mode)
598      rtx op;
599      enum machine_mode mode;
600 {
601   if (! register_operand (op, mode))
602     return 0;
603   if (GET_CODE (op) == SUBREG)
604     op = SUBREG_REG (op);
605   if (GET_CODE (op) == REG)
606     {
607       unsigned int regno = REGNO (op);
608       if (regno < FIRST_PSEUDO_REGISTER)
609         return GENERAL_REGNO_P (regno) || FR_REGNO_P (regno);
610     }
611   return 1;
612 }
613
614 /* Return 1 if OP is a nonimmediate operand that is (or could be) a GR reg.  */
615
616 int
617 gr_nonimmediate_operand (op, mode)
618      rtx op;
619      enum machine_mode mode;
620 {
621   if (! nonimmediate_operand (op, mode))
622     return 0;
623   if (GET_CODE (op) == SUBREG)
624     op = SUBREG_REG (op);
625   if (GET_CODE (op) == REG)
626     {
627       unsigned int regno = REGNO (op);
628       if (regno < FIRST_PSEUDO_REGISTER)
629         return GENERAL_REGNO_P (regno);
630     }
631   return 1;
632 }
633
634 /* Return 1 if OP is a nonimmediate operand that is (or could be) a FR reg.  */
635
636 int
637 fr_nonimmediate_operand (op, mode)
638      rtx op;
639      enum machine_mode mode;
640 {
641   if (! nonimmediate_operand (op, mode))
642     return 0;
643   if (GET_CODE (op) == SUBREG)
644     op = SUBREG_REG (op);
645   if (GET_CODE (op) == REG)
646     {
647       unsigned int regno = REGNO (op);
648       if (regno < FIRST_PSEUDO_REGISTER)
649         return FR_REGNO_P (regno);
650     }
651   return 1;
652 }
653
654 /* Return 1 if OP is a nonimmediate operand that is a GR/FR reg.  */
655
656 int
657 grfr_nonimmediate_operand (op, mode)
658      rtx op;
659      enum machine_mode mode;
660 {
661   if (! nonimmediate_operand (op, mode))
662     return 0;
663   if (GET_CODE (op) == SUBREG)
664     op = SUBREG_REG (op);
665   if (GET_CODE (op) == REG)
666     {
667       unsigned int regno = REGNO (op);
668       if (regno < FIRST_PSEUDO_REGISTER)
669         return GENERAL_REGNO_P (regno) || FR_REGNO_P (regno);
670     }
671   return 1;
672 }
673
674 /* Return 1 if OP is a GR register operand, or zero.  */
675
676 int
677 gr_reg_or_0_operand (op, mode)
678      rtx op;
679      enum machine_mode mode;
680 {
681   return (op == const0_rtx || gr_register_operand (op, mode));
682 }
683
684 /* Return 1 if OP is a GR register operand, or a 5 bit immediate operand.  */
685
686 int
687 gr_reg_or_5bit_operand (op, mode)
688      rtx op;
689      enum machine_mode mode;
690 {
691   return ((GET_CODE (op) == CONST_INT && INTVAL (op) >= 0 && INTVAL (op) < 32)
692           || GET_CODE (op) == CONSTANT_P_RTX
693           || gr_register_operand (op, mode));
694 }
695
696 /* Return 1 if OP is a GR register operand, or a 6 bit immediate operand.  */
697
698 int
699 gr_reg_or_6bit_operand (op, mode)
700      rtx op;
701      enum machine_mode mode;
702 {
703   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_M (INTVAL (op)))
704           || GET_CODE (op) == CONSTANT_P_RTX
705           || gr_register_operand (op, mode));
706 }
707
708 /* Return 1 if OP is a GR register operand, or an 8 bit immediate operand.  */
709
710 int
711 gr_reg_or_8bit_operand (op, mode)
712      rtx op;
713      enum machine_mode mode;
714 {
715   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_K (INTVAL (op)))
716           || GET_CODE (op) == CONSTANT_P_RTX
717           || gr_register_operand (op, mode));
718 }
719
720 /* Return 1 if OP is a GR/FR register operand, or an 8 bit immediate.  */
721
722 int
723 grfr_reg_or_8bit_operand (op, mode)
724      rtx op;
725      enum machine_mode mode;
726 {
727   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_K (INTVAL (op)))
728           || GET_CODE (op) == CONSTANT_P_RTX
729           || grfr_register_operand (op, mode));
730 }
731
732 /* Return 1 if OP is a register operand, or an 8 bit adjusted immediate
733    operand.  */
734
735 int
736 gr_reg_or_8bit_adjusted_operand (op, mode)
737      rtx op;
738      enum machine_mode mode;
739 {
740   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_L (INTVAL (op)))
741           || GET_CODE (op) == CONSTANT_P_RTX
742           || gr_register_operand (op, mode));
743 }
744
745 /* Return 1 if OP is a register operand, or is valid for both an 8 bit
746    immediate and an 8 bit adjusted immediate operand.  This is necessary
747    because when we emit a compare, we don't know what the condition will be,
748    so we need the union of the immediates accepted by GT and LT.  */
749
750 int
751 gr_reg_or_8bit_and_adjusted_operand (op, mode)
752      rtx op;
753      enum machine_mode mode;
754 {
755   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_K (INTVAL (op))
756            && CONST_OK_FOR_L (INTVAL (op)))
757           || GET_CODE (op) == CONSTANT_P_RTX
758           || gr_register_operand (op, mode));
759 }
760
761 /* Return 1 if OP is a register operand, or a 14 bit immediate operand.  */
762
763 int
764 gr_reg_or_14bit_operand (op, mode)
765      rtx op;
766      enum machine_mode mode;
767 {
768   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_I (INTVAL (op)))
769           || GET_CODE (op) == CONSTANT_P_RTX
770           || gr_register_operand (op, mode));
771 }
772
773 /* Return 1 if OP is a register operand, or a 22 bit immediate operand.  */
774
775 int
776 gr_reg_or_22bit_operand (op, mode)
777      rtx op;
778      enum machine_mode mode;
779 {
780   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_J (INTVAL (op)))
781           || GET_CODE (op) == CONSTANT_P_RTX
782           || gr_register_operand (op, mode));
783 }
784
785 /* Return 1 if OP is a 6 bit immediate operand.  */
786
787 int
788 shift_count_operand (op, mode)
789      rtx op;
790      enum machine_mode mode ATTRIBUTE_UNUSED;
791 {
792   return ((GET_CODE (op) == CONST_INT && CONST_OK_FOR_M (INTVAL (op)))
793           || GET_CODE (op) == CONSTANT_P_RTX);
794 }
795
796 /* Return 1 if OP is a 5 bit immediate operand.  */
797
798 int
799 shift_32bit_count_operand (op, mode)
800      rtx op;
801      enum machine_mode mode ATTRIBUTE_UNUSED;
802 {
803   return ((GET_CODE (op) == CONST_INT
804            && (INTVAL (op) >= 0 && INTVAL (op) < 32))
805           || GET_CODE (op) == CONSTANT_P_RTX);
806 }
807
808 /* Return 1 if OP is a 2, 4, 8, or 16 immediate operand.  */
809
810 int
811 shladd_operand (op, mode)
812      rtx op;
813      enum machine_mode mode ATTRIBUTE_UNUSED;
814 {
815   return (GET_CODE (op) == CONST_INT
816           && (INTVAL (op) == 2 || INTVAL (op) == 4
817               || INTVAL (op) == 8 || INTVAL (op) == 16));
818 }
819
820 /* Return 1 if OP is a -16, -8, -4, -1, 1, 4, 8, or 16 immediate operand.  */
821
822 int
823 fetchadd_operand (op, mode)
824      rtx op;
825      enum machine_mode mode ATTRIBUTE_UNUSED;
826 {
827   return (GET_CODE (op) == CONST_INT
828           && (INTVAL (op) == -16 || INTVAL (op) == -8 ||
829               INTVAL (op) == -4  || INTVAL (op) == -1 ||
830               INTVAL (op) == 1   || INTVAL (op) == 4  ||
831               INTVAL (op) == 8   || INTVAL (op) == 16));
832 }
833
834 /* Return 1 if OP is a floating-point constant zero, one, or a register.  */
835
836 int
837 fr_reg_or_fp01_operand (op, mode)
838      rtx op;
839      enum machine_mode mode;
840 {
841   return ((GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_OK_FOR_G (op))
842           || fr_register_operand (op, mode));
843 }
844
845 /* Like nonimmediate_operand, but don't allow MEMs that try to use a
846    POST_MODIFY with a REG as displacement.  */
847
848 int
849 destination_operand (op, mode)
850      rtx op;
851      enum machine_mode mode;
852 {
853   if (! nonimmediate_operand (op, mode))
854     return 0;
855   if (GET_CODE (op) == MEM
856       && GET_CODE (XEXP (op, 0)) == POST_MODIFY
857       && GET_CODE (XEXP (XEXP (XEXP (op, 0), 1), 1)) == REG)
858     return 0;
859   return 1;
860 }
861
862 /* Like memory_operand, but don't allow post-increments.  */
863
864 int
865 not_postinc_memory_operand (op, mode)
866      rtx op;
867      enum machine_mode mode;
868 {
869   return (memory_operand (op, mode)
870           && GET_RTX_CLASS (GET_CODE (XEXP (op, 0))) != 'a');
871 }
872
873 /* Return 1 if this is a comparison operator, which accepts a normal 8-bit
874    signed immediate operand.  */
875
876 int
877 normal_comparison_operator (op, mode)
878     register rtx op;
879     enum machine_mode mode;
880 {
881   enum rtx_code code = GET_CODE (op);
882   return ((mode == VOIDmode || GET_MODE (op) == mode)
883           && (code == EQ || code == NE
884               || code == GT || code == LE || code == GTU || code == LEU));
885 }
886
887 /* Return 1 if this is a comparison operator, which accepts an adjusted 8-bit
888    signed immediate operand.  */
889
890 int
891 adjusted_comparison_operator (op, mode)
892     register rtx op;
893     enum machine_mode mode;
894 {
895   enum rtx_code code = GET_CODE (op);
896   return ((mode == VOIDmode || GET_MODE (op) == mode)
897           && (code == LT || code == GE || code == LTU || code == GEU));
898 }
899
900 /* Return 1 if this is a signed inequality operator.  */
901
902 int
903 signed_inequality_operator (op, mode)
904     register rtx op;
905     enum machine_mode mode;
906 {
907   enum rtx_code code = GET_CODE (op);
908   return ((mode == VOIDmode || GET_MODE (op) == mode)
909           && (code == GE || code == GT
910               || code == LE || code == LT));
911 }
912
913 /* Return 1 if this operator is valid for predication.  */
914
915 int
916 predicate_operator (op, mode)
917     register rtx op;
918     enum machine_mode mode;
919 {
920   enum rtx_code code = GET_CODE (op);
921   return ((GET_MODE (op) == mode || mode == VOIDmode)
922           && (code == EQ || code == NE));
923 }
924
925 /* Return 1 if this operator can be used in a conditional operation.  */
926
927 int
928 condop_operator (op, mode)
929     register rtx op;
930     enum machine_mode mode;
931 {
932   enum rtx_code code = GET_CODE (op);
933   return ((GET_MODE (op) == mode || mode == VOIDmode)
934           && (code == PLUS || code == MINUS || code == AND
935               || code == IOR || code == XOR));
936 }
937
938 /* Return 1 if this is the ar.lc register.  */
939
940 int
941 ar_lc_reg_operand (op, mode)
942      register rtx op;
943      enum machine_mode mode;
944 {
945   return (GET_MODE (op) == DImode
946           && (mode == DImode || mode == VOIDmode)
947           && GET_CODE (op) == REG
948           && REGNO (op) == AR_LC_REGNUM);
949 }
950
951 /* Return 1 if this is the ar.ccv register.  */
952
953 int
954 ar_ccv_reg_operand (op, mode)
955      register rtx op;
956      enum machine_mode mode;
957 {
958   return ((GET_MODE (op) == mode || mode == VOIDmode)
959           && GET_CODE (op) == REG
960           && REGNO (op) == AR_CCV_REGNUM);
961 }
962
963 /* Return 1 if this is the ar.pfs register.  */
964
965 int
966 ar_pfs_reg_operand (op, mode)
967      register rtx op;
968      enum machine_mode mode;
969 {
970   return ((GET_MODE (op) == mode || mode == VOIDmode)
971           && GET_CODE (op) == REG
972           && REGNO (op) == AR_PFS_REGNUM);
973 }
974
975 /* Like general_operand, but don't allow (mem (addressof)).  */
976
977 int
978 general_tfmode_operand (op, mode)
979      rtx op;
980      enum machine_mode mode;
981 {
982   if (! general_operand (op, mode))
983     return 0;
984   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == ADDRESSOF)
985     return 0;
986   return 1;
987 }
988
989 /* Similarly.  */
990
991 int
992 destination_tfmode_operand (op, mode)
993      rtx op;
994      enum machine_mode mode;
995 {
996   if (! destination_operand (op, mode))
997     return 0;
998   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == ADDRESSOF)
999     return 0;
1000   return 1;
1001 }
1002
1003 /* Similarly.  */
1004
1005 int
1006 tfreg_or_fp01_operand (op, mode)
1007      rtx op;
1008      enum machine_mode mode;
1009 {
1010   if (GET_CODE (op) == SUBREG)
1011     return 0;
1012   return fr_reg_or_fp01_operand (op, mode);
1013 }
1014
1015 /* Return 1 if OP is valid as a base register in a reg + offset address.  */
1016
1017 int
1018 basereg_operand (op, mode)
1019      rtx op;
1020      enum machine_mode mode;
1021 {
1022   /* ??? Should I copy the flag_omit_frame_pointer and cse_not_expected
1023      checks from pa.c basereg_operand as well?  Seems to be OK without them
1024      in test runs.  */
1025
1026   return (register_operand (op, mode) &&
1027           REG_POINTER ((GET_CODE (op) == SUBREG) ? SUBREG_REG (op) : op));
1028 }
1029 \f
1030 /* Return 1 if the operands of a move are ok.  */
1031
1032 int
1033 ia64_move_ok (dst, src)
1034      rtx dst, src;
1035 {
1036   /* If we're under init_recog_no_volatile, we'll not be able to use
1037      memory_operand.  So check the code directly and don't worry about
1038      the validity of the underlying address, which should have been
1039      checked elsewhere anyway.  */
1040   if (GET_CODE (dst) != MEM)
1041     return 1;
1042   if (GET_CODE (src) == MEM)
1043     return 0;
1044   if (register_operand (src, VOIDmode))
1045     return 1;
1046
1047   /* Otherwise, this must be a constant, and that either 0 or 0.0 or 1.0.  */
1048   if (INTEGRAL_MODE_P (GET_MODE (dst)))
1049     return src == const0_rtx;
1050   else
1051     return GET_CODE (src) == CONST_DOUBLE && CONST_DOUBLE_OK_FOR_G (src);
1052 }
1053
1054 /* Return 0 if we are doing C++ code.  This optimization fails with
1055    C++ because of GNAT c++/6685.  */
1056
1057 int
1058 addp4_optimize_ok (op1, op2)
1059      rtx op1, op2;
1060 {
1061
1062   if (!strcmp (lang_hooks.name, "GNU C++"))
1063     return 0;
1064
1065   return (basereg_operand (op1, GET_MODE(op1)) !=
1066           basereg_operand (op2, GET_MODE(op2)));
1067 }
1068
1069 /* Check if OP is a mask suitable for use with SHIFT in a dep.z instruction.
1070    Return the length of the field, or <= 0 on failure.  */
1071
1072 int
1073 ia64_depz_field_mask (rop, rshift)
1074      rtx rop, rshift;
1075 {
1076   unsigned HOST_WIDE_INT op = INTVAL (rop);
1077   unsigned HOST_WIDE_INT shift = INTVAL (rshift);
1078
1079   /* Get rid of the zero bits we're shifting in.  */
1080   op >>= shift;
1081
1082   /* We must now have a solid block of 1's at bit 0.  */
1083   return exact_log2 (op + 1);
1084 }
1085
1086 /* Expand a symbolic constant load.  */
1087
1088 void
1089 ia64_expand_load_address (dest, src)
1090       rtx dest, src;
1091 {
1092   if (tls_symbolic_operand (src, VOIDmode))
1093     abort ();
1094   if (GET_CODE (dest) != REG)
1095     abort ();
1096
1097   if (TARGET_AUTO_PIC)
1098     {
1099       emit_insn (gen_load_gprel64 (dest, src));
1100       return;
1101     }
1102   else if (GET_CODE (src) == SYMBOL_REF && SYMBOL_REF_FUNCTION_P (src))
1103     {
1104       emit_insn (gen_load_fptr (dest, src));
1105       return;
1106     }
1107   else if (sdata_symbolic_operand (src, VOIDmode))
1108     {
1109       emit_insn (gen_load_gprel (dest, src));
1110       return;
1111     }
1112
1113   if (GET_CODE (src) == CONST
1114       && GET_CODE (XEXP (src, 0)) == PLUS
1115       && GET_CODE (XEXP (XEXP (src, 0), 1)) == CONST_INT
1116       && (INTVAL (XEXP (XEXP (src, 0), 1)) & 0x1fff) != 0)
1117     {
1118       rtx sym = XEXP (XEXP (src, 0), 0);
1119       HOST_WIDE_INT ofs, hi, lo;
1120
1121       /* Split the offset into a sign extended 14-bit low part
1122          and a complementary high part.  */
1123       ofs = INTVAL (XEXP (XEXP (src, 0), 1));
1124       lo = ((ofs & 0x3fff) ^ 0x2000) - 0x2000;
1125       hi = ofs - lo;
1126
1127       emit_insn (gen_load_symptr (dest, plus_constant (sym, hi), dest));
1128       emit_insn (gen_adddi3 (dest, dest, GEN_INT (lo)));
1129     }
1130   else
1131     emit_insn (gen_load_symptr (dest, src, dest));
1132 }
1133
1134 static GTY(()) rtx gen_tls_tga;
1135 static rtx
1136 gen_tls_get_addr ()
1137 {
1138   if (!gen_tls_tga)
1139     gen_tls_tga = init_one_libfunc ("__tls_get_addr");
1140   return gen_tls_tga;
1141 }
1142
1143 static GTY(()) rtx thread_pointer_rtx;
1144 static rtx
1145 gen_thread_pointer ()
1146 {
1147   if (!thread_pointer_rtx)
1148     {
1149       thread_pointer_rtx = gen_rtx_REG (Pmode, 13);
1150       RTX_UNCHANGING_P (thread_pointer_rtx) = 1;
1151     }
1152   return thread_pointer_rtx;
1153 }
1154
1155 static rtx
1156 ia64_expand_tls_address (tls_kind, op0, op1)
1157      enum tls_model tls_kind;
1158      rtx op0, op1;
1159 {
1160   rtx tga_op1, tga_op2, tga_ret, tga_eqv, tmp, insns;
1161
1162   switch (tls_kind)
1163     {
1164     case TLS_MODEL_GLOBAL_DYNAMIC:
1165       start_sequence ();
1166
1167       tga_op1 = gen_reg_rtx (Pmode);
1168       emit_insn (gen_load_ltoff_dtpmod (tga_op1, op1));
1169       tga_op1 = gen_rtx_MEM (Pmode, tga_op1);
1170       RTX_UNCHANGING_P (tga_op1) = 1;
1171
1172       tga_op2 = gen_reg_rtx (Pmode);
1173       emit_insn (gen_load_ltoff_dtprel (tga_op2, op1));
1174       tga_op2 = gen_rtx_MEM (Pmode, tga_op2);
1175       RTX_UNCHANGING_P (tga_op2) = 1;
1176               
1177       tga_ret = emit_library_call_value (gen_tls_get_addr (), NULL_RTX,
1178                                          LCT_CONST, Pmode, 2, tga_op1,
1179                                          Pmode, tga_op2, Pmode);
1180
1181       insns = get_insns ();
1182       end_sequence ();
1183
1184       emit_libcall_block (insns, op0, tga_ret, op1);
1185       return NULL_RTX;
1186
1187     case TLS_MODEL_LOCAL_DYNAMIC:
1188       /* ??? This isn't the completely proper way to do local-dynamic
1189          If the call to __tls_get_addr is used only by a single symbol,
1190          then we should (somehow) move the dtprel to the second arg
1191          to avoid the extra add.  */
1192       start_sequence ();
1193
1194       tga_op1 = gen_reg_rtx (Pmode);
1195       emit_insn (gen_load_ltoff_dtpmod (tga_op1, op1));
1196       tga_op1 = gen_rtx_MEM (Pmode, tga_op1);
1197       RTX_UNCHANGING_P (tga_op1) = 1;
1198
1199       tga_op2 = const0_rtx;
1200
1201       tga_ret = emit_library_call_value (gen_tls_get_addr (), NULL_RTX,
1202                                          LCT_CONST, Pmode, 2, tga_op1,
1203                                          Pmode, tga_op2, Pmode);
1204
1205       insns = get_insns ();
1206       end_sequence ();
1207
1208       tga_eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
1209                                 UNSPEC_LD_BASE);
1210       tmp = gen_reg_rtx (Pmode);
1211       emit_libcall_block (insns, tmp, tga_ret, tga_eqv);
1212
1213       if (register_operand (op0, Pmode))
1214         tga_ret = op0;
1215       else
1216         tga_ret = gen_reg_rtx (Pmode);
1217       if (TARGET_TLS64)
1218         {
1219           emit_insn (gen_load_dtprel (tga_ret, op1));
1220           emit_insn (gen_adddi3 (tga_ret, tmp, tga_ret));
1221         }
1222       else
1223         emit_insn (gen_add_dtprel (tga_ret, tmp, op1));
1224
1225       return (tga_ret == op0 ? NULL_RTX : tga_ret);
1226
1227     case TLS_MODEL_INITIAL_EXEC:
1228       tmp = gen_reg_rtx (Pmode);
1229       emit_insn (gen_load_ltoff_tprel (tmp, op1));
1230       tmp = gen_rtx_MEM (Pmode, tmp);
1231       RTX_UNCHANGING_P (tmp) = 1;
1232       tmp = force_reg (Pmode, tmp);
1233
1234       if (register_operand (op0, Pmode))
1235         op1 = op0;
1236       else
1237         op1 = gen_reg_rtx (Pmode);
1238       emit_insn (gen_adddi3 (op1, tmp, gen_thread_pointer ()));
1239
1240       return (op1 == op0 ? NULL_RTX : op1);
1241
1242     case TLS_MODEL_LOCAL_EXEC:
1243       if (register_operand (op0, Pmode))
1244         tmp = op0;
1245       else
1246         tmp = gen_reg_rtx (Pmode);
1247       if (TARGET_TLS64)
1248         {
1249           emit_insn (gen_load_tprel (tmp, op1));
1250           emit_insn (gen_adddi3 (tmp, gen_thread_pointer (), tmp));
1251         }
1252       else
1253         emit_insn (gen_add_tprel (tmp, gen_thread_pointer (), op1));
1254
1255       return (tmp == op0 ? NULL_RTX : tmp);
1256
1257     default:
1258       abort ();
1259     }
1260 }
1261
1262 rtx
1263 ia64_expand_move (op0, op1)
1264      rtx op0, op1;
1265 {
1266   enum machine_mode mode = GET_MODE (op0);
1267
1268   if (!reload_in_progress && !reload_completed && !ia64_move_ok (op0, op1))
1269     op1 = force_reg (mode, op1);
1270
1271   if ((mode == Pmode || mode == ptr_mode) && symbolic_operand (op1, VOIDmode))
1272     {
1273       enum tls_model tls_kind;
1274       if ((tls_kind = tls_symbolic_operand (op1, VOIDmode)))
1275         return ia64_expand_tls_address (tls_kind, op0, op1);
1276
1277       if (!TARGET_NO_PIC && reload_completed)
1278         {
1279           ia64_expand_load_address (op0, op1);
1280           return NULL_RTX;
1281         }
1282     }
1283
1284   return op1;
1285 }
1286
1287 /* Split a move from OP1 to OP0 conditional on COND.  */
1288
1289 void
1290 ia64_emit_cond_move (op0, op1, cond)
1291      rtx op0, op1, cond;
1292 {
1293   rtx insn, first = get_last_insn ();
1294
1295   emit_move_insn (op0, op1);
1296
1297   for (insn = get_last_insn (); insn != first; insn = PREV_INSN (insn))
1298     if (INSN_P (insn))
1299       PATTERN (insn) = gen_rtx_COND_EXEC (VOIDmode, copy_rtx (cond),
1300                                           PATTERN (insn));
1301 }
1302
1303 /* Split a post-reload TImode reference into two DImode components.  */
1304
1305 rtx
1306 ia64_split_timode (out, in, scratch)
1307      rtx out[2];
1308      rtx in, scratch;
1309 {
1310   switch (GET_CODE (in))
1311     {
1312     case REG:
1313       out[0] = gen_rtx_REG (DImode, REGNO (in));
1314       out[1] = gen_rtx_REG (DImode, REGNO (in) + 1);
1315       return NULL_RTX;
1316
1317     case MEM:
1318       {
1319         rtx base = XEXP (in, 0);
1320
1321         switch (GET_CODE (base))
1322           {
1323           case REG:
1324             out[0] = adjust_address (in, DImode, 0);
1325             break;
1326           case POST_MODIFY:
1327             base = XEXP (base, 0);
1328             out[0] = adjust_address (in, DImode, 0);
1329             break;
1330
1331           /* Since we're changing the mode, we need to change to POST_MODIFY
1332              as well to preserve the size of the increment.  Either that or
1333              do the update in two steps, but we've already got this scratch
1334              register handy so let's use it.  */
1335           case POST_INC:
1336             base = XEXP (base, 0);
1337             out[0]
1338               = change_address (in, DImode,
1339                                 gen_rtx_POST_MODIFY
1340                                 (Pmode, base, plus_constant (base, 16)));
1341             break;
1342           case POST_DEC:
1343             base = XEXP (base, 0);
1344             out[0]
1345               = change_address (in, DImode,
1346                                 gen_rtx_POST_MODIFY
1347                                 (Pmode, base, plus_constant (base, -16)));
1348             break;
1349           default:
1350             abort ();
1351           }
1352
1353         if (scratch == NULL_RTX)
1354           abort ();
1355         out[1] = change_address (in, DImode, scratch);
1356         return gen_adddi3 (scratch, base, GEN_INT (8));
1357       }
1358
1359     case CONST_INT:
1360     case CONST_DOUBLE:
1361       split_double (in, &out[0], &out[1]);
1362       return NULL_RTX;
1363
1364     default:
1365       abort ();
1366     }
1367 }
1368
1369 /* ??? Fixing GR->FR TFmode moves during reload is hard.  You need to go
1370    through memory plus an extra GR scratch register.  Except that you can
1371    either get the first from SECONDARY_MEMORY_NEEDED or the second from
1372    SECONDARY_RELOAD_CLASS, but not both.
1373
1374    We got into problems in the first place by allowing a construct like
1375    (subreg:TF (reg:TI)), which we got from a union containing a long double.  
1376    This solution attempts to prevent this situation from occurring.  When
1377    we see something like the above, we spill the inner register to memory.  */
1378
1379 rtx
1380 spill_tfmode_operand (in, force)
1381      rtx in;
1382      int force;
1383 {
1384   if (GET_CODE (in) == SUBREG
1385       && GET_MODE (SUBREG_REG (in)) == TImode
1386       && GET_CODE (SUBREG_REG (in)) == REG)
1387     {
1388       rtx mem = gen_mem_addressof (SUBREG_REG (in), NULL_TREE, /*rescan=*/true);
1389       return gen_rtx_MEM (TFmode, copy_to_reg (XEXP (mem, 0)));
1390     }
1391   else if (force && GET_CODE (in) == REG)
1392     {
1393       rtx mem = gen_mem_addressof (in, NULL_TREE, /*rescan=*/true);
1394       return gen_rtx_MEM (TFmode, copy_to_reg (XEXP (mem, 0)));
1395     }
1396   else if (GET_CODE (in) == MEM
1397            && GET_CODE (XEXP (in, 0)) == ADDRESSOF)
1398     return change_address (in, TFmode, copy_to_reg (XEXP (in, 0)));
1399   else
1400     return in;
1401 }
1402
1403 /* Emit comparison instruction if necessary, returning the expression
1404    that holds the compare result in the proper mode.  */
1405
1406 rtx
1407 ia64_expand_compare (code, mode)
1408      enum rtx_code code;
1409      enum machine_mode mode;
1410 {
1411   rtx op0 = ia64_compare_op0, op1 = ia64_compare_op1;
1412   rtx cmp;
1413
1414   /* If we have a BImode input, then we already have a compare result, and
1415      do not need to emit another comparison.  */
1416   if (GET_MODE (op0) == BImode)
1417     {
1418       if ((code == NE || code == EQ) && op1 == const0_rtx)
1419         cmp = op0;
1420       else
1421         abort ();
1422     }
1423   else
1424     {
1425       cmp = gen_reg_rtx (BImode);
1426       emit_insn (gen_rtx_SET (VOIDmode, cmp,
1427                               gen_rtx_fmt_ee (code, BImode, op0, op1)));
1428       code = NE;
1429     }
1430
1431   return gen_rtx_fmt_ee (code, mode, cmp, const0_rtx);
1432 }
1433
1434 /* Emit the appropriate sequence for a call.  */
1435
1436 void
1437 ia64_expand_call (retval, addr, nextarg, sibcall_p)
1438      rtx retval;
1439      rtx addr;
1440      rtx nextarg ATTRIBUTE_UNUSED;
1441      int sibcall_p;
1442 {
1443   rtx insn, b0;
1444
1445   addr = XEXP (addr, 0);
1446   b0 = gen_rtx_REG (DImode, R_BR (0));
1447
1448   /* ??? Should do this for functions known to bind local too.  */
1449   if (TARGET_NO_PIC || TARGET_AUTO_PIC)
1450     {
1451       if (sibcall_p)
1452         insn = gen_sibcall_nogp (addr);
1453       else if (! retval)
1454         insn = gen_call_nogp (addr, b0);
1455       else
1456         insn = gen_call_value_nogp (retval, addr, b0);
1457       insn = emit_call_insn (insn);
1458     }
1459   else
1460     {
1461       if (sibcall_p)
1462         insn = gen_sibcall_gp (addr);
1463       else if (! retval)
1464         insn = gen_call_gp (addr, b0);
1465       else
1466         insn = gen_call_value_gp (retval, addr, b0);
1467       insn = emit_call_insn (insn);
1468
1469       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
1470     }
1471
1472   if (sibcall_p)
1473     {
1474       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), b0);
1475       use_reg (&CALL_INSN_FUNCTION_USAGE (insn),
1476                gen_rtx_REG (DImode, AR_PFS_REGNUM));
1477     }
1478 }
1479
1480 void
1481 ia64_reload_gp ()
1482 {
1483   rtx tmp;
1484
1485   if (current_frame_info.reg_save_gp)
1486     tmp = gen_rtx_REG (DImode, current_frame_info.reg_save_gp);
1487   else
1488     {
1489       HOST_WIDE_INT offset;
1490
1491       offset = (current_frame_info.spill_cfa_off
1492                 + current_frame_info.spill_size);
1493       if (frame_pointer_needed)
1494         {
1495           tmp = hard_frame_pointer_rtx;
1496           offset = -offset;
1497         }
1498       else
1499         {
1500           tmp = stack_pointer_rtx;
1501           offset = current_frame_info.total_size - offset;
1502         }
1503
1504       if (CONST_OK_FOR_I (offset))
1505         emit_insn (gen_adddi3 (pic_offset_table_rtx,
1506                                tmp, GEN_INT (offset)));
1507       else
1508         {
1509           emit_move_insn (pic_offset_table_rtx, GEN_INT (offset));
1510           emit_insn (gen_adddi3 (pic_offset_table_rtx,
1511                                  pic_offset_table_rtx, tmp));
1512         }
1513
1514       tmp = gen_rtx_MEM (DImode, pic_offset_table_rtx);
1515     }
1516
1517   emit_move_insn (pic_offset_table_rtx, tmp);
1518 }
1519
1520 void
1521 ia64_split_call (retval, addr, retaddr, scratch_r, scratch_b,
1522                  noreturn_p, sibcall_p)
1523      rtx retval, addr, retaddr, scratch_r, scratch_b;
1524      int noreturn_p, sibcall_p;
1525 {
1526   rtx insn;
1527   bool is_desc = false;
1528
1529   /* If we find we're calling through a register, then we're actually
1530      calling through a descriptor, so load up the values.  */
1531   if (REG_P (addr))
1532     {
1533       rtx tmp;
1534       bool addr_dead_p;
1535
1536       /* ??? We are currently constrained to *not* use peep2, because
1537          we can legitimiately change the global lifetime of the GP
1538          (in the form of killing where previously live).  This is 
1539          because a call through a descriptor doesn't use the previous
1540          value of the GP, while a direct call does, and we do not
1541          commit to either form until the split here.
1542
1543          That said, this means that we lack precise life info for
1544          whether ADDR is dead after this call.  This is not terribly
1545          important, since we can fix things up essentially for free
1546          with the POST_DEC below, but it's nice to not use it when we
1547          can immediately tell it's not necessary.  */
1548       addr_dead_p = ((noreturn_p || sibcall_p
1549                       || TEST_HARD_REG_BIT (regs_invalidated_by_call,
1550                                             REGNO (addr)))
1551                      && !FUNCTION_ARG_REGNO_P (REGNO (addr)));
1552
1553       /* Load the code address into scratch_b.  */
1554       tmp = gen_rtx_POST_INC (Pmode, addr);
1555       tmp = gen_rtx_MEM (Pmode, tmp);
1556       emit_move_insn (scratch_r, tmp);
1557       emit_move_insn (scratch_b, scratch_r);
1558
1559       /* Load the GP address.  If ADDR is not dead here, then we must
1560          revert the change made above via the POST_INCREMENT.  */
1561       if (!addr_dead_p)
1562         tmp = gen_rtx_POST_DEC (Pmode, addr);
1563       else
1564         tmp = addr;
1565       tmp = gen_rtx_MEM (Pmode, tmp);
1566       emit_move_insn (pic_offset_table_rtx, tmp);
1567
1568       is_desc = true;
1569       addr = scratch_b;
1570     }
1571
1572   if (sibcall_p)
1573     insn = gen_sibcall_nogp (addr);
1574   else if (retval)
1575     insn = gen_call_value_nogp (retval, addr, retaddr);
1576   else
1577     insn = gen_call_nogp (addr, retaddr);
1578   emit_call_insn (insn);
1579
1580   if ((!TARGET_CONST_GP || is_desc) && !noreturn_p && !sibcall_p)
1581     ia64_reload_gp ();
1582 }
1583 \f
1584 /* Begin the assembly file.  */
1585
1586 void
1587 emit_safe_across_calls (f)
1588      FILE *f;
1589 {
1590   unsigned int rs, re;
1591   int out_state;
1592
1593   rs = 1;
1594   out_state = 0;
1595   while (1)
1596     {
1597       while (rs < 64 && call_used_regs[PR_REG (rs)])
1598         rs++;
1599       if (rs >= 64)
1600         break;
1601       for (re = rs + 1; re < 64 && ! call_used_regs[PR_REG (re)]; re++)
1602         continue;
1603       if (out_state == 0)
1604         {
1605           fputs ("\t.pred.safe_across_calls ", f);
1606           out_state = 1;
1607         }
1608       else
1609         fputc (',', f);
1610       if (re == rs + 1)
1611         fprintf (f, "p%u", rs);
1612       else
1613         fprintf (f, "p%u-p%u", rs, re - 1);
1614       rs = re + 1;
1615     }
1616   if (out_state)
1617     fputc ('\n', f);
1618 }
1619
1620 /* Helper function for ia64_compute_frame_size: find an appropriate general
1621    register to spill some special register to.  SPECIAL_SPILL_MASK contains
1622    bits in GR0 to GR31 that have already been allocated by this routine.
1623    TRY_LOCALS is true if we should attempt to locate a local regnum.  */
1624
1625 static int
1626 find_gr_spill (try_locals)
1627      int try_locals;
1628 {
1629   int regno;
1630
1631   /* If this is a leaf function, first try an otherwise unused
1632      call-clobbered register.  */
1633   if (current_function_is_leaf)
1634     {
1635       for (regno = GR_REG (1); regno <= GR_REG (31); regno++)
1636         if (! regs_ever_live[regno]
1637             && call_used_regs[regno]
1638             && ! fixed_regs[regno]
1639             && ! global_regs[regno]
1640             && ((current_frame_info.gr_used_mask >> regno) & 1) == 0)
1641           {
1642             current_frame_info.gr_used_mask |= 1 << regno;
1643             return regno;
1644           }
1645     }
1646
1647   if (try_locals)
1648     {
1649       regno = current_frame_info.n_local_regs;
1650       /* If there is a frame pointer, then we can't use loc79, because
1651          that is HARD_FRAME_POINTER_REGNUM.  In particular, see the
1652          reg_name switching code in ia64_expand_prologue.  */
1653       if (regno < (80 - frame_pointer_needed))
1654         {
1655           current_frame_info.n_local_regs = regno + 1;
1656           return LOC_REG (0) + regno;
1657         }
1658     }
1659
1660   /* Failed to find a general register to spill to.  Must use stack.  */
1661   return 0;
1662 }
1663
1664 /* In order to make for nice schedules, we try to allocate every temporary
1665    to a different register.  We must of course stay away from call-saved,
1666    fixed, and global registers.  We must also stay away from registers
1667    allocated in current_frame_info.gr_used_mask, since those include regs
1668    used all through the prologue.
1669
1670    Any register allocated here must be used immediately.  The idea is to
1671    aid scheduling, not to solve data flow problems.  */
1672
1673 static int last_scratch_gr_reg;
1674
1675 static int
1676 next_scratch_gr_reg ()
1677 {
1678   int i, regno;
1679
1680   for (i = 0; i < 32; ++i)
1681     {
1682       regno = (last_scratch_gr_reg + i + 1) & 31;
1683       if (call_used_regs[regno]
1684           && ! fixed_regs[regno]
1685           && ! global_regs[regno]
1686           && ((current_frame_info.gr_used_mask >> regno) & 1) == 0)
1687         {
1688           last_scratch_gr_reg = regno;
1689           return regno;
1690         }
1691     }
1692
1693   /* There must be _something_ available.  */
1694   abort ();
1695 }
1696
1697 /* Helper function for ia64_compute_frame_size, called through
1698    diddle_return_value.  Mark REG in current_frame_info.gr_used_mask.  */
1699
1700 static void
1701 mark_reg_gr_used_mask (reg, data)
1702      rtx reg;
1703      void *data ATTRIBUTE_UNUSED;
1704 {
1705   unsigned int regno = REGNO (reg);
1706   if (regno < 32)
1707     {
1708       unsigned int i, n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
1709       for (i = 0; i < n; ++i)
1710         current_frame_info.gr_used_mask |= 1 << (regno + i);
1711     }
1712 }
1713
1714 /* Returns the number of bytes offset between the frame pointer and the stack
1715    pointer for the current function.  SIZE is the number of bytes of space
1716    needed for local variables.  */
1717
1718 static void
1719 ia64_compute_frame_size (size)
1720      HOST_WIDE_INT size;
1721 {
1722   HOST_WIDE_INT total_size;
1723   HOST_WIDE_INT spill_size = 0;
1724   HOST_WIDE_INT extra_spill_size = 0;
1725   HOST_WIDE_INT pretend_args_size;
1726   HARD_REG_SET mask;
1727   int n_spilled = 0;
1728   int spilled_gr_p = 0;
1729   int spilled_fr_p = 0;
1730   unsigned int regno;
1731   int i;
1732
1733   if (current_frame_info.initialized)
1734     return;
1735
1736   memset (&current_frame_info, 0, sizeof current_frame_info);
1737   CLEAR_HARD_REG_SET (mask);
1738
1739   /* Don't allocate scratches to the return register.  */
1740   diddle_return_value (mark_reg_gr_used_mask, NULL);
1741
1742   /* Don't allocate scratches to the EH scratch registers.  */
1743   if (cfun->machine->ia64_eh_epilogue_sp)
1744     mark_reg_gr_used_mask (cfun->machine->ia64_eh_epilogue_sp, NULL);
1745   if (cfun->machine->ia64_eh_epilogue_bsp)
1746     mark_reg_gr_used_mask (cfun->machine->ia64_eh_epilogue_bsp, NULL);
1747
1748   /* Find the size of the register stack frame.  We have only 80 local
1749      registers, because we reserve 8 for the inputs and 8 for the
1750      outputs.  */
1751
1752   /* Skip HARD_FRAME_POINTER_REGNUM (loc79) when frame_pointer_needed,
1753      since we'll be adjusting that down later.  */
1754   regno = LOC_REG (78) + ! frame_pointer_needed;
1755   for (; regno >= LOC_REG (0); regno--)
1756     if (regs_ever_live[regno])
1757       break;
1758   current_frame_info.n_local_regs = regno - LOC_REG (0) + 1;
1759
1760   /* For functions marked with the syscall_linkage attribute, we must mark
1761      all eight input registers as in use, so that locals aren't visible to
1762      the caller.  */
1763
1764   if (cfun->machine->n_varargs > 0
1765       || lookup_attribute ("syscall_linkage",
1766                            TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
1767     current_frame_info.n_input_regs = 8;
1768   else
1769     {
1770       for (regno = IN_REG (7); regno >= IN_REG (0); regno--)
1771         if (regs_ever_live[regno])
1772           break;
1773       current_frame_info.n_input_regs = regno - IN_REG (0) + 1;
1774     }
1775
1776   for (regno = OUT_REG (7); regno >= OUT_REG (0); regno--)
1777     if (regs_ever_live[regno])
1778       break;
1779   i = regno - OUT_REG (0) + 1;
1780
1781   /* When -p profiling, we need one output register for the mcount argument.
1782      Likewise for -a profiling for the bb_init_func argument.  For -ax
1783      profiling, we need two output registers for the two bb_init_trace_func
1784      arguments.  */
1785   if (current_function_profile)
1786     i = MAX (i, 1);
1787   current_frame_info.n_output_regs = i;
1788
1789   /* ??? No rotating register support yet.  */
1790   current_frame_info.n_rotate_regs = 0;
1791
1792   /* Discover which registers need spilling, and how much room that
1793      will take.  Begin with floating point and general registers, 
1794      which will always wind up on the stack.  */
1795
1796   for (regno = FR_REG (2); regno <= FR_REG (127); regno++)
1797     if (regs_ever_live[regno] && ! call_used_regs[regno])
1798       {
1799         SET_HARD_REG_BIT (mask, regno);
1800         spill_size += 16;
1801         n_spilled += 1;
1802         spilled_fr_p = 1;
1803       }
1804
1805   for (regno = GR_REG (1); regno <= GR_REG (31); regno++)
1806     if (regs_ever_live[regno] && ! call_used_regs[regno])
1807       {
1808         SET_HARD_REG_BIT (mask, regno);
1809         spill_size += 8;
1810         n_spilled += 1;
1811         spilled_gr_p = 1;
1812       }
1813
1814   for (regno = BR_REG (1); regno <= BR_REG (7); regno++)
1815     if (regs_ever_live[regno] && ! call_used_regs[regno])
1816       {
1817         SET_HARD_REG_BIT (mask, regno);
1818         spill_size += 8;
1819         n_spilled += 1;
1820       }
1821
1822   /* Now come all special registers that might get saved in other
1823      general registers.  */
1824   
1825   if (frame_pointer_needed)
1826     {
1827       current_frame_info.reg_fp = find_gr_spill (1);
1828       /* If we did not get a register, then we take LOC79.  This is guaranteed
1829          to be free, even if regs_ever_live is already set, because this is
1830          HARD_FRAME_POINTER_REGNUM.  This requires incrementing n_local_regs,
1831          as we don't count loc79 above.  */
1832       if (current_frame_info.reg_fp == 0)
1833         {
1834           current_frame_info.reg_fp = LOC_REG (79);
1835           current_frame_info.n_local_regs++;
1836         }
1837     }
1838
1839   if (! current_function_is_leaf)
1840     {
1841       /* Emit a save of BR0 if we call other functions.  Do this even
1842          if this function doesn't return, as EH depends on this to be
1843          able to unwind the stack.  */
1844       SET_HARD_REG_BIT (mask, BR_REG (0));
1845
1846       current_frame_info.reg_save_b0 = find_gr_spill (1);
1847       if (current_frame_info.reg_save_b0 == 0)
1848         {
1849           spill_size += 8;
1850           n_spilled += 1;
1851         }
1852
1853       /* Similarly for ar.pfs.  */
1854       SET_HARD_REG_BIT (mask, AR_PFS_REGNUM);
1855       current_frame_info.reg_save_ar_pfs = find_gr_spill (1);
1856       if (current_frame_info.reg_save_ar_pfs == 0)
1857         {
1858           extra_spill_size += 8;
1859           n_spilled += 1;
1860         }
1861
1862       /* Similarly for gp.  Note that if we're calling setjmp, the stacked
1863          registers are clobbered, so we fall back to the stack.  */
1864       current_frame_info.reg_save_gp
1865         = (current_function_calls_setjmp ? 0 : find_gr_spill (1));
1866       if (current_frame_info.reg_save_gp == 0)
1867         {
1868           SET_HARD_REG_BIT (mask, GR_REG (1));
1869           spill_size += 8;
1870           n_spilled += 1;
1871         }
1872     }
1873   else
1874     {
1875       if (regs_ever_live[BR_REG (0)] && ! call_used_regs[BR_REG (0)])
1876         {
1877           SET_HARD_REG_BIT (mask, BR_REG (0));
1878           spill_size += 8;
1879           n_spilled += 1;
1880         }
1881
1882       if (regs_ever_live[AR_PFS_REGNUM])
1883         {
1884           SET_HARD_REG_BIT (mask, AR_PFS_REGNUM);
1885           current_frame_info.reg_save_ar_pfs = find_gr_spill (1);
1886           if (current_frame_info.reg_save_ar_pfs == 0)
1887             {
1888               extra_spill_size += 8;
1889               n_spilled += 1;
1890             }
1891         }
1892     }
1893
1894   /* Unwind descriptor hackery: things are most efficient if we allocate
1895      consecutive GR save registers for RP, PFS, FP in that order. However,
1896      it is absolutely critical that FP get the only hard register that's
1897      guaranteed to be free, so we allocated it first.  If all three did
1898      happen to be allocated hard regs, and are consecutive, rearrange them
1899      into the preferred order now.  */
1900   if (current_frame_info.reg_fp != 0
1901       && current_frame_info.reg_save_b0 == current_frame_info.reg_fp + 1
1902       && current_frame_info.reg_save_ar_pfs == current_frame_info.reg_fp + 2)
1903     {
1904       current_frame_info.reg_save_b0 = current_frame_info.reg_fp;
1905       current_frame_info.reg_save_ar_pfs = current_frame_info.reg_fp + 1;
1906       current_frame_info.reg_fp = current_frame_info.reg_fp + 2;
1907     }
1908
1909   /* See if we need to store the predicate register block.  */
1910   for (regno = PR_REG (0); regno <= PR_REG (63); regno++)
1911     if (regs_ever_live[regno] && ! call_used_regs[regno])
1912       break;
1913   if (regno <= PR_REG (63))
1914     {
1915       SET_HARD_REG_BIT (mask, PR_REG (0));
1916       current_frame_info.reg_save_pr = find_gr_spill (1);
1917       if (current_frame_info.reg_save_pr == 0)
1918         {
1919           extra_spill_size += 8;
1920           n_spilled += 1;
1921         }
1922
1923       /* ??? Mark them all as used so that register renaming and such
1924          are free to use them.  */
1925       for (regno = PR_REG (0); regno <= PR_REG (63); regno++)
1926         regs_ever_live[regno] = 1;
1927     }
1928
1929   /* If we're forced to use st8.spill, we're forced to save and restore
1930      ar.unat as well.  The check for existing liveness allows inline asm
1931      to touch ar.unat.  */
1932   if (spilled_gr_p || cfun->machine->n_varargs
1933       || regs_ever_live[AR_UNAT_REGNUM])
1934     {
1935       regs_ever_live[AR_UNAT_REGNUM] = 1;
1936       SET_HARD_REG_BIT (mask, AR_UNAT_REGNUM);
1937       current_frame_info.reg_save_ar_unat = find_gr_spill (spill_size == 0);
1938       if (current_frame_info.reg_save_ar_unat == 0)
1939         {
1940           extra_spill_size += 8;
1941           n_spilled += 1;
1942         }
1943     }
1944
1945   if (regs_ever_live[AR_LC_REGNUM])
1946     {
1947       SET_HARD_REG_BIT (mask, AR_LC_REGNUM);
1948       current_frame_info.reg_save_ar_lc = find_gr_spill (spill_size == 0);
1949       if (current_frame_info.reg_save_ar_lc == 0)
1950         {
1951           extra_spill_size += 8;
1952           n_spilled += 1;
1953         }
1954     }
1955
1956   /* If we have an odd number of words of pretend arguments written to
1957      the stack, then the FR save area will be unaligned.  We round the
1958      size of this area up to keep things 16 byte aligned.  */
1959   if (spilled_fr_p)
1960     pretend_args_size = IA64_STACK_ALIGN (current_function_pretend_args_size);
1961   else
1962     pretend_args_size = current_function_pretend_args_size;
1963
1964   total_size = (spill_size + extra_spill_size + size + pretend_args_size
1965                 + current_function_outgoing_args_size);
1966   total_size = IA64_STACK_ALIGN (total_size);
1967
1968   /* We always use the 16-byte scratch area provided by the caller, but
1969      if we are a leaf function, there's no one to which we need to provide
1970      a scratch area.  */
1971   if (current_function_is_leaf)
1972     total_size = MAX (0, total_size - 16);
1973
1974   current_frame_info.total_size = total_size;
1975   current_frame_info.spill_cfa_off = pretend_args_size - 16;
1976   current_frame_info.spill_size = spill_size;
1977   current_frame_info.extra_spill_size = extra_spill_size;
1978   COPY_HARD_REG_SET (current_frame_info.mask, mask);
1979   current_frame_info.n_spilled = n_spilled;
1980   current_frame_info.initialized = reload_completed;
1981 }
1982
1983 /* Compute the initial difference between the specified pair of registers.  */
1984
1985 HOST_WIDE_INT
1986 ia64_initial_elimination_offset (from, to)
1987      int from, to;
1988 {
1989   HOST_WIDE_INT offset;
1990
1991   ia64_compute_frame_size (get_frame_size ());
1992   switch (from)
1993     {
1994     case FRAME_POINTER_REGNUM:
1995       if (to == HARD_FRAME_POINTER_REGNUM)
1996         {
1997           if (current_function_is_leaf)
1998             offset = -current_frame_info.total_size;
1999           else
2000             offset = -(current_frame_info.total_size
2001                        - current_function_outgoing_args_size - 16);
2002         }
2003       else if (to == STACK_POINTER_REGNUM)
2004         {
2005           if (current_function_is_leaf)
2006             offset = 0;
2007           else
2008             offset = 16 + current_function_outgoing_args_size;
2009         }
2010       else
2011         abort ();
2012       break;
2013
2014     case ARG_POINTER_REGNUM:
2015       /* Arguments start above the 16 byte save area, unless stdarg
2016          in which case we store through the 16 byte save area.  */
2017       if (to == HARD_FRAME_POINTER_REGNUM)
2018         offset = 16 - current_function_pretend_args_size;
2019       else if (to == STACK_POINTER_REGNUM)
2020         offset = (current_frame_info.total_size
2021                   + 16 - current_function_pretend_args_size);
2022       else
2023         abort ();
2024       break;
2025
2026     case RETURN_ADDRESS_POINTER_REGNUM:
2027       offset = 0;
2028       break;
2029
2030     default:
2031       abort ();
2032     }
2033
2034   return offset;
2035 }
2036
2037 /* If there are more than a trivial number of register spills, we use
2038    two interleaved iterators so that we can get two memory references
2039    per insn group.
2040
2041    In order to simplify things in the prologue and epilogue expanders,
2042    we use helper functions to fix up the memory references after the
2043    fact with the appropriate offsets to a POST_MODIFY memory mode.
2044    The following data structure tracks the state of the two iterators
2045    while insns are being emitted.  */
2046
2047 struct spill_fill_data
2048 {
2049   rtx init_after;               /* point at which to emit initializations */
2050   rtx init_reg[2];              /* initial base register */
2051   rtx iter_reg[2];              /* the iterator registers */
2052   rtx *prev_addr[2];            /* address of last memory use */
2053   rtx prev_insn[2];             /* the insn corresponding to prev_addr */
2054   HOST_WIDE_INT prev_off[2];    /* last offset */
2055   int n_iter;                   /* number of iterators in use */
2056   int next_iter;                /* next iterator to use */
2057   unsigned int save_gr_used_mask;
2058 };
2059
2060 static struct spill_fill_data spill_fill_data;
2061
2062 static void
2063 setup_spill_pointers (n_spills, init_reg, cfa_off)
2064      int n_spills;
2065      rtx init_reg;
2066      HOST_WIDE_INT cfa_off;
2067 {
2068   int i;
2069
2070   spill_fill_data.init_after = get_last_insn ();
2071   spill_fill_data.init_reg[0] = init_reg;
2072   spill_fill_data.init_reg[1] = init_reg;
2073   spill_fill_data.prev_addr[0] = NULL;
2074   spill_fill_data.prev_addr[1] = NULL;
2075   spill_fill_data.prev_insn[0] = NULL;
2076   spill_fill_data.prev_insn[1] = NULL;
2077   spill_fill_data.prev_off[0] = cfa_off;
2078   spill_fill_data.prev_off[1] = cfa_off;
2079   spill_fill_data.next_iter = 0;
2080   spill_fill_data.save_gr_used_mask = current_frame_info.gr_used_mask;
2081
2082   spill_fill_data.n_iter = 1 + (n_spills > 2);
2083   for (i = 0; i < spill_fill_data.n_iter; ++i)
2084     {
2085       int regno = next_scratch_gr_reg ();
2086       spill_fill_data.iter_reg[i] = gen_rtx_REG (DImode, regno);
2087       current_frame_info.gr_used_mask |= 1 << regno;
2088     }
2089 }
2090
2091 static void
2092 finish_spill_pointers ()
2093 {
2094   current_frame_info.gr_used_mask = spill_fill_data.save_gr_used_mask;
2095 }
2096
2097 static rtx
2098 spill_restore_mem (reg, cfa_off)
2099      rtx reg;
2100      HOST_WIDE_INT cfa_off;
2101 {
2102   int iter = spill_fill_data.next_iter;
2103   HOST_WIDE_INT disp = spill_fill_data.prev_off[iter] - cfa_off;
2104   rtx disp_rtx = GEN_INT (disp);
2105   rtx mem;
2106
2107   if (spill_fill_data.prev_addr[iter])
2108     {
2109       if (CONST_OK_FOR_N (disp))
2110         {
2111           *spill_fill_data.prev_addr[iter]
2112             = gen_rtx_POST_MODIFY (DImode, spill_fill_data.iter_reg[iter],
2113                                    gen_rtx_PLUS (DImode,
2114                                                  spill_fill_data.iter_reg[iter],
2115                                                  disp_rtx));
2116           REG_NOTES (spill_fill_data.prev_insn[iter])
2117             = gen_rtx_EXPR_LIST (REG_INC, spill_fill_data.iter_reg[iter],
2118                                  REG_NOTES (spill_fill_data.prev_insn[iter]));
2119         }
2120       else
2121         {
2122           /* ??? Could use register post_modify for loads.  */
2123           if (! CONST_OK_FOR_I (disp))
2124             {
2125               rtx tmp = gen_rtx_REG (DImode, next_scratch_gr_reg ());
2126               emit_move_insn (tmp, disp_rtx);
2127               disp_rtx = tmp;
2128             }
2129           emit_insn (gen_adddi3 (spill_fill_data.iter_reg[iter],
2130                                  spill_fill_data.iter_reg[iter], disp_rtx));
2131         }
2132     }
2133   /* Micro-optimization: if we've created a frame pointer, it's at
2134      CFA 0, which may allow the real iterator to be initialized lower,
2135      slightly increasing parallelism.  Also, if there are few saves
2136      it may eliminate the iterator entirely.  */
2137   else if (disp == 0
2138            && spill_fill_data.init_reg[iter] == stack_pointer_rtx
2139            && frame_pointer_needed)
2140     {
2141       mem = gen_rtx_MEM (GET_MODE (reg), hard_frame_pointer_rtx);
2142       set_mem_alias_set (mem, get_varargs_alias_set ());
2143       return mem;
2144     }
2145   else
2146     {
2147       rtx seq, insn;
2148
2149       if (disp == 0)
2150         seq = gen_movdi (spill_fill_data.iter_reg[iter],
2151                          spill_fill_data.init_reg[iter]);
2152       else
2153         {
2154           start_sequence ();
2155
2156           if (! CONST_OK_FOR_I (disp))
2157             {
2158               rtx tmp = gen_rtx_REG (DImode, next_scratch_gr_reg ());
2159               emit_move_insn (tmp, disp_rtx);
2160               disp_rtx = tmp;
2161             }
2162
2163           emit_insn (gen_adddi3 (spill_fill_data.iter_reg[iter],
2164                                  spill_fill_data.init_reg[iter],
2165                                  disp_rtx));
2166
2167           seq = get_insns ();
2168           end_sequence ();
2169         }
2170
2171       /* Careful for being the first insn in a sequence.  */
2172       if (spill_fill_data.init_after)
2173         insn = emit_insn_after (seq, spill_fill_data.init_after);
2174       else
2175         {
2176           rtx first = get_insns ();
2177           if (first)
2178             insn = emit_insn_before (seq, first);
2179           else
2180             insn = emit_insn (seq);
2181         }
2182       spill_fill_data.init_after = insn;
2183
2184       /* If DISP is 0, we may or may not have a further adjustment
2185          afterward.  If we do, then the load/store insn may be modified
2186          to be a post-modify.  If we don't, then this copy may be
2187          eliminated by copyprop_hardreg_forward, which makes this
2188          insn garbage, which runs afoul of the sanity check in
2189          propagate_one_insn.  So mark this insn as legal to delete.  */
2190       if (disp == 0)
2191         REG_NOTES(insn) = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD, const0_rtx,
2192                                              REG_NOTES (insn));
2193     }
2194
2195   mem = gen_rtx_MEM (GET_MODE (reg), spill_fill_data.iter_reg[iter]);
2196
2197   /* ??? Not all of the spills are for varargs, but some of them are.
2198      The rest of the spills belong in an alias set of their own.  But
2199      it doesn't actually hurt to include them here.  */
2200   set_mem_alias_set (mem, get_varargs_alias_set ());
2201
2202   spill_fill_data.prev_addr[iter] = &XEXP (mem, 0);
2203   spill_fill_data.prev_off[iter] = cfa_off;
2204
2205   if (++iter >= spill_fill_data.n_iter)
2206     iter = 0;
2207   spill_fill_data.next_iter = iter;
2208
2209   return mem;
2210 }
2211
2212 static void
2213 do_spill (move_fn, reg, cfa_off, frame_reg)
2214      rtx (*move_fn) PARAMS ((rtx, rtx, rtx));
2215      rtx reg, frame_reg;
2216      HOST_WIDE_INT cfa_off;
2217 {
2218   int iter = spill_fill_data.next_iter;
2219   rtx mem, insn;
2220
2221   mem = spill_restore_mem (reg, cfa_off);
2222   insn = emit_insn ((*move_fn) (mem, reg, GEN_INT (cfa_off)));
2223   spill_fill_data.prev_insn[iter] = insn;
2224
2225   if (frame_reg)
2226     {
2227       rtx base;
2228       HOST_WIDE_INT off;
2229
2230       RTX_FRAME_RELATED_P (insn) = 1;
2231
2232       /* Don't even pretend that the unwind code can intuit its way 
2233          through a pair of interleaved post_modify iterators.  Just
2234          provide the correct answer.  */
2235
2236       if (frame_pointer_needed)
2237         {
2238           base = hard_frame_pointer_rtx;
2239           off = - cfa_off;
2240         }
2241       else
2242         {
2243           base = stack_pointer_rtx;
2244           off = current_frame_info.total_size - cfa_off;
2245         }
2246
2247       REG_NOTES (insn)
2248         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2249                 gen_rtx_SET (VOIDmode,
2250                              gen_rtx_MEM (GET_MODE (reg),
2251                                           plus_constant (base, off)),
2252                              frame_reg),
2253                 REG_NOTES (insn));
2254     }
2255 }
2256
2257 static void
2258 do_restore (move_fn, reg, cfa_off)
2259      rtx (*move_fn) PARAMS ((rtx, rtx, rtx));
2260      rtx reg;
2261      HOST_WIDE_INT cfa_off;
2262 {
2263   int iter = spill_fill_data.next_iter;
2264   rtx insn;
2265
2266   insn = emit_insn ((*move_fn) (reg, spill_restore_mem (reg, cfa_off),
2267                                 GEN_INT (cfa_off)));
2268   spill_fill_data.prev_insn[iter] = insn;
2269 }
2270
2271 /* Wrapper functions that discards the CONST_INT spill offset.  These
2272    exist so that we can give gr_spill/gr_fill the offset they need and
2273    use a consistent function interface.  */
2274
2275 static rtx
2276 gen_movdi_x (dest, src, offset)
2277      rtx dest, src;
2278      rtx offset ATTRIBUTE_UNUSED;
2279 {
2280   return gen_movdi (dest, src);
2281 }
2282
2283 static rtx
2284 gen_fr_spill_x (dest, src, offset)
2285      rtx dest, src;
2286      rtx offset ATTRIBUTE_UNUSED;
2287 {
2288   return gen_fr_spill (dest, src);
2289 }
2290
2291 static rtx
2292 gen_fr_restore_x (dest, src, offset)
2293      rtx dest, src;
2294      rtx offset ATTRIBUTE_UNUSED;
2295 {
2296   return gen_fr_restore (dest, src);
2297 }
2298
2299 /* Called after register allocation to add any instructions needed for the
2300    prologue.  Using a prologue insn is favored compared to putting all of the
2301    instructions in output_function_prologue(), since it allows the scheduler
2302    to intermix instructions with the saves of the caller saved registers.  In
2303    some cases, it might be necessary to emit a barrier instruction as the last
2304    insn to prevent such scheduling.
2305
2306    Also any insns generated here should have RTX_FRAME_RELATED_P(insn) = 1
2307    so that the debug info generation code can handle them properly.
2308
2309    The register save area is layed out like so:
2310    cfa+16
2311         [ varargs spill area ]
2312         [ fr register spill area ]
2313         [ br register spill area ]
2314         [ ar register spill area ]
2315         [ pr register spill area ]
2316         [ gr register spill area ] */
2317
2318 /* ??? Get inefficient code when the frame size is larger than can fit in an
2319    adds instruction.  */
2320
2321 void
2322 ia64_expand_prologue ()
2323 {
2324   rtx insn, ar_pfs_save_reg, ar_unat_save_reg;
2325   int i, epilogue_p, regno, alt_regno, cfa_off, n_varargs;
2326   rtx reg, alt_reg;
2327
2328   ia64_compute_frame_size (get_frame_size ());
2329   last_scratch_gr_reg = 15;
2330
2331   /* If there is no epilogue, then we don't need some prologue insns.
2332      We need to avoid emitting the dead prologue insns, because flow
2333      will complain about them.  */
2334   if (optimize)
2335     {
2336       edge e;
2337
2338       for (e = EXIT_BLOCK_PTR->pred; e ; e = e->pred_next)
2339         if ((e->flags & EDGE_FAKE) == 0
2340             && (e->flags & EDGE_FALLTHRU) != 0)
2341           break;
2342       epilogue_p = (e != NULL);
2343     }
2344   else
2345     epilogue_p = 1;
2346
2347   /* Set the local, input, and output register names.  We need to do this
2348      for GNU libc, which creates crti.S/crtn.S by splitting initfini.c in
2349      half.  If we use in/loc/out register names, then we get assembler errors
2350      in crtn.S because there is no alloc insn or regstk directive in there.  */
2351   if (! TARGET_REG_NAMES)
2352     {
2353       int inputs = current_frame_info.n_input_regs;
2354       int locals = current_frame_info.n_local_regs;
2355       int outputs = current_frame_info.n_output_regs;
2356
2357       for (i = 0; i < inputs; i++)
2358         reg_names[IN_REG (i)] = ia64_reg_numbers[i];
2359       for (i = 0; i < locals; i++)
2360         reg_names[LOC_REG (i)] = ia64_reg_numbers[inputs + i];
2361       for (i = 0; i < outputs; i++)
2362         reg_names[OUT_REG (i)] = ia64_reg_numbers[inputs + locals + i];
2363     }
2364
2365   /* Set the frame pointer register name.  The regnum is logically loc79,
2366      but of course we'll not have allocated that many locals.  Rather than
2367      worrying about renumbering the existing rtxs, we adjust the name.  */
2368   /* ??? This code means that we can never use one local register when
2369      there is a frame pointer.  loc79 gets wasted in this case, as it is
2370      renamed to a register that will never be used.  See also the try_locals
2371      code in find_gr_spill.  */
2372   if (current_frame_info.reg_fp)
2373     {
2374       const char *tmp = reg_names[HARD_FRAME_POINTER_REGNUM];
2375       reg_names[HARD_FRAME_POINTER_REGNUM]
2376         = reg_names[current_frame_info.reg_fp];
2377       reg_names[current_frame_info.reg_fp] = tmp;
2378     }
2379
2380   /* Fix up the return address placeholder.  */
2381   /* ??? We can fail if __builtin_return_address is used, and we didn't
2382      allocate a register in which to save b0.  I can't think of a way to
2383      eliminate RETURN_ADDRESS_POINTER_REGNUM to a local register and
2384      then be sure that I got the right one.  Further, reload doesn't seem
2385      to care if an eliminable register isn't used, and "eliminates" it
2386      anyway.  */
2387   if (regs_ever_live[RETURN_ADDRESS_POINTER_REGNUM]
2388       && current_frame_info.reg_save_b0 != 0)
2389     XINT (return_address_pointer_rtx, 0) = current_frame_info.reg_save_b0;
2390
2391   /* We don't need an alloc instruction if we've used no outputs or locals.  */
2392   if (current_frame_info.n_local_regs == 0
2393       && current_frame_info.n_output_regs == 0
2394       && current_frame_info.n_input_regs <= current_function_args_info.int_regs
2395       && !TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM))
2396     {
2397       /* If there is no alloc, but there are input registers used, then we
2398          need a .regstk directive.  */
2399       current_frame_info.need_regstk = (TARGET_REG_NAMES != 0);
2400       ar_pfs_save_reg = NULL_RTX;
2401     }
2402   else
2403     {
2404       current_frame_info.need_regstk = 0;
2405
2406       if (current_frame_info.reg_save_ar_pfs)
2407         regno = current_frame_info.reg_save_ar_pfs;
2408       else
2409         regno = next_scratch_gr_reg ();
2410       ar_pfs_save_reg = gen_rtx_REG (DImode, regno);
2411
2412       insn = emit_insn (gen_alloc (ar_pfs_save_reg, 
2413                                    GEN_INT (current_frame_info.n_input_regs),
2414                                    GEN_INT (current_frame_info.n_local_regs),
2415                                    GEN_INT (current_frame_info.n_output_regs),
2416                                    GEN_INT (current_frame_info.n_rotate_regs)));
2417       RTX_FRAME_RELATED_P (insn) = (current_frame_info.reg_save_ar_pfs != 0);
2418     }
2419
2420   /* Set up frame pointer, stack pointer, and spill iterators.  */
2421
2422   n_varargs = cfun->machine->n_varargs;
2423   setup_spill_pointers (current_frame_info.n_spilled + n_varargs,
2424                         stack_pointer_rtx, 0);
2425
2426   if (frame_pointer_needed)
2427     {
2428       insn = emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
2429       RTX_FRAME_RELATED_P (insn) = 1;
2430     }
2431
2432   if (current_frame_info.total_size != 0)
2433     {
2434       rtx frame_size_rtx = GEN_INT (- current_frame_info.total_size);
2435       rtx offset;
2436
2437       if (CONST_OK_FOR_I (- current_frame_info.total_size))
2438         offset = frame_size_rtx;
2439       else
2440         {
2441           regno = next_scratch_gr_reg ();
2442           offset = gen_rtx_REG (DImode, regno);
2443           emit_move_insn (offset, frame_size_rtx);
2444         }
2445
2446       insn = emit_insn (gen_adddi3 (stack_pointer_rtx,
2447                                     stack_pointer_rtx, offset));
2448
2449       if (! frame_pointer_needed)
2450         {
2451           RTX_FRAME_RELATED_P (insn) = 1;
2452           if (GET_CODE (offset) != CONST_INT)
2453             {
2454               REG_NOTES (insn)
2455                 = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2456                         gen_rtx_SET (VOIDmode,
2457                                      stack_pointer_rtx,
2458                                      gen_rtx_PLUS (DImode,
2459                                                    stack_pointer_rtx,
2460                                                    frame_size_rtx)),
2461                         REG_NOTES (insn));
2462             }
2463         }
2464
2465       /* ??? At this point we must generate a magic insn that appears to
2466          modify the stack pointer, the frame pointer, and all spill
2467          iterators.  This would allow the most scheduling freedom.  For
2468          now, just hard stop.  */
2469       emit_insn (gen_blockage ());
2470     }
2471
2472   /* Must copy out ar.unat before doing any integer spills.  */
2473   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
2474     {
2475       if (current_frame_info.reg_save_ar_unat)
2476         ar_unat_save_reg
2477           = gen_rtx_REG (DImode, current_frame_info.reg_save_ar_unat);
2478       else
2479         {
2480           alt_regno = next_scratch_gr_reg ();
2481           ar_unat_save_reg = gen_rtx_REG (DImode, alt_regno);
2482           current_frame_info.gr_used_mask |= 1 << alt_regno;
2483         }
2484
2485       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
2486       insn = emit_move_insn (ar_unat_save_reg, reg);
2487       RTX_FRAME_RELATED_P (insn) = (current_frame_info.reg_save_ar_unat != 0);
2488
2489       /* Even if we're not going to generate an epilogue, we still
2490          need to save the register so that EH works.  */
2491       if (! epilogue_p && current_frame_info.reg_save_ar_unat)
2492         emit_insn (gen_prologue_use (ar_unat_save_reg));
2493     }
2494   else
2495     ar_unat_save_reg = NULL_RTX;
2496
2497   /* Spill all varargs registers.  Do this before spilling any GR registers,
2498      since we want the UNAT bits for the GR registers to override the UNAT
2499      bits from varargs, which we don't care about.  */
2500
2501   cfa_off = -16;
2502   for (regno = GR_ARG_FIRST + 7; n_varargs > 0; --n_varargs, --regno)
2503     {
2504       reg = gen_rtx_REG (DImode, regno);
2505       do_spill (gen_gr_spill, reg, cfa_off += 8, NULL_RTX);
2506     }
2507
2508   /* Locate the bottom of the register save area.  */
2509   cfa_off = (current_frame_info.spill_cfa_off
2510              + current_frame_info.spill_size
2511              + current_frame_info.extra_spill_size);
2512
2513   /* Save the predicate register block either in a register or in memory.  */
2514   if (TEST_HARD_REG_BIT (current_frame_info.mask, PR_REG (0)))
2515     {
2516       reg = gen_rtx_REG (DImode, PR_REG (0));
2517       if (current_frame_info.reg_save_pr != 0)
2518         {
2519           alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_pr);
2520           insn = emit_move_insn (alt_reg, reg);
2521
2522           /* ??? Denote pr spill/fill by a DImode move that modifies all
2523              64 hard registers.  */
2524           RTX_FRAME_RELATED_P (insn) = 1;
2525           REG_NOTES (insn)
2526             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2527                         gen_rtx_SET (VOIDmode, alt_reg, reg),
2528                         REG_NOTES (insn));
2529
2530           /* Even if we're not going to generate an epilogue, we still
2531              need to save the register so that EH works.  */
2532           if (! epilogue_p)
2533             emit_insn (gen_prologue_use (alt_reg));
2534         }
2535       else
2536         {
2537           alt_regno = next_scratch_gr_reg ();
2538           alt_reg = gen_rtx_REG (DImode, alt_regno);
2539           insn = emit_move_insn (alt_reg, reg);
2540           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
2541           cfa_off -= 8;
2542         }
2543     }
2544
2545   /* Handle AR regs in numerical order.  All of them get special handling.  */
2546   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM)
2547       && current_frame_info.reg_save_ar_unat == 0)
2548     {
2549       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
2550       do_spill (gen_movdi_x, ar_unat_save_reg, cfa_off, reg);
2551       cfa_off -= 8;
2552     }
2553
2554   /* The alloc insn already copied ar.pfs into a general register.  The
2555      only thing we have to do now is copy that register to a stack slot
2556      if we'd not allocated a local register for the job.  */
2557   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_PFS_REGNUM)
2558       && current_frame_info.reg_save_ar_pfs == 0)
2559     {
2560       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
2561       do_spill (gen_movdi_x, ar_pfs_save_reg, cfa_off, reg);
2562       cfa_off -= 8;
2563     }
2564
2565   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_LC_REGNUM))
2566     {
2567       reg = gen_rtx_REG (DImode, AR_LC_REGNUM);
2568       if (current_frame_info.reg_save_ar_lc != 0)
2569         {
2570           alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_ar_lc);
2571           insn = emit_move_insn (alt_reg, reg);
2572           RTX_FRAME_RELATED_P (insn) = 1;
2573
2574           /* Even if we're not going to generate an epilogue, we still
2575              need to save the register so that EH works.  */
2576           if (! epilogue_p)
2577             emit_insn (gen_prologue_use (alt_reg));
2578         }
2579       else
2580         {
2581           alt_regno = next_scratch_gr_reg ();
2582           alt_reg = gen_rtx_REG (DImode, alt_regno);
2583           emit_move_insn (alt_reg, reg);
2584           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
2585           cfa_off -= 8;
2586         }
2587     }
2588
2589   if (current_frame_info.reg_save_gp)
2590     {
2591       insn = emit_move_insn (gen_rtx_REG (DImode,
2592                                           current_frame_info.reg_save_gp),
2593                              pic_offset_table_rtx);
2594       /* We don't know for sure yet if this is actually needed, since
2595          we've not split the PIC call patterns.  If all of the calls
2596          are indirect, and not followed by any uses of the gp, then
2597          this save is dead.  Allow it to go away.  */
2598       REG_NOTES (insn)
2599         = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD, const0_rtx, REG_NOTES (insn));
2600     }
2601
2602   /* We should now be at the base of the gr/br/fr spill area.  */
2603   if (cfa_off != (current_frame_info.spill_cfa_off
2604                   + current_frame_info.spill_size))
2605     abort ();
2606
2607   /* Spill all general registers.  */
2608   for (regno = GR_REG (1); regno <= GR_REG (31); ++regno)
2609     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2610       {
2611         reg = gen_rtx_REG (DImode, regno);
2612         do_spill (gen_gr_spill, reg, cfa_off, reg);
2613         cfa_off -= 8;
2614       }
2615
2616   /* Handle BR0 specially -- it may be getting stored permanently in
2617      some GR register.  */
2618   if (TEST_HARD_REG_BIT (current_frame_info.mask, BR_REG (0)))
2619     {
2620       reg = gen_rtx_REG (DImode, BR_REG (0));
2621       if (current_frame_info.reg_save_b0 != 0)
2622         {
2623           alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_b0);
2624           insn = emit_move_insn (alt_reg, reg);
2625           RTX_FRAME_RELATED_P (insn) = 1;
2626
2627           /* Even if we're not going to generate an epilogue, we still
2628              need to save the register so that EH works.  */
2629           if (! epilogue_p)
2630             emit_insn (gen_prologue_use (alt_reg));
2631         }
2632       else
2633         {
2634           alt_regno = next_scratch_gr_reg ();
2635           alt_reg = gen_rtx_REG (DImode, alt_regno);
2636           emit_move_insn (alt_reg, reg);
2637           do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
2638           cfa_off -= 8;
2639         }
2640     }
2641
2642   /* Spill the rest of the BR registers.  */
2643   for (regno = BR_REG (1); regno <= BR_REG (7); ++regno)
2644     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2645       {
2646         alt_regno = next_scratch_gr_reg ();
2647         alt_reg = gen_rtx_REG (DImode, alt_regno);
2648         reg = gen_rtx_REG (DImode, regno);
2649         emit_move_insn (alt_reg, reg);
2650         do_spill (gen_movdi_x, alt_reg, cfa_off, reg);
2651         cfa_off -= 8;
2652       }
2653
2654   /* Align the frame and spill all FR registers.  */
2655   for (regno = FR_REG (2); regno <= FR_REG (127); ++regno)
2656     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2657       {
2658         if (cfa_off & 15)
2659           abort ();
2660         reg = gen_rtx_REG (TFmode, regno);
2661         do_spill (gen_fr_spill_x, reg, cfa_off, reg);
2662         cfa_off -= 16;
2663       }
2664
2665   if (cfa_off != current_frame_info.spill_cfa_off)
2666     abort ();
2667
2668   finish_spill_pointers ();
2669 }
2670
2671 /* Called after register allocation to add any instructions needed for the
2672    epilogue.  Using an epilogue insn is favored compared to putting all of the
2673    instructions in output_function_prologue(), since it allows the scheduler
2674    to intermix instructions with the saves of the caller saved registers.  In
2675    some cases, it might be necessary to emit a barrier instruction as the last
2676    insn to prevent such scheduling.  */
2677
2678 void
2679 ia64_expand_epilogue (sibcall_p)
2680      int sibcall_p;
2681 {
2682   rtx insn, reg, alt_reg, ar_unat_save_reg;
2683   int regno, alt_regno, cfa_off;
2684
2685   ia64_compute_frame_size (get_frame_size ());
2686
2687   /* If there is a frame pointer, then we use it instead of the stack
2688      pointer, so that the stack pointer does not need to be valid when
2689      the epilogue starts.  See EXIT_IGNORE_STACK.  */
2690   if (frame_pointer_needed)
2691     setup_spill_pointers (current_frame_info.n_spilled,
2692                           hard_frame_pointer_rtx, 0);
2693   else
2694     setup_spill_pointers (current_frame_info.n_spilled, stack_pointer_rtx, 
2695                           current_frame_info.total_size);
2696
2697   if (current_frame_info.total_size != 0)
2698     {
2699       /* ??? At this point we must generate a magic insn that appears to
2700          modify the spill iterators and the frame pointer.  This would
2701          allow the most scheduling freedom.  For now, just hard stop.  */
2702       emit_insn (gen_blockage ());
2703     }
2704
2705   /* Locate the bottom of the register save area.  */
2706   cfa_off = (current_frame_info.spill_cfa_off
2707              + current_frame_info.spill_size
2708              + current_frame_info.extra_spill_size);
2709
2710   /* Restore the predicate registers.  */
2711   if (TEST_HARD_REG_BIT (current_frame_info.mask, PR_REG (0)))
2712     {
2713       if (current_frame_info.reg_save_pr != 0)
2714         alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_pr);
2715       else
2716         {
2717           alt_regno = next_scratch_gr_reg ();
2718           alt_reg = gen_rtx_REG (DImode, alt_regno);
2719           do_restore (gen_movdi_x, alt_reg, cfa_off);
2720           cfa_off -= 8;
2721         }
2722       reg = gen_rtx_REG (DImode, PR_REG (0));
2723       emit_move_insn (reg, alt_reg);
2724     }
2725
2726   /* Restore the application registers.  */
2727
2728   /* Load the saved unat from the stack, but do not restore it until
2729      after the GRs have been restored.  */
2730   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
2731     {
2732       if (current_frame_info.reg_save_ar_unat != 0)
2733         ar_unat_save_reg
2734           = gen_rtx_REG (DImode, current_frame_info.reg_save_ar_unat);
2735       else
2736         {
2737           alt_regno = next_scratch_gr_reg ();
2738           ar_unat_save_reg = gen_rtx_REG (DImode, alt_regno);
2739           current_frame_info.gr_used_mask |= 1 << alt_regno;
2740           do_restore (gen_movdi_x, ar_unat_save_reg, cfa_off);
2741           cfa_off -= 8;
2742         }
2743     }
2744   else
2745     ar_unat_save_reg = NULL_RTX;
2746       
2747   if (current_frame_info.reg_save_ar_pfs != 0)
2748     {
2749       alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_ar_pfs);
2750       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
2751       emit_move_insn (reg, alt_reg);
2752     }
2753   else if (! current_function_is_leaf)
2754     {
2755       alt_regno = next_scratch_gr_reg ();
2756       alt_reg = gen_rtx_REG (DImode, alt_regno);
2757       do_restore (gen_movdi_x, alt_reg, cfa_off);
2758       cfa_off -= 8;
2759       reg = gen_rtx_REG (DImode, AR_PFS_REGNUM);
2760       emit_move_insn (reg, alt_reg);
2761     }
2762
2763   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_LC_REGNUM))
2764     {
2765       if (current_frame_info.reg_save_ar_lc != 0)
2766         alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_ar_lc);
2767       else
2768         {
2769           alt_regno = next_scratch_gr_reg ();
2770           alt_reg = gen_rtx_REG (DImode, alt_regno);
2771           do_restore (gen_movdi_x, alt_reg, cfa_off);
2772           cfa_off -= 8;
2773         }
2774       reg = gen_rtx_REG (DImode, AR_LC_REGNUM);
2775       emit_move_insn (reg, alt_reg);
2776     }
2777
2778   /* We should now be at the base of the gr/br/fr spill area.  */
2779   if (cfa_off != (current_frame_info.spill_cfa_off
2780                   + current_frame_info.spill_size))
2781     abort ();
2782
2783   /* The GP may be stored on the stack in the prologue, but it's
2784      never restored in the epilogue.  Skip the stack slot.  */
2785   if (TEST_HARD_REG_BIT (current_frame_info.mask, GR_REG (1)))
2786     cfa_off -= 8;
2787
2788   /* Restore all general registers.  */
2789   for (regno = GR_REG (2); regno <= GR_REG (31); ++regno)
2790     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2791       {
2792         reg = gen_rtx_REG (DImode, regno);
2793         do_restore (gen_gr_restore, reg, cfa_off);
2794         cfa_off -= 8;
2795       }
2796   
2797   /* Restore the branch registers.  Handle B0 specially, as it may
2798      have gotten stored in some GR register.  */
2799   if (TEST_HARD_REG_BIT (current_frame_info.mask, BR_REG (0)))
2800     {
2801       if (current_frame_info.reg_save_b0 != 0)
2802         alt_reg = gen_rtx_REG (DImode, current_frame_info.reg_save_b0);
2803       else
2804         {
2805           alt_regno = next_scratch_gr_reg ();
2806           alt_reg = gen_rtx_REG (DImode, alt_regno);
2807           do_restore (gen_movdi_x, alt_reg, cfa_off);
2808           cfa_off -= 8;
2809         }
2810       reg = gen_rtx_REG (DImode, BR_REG (0));
2811       emit_move_insn (reg, alt_reg);
2812     }
2813     
2814   for (regno = BR_REG (1); regno <= BR_REG (7); ++regno)
2815     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2816       {
2817         alt_regno = next_scratch_gr_reg ();
2818         alt_reg = gen_rtx_REG (DImode, alt_regno);
2819         do_restore (gen_movdi_x, alt_reg, cfa_off);
2820         cfa_off -= 8;
2821         reg = gen_rtx_REG (DImode, regno);
2822         emit_move_insn (reg, alt_reg);
2823       }
2824
2825   /* Restore floating point registers.  */
2826   for (regno = FR_REG (2); regno <= FR_REG (127); ++regno)
2827     if (TEST_HARD_REG_BIT (current_frame_info.mask, regno))
2828       {
2829         if (cfa_off & 15)
2830           abort ();
2831         reg = gen_rtx_REG (TFmode, regno);
2832         do_restore (gen_fr_restore_x, reg, cfa_off);
2833         cfa_off -= 16;
2834       }
2835
2836   /* Restore ar.unat for real.  */
2837   if (TEST_HARD_REG_BIT (current_frame_info.mask, AR_UNAT_REGNUM))
2838     {
2839       reg = gen_rtx_REG (DImode, AR_UNAT_REGNUM);
2840       emit_move_insn (reg, ar_unat_save_reg);
2841     }
2842
2843   if (cfa_off != current_frame_info.spill_cfa_off)
2844     abort ();
2845
2846   finish_spill_pointers ();
2847
2848   if (current_frame_info.total_size || cfun->machine->ia64_eh_epilogue_sp)
2849     {
2850       /* ??? At this point we must generate a magic insn that appears to
2851          modify the spill iterators, the stack pointer, and the frame
2852          pointer.  This would allow the most scheduling freedom.  For now,
2853          just hard stop.  */
2854       emit_insn (gen_blockage ());
2855     }
2856
2857   if (cfun->machine->ia64_eh_epilogue_sp)
2858     emit_move_insn (stack_pointer_rtx, cfun->machine->ia64_eh_epilogue_sp);
2859   else if (frame_pointer_needed)
2860     {
2861       insn = emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
2862       RTX_FRAME_RELATED_P (insn) = 1;
2863     }
2864   else if (current_frame_info.total_size)
2865     {
2866       rtx offset, frame_size_rtx;
2867
2868       frame_size_rtx = GEN_INT (current_frame_info.total_size);
2869       if (CONST_OK_FOR_I (current_frame_info.total_size))
2870         offset = frame_size_rtx;
2871       else
2872         {
2873           regno = next_scratch_gr_reg ();
2874           offset = gen_rtx_REG (DImode, regno);
2875           emit_move_insn (offset, frame_size_rtx);
2876         }
2877
2878       insn = emit_insn (gen_adddi3 (stack_pointer_rtx, stack_pointer_rtx,
2879                                     offset));
2880
2881       RTX_FRAME_RELATED_P (insn) = 1;
2882       if (GET_CODE (offset) != CONST_INT)
2883         {
2884           REG_NOTES (insn)
2885             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2886                         gen_rtx_SET (VOIDmode,
2887                                      stack_pointer_rtx,
2888                                      gen_rtx_PLUS (DImode,
2889                                                    stack_pointer_rtx,
2890                                                    frame_size_rtx)),
2891                         REG_NOTES (insn));
2892         }
2893     }
2894
2895   if (cfun->machine->ia64_eh_epilogue_bsp)
2896     emit_insn (gen_set_bsp (cfun->machine->ia64_eh_epilogue_bsp));
2897  
2898   if (! sibcall_p)
2899     emit_jump_insn (gen_return_internal (gen_rtx_REG (DImode, BR_REG (0))));
2900   else
2901     {
2902       int fp = GR_REG (2);
2903       /* We need a throw away register here, r0 and r1 are reserved, so r2 is the
2904          first available call clobbered register.  If there was a frame_pointer 
2905          register, we may have swapped the names of r2 and HARD_FRAME_POINTER_REGNUM, 
2906          so we have to make sure we're using the string "r2" when emitting
2907          the register name for the assembler.  */
2908       if (current_frame_info.reg_fp && current_frame_info.reg_fp == GR_REG (2))
2909         fp = HARD_FRAME_POINTER_REGNUM;
2910
2911       /* We must emit an alloc to force the input registers to become output
2912          registers.  Otherwise, if the callee tries to pass its parameters
2913          through to another call without an intervening alloc, then these
2914          values get lost.  */
2915       /* ??? We don't need to preserve all input registers.  We only need to
2916          preserve those input registers used as arguments to the sibling call.
2917          It is unclear how to compute that number here.  */
2918       if (current_frame_info.n_input_regs != 0)
2919         emit_insn (gen_alloc (gen_rtx_REG (DImode, fp),
2920                               GEN_INT (0), GEN_INT (0),
2921                               GEN_INT (current_frame_info.n_input_regs),
2922                               GEN_INT (0)));
2923     }
2924 }
2925
2926 /* Return 1 if br.ret can do all the work required to return from a
2927    function.  */
2928
2929 int
2930 ia64_direct_return ()
2931 {
2932   if (reload_completed && ! frame_pointer_needed)
2933     {
2934       ia64_compute_frame_size (get_frame_size ());
2935
2936       return (current_frame_info.total_size == 0
2937               && current_frame_info.n_spilled == 0
2938               && current_frame_info.reg_save_b0 == 0
2939               && current_frame_info.reg_save_pr == 0
2940               && current_frame_info.reg_save_ar_pfs == 0
2941               && current_frame_info.reg_save_ar_unat == 0
2942               && current_frame_info.reg_save_ar_lc == 0);
2943     }
2944   return 0;
2945 }
2946
2947 int
2948 ia64_hard_regno_rename_ok (from, to)
2949      int from;
2950      int to;
2951 {
2952   /* Don't clobber any of the registers we reserved for the prologue.  */
2953   if (to == current_frame_info.reg_fp
2954       || to == current_frame_info.reg_save_b0
2955       || to == current_frame_info.reg_save_pr
2956       || to == current_frame_info.reg_save_ar_pfs
2957       || to == current_frame_info.reg_save_ar_unat
2958       || to == current_frame_info.reg_save_ar_lc)
2959     return 0;
2960
2961   if (from == current_frame_info.reg_fp
2962       || from == current_frame_info.reg_save_b0
2963       || from == current_frame_info.reg_save_pr
2964       || from == current_frame_info.reg_save_ar_pfs
2965       || from == current_frame_info.reg_save_ar_unat
2966       || from == current_frame_info.reg_save_ar_lc)
2967     return 0;
2968
2969   /* Don't use output registers outside the register frame.  */
2970   if (OUT_REGNO_P (to) && to >= OUT_REG (current_frame_info.n_output_regs))
2971     return 0;
2972
2973   /* Retain even/oddness on predicate register pairs.  */
2974   if (PR_REGNO_P (from) && PR_REGNO_P (to))
2975     return (from & 1) == (to & 1);
2976
2977   return 1;
2978 }
2979
2980 /* Target hook for assembling integer objects.  Handle word-sized
2981    aligned objects and detect the cases when @fptr is needed.  */
2982
2983 static bool
2984 ia64_assemble_integer (x, size, aligned_p)
2985      rtx x;
2986      unsigned int size;
2987      int aligned_p;
2988 {
2989   if (size == (TARGET_ILP32 ? 4 : 8)
2990       && aligned_p
2991       && !(TARGET_NO_PIC || TARGET_AUTO_PIC)
2992       && GET_CODE (x) == SYMBOL_REF
2993       && SYMBOL_REF_FUNCTION_P (x))
2994     {
2995       if (TARGET_ILP32)
2996         fputs ("\tdata4\t@fptr(", asm_out_file);
2997       else
2998         fputs ("\tdata8\t@fptr(", asm_out_file);
2999       output_addr_const (asm_out_file, x);
3000       fputs (")\n", asm_out_file);
3001       return true;
3002     }
3003   return default_assemble_integer (x, size, aligned_p);
3004 }
3005
3006 /* Emit the function prologue.  */
3007
3008 static void
3009 ia64_output_function_prologue (file, size)
3010      FILE *file;
3011      HOST_WIDE_INT size ATTRIBUTE_UNUSED;
3012 {
3013   int mask, grsave, grsave_prev;
3014
3015   if (current_frame_info.need_regstk)
3016     fprintf (file, "\t.regstk %d, %d, %d, %d\n",
3017              current_frame_info.n_input_regs,
3018              current_frame_info.n_local_regs,
3019              current_frame_info.n_output_regs,
3020              current_frame_info.n_rotate_regs);
3021
3022   if (!flag_unwind_tables && (!flag_exceptions || USING_SJLJ_EXCEPTIONS))
3023     return;
3024
3025   /* Emit the .prologue directive.  */
3026
3027   mask = 0;
3028   grsave = grsave_prev = 0;
3029   if (current_frame_info.reg_save_b0 != 0)
3030     {
3031       mask |= 8;
3032       grsave = grsave_prev = current_frame_info.reg_save_b0;
3033     }
3034   if (current_frame_info.reg_save_ar_pfs != 0
3035       && (grsave_prev == 0
3036           || current_frame_info.reg_save_ar_pfs == grsave_prev + 1))
3037     {
3038       mask |= 4;
3039       if (grsave_prev == 0)
3040         grsave = current_frame_info.reg_save_ar_pfs;
3041       grsave_prev = current_frame_info.reg_save_ar_pfs;
3042     }
3043   if (current_frame_info.reg_fp != 0
3044       && (grsave_prev == 0
3045           || current_frame_info.reg_fp == grsave_prev + 1))
3046     {
3047       mask |= 2;
3048       if (grsave_prev == 0)
3049         grsave = HARD_FRAME_POINTER_REGNUM;
3050       grsave_prev = current_frame_info.reg_fp;
3051     }
3052   if (current_frame_info.reg_save_pr != 0
3053       && (grsave_prev == 0
3054           || current_frame_info.reg_save_pr == grsave_prev + 1))
3055     {
3056       mask |= 1;
3057       if (grsave_prev == 0)
3058         grsave = current_frame_info.reg_save_pr;
3059     }
3060
3061   if (mask)
3062     fprintf (file, "\t.prologue %d, %d\n", mask,
3063              ia64_dbx_register_number (grsave));
3064   else
3065     fputs ("\t.prologue\n", file);
3066
3067   /* Emit a .spill directive, if necessary, to relocate the base of
3068      the register spill area.  */
3069   if (current_frame_info.spill_cfa_off != -16)
3070     fprintf (file, "\t.spill %ld\n",
3071              (long) (current_frame_info.spill_cfa_off
3072                      + current_frame_info.spill_size));
3073 }
3074
3075 /* Emit the .body directive at the scheduled end of the prologue.  */
3076
3077 static void
3078 ia64_output_function_end_prologue (file)
3079      FILE *file;
3080 {
3081   if (!flag_unwind_tables && (!flag_exceptions || USING_SJLJ_EXCEPTIONS))
3082     return;
3083
3084   fputs ("\t.body\n", file);
3085 }
3086
3087 /* Emit the function epilogue.  */
3088
3089 static void
3090 ia64_output_function_epilogue (file, size)
3091      FILE *file ATTRIBUTE_UNUSED;
3092      HOST_WIDE_INT size ATTRIBUTE_UNUSED;
3093 {
3094   int i;
3095
3096   /* Reset from the function's potential modifications.  */
3097   XINT (return_address_pointer_rtx, 0) = RETURN_ADDRESS_POINTER_REGNUM;
3098
3099   if (current_frame_info.reg_fp)
3100     {
3101       const char *tmp = reg_names[HARD_FRAME_POINTER_REGNUM];
3102       reg_names[HARD_FRAME_POINTER_REGNUM]
3103         = reg_names[current_frame_info.reg_fp];
3104       reg_names[current_frame_info.reg_fp] = tmp;
3105     }
3106   if (! TARGET_REG_NAMES)
3107     {
3108       for (i = 0; i < current_frame_info.n_input_regs; i++)
3109         reg_names[IN_REG (i)] = ia64_input_reg_names[i];
3110       for (i = 0; i < current_frame_info.n_local_regs; i++)
3111         reg_names[LOC_REG (i)] = ia64_local_reg_names[i];
3112       for (i = 0; i < current_frame_info.n_output_regs; i++)
3113         reg_names[OUT_REG (i)] = ia64_output_reg_names[i];
3114     }
3115
3116   current_frame_info.initialized = 0;
3117 }
3118
3119 int
3120 ia64_dbx_register_number (regno)
3121      int regno;
3122 {
3123   /* In ia64_expand_prologue we quite literally renamed the frame pointer
3124      from its home at loc79 to something inside the register frame.  We
3125      must perform the same renumbering here for the debug info.  */
3126   if (current_frame_info.reg_fp)
3127     {
3128       if (regno == HARD_FRAME_POINTER_REGNUM)
3129         regno = current_frame_info.reg_fp;
3130       else if (regno == current_frame_info.reg_fp)
3131         regno = HARD_FRAME_POINTER_REGNUM;
3132     }
3133
3134   if (IN_REGNO_P (regno))
3135     return 32 + regno - IN_REG (0);
3136   else if (LOC_REGNO_P (regno))
3137     return 32 + current_frame_info.n_input_regs + regno - LOC_REG (0);
3138   else if (OUT_REGNO_P (regno))
3139     return (32 + current_frame_info.n_input_regs
3140             + current_frame_info.n_local_regs + regno - OUT_REG (0));
3141   else
3142     return regno;
3143 }
3144
3145 void
3146 ia64_initialize_trampoline (addr, fnaddr, static_chain)
3147      rtx addr, fnaddr, static_chain;
3148 {
3149   rtx addr_reg, eight = GEN_INT (8);
3150
3151   /* Load up our iterator.  */
3152   addr_reg = gen_reg_rtx (Pmode);
3153   emit_move_insn (addr_reg, addr);
3154
3155   /* The first two words are the fake descriptor:
3156      __ia64_trampoline, ADDR+16.  */
3157   emit_move_insn (gen_rtx_MEM (Pmode, addr_reg),
3158                   gen_rtx_SYMBOL_REF (Pmode, "__ia64_trampoline"));
3159   emit_insn (gen_adddi3 (addr_reg, addr_reg, eight));
3160
3161   emit_move_insn (gen_rtx_MEM (Pmode, addr_reg),
3162                   copy_to_reg (plus_constant (addr, 16)));
3163   emit_insn (gen_adddi3 (addr_reg, addr_reg, eight));
3164
3165   /* The third word is the target descriptor.  */
3166   emit_move_insn (gen_rtx_MEM (Pmode, addr_reg), fnaddr);
3167   emit_insn (gen_adddi3 (addr_reg, addr_reg, eight));
3168
3169   /* The fourth word is the static chain.  */
3170   emit_move_insn (gen_rtx_MEM (Pmode, addr_reg), static_chain);
3171 }
3172 \f
3173 /* Do any needed setup for a variadic function.  CUM has not been updated
3174    for the last named argument which has type TYPE and mode MODE.
3175
3176    We generate the actual spill instructions during prologue generation.  */
3177
3178 void
3179 ia64_setup_incoming_varargs (cum, int_mode, type, pretend_size, second_time)
3180      CUMULATIVE_ARGS cum;
3181      int             int_mode;
3182      tree            type;
3183      int *           pretend_size;
3184      int             second_time ATTRIBUTE_UNUSED;
3185 {
3186   /* Skip the current argument.  */
3187   ia64_function_arg_advance (&cum, int_mode, type, 1);
3188
3189   if (cum.words < MAX_ARGUMENT_SLOTS)
3190     {
3191       int n = MAX_ARGUMENT_SLOTS - cum.words;
3192       *pretend_size = n * UNITS_PER_WORD;
3193       cfun->machine->n_varargs = n;
3194     }
3195 }
3196
3197 /* Check whether TYPE is a homogeneous floating point aggregate.  If
3198    it is, return the mode of the floating point type that appears
3199    in all leafs.  If it is not, return VOIDmode.
3200
3201    An aggregate is a homogeneous floating point aggregate is if all
3202    fields/elements in it have the same floating point type (e.g,
3203    SFmode).  128-bit quad-precision floats are excluded.  */
3204
3205 static enum machine_mode
3206 hfa_element_mode (type, nested)
3207      tree type;
3208      int nested;
3209 {
3210   enum machine_mode element_mode = VOIDmode;
3211   enum machine_mode mode;
3212   enum tree_code code = TREE_CODE (type);
3213   int know_element_mode = 0;
3214   tree t;
3215
3216   switch (code)
3217     {
3218     case VOID_TYPE:     case INTEGER_TYPE:      case ENUMERAL_TYPE:
3219     case BOOLEAN_TYPE:  case CHAR_TYPE:         case POINTER_TYPE:
3220     case OFFSET_TYPE:   case REFERENCE_TYPE:    case METHOD_TYPE:
3221     case FILE_TYPE:     case SET_TYPE:          case LANG_TYPE:
3222     case FUNCTION_TYPE:
3223       return VOIDmode;
3224
3225       /* Fortran complex types are supposed to be HFAs, so we need to handle
3226          gcc's COMPLEX_TYPEs as HFAs.  We need to exclude the integral complex
3227          types though.  */
3228     case COMPLEX_TYPE:
3229       if (GET_MODE_CLASS (TYPE_MODE (type)) == MODE_COMPLEX_FLOAT
3230           && (TYPE_MODE (type) != TCmode || INTEL_EXTENDED_IEEE_FORMAT))
3231         return mode_for_size (GET_MODE_UNIT_SIZE (TYPE_MODE (type))
3232                               * BITS_PER_UNIT, MODE_FLOAT, 0);
3233       else
3234         return VOIDmode;
3235
3236     case REAL_TYPE:
3237       /* We want to return VOIDmode for raw REAL_TYPEs, but the actual
3238          mode if this is contained within an aggregate.  */
3239       if (nested && (TYPE_MODE (type) != TFmode || INTEL_EXTENDED_IEEE_FORMAT))
3240         return TYPE_MODE (type);
3241       else
3242         return VOIDmode;
3243
3244     case ARRAY_TYPE:
3245       return hfa_element_mode (TREE_TYPE (type), 1);
3246
3247     case RECORD_TYPE:
3248     case UNION_TYPE:
3249     case QUAL_UNION_TYPE:
3250       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
3251         {
3252           if (TREE_CODE (t) != FIELD_DECL)
3253             continue;
3254
3255           mode = hfa_element_mode (TREE_TYPE (t), 1);
3256           if (know_element_mode)
3257             {
3258               if (mode != element_mode)
3259                 return VOIDmode;
3260             }
3261           else if (GET_MODE_CLASS (mode) != MODE_FLOAT)
3262             return VOIDmode;
3263           else
3264             {
3265               know_element_mode = 1;
3266               element_mode = mode;
3267             }
3268         }
3269       return element_mode;
3270
3271     default:
3272       /* If we reach here, we probably have some front-end specific type
3273          that the backend doesn't know about.  This can happen via the
3274          aggregate_value_p call in init_function_start.  All we can do is
3275          ignore unknown tree types.  */
3276       return VOIDmode;
3277     }
3278
3279   return VOIDmode;
3280 }
3281
3282 /* Return rtx for register where argument is passed, or zero if it is passed
3283    on the stack.  */
3284
3285 /* ??? 128-bit quad-precision floats are always passed in general
3286    registers.  */
3287
3288 rtx
3289 ia64_function_arg (cum, mode, type, named, incoming)
3290      CUMULATIVE_ARGS *cum;
3291      enum machine_mode mode;
3292      tree type;
3293      int named;
3294      int incoming;
3295 {
3296   int basereg = (incoming ? GR_ARG_FIRST : AR_ARG_FIRST);
3297   int words = (((mode == BLKmode ? int_size_in_bytes (type)
3298                  : GET_MODE_SIZE (mode)) + UNITS_PER_WORD - 1)
3299                / UNITS_PER_WORD);
3300   int offset = 0;
3301   enum machine_mode hfa_mode = VOIDmode;
3302
3303   /* Integer and float arguments larger than 8 bytes start at the next even
3304      boundary.  Aggregates larger than 8 bytes start at the next even boundary
3305      if the aggregate has 16 byte alignment.  Net effect is that types with
3306      alignment greater than 8 start at the next even boundary.  */
3307   /* ??? The ABI does not specify how to handle aggregates with alignment from
3308      9 to 15 bytes, or greater than 16.   We handle them all as if they had
3309      16 byte alignment.  Such aggregates can occur only if gcc extensions are
3310      used.  */
3311   if ((type ? (TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
3312        : (words > 1))
3313       && (cum->words & 1))
3314     offset = 1;
3315
3316   /* If all argument slots are used, then it must go on the stack.  */
3317   if (cum->words + offset >= MAX_ARGUMENT_SLOTS)
3318     return 0;
3319
3320   /* Check for and handle homogeneous FP aggregates.  */
3321   if (type)
3322     hfa_mode = hfa_element_mode (type, 0);
3323
3324   /* Unnamed prototyped hfas are passed as usual.  Named prototyped hfas
3325      and unprototyped hfas are passed specially.  */
3326   if (hfa_mode != VOIDmode && (! cum->prototype || named))
3327     {
3328       rtx loc[16];
3329       int i = 0;
3330       int fp_regs = cum->fp_regs;
3331       int int_regs = cum->words + offset;
3332       int hfa_size = GET_MODE_SIZE (hfa_mode);
3333       int byte_size;
3334       int args_byte_size;
3335
3336       /* If prototyped, pass it in FR regs then GR regs.
3337          If not prototyped, pass it in both FR and GR regs.
3338
3339          If this is an SFmode aggregate, then it is possible to run out of
3340          FR regs while GR regs are still left.  In that case, we pass the
3341          remaining part in the GR regs.  */
3342
3343       /* Fill the FP regs.  We do this always.  We stop if we reach the end
3344          of the argument, the last FP register, or the last argument slot.  */
3345
3346       byte_size = ((mode == BLKmode)
3347                    ? int_size_in_bytes (type) : GET_MODE_SIZE (mode));
3348       args_byte_size = int_regs * UNITS_PER_WORD;
3349       offset = 0;
3350       for (; (offset < byte_size && fp_regs < MAX_ARGUMENT_SLOTS
3351               && args_byte_size < (MAX_ARGUMENT_SLOTS * UNITS_PER_WORD)); i++)
3352         {
3353           loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
3354                                       gen_rtx_REG (hfa_mode, (FR_ARG_FIRST
3355                                                               + fp_regs)),
3356                                       GEN_INT (offset));
3357           offset += hfa_size;
3358           args_byte_size += hfa_size;
3359           fp_regs++;
3360         }
3361
3362       /* If no prototype, then the whole thing must go in GR regs.  */
3363       if (! cum->prototype)
3364         offset = 0;
3365       /* If this is an SFmode aggregate, then we might have some left over
3366          that needs to go in GR regs.  */
3367       else if (byte_size != offset)
3368         int_regs += offset / UNITS_PER_WORD;
3369
3370       /* Fill in the GR regs.  We must use DImode here, not the hfa mode.  */
3371
3372       for (; offset < byte_size && int_regs < MAX_ARGUMENT_SLOTS; i++)
3373         {
3374           enum machine_mode gr_mode = DImode;
3375
3376           /* If we have an odd 4 byte hunk because we ran out of FR regs,
3377              then this goes in a GR reg left adjusted/little endian, right
3378              adjusted/big endian.  */
3379           /* ??? Currently this is handled wrong, because 4-byte hunks are
3380              always right adjusted/little endian.  */
3381           if (offset & 0x4)
3382             gr_mode = SImode;
3383           /* If we have an even 4 byte hunk because the aggregate is a
3384              multiple of 4 bytes in size, then this goes in a GR reg right
3385              adjusted/little endian.  */
3386           else if (byte_size - offset == 4)
3387             gr_mode = SImode;
3388           /* Complex floats need to have float mode.  */
3389           if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
3390             gr_mode = hfa_mode;
3391
3392           loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
3393                                       gen_rtx_REG (gr_mode, (basereg
3394                                                              + int_regs)),
3395                                       GEN_INT (offset));
3396           offset += GET_MODE_SIZE (gr_mode);
3397           int_regs += GET_MODE_SIZE (gr_mode) <= UNITS_PER_WORD
3398                       ? 1 : GET_MODE_SIZE (gr_mode) / UNITS_PER_WORD;
3399         }
3400
3401       /* If we ended up using just one location, just return that one loc.  */
3402       if (i == 1)
3403         return XEXP (loc[0], 0);
3404       else
3405         return gen_rtx_PARALLEL (mode, gen_rtvec_v (i, loc));
3406     }
3407
3408   /* Integral and aggregates go in general registers.  If we have run out of
3409      FR registers, then FP values must also go in general registers.  This can
3410      happen when we have a SFmode HFA.  */
3411   else if (((mode == TFmode) && ! INTEL_EXTENDED_IEEE_FORMAT)
3412           || (! FLOAT_MODE_P (mode) || cum->fp_regs == MAX_ARGUMENT_SLOTS))
3413     {
3414       int byte_size = ((mode == BLKmode)
3415                        ? int_size_in_bytes (type) : GET_MODE_SIZE (mode));
3416       if (BYTES_BIG_ENDIAN
3417         && (mode == BLKmode || (type && AGGREGATE_TYPE_P (type)))
3418         && byte_size < UNITS_PER_WORD
3419         && byte_size > 0)
3420         {
3421           rtx gr_reg = gen_rtx_EXPR_LIST (VOIDmode,
3422                                           gen_rtx_REG (DImode,
3423                                                        (basereg + cum->words
3424                                                         + offset)),
3425                                           const0_rtx);
3426           return gen_rtx_PARALLEL (mode, gen_rtvec (1, gr_reg));
3427         }
3428       else
3429         return gen_rtx_REG (mode, basereg + cum->words + offset);
3430
3431     }
3432
3433   /* If there is a prototype, then FP values go in a FR register when
3434      named, and in a GR register when unnamed.  */
3435   else if (cum->prototype)
3436     {
3437       if (! named)
3438         return gen_rtx_REG (mode, basereg + cum->words + offset);
3439       else
3440         return gen_rtx_REG (mode, FR_ARG_FIRST + cum->fp_regs);
3441     }
3442   /* If there is no prototype, then FP values go in both FR and GR
3443      registers.  */
3444   else
3445     {
3446       rtx fp_reg = gen_rtx_EXPR_LIST (VOIDmode,
3447                                       gen_rtx_REG (mode, (FR_ARG_FIRST
3448                                                           + cum->fp_regs)),
3449                                       const0_rtx);
3450       rtx gr_reg = gen_rtx_EXPR_LIST (VOIDmode,
3451                                       gen_rtx_REG (mode,
3452                                                    (basereg + cum->words
3453                                                     + offset)),
3454                                       const0_rtx);
3455
3456       return gen_rtx_PARALLEL (mode, gen_rtvec (2, fp_reg, gr_reg));
3457     }
3458 }
3459
3460 /* Return number of words, at the beginning of the argument, that must be
3461    put in registers.  0 is the argument is entirely in registers or entirely
3462    in memory.  */
3463
3464 int
3465 ia64_function_arg_partial_nregs (cum, mode, type, named)
3466      CUMULATIVE_ARGS *cum;
3467      enum machine_mode mode;
3468      tree type;
3469      int named ATTRIBUTE_UNUSED;
3470 {
3471   int words = (((mode == BLKmode ? int_size_in_bytes (type)
3472                  : GET_MODE_SIZE (mode)) + UNITS_PER_WORD - 1)
3473                / UNITS_PER_WORD);
3474   int offset = 0;
3475
3476   /* Arguments with alignment larger than 8 bytes start at the next even
3477      boundary.  */
3478   if ((type ? (TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
3479        : (words > 1))
3480       && (cum->words & 1))
3481     offset = 1;
3482
3483   /* If all argument slots are used, then it must go on the stack.  */
3484   if (cum->words + offset >= MAX_ARGUMENT_SLOTS)
3485     return 0;
3486
3487   /* It doesn't matter whether the argument goes in FR or GR regs.  If
3488      it fits within the 8 argument slots, then it goes entirely in
3489      registers.  If it extends past the last argument slot, then the rest
3490      goes on the stack.  */
3491
3492   if (words + cum->words + offset <= MAX_ARGUMENT_SLOTS)
3493     return 0;
3494
3495   return MAX_ARGUMENT_SLOTS - cum->words - offset;
3496 }
3497
3498 /* Update CUM to point after this argument.  This is patterned after
3499    ia64_function_arg.  */
3500
3501 void
3502 ia64_function_arg_advance (cum, mode, type, named)
3503      CUMULATIVE_ARGS *cum;
3504      enum machine_mode mode;
3505      tree type;
3506      int named;
3507 {
3508   int words = (((mode == BLKmode ? int_size_in_bytes (type)
3509                  : GET_MODE_SIZE (mode)) + UNITS_PER_WORD - 1)
3510                / UNITS_PER_WORD);
3511   int offset = 0;
3512   enum machine_mode hfa_mode = VOIDmode;
3513
3514   /* If all arg slots are already full, then there is nothing to do.  */
3515   if (cum->words >= MAX_ARGUMENT_SLOTS)
3516     return;
3517
3518   /* Arguments with alignment larger than 8 bytes start at the next even
3519      boundary.  */
3520   if ((type ? (TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
3521        : (words > 1))
3522       && (cum->words & 1))
3523     offset = 1;
3524
3525   cum->words += words + offset;
3526
3527   /* Check for and handle homogeneous FP aggregates.  */
3528   if (type)
3529     hfa_mode = hfa_element_mode (type, 0);
3530
3531   /* Unnamed prototyped hfas are passed as usual.  Named prototyped hfas
3532      and unprototyped hfas are passed specially.  */
3533   if (hfa_mode != VOIDmode && (! cum->prototype || named))
3534     {
3535       int fp_regs = cum->fp_regs;
3536       /* This is the original value of cum->words + offset.  */
3537       int int_regs = cum->words - words;
3538       int hfa_size = GET_MODE_SIZE (hfa_mode);
3539       int byte_size;
3540       int args_byte_size;
3541
3542       /* If prototyped, pass it in FR regs then GR regs.
3543          If not prototyped, pass it in both FR and GR regs.
3544
3545          If this is an SFmode aggregate, then it is possible to run out of
3546          FR regs while GR regs are still left.  In that case, we pass the
3547          remaining part in the GR regs.  */
3548
3549       /* Fill the FP regs.  We do this always.  We stop if we reach the end
3550          of the argument, the last FP register, or the last argument slot.  */
3551
3552       byte_size = ((mode == BLKmode)
3553                    ? int_size_in_bytes (type) : GET_MODE_SIZE (mode));
3554       args_byte_size = int_regs * UNITS_PER_WORD;
3555       offset = 0;
3556       for (; (offset < byte_size && fp_regs < MAX_ARGUMENT_SLOTS
3557               && args_byte_size < (MAX_ARGUMENT_SLOTS * UNITS_PER_WORD));)
3558         {
3559           offset += hfa_size;
3560           args_byte_size += hfa_size;
3561           fp_regs++;
3562         }
3563
3564       cum->fp_regs = fp_regs;
3565     }
3566
3567   /* Integral and aggregates go in general registers.  If we have run out of
3568      FR registers, then FP values must also go in general registers.  This can
3569      happen when we have a SFmode HFA.  */
3570   else if (! FLOAT_MODE_P (mode) || cum->fp_regs == MAX_ARGUMENT_SLOTS)
3571     cum->int_regs = cum->words;
3572
3573   /* If there is a prototype, then FP values go in a FR register when
3574      named, and in a GR register when unnamed.  */
3575   else if (cum->prototype)
3576     {
3577       if (! named)
3578         cum->int_regs = cum->words;
3579       else
3580         /* ??? Complex types should not reach here.  */
3581         cum->fp_regs += (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT ? 2 : 1);
3582     }
3583   /* If there is no prototype, then FP values go in both FR and GR
3584      registers.  */
3585   else
3586     { 
3587       /* ??? Complex types should not reach here.  */
3588       cum->fp_regs += (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT ? 2 : 1);
3589       cum->int_regs = cum->words;
3590     }
3591 }
3592
3593 /* Variable sized types are passed by reference.  */
3594 /* ??? At present this is a GCC extension to the IA-64 ABI.  */
3595
3596 int
3597 ia64_function_arg_pass_by_reference (cum, mode, type, named)
3598      CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED;
3599      enum machine_mode mode ATTRIBUTE_UNUSED;
3600      tree type;
3601      int named ATTRIBUTE_UNUSED;
3602 {
3603   return type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST;
3604 }
3605
3606 /* True if it is OK to do sibling call optimization for the specified
3607    call expression EXP.  DECL will be the called function, or NULL if
3608    this is an indirect call.  */
3609 static bool
3610 ia64_function_ok_for_sibcall (decl, exp)
3611      tree decl, exp;
3612 {
3613   /* Direct calls are always ok.  */
3614   if (decl)
3615     return true;
3616
3617   /* If TARGET_CONST_GP is in effect, then our caller expects us to
3618      return with our current GP.  This means that we'll always have
3619      a GP reload after an indirect call.  */
3620   return !ia64_epilogue_uses (R_GR (1));
3621 }
3622 \f
3623
3624 /* Implement va_arg.  */
3625
3626 rtx
3627 ia64_va_arg (valist, type)
3628      tree valist, type;
3629 {
3630   tree t;
3631
3632   /* Variable sized types are passed by reference.  */
3633   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
3634     {
3635       rtx addr = std_expand_builtin_va_arg (valist, build_pointer_type (type));
3636       return gen_rtx_MEM (ptr_mode, force_reg (Pmode, addr));
3637     }
3638
3639   /* Arguments with alignment larger than 8 bytes start at the next even
3640      boundary.  */
3641   if (TYPE_ALIGN (type) > 8 * BITS_PER_UNIT)
3642     {
3643       t = build (PLUS_EXPR, TREE_TYPE (valist), valist,
3644                  build_int_2 (2 * UNITS_PER_WORD - 1, 0));
3645       t = build (BIT_AND_EXPR, TREE_TYPE (t), t,
3646                  build_int_2 (-2 * UNITS_PER_WORD, -1));
3647       t = build (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
3648       TREE_SIDE_EFFECTS (t) = 1;
3649       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
3650     }
3651
3652   return std_expand_builtin_va_arg (valist, type);
3653 }
3654 \f
3655 /* Return 1 if function return value returned in memory.  Return 0 if it is
3656    in a register.  */
3657
3658 int
3659 ia64_return_in_memory (valtype)
3660      tree valtype;
3661 {
3662   enum machine_mode mode;
3663   enum machine_mode hfa_mode;
3664   HOST_WIDE_INT byte_size;
3665
3666   mode = TYPE_MODE (valtype);
3667   byte_size = GET_MODE_SIZE (mode);
3668   if (mode == BLKmode)
3669     {
3670       byte_size = int_size_in_bytes (valtype);
3671       if (byte_size < 0)
3672         return 1;
3673     }
3674
3675   /* Hfa's with up to 8 elements are returned in the FP argument registers.  */
3676
3677   hfa_mode = hfa_element_mode (valtype, 0);
3678   if (hfa_mode != VOIDmode)
3679     {
3680       int hfa_size = GET_MODE_SIZE (hfa_mode);
3681
3682       if (byte_size / hfa_size > MAX_ARGUMENT_SLOTS)
3683         return 1;
3684       else
3685         return 0;
3686     }
3687   else if (byte_size > UNITS_PER_WORD * MAX_INT_RETURN_SLOTS)
3688     return 1;
3689   else
3690     return 0;
3691 }
3692
3693 /* Return rtx for register that holds the function return value.  */
3694
3695 rtx
3696 ia64_function_value (valtype, func)
3697      tree valtype;
3698      tree func ATTRIBUTE_UNUSED;
3699 {
3700   enum machine_mode mode;
3701   enum machine_mode hfa_mode;
3702
3703   mode = TYPE_MODE (valtype);
3704   hfa_mode = hfa_element_mode (valtype, 0);
3705
3706   if (hfa_mode != VOIDmode)
3707     {
3708       rtx loc[8];
3709       int i;
3710       int hfa_size;
3711       int byte_size;
3712       int offset;
3713
3714       hfa_size = GET_MODE_SIZE (hfa_mode);
3715       byte_size = ((mode == BLKmode)
3716                    ? int_size_in_bytes (valtype) : GET_MODE_SIZE (mode));
3717       offset = 0;
3718       for (i = 0; offset < byte_size; i++)
3719         {
3720           loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
3721                                       gen_rtx_REG (hfa_mode, FR_ARG_FIRST + i),
3722                                       GEN_INT (offset));
3723           offset += hfa_size;
3724         }
3725
3726       if (i == 1)
3727         return XEXP (loc[0], 0);
3728       else
3729         return gen_rtx_PARALLEL (mode, gen_rtvec_v (i, loc));
3730     }
3731   else if (FLOAT_TYPE_P (valtype) &&
3732            ((mode != TFmode) || INTEL_EXTENDED_IEEE_FORMAT))
3733     return gen_rtx_REG (mode, FR_ARG_FIRST);
3734   else
3735     {
3736       if (BYTES_BIG_ENDIAN
3737           && (mode == BLKmode || (valtype && AGGREGATE_TYPE_P (valtype))))
3738         {
3739           rtx loc[8];
3740           int offset;
3741           int bytesize;
3742           int i;
3743
3744           offset = 0;
3745           bytesize = int_size_in_bytes (valtype);
3746           for (i = 0; offset < bytesize; i++)
3747             {
3748               loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
3749                                           gen_rtx_REG (DImode,
3750                                                        GR_RET_FIRST + i),
3751                                           GEN_INT (offset));
3752               offset += UNITS_PER_WORD;
3753             }
3754           return gen_rtx_PARALLEL (mode, gen_rtvec_v (i, loc));
3755         }
3756       else
3757         return gen_rtx_REG (mode, GR_RET_FIRST);
3758     }
3759 }
3760
3761 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
3762    We need to emit DTP-relative relocations.  */
3763
3764 void
3765 ia64_output_dwarf_dtprel (file, size, x)
3766      FILE *file;
3767      int size;
3768      rtx x;
3769 {
3770   if (size != 8)
3771     abort ();
3772   fputs ("\tdata8.ua\t@dtprel(", file);
3773   output_addr_const (file, x);
3774   fputs (")", file);
3775 }
3776
3777 /* Print a memory address as an operand to reference that memory location.  */
3778
3779 /* ??? Do we need this?  It gets used only for 'a' operands.  We could perhaps
3780    also call this from ia64_print_operand for memory addresses.  */
3781
3782 void
3783 ia64_print_operand_address (stream, address)
3784      FILE * stream ATTRIBUTE_UNUSED;
3785      rtx    address ATTRIBUTE_UNUSED;
3786 {
3787 }
3788
3789 /* Print an operand to an assembler instruction.
3790    C    Swap and print a comparison operator.
3791    D    Print an FP comparison operator.
3792    E    Print 32 - constant, for SImode shifts as extract.
3793    e    Print 64 - constant, for DImode rotates.
3794    F    A floating point constant 0.0 emitted as f0, or 1.0 emitted as f1, or
3795         a floating point register emitted normally.
3796    I    Invert a predicate register by adding 1.
3797    J    Select the proper predicate register for a condition.
3798    j    Select the inverse predicate register for a condition.
3799    O    Append .acq for volatile load.
3800    P    Postincrement of a MEM.
3801    Q    Append .rel for volatile store.
3802    S    Shift amount for shladd instruction.
3803    T    Print an 8-bit sign extended number (K) as a 32-bit unsigned number
3804         for Intel assembler.
3805    U    Print an 8-bit sign extended number (K) as a 64-bit unsigned number
3806         for Intel assembler.
3807    r    Print register name, or constant 0 as r0.  HP compatibility for
3808         Linux kernel.  */
3809 void
3810 ia64_print_operand (file, x, code)
3811      FILE * file;
3812      rtx    x;
3813      int    code;
3814 {
3815   const char *str;
3816
3817   switch (code)
3818     {
3819     case 0:
3820       /* Handled below.  */
3821       break;
3822
3823     case 'C':
3824       {
3825         enum rtx_code c = swap_condition (GET_CODE (x));
3826         fputs (GET_RTX_NAME (c), file);
3827         return;
3828       }
3829
3830     case 'D':
3831       switch (GET_CODE (x))
3832         {
3833         case NE:
3834           str = "neq";
3835           break;
3836         case UNORDERED:
3837           str = "unord";
3838           break;
3839         case ORDERED:
3840           str = "ord";
3841           break;
3842         default:
3843           str = GET_RTX_NAME (GET_CODE (x));
3844           break;
3845         }
3846       fputs (str, file);
3847       return;
3848
3849     case 'E':
3850       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 32 - INTVAL (x));
3851       return;
3852
3853     case 'e':
3854       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 64 - INTVAL (x));
3855       return;
3856
3857     case 'F':
3858       if (x == CONST0_RTX (GET_MODE (x)))
3859         str = reg_names [FR_REG (0)];
3860       else if (x == CONST1_RTX (GET_MODE (x)))
3861         str = reg_names [FR_REG (1)];
3862       else if (GET_CODE (x) == REG)
3863         str = reg_names [REGNO (x)];
3864       else
3865         abort ();
3866       fputs (str, file);
3867       return;
3868
3869     case 'I':
3870       fputs (reg_names [REGNO (x) + 1], file);
3871       return;
3872
3873     case 'J':
3874     case 'j':
3875       {
3876         unsigned int regno = REGNO (XEXP (x, 0));
3877         if (GET_CODE (x) == EQ)
3878           regno += 1;
3879         if (code == 'j')
3880           regno ^= 1;
3881         fputs (reg_names [regno], file);
3882       }
3883       return;
3884
3885     case 'O':
3886       if (MEM_VOLATILE_P (x))
3887         fputs(".acq", file);
3888       return;
3889
3890     case 'P':
3891       {
3892         HOST_WIDE_INT value;
3893
3894         switch (GET_CODE (XEXP (x, 0)))
3895           {
3896           default:
3897             return;
3898
3899           case POST_MODIFY:
3900             x = XEXP (XEXP (XEXP (x, 0), 1), 1);
3901             if (GET_CODE (x) == CONST_INT)
3902               value = INTVAL (x);
3903             else if (GET_CODE (x) == REG)
3904               {
3905                 fprintf (file, ", %s", reg_names[REGNO (x)]);
3906                 return;
3907               }
3908             else
3909               abort ();
3910             break;
3911
3912           case POST_INC:
3913             value = GET_MODE_SIZE (GET_MODE (x));
3914             break;
3915
3916           case POST_DEC:
3917             value = - (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (x));
3918             break;
3919           }
3920
3921         putc (',', file);
3922         putc (' ', file);
3923         fprintf (file, HOST_WIDE_INT_PRINT_DEC, value);
3924         return;
3925       }
3926
3927     case 'Q':
3928       if (MEM_VOLATILE_P (x))
3929         fputs(".rel", file);
3930       return;
3931
3932     case 'S':
3933       fprintf (file, "%d", exact_log2 (INTVAL (x)));
3934       return;
3935
3936     case 'T':
3937       if (! TARGET_GNU_AS && GET_CODE (x) == CONST_INT)
3938         {
3939           fprintf (file, "0x%x", (int) INTVAL (x) & 0xffffffff);
3940           return;
3941         }
3942       break;
3943
3944     case 'U':
3945       if (! TARGET_GNU_AS && GET_CODE (x) == CONST_INT)
3946         {
3947           const char *prefix = "0x";
3948           if (INTVAL (x) & 0x80000000)
3949             {
3950               fprintf (file, "0xffffffff");
3951               prefix = "";
3952             }
3953           fprintf (file, "%s%x", prefix, (int) INTVAL (x) & 0xffffffff);
3954           return;
3955         }
3956       break;
3957
3958     case 'r':
3959       /* If this operand is the constant zero, write it as register zero.
3960          Any register, zero, or CONST_INT value is OK here.  */
3961       if (GET_CODE (x) == REG)
3962         fputs (reg_names[REGNO (x)], file);
3963       else if (x == CONST0_RTX (GET_MODE (x)))
3964         fputs ("r0", file);
3965       else if (GET_CODE (x) == CONST_INT)
3966         output_addr_const (file, x);
3967       else
3968         output_operand_lossage ("invalid %%r value");
3969       return;
3970
3971     case '+':
3972       {
3973         const char *which;
3974         
3975         /* For conditional branches, returns or calls, substitute
3976            sptk, dptk, dpnt, or spnt for %s.  */
3977         x = find_reg_note (current_output_insn, REG_BR_PROB, 0);
3978         if (x)
3979           {
3980             int pred_val = INTVAL (XEXP (x, 0));
3981
3982             /* Guess top and bottom 10% statically predicted.  */
3983             if (pred_val < REG_BR_PROB_BASE / 50)
3984               which = ".spnt";
3985             else if (pred_val < REG_BR_PROB_BASE / 2)
3986               which = ".dpnt";
3987             else if (pred_val < REG_BR_PROB_BASE / 100 * 98)
3988               which = ".dptk";
3989             else
3990               which = ".sptk";
3991           }
3992         else if (GET_CODE (current_output_insn) == CALL_INSN)
3993           which = ".sptk";
3994         else
3995           which = ".dptk";
3996
3997         fputs (which, file);
3998         return;
3999       }
4000
4001     case ',':
4002       x = current_insn_predicate;
4003       if (x)
4004         {
4005           unsigned int regno = REGNO (XEXP (x, 0));
4006           if (GET_CODE (x) == EQ)
4007             regno += 1;
4008           fprintf (file, "(%s) ", reg_names [regno]);
4009         }
4010       return;
4011
4012     default:
4013       output_operand_lossage ("ia64_print_operand: unknown code");
4014       return;
4015     }
4016
4017   switch (GET_CODE (x))
4018     {
4019       /* This happens for the spill/restore instructions.  */
4020     case POST_INC:
4021     case POST_DEC:
4022     case POST_MODIFY:
4023       x = XEXP (x, 0);
4024       /* ... fall through ...  */
4025
4026     case REG:
4027       fputs (reg_names [REGNO (x)], file);
4028       break;
4029
4030     case MEM:
4031       {
4032         rtx addr = XEXP (x, 0);
4033         if (GET_RTX_CLASS (GET_CODE (addr)) == 'a')
4034           addr = XEXP (addr, 0);
4035         fprintf (file, "[%s]", reg_names [REGNO (addr)]);
4036         break;
4037       }
4038
4039     default:
4040       output_addr_const (file, x);
4041       break;
4042     }
4043
4044   return;
4045 }
4046 \f
4047 /* Compute a (partial) cost for rtx X.  Return true if the complete
4048    cost has been computed, and false if subexpressions should be
4049    scanned.  In either case, *TOTAL contains the cost result.  */
4050 /* ??? This is incomplete.  */
4051
4052 static bool
4053 ia64_rtx_costs (x, code, outer_code, total)
4054      rtx x;
4055      int code, outer_code;
4056      int *total;
4057 {
4058   switch (code)
4059     {
4060     case CONST_INT:
4061       switch (outer_code)
4062         {
4063         case SET:
4064           *total = CONST_OK_FOR_J (INTVAL (x)) ? 0 : COSTS_N_INSNS (1);
4065           return true;
4066         case PLUS:
4067           if (CONST_OK_FOR_I (INTVAL (x)))
4068             *total = 0;
4069           else if (CONST_OK_FOR_J (INTVAL (x)))
4070             *total = 1;
4071           else
4072             *total = COSTS_N_INSNS (1);
4073           return true;
4074         default:
4075           if (CONST_OK_FOR_K (INTVAL (x)) || CONST_OK_FOR_L (INTVAL (x)))
4076             *total = 0;
4077           else
4078             *total = COSTS_N_INSNS (1);
4079           return true;
4080         }
4081
4082     case CONST_DOUBLE:
4083       *total = COSTS_N_INSNS (1);
4084       return true;
4085
4086     case CONST:
4087     case SYMBOL_REF:
4088     case LABEL_REF:
4089       *total = COSTS_N_INSNS (3);
4090       return true;
4091
4092     case MULT:
4093       /* For multiplies wider than HImode, we have to go to the FPU,
4094          which normally involves copies.  Plus there's the latency
4095          of the multiply itself, and the latency of the instructions to
4096          transfer integer regs to FP regs.  */
4097       /* ??? Check for FP mode.  */
4098       if (GET_MODE_SIZE (GET_MODE (x)) > 2)
4099         *total = COSTS_N_INSNS (10);
4100       else