OSDN Git Service

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