gcc/config/ia64/ia64.c

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