gcc/config/sparc/sparc.c

   1 /* Subroutines for insn-output.c for SPARC.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   4    2011
   5    Free Software Foundation, Inc.
   6    Contributed by Michael Tiemann (tiemann@cygnus.com)
   7    64-bit SPARC-V9 support by Michael Tiemann, Jim Wilson, and Doug Evans,
   8    at Cygnus Support.
   9
  10 This file is part of GCC.
  11
  12 GCC is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 3, or (at your option)
  15 any later version.
  16
  17 GCC is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GCC; see the file COPYING3.  If not see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "rtl.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "insn-config.h"
  35 #include "insn-codes.h"
  36 #include "conditions.h"
  37 #include "output.h"
  38 #include "insn-attr.h"
  39 #include "flags.h"
  40 #include "function.h"
  41 #include "except.h"
  42 #include "expr.h"
  43 #include "optabs.h"
  44 #include "recog.h"
  45 #include "diagnostic-core.h"
  46 #include "ggc.h"
  47 #include "tm_p.h"
  48 #include "debug.h"
  49 #include "target.h"
  50 #include "target-def.h"
  51 #include "common/common-target.h"
  52 #include "cfglayout.h"
  53 #include "gimple.h"
  54 #include "langhooks.h"
  55 #include "reload.h"
  56 #include "params.h"
  57 #include "df.h"
  58 #include "dwarf2out.h"
  59 #include "opts.h"
  60
  61 /* Processor costs */
  62 static const
  63 struct processor_costs cypress_costs = {
  64   COSTS_N_INSNS (2), /* int load */
  65   COSTS_N_INSNS (2), /* int signed load */
  66   COSTS_N_INSNS (2), /* int zeroed load */
  67   COSTS_N_INSNS (2), /* float load */
  68   COSTS_N_INSNS (5), /* fmov, fneg, fabs */
  69   COSTS_N_INSNS (5), /* fadd, fsub */
  70   COSTS_N_INSNS (1), /* fcmp */
  71   COSTS_N_INSNS (1), /* fmov, fmovr */
  72   COSTS_N_INSNS (7), /* fmul */
  73   COSTS_N_INSNS (37), /* fdivs */
  74   COSTS_N_INSNS (37), /* fdivd */
  75   COSTS_N_INSNS (63), /* fsqrts */
  76   COSTS_N_INSNS (63), /* fsqrtd */
  77   COSTS_N_INSNS (1), /* imul */
  78   COSTS_N_INSNS (1), /* imulX */
  79   0, /* imul bit factor */
  80   COSTS_N_INSNS (1), /* idiv */
  81   COSTS_N_INSNS (1), /* idivX */
  82   COSTS_N_INSNS (1), /* movcc/movr */
  83   0, /* shift penalty */
  84 };
  85
  86 static const
  87 struct processor_costs supersparc_costs = {
  88   COSTS_N_INSNS (1), /* int load */
  89   COSTS_N_INSNS (1), /* int signed load */
  90   COSTS_N_INSNS (1), /* int zeroed load */
  91   COSTS_N_INSNS (0), /* float load */
  92   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
  93   COSTS_N_INSNS (3), /* fadd, fsub */
  94   COSTS_N_INSNS (3), /* fcmp */
  95   COSTS_N_INSNS (1), /* fmov, fmovr */
  96   COSTS_N_INSNS (3), /* fmul */
  97   COSTS_N_INSNS (6), /* fdivs */
  98   COSTS_N_INSNS (9), /* fdivd */
  99   COSTS_N_INSNS (12), /* fsqrts */
 100   COSTS_N_INSNS (12), /* fsqrtd */
 101   COSTS_N_INSNS (4), /* imul */
 102   COSTS_N_INSNS (4), /* imulX */
 103   0, /* imul bit factor */
 104   COSTS_N_INSNS (4), /* idiv */
 105   COSTS_N_INSNS (4), /* idivX */
 106   COSTS_N_INSNS (1), /* movcc/movr */
 107   1, /* shift penalty */
 108 };
 109
 110 static const
 111 struct processor_costs hypersparc_costs = {
 112   COSTS_N_INSNS (1), /* int load */
 113   COSTS_N_INSNS (1), /* int signed load */
 114   COSTS_N_INSNS (1), /* int zeroed load */
 115   COSTS_N_INSNS (1), /* float load */
 116   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 117   COSTS_N_INSNS (1), /* fadd, fsub */
 118   COSTS_N_INSNS (1), /* fcmp */
 119   COSTS_N_INSNS (1), /* fmov, fmovr */
 120   COSTS_N_INSNS (1), /* fmul */
 121   COSTS_N_INSNS (8), /* fdivs */
 122   COSTS_N_INSNS (12), /* fdivd */
 123   COSTS_N_INSNS (17), /* fsqrts */
 124   COSTS_N_INSNS (17), /* fsqrtd */
 125   COSTS_N_INSNS (17), /* imul */
 126   COSTS_N_INSNS (17), /* imulX */
 127   0, /* imul bit factor */
 128   COSTS_N_INSNS (17), /* idiv */
 129   COSTS_N_INSNS (17), /* idivX */
 130   COSTS_N_INSNS (1), /* movcc/movr */
 131   0, /* shift penalty */
 132 };
 133
 134 static const
 135 struct processor_costs leon_costs = {
 136   COSTS_N_INSNS (1), /* int load */
 137   COSTS_N_INSNS (1), /* int signed load */
 138   COSTS_N_INSNS (1), /* int zeroed load */
 139   COSTS_N_INSNS (1), /* float load */
 140   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 141   COSTS_N_INSNS (1), /* fadd, fsub */
 142   COSTS_N_INSNS (1), /* fcmp */
 143   COSTS_N_INSNS (1), /* fmov, fmovr */
 144   COSTS_N_INSNS (1), /* fmul */
 145   COSTS_N_INSNS (15), /* fdivs */
 146   COSTS_N_INSNS (15), /* fdivd */
 147   COSTS_N_INSNS (23), /* fsqrts */
 148   COSTS_N_INSNS (23), /* fsqrtd */
 149   COSTS_N_INSNS (5), /* imul */
 150   COSTS_N_INSNS (5), /* imulX */
 151   0, /* imul bit factor */
 152   COSTS_N_INSNS (5), /* idiv */
 153   COSTS_N_INSNS (5), /* idivX */
 154   COSTS_N_INSNS (1), /* movcc/movr */
 155   0, /* shift penalty */
 156 };
 157
 158 static const
 159 struct processor_costs sparclet_costs = {
 160   COSTS_N_INSNS (3), /* int load */
 161   COSTS_N_INSNS (3), /* int signed load */
 162   COSTS_N_INSNS (1), /* int zeroed load */
 163   COSTS_N_INSNS (1), /* float load */
 164   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 165   COSTS_N_INSNS (1), /* fadd, fsub */
 166   COSTS_N_INSNS (1), /* fcmp */
 167   COSTS_N_INSNS (1), /* fmov, fmovr */
 168   COSTS_N_INSNS (1), /* fmul */
 169   COSTS_N_INSNS (1), /* fdivs */
 170   COSTS_N_INSNS (1), /* fdivd */
 171   COSTS_N_INSNS (1), /* fsqrts */
 172   COSTS_N_INSNS (1), /* fsqrtd */
 173   COSTS_N_INSNS (5), /* imul */
 174   COSTS_N_INSNS (5), /* imulX */
 175   0, /* imul bit factor */
 176   COSTS_N_INSNS (5), /* idiv */
 177   COSTS_N_INSNS (5), /* idivX */
 178   COSTS_N_INSNS (1), /* movcc/movr */
 179   0, /* shift penalty */
 180 };
 181
 182 static const
 183 struct processor_costs ultrasparc_costs = {
 184   COSTS_N_INSNS (2), /* int load */
 185   COSTS_N_INSNS (3), /* int signed load */
 186   COSTS_N_INSNS (2), /* int zeroed load */
 187   COSTS_N_INSNS (2), /* float load */
 188   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 189   COSTS_N_INSNS (4), /* fadd, fsub */
 190   COSTS_N_INSNS (1), /* fcmp */
 191   COSTS_N_INSNS (2), /* fmov, fmovr */
 192   COSTS_N_INSNS (4), /* fmul */
 193   COSTS_N_INSNS (13), /* fdivs */
 194   COSTS_N_INSNS (23), /* fdivd */
 195   COSTS_N_INSNS (13), /* fsqrts */
 196   COSTS_N_INSNS (23), /* fsqrtd */
 197   COSTS_N_INSNS (4), /* imul */
 198   COSTS_N_INSNS (4), /* imulX */
 199   2, /* imul bit factor */
 200   COSTS_N_INSNS (37), /* idiv */
 201   COSTS_N_INSNS (68), /* idivX */
 202   COSTS_N_INSNS (2), /* movcc/movr */
 203   2, /* shift penalty */
 204 };
 205
 206 static const
 207 struct processor_costs ultrasparc3_costs = {
 208   COSTS_N_INSNS (2), /* int load */
 209   COSTS_N_INSNS (3), /* int signed load */
 210   COSTS_N_INSNS (3), /* int zeroed load */
 211   COSTS_N_INSNS (2), /* float load */
 212   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
 213   COSTS_N_INSNS (4), /* fadd, fsub */
 214   COSTS_N_INSNS (5), /* fcmp */
 215   COSTS_N_INSNS (3), /* fmov, fmovr */
 216   COSTS_N_INSNS (4), /* fmul */
 217   COSTS_N_INSNS (17), /* fdivs */
 218   COSTS_N_INSNS (20), /* fdivd */
 219   COSTS_N_INSNS (20), /* fsqrts */
 220   COSTS_N_INSNS (29), /* fsqrtd */
 221   COSTS_N_INSNS (6), /* imul */
 222   COSTS_N_INSNS (6), /* imulX */
 223   0, /* imul bit factor */
 224   COSTS_N_INSNS (40), /* idiv */
 225   COSTS_N_INSNS (71), /* idivX */
 226   COSTS_N_INSNS (2), /* movcc/movr */
 227   0, /* shift penalty */
 228 };
 229
 230 static const
 231 struct processor_costs niagara_costs = {
 232   COSTS_N_INSNS (3), /* int load */
 233   COSTS_N_INSNS (3), /* int signed load */
 234   COSTS_N_INSNS (3), /* int zeroed load */
 235   COSTS_N_INSNS (9), /* float load */
 236   COSTS_N_INSNS (8), /* fmov, fneg, fabs */
 237   COSTS_N_INSNS (8), /* fadd, fsub */
 238   COSTS_N_INSNS (26), /* fcmp */
 239   COSTS_N_INSNS (8), /* fmov, fmovr */
 240   COSTS_N_INSNS (29), /* fmul */
 241   COSTS_N_INSNS (54), /* fdivs */
 242   COSTS_N_INSNS (83), /* fdivd */
 243   COSTS_N_INSNS (100), /* fsqrts - not implemented in hardware */
 244   COSTS_N_INSNS (100), /* fsqrtd - not implemented in hardware */
 245   COSTS_N_INSNS (11), /* imul */
 246   COSTS_N_INSNS (11), /* imulX */
 247   0, /* imul bit factor */
 248   COSTS_N_INSNS (72), /* idiv */
 249   COSTS_N_INSNS (72), /* idivX */
 250   COSTS_N_INSNS (1), /* movcc/movr */
 251   0, /* shift penalty */
 252 };
 253
 254 static const
 255 struct processor_costs niagara2_costs = {
 256   COSTS_N_INSNS (3), /* int load */
 257   COSTS_N_INSNS (3), /* int signed load */
 258   COSTS_N_INSNS (3), /* int zeroed load */
 259   COSTS_N_INSNS (3), /* float load */
 260   COSTS_N_INSNS (6), /* fmov, fneg, fabs */
 261   COSTS_N_INSNS (6), /* fadd, fsub */
 262   COSTS_N_INSNS (6), /* fcmp */
 263   COSTS_N_INSNS (6), /* fmov, fmovr */
 264   COSTS_N_INSNS (6), /* fmul */
 265   COSTS_N_INSNS (19), /* fdivs */
 266   COSTS_N_INSNS (33), /* fdivd */
 267   COSTS_N_INSNS (19), /* fsqrts */
 268   COSTS_N_INSNS (33), /* fsqrtd */
 269   COSTS_N_INSNS (5), /* imul */
 270   COSTS_N_INSNS (5), /* imulX */
 271   0, /* imul bit factor */
 272   COSTS_N_INSNS (26), /* idiv, average of 12 - 41 cycle range */
 273   COSTS_N_INSNS (26), /* idivX, average of 12 - 41 cycle range */
 274   COSTS_N_INSNS (1), /* movcc/movr */
 275   0, /* shift penalty */
 276 };
 277
 278 static const
 279 struct processor_costs niagara3_costs = {
 280   COSTS_N_INSNS (3), /* int load */
 281   COSTS_N_INSNS (3), /* int signed load */
 282   COSTS_N_INSNS (3), /* int zeroed load */
 283   COSTS_N_INSNS (3), /* float load */
 284   COSTS_N_INSNS (9), /* fmov, fneg, fabs */
 285   COSTS_N_INSNS (9), /* fadd, fsub */
 286   COSTS_N_INSNS (9), /* fcmp */
 287   COSTS_N_INSNS (9), /* fmov, fmovr */
 288   COSTS_N_INSNS (9), /* fmul */
 289   COSTS_N_INSNS (23), /* fdivs */
 290   COSTS_N_INSNS (37), /* fdivd */
 291   COSTS_N_INSNS (23), /* fsqrts */
 292   COSTS_N_INSNS (37), /* fsqrtd */
 293   COSTS_N_INSNS (9), /* imul */
 294   COSTS_N_INSNS (9), /* imulX */
 295   0, /* imul bit factor */
 296   COSTS_N_INSNS (31), /* idiv, average of 17 - 45 cycle range */
 297   COSTS_N_INSNS (30), /* idivX, average of 16 - 44 cycle range */
 298   COSTS_N_INSNS (1), /* movcc/movr */
 299   0, /* shift penalty */
 300 };
 301
 302 const struct processor_costs *sparc_costs = &cypress_costs;
 303
 304 #ifdef HAVE_AS_RELAX_OPTION
 305 /* If 'as' and 'ld' are relaxing tail call insns into branch always, use
 306    "or %o7,%g0,X; call Y; or X,%g0,%o7" always, so that it can be optimized.
 307    With sethi/jmp, neither 'as' nor 'ld' has an easy way how to find out if
 308    somebody does not branch between the sethi and jmp.  */
 309 #define LEAF_SIBCALL_SLOT_RESERVED_P 1
 310 #else
 311 #define LEAF_SIBCALL_SLOT_RESERVED_P \
 312   ((TARGET_ARCH64 && !TARGET_CM_MEDLOW) || flag_pic)
 313 #endif
 314
 315 /* Vector to say how input registers are mapped to output registers.
 316    HARD_FRAME_POINTER_REGNUM cannot be remapped by this function to
 317    eliminate it.  You must use -fomit-frame-pointer to get that.  */
 318 char leaf_reg_remap[] =
 319 { 0, 1, 2, 3, 4, 5, 6, 7,
 320   -1, -1, -1, -1, -1, -1, 14, -1,
 321   -1, -1, -1, -1, -1, -1, -1, -1,
 322   8, 9, 10, 11, 12, 13, -1, 15,
 323
 324   32, 33, 34, 35, 36, 37, 38, 39,
 325   40, 41, 42, 43, 44, 45, 46, 47,
 326   48, 49, 50, 51, 52, 53, 54, 55,
 327   56, 57, 58, 59, 60, 61, 62, 63,
 328   64, 65, 66, 67, 68, 69, 70, 71,
 329   72, 73, 74, 75, 76, 77, 78, 79,
 330   80, 81, 82, 83, 84, 85, 86, 87,
 331   88, 89, 90, 91, 92, 93, 94, 95,
 332   96, 97, 98, 99, 100, 101, 102};
 333
 334 /* Vector, indexed by hard register number, which contains 1
 335    for a register that is allowable in a candidate for leaf
 336    function treatment.  */
 337 char sparc_leaf_regs[] =
 338 { 1, 1, 1, 1, 1, 1, 1, 1,
 339   0, 0, 0, 0, 0, 0, 1, 0,
 340   0, 0, 0, 0, 0, 0, 0, 0,
 341   1, 1, 1, 1, 1, 1, 0, 1,
 342   1, 1, 1, 1, 1, 1, 1, 1,
 343   1, 1, 1, 1, 1, 1, 1, 1,
 344   1, 1, 1, 1, 1, 1, 1, 1,
 345   1, 1, 1, 1, 1, 1, 1, 1,
 346   1, 1, 1, 1, 1, 1, 1, 1,
 347   1, 1, 1, 1, 1, 1, 1, 1,
 348   1, 1, 1, 1, 1, 1, 1, 1,
 349   1, 1, 1, 1, 1, 1, 1, 1,
 350   1, 1, 1, 1, 1, 1, 1};
 351
 352 struct GTY(()) machine_function
 353 {
 354   /* Size of the frame of the function.  */
 355   HOST_WIDE_INT frame_size;
 356
 357   /* Size of the frame of the function minus the register window save area
 358      and the outgoing argument area.  */
 359   HOST_WIDE_INT apparent_frame_size;
 360
 361   /* Register we pretend the frame pointer is allocated to.  Normally, this
 362      is %fp, but if we are in a leaf procedure, this is (%sp + offset).  We
 363      record "offset" separately as it may be too big for (reg + disp).  */
 364   rtx frame_base_reg;
 365   HOST_WIDE_INT frame_base_offset;
 366
 367   /* Some local-dynamic TLS symbol name.  */
 368   const char *some_ld_name;
 369
 370   /* Number of global or FP registers to be saved (as 4-byte quantities).  */
 371   int n_global_fp_regs;
 372
 373   /* True if the current function is leaf and uses only leaf regs,
 374      so that the SPARC leaf function optimization can be applied.
 375      Private version of current_function_uses_only_leaf_regs, see
 376      sparc_expand_prologue for the rationale.  */
 377   int leaf_function_p;
 378
 379   /* True if the prologue saves local or in registers.  */
 380   bool save_local_in_regs_p;
 381
 382   /* True if the data calculated by sparc_expand_prologue are valid.  */
 383   bool prologue_data_valid_p;
 384 };
 385
 386 #define sparc_frame_size                cfun->machine->frame_size
 387 #define sparc_apparent_frame_size       cfun->machine->apparent_frame_size
 388 #define sparc_frame_base_reg            cfun->machine->frame_base_reg
 389 #define sparc_frame_base_offset         cfun->machine->frame_base_offset
 390 #define sparc_n_global_fp_regs          cfun->machine->n_global_fp_regs
 391 #define sparc_leaf_function_p           cfun->machine->leaf_function_p
 392 #define sparc_save_local_in_regs_p      cfun->machine->save_local_in_regs_p
 393 #define sparc_prologue_data_valid_p     cfun->machine->prologue_data_valid_p
 394
 395 /* 1 if the next opcode is to be specially indented.  */
 396 int sparc_indent_opcode = 0;
 397
 398 static void sparc_option_override (void);
 399 static void sparc_init_modes (void);
 400 static void scan_record_type (const_tree, int *, int *, int *);
 401 static int function_arg_slotno (const CUMULATIVE_ARGS *, enum machine_mode,
 402                                 const_tree, bool, bool, int *, int *);
 403
 404 static int supersparc_adjust_cost (rtx, rtx, rtx, int);
 405 static int hypersparc_adjust_cost (rtx, rtx, rtx, int);
 406
 407 static void sparc_emit_set_const32 (rtx, rtx);
 408 static void sparc_emit_set_const64 (rtx, rtx);
 409 static void sparc_output_addr_vec (rtx);
 410 static void sparc_output_addr_diff_vec (rtx);
 411 static void sparc_output_deferred_case_vectors (void);
 412 static bool sparc_legitimate_address_p (enum machine_mode, rtx, bool);
 413 static bool sparc_legitimate_constant_p (enum machine_mode, rtx);
 414 static rtx sparc_builtin_saveregs (void);
 415 static int epilogue_renumber (rtx *, int);
 416 static bool sparc_assemble_integer (rtx, unsigned int, int);
 417 static int set_extends (rtx);
 418 static void sparc_asm_function_prologue (FILE *, HOST_WIDE_INT);
 419 static void sparc_asm_function_epilogue (FILE *, HOST_WIDE_INT);
 420 #ifdef TARGET_SOLARIS
 421 static void sparc_solaris_elf_asm_named_section (const char *, unsigned int,
 422                                                  tree) ATTRIBUTE_UNUSED;
 423 #endif
 424 static int sparc_adjust_cost (rtx, rtx, rtx, int);
 425 static int sparc_issue_rate (void);
 426 static void sparc_sched_init (FILE *, int, int);
 427 static int sparc_use_sched_lookahead (void);
 428
 429 static void emit_soft_tfmode_libcall (const char *, int, rtx *);
 430 static void emit_soft_tfmode_binop (enum rtx_code, rtx *);
 431 static void emit_soft_tfmode_unop (enum rtx_code, rtx *);
 432 static void emit_soft_tfmode_cvt (enum rtx_code, rtx *);
 433 static void emit_hard_tfmode_operation (enum rtx_code, rtx *);
 434
 435 static bool sparc_function_ok_for_sibcall (tree, tree);
 436 static void sparc_init_libfuncs (void);
 437 static void sparc_init_builtins (void);
 438 static void sparc_vis_init_builtins (void);
 439 static rtx sparc_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 440 static tree sparc_fold_builtin (tree, int, tree *, bool);
 441 static int sparc_vis_mul8x16 (int, int);
 442 static tree sparc_handle_vis_mul8x16 (int, tree, tree, tree);
 443 static void sparc_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 444                                    HOST_WIDE_INT, tree);
 445 static bool sparc_can_output_mi_thunk (const_tree, HOST_WIDE_INT,
 446                                        HOST_WIDE_INT, const_tree);
 447 static struct machine_function * sparc_init_machine_status (void);
 448 static bool sparc_cannot_force_const_mem (enum machine_mode, rtx);
 449 static rtx sparc_tls_get_addr (void);
 450 static rtx sparc_tls_got (void);
 451 static const char *get_some_local_dynamic_name (void);
 452 static int get_some_local_dynamic_name_1 (rtx *, void *);
 453 static int sparc_register_move_cost (enum machine_mode,
 454                                      reg_class_t, reg_class_t);
 455 static bool sparc_rtx_costs (rtx, int, int, int, int *, bool);
 456 static rtx sparc_function_value (const_tree, const_tree, bool);
 457 static rtx sparc_libcall_value (enum machine_mode, const_rtx);
 458 static bool sparc_function_value_regno_p (const unsigned int);
 459 static rtx sparc_struct_value_rtx (tree, int);
 460 static enum machine_mode sparc_promote_function_mode (const_tree, enum machine_mode,
 461                                                       int *, const_tree, int);
 462 static bool sparc_return_in_memory (const_tree, const_tree);
 463 static bool sparc_strict_argument_naming (cumulative_args_t);
 464 static void sparc_va_start (tree, rtx);
 465 static tree sparc_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
 466 static bool sparc_vector_mode_supported_p (enum machine_mode);
 467 static bool sparc_tls_referenced_p (rtx);
 468 static rtx sparc_legitimize_tls_address (rtx);
 469 static rtx sparc_legitimize_pic_address (rtx, rtx);
 470 static rtx sparc_legitimize_address (rtx, rtx, enum machine_mode);
 471 static rtx sparc_delegitimize_address (rtx);
 472 static bool sparc_mode_dependent_address_p (const_rtx);
 473 static bool sparc_pass_by_reference (cumulative_args_t,
 474                                      enum machine_mode, const_tree, bool);
 475 static void sparc_function_arg_advance (cumulative_args_t,
 476                                         enum machine_mode, const_tree, bool);
 477 static rtx sparc_function_arg_1 (cumulative_args_t,
 478                                  enum machine_mode, const_tree, bool, bool);
 479 static rtx sparc_function_arg (cumulative_args_t,
 480                                enum machine_mode, const_tree, bool);
 481 static rtx sparc_function_incoming_arg (cumulative_args_t,
 482                                         enum machine_mode, const_tree, bool);
 483 static unsigned int sparc_function_arg_boundary (enum machine_mode,
 484                                                  const_tree);
 485 static int sparc_arg_partial_bytes (cumulative_args_t,
 486                                     enum machine_mode, tree, bool);
 487 static void sparc_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
 488 static void sparc_file_end (void);
 489 static bool sparc_frame_pointer_required (void);
 490 static bool sparc_can_eliminate (const int, const int);
 491 static rtx sparc_builtin_setjmp_frame_value (void);
 492 static void sparc_conditional_register_usage (void);
 493 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
 494 static const char *sparc_mangle_type (const_tree);
 495 #endif
 496 static void sparc_trampoline_init (rtx, tree, rtx);
 497 static enum machine_mode sparc_preferred_simd_mode (enum machine_mode);
 498 static reg_class_t sparc_preferred_reload_class (rtx x, reg_class_t rclass);
 499 static bool sparc_print_operand_punct_valid_p (unsigned char);
 500 static void sparc_print_operand (FILE *, rtx, int);
 501 static void sparc_print_operand_address (FILE *, rtx);
 502 \f
 503 #ifdef SUBTARGET_ATTRIBUTE_TABLE
 504 /* Table of valid machine attributes.  */
 505 static const struct attribute_spec sparc_attribute_table[] =
 506 {
 507   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
 508        do_diagnostic } */
 509   SUBTARGET_ATTRIBUTE_TABLE,
 510   { NULL,        0, 0, false, false, false, NULL, false }
 511 };
 512 #endif
 513 \f
 514 /* Option handling.  */
 515
 516 /* Parsed value.  */
 517 enum cmodel sparc_cmodel;
 518
 519 char sparc_hard_reg_printed[8];
 520
 521 /* Initialize the GCC target structure.  */
 522
 523 /* The default is to use .half rather than .short for aligned HI objects.  */
 524 #undef TARGET_ASM_ALIGNED_HI_OP
 525 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
 526
 527 #undef TARGET_ASM_UNALIGNED_HI_OP
 528 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uahalf\t"
 529 #undef TARGET_ASM_UNALIGNED_SI_OP
 530 #define TARGET_ASM_UNALIGNED_SI_OP "\t.uaword\t"
 531 #undef TARGET_ASM_UNALIGNED_DI_OP
 532 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaxword\t"
 533
 534 /* The target hook has to handle DI-mode values.  */
 535 #undef TARGET_ASM_INTEGER
 536 #define TARGET_ASM_INTEGER sparc_assemble_integer
 537
 538 #undef TARGET_ASM_FUNCTION_PROLOGUE
 539 #define TARGET_ASM_FUNCTION_PROLOGUE sparc_asm_function_prologue
 540 #undef TARGET_ASM_FUNCTION_EPILOGUE
 541 #define TARGET_ASM_FUNCTION_EPILOGUE sparc_asm_function_epilogue
 542
 543 #undef TARGET_SCHED_ADJUST_COST
 544 #define TARGET_SCHED_ADJUST_COST sparc_adjust_cost
 545 #undef TARGET_SCHED_ISSUE_RATE
 546 #define TARGET_SCHED_ISSUE_RATE sparc_issue_rate
 547 #undef TARGET_SCHED_INIT
 548 #define TARGET_SCHED_INIT sparc_sched_init
 549 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
 550 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD sparc_use_sched_lookahead
 551
 552 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 553 #define TARGET_FUNCTION_OK_FOR_SIBCALL sparc_function_ok_for_sibcall
 554
 555 #undef TARGET_INIT_LIBFUNCS
 556 #define TARGET_INIT_LIBFUNCS sparc_init_libfuncs
 557 #undef TARGET_INIT_BUILTINS
 558 #define TARGET_INIT_BUILTINS sparc_init_builtins
 559
 560 #undef TARGET_LEGITIMIZE_ADDRESS
 561 #define TARGET_LEGITIMIZE_ADDRESS sparc_legitimize_address
 562 #undef TARGET_DELEGITIMIZE_ADDRESS
 563 #define TARGET_DELEGITIMIZE_ADDRESS sparc_delegitimize_address
 564 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
 565 #define TARGET_MODE_DEPENDENT_ADDRESS_P sparc_mode_dependent_address_p
 566
 567 #undef TARGET_EXPAND_BUILTIN
 568 #define TARGET_EXPAND_BUILTIN sparc_expand_builtin
 569 #undef TARGET_FOLD_BUILTIN
 570 #define TARGET_FOLD_BUILTIN sparc_fold_builtin
 571
 572 #if TARGET_TLS
 573 #undef TARGET_HAVE_TLS
 574 #define TARGET_HAVE_TLS true
 575 #endif
 576
 577 #undef TARGET_CANNOT_FORCE_CONST_MEM
 578 #define TARGET_CANNOT_FORCE_CONST_MEM sparc_cannot_force_const_mem
 579
 580 #undef TARGET_ASM_OUTPUT_MI_THUNK
 581 #define TARGET_ASM_OUTPUT_MI_THUNK sparc_output_mi_thunk
 582 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 583 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK sparc_can_output_mi_thunk
 584
 585 #undef TARGET_RTX_COSTS
 586 #define TARGET_RTX_COSTS sparc_rtx_costs
 587 #undef TARGET_ADDRESS_COST
 588 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
 589 #undef TARGET_REGISTER_MOVE_COST
 590 #define TARGET_REGISTER_MOVE_COST sparc_register_move_cost
 591
 592 #undef TARGET_PROMOTE_FUNCTION_MODE
 593 #define TARGET_PROMOTE_FUNCTION_MODE sparc_promote_function_mode
 594
 595 #undef TARGET_FUNCTION_VALUE
 596 #define TARGET_FUNCTION_VALUE sparc_function_value
 597 #undef TARGET_LIBCALL_VALUE
 598 #define TARGET_LIBCALL_VALUE sparc_libcall_value
 599 #undef TARGET_FUNCTION_VALUE_REGNO_P
 600 #define TARGET_FUNCTION_VALUE_REGNO_P sparc_function_value_regno_p
 601
 602 #undef TARGET_STRUCT_VALUE_RTX
 603 #define TARGET_STRUCT_VALUE_RTX sparc_struct_value_rtx
 604 #undef TARGET_RETURN_IN_MEMORY
 605 #define TARGET_RETURN_IN_MEMORY sparc_return_in_memory
 606 #undef TARGET_MUST_PASS_IN_STACK
 607 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 608 #undef TARGET_PASS_BY_REFERENCE
 609 #define TARGET_PASS_BY_REFERENCE sparc_pass_by_reference
 610 #undef TARGET_ARG_PARTIAL_BYTES
 611 #define TARGET_ARG_PARTIAL_BYTES sparc_arg_partial_bytes
 612 #undef TARGET_FUNCTION_ARG_ADVANCE
 613 #define TARGET_FUNCTION_ARG_ADVANCE sparc_function_arg_advance
 614 #undef TARGET_FUNCTION_ARG
 615 #define TARGET_FUNCTION_ARG sparc_function_arg
 616 #undef TARGET_FUNCTION_INCOMING_ARG
 617 #define TARGET_FUNCTION_INCOMING_ARG sparc_function_incoming_arg
 618 #undef TARGET_FUNCTION_ARG_BOUNDARY
 619 #define TARGET_FUNCTION_ARG_BOUNDARY sparc_function_arg_boundary
 620
 621 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 622 #define TARGET_EXPAND_BUILTIN_SAVEREGS sparc_builtin_saveregs
 623 #undef TARGET_STRICT_ARGUMENT_NAMING
 624 #define TARGET_STRICT_ARGUMENT_NAMING sparc_strict_argument_naming
 625
 626 #undef TARGET_EXPAND_BUILTIN_VA_START
 627 #define TARGET_EXPAND_BUILTIN_VA_START sparc_va_start
 628 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 629 #define TARGET_GIMPLIFY_VA_ARG_EXPR sparc_gimplify_va_arg
 630
 631 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 632 #define TARGET_VECTOR_MODE_SUPPORTED_P sparc_vector_mode_supported_p
 633
 634 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
 635 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE sparc_preferred_simd_mode
 636
 637 #ifdef SUBTARGET_INSERT_ATTRIBUTES
 638 #undef TARGET_INSERT_ATTRIBUTES
 639 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
 640 #endif
 641
 642 #ifdef SUBTARGET_ATTRIBUTE_TABLE
 643 #undef TARGET_ATTRIBUTE_TABLE
 644 #define TARGET_ATTRIBUTE_TABLE sparc_attribute_table
 645 #endif
 646
 647 #undef TARGET_RELAXED_ORDERING
 648 #define TARGET_RELAXED_ORDERING SPARC_RELAXED_ORDERING
 649
 650 #undef TARGET_OPTION_OVERRIDE
 651 #define TARGET_OPTION_OVERRIDE sparc_option_override
 652
 653 #if TARGET_GNU_TLS && defined(HAVE_AS_SPARC_UA_PCREL)
 654 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
 655 #define TARGET_ASM_OUTPUT_DWARF_DTPREL sparc_output_dwarf_dtprel
 656 #endif
 657
 658 #undef TARGET_ASM_FILE_END
 659 #define TARGET_ASM_FILE_END sparc_file_end
 660
 661 #undef TARGET_FRAME_POINTER_REQUIRED
 662 #define TARGET_FRAME_POINTER_REQUIRED sparc_frame_pointer_required
 663
 664 #undef TARGET_BUILTIN_SETJMP_FRAME_VALUE
 665 #define TARGET_BUILTIN_SETJMP_FRAME_VALUE sparc_builtin_setjmp_frame_value
 666
 667 #undef TARGET_CAN_ELIMINATE
 668 #define TARGET_CAN_ELIMINATE sparc_can_eliminate
 669
 670 #undef  TARGET_PREFERRED_RELOAD_CLASS
 671 #define TARGET_PREFERRED_RELOAD_CLASS sparc_preferred_reload_class
 672
 673 #undef TARGET_CONDITIONAL_REGISTER_USAGE
 674 #define TARGET_CONDITIONAL_REGISTER_USAGE sparc_conditional_register_usage
 675
 676 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
 677 #undef TARGET_MANGLE_TYPE
 678 #define TARGET_MANGLE_TYPE sparc_mangle_type
 679 #endif
 680
 681 #undef TARGET_LEGITIMATE_ADDRESS_P
 682 #define TARGET_LEGITIMATE_ADDRESS_P sparc_legitimate_address_p
 683
 684 #undef TARGET_LEGITIMATE_CONSTANT_P
 685 #define TARGET_LEGITIMATE_CONSTANT_P sparc_legitimate_constant_p
 686
 687 #undef TARGET_TRAMPOLINE_INIT
 688 #define TARGET_TRAMPOLINE_INIT sparc_trampoline_init
 689
 690 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
 691 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P sparc_print_operand_punct_valid_p
 692 #undef TARGET_PRINT_OPERAND
 693 #define TARGET_PRINT_OPERAND sparc_print_operand
 694 #undef TARGET_PRINT_OPERAND_ADDRESS
 695 #define TARGET_PRINT_OPERAND_ADDRESS sparc_print_operand_address
 696
 697 struct gcc_target targetm = TARGET_INITIALIZER;
 698
 699 /* Validate and override various options, and do some machine dependent
 700    initialization.  */
 701
 702 static void
 703 sparc_option_override (void)
 704 {
 705   static struct code_model {
 706     const char *const name;
 707     const enum cmodel value;
 708   } const cmodels[] = {
 709     { "32", CM_32 },
 710     { "medlow", CM_MEDLOW },
 711     { "medmid", CM_MEDMID },
 712     { "medany", CM_MEDANY },
 713     { "embmedany", CM_EMBMEDANY },
 714     { NULL, (enum cmodel) 0 }
 715   };
 716   const struct code_model *cmodel;
 717   /* Map TARGET_CPU_DEFAULT to value for -m{cpu,tune}=.  */
 718   static struct cpu_default {
 719     const int cpu;
 720     const enum processor_type processor;
 721   } const cpu_default[] = {
 722     /* There must be one entry here for each TARGET_CPU value.  */
 723     { TARGET_CPU_sparc, PROCESSOR_CYPRESS },
 724     { TARGET_CPU_v8, PROCESSOR_V8 },
 725     { TARGET_CPU_supersparc, PROCESSOR_SUPERSPARC },
 726     { TARGET_CPU_hypersparc, PROCESSOR_HYPERSPARC },
 727     { TARGET_CPU_leon, PROCESSOR_LEON },
 728     { TARGET_CPU_sparclite, PROCESSOR_F930 },
 729     { TARGET_CPU_sparclite86x, PROCESSOR_SPARCLITE86X },
 730     { TARGET_CPU_sparclet, PROCESSOR_TSC701 },
 731     { TARGET_CPU_v9, PROCESSOR_V9 },
 732     { TARGET_CPU_ultrasparc, PROCESSOR_ULTRASPARC },
 733     { TARGET_CPU_ultrasparc3, PROCESSOR_ULTRASPARC3 },
 734     { TARGET_CPU_niagara, PROCESSOR_NIAGARA },
 735     { TARGET_CPU_niagara2, PROCESSOR_NIAGARA2 },
 736     { TARGET_CPU_niagara3, PROCESSOR_NIAGARA3 },
 737     { TARGET_CPU_niagara4, PROCESSOR_NIAGARA4 },
 738     { -1, PROCESSOR_V7 }
 739   };
 740   const struct cpu_default *def;
 741   /* Table of values for -m{cpu,tune}=.  This must match the order of
 742      the PROCESSOR_* enumeration.  */
 743   static struct cpu_table {
 744     const int disable;
 745     const int enable;
 746   } const cpu_table[] = {
 747     { MASK_ISA, 0 },
 748     { MASK_ISA, 0 },
 749     { MASK_ISA, MASK_V8 },
 750     /* TI TMS390Z55 supersparc */
 751     { MASK_ISA, MASK_V8 },
 752     { MASK_ISA, MASK_V8|MASK_FPU },
 753     /* LEON */
 754     { MASK_ISA, MASK_V8|MASK_FPU },
 755     { MASK_ISA, MASK_SPARCLITE },
 756     /* The Fujitsu MB86930 is the original sparclite chip, with no FPU.  */
 757     { MASK_ISA|MASK_FPU, MASK_SPARCLITE },
 758     /* The Fujitsu MB86934 is the recent sparclite chip, with an FPU.  */
 759     { MASK_ISA, MASK_SPARCLITE|MASK_FPU },
 760     { MASK_ISA|MASK_FPU, MASK_SPARCLITE },
 761     { MASK_ISA, MASK_SPARCLET },
 762     /* TEMIC sparclet */
 763     { MASK_ISA, MASK_SPARCLET },
 764     { MASK_ISA, MASK_V9 },
 765     /* UltraSPARC I, II, IIi */
 766     { MASK_ISA,
 767     /* Although insns using %y are deprecated, it is a clear win.  */
 768       MASK_V9|MASK_DEPRECATED_V8_INSNS},
 769     /* UltraSPARC III */
 770     /* ??? Check if %y issue still holds true.  */
 771     { MASK_ISA,
 772       MASK_V9|MASK_DEPRECATED_V8_INSNS},
 773     /* UltraSPARC T1 */
 774     { MASK_ISA,
 775       MASK_V9|MASK_DEPRECATED_V8_INSNS},
 776     /* UltraSPARC T2 */
 777     { MASK_ISA, MASK_V9},
 778     /* UltraSPARC T3 */
 779     { MASK_ISA, MASK_V9 | MASK_FMAF},
 780     /* UltraSPARC T4 */
 781     { MASK_ISA, MASK_V9 | MASK_FMAF},
 782   };
 783   const struct cpu_table *cpu;
 784   unsigned int i;
 785   int fpu;
 786
 787 #ifdef SUBTARGET_OVERRIDE_OPTIONS
 788   SUBTARGET_OVERRIDE_OPTIONS;
 789 #endif
 790
 791 #ifndef SPARC_BI_ARCH
 792   /* Check for unsupported architecture size.  */
 793   if (! TARGET_64BIT != DEFAULT_ARCH32_P)
 794     error ("%s is not supported by this configuration",
 795            DEFAULT_ARCH32_P ? "-m64" : "-m32");
 796 #endif
 797
 798   /* We force all 64bit archs to use 128 bit long double */
 799   if (TARGET_64BIT && ! TARGET_LONG_DOUBLE_128)
 800     {
 801       error ("-mlong-double-64 not allowed with -m64");
 802       target_flags |= MASK_LONG_DOUBLE_128;
 803     }
 804
 805   /* Code model selection.  */
 806   sparc_cmodel = SPARC_DEFAULT_CMODEL;
 807
 808 #ifdef SPARC_BI_ARCH
 809   if (TARGET_ARCH32)
 810     sparc_cmodel = CM_32;
 811 #endif
 812
 813   if (sparc_cmodel_string != NULL)
 814     {
 815       if (TARGET_ARCH64)
 816         {
 817           for (cmodel = &cmodels[0]; cmodel->name; cmodel++)
 818             if (strcmp (sparc_cmodel_string, cmodel->name) == 0)
 819               break;
 820           if (cmodel->name == NULL)
 821             error ("bad value (%s) for -mcmodel= switch", sparc_cmodel_string);
 822           else
 823             sparc_cmodel = cmodel->value;
 824         }
 825       else
 826         error ("-mcmodel= is not supported on 32 bit systems");
 827     }
 828
 829   /* Check that -fcall-saved-REG wasn't specified for out registers.  */
 830   for (i = 8; i < 16; i++)
 831     if (!call_used_regs [i])
 832       {
 833         error ("-fcall-saved-REG is not supported for out registers");
 834         call_used_regs [i] = 1;
 835       }
 836
 837   fpu = target_flags & MASK_FPU; /* save current -mfpu status */
 838
 839   /* Set the default CPU.  */
 840   if (!global_options_set.x_sparc_cpu_and_features)
 841     {
 842       for (def = &cpu_default[0]; def->cpu != -1; ++def)
 843         if (def->cpu == TARGET_CPU_DEFAULT)
 844           break;
 845       gcc_assert (def->cpu != -1);
 846       sparc_cpu_and_features = def->processor;
 847     }
 848   if (!global_options_set.x_sparc_cpu)
 849     sparc_cpu = sparc_cpu_and_features;
 850
 851   cpu = &cpu_table[(int) sparc_cpu_and_features];
 852   target_flags &= ~cpu->disable;
 853   target_flags |= cpu->enable;
 854
 855   /* If -mfpu or -mno-fpu was explicitly used, don't override with
 856      the processor default.  */
 857   if (target_flags_explicit & MASK_FPU)
 858     target_flags = (target_flags & ~MASK_FPU) | fpu;
 859
 860   /* Don't allow -mvis or -mfmaf if FPU is disabled.  */
 861   if (! TARGET_FPU)
 862     target_flags &= ~(MASK_VIS | MASK_FMAF);
 863
 864   /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
 865      are available.
 866      -m64 also implies v9.  */
 867   if (TARGET_VIS || TARGET_ARCH64)
 868     {
 869       target_flags |= MASK_V9;
 870       target_flags &= ~(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE);
 871     }
 872
 873   /* -mvis also implies -mv8plus on 32-bit */
 874   if (TARGET_VIS && ! TARGET_ARCH64)
 875     target_flags |= MASK_V8PLUS;
 876
 877   /* Use the deprecated v8 insns for sparc64 in 32 bit mode.  */
 878   if (TARGET_V9 && TARGET_ARCH32)
 879     target_flags |= MASK_DEPRECATED_V8_INSNS;
 880
 881   /* V8PLUS requires V9, makes no sense in 64 bit mode.  */
 882   if (! TARGET_V9 || TARGET_ARCH64)
 883     target_flags &= ~MASK_V8PLUS;
 884
 885   /* Don't use stack biasing in 32 bit mode.  */
 886   if (TARGET_ARCH32)
 887     target_flags &= ~MASK_STACK_BIAS;
 888
 889   /* Supply a default value for align_functions.  */
 890   if (align_functions == 0
 891       && (sparc_cpu == PROCESSOR_ULTRASPARC
 892           || sparc_cpu == PROCESSOR_ULTRASPARC3
 893           || sparc_cpu == PROCESSOR_NIAGARA
 894           || sparc_cpu == PROCESSOR_NIAGARA2
 895           || sparc_cpu == PROCESSOR_NIAGARA3
 896           || sparc_cpu == PROCESSOR_NIAGARA4))
 897     align_functions = 32;
 898
 899   /* Validate PCC_STRUCT_RETURN.  */
 900   if (flag_pcc_struct_return == DEFAULT_PCC_STRUCT_RETURN)
 901     flag_pcc_struct_return = (TARGET_ARCH64 ? 0 : 1);
 902
 903   /* Only use .uaxword when compiling for a 64-bit target.  */
 904   if (!TARGET_ARCH64)
 905     targetm.asm_out.unaligned_op.di = NULL;
 906
 907   /* Do various machine dependent initializations.  */
 908   sparc_init_modes ();
 909
 910   /* Set up function hooks.  */
 911   init_machine_status = sparc_init_machine_status;
 912
 913   switch (sparc_cpu)
 914     {
 915     case PROCESSOR_V7:
 916     case PROCESSOR_CYPRESS:
 917       sparc_costs = &cypress_costs;
 918       break;
 919     case PROCESSOR_V8:
 920     case PROCESSOR_SPARCLITE:
 921     case PROCESSOR_SUPERSPARC:
 922       sparc_costs = &supersparc_costs;
 923       break;
 924     case PROCESSOR_F930:
 925     case PROCESSOR_F934:
 926     case PROCESSOR_HYPERSPARC:
 927     case PROCESSOR_SPARCLITE86X:
 928       sparc_costs = &hypersparc_costs;
 929       break;
 930     case PROCESSOR_LEON:
 931       sparc_costs = &leon_costs;
 932       break;
 933     case PROCESSOR_SPARCLET:
 934     case PROCESSOR_TSC701:
 935       sparc_costs = &sparclet_costs;
 936       break;
 937     case PROCESSOR_V9:
 938     case PROCESSOR_ULTRASPARC:
 939       sparc_costs = &ultrasparc_costs;
 940       break;
 941     case PROCESSOR_ULTRASPARC3:
 942       sparc_costs = &ultrasparc3_costs;
 943       break;
 944     case PROCESSOR_NIAGARA:
 945       sparc_costs = &niagara_costs;
 946       break;
 947     case PROCESSOR_NIAGARA2:
 948       sparc_costs = &niagara2_costs;
 949       break;
 950     case PROCESSOR_NIAGARA3:
 951     case PROCESSOR_NIAGARA4:
 952       sparc_costs = &niagara3_costs;
 953       break;
 954     case PROCESSOR_NATIVE:
 955       gcc_unreachable ();
 956     };
 957
 958 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
 959   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
 960     target_flags |= MASK_LONG_DOUBLE_128;
 961 #endif
 962
 963   maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
 964                          ((sparc_cpu == PROCESSOR_ULTRASPARC
 965                            || sparc_cpu == PROCESSOR_NIAGARA
 966                            || sparc_cpu == PROCESSOR_NIAGARA2
 967                            || sparc_cpu == PROCESSOR_NIAGARA3
 968                            || sparc_cpu == PROCESSOR_NIAGARA4)
 969                           ? 2
 970                           : (sparc_cpu == PROCESSOR_ULTRASPARC3
 971                              ? 8 : 3)),
 972                          global_options.x_param_values,
 973                          global_options_set.x_param_values);
 974   maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
 975                          ((sparc_cpu == PROCESSOR_ULTRASPARC
 976                            || sparc_cpu == PROCESSOR_ULTRASPARC3
 977                            || sparc_cpu == PROCESSOR_NIAGARA
 978                            || sparc_cpu == PROCESSOR_NIAGARA2
 979                            || sparc_cpu == PROCESSOR_NIAGARA3
 980                            || sparc_cpu == PROCESSOR_NIAGARA4)
 981                           ? 64 : 32),
 982                          global_options.x_param_values,
 983                          global_options_set.x_param_values);
 984
 985   /* Disable save slot sharing for call-clobbered registers by default.
 986      The IRA sharing algorithm works on single registers only and this
 987      pessimizes for double floating-point registers.  */
 988   if (!global_options_set.x_flag_ira_share_save_slots)
 989     flag_ira_share_save_slots = 0;
 990 }
 991 \f
 992 /* Miscellaneous utilities.  */
 993
 994 /* Nonzero if CODE, a comparison, is suitable for use in v9 conditional move
 995    or branch on register contents instructions.  */
 996
 997 int
 998 v9_regcmp_p (enum rtx_code code)
 999 {
1000   return (code == EQ || code == NE || code == GE || code == LT
1001           || code == LE || code == GT);
1002 }
1003
1004 /* Nonzero if OP is a floating point constant which can
1005    be loaded into an integer register using a single
1006    sethi instruction.  */
1007
1008 int
1009 fp_sethi_p (rtx op)
1010 {
1011   if (GET_CODE (op) == CONST_DOUBLE)
1012     {
1013       REAL_VALUE_TYPE r;
1014       long i;
1015
1016       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1017       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1018       return !SPARC_SIMM13_P (i) && SPARC_SETHI_P (i);
1019     }
1020
1021   return 0;
1022 }
1023
1024 /* Nonzero if OP is a floating point constant which can
1025    be loaded into an integer register using a single
1026    mov instruction.  */
1027
1028 int
1029 fp_mov_p (rtx op)
1030 {
1031   if (GET_CODE (op) == CONST_DOUBLE)
1032     {
1033       REAL_VALUE_TYPE r;
1034       long i;
1035
1036       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1037       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1038       return SPARC_SIMM13_P (i);
1039     }
1040
1041   return 0;
1042 }
1043
1044 /* Nonzero if OP is a floating point constant which can
1045    be loaded into an integer register using a high/losum
1046    instruction sequence.  */
1047
1048 int
1049 fp_high_losum_p (rtx op)
1050 {
1051   /* The constraints calling this should only be in
1052      SFmode move insns, so any constant which cannot
1053      be moved using a single insn will do.  */
1054   if (GET_CODE (op) == CONST_DOUBLE)
1055     {
1056       REAL_VALUE_TYPE r;
1057       long i;
1058
1059       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
1060       REAL_VALUE_TO_TARGET_SINGLE (r, i);
1061       return !SPARC_SIMM13_P (i) && !SPARC_SETHI_P (i);
1062     }
1063
1064   return 0;
1065 }
1066
1067 /* Return true if the address of LABEL can be loaded by means of the
1068    mov{si,di}_pic_label_ref patterns in PIC mode.  */
1069
1070 static bool
1071 can_use_mov_pic_label_ref (rtx label)
1072 {
1073   /* VxWorks does not impose a fixed gap between segments; the run-time
1074      gap can be different from the object-file gap.  We therefore can't
1075      assume X - _GLOBAL_OFFSET_TABLE_ is a link-time constant unless we
1076      are absolutely sure that X is in the same segment as the GOT.
1077      Unfortunately, the flexibility of linker scripts means that we
1078      can't be sure of that in general, so assume that GOT-relative
1079      accesses are never valid on VxWorks.  */
1080   if (TARGET_VXWORKS_RTP)
1081     return false;
1082
1083   /* Similarly, if the label is non-local, it might end up being placed
1084      in a different section than the current one; now mov_pic_label_ref
1085      requires the label and the code to be in the same section.  */
1086   if (LABEL_REF_NONLOCAL_P (label))
1087     return false;
1088
1089   /* Finally, if we are reordering basic blocks and partition into hot
1090      and cold sections, this might happen for any label.  */
1091   if (flag_reorder_blocks_and_partition)
1092     return false;
1093
1094   return true;
1095 }
1096
1097 /* Expand a move instruction.  Return true if all work is done.  */
1098
1099 bool
1100 sparc_expand_move (enum machine_mode mode, rtx *operands)
1101 {
1102   /* Handle sets of MEM first.  */
1103   if (GET_CODE (operands[0]) == MEM)
1104     {
1105       /* 0 is a register (or a pair of registers) on SPARC.  */
1106       if (register_or_zero_operand (operands[1], mode))
1107         return false;
1108
1109       if (!reload_in_progress)
1110         {
1111           operands[0] = validize_mem (operands[0]);
1112           operands[1] = force_reg (mode, operands[1]);
1113         }
1114     }
1115
1116   /* Fixup TLS cases.  */
1117   if (TARGET_HAVE_TLS
1118       && CONSTANT_P (operands[1])
1119       && sparc_tls_referenced_p (operands [1]))
1120     {
1121       operands[1] = sparc_legitimize_tls_address (operands[1]);
1122       return false;
1123     }
1124
1125   /* Fixup PIC cases.  */
1126   if (flag_pic && CONSTANT_P (operands[1]))
1127     {
1128       if (pic_address_needs_scratch (operands[1]))
1129         operands[1] = sparc_legitimize_pic_address (operands[1], NULL_RTX);
1130
1131       /* We cannot use the mov{si,di}_pic_label_ref patterns in all cases.  */
1132       if (GET_CODE (operands[1]) == LABEL_REF
1133           && can_use_mov_pic_label_ref (operands[1]))
1134         {
1135           if (mode == SImode)
1136             {
1137               emit_insn (gen_movsi_pic_label_ref (operands[0], operands[1]));
1138               return true;
1139             }
1140
1141           if (mode == DImode)
1142             {
1143               gcc_assert (TARGET_ARCH64);
1144               emit_insn (gen_movdi_pic_label_ref (operands[0], operands[1]));
1145               return true;
1146             }
1147         }
1148
1149       if (symbolic_operand (operands[1], mode))
1150         {
1151           operands[1]
1152             = sparc_legitimize_pic_address (operands[1],
1153                                             reload_in_progress
1154                                             ? operands[0] : NULL_RTX);
1155           return false;
1156         }
1157     }
1158
1159   /* If we are trying to toss an integer constant into FP registers,
1160      or loading a FP or vector constant, force it into memory.  */
1161   if (CONSTANT_P (operands[1])
1162       && REG_P (operands[0])
1163       && (SPARC_FP_REG_P (REGNO (operands[0]))
1164           || SCALAR_FLOAT_MODE_P (mode)
1165           || VECTOR_MODE_P (mode)))
1166     {
1167       /* emit_group_store will send such bogosity to us when it is
1168          not storing directly into memory.  So fix this up to avoid
1169          crashes in output_constant_pool.  */
1170       if (operands [1] == const0_rtx)
1171         operands[1] = CONST0_RTX (mode);
1172
1173       /* We can clear or set to all-ones FP registers if TARGET_VIS, and
1174          always other regs.  */
1175       if ((TARGET_VIS || REGNO (operands[0]) < SPARC_FIRST_FP_REG)
1176           && (const_zero_operand (operands[1], mode)
1177               || const_all_ones_operand (operands[1], mode)))
1178         return false;
1179
1180       if (REGNO (operands[0]) < SPARC_FIRST_FP_REG
1181           /* We are able to build any SF constant in integer registers
1182              with at most 2 instructions.  */
1183           && (mode == SFmode
1184               /* And any DF constant in integer registers.  */
1185               || (mode == DFmode
1186                   && (reload_completed || reload_in_progress))))
1187         return false;
1188
1189       operands[1] = force_const_mem (mode, operands[1]);
1190       if (!reload_in_progress)
1191         operands[1] = validize_mem (operands[1]);
1192       return false;
1193     }
1194
1195   /* Accept non-constants and valid constants unmodified.  */
1196   if (!CONSTANT_P (operands[1])
1197       || GET_CODE (operands[1]) == HIGH
1198       || input_operand (operands[1], mode))
1199     return false;
1200
1201   switch (mode)
1202     {
1203     case QImode:
1204       /* All QImode constants require only one insn, so proceed.  */
1205       break;
1206
1207     case HImode:
1208     case SImode:
1209       sparc_emit_set_const32 (operands[0], operands[1]);
1210       return true;
1211
1212     case DImode:
1213       /* input_operand should have filtered out 32-bit mode.  */
1214       sparc_emit_set_const64 (operands[0], operands[1]);
1215       return true;
1216
1217     default:
1218       gcc_unreachable ();
1219     }
1220
1221   return false;
1222 }
1223
1224 /* Load OP1, a 32-bit constant, into OP0, a register.
1225    We know it can't be done in one insn when we get
1226    here, the move expander guarantees this.  */
1227
1228 static void
1229 sparc_emit_set_const32 (rtx op0, rtx op1)
1230 {
1231   enum machine_mode mode = GET_MODE (op0);
1232   rtx temp;
1233
1234   if (reload_in_progress || reload_completed)
1235     temp = op0;
1236   else
1237     temp = gen_reg_rtx (mode);
1238
1239   if (GET_CODE (op1) == CONST_INT)
1240     {
1241       gcc_assert (!small_int_operand (op1, mode)
1242                   && !const_high_operand (op1, mode));
1243
1244       /* Emit them as real moves instead of a HIGH/LO_SUM,
1245          this way CSE can see everything and reuse intermediate
1246          values if it wants.  */
1247       emit_insn (gen_rtx_SET (VOIDmode, temp,
1248                               GEN_INT (INTVAL (op1)
1249                                 & ~(HOST_WIDE_INT)0x3ff)));
1250
1251       emit_insn (gen_rtx_SET (VOIDmode,
1252                               op0,
1253                               gen_rtx_IOR (mode, temp,
1254                                            GEN_INT (INTVAL (op1) & 0x3ff))));
1255     }
1256   else
1257     {
1258       /* A symbol, emit in the traditional way.  */
1259       emit_insn (gen_rtx_SET (VOIDmode, temp,
1260                               gen_rtx_HIGH (mode, op1)));
1261       emit_insn (gen_rtx_SET (VOIDmode,
1262                               op0, gen_rtx_LO_SUM (mode, temp, op1)));
1263     }
1264 }
1265
1266 /* Load OP1, a symbolic 64-bit constant, into OP0, a DImode register.
1267    If TEMP is nonzero, we are forbidden to use any other scratch
1268    registers.  Otherwise, we are allowed to generate them as needed.
1269
1270    Note that TEMP may have TImode if the code model is TARGET_CM_MEDANY
1271    or TARGET_CM_EMBMEDANY (see the reload_indi and reload_outdi patterns).  */
1272
1273 void
1274 sparc_emit_set_symbolic_const64 (rtx op0, rtx op1, rtx temp)
1275 {
1276   rtx temp1, temp2, temp3, temp4, temp5;
1277   rtx ti_temp = 0;
1278
1279   if (temp && GET_MODE (temp) == TImode)
1280     {
1281       ti_temp = temp;
1282       temp = gen_rtx_REG (DImode, REGNO (temp));
1283     }
1284
1285   /* SPARC-V9 code-model support.  */
1286   switch (sparc_cmodel)
1287     {
1288     case CM_MEDLOW:
1289       /* The range spanned by all instructions in the object is less
1290          than 2^31 bytes (2GB) and the distance from any instruction
1291          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1292          than 2^31 bytes (2GB).
1293
1294          The executable must be in the low 4TB of the virtual address
1295          space.
1296
1297          sethi  %hi(symbol), %temp1
1298          or     %temp1, %lo(symbol), %reg  */
1299       if (temp)
1300         temp1 = temp;  /* op0 is allowed.  */
1301       else
1302         temp1 = gen_reg_rtx (DImode);
1303
1304       emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
1305       emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
1306       break;
1307
1308     case CM_MEDMID:
1309       /* The range spanned by all instructions in the object is less
1310          than 2^31 bytes (2GB) and the distance from any instruction
1311          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1312          than 2^31 bytes (2GB).
1313
1314          The executable must be in the low 16TB of the virtual address
1315          space.
1316
1317          sethi  %h44(symbol), %temp1
1318          or     %temp1, %m44(symbol), %temp2
1319          sllx   %temp2, 12, %temp3
1320          or     %temp3, %l44(symbol), %reg  */
1321       if (temp)
1322         {
1323           temp1 = op0;
1324           temp2 = op0;
1325           temp3 = temp;  /* op0 is allowed.  */
1326         }
1327       else
1328         {
1329           temp1 = gen_reg_rtx (DImode);
1330           temp2 = gen_reg_rtx (DImode);
1331           temp3 = gen_reg_rtx (DImode);
1332         }
1333
1334       emit_insn (gen_seth44 (temp1, op1));
1335       emit_insn (gen_setm44 (temp2, temp1, op1));
1336       emit_insn (gen_rtx_SET (VOIDmode, temp3,
1337                               gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
1338       emit_insn (gen_setl44 (op0, temp3, op1));
1339       break;
1340
1341     case CM_MEDANY:
1342       /* The range spanned by all instructions in the object is less
1343          than 2^31 bytes (2GB) and the distance from any instruction
1344          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1345          than 2^31 bytes (2GB).
1346
1347          The executable can be placed anywhere in the virtual address
1348          space.
1349
1350          sethi  %hh(symbol), %temp1
1351          sethi  %lm(symbol), %temp2
1352          or     %temp1, %hm(symbol), %temp3
1353          sllx   %temp3, 32, %temp4
1354          or     %temp4, %temp2, %temp5
1355          or     %temp5, %lo(symbol), %reg  */
1356       if (temp)
1357         {
1358           /* It is possible that one of the registers we got for operands[2]
1359              might coincide with that of operands[0] (which is why we made
1360              it TImode).  Pick the other one to use as our scratch.  */
1361           if (rtx_equal_p (temp, op0))
1362             {
1363               gcc_assert (ti_temp);
1364               temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1365             }
1366           temp1 = op0;
1367           temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1368           temp3 = op0;
1369           temp4 = op0;
1370           temp5 = op0;
1371         }
1372       else
1373         {
1374           temp1 = gen_reg_rtx (DImode);
1375           temp2 = gen_reg_rtx (DImode);
1376           temp3 = gen_reg_rtx (DImode);
1377           temp4 = gen_reg_rtx (DImode);
1378           temp5 = gen_reg_rtx (DImode);
1379         }
1380
1381       emit_insn (gen_sethh (temp1, op1));
1382       emit_insn (gen_setlm (temp2, op1));
1383       emit_insn (gen_sethm (temp3, temp1, op1));
1384       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1385                               gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1386       emit_insn (gen_rtx_SET (VOIDmode, temp5,
1387                               gen_rtx_PLUS (DImode, temp4, temp2)));
1388       emit_insn (gen_setlo (op0, temp5, op1));
1389       break;
1390
1391     case CM_EMBMEDANY:
1392       /* Old old old backwards compatibility kruft here.
1393          Essentially it is MEDLOW with a fixed 64-bit
1394          virtual base added to all data segment addresses.
1395          Text-segment stuff is computed like MEDANY, we can't
1396          reuse the code above because the relocation knobs
1397          look different.
1398
1399          Data segment:  sethi   %hi(symbol), %temp1
1400                         add     %temp1, EMBMEDANY_BASE_REG, %temp2
1401                         or      %temp2, %lo(symbol), %reg  */
1402       if (data_segment_operand (op1, GET_MODE (op1)))
1403         {
1404           if (temp)
1405             {
1406               temp1 = temp;  /* op0 is allowed.  */
1407               temp2 = op0;
1408             }
1409           else
1410             {
1411               temp1 = gen_reg_rtx (DImode);
1412               temp2 = gen_reg_rtx (DImode);
1413             }
1414
1415           emit_insn (gen_embmedany_sethi (temp1, op1));
1416           emit_insn (gen_embmedany_brsum (temp2, temp1));
1417           emit_insn (gen_embmedany_losum (op0, temp2, op1));
1418         }
1419
1420       /* Text segment:  sethi   %uhi(symbol), %temp1
1421                         sethi   %hi(symbol), %temp2
1422                         or      %temp1, %ulo(symbol), %temp3
1423                         sllx    %temp3, 32, %temp4
1424                         or      %temp4, %temp2, %temp5
1425                         or      %temp5, %lo(symbol), %reg  */
1426       else
1427         {
1428           if (temp)
1429             {
1430               /* It is possible that one of the registers we got for operands[2]
1431                  might coincide with that of operands[0] (which is why we made
1432                  it TImode).  Pick the other one to use as our scratch.  */
1433               if (rtx_equal_p (temp, op0))
1434                 {
1435                   gcc_assert (ti_temp);
1436                   temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1437                 }
1438               temp1 = op0;
1439               temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1440               temp3 = op0;
1441               temp4 = op0;
1442               temp5 = op0;
1443             }
1444           else
1445             {
1446               temp1 = gen_reg_rtx (DImode);
1447               temp2 = gen_reg_rtx (DImode);
1448               temp3 = gen_reg_rtx (DImode);
1449               temp4 = gen_reg_rtx (DImode);
1450               temp5 = gen_reg_rtx (DImode);
1451             }
1452
1453           emit_insn (gen_embmedany_textuhi (temp1, op1));
1454           emit_insn (gen_embmedany_texthi  (temp2, op1));
1455           emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
1456           emit_insn (gen_rtx_SET (VOIDmode, temp4,
1457                                   gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1458           emit_insn (gen_rtx_SET (VOIDmode, temp5,
1459                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1460           emit_insn (gen_embmedany_textlo  (op0, temp5, op1));
1461         }
1462       break;
1463
1464     default:
1465       gcc_unreachable ();
1466     }
1467 }
1468
1469 #if HOST_BITS_PER_WIDE_INT == 32
1470 static void
1471 sparc_emit_set_const64 (rtx op0 ATTRIBUTE_UNUSED, rtx op1 ATTRIBUTE_UNUSED)
1472 {
1473   gcc_unreachable ();
1474 }
1475 #else
1476 /* These avoid problems when cross compiling.  If we do not
1477    go through all this hair then the optimizer will see
1478    invalid REG_EQUAL notes or in some cases none at all.  */
1479 static rtx gen_safe_HIGH64 (rtx, HOST_WIDE_INT);
1480 static rtx gen_safe_SET64 (rtx, HOST_WIDE_INT);
1481 static rtx gen_safe_OR64 (rtx, HOST_WIDE_INT);
1482 static rtx gen_safe_XOR64 (rtx, HOST_WIDE_INT);
1483
1484 /* The optimizer is not to assume anything about exactly
1485    which bits are set for a HIGH, they are unspecified.
1486    Unfortunately this leads to many missed optimizations
1487    during CSE.  We mask out the non-HIGH bits, and matches
1488    a plain movdi, to alleviate this problem.  */
1489 static rtx
1490 gen_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
1491 {
1492   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
1493 }
1494
1495 static rtx
1496 gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
1497 {
1498   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val));
1499 }
1500
1501 static rtx
1502 gen_safe_OR64 (rtx src, HOST_WIDE_INT val)
1503 {
1504   return gen_rtx_IOR (DImode, src, GEN_INT (val));
1505 }
1506
1507 static rtx
1508 gen_safe_XOR64 (rtx src, HOST_WIDE_INT val)
1509 {
1510   return gen_rtx_XOR (DImode, src, GEN_INT (val));
1511 }
1512
1513 /* Worker routines for 64-bit constant formation on arch64.
1514    One of the key things to be doing in these emissions is
1515    to create as many temp REGs as possible.  This makes it
1516    possible for half-built constants to be used later when
1517    such values are similar to something required later on.
1518    Without doing this, the optimizer cannot see such
1519    opportunities.  */
1520
1521 static void sparc_emit_set_const64_quick1 (rtx, rtx,
1522                                            unsigned HOST_WIDE_INT, int);
1523
1524 static void
1525 sparc_emit_set_const64_quick1 (rtx op0, rtx temp,
1526                                unsigned HOST_WIDE_INT low_bits, int is_neg)
1527 {
1528   unsigned HOST_WIDE_INT high_bits;
1529
1530   if (is_neg)
1531     high_bits = (~low_bits) & 0xffffffff;
1532   else
1533     high_bits = low_bits;
1534
1535   emit_insn (gen_safe_HIGH64 (temp, high_bits));
1536   if (!is_neg)
1537     {
1538       emit_insn (gen_rtx_SET (VOIDmode, op0,
1539                               gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1540     }
1541   else
1542     {
1543       /* If we are XOR'ing with -1, then we should emit a one's complement
1544          instead.  This way the combiner will notice logical operations
1545          such as ANDN later on and substitute.  */
1546       if ((low_bits & 0x3ff) == 0x3ff)
1547         {
1548           emit_insn (gen_rtx_SET (VOIDmode, op0,
1549                                   gen_rtx_NOT (DImode, temp)));
1550         }
1551       else
1552         {
1553           emit_insn (gen_rtx_SET (VOIDmode, op0,
1554                                   gen_safe_XOR64 (temp,
1555                                                   (-(HOST_WIDE_INT)0x400
1556                                                    | (low_bits & 0x3ff)))));
1557         }
1558     }
1559 }
1560
1561 static void sparc_emit_set_const64_quick2 (rtx, rtx, unsigned HOST_WIDE_INT,
1562                                            unsigned HOST_WIDE_INT, int);
1563
1564 static void
1565 sparc_emit_set_const64_quick2 (rtx op0, rtx temp,
1566                                unsigned HOST_WIDE_INT high_bits,
1567                                unsigned HOST_WIDE_INT low_immediate,
1568                                int shift_count)
1569 {
1570   rtx temp2 = op0;
1571
1572   if ((high_bits & 0xfffffc00) != 0)
1573     {
1574       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1575       if ((high_bits & ~0xfffffc00) != 0)
1576         emit_insn (gen_rtx_SET (VOIDmode, op0,
1577                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1578       else
1579         temp2 = temp;
1580     }
1581   else
1582     {
1583       emit_insn (gen_safe_SET64 (temp, high_bits));
1584       temp2 = temp;
1585     }
1586
1587   /* Now shift it up into place.  */
1588   emit_insn (gen_rtx_SET (VOIDmode, op0,
1589                           gen_rtx_ASHIFT (DImode, temp2,
1590                                           GEN_INT (shift_count))));
1591
1592   /* If there is a low immediate part piece, finish up by
1593      putting that in as well.  */
1594   if (low_immediate != 0)
1595     emit_insn (gen_rtx_SET (VOIDmode, op0,
1596                             gen_safe_OR64 (op0, low_immediate)));
1597 }
1598
1599 static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
1600                                             unsigned HOST_WIDE_INT);
1601
1602 /* Full 64-bit constant decomposition.  Even though this is the
1603    'worst' case, we still optimize a few things away.  */
1604 static void
1605 sparc_emit_set_const64_longway (rtx op0, rtx temp,
1606                                 unsigned HOST_WIDE_INT high_bits,
1607                                 unsigned HOST_WIDE_INT low_bits)
1608 {
1609   rtx sub_temp;
1610
1611   if (reload_in_progress || reload_completed)
1612     sub_temp = op0;
1613   else
1614     sub_temp = gen_reg_rtx (DImode);
1615
1616   if ((high_bits & 0xfffffc00) != 0)
1617     {
1618       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1619       if ((high_bits & ~0xfffffc00) != 0)
1620         emit_insn (gen_rtx_SET (VOIDmode,
1621                                 sub_temp,
1622                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1623       else
1624         sub_temp = temp;
1625     }
1626   else
1627     {
1628       emit_insn (gen_safe_SET64 (temp, high_bits));
1629       sub_temp = temp;
1630     }
1631
1632   if (!reload_in_progress && !reload_completed)
1633     {
1634       rtx temp2 = gen_reg_rtx (DImode);
1635       rtx temp3 = gen_reg_rtx (DImode);
1636       rtx temp4 = gen_reg_rtx (DImode);
1637
1638       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1639                               gen_rtx_ASHIFT (DImode, sub_temp,
1640                                               GEN_INT (32))));
1641
1642       emit_insn (gen_safe_HIGH64 (temp2, low_bits));
1643       if ((low_bits & ~0xfffffc00) != 0)
1644         {
1645           emit_insn (gen_rtx_SET (VOIDmode, temp3,
1646                                   gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
1647           emit_insn (gen_rtx_SET (VOIDmode, op0,
1648                                   gen_rtx_PLUS (DImode, temp4, temp3)));
1649         }
1650       else
1651         {
1652           emit_insn (gen_rtx_SET (VOIDmode, op0,
1653                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1654         }
1655     }
1656   else
1657     {
1658       rtx low1 = GEN_INT ((low_bits >> (32 - 12))          & 0xfff);
1659       rtx low2 = GEN_INT ((low_bits >> (32 - 12 - 12))     & 0xfff);
1660       rtx low3 = GEN_INT ((low_bits >> (32 - 12 - 12 - 8)) & 0x0ff);
1661       int to_shift = 12;
1662
1663       /* We are in the middle of reload, so this is really
1664          painful.  However we do still make an attempt to
1665          avoid emitting truly stupid code.  */
1666       if (low1 != const0_rtx)
1667         {
1668           emit_insn (gen_rtx_SET (VOIDmode, op0,
1669                                   gen_rtx_ASHIFT (DImode, sub_temp,
1670                                                   GEN_INT (to_shift))));
1671           emit_insn (gen_rtx_SET (VOIDmode, op0,
1672                                   gen_rtx_IOR (DImode, op0, low1)));
1673           sub_temp = op0;
1674           to_shift = 12;
1675         }
1676       else
1677         {
1678           to_shift += 12;
1679         }
1680       if (low2 != const0_rtx)
1681         {
1682           emit_insn (gen_rtx_SET (VOIDmode, op0,
1683                                   gen_rtx_ASHIFT (DImode, sub_temp,
1684                                                   GEN_INT (to_shift))));
1685           emit_insn (gen_rtx_SET (VOIDmode, op0,
1686                                   gen_rtx_IOR (DImode, op0, low2)));
1687           sub_temp = op0;
1688           to_shift = 8;
1689         }
1690       else
1691         {
1692           to_shift += 8;
1693         }
1694       emit_insn (gen_rtx_SET (VOIDmode, op0,
1695                               gen_rtx_ASHIFT (DImode, sub_temp,
1696                                               GEN_INT (to_shift))));
1697       if (low3 != const0_rtx)
1698         emit_insn (gen_rtx_SET (VOIDmode, op0,
1699                                 gen_rtx_IOR (DImode, op0, low3)));
1700       /* phew...  */
1701     }
1702 }
1703
1704 /* Analyze a 64-bit constant for certain properties.  */
1705 static void analyze_64bit_constant (unsigned HOST_WIDE_INT,
1706                                     unsigned HOST_WIDE_INT,
1707                                     int *, int *, int *);
1708
1709 static void
1710 analyze_64bit_constant (unsigned HOST_WIDE_INT high_bits,
1711                         unsigned HOST_WIDE_INT low_bits,
1712                         int *hbsp, int *lbsp, int *abbasp)
1713 {
1714   int lowest_bit_set, highest_bit_set, all_bits_between_are_set;
1715   int i;
1716
1717   lowest_bit_set = highest_bit_set = -1;
1718   i = 0;
1719   do
1720     {
1721       if ((lowest_bit_set == -1)
1722           && ((low_bits >> i) & 1))
1723         lowest_bit_set = i;
1724       if ((highest_bit_set == -1)
1725           && ((high_bits >> (32 - i - 1)) & 1))
1726         highest_bit_set = (64 - i - 1);
1727     }
1728   while (++i < 32
1729          && ((highest_bit_set == -1)
1730              || (lowest_bit_set == -1)));
1731   if (i == 32)
1732     {
1733       i = 0;
1734       do
1735         {
1736           if ((lowest_bit_set == -1)
1737               && ((high_bits >> i) & 1))
1738             lowest_bit_set = i + 32;
1739           if ((highest_bit_set == -1)
1740               && ((low_bits >> (32 - i - 1)) & 1))
1741             highest_bit_set = 32 - i - 1;
1742         }
1743       while (++i < 32
1744              && ((highest_bit_set == -1)
1745                  || (lowest_bit_set == -1)));
1746     }
1747   /* If there are no bits set this should have gone out
1748      as one instruction!  */
1749   gcc_assert (lowest_bit_set != -1 && highest_bit_set != -1);
1750   all_bits_between_are_set = 1;
1751   for (i = lowest_bit_set; i <= highest_bit_set; i++)
1752     {
1753       if (i < 32)
1754         {
1755           if ((low_bits & (1 << i)) != 0)
1756             continue;
1757         }
1758       else
1759         {
1760           if ((high_bits & (1 << (i - 32))) != 0)
1761             continue;
1762         }
1763       all_bits_between_are_set = 0;
1764       break;
1765     }
1766   *hbsp = highest_bit_set;
1767   *lbsp = lowest_bit_set;
1768   *abbasp = all_bits_between_are_set;
1769 }
1770
1771 static int const64_is_2insns (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
1772
1773 static int
1774 const64_is_2insns (unsigned HOST_WIDE_INT high_bits,
1775                    unsigned HOST_WIDE_INT low_bits)
1776 {
1777   int highest_bit_set, lowest_bit_set, all_bits_between_are_set;
1778
1779   if (high_bits == 0
1780       || high_bits == 0xffffffff)
1781     return 1;
1782
1783   analyze_64bit_constant (high_bits, low_bits,
1784                           &highest_bit_set, &lowest_bit_set,
1785                           &all_bits_between_are_set);
1786
1787   if ((highest_bit_set == 63
1788        || lowest_bit_set == 0)
1789       && all_bits_between_are_set != 0)
1790     return 1;
1791
1792   if ((highest_bit_set - lowest_bit_set) < 21)
1793     return 1;
1794
1795   return 0;
1796 }
1797
1798 static unsigned HOST_WIDE_INT create_simple_focus_bits (unsigned HOST_WIDE_INT,
1799                                                         unsigned HOST_WIDE_INT,
1800                                                         int, int);
1801
1802 static unsigned HOST_WIDE_INT
1803 create_simple_focus_bits (unsigned HOST_WIDE_INT high_bits,
1804                           unsigned HOST_WIDE_INT low_bits,
1805                           int lowest_bit_set, int shift)
1806 {
1807   HOST_WIDE_INT hi, lo;
1808
1809   if (lowest_bit_set < 32)
1810     {
1811       lo = (low_bits >> lowest_bit_set) << shift;
1812       hi = ((high_bits << (32 - lowest_bit_set)) << shift);
1813     }
1814   else
1815     {
1816       lo = 0;
1817       hi = ((high_bits >> (lowest_bit_set - 32)) << shift);
1818     }
1819   gcc_assert (! (hi & lo));
1820   return (hi | lo);
1821 }
1822
1823 /* Here we are sure to be arch64 and this is an integer constant
1824    being loaded into a register.  Emit the most efficient
1825    insn sequence possible.  Detection of all the 1-insn cases
1826    has been done already.  */
1827 static void
1828 sparc_emit_set_const64 (rtx op0, rtx op1)
1829 {
1830   unsigned HOST_WIDE_INT high_bits, low_bits;
1831   int lowest_bit_set, highest_bit_set;
1832   int all_bits_between_are_set;
1833   rtx temp = 0;
1834
1835   /* Sanity check that we know what we are working with.  */
1836   gcc_assert (TARGET_ARCH64
1837               && (GET_CODE (op0) == SUBREG
1838                   || (REG_P (op0) && ! SPARC_FP_REG_P (REGNO (op0)))));
1839
1840   if (reload_in_progress || reload_completed)
1841     temp = op0;
1842
1843   if (GET_CODE (op1) != CONST_INT)
1844     {
1845       sparc_emit_set_symbolic_const64 (op0, op1, temp);
1846       return;
1847     }
1848
1849   if (! temp)
1850     temp = gen_reg_rtx (DImode);
1851
1852   high_bits = ((INTVAL (op1) >> 32) & 0xffffffff);
1853   low_bits = (INTVAL (op1) & 0xffffffff);
1854
1855   /* low_bits   bits 0  --> 31
1856      high_bits  bits 32 --> 63  */
1857
1858   analyze_64bit_constant (high_bits, low_bits,
1859                           &highest_bit_set, &lowest_bit_set,
1860                           &all_bits_between_are_set);
1861
1862   /* First try for a 2-insn sequence.  */
1863
1864   /* These situations are preferred because the optimizer can
1865    * do more things with them:
1866    * 1) mov     -1, %reg
1867    *    sllx    %reg, shift, %reg
1868    * 2) mov     -1, %reg
1869    *    srlx    %reg, shift, %reg
1870    * 3) mov     some_small_const, %reg
1871    *    sllx    %reg, shift, %reg
1872    */
1873   if (((highest_bit_set == 63
1874         || lowest_bit_set == 0)
1875        && all_bits_between_are_set != 0)
1876       || ((highest_bit_set - lowest_bit_set) < 12))
1877     {
1878       HOST_WIDE_INT the_const = -1;
1879       int shift = lowest_bit_set;
1880
1881       if ((highest_bit_set != 63
1882            && lowest_bit_set != 0)
1883           || all_bits_between_are_set == 0)
1884         {
1885           the_const =
1886             create_simple_focus_bits (high_bits, low_bits,
1887                                       lowest_bit_set, 0);
1888         }
1889       else if (lowest_bit_set == 0)
1890         shift = -(63 - highest_bit_set);
1891
1892       gcc_assert (SPARC_SIMM13_P (the_const));
1893       gcc_assert (shift != 0);
1894
1895       emit_insn (gen_safe_SET64 (temp, the_const));
1896       if (shift > 0)
1897         emit_insn (gen_rtx_SET (VOIDmode,
1898                                 op0,
1899                                 gen_rtx_ASHIFT (DImode,
1900                                                 temp,
1901                                                 GEN_INT (shift))));
1902       else if (shift < 0)
1903         emit_insn (gen_rtx_SET (VOIDmode,
1904                                 op0,
1905                                 gen_rtx_LSHIFTRT (DImode,
1906                                                   temp,
1907                                                   GEN_INT (-shift))));
1908       return;
1909     }
1910
1911   /* Now a range of 22 or less bits set somewhere.
1912    * 1) sethi   %hi(focus_bits), %reg
1913    *    sllx    %reg, shift, %reg
1914    * 2) sethi   %hi(focus_bits), %reg
1915    *    srlx    %reg, shift, %reg
1916    */
1917   if ((highest_bit_set - lowest_bit_set) < 21)
1918     {
1919       unsigned HOST_WIDE_INT focus_bits =
1920         create_simple_focus_bits (high_bits, low_bits,
1921                                   lowest_bit_set, 10);
1922
1923       gcc_assert (SPARC_SETHI_P (focus_bits));
1924       gcc_assert (lowest_bit_set != 10);
1925
1926       emit_insn (gen_safe_HIGH64 (temp, focus_bits));
1927
1928       /* If lowest_bit_set == 10 then a sethi alone could have done it.  */
1929       if (lowest_bit_set < 10)
1930         emit_insn (gen_rtx_SET (VOIDmode,
1931                                 op0,
1932                                 gen_rtx_LSHIFTRT (DImode, temp,
1933                                                   GEN_INT (10 - lowest_bit_set))));
1934       else if (lowest_bit_set > 10)
1935         emit_insn (gen_rtx_SET (VOIDmode,
1936                                 op0,
1937                                 gen_rtx_ASHIFT (DImode, temp,
1938                                                 GEN_INT (lowest_bit_set - 10))));
1939       return;
1940     }
1941
1942   /* 1) sethi   %hi(low_bits), %reg
1943    *    or      %reg, %lo(low_bits), %reg
1944    * 2) sethi   %hi(~low_bits), %reg
1945    *    xor     %reg, %lo(-0x400 | (low_bits & 0x3ff)), %reg
1946    */
1947   if (high_bits == 0
1948       || high_bits == 0xffffffff)
1949     {
1950       sparc_emit_set_const64_quick1 (op0, temp, low_bits,
1951                                      (high_bits == 0xffffffff));
1952       return;
1953     }
1954
1955   /* Now, try 3-insn sequences.  */
1956
1957   /* 1) sethi   %hi(high_bits), %reg
1958    *    or      %reg, %lo(high_bits), %reg
1959    *    sllx    %reg, 32, %reg
1960    */
1961   if (low_bits == 0)
1962     {
1963       sparc_emit_set_const64_quick2 (op0, temp, high_bits, 0, 32);
1964       return;
1965     }
1966
1967   /* We may be able to do something quick
1968      when the constant is negated, so try that.  */
1969   if (const64_is_2insns ((~high_bits) & 0xffffffff,
1970                          (~low_bits) & 0xfffffc00))
1971     {
1972       /* NOTE: The trailing bits get XOR'd so we need the
1973          non-negated bits, not the negated ones.  */
1974       unsigned HOST_WIDE_INT trailing_bits = low_bits & 0x3ff;
1975
1976       if ((((~high_bits) & 0xffffffff) == 0
1977            && ((~low_bits) & 0x80000000) == 0)
1978           || (((~high_bits) & 0xffffffff) == 0xffffffff
1979               && ((~low_bits) & 0x80000000) != 0))
1980         {
1981           unsigned HOST_WIDE_INT fast_int = (~low_bits & 0xffffffff);
1982
1983           if ((SPARC_SETHI_P (fast_int)
1984                && (~high_bits & 0xffffffff) == 0)
1985               || SPARC_SIMM13_P (fast_int))
1986             emit_insn (gen_safe_SET64 (temp, fast_int));
1987           else
1988             sparc_emit_set_const64 (temp, GEN_INT (fast_int));
1989         }
1990       else
1991         {
1992           rtx negated_const;
1993           negated_const = GEN_INT (((~low_bits) & 0xfffffc00) |
1994                                    (((HOST_WIDE_INT)((~high_bits) & 0xffffffff))<<32));
1995           sparc_emit_set_const64 (temp, negated_const);
1996         }
1997
1998       /* If we are XOR'ing with -1, then we should emit a one's complement
1999          instead.  This way the combiner will notice logical operations
2000          such as ANDN later on and substitute.  */
2001       if (trailing_bits == 0x3ff)
2002         {
2003           emit_insn (gen_rtx_SET (VOIDmode, op0,
2004                                   gen_rtx_NOT (DImode, temp)));
2005         }
2006       else
2007         {
2008           emit_insn (gen_rtx_SET (VOIDmode,
2009                                   op0,
2010                                   gen_safe_XOR64 (temp,
2011                                                   (-0x400 | trailing_bits))));
2012         }
2013       return;
2014     }
2015
2016   /* 1) sethi   %hi(xxx), %reg
2017    *    or      %reg, %lo(xxx), %reg
2018    *    sllx    %reg, yyy, %reg
2019    *
2020    * ??? This is just a generalized version of the low_bits==0
2021    * thing above, FIXME...
2022    */
2023   if ((highest_bit_set - lowest_bit_set) < 32)
2024     {
2025       unsigned HOST_WIDE_INT focus_bits =
2026         create_simple_focus_bits (high_bits, low_bits,
2027                                   lowest_bit_set, 0);
2028
2029       /* We can't get here in this state.  */
2030       gcc_assert (highest_bit_set >= 32 && lowest_bit_set < 32);
2031
2032       /* So what we know is that the set bits straddle the
2033          middle of the 64-bit word.  */
2034       sparc_emit_set_const64_quick2 (op0, temp,
2035                                      focus_bits, 0,
2036                                      lowest_bit_set);
2037       return;
2038     }
2039
2040   /* 1) sethi   %hi(high_bits), %reg
2041    *    or      %reg, %lo(high_bits), %reg
2042    *    sllx    %reg, 32, %reg
2043    *    or      %reg, low_bits, %reg
2044    */
2045   if (SPARC_SIMM13_P(low_bits)
2046       && ((int)low_bits > 0))
2047     {
2048       sparc_emit_set_const64_quick2 (op0, temp, high_bits, low_bits, 32);
2049       return;
2050     }
2051
2052   /* The easiest way when all else fails, is full decomposition.  */
2053   sparc_emit_set_const64_longway (op0, temp, high_bits, low_bits);
2054 }
2055 #endif /* HOST_BITS_PER_WIDE_INT == 32 */
2056
2057 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
2058    return the mode to be used for the comparison.  For floating-point,
2059    CCFP[E]mode is used.  CC_NOOVmode should be used when the first operand
2060    is a PLUS, MINUS, NEG, or ASHIFT.  CCmode should be used when no special
2061    processing is needed.  */
2062
2063 enum machine_mode
2064 select_cc_mode (enum rtx_code op, rtx x, rtx y ATTRIBUTE_UNUSED)
2065 {
2066   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2067     {
2068       switch (op)
2069         {
2070         case EQ:
2071         case NE:
2072         case UNORDERED:
2073         case ORDERED:
2074         case UNLT:
2075         case UNLE:
2076         case UNGT:
2077         case UNGE:
2078         case UNEQ:
2079         case LTGT:
2080           return CCFPmode;
2081
2082         case LT:
2083         case LE:
2084         case GT:
2085         case GE:
2086           return CCFPEmode;
2087
2088         default:
2089           gcc_unreachable ();
2090         }
2091     }
2092   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
2093            || GET_CODE (x) == NEG || GET_CODE (x) == ASHIFT)
2094     {
2095       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2096         return CCX_NOOVmode;
2097       else
2098         return CC_NOOVmode;
2099     }
2100   else
2101     {
2102       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
2103         return CCXmode;
2104       else
2105         return CCmode;
2106     }
2107 }
2108
2109 /* Emit the compare insn and return the CC reg for a CODE comparison
2110    with operands X and Y.  */
2111
2112 static rtx
2113 gen_compare_reg_1 (enum rtx_code code, rtx x, rtx y)
2114 {
2115   enum machine_mode mode;
2116   rtx cc_reg;
2117
2118   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_CC)
2119     return x;
2120
2121   mode = SELECT_CC_MODE (code, x, y);
2122
2123   /* ??? We don't have movcc patterns so we cannot generate pseudo regs for the
2124      fcc regs (cse can't tell they're really call clobbered regs and will
2125      remove a duplicate comparison even if there is an intervening function
2126      call - it will then try to reload the cc reg via an int reg which is why
2127      we need the movcc patterns).  It is possible to provide the movcc
2128      patterns by using the ldxfsr/stxfsr v9 insns.  I tried it: you need two
2129      registers (say %g1,%g5) and it takes about 6 insns.  A better fix would be
2130      to tell cse that CCFPE mode registers (even pseudos) are call
2131      clobbered.  */
2132
2133   /* ??? This is an experiment.  Rather than making changes to cse which may
2134      or may not be easy/clean, we do our own cse.  This is possible because
2135      we will generate hard registers.  Cse knows they're call clobbered (it
2136      doesn't know the same thing about pseudos). If we guess wrong, no big
2137      deal, but if we win, great!  */
2138
2139   if (TARGET_V9 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2140 #if 1 /* experiment */
2141     {
2142       int reg;
2143       /* We cycle through the registers to ensure they're all exercised.  */
2144       static int next_fcc_reg = 0;
2145       /* Previous x,y for each fcc reg.  */
2146       static rtx prev_args[4][2];
2147
2148       /* Scan prev_args for x,y.  */
2149       for (reg = 0; reg < 4; reg++)
2150         if (prev_args[reg][0] == x && prev_args[reg][1] == y)
2151           break;
2152       if (reg == 4)
2153         {
2154           reg = next_fcc_reg;
2155           prev_args[reg][0] = x;
2156           prev_args[reg][1] = y;
2157           next_fcc_reg = (next_fcc_reg + 1) & 3;
2158         }
2159       cc_reg = gen_rtx_REG (mode, reg + SPARC_FIRST_V9_FCC_REG);
2160     }
2161 #else
2162     cc_reg = gen_reg_rtx (mode);
2163 #endif /* ! experiment */
2164   else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2165     cc_reg = gen_rtx_REG (mode, SPARC_FCC_REG);
2166   else
2167     cc_reg = gen_rtx_REG (mode, SPARC_ICC_REG);
2168
2169   /* We shouldn't get there for TFmode if !TARGET_HARD_QUAD.  If we do, this
2170      will only result in an unrecognizable insn so no point in asserting.  */
2171   emit_insn (gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y)));
2172
2173   return cc_reg;
2174 }
2175
2176
2177 /* Emit the compare insn and return the CC reg for the comparison in CMP.  */
2178
2179 rtx
2180 gen_compare_reg (rtx cmp)
2181 {
2182   return gen_compare_reg_1 (GET_CODE (cmp), XEXP (cmp, 0), XEXP (cmp, 1));
2183 }
2184
2185 /* This function is used for v9 only.
2186    DEST is the target of the Scc insn.
2187    CODE is the code for an Scc's comparison.
2188    X and Y are the values we compare.
2189
2190    This function is needed to turn
2191
2192            (set (reg:SI 110)
2193                (gt (reg:CCX 100 %icc)
2194                    (const_int 0)))
2195    into
2196            (set (reg:SI 110)
2197                (gt:DI (reg:CCX 100 %icc)
2198                    (const_int 0)))
2199
2200    IE: The instruction recognizer needs to see the mode of the comparison to
2201    find the right instruction. We could use "gt:DI" right in the
2202    define_expand, but leaving it out allows us to handle DI, SI, etc.  */
2203
2204 static int
2205 gen_v9_scc (rtx dest, enum rtx_code compare_code, rtx x, rtx y)
2206 {
2207   if (! TARGET_ARCH64
2208       && (GET_MODE (x) == DImode
2209           || GET_MODE (dest) == DImode))
2210     return 0;
2211
2212   /* Try to use the movrCC insns.  */
2213   if (TARGET_ARCH64
2214       && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
2215       && y == const0_rtx
2216       && v9_regcmp_p (compare_code))
2217     {
2218       rtx op0 = x;
2219       rtx temp;
2220
2221       /* Special case for op0 != 0.  This can be done with one instruction if
2222          dest == x.  */
2223
2224       if (compare_code == NE
2225           && GET_MODE (dest) == DImode
2226           && rtx_equal_p (op0, dest))
2227         {
2228           emit_insn (gen_rtx_SET (VOIDmode, dest,
2229                               gen_rtx_IF_THEN_ELSE (DImode,
2230                                        gen_rtx_fmt_ee (compare_code, DImode,
2231                                                        op0, const0_rtx),
2232                                        const1_rtx,
2233                                        dest)));
2234           return 1;
2235         }
2236
2237       if (reg_overlap_mentioned_p (dest, op0))
2238         {
2239           /* Handle the case where dest == x.
2240              We "early clobber" the result.  */
2241           op0 = gen_reg_rtx (GET_MODE (x));
2242           emit_move_insn (op0, x);
2243         }
2244
2245       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2246       if (GET_MODE (op0) != DImode)
2247         {
2248           temp = gen_reg_rtx (DImode);
2249           convert_move (temp, op0, 0);
2250         }
2251       else
2252         temp = op0;
2253       emit_insn (gen_rtx_SET (VOIDmode, dest,
2254                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2255                                    gen_rtx_fmt_ee (compare_code, DImode,
2256                                                    temp, const0_rtx),
2257                                    const1_rtx,
2258                                    dest)));
2259       return 1;
2260     }
2261   else
2262     {
2263       x = gen_compare_reg_1 (compare_code, x, y);
2264       y = const0_rtx;
2265
2266       gcc_assert (GET_MODE (x) != CC_NOOVmode
2267                   && GET_MODE (x) != CCX_NOOVmode);
2268
2269       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2270       emit_insn (gen_rtx_SET (VOIDmode, dest,
2271                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2272                                    gen_rtx_fmt_ee (compare_code,
2273                                                    GET_MODE (x), x, y),
2274                                     const1_rtx, dest)));
2275       return 1;
2276     }
2277 }
2278
2279
2280 /* Emit an scc insn.  For seq, sne, sgeu, and sltu, we can do this
2281    without jumps using the addx/subx instructions.  */
2282
2283 bool
2284 emit_scc_insn (rtx operands[])
2285 {
2286   rtx tem;
2287   rtx x;
2288   rtx y;
2289   enum rtx_code code;
2290
2291   /* The quad-word fp compare library routines all return nonzero to indicate
2292      true, which is different from the equivalent libgcc routines, so we must
2293      handle them specially here.  */
2294   if (GET_MODE (operands[2]) == TFmode && ! TARGET_HARD_QUAD)
2295     {
2296       operands[1] = sparc_emit_float_lib_cmp (operands[2], operands[3],
2297                                               GET_CODE (operands[1]));
2298       operands[2] = XEXP (operands[1], 0);
2299       operands[3] = XEXP (operands[1], 1);
2300     }
2301
2302   code = GET_CODE (operands[1]);
2303   x = operands[2];
2304   y = operands[3];
2305
2306   /* For seq/sne on v9 we use the same code as v8 (the addx/subx method has
2307      more applications).  The exception to this is "reg != 0" which can
2308      be done in one instruction on v9 (so we do it).  */
2309   if (code == EQ)
2310     {
2311       if (GET_MODE (x) == SImode)
2312         {
2313           rtx pat = gen_seqsi_special (operands[0], x, y);
2314           emit_insn (pat);
2315           return true;
2316         }
2317       else if (GET_MODE (x) == DImode)
2318         {
2319           rtx pat = gen_seqdi_special (operands[0], x, y);
2320           emit_insn (pat);
2321           return true;
2322         }
2323     }
2324
2325   if (code == NE)
2326     {
2327       if (GET_MODE (x) == SImode)
2328         {
2329           rtx pat = gen_snesi_special (operands[0], x, y);
2330           emit_insn (pat);
2331           return true;
2332         }
2333       else if (GET_MODE (x) == DImode)
2334         {
2335           rtx pat = gen_snedi_special (operands[0], x, y);
2336           emit_insn (pat);
2337           return true;
2338         }
2339     }
2340
2341   /* For the rest, on v9 we can use conditional moves.  */
2342
2343   if (TARGET_V9)
2344     {
2345       if (gen_v9_scc (operands[0], code, x, y))
2346         return true;
2347     }
2348
2349   /* We can do LTU and GEU using the addx/subx instructions too.  And
2350      for GTU/LEU, if both operands are registers swap them and fall
2351      back to the easy case.  */
2352   if (code == GTU || code == LEU)
2353     {
2354       if ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2355           && (GET_CODE (y) == REG || GET_CODE (y) == SUBREG))
2356         {
2357           tem = x;
2358           x = y;
2359           y = tem;
2360           code = swap_condition (code);
2361         }
2362     }
2363
2364   if (code == LTU || code == GEU)
2365     {
2366       emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2367                               gen_rtx_fmt_ee (code, SImode,
2368                                               gen_compare_reg_1 (code, x, y),
2369                                               const0_rtx)));
2370       return true;
2371     }
2372
2373   /* Nope, do branches.  */
2374   return false;
2375 }
2376
2377 /* Emit a conditional jump insn for the v9 architecture using comparison code
2378    CODE and jump target LABEL.
2379    This function exists to take advantage of the v9 brxx insns.  */
2380
2381 static void
2382 emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
2383 {
2384   emit_jump_insn (gen_rtx_SET (VOIDmode,
2385                            pc_rtx,
2386                            gen_rtx_IF_THEN_ELSE (VOIDmode,
2387                                     gen_rtx_fmt_ee (code, GET_MODE (op0),
2388                                                     op0, const0_rtx),
2389                                     gen_rtx_LABEL_REF (VOIDmode, label),
2390                                     pc_rtx)));
2391 }
2392
2393 void
2394 emit_conditional_branch_insn (rtx operands[])
2395 {
2396   /* The quad-word fp compare library routines all return nonzero to indicate
2397      true, which is different from the equivalent libgcc routines, so we must
2398      handle them specially here.  */
2399   if (GET_MODE (operands[1]) == TFmode && ! TARGET_HARD_QUAD)
2400     {
2401       operands[0] = sparc_emit_float_lib_cmp (operands[1], operands[2],
2402                                               GET_CODE (operands[0]));
2403       operands[1] = XEXP (operands[0], 0);
2404       operands[2] = XEXP (operands[0], 1);
2405     }
2406
2407   if (TARGET_ARCH64 && operands[2] == const0_rtx
2408       && GET_CODE (operands[1]) == REG
2409       && GET_MODE (operands[1]) == DImode)
2410     {
2411       emit_v9_brxx_insn (GET_CODE (operands[0]), operands[1], operands[3]);
2412       return;
2413     }
2414
2415   operands[1] = gen_compare_reg (operands[0]);
2416   operands[2] = const0_rtx;
2417   operands[0] = gen_rtx_fmt_ee (GET_CODE (operands[0]), VOIDmode,
2418                                 operands[1], operands[2]);
2419   emit_jump_insn (gen_cbranchcc4 (operands[0], operands[1], operands[2],
2420                                   operands[3]));
2421 }
2422
2423
2424 /* Generate a DFmode part of a hard TFmode register.
2425    REG is the TFmode hard register, LOW is 1 for the
2426    low 64bit of the register and 0 otherwise.
2427  */
2428 rtx
2429 gen_df_reg (rtx reg, int low)
2430 {
2431   int regno = REGNO (reg);
2432
2433   if ((WORDS_BIG_ENDIAN == 0) ^ (low != 0))
2434     regno += (TARGET_ARCH64 && regno < 32) ? 1 : 2;
2435   return gen_rtx_REG (DFmode, regno);
2436 }
2437 \f
2438 /* Generate a call to FUNC with OPERANDS.  Operand 0 is the return value.
2439    Unlike normal calls, TFmode operands are passed by reference.  It is
2440    assumed that no more than 3 operands are required.  */
2441
2442 static void
2443 emit_soft_tfmode_libcall (const char *func_name, int nargs, rtx *operands)
2444 {
2445   rtx ret_slot = NULL, arg[3], func_sym;
2446   int i;
2447
2448   /* We only expect to be called for conversions, unary, and binary ops.  */
2449   gcc_assert (nargs == 2 || nargs == 3);
2450
2451   for (i = 0; i < nargs; ++i)
2452     {
2453       rtx this_arg = operands[i];
2454       rtx this_slot;
2455
2456       /* TFmode arguments and return values are passed by reference.  */
2457       if (GET_MODE (this_arg) == TFmode)
2458         {
2459           int force_stack_temp;
2460
2461           force_stack_temp = 0;
2462           if (TARGET_BUGGY_QP_LIB && i == 0)
2463             force_stack_temp = 1;
2464
2465           if (GET_CODE (this_arg) == MEM
2466               && ! force_stack_temp)
2467             this_arg = XEXP (this_arg, 0);
2468           else if (CONSTANT_P (this_arg)
2469                    && ! force_stack_temp)
2470             {
2471               this_slot = force_const_mem (TFmode, this_arg);
2472               this_arg = XEXP (this_slot, 0);
2473             }
2474           else
2475             {
2476               this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2477
2478               /* Operand 0 is the return value.  We'll copy it out later.  */
2479               if (i > 0)
2480                 emit_move_insn (this_slot, this_arg);
2481               else
2482                 ret_slot = this_slot;
2483
2484               this_arg = XEXP (this_slot, 0);
2485             }
2486         }
2487
2488       arg[i] = this_arg;
2489     }
2490
2491   func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2492
2493   if (GET_MODE (operands[0]) == TFmode)
2494     {
2495       if (nargs == 2)
2496         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2497                            arg[0], GET_MODE (arg[0]),
2498                            arg[1], GET_MODE (arg[1]));
2499       else
2500         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2501                            arg[0], GET_MODE (arg[0]),
2502                            arg[1], GET_MODE (arg[1]),
2503                            arg[2], GET_MODE (arg[2]));
2504
2505       if (ret_slot)
2506         emit_move_insn (operands[0], ret_slot);
2507     }
2508   else
2509     {
2510       rtx ret;
2511
2512       gcc_assert (nargs == 2);
2513
2514       ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2515                                      GET_MODE (operands[0]), 1,
2516                                      arg[1], GET_MODE (arg[1]));
2517
2518       if (ret != operands[0])
2519         emit_move_insn (operands[0], ret);
2520     }
2521 }
2522
2523 /* Expand soft-float TFmode calls to sparc abi routines.  */
2524
2525 static void
2526 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2527 {
2528   const char *func;
2529
2530   switch (code)
2531     {
2532     case PLUS:
2533       func = "_Qp_add";
2534       break;
2535     case MINUS:
2536       func = "_Qp_sub";
2537       break;
2538     case MULT:
2539       func = "_Qp_mul";
2540       break;
2541     case DIV:
2542       func = "_Qp_div";
2543       break;
2544     default:
2545       gcc_unreachable ();
2546     }
2547
2548   emit_soft_tfmode_libcall (func, 3, operands);
2549 }
2550
2551 static void
2552 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2553 {
2554   const char *func;
2555
2556   gcc_assert (code == SQRT);
2557   func = "_Qp_sqrt";
2558
2559   emit_soft_tfmode_libcall (func, 2, operands);
2560 }
2561
2562 static void
2563 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2564 {
2565   const char *func;
2566
2567   switch (code)
2568     {
2569     case FLOAT_EXTEND:
2570       switch (GET_MODE (operands[1]))
2571         {
2572         case SFmode:
2573           func = "_Qp_stoq";
2574           break;
2575         case DFmode:
2576           func = "_Qp_dtoq";
2577           break;
2578         default:
2579           gcc_unreachable ();
2580         }
2581       break;
2582
2583     case FLOAT_TRUNCATE:
2584       switch (GET_MODE (operands[0]))
2585         {
2586         case SFmode:
2587           func = "_Qp_qtos";
2588           break;
2589         case DFmode:
2590           func = "_Qp_qtod";
2591           break;
2592         default:
2593           gcc_unreachable ();
2594         }
2595       break;
2596
2597     case FLOAT:
2598       switch (GET_MODE (operands[1]))
2599         {
2600         case SImode:
2601           func = "_Qp_itoq";
2602           if (TARGET_ARCH64)
2603             operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]);
2604           break;
2605         case DImode:
2606           func = "_Qp_xtoq";
2607           break;
2608         default:
2609           gcc_unreachable ();
2610         }
2611       break;
2612
2613     case UNSIGNED_FLOAT:
2614       switch (GET_MODE (operands[1]))
2615         {
2616         case SImode:
2617           func = "_Qp_uitoq";
2618           if (TARGET_ARCH64)
2619             operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
2620           break;
2621         case DImode:
2622           func = "_Qp_uxtoq";
2623           break;
2624         default:
2625           gcc_unreachable ();
2626         }
2627       break;
2628
2629     case FIX:
2630       switch (GET_MODE (operands[0]))
2631         {
2632         case SImode:
2633           func = "_Qp_qtoi";
2634           break;
2635         case DImode:
2636           func = "_Qp_qtox";
2637           break;
2638         default:
2639           gcc_unreachable ();
2640         }
2641       break;
2642
2643     case UNSIGNED_FIX:
2644       switch (GET_MODE (operands[0]))
2645         {
2646         case SImode:
2647           func = "_Qp_qtoui";
2648           break;
2649         case DImode:
2650           func = "_Qp_qtoux";
2651           break;
2652         default:
2653           gcc_unreachable ();
2654         }
2655       break;
2656
2657     default:
2658       gcc_unreachable ();
2659     }
2660
2661   emit_soft_tfmode_libcall (func, 2, operands);
2662 }
2663
2664 /* Expand a hard-float tfmode operation.  All arguments must be in
2665    registers.  */
2666
2667 static void
2668 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2669 {
2670   rtx op, dest;
2671
2672   if (GET_RTX_CLASS (code) == RTX_UNARY)
2673     {
2674       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2675       op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2676     }
2677   else
2678     {
2679       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2680       operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2681       op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2682                            operands[1], operands[2]);
2683     }
2684
2685   if (register_operand (operands[0], VOIDmode))
2686     dest = operands[0];
2687   else
2688     dest = gen_reg_rtx (GET_MODE (operands[0]));
2689
2690   emit_insn (gen_rtx_SET (VOIDmode, dest, op));
2691
2692   if (dest != operands[0])
2693     emit_move_insn (operands[0], dest);
2694 }
2695
2696 void
2697 emit_tfmode_binop (enum rtx_code code, rtx *operands)
2698 {
2699   if (TARGET_HARD_QUAD)
2700     emit_hard_tfmode_operation (code, operands);
2701   else
2702     emit_soft_tfmode_binop (code, operands);
2703 }
2704
2705 void
2706 emit_tfmode_unop (enum rtx_code code, rtx *operands)
2707 {
2708   if (TARGET_HARD_QUAD)
2709     emit_hard_tfmode_operation (code, operands);
2710   else
2711     emit_soft_tfmode_unop (code, operands);
2712 }
2713
2714 void
2715 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
2716 {
2717   if (TARGET_HARD_QUAD)
2718     emit_hard_tfmode_operation (code, operands);
2719   else
2720     emit_soft_tfmode_cvt (code, operands);
2721 }
2722 \f
2723 /* Return nonzero if a branch/jump/call instruction will be emitting
2724    nop into its delay slot.  */
2725
2726 int
2727 empty_delay_slot (rtx insn)
2728 {
2729   rtx seq;
2730
2731   /* If no previous instruction (should not happen), return true.  */
2732   if (PREV_INSN (insn) == NULL)
2733     return 1;
2734
2735   seq = NEXT_INSN (PREV_INSN (insn));
2736   if (GET_CODE (PATTERN (seq)) == SEQUENCE)
2737     return 0;
2738
2739   return 1;
2740 }
2741
2742 /* Return nonzero if TRIAL can go into the call delay slot.  */
2743
2744 int
2745 tls_call_delay (rtx trial)
2746 {
2747   rtx pat;
2748
2749   /* Binutils allows
2750        call __tls_get_addr, %tgd_call (foo)
2751         add %l7, %o0, %o0, %tgd_add (foo)
2752      while Sun as/ld does not.  */
2753   if (TARGET_GNU_TLS || !TARGET_TLS)
2754     return 1;
2755
2756   pat = PATTERN (trial);
2757
2758   /* We must reject tgd_add{32|64}, i.e.
2759        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSGD)))
2760      and tldm_add{32|64}, i.e.
2761        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSLDM)))
2762      for Sun as/ld.  */
2763   if (GET_CODE (pat) == SET
2764       && GET_CODE (SET_SRC (pat)) == PLUS)
2765     {
2766       rtx unspec = XEXP (SET_SRC (pat), 1);
2767
2768       if (GET_CODE (unspec) == UNSPEC
2769           && (XINT (unspec, 1) == UNSPEC_TLSGD
2770               || XINT (unspec, 1) == UNSPEC_TLSLDM))
2771         return 0;
2772     }
2773
2774   return 1;
2775 }
2776
2777 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
2778    instruction.  RETURN_P is true if the v9 variant 'return' is to be
2779    considered in the test too.
2780
2781    TRIAL must be a SET whose destination is a REG appropriate for the
2782    'restore' instruction or, if RETURN_P is true, for the 'return'
2783    instruction.  */
2784
2785 static int
2786 eligible_for_restore_insn (rtx trial, bool return_p)
2787 {
2788   rtx pat = PATTERN (trial);
2789   rtx src = SET_SRC (pat);
2790
2791   /* The 'restore src,%g0,dest' pattern for word mode and below.  */
2792   if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
2793       && arith_operand (src, GET_MODE (src)))
2794     {
2795       if (TARGET_ARCH64)
2796         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
2797       else
2798         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
2799     }
2800
2801   /* The 'restore src,%g0,dest' pattern for double-word mode.  */
2802   else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
2803            && arith_double_operand (src, GET_MODE (src)))
2804     return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
2805
2806   /* The 'restore src,%g0,dest' pattern for float if no FPU.  */
2807   else if (! TARGET_FPU && register_operand (src, SFmode))
2808     return 1;
2809
2810   /* The 'restore src,%g0,dest' pattern for double if no FPU.  */
2811   else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
2812     return 1;
2813
2814   /* If we have the 'return' instruction, anything that does not use
2815      local or output registers and can go into a delay slot wins.  */
2816   else if (return_p
2817            && TARGET_V9
2818            && !epilogue_renumber (&pat, 1)
2819            && get_attr_in_uncond_branch_delay (trial)
2820                == IN_UNCOND_BRANCH_DELAY_TRUE)
2821     return 1;
2822
2823   /* The 'restore src1,src2,dest' pattern for SImode.  */
2824   else if (GET_CODE (src) == PLUS
2825            && register_operand (XEXP (src, 0), SImode)
2826            && arith_operand (XEXP (src, 1), SImode))
2827     return 1;
2828
2829   /* The 'restore src1,src2,dest' pattern for DImode.  */
2830   else if (GET_CODE (src) == PLUS
2831            && register_operand (XEXP (src, 0), DImode)
2832            && arith_double_operand (XEXP (src, 1), DImode))
2833     return 1;
2834
2835   /* The 'restore src1,%lo(src2),dest' pattern.  */
2836   else if (GET_CODE (src) == LO_SUM
2837            && ! TARGET_CM_MEDMID
2838            && ((register_operand (XEXP (src, 0), SImode)
2839                 && immediate_operand (XEXP (src, 1), SImode))
2840                || (TARGET_ARCH64
2841                    && register_operand (XEXP (src, 0), DImode)
2842                    && immediate_operand (XEXP (src, 1), DImode))))
2843     return 1;
2844
2845   /* The 'restore src,src,dest' pattern.  */
2846   else if (GET_CODE (src) == ASHIFT
2847            && (register_operand (XEXP (src, 0), SImode)
2848                || register_operand (XEXP (src, 0), DImode))
2849            && XEXP (src, 1) == const1_rtx)
2850     return 1;
2851
2852   return 0;
2853 }
2854
2855 /* Return nonzero if TRIAL can go into the function return's delay slot.  */
2856
2857 int
2858 eligible_for_return_delay (rtx trial)
2859 {
2860   int regno;
2861   rtx pat;
2862
2863   if (GET_CODE (trial) != INSN)
2864     return 0;
2865
2866   if (get_attr_length (trial) != 1)
2867     return 0;
2868
2869   /* If the function uses __builtin_eh_return, the eh_return machinery
2870      occupies the delay slot.  */
2871   if (crtl->calls_eh_return)
2872     return 0;
2873
2874   /* In the case of a leaf or flat function, anything can go into the slot.  */
2875   if (sparc_leaf_function_p || TARGET_FLAT)
2876     return
2877       get_attr_in_uncond_branch_delay (trial) == IN_UNCOND_BRANCH_DELAY_TRUE;
2878
2879   pat = PATTERN (trial);
2880   if (GET_CODE (pat) == PARALLEL)
2881     {
2882       int i;
2883
2884       if (! TARGET_V9)
2885         return 0;
2886       for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
2887         {
2888           rtx expr = XVECEXP (pat, 0, i);
2889           if (GET_CODE (expr) != SET)
2890             return 0;
2891           if (GET_CODE (SET_DEST (expr)) != REG)
2892             return 0;
2893           regno = REGNO (SET_DEST (expr));
2894           if (regno >= 8 && regno < 24)
2895             return 0;
2896         }
2897       return !epilogue_renumber (&pat, 1)
2898         && (get_attr_in_uncond_branch_delay (trial)
2899             == IN_UNCOND_BRANCH_DELAY_TRUE);
2900     }
2901
2902   if (GET_CODE (pat) != SET)
2903     return 0;
2904
2905   if (GET_CODE (SET_DEST (pat)) != REG)
2906     return 0;
2907
2908   regno = REGNO (SET_DEST (pat));
2909
2910   /* Otherwise, only operations which can be done in tandem with
2911      a `restore' or `return' insn can go into the delay slot.  */
2912   if (regno >= 8 && regno < 24)
2913     return 0;
2914
2915   /* If this instruction sets up floating point register and we have a return
2916      instruction, it can probably go in.  But restore will not work
2917      with FP_REGS.  */
2918   if (regno >= 32)
2919     return (TARGET_V9
2920             && !epilogue_renumber (&pat, 1)
2921             && get_attr_in_uncond_branch_delay (trial)
2922                == IN_UNCOND_BRANCH_DELAY_TRUE);
2923
2924   return eligible_for_restore_insn (trial, true);
2925 }
2926
2927 /* Return nonzero if TRIAL can go into the sibling call's delay slot.  */
2928
2929 int
2930 eligible_for_sibcall_delay (rtx trial)
2931 {
2932   rtx pat;
2933
2934   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
2935     return 0;
2936
2937   if (get_attr_length (trial) != 1)
2938     return 0;
2939
2940   pat = PATTERN (trial);
2941
2942   if (sparc_leaf_function_p || TARGET_FLAT)
2943     {
2944       /* If the tail call is done using the call instruction,
2945          we have to restore %o7 in the delay slot.  */
2946       if (LEAF_SIBCALL_SLOT_RESERVED_P)
2947         return 0;
2948
2949       /* %g1 is used to build the function address */
2950       if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
2951         return 0;
2952
2953       return 1;
2954     }
2955
2956   /* Otherwise, only operations which can be done in tandem with
2957      a `restore' insn can go into the delay slot.  */
2958   if (GET_CODE (SET_DEST (pat)) != REG
2959       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
2960       || REGNO (SET_DEST (pat)) >= 32)
2961     return 0;
2962
2963   /* If it mentions %o7, it can't go in, because sibcall will clobber it
2964      in most cases.  */
2965   if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
2966     return 0;
2967
2968   return eligible_for_restore_insn (trial, false);
2969 }
2970
2971 int
2972 short_branch (int uid1, int uid2)
2973 {
2974   int delta = INSN_ADDRESSES (uid1) - INSN_ADDRESSES (uid2);
2975
2976   /* Leave a few words of "slop".  */
2977   if (delta >= -1023 && delta <= 1022)
2978     return 1;
2979
2980   return 0;
2981 }
2982
2983 /* Return nonzero if REG is not used after INSN.
2984    We assume REG is a reload reg, and therefore does
2985    not live past labels or calls or jumps.  */
2986 int
2987 reg_unused_after (rtx reg, rtx insn)
2988 {
2989   enum rtx_code code, prev_code = UNKNOWN;
2990
2991   while ((insn = NEXT_INSN (insn)))
2992     {
2993       if (prev_code == CALL_INSN && call_used_regs[REGNO (reg)])
2994         return 1;
2995
2996       code = GET_CODE (insn);
2997       if (GET_CODE (insn) == CODE_LABEL)
2998         return 1;
2999
3000       if (INSN_P (insn))
3001         {
3002           rtx set = single_set (insn);
3003           int in_src = set && reg_overlap_mentioned_p (reg, SET_SRC (set));
3004           if (set && in_src)
3005             return 0;
3006           if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
3007             return 1;
3008           if (set == 0 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
3009             return 0;
3010         }
3011       prev_code = code;
3012     }
3013   return 1;
3014 }
3015 \f
3016 /* Determine if it's legal to put X into the constant pool.  This
3017    is not possible if X contains the address of a symbol that is
3018    not constant (TLS) or not known at final link time (PIC).  */
3019
3020 static bool
3021 sparc_cannot_force_const_mem (enum machine_mode mode, rtx x)
3022 {
3023   switch (GET_CODE (x))
3024     {
3025     case CONST_INT:
3026     case CONST_DOUBLE:
3027     case CONST_VECTOR:
3028       /* Accept all non-symbolic constants.  */
3029       return false;
3030
3031     case LABEL_REF:
3032       /* Labels are OK iff we are non-PIC.  */
3033       return flag_pic != 0;
3034
3035     case SYMBOL_REF:
3036       /* 'Naked' TLS symbol references are never OK,
3037          non-TLS symbols are OK iff we are non-PIC.  */
3038       if (SYMBOL_REF_TLS_MODEL (x))
3039         return true;
3040       else
3041         return flag_pic != 0;
3042
3043     case CONST:
3044       return sparc_cannot_force_const_mem (mode, XEXP (x, 0));
3045     case PLUS:
3046     case MINUS:
3047       return sparc_cannot_force_const_mem (mode, XEXP (x, 0))
3048          || sparc_cannot_force_const_mem (mode, XEXP (x, 1));
3049     case UNSPEC:
3050       return true;
3051     default:
3052       gcc_unreachable ();
3053     }
3054 }
3055 \f
3056 /* Global Offset Table support.  */
3057 static GTY(()) rtx got_helper_rtx = NULL_RTX;
3058 static GTY(()) rtx global_offset_table_rtx = NULL_RTX;
3059
3060 /* Return the SYMBOL_REF for the Global Offset Table.  */
3061
3062 static GTY(()) rtx sparc_got_symbol = NULL_RTX;
3063
3064 static rtx
3065 sparc_got (void)
3066 {
3067   if (!sparc_got_symbol)
3068     sparc_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3069
3070   return sparc_got_symbol;
3071 }
3072
3073 /* Ensure that we are not using patterns that are not OK with PIC.  */
3074
3075 int
3076 check_pic (int i)
3077 {
3078   rtx op;
3079
3080   switch (flag_pic)
3081     {
3082     case 1:
3083       op = recog_data.operand[i];
3084       gcc_assert (GET_CODE (op) != SYMBOL_REF
3085                   && (GET_CODE (op) != CONST
3086                       || (GET_CODE (XEXP (op, 0)) == MINUS
3087                           && XEXP (XEXP (op, 0), 0) == sparc_got ()
3088                           && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST)));
3089     case 2:
3090     default:
3091       return 1;
3092     }
3093 }
3094
3095 /* Return true if X is an address which needs a temporary register when
3096    reloaded while generating PIC code.  */
3097
3098 int
3099 pic_address_needs_scratch (rtx x)
3100 {
3101   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
3102   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3103       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3104       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3105       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
3106     return 1;
3107
3108   return 0;
3109 }
3110
3111 /* Determine if a given RTX is a valid constant.  We already know this
3112    satisfies CONSTANT_P.  */
3113
3114 static bool
3115 sparc_legitimate_constant_p (enum machine_mode mode, rtx x)
3116 {
3117   switch (GET_CODE (x))
3118     {
3119     case CONST:
3120     case SYMBOL_REF:
3121       if (sparc_tls_referenced_p (x))
3122         return false;
3123       break;
3124
3125     case CONST_DOUBLE:
3126       if (GET_MODE (x) == VOIDmode)
3127         return true;
3128
3129       /* Floating point constants are generally not ok.
3130          The only exception is 0.0 and all-ones in VIS.  */
3131       if (TARGET_VIS
3132           && SCALAR_FLOAT_MODE_P (mode)
3133           && (const_zero_operand (x, mode)
3134               || const_all_ones_operand (x, mode)))
3135         return true;
3136
3137       return false;
3138
3139     case CONST_VECTOR:
3140       /* Vector constants are generally not ok.
3141          The only exception is 0 or -1 in VIS.  */
3142       if (TARGET_VIS
3143           && (const_zero_operand (x, mode)
3144               || const_all_ones_operand (x, mode)))
3145         return true;
3146
3147       return false;
3148
3149     default:
3150       break;
3151     }
3152
3153   return true;
3154 }
3155
3156 /* Determine if a given RTX is a valid constant address.  */
3157
3158 bool
3159 constant_address_p (rtx x)
3160 {
3161   switch (GET_CODE (x))
3162     {
3163     case LABEL_REF:
3164     case CONST_INT:
3165     case HIGH:
3166       return true;
3167
3168     case CONST:
3169       if (flag_pic && pic_address_needs_scratch (x))
3170         return false;
3171       return sparc_legitimate_constant_p (Pmode, x);
3172
3173     case SYMBOL_REF:
3174       return !flag_pic && sparc_legitimate_constant_p (Pmode, x);
3175
3176     default:
3177       return false;
3178     }
3179 }
3180
3181 /* Nonzero if the constant value X is a legitimate general operand
3182    when generating PIC code.  It is given that flag_pic is on and
3183    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
3184
3185 bool
3186 legitimate_pic_operand_p (rtx x)
3187 {
3188   if (pic_address_needs_scratch (x))
3189     return false;
3190   if (sparc_tls_referenced_p (x))
3191     return false;
3192   return true;
3193 }
3194
3195 #define RTX_OK_FOR_OFFSET_P(X, MODE)                    \
3196   (CONST_INT_P (X)                                      \
3197    && INTVAL (X) >= -0x1000                             \
3198    && INTVAL (X) < (0x1000 - GET_MODE_SIZE (MODE)))
3199
3200 #define RTX_OK_FOR_OLO10_P(X, MODE)                     \
3201   (CONST_INT_P (X)                                      \
3202    && INTVAL (X) >= -0x1000                             \
3203    && INTVAL (X) < (0xc00 - GET_MODE_SIZE (MODE)))
3204
3205 /* Handle the TARGET_LEGITIMATE_ADDRESS_P target hook.
3206
3207    On SPARC, the actual legitimate addresses must be REG+REG or REG+SMALLINT
3208    ordinarily.  This changes a bit when generating PIC.  */
3209
3210 static bool
3211 sparc_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3212 {
3213   rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3214
3215   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3216     rs1 = addr;
3217   else if (GET_CODE (addr) == PLUS)
3218     {
3219       rs1 = XEXP (addr, 0);
3220       rs2 = XEXP (addr, 1);
3221
3222       /* Canonicalize.  REG comes first, if there are no regs,
3223          LO_SUM comes first.  */
3224       if (!REG_P (rs1)
3225           && GET_CODE (rs1) != SUBREG
3226           && (REG_P (rs2)
3227               || GET_CODE (rs2) == SUBREG
3228               || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3229         {
3230           rs1 = XEXP (addr, 1);
3231           rs2 = XEXP (addr, 0);
3232         }
3233
3234       if ((flag_pic == 1
3235            && rs1 == pic_offset_table_rtx
3236            && !REG_P (rs2)
3237            && GET_CODE (rs2) != SUBREG
3238            && GET_CODE (rs2) != LO_SUM
3239            && GET_CODE (rs2) != MEM
3240            && !(GET_CODE (rs2) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs2))
3241            && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3242            && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3243           || ((REG_P (rs1)
3244                || GET_CODE (rs1) == SUBREG)
3245               && RTX_OK_FOR_OFFSET_P (rs2, mode)))
3246         {
3247           imm1 = rs2;
3248           rs2 = NULL;
3249         }
3250       else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3251                && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3252         {
3253           /* We prohibit REG + REG for TFmode when there are no quad move insns
3254              and we consequently need to split.  We do this because REG+REG
3255              is not an offsettable address.  If we get the situation in reload
3256              where source and destination of a movtf pattern are both MEMs with
3257              REG+REG address, then only one of them gets converted to an
3258              offsettable address.  */
3259           if (mode == TFmode
3260               && ! (TARGET_FPU && TARGET_ARCH64 && TARGET_HARD_QUAD))
3261             return 0;
3262
3263           /* We prohibit REG + REG on ARCH32 if not optimizing for
3264              DFmode/DImode because then mem_min_alignment is likely to be zero
3265              after reload and the  forced split would lack a matching splitter
3266              pattern.  */
3267           if (TARGET_ARCH32 && !optimize
3268               && (mode == DFmode || mode == DImode))
3269             return 0;
3270         }
3271       else if (USE_AS_OFFSETABLE_LO10
3272                && GET_CODE (rs1) == LO_SUM
3273                && TARGET_ARCH64
3274                && ! TARGET_CM_MEDMID
3275                && RTX_OK_FOR_OLO10_P (rs2, mode))
3276         {
3277           rs2 = NULL;
3278           imm1 = XEXP (rs1, 1);
3279           rs1 = XEXP (rs1, 0);
3280           if (!CONSTANT_P (imm1)
3281               || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3282             return 0;
3283         }
3284     }
3285   else if (GET_CODE (addr) == LO_SUM)
3286     {
3287       rs1 = XEXP (addr, 0);
3288       imm1 = XEXP (addr, 1);
3289
3290       if (!CONSTANT_P (imm1)
3291           || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3292         return 0;
3293
3294       /* We can't allow TFmode in 32-bit mode, because an offset greater
3295          than the alignment (8) may cause the LO_SUM to overflow.  */
3296       if (mode == TFmode && TARGET_ARCH32)
3297         return 0;
3298     }
3299   else if (GET_CODE (addr) == CONST_INT && SMALL_INT (addr))
3300     return 1;
3301   else
3302     return 0;
3303
3304   if (GET_CODE (rs1) == SUBREG)
3305     rs1 = SUBREG_REG (rs1);
3306   if (!REG_P (rs1))
3307     return 0;
3308
3309   if (rs2)
3310     {
3311       if (GET_CODE (rs2) == SUBREG)
3312         rs2 = SUBREG_REG (rs2);
3313       if (!REG_P (rs2))
3314         return 0;
3315     }
3316
3317   if (strict)
3318     {
3319       if (!REGNO_OK_FOR_BASE_P (REGNO (rs1))
3320           || (rs2 && !REGNO_OK_FOR_BASE_P (REGNO (rs2))))
3321         return 0;
3322     }
3323   else
3324     {
3325       if ((REGNO (rs1) >= 32
3326            && REGNO (rs1) != FRAME_POINTER_REGNUM
3327            && REGNO (rs1) < FIRST_PSEUDO_REGISTER)
3328           || (rs2
3329               && (REGNO (rs2) >= 32
3330                   && REGNO (rs2) != FRAME_POINTER_REGNUM
3331                   && REGNO (rs2) < FIRST_PSEUDO_REGISTER)))
3332         return 0;
3333     }
3334   return 1;
3335 }
3336
3337 /* Return the SYMBOL_REF for the tls_get_addr function.  */
3338
3339 static GTY(()) rtx sparc_tls_symbol = NULL_RTX;
3340
3341 static rtx
3342 sparc_tls_get_addr (void)
3343 {
3344   if (!sparc_tls_symbol)
3345     sparc_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_addr");
3346
3347   return sparc_tls_symbol;
3348 }
3349
3350 /* Return the Global Offset Table to be used in TLS mode.  */
3351
3352 static rtx
3353 sparc_tls_got (void)
3354 {
3355   /* In PIC mode, this is just the PIC offset table.  */
3356   if (flag_pic)
3357     {
3358       crtl->uses_pic_offset_table = 1;
3359       return pic_offset_table_rtx;
3360     }
3361
3362   /* In non-PIC mode, Sun as (unlike GNU as) emits PC-relative relocations for
3363      the GOT symbol with the 32-bit ABI, so we reload the GOT register.  */
3364   if (TARGET_SUN_TLS && TARGET_ARCH32)
3365     {
3366       load_got_register ();
3367       return global_offset_table_rtx;
3368     }
3369
3370   /* In all other cases, we load a new pseudo with the GOT symbol.  */
3371   return copy_to_reg (sparc_got ());
3372 }
3373
3374 /* Return true if X contains a thread-local symbol.  */
3375
3376 static bool
3377 sparc_tls_referenced_p (rtx x)
3378 {
3379   if (!TARGET_HAVE_TLS)
3380     return false;
3381
3382   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS)
3383     x = XEXP (XEXP (x, 0), 0);
3384
3385   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x))
3386     return true;
3387
3388   /* That's all we handle in sparc_legitimize_tls_address for now.  */
3389   return false;
3390 }
3391
3392 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3393    this (thread-local) address.  */
3394
3395 static rtx
3396 sparc_legitimize_tls_address (rtx addr)
3397 {
3398   rtx temp1, temp2, temp3, ret, o0, got, insn;
3399
3400   gcc_assert (can_create_pseudo_p ());
3401
3402   if (GET_CODE (addr) == SYMBOL_REF)
3403     switch (SYMBOL_REF_TLS_MODEL (addr))
3404       {
3405       case TLS_MODEL_GLOBAL_DYNAMIC:
3406         start_sequence ();
3407         temp1 = gen_reg_rtx (SImode);
3408         temp2 = gen_reg_rtx (SImode);
3409         ret = gen_reg_rtx (Pmode);
3410         o0 = gen_rtx_REG (Pmode, 8);
3411         got = sparc_tls_got ();
3412         emit_insn (gen_tgd_hi22 (temp1, addr));
3413         emit_insn (gen_tgd_lo10 (temp2, temp1, addr));
3414         if (TARGET_ARCH32)
3415           {
3416             emit_insn (gen_tgd_add32 (o0, got, temp2, addr));
3417             insn = emit_call_insn (gen_tgd_call32 (o0, sparc_tls_get_addr (),
3418                                                    addr, const1_rtx));
3419           }
3420         else
3421           {
3422             emit_insn (gen_tgd_add64 (o0, got, temp2, addr));
3423             insn = emit_call_insn (gen_tgd_call64 (o0, sparc_tls_get_addr (),
3424                                                    addr, const1_rtx));
3425           }
3426         use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
3427         insn = get_insns ();
3428         end_sequence ();
3429         emit_libcall_block (insn, ret, o0, addr);
3430         break;
3431
3432       case TLS_MODEL_LOCAL_DYNAMIC:
3433         start_sequence ();
3434         temp1 = gen_reg_rtx (SImode);
3435         temp2 = gen_reg_rtx (SImode);
3436         temp3 = gen_reg_rtx (Pmode);
3437         ret = gen_reg_rtx (Pmode);
3438         o0 = gen_rtx_REG (Pmode, 8);
3439         got = sparc_tls_got ();
3440         emit_insn (gen_tldm_hi22 (temp1));
3441         emit_insn (gen_tldm_lo10 (temp2, temp1));
3442         if (TARGET_ARCH32)
3443           {
3444             emit_insn (gen_tldm_add32 (o0, got, temp2));
3445             insn = emit_call_insn (gen_tldm_call32 (o0, sparc_tls_get_addr (),
3446                                                     const1_rtx));
3447           }
3448         else
3449           {
3450             emit_insn (gen_tldm_add64 (o0, got, temp2));
3451             insn = emit_call_insn (gen_tldm_call64 (o0, sparc_tls_get_addr (),
3452                                                     const1_rtx));
3453           }
3454         use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
3455         insn = get_insns ();
3456         end_sequence ();
3457         emit_libcall_block (insn, temp3, o0,
3458                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3459                                             UNSPEC_TLSLD_BASE));
3460         temp1 = gen_reg_rtx (SImode);
3461         temp2 = gen_reg_rtx (SImode);
3462         emit_insn (gen_tldo_hix22 (temp1, addr));
3463         emit_insn (gen_tldo_lox10 (temp2, temp1, addr));
3464         if (TARGET_ARCH32)
3465           emit_insn (gen_tldo_add32 (ret, temp3, temp2, addr));
3466         else
3467           emit_insn (gen_tldo_add64 (ret, temp3, temp2, addr));
3468         break;
3469
3470       case TLS_MODEL_INITIAL_EXEC:
3471         temp1 = gen_reg_rtx (SImode);
3472         temp2 = gen_reg_rtx (SImode);
3473         temp3 = gen_reg_rtx (Pmode);
3474         got = sparc_tls_got ();
3475         emit_insn (gen_tie_hi22 (temp1, addr));
3476         emit_insn (gen_tie_lo10 (temp2, temp1, addr));
3477         if (TARGET_ARCH32)
3478           emit_insn (gen_tie_ld32 (temp3, got, temp2, addr));
3479         else
3480           emit_insn (gen_tie_ld64 (temp3, got, temp2, addr));
3481         if (TARGET_SUN_TLS)
3482           {
3483             ret = gen_reg_rtx (Pmode);
3484             if (TARGET_ARCH32)
3485               emit_insn (gen_tie_add32 (ret, gen_rtx_REG (Pmode, 7),
3486                                         temp3, addr));
3487             else
3488               emit_insn (gen_tie_add64 (ret, gen_rtx_REG (Pmode, 7),
3489                                         temp3, addr));
3490           }
3491         else
3492           ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp3);
3493         break;
3494
3495       case TLS_MODEL_LOCAL_EXEC:
3496         temp1 = gen_reg_rtx (Pmode);
3497         temp2 = gen_reg_rtx (Pmode);
3498         if (TARGET_ARCH32)
3499           {
3500             emit_insn (gen_tle_hix22_sp32 (temp1, addr));
3501             emit_insn (gen_tle_lox10_sp32 (temp2, temp1, addr));
3502           }
3503         else
3504           {
3505             emit_insn (gen_tle_hix22_sp64 (temp1, addr));
3506             emit_insn (gen_tle_lox10_sp64 (temp2, temp1, addr));
3507           }
3508         ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp2);
3509         break;
3510
3511       default:
3512         gcc_unreachable ();
3513       }
3514
3515   else if (GET_CODE (addr) == CONST)
3516     {
3517       rtx base, offset;
3518
3519       gcc_assert (GET_CODE (XEXP (addr, 0)) == PLUS);
3520
3521       base = sparc_legitimize_tls_address (XEXP (XEXP (addr, 0), 0));
3522       offset = XEXP (XEXP (addr, 0), 1);
3523
3524       base = force_operand (base, NULL_RTX);
3525       if (!(GET_CODE (offset) == CONST_INT && SMALL_INT (offset)))
3526         offset = force_reg (Pmode, offset);
3527       ret = gen_rtx_PLUS (Pmode, base, offset);
3528     }
3529
3530   else
3531     gcc_unreachable ();  /* for now ... */
3532
3533   return ret;
3534 }
3535
3536 /* Legitimize PIC addresses.  If the address is already position-independent,
3537    we return ORIG.  Newly generated position-independent addresses go into a
3538    reg.  This is REG if nonzero, otherwise we allocate register(s) as
3539    necessary.  */
3540
3541 static rtx
3542 sparc_legitimize_pic_address (rtx orig, rtx reg)
3543 {
3544   bool gotdata_op = false;
3545
3546   if (GET_CODE (orig) == SYMBOL_REF
3547       /* See the comment in sparc_expand_move.  */
3548       || (GET_CODE (orig) == LABEL_REF && !can_use_mov_pic_label_ref (orig)))
3549     {
3550       rtx pic_ref, address;
3551       rtx insn;
3552
3553       if (reg == 0)
3554         {
3555           gcc_assert (! reload_in_progress && ! reload_completed);
3556           reg = gen_reg_rtx (Pmode);
3557         }
3558
3559       if (flag_pic == 2)
3560         {
3561           /* If not during reload, allocate another temp reg here for loading
3562              in the address, so that these instructions can be optimized
3563              properly.  */
3564           rtx temp_reg = ((reload_in_progress || reload_completed)
3565                           ? reg : gen_reg_rtx (Pmode));
3566
3567           /* Must put the SYMBOL_REF inside an UNSPEC here so that cse
3568              won't get confused into thinking that these two instructions
3569              are loading in the true address of the symbol.  If in the
3570              future a PIC rtx exists, that should be used instead.  */
3571           if (TARGET_ARCH64)
3572             {
3573               emit_insn (gen_movdi_high_pic (temp_reg, orig));
3574               emit_insn (gen_movdi_lo_sum_pic (temp_reg, temp_reg, orig));
3575             }
3576           else
3577             {
3578               emit_insn (gen_movsi_high_pic (temp_reg, orig));
3579               emit_insn (gen_movsi_lo_sum_pic (temp_reg, temp_reg, orig));
3580             }
3581           address = temp_reg;
3582           gotdata_op = true;
3583         }
3584       else
3585         address = orig;
3586
3587       crtl->uses_pic_offset_table = 1;
3588       if (gotdata_op)
3589         {
3590           if (TARGET_ARCH64)
3591             insn = emit_insn (gen_movdi_pic_gotdata_op (reg,
3592                                                         pic_offset_table_rtx,
3593                                                         address, orig));
3594           else
3595             insn = emit_insn (gen_movsi_pic_gotdata_op (reg,
3596                                                         pic_offset_table_rtx,
3597                                                         address, orig));
3598         }
3599       else
3600         {
3601           pic_ref
3602             = gen_const_mem (Pmode,
3603                              gen_rtx_PLUS (Pmode,
3604                                            pic_offset_table_rtx, address));
3605           insn = emit_move_insn (reg, pic_ref);
3606         }
3607
3608       /* Put a REG_EQUAL note on this insn, so that it can be optimized
3609          by loop.  */
3610       set_unique_reg_note (insn, REG_EQUAL, orig);
3611       return reg;
3612     }
3613   else if (GET_CODE (orig) == CONST)
3614     {
3615       rtx base, offset;
3616
3617       if (GET_CODE (XEXP (orig, 0)) == PLUS
3618           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
3619         return orig;
3620
3621       if (reg == 0)
3622         {
3623           gcc_assert (! reload_in_progress && ! reload_completed);
3624           reg = gen_reg_rtx (Pmode);
3625         }
3626
3627       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
3628       base = sparc_legitimize_pic_address (XEXP (XEXP (orig, 0), 0), reg);
3629       offset = sparc_legitimize_pic_address (XEXP (XEXP (orig, 0), 1),
3630                                              base == reg ? NULL_RTX : reg);
3631
3632       if (GET_CODE (offset) == CONST_INT)
3633         {
3634           if (SMALL_INT (offset))
3635             return plus_constant (base, INTVAL (offset));
3636           else if (! reload_in_progress && ! reload_completed)
3637             offset = force_reg (Pmode, offset);
3638           else
3639             /* If we reach here, then something is seriously wrong.  */
3640             gcc_unreachable ();
3641         }
3642       return gen_rtx_PLUS (Pmode, base, offset);
3643     }
3644   else if (GET_CODE (orig) == LABEL_REF)
3645     /* ??? We ought to be checking that the register is live instead, in case
3646        it is eliminated.  */
3647     crtl->uses_pic_offset_table = 1;
3648
3649   return orig;
3650 }
3651
3652 /* Try machine-dependent ways of modifying an illegitimate address X
3653    to be legitimate.  If we find one, return the new, valid address.
3654
3655    OLDX is the address as it was before break_out_memory_refs was called.
3656    In some cases it is useful to look at this to decide what needs to be done.
3657
3658    MODE is the mode of the operand pointed to by X.
3659
3660    On SPARC, change REG+N into REG+REG, and REG+(X*Y) into REG+REG.  */
3661
3662 static rtx
3663 sparc_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3664                           enum machine_mode mode)
3665 {
3666   rtx orig_x = x;
3667
3668   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT)
3669     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3670                       force_operand (XEXP (x, 0), NULL_RTX));
3671   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == MULT)
3672     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3673                       force_operand (XEXP (x, 1), NULL_RTX));
3674   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS)
3675     x = gen_rtx_PLUS (Pmode, force_operand (XEXP (x, 0), NULL_RTX),
3676                       XEXP (x, 1));
3677   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == PLUS)
3678     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3679                       force_operand (XEXP (x, 1), NULL_RTX));
3680
3681   if (x != orig_x && sparc_legitimate_address_p (mode, x, FALSE))
3682     return x;
3683
3684   if (sparc_tls_referenced_p (x))
3685     x = sparc_legitimize_tls_address (x);
3686   else if (flag_pic)
3687     x = sparc_legitimize_pic_address (x, NULL_RTX);
3688   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 1)))
3689     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3690                       copy_to_mode_reg (Pmode, XEXP (x, 1)));
3691   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 0)))
3692     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3693                       copy_to_mode_reg (Pmode, XEXP (x, 0)));
3694   else if (GET_CODE (x) == SYMBOL_REF
3695            || GET_CODE (x) == CONST
3696            || GET_CODE (x) == LABEL_REF)
3697     x = copy_to_suggested_reg (x, NULL_RTX, Pmode);
3698
3699   return x;
3700 }
3701
3702 /* Delegitimize an address that was legitimized by the above function.  */
3703
3704 static rtx
3705 sparc_delegitimize_address (rtx x)
3706 {
3707   x = delegitimize_mem_from_attrs (x);
3708
3709   if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 1)) == UNSPEC)
3710     switch (XINT (XEXP (x, 1), 1))
3711       {
3712       case UNSPEC_MOVE_PIC:
3713       case UNSPEC_TLSLE:
3714         x = XVECEXP (XEXP (x, 1), 0, 0);
3715         gcc_assert (GET_CODE (x) == SYMBOL_REF);
3716         break;
3717       default:
3718         break;
3719       }
3720
3721   /* This is generated by mov{si,di}_pic_label_ref in PIC mode.  */
3722   if (GET_CODE (x) == MINUS
3723       && REG_P (XEXP (x, 0))
3724       && REGNO (XEXP (x, 0)) == PIC_OFFSET_TABLE_REGNUM
3725       && GET_CODE (XEXP (x, 1)) == LO_SUM
3726       && GET_CODE (XEXP (XEXP (x, 1), 1)) == UNSPEC
3727       && XINT (XEXP (XEXP (x, 1), 1), 1) == UNSPEC_MOVE_PIC_LABEL)
3728     {
3729       x = XVECEXP (XEXP (XEXP (x, 1), 1), 0, 0);
3730       gcc_assert (GET_CODE (x) == LABEL_REF);
3731     }
3732
3733   return x;
3734 }
3735
3736 /* SPARC implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
3737    replace the input X, or the original X if no replacement is called for.
3738    The output parameter *WIN is 1 if the calling macro should goto WIN,
3739    0 if it should not.
3740
3741    For SPARC, we wish to handle addresses by splitting them into
3742    HIGH+LO_SUM pairs, retaining the LO_SUM in the memory reference.
3743    This cuts the number of extra insns by one.
3744
3745    Do nothing when generating PIC code and the address is a symbolic
3746    operand or requires a scratch register.  */
3747
3748 rtx
3749 sparc_legitimize_reload_address (rtx x, enum machine_mode mode,
3750                                  int opnum, int type,
3751                                  int ind_levels ATTRIBUTE_UNUSED, int *win)
3752 {
3753   /* Decompose SImode constants into HIGH+LO_SUM.  */
3754   if (CONSTANT_P (x)
3755       && (mode != TFmode || TARGET_ARCH64)
3756       && GET_MODE (x) == SImode
3757       && GET_CODE (x) != LO_SUM
3758       && GET_CODE (x) != HIGH
3759       && sparc_cmodel <= CM_MEDLOW
3760       && !(flag_pic
3761            && (symbolic_operand (x, Pmode) || pic_address_needs_scratch (x))))
3762     {
3763       x = gen_rtx_LO_SUM (GET_MODE (x), gen_rtx_HIGH (GET_MODE (x), x), x);
3764       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3765                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3766                    opnum, (enum reload_type)type);
3767       *win = 1;
3768       return x;
3769     }
3770
3771   /* We have to recognize what we have already generated above.  */
3772   if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 0)) == HIGH)
3773     {
3774       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3775                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3776                    opnum, (enum reload_type)type);
3777       *win = 1;
3778       return x;
3779     }
3780
3781   *win = 0;
3782   return x;
3783 }
3784
3785 /* Return true if ADDR (a legitimate address expression)
3786    has an effect that depends on the machine mode it is used for.
3787
3788    In PIC mode,
3789
3790       (mem:HI [%l7+a])
3791
3792    is not equivalent to
3793
3794       (mem:QI [%l7+a]) (mem:QI [%l7+a+1])
3795
3796    because [%l7+a+1] is interpreted as the address of (a+1).  */
3797
3798
3799 static bool
3800 sparc_mode_dependent_address_p (const_rtx addr)
3801 {
3802   if (flag_pic && GET_CODE (addr) == PLUS)
3803     {
3804       rtx op0 = XEXP (addr, 0);
3805       rtx op1 = XEXP (addr, 1);
3806       if (op0 == pic_offset_table_rtx
3807           && symbolic_operand (op1, VOIDmode))
3808         return true;
3809     }
3810
3811   return false;
3812 }
3813
3814 #ifdef HAVE_GAS_HIDDEN
3815 # define USE_HIDDEN_LINKONCE 1
3816 #else
3817 # define USE_HIDDEN_LINKONCE 0
3818 #endif
3819
3820 static void
3821 get_pc_thunk_name (char name[32], unsigned int regno)
3822 {
3823   const char *reg_name = reg_names[regno];
3824
3825   /* Skip the leading '%' as that cannot be used in a
3826      symbol name.  */
3827   reg_name += 1;
3828
3829   if (USE_HIDDEN_LINKONCE)
3830     sprintf (name, "__sparc_get_pc_thunk.%s", reg_name);
3831   else
3832     ASM_GENERATE_INTERNAL_LABEL (name, "LADDPC", regno);
3833 }
3834
3835 /* Wrapper around the load_pcrel_sym{si,di} patterns.  */
3836
3837 static rtx
3838 gen_load_pcrel_sym (rtx op0, rtx op1, rtx op2, rtx op3)
3839 {
3840   int orig_flag_pic = flag_pic;
3841   rtx insn;
3842
3843   /* The load_pcrel_sym{si,di} patterns require absolute addressing.  */
3844   flag_pic = 0;
3845   if (TARGET_ARCH64)
3846     insn = gen_load_pcrel_symdi (op0, op1, op2, op3);
3847   else
3848     insn = gen_load_pcrel_symsi (op0, op1, op2, op3);
3849   flag_pic = orig_flag_pic;
3850
3851   return insn;
3852 }
3853
3854 /* Emit code to load the GOT register.  */
3855
3856 void
3857 load_got_register (void)
3858 {
3859   /* In PIC mode, this will retrieve pic_offset_table_rtx.  */
3860   if (!global_offset_table_rtx)
3861     global_offset_table_rtx = gen_rtx_REG (Pmode, GLOBAL_OFFSET_TABLE_REGNUM);
3862
3863   if (TARGET_VXWORKS_RTP)
3864     emit_insn (gen_vxworks_load_got ());
3865   else
3866     {
3867       /* The GOT symbol is subject to a PC-relative relocation so we need a
3868          helper function to add the PC value and thus get the final value.  */
3869       if (!got_helper_rtx)
3870         {
3871           char name[32];
3872           get_pc_thunk_name (name, GLOBAL_OFFSET_TABLE_REGNUM);
3873           got_helper_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
3874         }
3875
3876       emit_insn (gen_load_pcrel_sym (global_offset_table_rtx, sparc_got (),
3877                                      got_helper_rtx,
3878                                      GEN_INT (GLOBAL_OFFSET_TABLE_REGNUM)));
3879     }
3880
3881   /* Need to emit this whether or not we obey regdecls,
3882      since setjmp/longjmp can cause life info to screw up.
3883      ??? In the case where we don't obey regdecls, this is not sufficient
3884      since we may not fall out the bottom.  */
3885   emit_use (global_offset_table_rtx);
3886 }
3887
3888 /* Emit a call instruction with the pattern given by PAT.  ADDR is the
3889    address of the call target.  */
3890
3891 void
3892 sparc_emit_call_insn (rtx pat, rtx addr)
3893 {
3894   rtx insn;
3895
3896   insn = emit_call_insn (pat);
3897
3898   /* The PIC register is live on entry to VxWorks PIC PLT entries.  */
3899   if (TARGET_VXWORKS_RTP
3900       && flag_pic
3901       && GET_CODE (addr) == SYMBOL_REF
3902       && (SYMBOL_REF_DECL (addr)
3903           ? !targetm.binds_local_p (SYMBOL_REF_DECL (addr))
3904           : !SYMBOL_REF_LOCAL_P (addr)))
3905     {
3906       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
3907       crtl->uses_pic_offset_table = 1;
3908     }
3909 }
3910 \f
3911 /* Return 1 if RTX is a MEM which is known to be aligned to at
3912    least a DESIRED byte boundary.  */
3913
3914 int
3915 mem_min_alignment (rtx mem, int desired)
3916 {
3917   rtx addr, base, offset;
3918
3919   /* If it's not a MEM we can't accept it.  */
3920   if (GET_CODE (mem) != MEM)
3921     return 0;
3922
3923   /* Obviously...  */
3924   if (!TARGET_UNALIGNED_DOUBLES
3925       && MEM_ALIGN (mem) / BITS_PER_UNIT >= (unsigned)desired)
3926     return 1;
3927
3928   /* ??? The rest of the function predates MEM_ALIGN so
3929      there is probably a bit of redundancy.  */
3930   addr = XEXP (mem, 0);
3931   base = offset = NULL_RTX;
3932   if (GET_CODE (addr) == PLUS)
3933     {
3934       if (GET_CODE (XEXP (addr, 0)) == REG)
3935         {
3936           base = XEXP (addr, 0);
3937
3938           /* What we are saying here is that if the base
3939              REG is aligned properly, the compiler will make
3940              sure any REG based index upon it will be so
3941              as well.  */
3942           if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3943             offset = XEXP (addr, 1);
3944           else
3945             offset = const0_rtx;
3946         }
3947     }
3948   else if (GET_CODE (addr) == REG)
3949     {
3950       base = addr;
3951       offset = const0_rtx;
3952     }
3953
3954   if (base != NULL_RTX)
3955     {
3956       int regno = REGNO (base);
3957
3958       if (regno != HARD_FRAME_POINTER_REGNUM && regno != STACK_POINTER_REGNUM)
3959         {
3960           /* Check if the compiler has recorded some information
3961              about the alignment of the base REG.  If reload has
3962              completed, we already matched with proper alignments.
3963              If not running global_alloc, reload might give us
3964              unaligned pointer to local stack though.  */
3965           if (((cfun != 0
3966                 && REGNO_POINTER_ALIGN (regno) >= desired * BITS_PER_UNIT)
3967                || (optimize && reload_completed))
3968               && (INTVAL (offset) & (desired - 1)) == 0)
3969             return 1;
3970         }
3971       else
3972         {
3973           if (((INTVAL (offset) - SPARC_STACK_BIAS) & (desired - 1)) == 0)
3974             return 1;
3975         }
3976     }
3977   else if (! TARGET_UNALIGNED_DOUBLES
3978            || CONSTANT_P (addr)
3979            || GET_CODE (addr) == LO_SUM)
3980     {
3981       /* Anything else we know is properly aligned unless TARGET_UNALIGNED_DOUBLES
3982          is true, in which case we can only assume that an access is aligned if
3983          it is to a constant address, or the address involves a LO_SUM.  */
3984       return 1;
3985     }
3986
3987   /* An obviously unaligned address.  */
3988   return 0;
3989 }
3990
3991 \f
3992 /* Vectors to keep interesting information about registers where it can easily
3993    be got.  We used to use the actual mode value as the bit number, but there
3994    are more than 32 modes now.  Instead we use two tables: one indexed by
3995    hard register number, and one indexed by mode.  */
3996
3997 /* The purpose of sparc_mode_class is to shrink the range of modes so that
3998    they all fit (as bit numbers) in a 32-bit word (again).  Each real mode is
3999    mapped into one sparc_mode_class mode.  */
4000
4001 enum sparc_mode_class {
4002   S_MODE, D_MODE, T_MODE, O_MODE,
4003   SF_MODE, DF_MODE, TF_MODE, OF_MODE,
4004   CC_MODE, CCFP_MODE
4005 };
4006
4007 /* Modes for single-word and smaller quantities.  */
4008 #define S_MODES ((1 << (int) S_MODE) | (1 << (int) SF_MODE))
4009
4010 /* Modes for double-word and smaller quantities.  */
4011 #define D_MODES (S_MODES | (1 << (int) D_MODE) | (1 << DF_MODE))
4012
4013 /* Modes for quad-word and smaller quantities.  */
4014 #define T_MODES (D_MODES | (1 << (int) T_MODE) | (1 << (int) TF_MODE))
4015
4016 /* Modes for 8-word and smaller quantities.  */
4017 #define O_MODES (T_MODES | (1 << (int) O_MODE) | (1 << (int) OF_MODE))
4018
4019 /* Modes for single-float quantities.  We must allow any single word or
4020    smaller quantity.  This is because the fix/float conversion instructions
4021    take integer inputs/outputs from the float registers.  */
4022 #define SF_MODES (S_MODES)
4023
4024 /* Modes for double-float and smaller quantities.  */
4025 #define DF_MODES (D_MODES)
4026
4027 /* Modes for quad-float and smaller quantities.  */
4028 #define TF_MODES (DF_MODES | (1 << (int) TF_MODE))
4029
4030 /* Modes for quad-float pairs and smaller quantities.  */
4031 #define OF_MODES (TF_MODES | (1 << (int) OF_MODE))
4032
4033 /* Modes for double-float only quantities.  */
4034 #define DF_MODES_NO_S ((1 << (int) D_MODE) | (1 << (int) DF_MODE))
4035
4036 /* Modes for quad-float and double-float only quantities.  */
4037 #define TF_MODES_NO_S (DF_MODES_NO_S | (1 << (int) TF_MODE))
4038
4039 /* Modes for quad-float pairs and double-float only quantities.  */
4040 #define OF_MODES_NO_S (TF_MODES_NO_S | (1 << (int) OF_MODE))
4041
4042 /* Modes for condition codes.  */
4043 #define CC_MODES (1 << (int) CC_MODE)
4044 #define CCFP_MODES (1 << (int) CCFP_MODE)
4045
4046 /* Value is 1 if register/mode pair is acceptable on sparc.
4047    The funny mixture of D and T modes is because integer operations
4048    do not specially operate on tetra quantities, so non-quad-aligned
4049    registers can hold quadword quantities (except %o4 and %i4 because
4050    they cross fixed registers).  */
4051
4052 /* This points to either the 32 bit or the 64 bit version.  */
4053 const int *hard_regno_mode_classes;
4054
4055 static const int hard_32bit_mode_classes[] = {
4056   S_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4057   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4058   T_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4059   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4060
4061   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4062   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4063   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4064   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4065
4066   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
4067      and none can hold SFmode/SImode values.  */
4068   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4069   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4070   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4071   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4072
4073   /* %fcc[0123] */
4074   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4075
4076   /* %icc, %sfp, %gsr */
4077   CC_MODES, 0, D_MODES
4078 };
4079
4080 static const int hard_64bit_mode_classes[] = {
4081   D_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4082   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4083   T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4084   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4085
4086   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4087   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4088   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4089   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4090
4091   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
4092      and none can hold SFmode/SImode values.  */
4093   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4094   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4095   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4096   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4097
4098   /* %fcc[0123] */
4099   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4100
4101   /* %icc, %sfp, %gsr */
4102   CC_MODES, 0, D_MODES
4103 };
4104
4105 int sparc_mode_class [NUM_MACHINE_MODES];
4106
4107 enum reg_class sparc_regno_reg_class[FIRST_PSEUDO_REGISTER];
4108
4109 static void
4110 sparc_init_modes (void)
4111 {
4112   int i;
4113
4114   for (i = 0; i < NUM_MACHINE_MODES; i++)
4115     {
4116       switch (GET_MODE_CLASS (i))
4117         {
4118         case MODE_INT:
4119         case MODE_PARTIAL_INT:
4120         case MODE_COMPLEX_INT:
4121           if (GET_MODE_SIZE (i) <= 4)
4122             sparc_mode_class[i] = 1 << (int) S_MODE;
4123           else if (GET_MODE_SIZE (i) == 8)
4124             sparc_mode_class[i] = 1 << (int) D_MODE;
4125           else if (GET_MODE_SIZE (i) == 16)
4126             sparc_mode_class[i] = 1 << (int) T_MODE;
4127           else if (GET_MODE_SIZE (i) == 32)
4128             sparc_mode_class[i] = 1 << (int) O_MODE;
4129           else
4130             sparc_mode_class[i] = 0;
4131           break;
4132         case MODE_VECTOR_INT:
4133           if (GET_MODE_SIZE (i) <= 4)
4134             sparc_mode_class[i] = 1 << (int)SF_MODE;
4135           else if (GET_MODE_SIZE (i) == 8)
4136             sparc_mode_class[i] = 1 << (int)DF_MODE;
4137           break;
4138         case MODE_FLOAT:
4139         case MODE_COMPLEX_FLOAT:
4140           if (GET_MODE_SIZE (i) <= 4)
4141             sparc_mode_class[i] = 1 << (int) SF_MODE;
4142           else if (GET_MODE_SIZE (i) == 8)
4143             sparc_mode_class[i] = 1 << (int) DF_MODE;
4144           else if (GET_MODE_SIZE (i) == 16)
4145             sparc_mode_class[i] = 1 << (int) TF_MODE;
4146           else if (GET_MODE_SIZE (i) == 32)
4147             sparc_mode_class[i] = 1 << (int) OF_MODE;
4148           else
4149             sparc_mode_class[i] = 0;
4150           break;
4151         case MODE_CC:
4152           if (i == (int) CCFPmode || i == (int) CCFPEmode)
4153             sparc_mode_class[i] = 1 << (int) CCFP_MODE;
4154           else
4155             sparc_mode_class[i] = 1 << (int) CC_MODE;
4156           break;
4157         default:
4158           sparc_mode_class[i] = 0;
4159           break;
4160         }
4161     }
4162
4163   if (TARGET_ARCH64)
4164     hard_regno_mode_classes = hard_64bit_mode_classes;
4165   else
4166     hard_regno_mode_classes = hard_32bit_mode_classes;
4167
4168   /* Initialize the array used by REGNO_REG_CLASS.  */
4169   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4170     {
4171       if (i < 16 && TARGET_V8PLUS)
4172         sparc_regno_reg_class[i] = I64_REGS;
4173       else if (i < 32 || i == FRAME_POINTER_REGNUM)
4174         sparc_regno_reg_class[i] = GENERAL_REGS;
4175       else if (i < 64)
4176         sparc_regno_reg_class[i] = FP_REGS;
4177       else if (i < 96)
4178         sparc_regno_reg_class[i] = EXTRA_FP_REGS;
4179       else if (i < 100)
4180         sparc_regno_reg_class[i] = FPCC_REGS;
4181       else
4182         sparc_regno_reg_class[i] = NO_REGS;
4183     }
4184 }
4185 \f
4186 /* Return whether REGNO, a global or FP register, must be saved/restored.  */
4187
4188 static inline bool
4189 save_global_or_fp_reg_p (unsigned int regno,
4190                          int leaf_function ATTRIBUTE_UNUSED)
4191 {
4192   return !call_used_regs[regno] && df_regs_ever_live_p (regno);
4193 }
4194
4195 /* Return whether the return address register (%i7) is needed.  */
4196
4197 static inline bool
4198 return_addr_reg_needed_p (int leaf_function)
4199 {
4200   /* If it is live, for example because of __builtin_return_address (0).  */
4201   if (df_regs_ever_live_p (RETURN_ADDR_REGNUM))
4202     return true;
4203
4204   /* Otherwise, it is needed as save register if %o7 is clobbered.  */
4205   if (!leaf_function
4206       /* Loading the GOT register clobbers %o7.  */
4207       || crtl->uses_pic_offset_table
4208       || df_regs_ever_live_p (INCOMING_RETURN_ADDR_REGNUM))
4209     return true;
4210
4211   return false;
4212 }
4213
4214 /* Return whether REGNO, a local or in register, must be saved/restored.  */
4215
4216 static bool
4217 save_local_or_in_reg_p (unsigned int regno, int leaf_function)
4218 {
4219   /* General case: call-saved registers live at some point.  */
4220   if (!call_used_regs[regno] && df_regs_ever_live_p (regno))
4221     return true;
4222
4223   /* Frame pointer register (%fp) if needed.  */
4224   if (regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
4225     return true;
4226
4227   /* Return address register (%i7) if needed.  */
4228   if (regno == RETURN_ADDR_REGNUM && return_addr_reg_needed_p (leaf_function))
4229     return true;
4230
4231   /* GOT register (%l7) if needed.  */
4232   if (regno == PIC_OFFSET_TABLE_REGNUM && crtl->uses_pic_offset_table)
4233     return true;
4234
4235   /* If the function accesses prior frames, the frame pointer and the return
4236      address of the previous frame must be saved on the stack.  */
4237   if (crtl->accesses_prior_frames
4238       && (regno == HARD_FRAME_POINTER_REGNUM || regno == RETURN_ADDR_REGNUM))
4239     return true;
4240
4241   return false;
4242 }
4243
4244 /* Compute the frame size required by the function.  This function is called
4245    during the reload pass and also by sparc_expand_prologue.  */
4246
4247 HOST_WIDE_INT
4248 sparc_compute_frame_size (HOST_WIDE_INT size, int leaf_function)
4249 {
4250   HOST_WIDE_INT frame_size, apparent_frame_size;
4251   int args_size, n_global_fp_regs = 0;
4252   bool save_local_in_regs_p = false;
4253   unsigned int i;
4254
4255   /* If the function allocates dynamic stack space, the dynamic offset is
4256      computed early and contains REG_PARM_STACK_SPACE, so we need to cope.  */
4257   if (leaf_function && !cfun->calls_alloca)
4258     args_size = 0;
4259   else
4260     args_size = crtl->outgoing_args_size + REG_PARM_STACK_SPACE (cfun->decl);
4261
4262   /* Calculate space needed for global registers.  */
4263   if (TARGET_ARCH64)
4264     for (i = 0; i < 8; i++)
4265       if (save_global_or_fp_reg_p (i, 0))
4266         n_global_fp_regs += 2;
4267   else
4268     for (i = 0; i < 8; i += 2)
4269       if (save_global_or_fp_reg_p (i, 0) || save_global_or_fp_reg_p (i + 1, 0))
4270         n_global_fp_regs += 2;
4271
4272   /* In the flat window model, find out which local and in registers need to
4273      be saved.  We don't reserve space in the current frame for them as they
4274      will be spilled into the register window save area of the caller's frame.
4275      However, as soon as we use this register window save area, we must create
4276      that of the current frame to make it the live one.  */
4277   if (TARGET_FLAT)
4278     for (i = 16; i < 32; i++)
4279       if (save_local_or_in_reg_p (i, leaf_function))
4280         {
4281          save_local_in_regs_p = true;
4282          break;
4283         }
4284
4285   /* Calculate space needed for FP registers.  */
4286   for (i = 32; i < (TARGET_V9 ? 96 : 64); i += 2)
4287     if (save_global_or_fp_reg_p (i, 0) || save_global_or_fp_reg_p (i + 1, 0))
4288       n_global_fp_regs += 2;
4289
4290   if (size == 0
4291       && n_global_fp_regs == 0
4292       && args_size == 0
4293       && !save_local_in_regs_p)
4294     frame_size = apparent_frame_size = 0;
4295   else
4296     {
4297       /* We subtract STARTING_FRAME_OFFSET, remember it's negative.  */
4298       apparent_frame_size = (size - STARTING_FRAME_OFFSET + 7) & -8;
4299       apparent_frame_size += n_global_fp_regs * 4;
4300
4301       /* We need to add the size of the outgoing argument area.  */
4302       frame_size = apparent_frame_size + ((args_size + 7) & -8);
4303
4304       /* And that of the register window save area.  */
4305       frame_size += FIRST_PARM_OFFSET (cfun->decl);
4306
4307       /* Finally, bump to the appropriate alignment.  */
4308       frame_size = SPARC_STACK_ALIGN (frame_size);
4309     }
4310
4311   /* Set up values for use in prologue and epilogue.  */
4312   sparc_frame_size = frame_size;
4313   sparc_apparent_frame_size = apparent_frame_size;
4314   sparc_n_global_fp_regs = n_global_fp_regs;
4315   sparc_save_local_in_regs_p = save_local_in_regs_p;
4316
4317   return frame_size;
4318 }
4319
4320 /* Output any necessary .register pseudo-ops.  */
4321
4322 void
4323 sparc_output_scratch_registers (FILE *file ATTRIBUTE_UNUSED)
4324 {
4325 #ifdef HAVE_AS_REGISTER_PSEUDO_OP
4326   int i;
4327
4328   if (TARGET_ARCH32)
4329     return;
4330
4331   /* Check if %g[2367] were used without
4332      .register being printed for them already.  */
4333   for (i = 2; i < 8; i++)
4334     {
4335       if (df_regs_ever_live_p (i)
4336           && ! sparc_hard_reg_printed [i])
4337         {
4338           sparc_hard_reg_printed [i] = 1;
4339           /* %g7 is used as TLS base register, use #ignore
4340              for it instead of #scratch.  */
4341           fprintf (file, "\t.register\t%%g%d, #%s\n", i,
4342                    i == 7 ? "ignore" : "scratch");
4343         }
4344       if (i == 3) i = 5;
4345     }
4346 #endif
4347 }
4348
4349 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
4350
4351 #if PROBE_INTERVAL > 4096
4352 #error Cannot use indexed addressing mode for stack probing
4353 #endif
4354
4355 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
4356    inclusive.  These are offsets from the current stack pointer.
4357
4358    Note that we don't use the REG+REG addressing mode for the probes because
4359    of the stack bias in 64-bit mode.  And it doesn't really buy us anything
4360    so the advantages of having a single code win here.  */
4361
4362 static void
4363 sparc_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
4364 {
4365   rtx g1 = gen_rtx_REG (Pmode, 1);
4366
4367   /* See if we have a constant small number of probes to generate.  If so,
4368      that's the easy case.  */
4369   if (size <= PROBE_INTERVAL)
4370     {
4371       emit_move_insn (g1, GEN_INT (first));
4372       emit_insn (gen_rtx_SET (VOIDmode, g1,
4373                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4374       emit_stack_probe (plus_constant (g1, -size));
4375     }
4376
4377   /* The run-time loop is made up of 10 insns in the generic case while the
4378      compile-time loop is made up of 4+2*(n-2) insns for n # of intervals.  */
4379   else if (size <= 5 * PROBE_INTERVAL)
4380     {
4381       HOST_WIDE_INT i;
4382
4383       emit_move_insn (g1, GEN_INT (first + PROBE_INTERVAL));
4384       emit_insn (gen_rtx_SET (VOIDmode, g1,
4385                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4386       emit_stack_probe (g1);
4387
4388       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 2 until
4389          it exceeds SIZE.  If only two probes are needed, this will not
4390          generate any code.  Then probe at FIRST + SIZE.  */
4391       for (i = 2 * PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
4392         {
4393           emit_insn (gen_rtx_SET (VOIDmode, g1,
4394                                   plus_constant (g1, -PROBE_INTERVAL)));
4395           emit_stack_probe (g1);
4396         }
4397
4398       emit_stack_probe (plus_constant (g1, (i - PROBE_INTERVAL) - size));
4399     }
4400
4401   /* Otherwise, do the same as above, but in a loop.  Note that we must be
4402      extra careful with variables wrapping around because we might be at
4403      the very top (or the very bottom) of the address space and we have
4404      to be able to handle this case properly; in particular, we use an
4405      equality test for the loop condition.  */
4406   else
4407     {
4408       HOST_WIDE_INT rounded_size;
4409       rtx g4 = gen_rtx_REG (Pmode, 4);
4410
4411       emit_move_insn (g1, GEN_INT (first));
4412
4413
4414       /* Step 1: round SIZE to the previous multiple of the interval.  */
4415
4416       rounded_size = size & -PROBE_INTERVAL;
4417       emit_move_insn (g4, GEN_INT (rounded_size));
4418
4419
4420       /* Step 2: compute initial and final value of the loop counter.  */
4421
4422       /* TEST_ADDR = SP + FIRST.  */
4423       emit_insn (gen_rtx_SET (VOIDmode, g1,
4424                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4425
4426       /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE.  */
4427       emit_insn (gen_rtx_SET (VOIDmode, g4, gen_rtx_MINUS (Pmode, g1, g4)));
4428
4429
4430       /* Step 3: the loop
4431
4432          while (TEST_ADDR != LAST_ADDR)
4433            {
4434              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
4435              probe at TEST_ADDR
4436            }
4437
4438          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
4439          until it is equal to ROUNDED_SIZE.  */
4440
4441       if (TARGET_64BIT)
4442         emit_insn (gen_probe_stack_rangedi (g1, g1, g4));
4443       else
4444         emit_insn (gen_probe_stack_rangesi (g1, g1, g4));
4445
4446
4447       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
4448          that SIZE is equal to ROUNDED_SIZE.  */
4449
4450       if (size != rounded_size)
4451         emit_stack_probe (plus_constant (g4, rounded_size - size));
4452     }
4453
4454   /* Make sure nothing is scheduled before we are done.  */
4455   emit_insn (gen_blockage ());
4456 }
4457
4458 /* Probe a range of stack addresses from REG1 to REG2 inclusive.  These are
4459    absolute addresses.  */
4460
4461 const char *
4462 output_probe_stack_range (rtx reg1, rtx reg2)
4463 {
4464   static int labelno = 0;
4465   char loop_lab[32], end_lab[32];
4466   rtx xops[2];
4467
4468   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
4469   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
4470
4471   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
4472
4473    /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
4474   xops[0] = reg1;
4475   xops[1] = reg2;
4476   output_asm_insn ("cmp\t%0, %1", xops);
4477   if (TARGET_ARCH64)
4478     fputs ("\tbe,pn\t%xcc,", asm_out_file);
4479   else
4480     fputs ("\tbe\t", asm_out_file);
4481   assemble_name_raw (asm_out_file, end_lab);
4482   fputc ('\n', asm_out_file);
4483
4484   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
4485   xops[1] = GEN_INT (-PROBE_INTERVAL);
4486   output_asm_insn (" add\t%0, %1, %0", xops);
4487
4488   /* Probe at TEST_ADDR and branch.  */
4489   if (TARGET_ARCH64)
4490     fputs ("\tba,pt\t%xcc,", asm_out_file);
4491   else
4492     fputs ("\tba\t", asm_out_file);
4493   assemble_name_raw (asm_out_file, loop_lab);
4494   fputc ('\n', asm_out_file);
4495   xops[1] = GEN_INT (SPARC_STACK_BIAS);
4496   output_asm_insn (" st\t%%g0, [%0+%1]", xops);
4497
4498   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
4499
4500   return "";
4501 }
4502
4503 /* Emit code to save/restore registers from LOW to HIGH at BASE+OFFSET as
4504    needed.  LOW is supposed to be double-word aligned for 32-bit registers.
4505    SAVE_P decides whether a register must be saved/restored.  ACTION_TRUE
4506    is the action to be performed if SAVE_P returns true and ACTION_FALSE
4507    the action to be performed if it returns false.  Return the new offset.  */
4508
4509 typedef bool (*sorr_pred_t) (unsigned int, int);
4510 typedef enum { SORR_NONE, SORR_ADVANCE, SORR_SAVE, SORR_RESTORE } sorr_act_t;
4511
4512 static int
4513 emit_save_or_restore_regs (unsigned int low, unsigned int high, rtx base,
4514                            int offset, int leaf_function, sorr_pred_t save_p,
4515                            sorr_act_t action_true, sorr_act_t action_false)
4516 {
4517   unsigned int i;
4518   rtx mem, insn;
4519
4520   if (TARGET_ARCH64 && high <= 32)
4521     {
4522       int fp_offset = -1;
4523
4524       for (i = low; i < high; i++)
4525         {
4526           if (save_p (i, leaf_function))
4527             {
4528               mem = gen_frame_mem (DImode, plus_constant (base, offset));
4529               if (action_true == SORR_SAVE)
4530                 {
4531                   insn = emit_move_insn (mem, gen_rtx_REG (DImode, i));
4532                   RTX_FRAME_RELATED_P (insn) = 1;
4533                 }
4534               else  /* action_true == SORR_RESTORE */
4535                 {
4536                   /* The frame pointer must be restored last since its old
4537                      value may be used as base address for the frame.  This
4538                      is problematic in 64-bit mode only because of the lack
4539                      of double-word load instruction.  */
4540                   if (i == HARD_FRAME_POINTER_REGNUM)
4541                     fp_offset = offset;
4542                   else
4543                     emit_move_insn (gen_rtx_REG (DImode, i), mem);
4544                 }
4545               offset += 8;
4546             }
4547           else if (action_false == SORR_ADVANCE)
4548             offset += 8;
4549         }
4550
4551       if (fp_offset >= 0)
4552         {
4553           mem = gen_frame_mem (DImode, plus_constant (base, fp_offset));
4554           emit_move_insn (hard_frame_pointer_rtx, mem);
4555         }
4556     }
4557   else
4558     {
4559       for (i = low; i < high; i += 2)
4560         {
4561           bool reg0 = save_p (i, leaf_function);
4562           bool reg1 = save_p (i + 1, leaf_function);
4563           enum machine_mode mode;
4564           int regno;
4565
4566           if (reg0 && reg1)
4567             {
4568               mode = i < 32 ? DImode : DFmode;
4569               regno = i;
4570             }
4571           else if (reg0)
4572             {
4573               mode = i < 32 ? SImode : SFmode;
4574               regno = i;
4575             }
4576           else if (reg1)
4577             {
4578               mode = i < 32 ? SImode : SFmode;
4579               regno = i + 1;
4580               offset += 4;
4581             }
4582           else
4583             {
4584               if (action_false == SORR_ADVANCE)
4585                 offset += 8;
4586               continue;
4587             }
4588
4589           mem = gen_frame_mem (mode, plus_constant (base, offset));
4590           if (action_true == SORR_SAVE)
4591             {
4592               insn = emit_move_insn (mem, gen_rtx_REG (mode, regno));
4593               RTX_FRAME_RELATED_P (insn) = 1;
4594               if (mode == DImode)
4595                 {
4596                   rtx set1, set2;
4597                   mem = gen_frame_mem (SImode, plus_constant (base, offset));
4598                   set1 = gen_rtx_SET (VOIDmode, mem,
4599                                       gen_rtx_REG (SImode, regno));
4600                   RTX_FRAME_RELATED_P (set1) = 1;
4601                   mem
4602                     = gen_frame_mem (SImode, plus_constant (base, offset + 4));
4603                   set2 = gen_rtx_SET (VOIDmode, mem,
4604                                       gen_rtx_REG (SImode, regno + 1));
4605                   RTX_FRAME_RELATED_P (set2) = 1;
4606                   add_reg_note (insn, REG_FRAME_RELATED_EXPR,
4607                                 gen_rtx_PARALLEL (VOIDmode,
4608                                                   gen_rtvec (2, set1, set2)));
4609                 }
4610             }
4611           else  /* action_true == SORR_RESTORE */
4612             emit_move_insn (gen_rtx_REG (mode, regno), mem);
4613
4614           /* Always preserve double-word alignment.  */
4615           offset = (offset + 8) & -8;
4616         }
4617     }
4618
4619   return offset;
4620 }
4621
4622 /* Emit code to adjust BASE to OFFSET.  Return the new base.  */
4623
4624 static rtx
4625 emit_adjust_base_to_offset (rtx base, int offset)
4626 {
4627   /* ??? This might be optimized a little as %g1 might already have a
4628      value close enough that a single add insn will do.  */
4629   /* ??? Although, all of this is probably only a temporary fix because
4630      if %g1 can hold a function result, then sparc_expand_epilogue will
4631      lose (the result will be clobbered).  */
4632   rtx new_base = gen_rtx_REG (Pmode, 1);
4633   emit_move_insn (new_base, GEN_INT (offset));
4634   emit_insn (gen_rtx_SET (VOIDmode,
4635                           new_base, gen_rtx_PLUS (Pmode, base, new_base)));
4636   return new_base;
4637 }
4638
4639 /* Emit code to save/restore call-saved global and FP registers.  */
4640
4641 static void
4642 emit_save_or_restore_global_fp_regs (rtx base, int offset, sorr_act_t action)
4643 {
4644   if (offset < -4096 || offset + sparc_n_global_fp_regs * 4 > 4095)
4645     {
4646       base = emit_adjust_base_to_offset  (base, offset);
4647       offset = 0;
4648     }
4649
4650   offset
4651     = emit_save_or_restore_regs (0, 8, base, offset, 0,
4652                                  save_global_or_fp_reg_p, action, SORR_NONE);
4653   emit_save_or_restore_regs (32, TARGET_V9 ? 96 : 64, base, offset, 0,
4654                              save_global_or_fp_reg_p, action, SORR_NONE);
4655 }
4656
4657 /* Emit code to save/restore call-saved local and in registers.  */
4658
4659 static void
4660 emit_save_or_restore_local_in_regs (rtx base, int offset, sorr_act_t action)
4661 {
4662   if (offset < -4096 || offset + 16 * UNITS_PER_WORD > 4095)
4663     {
4664       base = emit_adjust_base_to_offset  (base, offset);
4665       offset = 0;
4666     }
4667
4668   emit_save_or_restore_regs (16, 32, base, offset, sparc_leaf_function_p,
4669                              save_local_or_in_reg_p, action, SORR_ADVANCE);
4670 }
4671
4672 /* Emit a window_save insn.  */
4673
4674 static rtx
4675 emit_window_save (rtx increment)
4676 {
4677   rtx insn = emit_insn (gen_window_save (increment));
4678   RTX_FRAME_RELATED_P (insn) = 1;
4679
4680   /* The incoming return address (%o7) is saved in %i7.  */
4681   add_reg_note (insn, REG_CFA_REGISTER,
4682                 gen_rtx_SET (VOIDmode,
4683                              gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM),
4684                              gen_rtx_REG (Pmode,
4685                                           INCOMING_RETURN_ADDR_REGNUM)));
4686
4687   /* The window save event.  */
4688   add_reg_note (insn, REG_CFA_WINDOW_SAVE, const0_rtx);
4689
4690   /* The CFA is %fp, the hard frame pointer.  */
4691   add_reg_note (insn, REG_CFA_DEF_CFA,
4692                 plus_constant (hard_frame_pointer_rtx,
4693                                INCOMING_FRAME_SP_OFFSET));
4694
4695   return insn;
4696 }
4697
4698 /* Generate an increment for the stack pointer.  */
4699
4700 static rtx
4701 gen_stack_pointer_inc (rtx increment)
4702 {
4703   return gen_rtx_SET (VOIDmode,
4704                       stack_pointer_rtx,
4705                       gen_rtx_PLUS (Pmode,
4706                                     stack_pointer_rtx,
4707                                     increment));
4708 }
4709
4710 /* Generate a decrement for the stack pointer.  */
4711
4712 static rtx
4713 gen_stack_pointer_dec (rtx decrement)
4714 {
4715   return gen_rtx_SET (VOIDmode,
4716                       stack_pointer_rtx,
4717                       gen_rtx_MINUS (Pmode,
4718                                      stack_pointer_rtx,
4719                                      decrement));
4720 }
4721
4722 /* Expand the function prologue.  The prologue is responsible for reserving
4723    storage for the frame, saving the call-saved registers and loading the
4724    GOT register if needed.  */
4725
4726 void
4727 sparc_expand_prologue (void)
4728 {
4729   HOST_WIDE_INT size;
4730   rtx insn;
4731
4732   /* Compute a snapshot of current_function_uses_only_leaf_regs.  Relying
4733      on the final value of the flag means deferring the prologue/epilogue
4734      expansion until just before the second scheduling pass, which is too
4735      late to emit multiple epilogues or return insns.
4736
4737      Of course we are making the assumption that the value of the flag
4738      will not change between now and its final value.  Of the three parts
4739      of the formula, only the last one can reasonably vary.  Let's take a
4740      closer look, after assuming that the first two ones are set to true
4741      (otherwise the last value is effectively silenced).
4742
4743      If only_leaf_regs_used returns false, the global predicate will also
4744      be false so the actual frame size calculated below will be positive.
4745      As a consequence, the save_register_window insn will be emitted in
4746      the instruction stream; now this insn explicitly references %fp
4747      which is not a leaf register so only_leaf_regs_used will always
4748      return false subsequently.
4749
4750      If only_leaf_regs_used returns true, we hope that the subsequent
4751      optimization passes won't cause non-leaf registers to pop up.  For
4752      example, the regrename pass has special provisions to not rename to
4753      non-leaf registers in a leaf function.  */
4754   sparc_leaf_function_p
4755     = optimize > 0 && current_function_is_leaf && only_leaf_regs_used ();
4756
4757   size = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
4758
4759   if (flag_stack_usage_info)
4760     current_function_static_stack_size = size;
4761
4762   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && size)
4763     sparc_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
4764
4765   if (size == 0)
4766     ; /* do nothing.  */
4767   else if (sparc_leaf_function_p)
4768     {
4769       rtx size_int_rtx = GEN_INT (-size);
4770
4771       if (size <= 4096)
4772         insn = emit_insn (gen_stack_pointer_inc (size_int_rtx));
4773       else if (size <= 8192)
4774         {
4775           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
4776           /* %sp is still the CFA register.  */
4777           RTX_FRAME_RELATED_P (insn) = 1;
4778           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
4779         }
4780       else
4781         {
4782           rtx size_rtx = gen_rtx_REG (Pmode, 1);
4783           emit_move_insn (size_rtx, size_int_rtx);
4784           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
4785           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
4786                         gen_stack_pointer_inc (size_int_rtx));
4787         }
4788
4789       RTX_FRAME_RELATED_P (insn) = 1;
4790     }
4791   else
4792     {
4793       rtx size_int_rtx = GEN_INT (-size);
4794
4795       if (size <= 4096)
4796         emit_window_save (size_int_rtx);
4797       else if (size <= 8192)
4798         {
4799           emit_window_save (GEN_INT (-4096));
4800           /* %sp is not the CFA register anymore.  */
4801           emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
4802         }
4803       else
4804         {
4805           rtx size_rtx = gen_rtx_REG (Pmode, 1);
4806           emit_move_insn (size_rtx, size_int_rtx);
4807           emit_window_save (size_rtx);
4808         }
4809     }
4810
4811   if (sparc_leaf_function_p)
4812     {
4813       sparc_frame_base_reg = stack_pointer_rtx;
4814       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
4815     }
4816   else
4817     {
4818       sparc_frame_base_reg = hard_frame_pointer_rtx;
4819       sparc_frame_base_offset = SPARC_STACK_BIAS;
4820     }
4821
4822   if (sparc_n_global_fp_regs > 0)
4823     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
4824                                          sparc_frame_base_offset
4825                                            - sparc_apparent_frame_size,
4826                                          SORR_SAVE);
4827
4828   /* Load the GOT register if needed.  */
4829   if (crtl->uses_pic_offset_table)
4830     load_got_register ();
4831
4832   /* Advertise that the data calculated just above are now valid.  */
4833   sparc_prologue_data_valid_p = true;
4834 }
4835
4836 /* Expand the function prologue.  The prologue is responsible for reserving
4837    storage for the frame, saving the call-saved registers and loading the
4838    GOT register if needed.  */
4839
4840 void
4841 sparc_flat_expand_prologue (void)
4842 {
4843   HOST_WIDE_INT size;
4844   rtx insn;
4845
4846   sparc_leaf_function_p = optimize > 0 && current_function_is_leaf;
4847
4848   size = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
4849
4850   if (flag_stack_usage_info)
4851     current_function_static_stack_size = size;
4852
4853   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && size)
4854     sparc_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
4855
4856   if (sparc_save_local_in_regs_p)
4857     emit_save_or_restore_local_in_regs (stack_pointer_rtx, SPARC_STACK_BIAS,
4858                                         SORR_SAVE);
4859
4860   if (size == 0)
4861     ; /* do nothing.  */
4862   else
4863     {
4864       rtx size_int_rtx, size_rtx;
4865
4866       size_rtx = size_int_rtx = GEN_INT (-size);
4867
4868       /* We establish the frame (i.e. decrement the stack pointer) first, even
4869          if we use a frame pointer, because we cannot clobber any call-saved
4870          registers, including the frame pointer, if we haven't created a new
4871          register save area, for the sake of compatibility with the ABI.  */
4872       if (size <= 4096)
4873         insn = emit_insn (gen_stack_pointer_inc (size_int_rtx));
4874       else if (size <= 8192 && !frame_pointer_needed)
4875         {
4876           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
4877           RTX_FRAME_RELATED_P (insn) = 1;
4878           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
4879         }
4880       else
4881         {
4882           size_rtx = gen_rtx_REG (Pmode, 1);
4883           emit_move_insn (size_rtx, size_int_rtx);
4884           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
4885           add_reg_note (insn, REG_CFA_ADJUST_CFA,
4886                         gen_stack_pointer_inc (size_int_rtx));
4887         }
4888       RTX_FRAME_RELATED_P (insn) = 1;
4889
4890       /* Ensure nothing is scheduled until after the frame is established.  */
4891       emit_insn (gen_blockage ());
4892
4893       if (frame_pointer_needed)
4894         {
4895           insn = emit_insn (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
4896                                          gen_rtx_MINUS (Pmode,
4897                                                         stack_pointer_rtx,
4898                                                         size_rtx)));
4899           RTX_FRAME_RELATED_P (insn) = 1;
4900
4901           add_reg_note (insn, REG_CFA_ADJUST_CFA,
4902                         gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
4903                                      plus_constant (stack_pointer_rtx,
4904                                                     size)));
4905         }
4906
4907       if (return_addr_reg_needed_p (sparc_leaf_function_p))
4908         {
4909           rtx o7 = gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM);
4910           rtx i7 = gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM);
4911
4912           insn = emit_move_insn (i7, o7);
4913           RTX_FRAME_RELATED_P (insn) = 1;
4914
4915           add_reg_note (insn, REG_CFA_REGISTER,
4916                         gen_rtx_SET (VOIDmode, i7, o7));
4917
4918           /* Prevent this instruction from ever being considered dead,
4919              even if this function has no epilogue.  */
4920           emit_insn (gen_rtx_USE (VOIDmode, i7));
4921         }
4922     }
4923
4924   if (frame_pointer_needed)
4925     {
4926       sparc_frame_base_reg = hard_frame_pointer_rtx;
4927       sparc_frame_base_offset = SPARC_STACK_BIAS;
4928     }
4929   else
4930     {
4931       sparc_frame_base_reg = stack_pointer_rtx;
4932       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
4933     }
4934
4935   if (sparc_n_global_fp_regs > 0)
4936     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
4937                                          sparc_frame_base_offset
4938                                            - sparc_apparent_frame_size,
4939                                          SORR_SAVE);
4940
4941   /* Load the GOT register if needed.  */
4942   if (crtl->uses_pic_offset_table)
4943     load_got_register ();
4944
4945   /* Advertise that the data calculated just above are now valid.  */
4946   sparc_prologue_data_valid_p = true;
4947 }
4948
4949 /* This function generates the assembly code for function entry, which boils
4950    down to emitting the necessary .register directives.  */
4951
4952 static void
4953 sparc_asm_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
4954 {
4955   /* Check that the assumption we made in sparc_expand_prologue is valid.  */
4956   if (!TARGET_FLAT)
4957     gcc_assert (sparc_leaf_function_p == current_function_uses_only_leaf_regs);
4958
4959   sparc_output_scratch_registers (file);
4960 }
4961
4962 /* Expand the function epilogue, either normal or part of a sibcall.
4963    We emit all the instructions except the return or the call.  */
4964
4965 void
4966 sparc_expand_epilogue (bool for_eh)
4967 {
4968   HOST_WIDE_INT size = sparc_frame_size;
4969
4970   if (sparc_n_global_fp_regs > 0)
4971     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
4972                                          sparc_frame_base_offset
4973                                            - sparc_apparent_frame_size,
4974                                          SORR_RESTORE);
4975
4976   if (size == 0 || for_eh)
4977     ; /* do nothing.  */
4978   else if (sparc_leaf_function_p)
4979     {
4980       if (size <= 4096)
4981         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
4982       else if (size <= 8192)
4983         {
4984           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
4985           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
4986         }
4987       else
4988         {
4989           rtx reg = gen_rtx_REG (Pmode, 1);
4990           emit_move_insn (reg, GEN_INT (-size));
4991           emit_insn (gen_stack_pointer_dec (reg));
4992         }
4993     }
4994 }
4995
4996 /* Expand the function epilogue, either normal or part of a sibcall.
4997    We emit all the instructions except the return or the call.  */
4998
4999 void
5000 sparc_flat_expand_epilogue (bool for_eh)
5001 {
5002   HOST_WIDE_INT size = sparc_frame_size;
5003
5004   if (sparc_n_global_fp_regs > 0)
5005     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5006                                          sparc_frame_base_offset
5007                                            - sparc_apparent_frame_size,
5008                                          SORR_RESTORE);
5009
5010   /* If we have a frame pointer, we'll need both to restore it before the
5011      frame is destroyed and use its current value in destroying the frame.
5012      Since we don't have an atomic way to do that in the flat window model,
5013      we save the current value into a temporary register (%g1).  */
5014   if (frame_pointer_needed && !for_eh)
5015     emit_move_insn (gen_rtx_REG (Pmode, 1), hard_frame_pointer_rtx);
5016
5017   if (return_addr_reg_needed_p (sparc_leaf_function_p))
5018     emit_move_insn (gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM),
5019                     gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM));
5020
5021   if (sparc_save_local_in_regs_p)
5022     emit_save_or_restore_local_in_regs (sparc_frame_base_reg,
5023                                         sparc_frame_base_offset,
5024                                         SORR_RESTORE);
5025
5026   if (size == 0 || for_eh)
5027     ; /* do nothing.  */
5028   else if (frame_pointer_needed)
5029     {
5030       /* Make sure the frame is destroyed after everything else is done.  */
5031       emit_insn (gen_blockage ());
5032
5033       emit_move_insn (stack_pointer_rtx, gen_rtx_REG (Pmode, 1));
5034     }
5035   else
5036     {
5037       /* Likewise.  */
5038       emit_insn (gen_blockage ());
5039
5040       if (size <= 4096)
5041         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
5042       else if (size <= 8192)
5043         {
5044           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
5045           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
5046         }
5047       else
5048         {
5049           rtx reg = gen_rtx_REG (Pmode, 1);
5050           emit_move_insn (reg, GEN_INT (-size));
5051           emit_insn (gen_stack_pointer_dec (reg));
5052         }
5053     }
5054 }
5055
5056 /* Return true if it is appropriate to emit `return' instructions in the
5057    body of a function.  */
5058
5059 bool
5060 sparc_can_use_return_insn_p (void)
5061 {
5062   return sparc_prologue_data_valid_p
5063          && sparc_n_global_fp_regs == 0
5064          && TARGET_FLAT
5065             ? (sparc_frame_size == 0 && !sparc_save_local_in_regs_p)
5066             : (sparc_frame_size == 0 || !sparc_leaf_function_p);
5067 }
5068
5069 /* This function generates the assembly code for function exit.  */
5070
5071 static void
5072 sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
5073 {
5074   /* If the last two instructions of a function are "call foo; dslot;"
5075      the return address might point to the first instruction in the next
5076      function and we have to output a dummy nop for the sake of sane
5077      backtraces in such cases.  This is pointless for sibling calls since
5078      the return address is explicitly adjusted.  */
5079
5080   rtx insn, last_real_insn;
5081
5082   insn = get_last_insn ();
5083
5084   last_real_insn = prev_real_insn (insn);
5085   if (last_real_insn
5086       && GET_CODE (last_real_insn) == INSN
5087       && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE)
5088     last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0);
5089
5090   if (last_real_insn
5091       && CALL_P (last_real_insn)
5092       && !SIBLING_CALL_P (last_real_insn))
5093     fputs("\tnop\n", file);
5094
5095   sparc_output_deferred_case_vectors ();
5096 }
5097
5098 /* Output a 'restore' instruction.  */
5099
5100 static void
5101 output_restore (rtx pat)
5102 {
5103   rtx operands[3];
5104
5105   if (! pat)
5106     {
5107       fputs ("\t restore\n", asm_out_file);
5108       return;
5109     }
5110
5111   gcc_assert (GET_CODE (pat) == SET);
5112
5113   operands[0] = SET_DEST (pat);
5114   pat = SET_SRC (pat);
5115
5116   switch (GET_CODE (pat))
5117     {
5118       case PLUS:
5119         operands[1] = XEXP (pat, 0);
5120         operands[2] = XEXP (pat, 1);
5121         output_asm_insn (" restore %r1, %2, %Y0", operands);
5122         break;
5123       case LO_SUM:
5124         operands[1] = XEXP (pat, 0);
5125         operands[2] = XEXP (pat, 1);
5126         output_asm_insn (" restore %r1, %%lo(%a2), %Y0", operands);
5127         break;
5128       case ASHIFT:
5129         operands[1] = XEXP (pat, 0);
5130         gcc_assert (XEXP (pat, 1) == const1_rtx);
5131         output_asm_insn (" restore %r1, %r1, %Y0", operands);
5132         break;
5133       default:
5134         operands[1] = pat;
5135         output_asm_insn (" restore %%g0, %1, %Y0", operands);
5136         break;
5137     }
5138 }
5139
5140 /* Output a return.  */
5141
5142 const char *
5143 output_return (rtx insn)
5144 {
5145   if (crtl->calls_eh_return)
5146     {
5147       /* If the function uses __builtin_eh_return, the eh_return
5148          machinery occupies the delay slot.  */
5149       gcc_assert (!final_sequence);
5150
5151       if (flag_delayed_branch)
5152         {
5153           if (!TARGET_FLAT && TARGET_V9)
5154             fputs ("\treturn\t%i7+8\n", asm_out_file);
5155           else
5156             {
5157               if (!TARGET_FLAT)
5158                 fputs ("\trestore\n", asm_out_file);
5159
5160               fputs ("\tjmp\t%o7+8\n", asm_out_file);
5161             }
5162
5163           fputs ("\t add\t%sp, %g1, %sp\n", asm_out_file);
5164         }
5165       else
5166         {
5167           if (!TARGET_FLAT)
5168             fputs ("\trestore\n", asm_out_file);
5169
5170           fputs ("\tadd\t%sp, %g1, %sp\n", asm_out_file);
5171           fputs ("\tjmp\t%o7+8\n\t nop\n", asm_out_file);
5172         }
5173     }
5174   else if (sparc_leaf_function_p || TARGET_FLAT)
5175     {
5176       /* This is a leaf or flat function so we don't have to bother restoring
5177          the register window, which frees us from dealing with the convoluted
5178          semantics of restore/return.  We simply output the jump to the
5179          return address and the insn in the delay slot (if any).  */
5180
5181       return "jmp\t%%o7+%)%#";
5182     }
5183   else
5184     {
5185       /* This is a regular function so we have to restore the register window.
5186          We may have a pending insn for the delay slot, which will be either
5187          combined with the 'restore' instruction or put in the delay slot of
5188          the 'return' instruction.  */
5189
5190       if (final_sequence)
5191         {
5192           rtx delay, pat;
5193
5194           delay = NEXT_INSN (insn);
5195           gcc_assert (delay);
5196
5197           pat = PATTERN (delay);
5198
5199           if (TARGET_V9 && ! epilogue_renumber (&pat, 1))
5200             {
5201               epilogue_renumber (&pat, 0);
5202               return "return\t%%i7+%)%#";
5203             }
5204           else
5205             {
5206               output_asm_insn ("jmp\t%%i7+%)", NULL);
5207               output_restore (pat);
5208               PATTERN (delay) = gen_blockage ();
5209               INSN_CODE (delay) = -1;
5210             }
5211         }
5212       else
5213         {
5214           /* The delay slot is empty.  */
5215           if (TARGET_V9)
5216             return "return\t%%i7+%)\n\t nop";
5217           else if (flag_delayed_branch)
5218             return "jmp\t%%i7+%)\n\t restore";
5219           else
5220             return "restore\n\tjmp\t%%o7+%)\n\t nop";
5221         }
5222     }
5223
5224   return "";
5225 }
5226
5227 /* Output a sibling call.  */
5228
5229 const char *
5230 output_sibcall (rtx insn, rtx call_operand)
5231 {
5232   rtx operands[1];
5233
5234   gcc_assert (flag_delayed_branch);
5235
5236   operands[0] = call_operand;
5237
5238   if (sparc_leaf_function_p || TARGET_FLAT)
5239     {
5240       /* This is a leaf or flat function so we don't have to bother restoring
5241          the register window.  We simply output the jump to the function and
5242          the insn in the delay slot (if any).  */
5243
5244       gcc_assert (!(LEAF_SIBCALL_SLOT_RESERVED_P && final_sequence));
5245
5246       if (final_sequence)
5247         output_asm_insn ("sethi\t%%hi(%a0), %%g1\n\tjmp\t%%g1 + %%lo(%a0)%#",
5248                          operands);
5249       else
5250         /* Use or with rs2 %%g0 instead of mov, so that as/ld can optimize
5251            it into branch if possible.  */
5252         output_asm_insn ("or\t%%o7, %%g0, %%g1\n\tcall\t%a0, 0\n\t or\t%%g1, %%g0, %%o7",
5253                          operands);
5254     }
5255   else
5256     {
5257       /* This is a regular function so we have to restore the register window.
5258          We may have a pending insn for the delay slot, which will be combined
5259          with the 'restore' instruction.  */
5260
5261       output_asm_insn ("call\t%a0, 0", operands);
5262
5263       if (final_sequence)
5264         {
5265           rtx delay = NEXT_INSN (insn);
5266           gcc_assert (delay);
5267
5268           output_restore (PATTERN (delay));
5269
5270           PATTERN (delay) = gen_blockage ();
5271           INSN_CODE (delay) = -1;
5272         }
5273       else
5274         output_restore (NULL_RTX);
5275     }
5276
5277   return "";
5278 }
5279 \f
5280 /* Functions for handling argument passing.
5281
5282    For 32-bit, the first 6 args are normally in registers and the rest are
5283    pushed.  Any arg that starts within the first 6 words is at least
5284    partially passed in a register unless its data type forbids.
5285
5286    For 64-bit, the argument registers are laid out as an array of 16 elements
5287    and arguments are added sequentially.  The first 6 int args and up to the
5288    first 16 fp args (depending on size) are passed in regs.
5289
5290    Slot    Stack   Integral   Float   Float in structure   Double   Long Double
5291    ----    -----   --------   -----   ------------------   ------   -----------
5292     15   [SP+248]              %f31       %f30,%f31         %d30
5293     14   [SP+240]              %f29       %f28,%f29         %d28       %q28
5294     13   [SP+232]              %f27       %f26,%f27         %d26
5295     12   [SP+224]              %f25       %f24,%f25         %d24       %q24
5296     11   [SP+216]              %f23       %f22,%f23         %d22
5297     10   [SP+208]              %f21       %f20,%f21         %d20       %q20
5298      9   [SP+200]              %f19       %f18,%f19         %d18
5299      8   [SP+192]              %f17       %f16,%f17         %d16       %q16
5300      7   [SP+184]              %f15       %f14,%f15         %d14
5301      6   [SP+176]              %f13       %f12,%f13         %d12       %q12
5302      5   [SP+168]     %o5      %f11       %f10,%f11         %d10
5303      4   [SP+160]     %o4       %f9        %f8,%f9           %d8        %q8
5304      3   [SP+152]     %o3       %f7        %f6,%f7           %d6
5305      2   [SP+144]     %o2       %f5        %f4,%f5           %d4        %q4
5306      1   [SP+136]     %o1       %f3        %f2,%f3           %d2
5307      0   [SP+128]     %o0       %f1        %f0,%f1           %d0        %q0
5308
5309    Here SP = %sp if -mno-stack-bias or %sp+stack_bias otherwise.
5310
5311    Integral arguments are always passed as 64-bit quantities appropriately
5312    extended.
5313
5314    Passing of floating point values is handled as follows.
5315    If a prototype is in scope:
5316      If the value is in a named argument (i.e. not a stdarg function or a
5317      value not part of the `...') then the value is passed in the appropriate
5318      fp reg.
5319      If the value is part of the `...' and is passed in one of the first 6
5320      slots then the value is passed in the appropriate int reg.
5321      If the value is part of the `...' and is not passed in one of the first 6
5322      slots then the value is passed in memory.
5323    If a prototype is not in scope:
5324      If the value is one of the first 6 arguments the value is passed in the
5325      appropriate integer reg and the appropriate fp reg.
5326      If the value is not one of the first 6 arguments the value is passed in
5327      the appropriate fp reg and in memory.
5328
5329
5330    Summary of the calling conventions implemented by GCC on the SPARC:
5331
5332    32-bit ABI:
5333                                 size      argument     return value
5334
5335       small integer              <4       int. reg.      int. reg.
5336       word                        4       int. reg.      int. reg.
5337       double word                 8       int. reg.      int. reg.
5338
5339       _Complex small integer     <8       int. reg.      int. reg.
5340       _Complex word               8       int. reg.      int. reg.
5341       _Complex double word       16        memory        int. reg.
5342
5343       vector integer            <=8       int. reg.       FP reg.
5344       vector integer             >8        memory         memory
5345
5346       float                       4       int. reg.       FP reg.
5347       double                      8       int. reg.       FP reg.
5348       long double                16        memory         memory
5349
5350       _Complex float              8        memory         FP reg.
5351       _Complex double            16        memory         FP reg.
5352       _Complex long double       32        memory         FP reg.
5353
5354       vector float              any        memory         memory
5355
5356       aggregate                 any        memory         memory
5357
5358
5359
5360     64-bit ABI:
5361                                 size      argument     return value
5362
5363       small integer              <8       int. reg.      int. reg.
5364       word                        8       int. reg.      int. reg.
5365       double word                16       int. reg.      int. reg.
5366
5367       _Complex small integer    <16       int. reg.      int. reg.
5368       _Complex word              16       int. reg.      int. reg.
5369       _Complex double word       32        memory        int. reg.
5370
5371       vector integer           <=16        FP reg.        FP reg.
5372       vector integer       16<s<=32        memory         FP reg.
5373       vector integer            >32        memory         memory
5374
5375       float                       4        FP reg.        FP reg.
5376       double                      8        FP reg.        FP reg.
5377       long double                16        FP reg.        FP reg.
5378
5379       _Complex float              8        FP reg.        FP reg.
5380       _Complex double            16        FP reg.        FP reg.
5381       _Complex long double       32        memory         FP reg.
5382
5383       vector float             <=16        FP reg.        FP reg.
5384       vector float         16<s<=32        memory         FP reg.
5385       vector float              >32        memory         memory
5386
5387       aggregate                <=16         reg.           reg.
5388       aggregate            16<s<=32        memory          reg.
5389       aggregate                 >32        memory         memory
5390
5391
5392
5393 Note #1: complex floating-point types follow the extended SPARC ABIs as
5394 implemented by the Sun compiler.
5395
5396 Note #2: integral vector types follow the scalar floating-point types
5397 conventions to match what is implemented by the Sun VIS SDK.
5398
5399 Note #3: floating-point vector types follow the aggregate types
5400 conventions.  */
5401
5402
5403 /* Maximum number of int regs for args.  */
5404 #define SPARC_INT_ARG_MAX 6
5405 /* Maximum number of fp regs for args.  */
5406 #define SPARC_FP_ARG_MAX 16
5407
5408 #define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
5409
5410 /* Handle the INIT_CUMULATIVE_ARGS macro.
5411    Initialize a variable CUM of type CUMULATIVE_ARGS
5412    for a call to a function whose data type is FNTYPE.
5413    For a library call, FNTYPE is 0.  */
5414
5415 void
5416 init_cumulative_args (struct sparc_args *cum, tree fntype,
5417                       rtx libname ATTRIBUTE_UNUSED,
5418                       tree fndecl ATTRIBUTE_UNUSED)
5419 {
5420   cum->words = 0;
5421   cum->prototype_p = fntype && prototype_p (fntype);
5422   cum->libcall_p = fntype == 0;
5423 }
5424
5425 /* Handle promotion of pointer and integer arguments.  */
5426
5427 static enum machine_mode
5428 sparc_promote_function_mode (const_tree type,
5429                              enum machine_mode mode,
5430                              int *punsignedp,
5431                              const_tree fntype ATTRIBUTE_UNUSED,
5432                              int for_return ATTRIBUTE_UNUSED)
5433 {
5434   if (type != NULL_TREE && POINTER_TYPE_P (type))
5435     {
5436       *punsignedp = POINTERS_EXTEND_UNSIGNED;
5437       return Pmode;
5438     }
5439
5440   /* Integral arguments are passed as full words, as per the ABI.  */
5441   if (GET_MODE_CLASS (mode) == MODE_INT
5442       && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
5443     return word_mode;
5444
5445   return mode;
5446 }
5447
5448 /* Handle the TARGET_STRICT_ARGUMENT_NAMING target hook.  */
5449
5450 static bool
5451 sparc_strict_argument_naming (cumulative_args_t ca ATTRIBUTE_UNUSED)
5452 {
5453   return TARGET_ARCH64 ? true : false;
5454 }
5455
5456 /* Scan the record type TYPE and return the following predicates:
5457     - INTREGS_P: the record contains at least one field or sub-field
5458       that is eligible for promotion in integer registers.
5459     - FP_REGS_P: the record contains at least one field or sub-field
5460       that is eligible for promotion in floating-point registers.
5461     - PACKED_P: the record contains at least one field that is packed.
5462
5463    Sub-fields are not taken into account for the PACKED_P predicate.  */
5464
5465 static void
5466 scan_record_type (const_tree type, int *intregs_p, int *fpregs_p,
5467                   int *packed_p)
5468 {
5469   tree field;
5470
5471   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5472     {
5473       if (TREE_CODE (field) == FIELD_DECL)
5474         {
5475           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5476             scan_record_type (TREE_TYPE (field), intregs_p, fpregs_p, 0);
5477           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5478                    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5479                   && TARGET_FPU)
5480             *fpregs_p = 1;
5481           else
5482             *intregs_p = 1;
5483
5484           if (packed_p && DECL_PACKED (field))
5485             *packed_p = 1;
5486         }
5487     }
5488 }
5489
5490 /* Compute the slot number to pass an argument in.
5491    Return the slot number or -1 if passing on the stack.
5492
5493    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5494     the preceding args and about the function being called.
5495    MODE is the argument's machine mode.
5496    TYPE is the data type of the argument (as a tree).
5497     This is null for libcalls where that information may
5498     not be available.
5499    NAMED is nonzero if this argument is a named parameter
5500     (otherwise it is an extra parameter matching an ellipsis).
5501    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
5502    *PREGNO records the register number to use if scalar type.
5503    *PPADDING records the amount of padding needed in words.  */
5504
5505 static int
5506 function_arg_slotno (const struct sparc_args *cum, enum machine_mode mode,
5507                      const_tree type, bool named, bool incoming_p,
5508                      int *pregno, int *ppadding)
5509 {
5510   int regbase = (incoming_p
5511                  ? SPARC_INCOMING_INT_ARG_FIRST
5512                  : SPARC_OUTGOING_INT_ARG_FIRST);
5513   int slotno = cum->words;
5514   enum mode_class mclass;
5515   int regno;
5516
5517   *ppadding = 0;
5518
5519   if (type && TREE_ADDRESSABLE (type))
5520     return -1;
5521
5522   if (TARGET_ARCH32
5523       && mode == BLKmode
5524       && type
5525       && TYPE_ALIGN (type) % PARM_BOUNDARY != 0)
5526     return -1;
5527
5528   /* For SPARC64, objects requiring 16-byte alignment get it.  */
5529   if (TARGET_ARCH64
5530       && (type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode)) >= 128
5531       && (slotno & 1) != 0)
5532     slotno++, *ppadding = 1;
5533
5534   mclass = GET_MODE_CLASS (mode);
5535   if (type && TREE_CODE (type) == VECTOR_TYPE)
5536     {
5537       /* Vector types deserve special treatment because they are
5538          polymorphic wrt their mode, depending upon whether VIS
5539          instructions are enabled.  */
5540       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5541         {
5542           /* The SPARC port defines no floating-point vector modes.  */
5543           gcc_assert (mode == BLKmode);
5544         }
5545       else
5546         {
5547           /* Integral vector types should either have a vector
5548              mode or an integral mode, because we are guaranteed
5549              by pass_by_reference that their size is not greater
5550              than 16 bytes and TImode is 16-byte wide.  */
5551           gcc_assert (mode != BLKmode);
5552
5553           /* Vector integers are handled like floats according to
5554              the Sun VIS SDK.  */
5555           mclass = MODE_FLOAT;
5556         }
5557     }
5558
5559   switch (mclass)
5560     {
5561     case MODE_FLOAT:
5562     case MODE_COMPLEX_FLOAT:
5563     case MODE_VECTOR_INT:
5564       if (TARGET_ARCH64 && TARGET_FPU && named)
5565         {
5566           if (slotno >= SPARC_FP_ARG_MAX)
5567             return -1;
5568           regno = SPARC_FP_ARG_FIRST + slotno * 2;
5569           /* Arguments filling only one single FP register are
5570              right-justified in the outer double FP register.  */
5571           if (GET_MODE_SIZE (mode) <= 4)
5572             regno++;
5573           break;
5574         }
5575       /* fallthrough */
5576
5577     case MODE_INT:
5578     case MODE_COMPLEX_INT:
5579       if (slotno >= SPARC_INT_ARG_MAX)
5580         return -1;
5581       regno = regbase + slotno;
5582       break;
5583
5584     case MODE_RANDOM:
5585       if (mode == VOIDmode)
5586         /* MODE is VOIDmode when generating the actual call.  */
5587         return -1;
5588
5589       gcc_assert (mode == BLKmode);
5590
5591       if (TARGET_ARCH32
5592           || !type
5593           || (TREE_CODE (type) != VECTOR_TYPE
5594               && TREE_CODE (type) != RECORD_TYPE))
5595         {
5596           if (slotno >= SPARC_INT_ARG_MAX)
5597             return -1;
5598           regno = regbase + slotno;
5599         }
5600       else  /* TARGET_ARCH64 && type */
5601         {
5602           int intregs_p = 0, fpregs_p = 0, packed_p = 0;
5603
5604           /* First see what kinds of registers we would need.  */
5605           if (TREE_CODE (type) == VECTOR_TYPE)
5606             fpregs_p = 1;
5607           else
5608             scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
5609
5610           /* The ABI obviously doesn't specify how packed structures
5611              are passed.  These are defined to be passed in int regs
5612              if possible, otherwise memory.  */
5613           if (packed_p || !named)
5614             fpregs_p = 0, intregs_p = 1;
5615
5616           /* If all arg slots are filled, then must pass on stack.  */
5617           if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
5618             return -1;
5619
5620           /* If there are only int args and all int arg slots are filled,
5621              then must pass on stack.  */
5622           if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
5623             return -1;
5624
5625           /* Note that even if all int arg slots are filled, fp members may
5626              still be passed in regs if such regs are available.
5627              *PREGNO isn't set because there may be more than one, it's up
5628              to the caller to compute them.  */
5629           return slotno;
5630         }
5631       break;
5632
5633     default :
5634       gcc_unreachable ();
5635     }
5636
5637   *pregno = regno;
5638   return slotno;
5639 }
5640
5641 /* Handle recursive register counting for structure field layout.  */
5642
5643 struct function_arg_record_value_parms
5644 {
5645   rtx ret;              /* return expression being built.  */
5646   int slotno;           /* slot number of the argument.  */
5647   int named;            /* whether the argument is named.  */
5648   int regbase;          /* regno of the base register.  */
5649   int stack;            /* 1 if part of the argument is on the stack.  */
5650   int intoffset;        /* offset of the first pending integer field.  */
5651   unsigned int nregs;   /* number of words passed in registers.  */
5652 };
5653
5654 static void function_arg_record_value_3
5655  (HOST_WIDE_INT, struct function_arg_record_value_parms *);
5656 static void function_arg_record_value_2
5657  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5658 static void function_arg_record_value_1
5659  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5660 static rtx function_arg_record_value (const_tree, enum machine_mode, int, int, int);
5661 static rtx function_arg_union_value (int, enum machine_mode, int, int);
5662
5663 /* A subroutine of function_arg_record_value.  Traverse the structure
5664    recursively and determine how many registers will be required.  */
5665
5666 static void
5667 function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos,
5668                              struct function_arg_record_value_parms *parms,
5669                              bool packed_p)
5670 {
5671   tree field;
5672
5673   /* We need to compute how many registers are needed so we can
5674      allocate the PARALLEL but before we can do that we need to know
5675      whether there are any packed fields.  The ABI obviously doesn't
5676      specify how structures are passed in this case, so they are
5677      defined to be passed in int regs if possible, otherwise memory,
5678      regardless of whether there are fp values present.  */
5679
5680   if (! packed_p)
5681     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5682       {
5683         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5684           {
5685             packed_p = true;
5686             break;
5687           }
5688       }
5689
5690   /* Compute how many registers we need.  */
5691   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5692     {
5693       if (TREE_CODE (field) == FIELD_DECL)
5694         {
5695           HOST_WIDE_INT bitpos = startbitpos;
5696
5697           if (DECL_SIZE (field) != 0)
5698             {
5699               if (integer_zerop (DECL_SIZE (field)))
5700                 continue;
5701
5702               if (host_integerp (bit_position (field), 1))
5703                 bitpos += int_bit_position (field);
5704             }
5705
5706           /* ??? FIXME: else assume zero offset.  */
5707
5708           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5709             function_arg_record_value_1 (TREE_TYPE (field),
5710                                          bitpos,
5711                                          parms,
5712                                          packed_p);
5713           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5714                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5715                    && TARGET_FPU
5716                    && parms->named
5717                    && ! packed_p)
5718             {
5719               if (parms->intoffset != -1)
5720                 {
5721                   unsigned int startbit, endbit;
5722                   int intslots, this_slotno;
5723
5724                   startbit = parms->intoffset & -BITS_PER_WORD;
5725                   endbit   = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5726
5727                   intslots = (endbit - startbit) / BITS_PER_WORD;
5728                   this_slotno = parms->slotno + parms->intoffset
5729                     / BITS_PER_WORD;
5730
5731                   if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5732                     {
5733                       intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5734                       /* We need to pass this field on the stack.  */
5735                       parms->stack = 1;
5736                     }
5737
5738                   parms->nregs += intslots;
5739                   parms->intoffset = -1;
5740                 }
5741
5742               /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
5743                  If it wasn't true we wouldn't be here.  */
5744               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5745                   && DECL_MODE (field) == BLKmode)
5746                 parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5747               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5748                 parms->nregs += 2;
5749               else
5750                 parms->nregs += 1;
5751             }
5752           else
5753             {
5754               if (parms->intoffset == -1)
5755                 parms->intoffset = bitpos;
5756             }
5757         }
5758     }
5759 }
5760
5761 /* A subroutine of function_arg_record_value.  Assign the bits of the
5762    structure between parms->intoffset and bitpos to integer registers.  */
5763
5764 static void
5765 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
5766                              struct function_arg_record_value_parms *parms)
5767 {
5768   enum machine_mode mode;
5769   unsigned int regno;
5770   unsigned int startbit, endbit;
5771   int this_slotno, intslots, intoffset;
5772   rtx reg;
5773
5774   if (parms->intoffset == -1)
5775     return;
5776
5777   intoffset = parms->intoffset;
5778   parms->intoffset = -1;
5779
5780   startbit = intoffset & -BITS_PER_WORD;
5781   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5782   intslots = (endbit - startbit) / BITS_PER_WORD;
5783   this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
5784
5785   intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
5786   if (intslots <= 0)
5787     return;
5788
5789   /* If this is the trailing part of a word, only load that much into
5790      the register.  Otherwise load the whole register.  Note that in
5791      the latter case we may pick up unwanted bits.  It's not a problem
5792      at the moment but may wish to revisit.  */
5793
5794   if (intoffset % BITS_PER_WORD != 0)
5795     mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
5796                                    MODE_INT);
5797   else
5798     mode = word_mode;
5799
5800   intoffset /= BITS_PER_UNIT;
5801   do
5802     {
5803       regno = parms->regbase + this_slotno;
5804       reg = gen_rtx_REG (mode, regno);
5805       XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5806         = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
5807
5808       this_slotno += 1;
5809       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
5810       mode = word_mode;
5811       parms->nregs += 1;
5812       intslots -= 1;
5813     }
5814   while (intslots > 0);
5815 }
5816
5817 /* A subroutine of function_arg_record_value.  Traverse the structure
5818    recursively and assign bits to floating point registers.  Track which
5819    bits in between need integer registers; invoke function_arg_record_value_3
5820    to make that happen.  */
5821
5822 static void
5823 function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
5824                              struct function_arg_record_value_parms *parms,
5825                              bool packed_p)
5826 {
5827   tree field;
5828
5829   if (! packed_p)
5830     for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5831       {
5832         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5833           {
5834             packed_p = true;
5835             break;
5836           }
5837       }
5838
5839   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5840     {
5841       if (TREE_CODE (field) == FIELD_DECL)
5842         {
5843           HOST_WIDE_INT bitpos = startbitpos;
5844
5845           if (DECL_SIZE (field) != 0)
5846             {
5847               if (integer_zerop (DECL_SIZE (field)))
5848                 continue;
5849
5850               if (host_integerp (bit_position (field), 1))
5851                 bitpos += int_bit_position (field);
5852             }
5853
5854           /* ??? FIXME: else assume zero offset.  */
5855
5856           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5857             function_arg_record_value_2 (TREE_TYPE (field),
5858                                          bitpos,
5859                                          parms,
5860                                          packed_p);
5861           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5862                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5863                    && TARGET_FPU
5864                    && parms->named
5865                    && ! packed_p)
5866             {
5867               int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
5868               int regno, nregs, pos;
5869               enum machine_mode mode = DECL_MODE (field);
5870               rtx reg;
5871
5872               function_arg_record_value_3 (bitpos, parms);
5873
5874               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5875                   && mode == BLKmode)
5876                 {
5877                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5878                   nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5879                 }
5880               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5881                 {
5882                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5883                   nregs = 2;
5884                 }
5885               else
5886                 nregs = 1;
5887
5888               regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
5889               if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
5890                 regno++;
5891               reg = gen_rtx_REG (mode, regno);
5892               pos = bitpos / BITS_PER_UNIT;
5893               XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5894                 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5895               parms->nregs += 1;
5896               while (--nregs > 0)
5897                 {
5898                   regno += GET_MODE_SIZE (mode) / 4;
5899                   reg = gen_rtx_REG (mode, regno);
5900                   pos += GET_MODE_SIZE (mode);
5901                   XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5902                     = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5903                   parms->nregs += 1;
5904                 }
5905             }
5906           else
5907             {
5908               if (parms->intoffset == -1)
5909                 parms->intoffset = bitpos;
5910             }
5911         }
5912     }
5913 }
5914
5915 /* Used by function_arg and sparc_function_value_1 to implement the complex
5916    conventions of the 64-bit ABI for passing and returning structures.
5917    Return an expression valid as a return value for the FUNCTION_ARG
5918    and TARGET_FUNCTION_VALUE.
5919
5920    TYPE is the data type of the argument (as a tree).
5921     This is null for libcalls where that information may
5922     not be available.
5923    MODE is the argument's machine mode.
5924    SLOTNO is the index number of the argument's slot in the parameter array.
5925    NAMED is nonzero if this argument is a named parameter
5926     (otherwise it is an extra parameter matching an ellipsis).
5927    REGBASE is the regno of the base register for the parameter array.  */
5928
5929 static rtx
5930 function_arg_record_value (const_tree type, enum machine_mode mode,
5931                            int slotno, int named, int regbase)
5932 {
5933   HOST_WIDE_INT typesize = int_size_in_bytes (type);
5934   struct function_arg_record_value_parms parms;
5935   unsigned int nregs;
5936
5937   parms.ret = NULL_RTX;
5938   parms.slotno = slotno;
5939   parms.named = named;
5940   parms.regbase = regbase;
5941   parms.stack = 0;
5942
5943   /* Compute how many registers we need.  */
5944   parms.nregs = 0;
5945   parms.intoffset = 0;
5946   function_arg_record_value_1 (type, 0, &parms, false);
5947
5948   /* Take into account pending integer fields.  */
5949   if (parms.intoffset != -1)
5950     {
5951       unsigned int startbit, endbit;
5952       int intslots, this_slotno;
5953
5954       startbit = parms.intoffset & -BITS_PER_WORD;
5955       endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5956       intslots = (endbit - startbit) / BITS_PER_WORD;
5957       this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
5958
5959       if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5960         {
5961           intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5962           /* We need to pass this field on the stack.  */
5963           parms.stack = 1;
5964         }
5965
5966       parms.nregs += intslots;
5967     }
5968   nregs = parms.nregs;
5969
5970   /* Allocate the vector and handle some annoying special cases.  */
5971   if (nregs == 0)
5972     {
5973       /* ??? Empty structure has no value?  Duh?  */
5974       if (typesize <= 0)
5975         {
5976           /* Though there's nothing really to store, return a word register
5977              anyway so the rest of gcc doesn't go nuts.  Returning a PARALLEL
5978              leads to breakage due to the fact that there are zero bytes to
5979              load.  */
5980           return gen_rtx_REG (mode, regbase);
5981         }
5982       else
5983         {
5984           /* ??? C++ has structures with no fields, and yet a size.  Give up
5985              for now and pass everything back in integer registers.  */
5986           nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5987         }
5988       if (nregs + slotno > SPARC_INT_ARG_MAX)
5989         nregs = SPARC_INT_ARG_MAX - slotno;
5990     }
5991   gcc_assert (nregs != 0);
5992
5993   parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
5994
5995   /* If at least one field must be passed on the stack, generate
5996      (parallel [(expr_list (nil) ...) ...]) so that all fields will
5997      also be passed on the stack.  We can't do much better because the
5998      semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
5999      of structures for which the fields passed exclusively in registers
6000      are not at the beginning of the structure.  */
6001   if (parms.stack)
6002     XVECEXP (parms.ret, 0, 0)
6003       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6004
6005   /* Fill in the entries.  */
6006   parms.nregs = 0;
6007   parms.intoffset = 0;
6008   function_arg_record_value_2 (type, 0, &parms, false);
6009   function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
6010
6011   gcc_assert (parms.nregs == nregs);
6012
6013   return parms.ret;
6014 }
6015
6016 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6017    of the 64-bit ABI for passing and returning unions.
6018    Return an expression valid as a return value for the FUNCTION_ARG
6019    and TARGET_FUNCTION_VALUE.
6020
6021    SIZE is the size in bytes of the union.
6022    MODE is the argument's machine mode.
6023    REGNO is the hard register the union will be passed in.  */
6024
6025 static rtx
6026 function_arg_union_value (int size, enum machine_mode mode, int slotno,
6027                           int regno)
6028 {
6029   int nwords = ROUND_ADVANCE (size), i;
6030   rtx regs;
6031
6032   /* See comment in previous function for empty structures.  */
6033   if (nwords == 0)
6034     return gen_rtx_REG (mode, regno);
6035
6036   if (slotno == SPARC_INT_ARG_MAX - 1)
6037     nwords = 1;
6038
6039   regs = gen_rtx_PARALLEL (mode, rtvec_alloc (nwords));
6040
6041   for (i = 0; i < nwords; i++)
6042     {
6043       /* Unions are passed left-justified.  */
6044       XVECEXP (regs, 0, i)
6045         = gen_rtx_EXPR_LIST (VOIDmode,
6046                              gen_rtx_REG (word_mode, regno),
6047                              GEN_INT (UNITS_PER_WORD * i));
6048       regno++;
6049     }
6050
6051   return regs;
6052 }
6053
6054 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6055    for passing and returning large (BLKmode) vectors.
6056    Return an expression valid as a return value for the FUNCTION_ARG
6057    and TARGET_FUNCTION_VALUE.
6058
6059    SIZE is the size in bytes of the vector (at least 8 bytes).
6060    REGNO is the FP hard register the vector will be passed in.  */
6061
6062 static rtx
6063 function_arg_vector_value (int size, int regno)
6064 {
6065   int i, nregs = size / 8;
6066   rtx regs;
6067
6068   regs = gen_rtx_PARALLEL (BLKmode, rtvec_alloc (nregs));
6069
6070   for (i = 0; i < nregs; i++)
6071     {
6072       XVECEXP (regs, 0, i)
6073         = gen_rtx_EXPR_LIST (VOIDmode,
6074                              gen_rtx_REG (DImode, regno + 2*i),
6075                              GEN_INT (i*8));
6076     }
6077
6078   return regs;
6079 }
6080
6081 /* Determine where to put an argument to a function.
6082    Value is zero to push the argument on the stack,
6083    or a hard register in which to store the argument.
6084
6085    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6086     the preceding args and about the function being called.
6087    MODE is the argument's machine mode.
6088    TYPE is the data type of the argument (as a tree).
6089     This is null for libcalls where that information may
6090     not be available.
6091    NAMED is true if this argument is a named parameter
6092     (otherwise it is an extra parameter matching an ellipsis).
6093    INCOMING_P is false for TARGET_FUNCTION_ARG, true for
6094     TARGET_FUNCTION_INCOMING_ARG.  */
6095
6096 static rtx
6097 sparc_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
6098                       const_tree type, bool named, bool incoming_p)
6099 {
6100   const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6101
6102   int regbase = (incoming_p
6103                  ? SPARC_INCOMING_INT_ARG_FIRST
6104                  : SPARC_OUTGOING_INT_ARG_FIRST);
6105   int slotno, regno, padding;
6106   enum mode_class mclass = GET_MODE_CLASS (mode);
6107
6108   slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
6109                                 &regno, &padding);
6110   if (slotno == -1)
6111     return 0;
6112
6113   /* Vector types deserve special treatment because they are polymorphic wrt
6114      their mode, depending upon whether VIS instructions are enabled.  */
6115   if (type && TREE_CODE (type) == VECTOR_TYPE)
6116     {
6117       HOST_WIDE_INT size = int_size_in_bytes (type);
6118       gcc_assert ((TARGET_ARCH32 && size <= 8)
6119                   || (TARGET_ARCH64 && size <= 16));
6120
6121       if (mode == BLKmode)
6122         return function_arg_vector_value (size,
6123                                           SPARC_FP_ARG_FIRST + 2*slotno);
6124       else
6125         mclass = MODE_FLOAT;
6126     }
6127
6128   if (TARGET_ARCH32)
6129     return gen_rtx_REG (mode, regno);
6130
6131   /* Structures up to 16 bytes in size are passed in arg slots on the stack
6132      and are promoted to registers if possible.  */
6133   if (type && TREE_CODE (type) == RECORD_TYPE)
6134     {
6135       HOST_WIDE_INT size = int_size_in_bytes (type);
6136       gcc_assert (size <= 16);
6137
6138       return function_arg_record_value (type, mode, slotno, named, regbase);
6139     }
6140
6141   /* Unions up to 16 bytes in size are passed in integer registers.  */
6142   else if (type && TREE_CODE (type) == UNION_TYPE)
6143     {
6144       HOST_WIDE_INT size = int_size_in_bytes (type);
6145       gcc_assert (size <= 16);
6146
6147       return function_arg_union_value (size, mode, slotno, regno);
6148     }
6149
6150   /* v9 fp args in reg slots beyond the int reg slots get passed in regs
6151      but also have the slot allocated for them.
6152      If no prototype is in scope fp values in register slots get passed
6153      in two places, either fp regs and int regs or fp regs and memory.  */
6154   else if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6155            && SPARC_FP_REG_P (regno))
6156     {
6157       rtx reg = gen_rtx_REG (mode, regno);
6158       if (cum->prototype_p || cum->libcall_p)
6159         {
6160           /* "* 2" because fp reg numbers are recorded in 4 byte
6161              quantities.  */
6162 #if 0
6163           /* ??? This will cause the value to be passed in the fp reg and
6164              in the stack.  When a prototype exists we want to pass the
6165              value in the reg but reserve space on the stack.  That's an
6166              optimization, and is deferred [for a bit].  */
6167           if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
6168             return gen_rtx_PARALLEL (mode,
6169                             gen_rtvec (2,
6170                                        gen_rtx_EXPR_LIST (VOIDmode,
6171                                                 NULL_RTX, const0_rtx),
6172                                        gen_rtx_EXPR_LIST (VOIDmode,
6173                                                 reg, const0_rtx)));
6174           else
6175 #else
6176           /* ??? It seems that passing back a register even when past
6177              the area declared by REG_PARM_STACK_SPACE will allocate
6178              space appropriately, and will not copy the data onto the
6179              stack, exactly as we desire.
6180
6181              This is due to locate_and_pad_parm being called in
6182              expand_call whenever reg_parm_stack_space > 0, which
6183              while beneficial to our example here, would seem to be
6184              in error from what had been intended.  Ho hum...  -- r~ */
6185 #endif
6186             return reg;
6187         }
6188       else
6189         {
6190           rtx v0, v1;
6191
6192           if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
6193             {
6194               int intreg;
6195
6196               /* On incoming, we don't need to know that the value
6197                  is passed in %f0 and %i0, and it confuses other parts
6198                  causing needless spillage even on the simplest cases.  */
6199               if (incoming_p)
6200                 return reg;
6201
6202               intreg = (SPARC_OUTGOING_INT_ARG_FIRST
6203                         + (regno - SPARC_FP_ARG_FIRST) / 2);
6204
6205               v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6206               v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
6207                                       const0_rtx);
6208               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6209             }
6210           else
6211             {
6212               v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6213               v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6214               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6215             }
6216         }
6217     }
6218
6219   /* All other aggregate types are passed in an integer register in a mode
6220      corresponding to the size of the type.  */
6221   else if (type && AGGREGATE_TYPE_P (type))
6222     {
6223       HOST_WIDE_INT size = int_size_in_bytes (type);
6224       gcc_assert (size <= 16);
6225
6226       mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6227     }
6228
6229   return gen_rtx_REG (mode, regno);
6230 }
6231
6232 /* Handle the TARGET_FUNCTION_ARG target hook.  */
6233
6234 static rtx
6235 sparc_function_arg (cumulative_args_t cum, enum machine_mode mode,
6236                     const_tree type, bool named)
6237 {
6238   return sparc_function_arg_1 (cum, mode, type, named, false);
6239 }
6240
6241 /* Handle the TARGET_FUNCTION_INCOMING_ARG target hook.  */
6242
6243 static rtx
6244 sparc_function_incoming_arg (cumulative_args_t cum, enum machine_mode mode,
6245                              const_tree type, bool named)
6246 {
6247   return sparc_function_arg_1 (cum, mode, type, named, true);
6248 }
6249
6250 /* For sparc64, objects requiring 16 byte alignment are passed that way.  */
6251
6252 static unsigned int
6253 sparc_function_arg_boundary (enum machine_mode mode, const_tree type)
6254 {
6255   return ((TARGET_ARCH64
6256            && (GET_MODE_ALIGNMENT (mode) == 128
6257                || (type && TYPE_ALIGN (type) == 128)))
6258           ? 128
6259           : PARM_BOUNDARY);
6260 }
6261
6262 /* For an arg passed partly in registers and partly in memory,
6263    this is the number of bytes of registers used.
6264    For args passed entirely in registers or entirely in memory, zero.
6265
6266    Any arg that starts in the first 6 regs but won't entirely fit in them
6267    needs partial registers on v8.  On v9, structures with integer
6268    values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
6269    values that begin in the last fp reg [where "last fp reg" varies with the
6270    mode] will be split between that reg and memory.  */
6271
6272 static int
6273 sparc_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
6274                          tree type, bool named)
6275 {
6276   int slotno, regno, padding;
6277
6278   /* We pass false for incoming_p here, it doesn't matter.  */
6279   slotno = function_arg_slotno (get_cumulative_args (cum), mode, type, named,
6280                                 false, &regno, &padding);
6281
6282   if (slotno == -1)
6283     return 0;
6284
6285   if (TARGET_ARCH32)
6286     {
6287       if ((slotno + (mode == BLKmode
6288                      ? ROUND_ADVANCE (int_size_in_bytes (type))
6289                      : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
6290           > SPARC_INT_ARG_MAX)
6291         return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
6292     }
6293   else
6294     {
6295       /* We are guaranteed by pass_by_reference that the size of the
6296          argument is not greater than 16 bytes, so we only need to return
6297          one word if the argument is partially passed in registers.  */
6298
6299       if (type && AGGREGATE_TYPE_P (type))
6300         {
6301           int size = int_size_in_bytes (type);
6302
6303           if (size > UNITS_PER_WORD
6304               && slotno == SPARC_INT_ARG_MAX - 1)
6305             return UNITS_PER_WORD;
6306         }
6307       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
6308                || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
6309                    && ! (TARGET_FPU && named)))
6310         {
6311           /* The complex types are passed as packed types.  */
6312           if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
6313               && slotno == SPARC_INT_ARG_MAX - 1)
6314             return UNITS_PER_WORD;
6315         }
6316       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
6317         {
6318           if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
6319               > SPARC_FP_ARG_MAX)
6320             return UNITS_PER_WORD;
6321         }
6322     }
6323
6324   return 0;
6325 }
6326
6327 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
6328    Specify whether to pass the argument by reference.  */
6329
6330 static bool
6331 sparc_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
6332                          enum machine_mode mode, const_tree type,
6333                          bool named ATTRIBUTE_UNUSED)
6334 {
6335   if (TARGET_ARCH32)
6336     /* Original SPARC 32-bit ABI says that structures and unions,
6337        and quad-precision floats are passed by reference.  For Pascal,
6338        also pass arrays by reference.  All other base types are passed
6339        in registers.
6340
6341        Extended ABI (as implemented by the Sun compiler) says that all
6342        complex floats are passed by reference.  Pass complex integers
6343        in registers up to 8 bytes.  More generally, enforce the 2-word
6344        cap for passing arguments in registers.
6345
6346        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6347        integers are passed like floats of the same size, that is in
6348        registers up to 8 bytes.  Pass all vector floats by reference
6349        like structure and unions.  */
6350     return ((type && (AGGREGATE_TYPE_P (type) || VECTOR_FLOAT_TYPE_P (type)))
6351             || mode == SCmode
6352             /* Catch CDImode, TFmode, DCmode and TCmode.  */
6353             || GET_MODE_SIZE (mode) > 8
6354             || (type
6355                 && TREE_CODE (type) == VECTOR_TYPE
6356                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6357   else
6358     /* Original SPARC 64-bit ABI says that structures and unions
6359        smaller than 16 bytes are passed in registers, as well as
6360        all other base types.
6361
6362        Extended ABI (as implemented by the Sun compiler) says that
6363        complex floats are passed in registers up to 16 bytes.  Pass
6364        all complex integers in registers up to 16 bytes.  More generally,
6365        enforce the 2-word cap for passing arguments in registers.
6366
6367        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6368        integers are passed like floats of the same size, that is in
6369        registers (up to 16 bytes).  Pass all vector floats like structure
6370        and unions.  */
6371     return ((type
6372              && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE)
6373              && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16)
6374             /* Catch CTImode and TCmode.  */
6375             || GET_MODE_SIZE (mode) > 16);
6376 }
6377
6378 /* Handle the TARGET_FUNCTION_ARG_ADVANCE hook.
6379    Update the data in CUM to advance over an argument
6380    of mode MODE and data type TYPE.
6381    TYPE is null for libcalls where that information may not be available.  */
6382
6383 static void
6384 sparc_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6385                             const_tree type, bool named)
6386 {
6387   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6388   int regno, padding;
6389
6390   /* We pass false for incoming_p here, it doesn't matter.  */
6391   function_arg_slotno (cum, mode, type, named, false, &regno, &padding);
6392
6393   /* If argument requires leading padding, add it.  */
6394   cum->words += padding;
6395
6396   if (TARGET_ARCH32)
6397     {
6398       cum->words += (mode != BLKmode
6399                      ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6400                      : ROUND_ADVANCE (int_size_in_bytes (type)));
6401     }
6402   else
6403     {
6404       if (type && AGGREGATE_TYPE_P (type))
6405         {
6406           int size = int_size_in_bytes (type);
6407
6408           if (size <= 8)
6409             ++cum->words;
6410           else if (size <= 16)
6411             cum->words += 2;
6412           else /* passed by reference */
6413             ++cum->words;
6414         }
6415       else
6416         {
6417           cum->words += (mode != BLKmode
6418                          ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6419                          : ROUND_ADVANCE (int_size_in_bytes (type)));
6420         }
6421     }
6422 }
6423
6424 /* Handle the FUNCTION_ARG_PADDING macro.
6425    For the 64 bit ABI structs are always stored left shifted in their
6426    argument slot.  */
6427
6428 enum direction
6429 function_arg_padding (enum machine_mode mode, const_tree type)
6430 {
6431   if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
6432     return upward;
6433
6434   /* Fall back to the default.  */
6435   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
6436 }
6437
6438 /* Handle the TARGET_RETURN_IN_MEMORY target hook.
6439    Specify whether to return the return value in memory.  */
6440
6441 static bool
6442 sparc_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
6443 {
6444   if (TARGET_ARCH32)
6445     /* Original SPARC 32-bit ABI says that structures and unions,
6446        and quad-precision floats are returned in memory.  All other
6447        base types are returned in registers.
6448
6449        Extended ABI (as implemented by the Sun compiler) says that
6450        all complex floats are returned in registers (8 FP registers
6451        at most for '_Complex long double').  Return all complex integers
6452        in registers (4 at most for '_Complex long long').
6453
6454        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6455        integers are returned like floats of the same size, that is in
6456        registers up to 8 bytes and in memory otherwise.  Return all
6457        vector floats in memory like structure and unions; note that
6458        they always have BLKmode like the latter.  */
6459     return (TYPE_MODE (type) == BLKmode
6460             || TYPE_MODE (type) == TFmode
6461             || (TREE_CODE (type) == VECTOR_TYPE
6462                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6463   else
6464     /* Original SPARC 64-bit ABI says that structures and unions
6465        smaller than 32 bytes are returned in registers, as well as
6466        all other base types.
6467
6468        Extended ABI (as implemented by the Sun compiler) says that all
6469        complex floats are returned in registers (8 FP registers at most
6470        for '_Complex long double').  Return all complex integers in
6471        registers (4 at most for '_Complex TItype').
6472
6473        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6474        integers are returned like floats of the same size, that is in
6475        registers.  Return all vector floats like structure and unions;
6476        note that they always have BLKmode like the latter.  */
6477     return (TYPE_MODE (type) == BLKmode
6478             && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 32);
6479 }
6480
6481 /* Handle the TARGET_STRUCT_VALUE target hook.
6482    Return where to find the structure return value address.  */
6483
6484 static rtx
6485 sparc_struct_value_rtx (tree fndecl, int incoming)
6486 {
6487   if (TARGET_ARCH64)
6488     return 0;
6489   else
6490     {
6491       rtx mem;
6492
6493       if (incoming)
6494         mem = gen_frame_mem (Pmode, plus_constant (frame_pointer_rtx,
6495                                                    STRUCT_VALUE_OFFSET));
6496       else
6497         mem = gen_frame_mem (Pmode, plus_constant (stack_pointer_rtx,
6498                                                    STRUCT_VALUE_OFFSET));
6499
6500       /* Only follow the SPARC ABI for fixed-size structure returns.
6501          Variable size structure returns are handled per the normal
6502          procedures in GCC. This is enabled by -mstd-struct-return */
6503       if (incoming == 2
6504           && sparc_std_struct_return
6505           && TYPE_SIZE_UNIT (TREE_TYPE (fndecl))
6506           && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (fndecl))) == INTEGER_CST)
6507         {
6508           /* We must check and adjust the return address, as it is
6509              optional as to whether the return object is really
6510              provided.  */
6511           rtx ret_reg = gen_rtx_REG (Pmode, 31);
6512           rtx scratch = gen_reg_rtx (SImode);
6513           rtx endlab = gen_label_rtx ();
6514
6515           /* Calculate the return object size */
6516           tree size = TYPE_SIZE_UNIT (TREE_TYPE (fndecl));
6517           rtx size_rtx = GEN_INT (TREE_INT_CST_LOW (size) & 0xfff);
6518           /* Construct a temporary return value */
6519           rtx temp_val
6520             = assign_stack_local (Pmode, TREE_INT_CST_LOW (size), 0);
6521
6522           /* Implement SPARC 32-bit psABI callee return struct checking:
6523
6524              Fetch the instruction where we will return to and see if
6525              it's an unimp instruction (the most significant 10 bits
6526              will be zero).  */
6527           emit_move_insn (scratch, gen_rtx_MEM (SImode,
6528                                                 plus_constant (ret_reg, 8)));
6529           /* Assume the size is valid and pre-adjust */
6530           emit_insn (gen_add3_insn (ret_reg, ret_reg, GEN_INT (4)));
6531           emit_cmp_and_jump_insns (scratch, size_rtx, EQ, const0_rtx, SImode,
6532                                    0, endlab);
6533           emit_insn (gen_sub3_insn (ret_reg, ret_reg, GEN_INT (4)));
6534           /* Write the address of the memory pointed to by temp_val into
6535              the memory pointed to by mem */
6536           emit_move_insn (mem, XEXP (temp_val, 0));
6537           emit_label (endlab);
6538         }
6539
6540       return mem;
6541     }
6542 }
6543
6544 /* Handle TARGET_FUNCTION_VALUE, and TARGET_LIBCALL_VALUE target hook.
6545    For v9, function return values are subject to the same rules as arguments,
6546    except that up to 32 bytes may be returned in registers.  */
6547
6548 static rtx
6549 sparc_function_value_1 (const_tree type, enum machine_mode mode,
6550                         bool outgoing)
6551 {
6552   /* Beware that the two values are swapped here wrt function_arg.  */
6553   int regbase = (outgoing
6554                  ? SPARC_INCOMING_INT_ARG_FIRST
6555                  : SPARC_OUTGOING_INT_ARG_FIRST);
6556   enum mode_class mclass = GET_MODE_CLASS (mode);
6557   int regno;
6558
6559   /* Vector types deserve special treatment because they are polymorphic wrt
6560      their mode, depending upon whether VIS instructions are enabled.  */
6561   if (type && TREE_CODE (type) == VECTOR_TYPE)
6562     {
6563       HOST_WIDE_INT size = int_size_in_bytes (type);
6564       gcc_assert ((TARGET_ARCH32 && size <= 8)
6565                   || (TARGET_ARCH64 && size <= 32));
6566
6567       if (mode == BLKmode)
6568         return function_arg_vector_value (size,
6569                                           SPARC_FP_ARG_FIRST);
6570       else
6571         mclass = MODE_FLOAT;
6572     }
6573
6574   if (TARGET_ARCH64 && type)
6575     {
6576       /* Structures up to 32 bytes in size are returned in registers.  */
6577       if (TREE_CODE (type) == RECORD_TYPE)
6578         {
6579           HOST_WIDE_INT size = int_size_in_bytes (type);
6580           gcc_assert (size <= 32);
6581
6582           return function_arg_record_value (type, mode, 0, 1, regbase);
6583         }
6584
6585       /* Unions up to 32 bytes in size are returned in integer registers.  */
6586       else if (TREE_CODE (type) == UNION_TYPE)
6587         {
6588           HOST_WIDE_INT size = int_size_in_bytes (type);
6589           gcc_assert (size <= 32);
6590
6591           return function_arg_union_value (size, mode, 0, regbase);
6592         }
6593
6594       /* Objects that require it are returned in FP registers.  */
6595       else if (mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6596         ;
6597
6598       /* All other aggregate types are returned in an integer register in a
6599          mode corresponding to the size of the type.  */
6600       else if (AGGREGATE_TYPE_P (type))
6601         {
6602           /* All other aggregate types are passed in an integer register
6603              in a mode corresponding to the size of the type.  */
6604           HOST_WIDE_INT size = int_size_in_bytes (type);
6605           gcc_assert (size <= 32);
6606
6607           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6608
6609           /* ??? We probably should have made the same ABI change in
6610              3.4.0 as the one we made for unions.   The latter was
6611              required by the SCD though, while the former is not
6612              specified, so we favored compatibility and efficiency.
6613
6614              Now we're stuck for aggregates larger than 16 bytes,
6615              because OImode vanished in the meantime.  Let's not
6616              try to be unduly clever, and simply follow the ABI
6617              for unions in that case.  */
6618           if (mode == BLKmode)
6619             return function_arg_union_value (size, mode, 0, regbase);
6620           else
6621             mclass = MODE_INT;
6622         }
6623
6624       /* We should only have pointer and integer types at this point.  This
6625          must match sparc_promote_function_mode.  */
6626       else if (mclass == MODE_INT && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6627         mode = word_mode;
6628     }
6629
6630   /* We should only have pointer and integer types at this point.  This must
6631      match sparc_promote_function_mode.  */
6632   else if (TARGET_ARCH32
6633            && mclass == MODE_INT
6634            && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6635     mode = word_mode;
6636
6637   if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT) && TARGET_FPU)
6638     regno = SPARC_FP_ARG_FIRST;
6639   else
6640     regno = regbase;
6641
6642   return gen_rtx_REG (mode, regno);
6643 }
6644
6645 /* Handle TARGET_FUNCTION_VALUE.
6646    On the SPARC, the value is found in the first "output" register, but the
6647    called function leaves it in the first "input" register.  */
6648
6649 static rtx
6650 sparc_function_value (const_tree valtype,
6651                       const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
6652                       bool outgoing)
6653 {
6654   return sparc_function_value_1 (valtype, TYPE_MODE (valtype), outgoing);
6655 }
6656
6657 /* Handle TARGET_LIBCALL_VALUE.  */
6658
6659 static rtx
6660 sparc_libcall_value (enum machine_mode mode,
6661                      const_rtx fun ATTRIBUTE_UNUSED)
6662 {
6663   return sparc_function_value_1 (NULL_TREE, mode, false);
6664 }
6665
6666 /* Handle FUNCTION_VALUE_REGNO_P.
6667    On the SPARC, the first "output" reg is used for integer values, and the
6668    first floating point register is used for floating point values.  */
6669
6670 static bool
6671 sparc_function_value_regno_p (const unsigned int regno)
6672 {
6673   return (regno == 8 || regno == 32);
6674 }
6675
6676 /* Do what is necessary for `va_start'.  We look at the current function
6677    to determine if stdarg or varargs is used and return the address of
6678    the first unnamed parameter.  */
6679
6680 static rtx
6681 sparc_builtin_saveregs (void)
6682 {
6683   int first_reg = crtl->args.info.words;
6684   rtx address;
6685   int regno;
6686
6687   for (regno = first_reg; regno < SPARC_INT_ARG_MAX; regno++)
6688     emit_move_insn (gen_rtx_MEM (word_mode,
6689                                  gen_rtx_PLUS (Pmode,
6690                                                frame_pointer_rtx,
6691                                                GEN_INT (FIRST_PARM_OFFSET (0)
6692                                                         + (UNITS_PER_WORD
6693                                                            * regno)))),
6694                     gen_rtx_REG (word_mode,
6695                                  SPARC_INCOMING_INT_ARG_FIRST + regno));
6696
6697   address = gen_rtx_PLUS (Pmode,
6698                           frame_pointer_rtx,
6699                           GEN_INT (FIRST_PARM_OFFSET (0)
6700                                    + UNITS_PER_WORD * first_reg));
6701
6702   return address;
6703 }
6704
6705 /* Implement `va_start' for stdarg.  */
6706
6707 static void
6708 sparc_va_start (tree valist, rtx nextarg)
6709 {
6710   nextarg = expand_builtin_saveregs ();
6711   std_expand_builtin_va_start (valist, nextarg);
6712 }
6713
6714 /* Implement `va_arg' for stdarg.  */
6715
6716 static tree
6717 sparc_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
6718                        gimple_seq *post_p)
6719 {
6720   HOST_WIDE_INT size, rsize, align;
6721   tree addr, incr;
6722   bool indirect;
6723   tree ptrtype = build_pointer_type (type);
6724
6725   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
6726     {
6727       indirect = true;
6728       size = rsize = UNITS_PER_WORD;
6729       align = 0;
6730     }
6731   else
6732     {
6733       indirect = false;
6734       size = int_size_in_bytes (type);
6735       rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
6736       align = 0;
6737
6738       if (TARGET_ARCH64)
6739         {
6740           /* For SPARC64, objects requiring 16-byte alignment get it.  */
6741           if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
6742             align = 2 * UNITS_PER_WORD;
6743
6744           /* SPARC-V9 ABI states that structures up to 16 bytes in size
6745              are left-justified in their slots.  */
6746           if (AGGREGATE_TYPE_P (type))
6747             {
6748               if (size == 0)
6749                 size = rsize = UNITS_PER_WORD;
6750               else
6751                 size = rsize;
6752             }
6753         }
6754     }
6755
6756   incr = valist;
6757   if (align)
6758     {
6759       incr = fold_build_pointer_plus_hwi (incr, align - 1);
6760       incr = fold_convert (sizetype, incr);
6761       incr = fold_build2 (BIT_AND_EXPR, sizetype, incr,
6762                           size_int (-align));
6763       incr = fold_convert (ptr_type_node, incr);
6764     }
6765
6766   gimplify_expr (&incr, pre_p, post_p, is_gimple_val, fb_rvalue);
6767   addr = incr;
6768
6769   if (BYTES_BIG_ENDIAN && size < rsize)
6770     addr = fold_build_pointer_plus_hwi (incr, rsize - size);
6771
6772   if (indirect)
6773     {
6774       addr = fold_convert (build_pointer_type (ptrtype), addr);
6775       addr = build_va_arg_indirect_ref (addr);
6776     }
6777
6778   /* If the address isn't aligned properly for the type, we need a temporary.
6779      FIXME: This is inefficient, usually we can do this in registers.  */
6780   else if (align == 0 && TYPE_ALIGN (type) > BITS_PER_WORD)
6781     {
6782       tree tmp = create_tmp_var (type, "va_arg_tmp");
6783       tree dest_addr = build_fold_addr_expr (tmp);
6784       tree copy = build_call_expr (implicit_built_in_decls[BUILT_IN_MEMCPY],
6785                                    3, dest_addr, addr, size_int (rsize));
6786       TREE_ADDRESSABLE (tmp) = 1;
6787       gimplify_and_add (copy, pre_p);
6788       addr = dest_addr;
6789     }
6790
6791   else
6792     addr = fold_convert (ptrtype, addr);
6793
6794   incr = fold_build_pointer_plus_hwi (incr, rsize);
6795   gimplify_assign (valist, incr, post_p);
6796
6797   return build_va_arg_indirect_ref (addr);
6798 }
6799 \f
6800 /* Implement the TARGET_VECTOR_MODE_SUPPORTED_P target hook.
6801    Specify whether the vector mode is supported by the hardware.  */
6802
6803 static bool
6804 sparc_vector_mode_supported_p (enum machine_mode mode)
6805 {
6806   return TARGET_VIS && VECTOR_MODE_P (mode) ? true : false;
6807 }
6808 \f
6809 /* Implement the TARGET_VECTORIZE_PREFERRED_SIMD_MODE target hook.  */
6810
6811 static enum machine_mode
6812 sparc_preferred_simd_mode (enum machine_mode mode)
6813 {
6814   if (TARGET_VIS)
6815     switch (mode)
6816       {
6817       case SImode:
6818         return V2SImode;
6819       case HImode:
6820         return V4HImode;
6821       case QImode:
6822         return V8QImode;
6823
6824       default:;
6825       }
6826
6827   return word_mode;
6828 }
6829 \f
6830 /* Return the string to output an unconditional branch to LABEL, which is
6831    the operand number of the label.
6832
6833    DEST is the destination insn (i.e. the label), INSN is the source.  */
6834
6835 const char *
6836 output_ubranch (rtx dest, int label, rtx insn)
6837 {
6838   static char string[64];
6839   bool v9_form = false;
6840   char *p;
6841
6842   if (TARGET_V9 && INSN_ADDRESSES_SET_P ())
6843     {
6844       int delta = (INSN_ADDRESSES (INSN_UID (dest))
6845                    - INSN_ADDRESSES (INSN_UID (insn)));
6846       /* Leave some instructions for "slop".  */
6847       if (delta >= -260000 && delta < 260000)
6848         v9_form = true;
6849     }
6850
6851   if (v9_form)
6852     strcpy (string, "ba%*,pt\t%%xcc, ");
6853   else
6854     strcpy (string, "b%*\t");
6855
6856   p = strchr (string, '\0');
6857   *p++ = '%';
6858   *p++ = 'l';
6859   *p++ = '0' + label;
6860   *p++ = '%';
6861   *p++ = '(';
6862   *p = '\0';
6863
6864   return string;
6865 }
6866
6867 /* Return the string to output a conditional branch to LABEL, which is
6868    the operand number of the label.  OP is the conditional expression.
6869    XEXP (OP, 0) is assumed to be a condition code register (integer or
6870    floating point) and its mode specifies what kind of comparison we made.
6871
6872    DEST is the destination insn (i.e. the label), INSN is the source.
6873
6874    REVERSED is nonzero if we should reverse the sense of the comparison.
6875
6876    ANNUL is nonzero if we should generate an annulling branch.  */
6877
6878 const char *
6879 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
6880                 rtx insn)
6881 {
6882   static char string[64];
6883   enum rtx_code code = GET_CODE (op);
6884   rtx cc_reg = XEXP (op, 0);
6885   enum machine_mode mode = GET_MODE (cc_reg);
6886   const char *labelno, *branch;
6887   int spaces = 8, far;
6888   char *p;
6889
6890   /* v9 branches are limited to +-1MB.  If it is too far away,
6891      change
6892
6893      bne,pt %xcc, .LC30
6894
6895      to
6896
6897      be,pn %xcc, .+12
6898       nop
6899      ba .LC30
6900
6901      and
6902
6903      fbne,a,pn %fcc2, .LC29
6904
6905      to
6906
6907      fbe,pt %fcc2, .+16
6908       nop
6909      ba .LC29  */
6910
6911   far = TARGET_V9 && (get_attr_length (insn) >= 3);
6912   if (reversed ^ far)
6913     {
6914       /* Reversal of FP compares takes care -- an ordered compare
6915          becomes an unordered compare and vice versa.  */
6916       if (mode == CCFPmode || mode == CCFPEmode)
6917         code = reverse_condition_maybe_unordered (code);
6918       else
6919         code = reverse_condition (code);
6920     }
6921
6922   /* Start by writing the branch condition.  */
6923   if (mode == CCFPmode || mode == CCFPEmode)
6924     {
6925       switch (code)
6926         {
6927         case NE:
6928           branch = "fbne";
6929           break;
6930         case EQ:
6931           branch = "fbe";
6932           break;
6933         case GE:
6934           branch = "fbge";
6935           break;
6936         case GT:
6937           branch = "fbg";
6938           break;
6939         case LE:
6940           branch = "fble";
6941           break;
6942         case LT:
6943           branch = "fbl";
6944           break;
6945         case UNORDERED:
6946           branch = "fbu";
6947           break;
6948         case ORDERED:
6949           branch = "fbo";
6950           break;
6951         case UNGT:
6952           branch = "fbug";
6953           break;
6954         case UNLT:
6955           branch = "fbul";
6956           break;
6957         case UNEQ:
6958           branch = "fbue";
6959           break;
6960         case UNGE:
6961           branch = "fbuge";
6962           break;
6963         case UNLE:
6964           branch = "fbule";
6965           break;
6966         case LTGT:
6967           branch = "fblg";
6968           break;
6969
6970         default:
6971           gcc_unreachable ();
6972         }
6973
6974       /* ??? !v9: FP branches cannot be preceded by another floating point
6975          insn.  Because there is currently no concept of pre-delay slots,
6976          we can fix this only by always emitting a nop before a floating
6977          point branch.  */
6978
6979       string[0] = '\0';
6980       if (! TARGET_V9)
6981         strcpy (string, "nop\n\t");
6982       strcat (string, branch);
6983     }
6984   else
6985     {
6986       switch (code)
6987         {
6988         case NE:
6989           branch = "bne";
6990           break;
6991         case EQ:
6992           branch = "be";
6993           break;
6994         case GE:
6995           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
6996             branch = "bpos";
6997           else
6998             branch = "bge";
6999           break;
7000         case GT:
7001           branch = "bg";
7002           break;
7003         case LE:
7004           branch = "ble";
7005           break;
7006         case LT:
7007           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
7008             branch = "bneg";
7009           else
7010             branch = "bl";
7011           break;
7012         case GEU:
7013           branch = "bgeu";
7014           break;
7015         case GTU:
7016           branch = "bgu";
7017           break;
7018         case LEU:
7019           branch = "bleu";
7020           break;
7021         case LTU:
7022           branch = "blu";
7023           break;
7024
7025         default:
7026           gcc_unreachable ();
7027         }
7028       strcpy (string, branch);
7029     }
7030   spaces -= strlen (branch);
7031   p = strchr (string, '\0');
7032
7033   /* Now add the annulling, the label, and a possible noop.  */
7034   if (annul && ! far)
7035     {
7036       strcpy (p, ",a");
7037       p += 2;
7038       spaces -= 2;
7039     }
7040
7041   if (TARGET_V9)
7042     {
7043       rtx note;
7044       int v8 = 0;
7045
7046       if (! far && insn && INSN_ADDRESSES_SET_P ())
7047         {
7048           int delta = (INSN_ADDRESSES (INSN_UID (dest))
7049                        - INSN_ADDRESSES (INSN_UID (insn)));
7050           /* Leave some instructions for "slop".  */
7051           if (delta < -260000 || delta >= 260000)
7052             v8 = 1;
7053         }
7054
7055       if (mode == CCFPmode || mode == CCFPEmode)
7056         {
7057           static char v9_fcc_labelno[] = "%%fccX, ";
7058           /* Set the char indicating the number of the fcc reg to use.  */
7059           v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
7060           labelno = v9_fcc_labelno;
7061           if (v8)
7062             {
7063               gcc_assert (REGNO (cc_reg) == SPARC_FCC_REG);
7064               labelno = "";
7065             }
7066         }
7067       else if (mode == CCXmode || mode == CCX_NOOVmode)
7068         {
7069           labelno = "%%xcc, ";
7070           gcc_assert (! v8);
7071         }
7072       else
7073         {
7074           labelno = "%%icc, ";
7075           if (v8)
7076             labelno = "";
7077         }
7078
7079       if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7080         {
7081           strcpy (p,
7082                   ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7083                   ? ",pt" : ",pn");
7084           p += 3;
7085           spaces -= 3;
7086         }
7087     }
7088   else
7089     labelno = "";
7090
7091   if (spaces > 0)
7092     *p++ = '\t';
7093   else
7094     *p++ = ' ';
7095   strcpy (p, labelno);
7096   p = strchr (p, '\0');
7097   if (far)
7098     {
7099       strcpy (p, ".+12\n\t nop\n\tb\t");
7100       /* Skip the next insn if requested or
7101          if we know that it will be a nop.  */
7102       if (annul || ! final_sequence)
7103         p[3] = '6';
7104       p += 14;
7105     }
7106   *p++ = '%';
7107   *p++ = 'l';
7108   *p++ = label + '0';
7109   *p++ = '%';
7110   *p++ = '#';
7111   *p = '\0';
7112
7113   return string;
7114 }
7115
7116 /* Emit a library call comparison between floating point X and Y.
7117    COMPARISON is the operator to compare with (EQ, NE, GT, etc).
7118    Return the new operator to be used in the comparison sequence.
7119
7120    TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
7121    values as arguments instead of the TFmode registers themselves,
7122    that's why we cannot call emit_float_lib_cmp.  */
7123
7124 rtx
7125 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
7126 {
7127   const char *qpfunc;
7128   rtx slot0, slot1, result, tem, tem2, libfunc;
7129   enum machine_mode mode;
7130   enum rtx_code new_comparison;
7131
7132   switch (comparison)
7133     {
7134     case EQ:
7135       qpfunc = (TARGET_ARCH64 ? "_Qp_feq" : "_Q_feq");
7136       break;
7137
7138     case NE:
7139       qpfunc = (TARGET_ARCH64 ? "_Qp_fne" : "_Q_fne");
7140       break;
7141
7142     case GT:
7143       qpfunc = (TARGET_ARCH64 ? "_Qp_fgt" : "_Q_fgt");
7144       break;
7145
7146     case GE:
7147       qpfunc = (TARGET_ARCH64 ? "_Qp_fge" : "_Q_fge");
7148       break;
7149
7150     case LT:
7151       qpfunc = (TARGET_ARCH64 ? "_Qp_flt" : "_Q_flt");
7152       break;
7153
7154     case LE:
7155       qpfunc = (TARGET_ARCH64 ? "_Qp_fle" : "_Q_fle");
7156       break;
7157
7158     case ORDERED:
7159     case UNORDERED:
7160     case UNGT:
7161     case UNLT:
7162     case UNEQ:
7163     case UNGE:
7164     case UNLE:
7165     case LTGT:
7166       qpfunc = (TARGET_ARCH64 ? "_Qp_cmp" : "_Q_cmp");
7167       break;
7168
7169     default:
7170       gcc_unreachable ();
7171     }
7172
7173   if (TARGET_ARCH64)
7174     {
7175       if (MEM_P (x))
7176         slot0 = x;
7177       else
7178         {
7179           slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7180           emit_move_insn (slot0, x);
7181         }
7182
7183       if (MEM_P (y))
7184         slot1 = y;
7185       else
7186         {
7187           slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7188           emit_move_insn (slot1, y);
7189         }
7190
7191       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7192       emit_library_call (libfunc, LCT_NORMAL,
7193                          DImode, 2,
7194                          XEXP (slot0, 0), Pmode,
7195                          XEXP (slot1, 0), Pmode);
7196       mode = DImode;
7197     }
7198   else
7199     {
7200       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7201       emit_library_call (libfunc, LCT_NORMAL,
7202                          SImode, 2,
7203                          x, TFmode, y, TFmode);
7204       mode = SImode;
7205     }
7206
7207
7208   /* Immediately move the result of the libcall into a pseudo
7209      register so reload doesn't clobber the value if it needs
7210      the return register for a spill reg.  */
7211   result = gen_reg_rtx (mode);
7212   emit_move_insn (result, hard_libcall_value (mode, libfunc));
7213
7214   switch (comparison)
7215     {
7216     default:
7217       return gen_rtx_NE (VOIDmode, result, const0_rtx);
7218     case ORDERED:
7219     case UNORDERED:
7220       new_comparison = (comparison == UNORDERED ? EQ : NE);
7221       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, GEN_INT(3));
7222     case UNGT:
7223     case UNGE:
7224       new_comparison = (comparison == UNGT ? GT : NE);
7225       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, const1_rtx);
7226     case UNLE:
7227       return gen_rtx_NE (VOIDmode, result, const2_rtx);
7228     case UNLT:
7229       tem = gen_reg_rtx (mode);
7230       if (TARGET_ARCH32)
7231         emit_insn (gen_andsi3 (tem, result, const1_rtx));
7232       else
7233         emit_insn (gen_anddi3 (tem, result, const1_rtx));
7234       return gen_rtx_NE (VOIDmode, tem, const0_rtx);
7235     case UNEQ:
7236     case LTGT:
7237       tem = gen_reg_rtx (mode);
7238       if (TARGET_ARCH32)
7239         emit_insn (gen_addsi3 (tem, result, const1_rtx));
7240       else
7241         emit_insn (gen_adddi3 (tem, result, const1_rtx));
7242       tem2 = gen_reg_rtx (mode);
7243       if (TARGET_ARCH32)
7244         emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
7245       else
7246         emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
7247       new_comparison = (comparison == UNEQ ? EQ : NE);
7248       return gen_rtx_fmt_ee (new_comparison, VOIDmode, tem2, const0_rtx);
7249     }
7250
7251   gcc_unreachable ();
7252 }
7253
7254 /* Generate an unsigned DImode to FP conversion.  This is the same code
7255    optabs would emit if we didn't have TFmode patterns.  */
7256
7257 void
7258 sparc_emit_floatunsdi (rtx *operands, enum machine_mode mode)
7259 {
7260   rtx neglab, donelab, i0, i1, f0, in, out;
7261
7262   out = operands[0];
7263   in = force_reg (DImode, operands[1]);
7264   neglab = gen_label_rtx ();
7265   donelab = gen_label_rtx ();
7266   i0 = gen_reg_rtx (DImode);
7267   i1 = gen_reg_rtx (DImode);
7268   f0 = gen_reg_rtx (mode);
7269
7270   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
7271
7272   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
7273   emit_jump_insn (gen_jump (donelab));
7274   emit_barrier ();
7275
7276   emit_label (neglab);
7277
7278   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
7279   emit_insn (gen_anddi3 (i1, in, const1_rtx));
7280   emit_insn (gen_iordi3 (i0, i0, i1));
7281   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
7282   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
7283
7284   emit_label (donelab);
7285 }
7286
7287 /* Generate an FP to unsigned DImode conversion.  This is the same code
7288    optabs would emit if we didn't have TFmode patterns.  */
7289
7290 void
7291 sparc_emit_fixunsdi (rtx *operands, enum machine_mode mode)
7292 {
7293   rtx neglab, donelab, i0, i1, f0, in, out, limit;
7294
7295   out = operands[0];
7296   in = force_reg (mode, operands[1]);
7297   neglab = gen_label_rtx ();
7298   donelab = gen_label_rtx ();
7299   i0 = gen_reg_rtx (DImode);
7300   i1 = gen_reg_rtx (DImode);
7301   limit = gen_reg_rtx (mode);
7302   f0 = gen_reg_rtx (mode);
7303
7304   emit_move_insn (limit,
7305                   CONST_DOUBLE_FROM_REAL_VALUE (
7306                     REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
7307   emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
7308
7309   emit_insn (gen_rtx_SET (VOIDmode,
7310                           out,
7311                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
7312   emit_jump_insn (gen_jump (donelab));
7313   emit_barrier ();
7314
7315   emit_label (neglab);
7316
7317   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
7318   emit_insn (gen_rtx_SET (VOIDmode,
7319                           i0,
7320                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
7321   emit_insn (gen_movdi (i1, const1_rtx));
7322   emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
7323   emit_insn (gen_xordi3 (out, i0, i1));
7324
7325   emit_label (donelab);
7326 }
7327
7328 /* Return the string to output a conditional branch to LABEL, testing
7329    register REG.  LABEL is the operand number of the label; REG is the
7330    operand number of the reg.  OP is the conditional expression.  The mode
7331    of REG says what kind of comparison we made.
7332
7333    DEST is the destination insn (i.e. the label), INSN is the source.
7334
7335    REVERSED is nonzero if we should reverse the sense of the comparison.
7336
7337    ANNUL is nonzero if we should generate an annulling branch.  */
7338
7339 const char *
7340 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
7341                  int annul, rtx insn)
7342 {
7343   static char string[64];
7344   enum rtx_code code = GET_CODE (op);
7345   enum machine_mode mode = GET_MODE (XEXP (op, 0));
7346   rtx note;
7347   int far;
7348   char *p;
7349
7350   /* branch on register are limited to +-128KB.  If it is too far away,
7351      change
7352
7353      brnz,pt %g1, .LC30
7354
7355      to
7356
7357      brz,pn %g1, .+12
7358       nop
7359      ba,pt %xcc, .LC30
7360
7361      and
7362
7363      brgez,a,pn %o1, .LC29
7364
7365      to
7366
7367      brlz,pt %o1, .+16
7368       nop
7369      ba,pt %xcc, .LC29  */
7370
7371   far = get_attr_length (insn) >= 3;
7372
7373   /* If not floating-point or if EQ or NE, we can just reverse the code.  */
7374   if (reversed ^ far)
7375     code = reverse_condition (code);
7376
7377   /* Only 64 bit versions of these instructions exist.  */
7378   gcc_assert (mode == DImode);
7379
7380   /* Start by writing the branch condition.  */
7381
7382   switch (code)
7383     {
7384     case NE:
7385       strcpy (string, "brnz");
7386       break;
7387
7388     case EQ:
7389       strcpy (string, "brz");
7390       break;
7391
7392     case GE:
7393       strcpy (string, "brgez");
7394       break;
7395
7396     case LT:
7397       strcpy (string, "brlz");
7398       break;
7399
7400     case LE:
7401       strcpy (string, "brlez");
7402       break;
7403
7404     case GT:
7405       strcpy (string, "brgz");
7406       break;
7407
7408     default:
7409       gcc_unreachable ();
7410     }
7411
7412   p = strchr (string, '\0');
7413
7414   /* Now add the annulling, reg, label, and nop.  */
7415   if (annul && ! far)
7416     {
7417       strcpy (p, ",a");
7418       p += 2;
7419     }
7420
7421   if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7422     {
7423       strcpy (p,
7424               ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7425               ? ",pt" : ",pn");
7426       p += 3;
7427     }
7428
7429   *p = p < string + 8 ? '\t' : ' ';
7430   p++;
7431   *p++ = '%';
7432   *p++ = '0' + reg;
7433   *p++ = ',';
7434   *p++ = ' ';
7435   if (far)
7436     {
7437       int veryfar = 1, delta;
7438
7439       if (INSN_ADDRESSES_SET_P ())
7440         {
7441           delta = (INSN_ADDRESSES (INSN_UID (dest))
7442                    - INSN_ADDRESSES (INSN_UID (insn)));
7443           /* Leave some instructions for "slop".  */
7444           if (delta >= -260000 && delta < 260000)
7445             veryfar = 0;
7446         }
7447
7448       strcpy (p, ".+12\n\t nop\n\t");
7449       /* Skip the next insn if requested or
7450          if we know that it will be a nop.  */
7451       if (annul || ! final_sequence)
7452         p[3] = '6';
7453       p += 12;
7454       if (veryfar)
7455         {
7456           strcpy (p, "b\t");
7457           p += 2;
7458         }
7459       else
7460         {
7461           strcpy (p, "ba,pt\t%%xcc, ");
7462           p += 13;
7463         }
7464     }
7465   *p++ = '%';
7466   *p++ = 'l';
7467   *p++ = '0' + label;
7468   *p++ = '%';
7469   *p++ = '#';
7470   *p = '\0';
7471
7472   return string;
7473 }
7474
7475 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
7476    Such instructions cannot be used in the delay slot of return insn on v9.
7477    If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
7478  */
7479
7480 static int
7481 epilogue_renumber (register rtx *where, int test)
7482 {
7483   register const char *fmt;
7484   register int i;
7485   register enum rtx_code code;
7486
7487   if (*where == 0)
7488     return 0;
7489
7490   code = GET_CODE (*where);
7491
7492   switch (code)
7493     {
7494     case REG:
7495       if (REGNO (*where) >= 8 && REGNO (*where) < 24)      /* oX or lX */
7496         return 1;
7497       if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
7498         *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
7499     case SCRATCH:
7500     case CC0:
7501     case PC:
7502     case CONST_INT:
7503     case CONST_DOUBLE:
7504       return 0;
7505
7506       /* Do not replace the frame pointer with the stack pointer because
7507          it can cause the delayed instruction to load below the stack.
7508          This occurs when instructions like:
7509
7510          (set (reg/i:SI 24 %i0)
7511              (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
7512                        (const_int -20 [0xffffffec])) 0))
7513
7514          are in the return delayed slot.  */
7515     case PLUS:
7516       if (GET_CODE (XEXP (*where, 0)) == REG
7517           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
7518           && (GET_CODE (XEXP (*where, 1)) != CONST_INT
7519               || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
7520         return 1;
7521       break;
7522
7523     case MEM:
7524       if (SPARC_STACK_BIAS
7525           && GET_CODE (XEXP (*where, 0)) == REG
7526           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
7527         return 1;
7528       break;
7529
7530     default:
7531       break;
7532     }
7533
7534   fmt = GET_RTX_FORMAT (code);
7535
7536   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7537     {
7538       if (fmt[i] == 'E')
7539         {
7540           register int j;
7541           for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
7542             if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
7543               return 1;
7544         }
7545       else if (fmt[i] == 'e'
7546                && epilogue_renumber (&(XEXP (*where, i)), test))
7547         return 1;
7548     }
7549   return 0;
7550 }
7551 \f
7552 /* Leaf functions and non-leaf functions have different needs.  */
7553
7554 static const int
7555 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
7556
7557 static const int
7558 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
7559
7560 static const int *const reg_alloc_orders[] = {
7561   reg_leaf_alloc_order,
7562   reg_nonleaf_alloc_order};
7563
7564 void
7565 order_regs_for_local_alloc (void)
7566 {
7567   static int last_order_nonleaf = 1;
7568
7569   if (df_regs_ever_live_p (15) != last_order_nonleaf)
7570     {
7571       last_order_nonleaf = !last_order_nonleaf;
7572       memcpy ((char *) reg_alloc_order,
7573               (const char *) reg_alloc_orders[last_order_nonleaf],
7574               FIRST_PSEUDO_REGISTER * sizeof (int));
7575     }
7576 }
7577 \f
7578 /* Return 1 if REG and MEM are legitimate enough to allow the various
7579    mem<-->reg splits to be run.  */
7580
7581 int
7582 sparc_splitdi_legitimate (rtx reg, rtx mem)
7583 {
7584   /* Punt if we are here by mistake.  */
7585   gcc_assert (reload_completed);
7586
7587   /* We must have an offsettable memory reference.  */
7588   if (! offsettable_memref_p (mem))
7589     return 0;
7590
7591   /* If we have legitimate args for ldd/std, we do not want
7592      the split to happen.  */
7593   if ((REGNO (reg) % 2) == 0
7594       && mem_min_alignment (mem, 8))
7595     return 0;
7596
7597   /* Success.  */
7598   return 1;
7599 }
7600
7601 /* Return 1 if x and y are some kind of REG and they refer to
7602    different hard registers.  This test is guaranteed to be
7603    run after reload.  */
7604
7605 int
7606 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
7607 {
7608   if (GET_CODE (x) != REG)
7609     return 0;
7610   if (GET_CODE (y) != REG)
7611     return 0;
7612   if (REGNO (x) == REGNO (y))
7613     return 0;
7614   return 1;
7615 }
7616
7617 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
7618    This makes them candidates for using ldd and std insns.
7619
7620    Note reg1 and reg2 *must* be hard registers.  */
7621
7622 int
7623 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
7624 {
7625   /* We might have been passed a SUBREG.  */
7626   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
7627     return 0;
7628
7629   if (REGNO (reg1) % 2 != 0)
7630     return 0;
7631
7632   /* Integer ldd is deprecated in SPARC V9 */
7633   if (TARGET_V9 && REGNO (reg1) < 32)
7634     return 0;
7635
7636   return (REGNO (reg1) == REGNO (reg2) - 1);
7637 }
7638
7639 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
7640    an ldd or std insn.
7641
7642    This can only happen when addr1 and addr2, the addresses in mem1
7643    and mem2, are consecutive memory locations (addr1 + 4 == addr2).
7644    addr1 must also be aligned on a 64-bit boundary.
7645
7646    Also iff dependent_reg_rtx is not null it should not be used to
7647    compute the address for mem1, i.e. we cannot optimize a sequence
7648    like:
7649         ld [%o0], %o0
7650         ld [%o0 + 4], %o1
7651    to
7652         ldd [%o0], %o0
7653    nor:
7654         ld [%g3 + 4], %g3
7655         ld [%g3], %g2
7656    to
7657         ldd [%g3], %g2
7658
7659    But, note that the transformation from:
7660         ld [%g2 + 4], %g3
7661         ld [%g2], %g2
7662    to
7663         ldd [%g2], %g2
7664    is perfectly fine.  Thus, the peephole2 patterns always pass us
7665    the destination register of the first load, never the second one.
7666
7667    For stores we don't have a similar problem, so dependent_reg_rtx is
7668    NULL_RTX.  */
7669
7670 int
7671 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
7672 {
7673   rtx addr1, addr2;
7674   unsigned int reg1;
7675   HOST_WIDE_INT offset1;
7676
7677   /* The mems cannot be volatile.  */
7678   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
7679     return 0;
7680
7681   /* MEM1 should be aligned on a 64-bit boundary.  */
7682   if (MEM_ALIGN (mem1) < 64)
7683     return 0;
7684
7685   addr1 = XEXP (mem1, 0);
7686   addr2 = XEXP (mem2, 0);
7687
7688   /* Extract a register number and offset (if used) from the first addr.  */
7689   if (GET_CODE (addr1) == PLUS)
7690     {
7691       /* If not a REG, return zero.  */
7692       if (GET_CODE (XEXP (addr1, 0)) != REG)
7693         return 0;
7694       else
7695         {
7696           reg1 = REGNO (XEXP (addr1, 0));
7697           /* The offset must be constant!  */
7698           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
7699             return 0;
7700           offset1 = INTVAL (XEXP (addr1, 1));
7701         }
7702     }
7703   else if (GET_CODE (addr1) != REG)
7704     return 0;
7705   else
7706     {
7707       reg1 = REGNO (addr1);
7708       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
7709       offset1 = 0;
7710     }
7711
7712   /* Make sure the second address is a (mem (plus (reg) (const_int).  */
7713   if (GET_CODE (addr2) != PLUS)
7714     return 0;
7715
7716   if (GET_CODE (XEXP (addr2, 0)) != REG
7717       || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
7718     return 0;
7719
7720   if (reg1 != REGNO (XEXP (addr2, 0)))
7721     return 0;
7722
7723   if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
7724     return 0;
7725
7726   /* The first offset must be evenly divisible by 8 to ensure the
7727      address is 64 bit aligned.  */
7728   if (offset1 % 8 != 0)
7729     return 0;
7730
7731   /* The offset for the second addr must be 4 more than the first addr.  */
7732   if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
7733     return 0;
7734
7735   /* All the tests passed.  addr1 and addr2 are valid for ldd and std
7736      instructions.  */
7737   return 1;
7738 }
7739
7740 /* Return 1 if reg is a pseudo, or is the first register in
7741    a hard register pair.  This makes it suitable for use in
7742    ldd and std insns.  */
7743
7744 int
7745 register_ok_for_ldd (rtx reg)
7746 {
7747   /* We might have been passed a SUBREG.  */
7748   if (!REG_P (reg))
7749     return 0;
7750
7751   if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
7752     return (REGNO (reg) % 2 == 0);
7753
7754   return 1;
7755 }
7756
7757 /* Return 1 if OP is a memory whose address is known to be
7758    aligned to 8-byte boundary, or a pseudo during reload.
7759    This makes it suitable for use in ldd and std insns.  */
7760
7761 int
7762 memory_ok_for_ldd (rtx op)
7763 {
7764   if (MEM_P (op))
7765     {
7766       /* In 64-bit mode, we assume that the address is word-aligned.  */
7767       if (TARGET_ARCH32 && !mem_min_alignment (op, 8))
7768         return 0;
7769
7770       if ((reload_in_progress || reload_completed)
7771           && !strict_memory_address_p (Pmode, XEXP (op, 0)))
7772         return 0;
7773     }
7774   else if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
7775     {
7776       if (!(reload_in_progress && reg_renumber [REGNO (op)] < 0))
7777         return 0;
7778     }
7779   else
7780     return 0;
7781
7782   return 1;
7783 }
7784 \f
7785 /* Implement TARGET_PRINT_OPERAND_PUNCT_VALID_P.  */
7786
7787 static bool
7788 sparc_print_operand_punct_valid_p (unsigned char code)
7789 {
7790   if (code == '#'
7791       || code == '*'
7792       || code == '('
7793       || code == ')'
7794       || code == '_'
7795       || code == '&')
7796     return true;
7797
7798   return false;
7799 }
7800
7801 /* Implement TARGET_PRINT_OPERAND.
7802    Print operand X (an rtx) in assembler syntax to file FILE.
7803    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
7804    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
7805
7806 static void
7807 sparc_print_operand (FILE *file, rtx x, int code)
7808 {
7809   switch (code)
7810     {
7811     case '#':
7812       /* Output an insn in a delay slot.  */
7813       if (final_sequence)
7814         sparc_indent_opcode = 1;
7815       else
7816         fputs ("\n\t nop", file);
7817       return;
7818     case '*':
7819       /* Output an annul flag if there's nothing for the delay slot and we
7820          are optimizing.  This is always used with '(' below.
7821          Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
7822          this is a dbx bug.  So, we only do this when optimizing.
7823          On UltraSPARC, a branch in a delay slot causes a pipeline flush.
7824          Always emit a nop in case the next instruction is a branch.  */
7825       if (! final_sequence && (optimize && (int)sparc_cpu < PROCESSOR_V9))
7826         fputs (",a", file);
7827       return;
7828     case '(':
7829       /* Output a 'nop' if there's nothing for the delay slot and we are
7830          not optimizing.  This is always used with '*' above.  */
7831       if (! final_sequence && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
7832         fputs ("\n\t nop", file);
7833       else if (final_sequence)
7834         sparc_indent_opcode = 1;
7835       return;
7836     case ')':
7837       /* Output the right displacement from the saved PC on function return.
7838          The caller may have placed an "unimp" insn immediately after the call
7839          so we have to account for it.  This insn is used in the 32-bit ABI
7840          when calling a function that returns a non zero-sized structure.  The
7841          64-bit ABI doesn't have it.  Be careful to have this test be the same
7842          as that for the call.  The exception is when sparc_std_struct_return
7843          is enabled, the psABI is followed exactly and the adjustment is made
7844          by the code in sparc_struct_value_rtx.  The call emitted is the same
7845          when sparc_std_struct_return is enabled. */
7846      if (!TARGET_ARCH64
7847          && cfun->returns_struct
7848          && !sparc_std_struct_return
7849          && DECL_SIZE (DECL_RESULT (current_function_decl))
7850          && TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))
7851              == INTEGER_CST
7852          && !integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl))))
7853         fputs ("12", file);
7854       else
7855         fputc ('8', file);
7856       return;
7857     case '_':
7858       /* Output the Embedded Medium/Anywhere code model base register.  */
7859       fputs (EMBMEDANY_BASE_REG, file);
7860       return;
7861     case '&':
7862       /* Print some local dynamic TLS name.  */
7863       assemble_name (file, get_some_local_dynamic_name ());
7864       return;
7865
7866     case 'Y':
7867       /* Adjust the operand to take into account a RESTORE operation.  */
7868       if (GET_CODE (x) == CONST_INT)
7869         break;
7870       else if (GET_CODE (x) != REG)
7871         output_operand_lossage ("invalid %%Y operand");
7872       else if (REGNO (x) < 8)
7873         fputs (reg_names[REGNO (x)], file);
7874       else if (REGNO (x) >= 24 && REGNO (x) < 32)
7875         fputs (reg_names[REGNO (x)-16], file);
7876       else
7877         output_operand_lossage ("invalid %%Y operand");
7878       return;
7879     case 'L':
7880       /* Print out the low order register name of a register pair.  */
7881       if (WORDS_BIG_ENDIAN)
7882         fputs (reg_names[REGNO (x)+1], file);
7883       else
7884         fputs (reg_names[REGNO (x)], file);
7885       return;
7886     case 'H':
7887       /* Print out the high order register name of a register pair.  */
7888       if (WORDS_BIG_ENDIAN)
7889         fputs (reg_names[REGNO (x)], file);
7890       else
7891         fputs (reg_names[REGNO (x)+1], file);
7892       return;
7893     case 'R':
7894       /* Print out the second register name of a register pair or quad.
7895          I.e., R (%o0) => %o1.  */
7896       fputs (reg_names[REGNO (x)+1], file);
7897       return;
7898     case 'S':
7899       /* Print out the third register name of a register quad.
7900          I.e., S (%o0) => %o2.  */
7901       fputs (reg_names[REGNO (x)+2], file);
7902       return;
7903     case 'T':
7904       /* Print out the fourth register name of a register quad.
7905          I.e., T (%o0) => %o3.  */
7906       fputs (reg_names[REGNO (x)+3], file);
7907       return;
7908     case 'x':
7909       /* Print a condition code register.  */
7910       if (REGNO (x) == SPARC_ICC_REG)
7911         {
7912           /* We don't handle CC[X]_NOOVmode because they're not supposed
7913              to occur here.  */
7914           if (GET_MODE (x) == CCmode)
7915             fputs ("%icc", file);
7916           else if (GET_MODE (x) == CCXmode)
7917             fputs ("%xcc", file);
7918           else
7919             gcc_unreachable ();
7920         }
7921       else
7922         /* %fccN register */
7923         fputs (reg_names[REGNO (x)], file);
7924       return;
7925     case 'm':
7926       /* Print the operand's address only.  */
7927       output_address (XEXP (x, 0));
7928       return;
7929     case 'r':
7930       /* In this case we need a register.  Use %g0 if the
7931          operand is const0_rtx.  */
7932       if (x == const0_rtx
7933           || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
7934         {
7935           fputs ("%g0", file);
7936           return;
7937         }
7938       else
7939         break;
7940
7941     case 'A':
7942       switch (GET_CODE (x))
7943         {
7944         case IOR: fputs ("or", file); break;
7945         case AND: fputs ("and", file); break;
7946         case XOR: fputs ("xor", file); break;
7947         default: output_operand_lossage ("invalid %%A operand");
7948         }
7949       return;
7950
7951     case 'B':
7952       switch (GET_CODE (x))
7953         {
7954         case IOR: fputs ("orn", file); break;
7955         case AND: fputs ("andn", file); break;
7956         case XOR: fputs ("xnor", file); break;
7957         default: output_operand_lossage ("invalid %%B operand");
7958         }
7959       return;
7960
7961       /* These are used by the conditional move instructions.  */
7962     case 'c' :
7963     case 'C':
7964       {
7965         enum rtx_code rc = GET_CODE (x);
7966
7967         if (code == 'c')
7968           {
7969             enum machine_mode mode = GET_MODE (XEXP (x, 0));
7970             if (mode == CCFPmode || mode == CCFPEmode)
7971               rc = reverse_condition_maybe_unordered (GET_CODE (x));
7972             else
7973               rc = reverse_condition (GET_CODE (x));
7974           }
7975         switch (rc)
7976           {
7977           case NE: fputs ("ne", file); break;
7978           case EQ: fputs ("e", file); break;
7979           case GE: fputs ("ge", file); break;
7980           case GT: fputs ("g", file); break;
7981           case LE: fputs ("le", file); break;
7982           case LT: fputs ("l", file); break;
7983           case GEU: fputs ("geu", file); break;
7984           case GTU: fputs ("gu", file); break;
7985           case LEU: fputs ("leu", file); break;
7986           case LTU: fputs ("lu", file); break;
7987           case LTGT: fputs ("lg", file); break;
7988           case UNORDERED: fputs ("u", file); break;
7989           case ORDERED: fputs ("o", file); break;
7990           case UNLT: fputs ("ul", file); break;
7991           case UNLE: fputs ("ule", file); break;
7992           case UNGT: fputs ("ug", file); break;
7993           case UNGE: fputs ("uge", file); break;
7994           case UNEQ: fputs ("ue", file); break;
7995           default: output_operand_lossage (code == 'c'
7996                                            ? "invalid %%c operand"
7997                                            : "invalid %%C operand");
7998           }
7999         return;
8000       }
8001
8002       /* These are used by the movr instruction pattern.  */
8003     case 'd':
8004     case 'D':
8005       {
8006         enum rtx_code rc = (code == 'd'
8007                             ? reverse_condition (GET_CODE (x))
8008                             : GET_CODE (x));
8009         switch (rc)
8010           {
8011           case NE: fputs ("ne", file); break;
8012           case EQ: fputs ("e", file); break;
8013           case GE: fputs ("gez", file); break;
8014           case LT: fputs ("lz", file); break;
8015           case LE: fputs ("lez", file); break;
8016           case GT: fputs ("gz", file); break;
8017           default: output_operand_lossage (code == 'd'
8018                                            ? "invalid %%d operand"
8019                                            : "invalid %%D operand");
8020           }
8021         return;
8022       }
8023
8024     case 'b':
8025       {
8026         /* Print a sign-extended character.  */
8027         int i = trunc_int_for_mode (INTVAL (x), QImode);
8028         fprintf (file, "%d", i);
8029         return;
8030       }
8031
8032     case 'f':
8033       /* Operand must be a MEM; write its address.  */
8034       if (GET_CODE (x) != MEM)
8035         output_operand_lossage ("invalid %%f operand");
8036       output_address (XEXP (x, 0));
8037       return;
8038
8039     case 's':
8040       {
8041         /* Print a sign-extended 32-bit value.  */
8042         HOST_WIDE_INT i;
8043         if (GET_CODE(x) == CONST_INT)
8044           i = INTVAL (x);
8045         else if (GET_CODE(x) == CONST_DOUBLE)
8046           i = CONST_DOUBLE_LOW (x);
8047         else
8048           {
8049             output_operand_lossage ("invalid %%s operand");
8050             return;
8051           }
8052         i = trunc_int_for_mode (i, SImode);
8053         fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
8054         return;
8055       }
8056
8057     case 0:
8058       /* Do nothing special.  */
8059       break;
8060
8061     default:
8062       /* Undocumented flag.  */
8063       output_operand_lossage ("invalid operand output code");
8064     }
8065
8066   if (GET_CODE (x) == REG)
8067     fputs (reg_names[REGNO (x)], file);
8068   else if (GET_CODE (x) == MEM)
8069     {
8070       fputc ('[', file);
8071         /* Poor Sun assembler doesn't understand absolute addressing.  */
8072       if (CONSTANT_P (XEXP (x, 0)))
8073         fputs ("%g0+", file);
8074       output_address (XEXP (x, 0));
8075       fputc (']', file);
8076     }
8077   else if (GET_CODE (x) == HIGH)
8078     {
8079       fputs ("%hi(", file);
8080       output_addr_const (file, XEXP (x, 0));
8081       fputc (')', file);
8082     }
8083   else if (GET_CODE (x) == LO_SUM)
8084     {
8085       sparc_print_operand (file, XEXP (x, 0), 0);
8086       if (TARGET_CM_MEDMID)
8087         fputs ("+%l44(", file);
8088       else
8089         fputs ("+%lo(", file);
8090       output_addr_const (file, XEXP (x, 1));
8091       fputc (')', file);
8092     }
8093   else if (GET_CODE (x) == CONST_DOUBLE
8094            && (GET_MODE (x) == VOIDmode
8095                || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
8096     {
8097       if (CONST_DOUBLE_HIGH (x) == 0)
8098         fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
8099       else if (CONST_DOUBLE_HIGH (x) == -1
8100                && CONST_DOUBLE_LOW (x) < 0)
8101         fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
8102       else
8103         output_operand_lossage ("long long constant not a valid immediate operand");
8104     }
8105   else if (GET_CODE (x) == CONST_DOUBLE)
8106     output_operand_lossage ("floating point constant not a valid immediate operand");
8107   else { output_addr_const (file, x); }
8108 }
8109
8110 /* Implement TARGET_PRINT_OPERAND_ADDRESS.  */
8111
8112 static void
8113 sparc_print_operand_address (FILE *file, rtx x)
8114 {
8115   register rtx base, index = 0;
8116   int offset = 0;
8117   register rtx addr = x;
8118
8119   if (REG_P (addr))
8120     fputs (reg_names[REGNO (addr)], file);
8121   else if (GET_CODE (addr) == PLUS)
8122     {
8123       if (CONST_INT_P (XEXP (addr, 0)))
8124         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);
8125       else if (CONST_INT_P (XEXP (addr, 1)))
8126         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);
8127       else
8128         base = XEXP (addr, 0), index = XEXP (addr, 1);
8129       if (GET_CODE (base) == LO_SUM)
8130         {
8131           gcc_assert (USE_AS_OFFSETABLE_LO10
8132                       && TARGET_ARCH64
8133                       && ! TARGET_CM_MEDMID);
8134           output_operand (XEXP (base, 0), 0);
8135           fputs ("+%lo(", file);
8136           output_address (XEXP (base, 1));
8137           fprintf (file, ")+%d", offset);
8138         }
8139       else
8140         {
8141           fputs (reg_names[REGNO (base)], file);
8142           if (index == 0)
8143             fprintf (file, "%+d", offset);
8144           else if (REG_P (index))
8145             fprintf (file, "+%s", reg_names[REGNO (index)]);
8146           else if (GET_CODE (index) == SYMBOL_REF
8147                    || GET_CODE (index) == LABEL_REF
8148                    || GET_CODE (index) == CONST)
8149             fputc ('+', file), output_addr_const (file, index);
8150           else gcc_unreachable ();
8151         }
8152     }
8153   else if (GET_CODE (addr) == MINUS
8154            && GET_CODE (XEXP (addr, 1)) == LABEL_REF)
8155     {
8156       output_addr_const (file, XEXP (addr, 0));
8157       fputs ("-(", file);
8158       output_addr_const (file, XEXP (addr, 1));
8159       fputs ("-.)", file);
8160     }
8161   else if (GET_CODE (addr) == LO_SUM)
8162     {
8163       output_operand (XEXP (addr, 0), 0);
8164       if (TARGET_CM_MEDMID)
8165         fputs ("+%l44(", file);
8166       else
8167         fputs ("+%lo(", file);
8168       output_address (XEXP (addr, 1));
8169       fputc (')', file);
8170     }
8171   else if (flag_pic
8172            && GET_CODE (addr) == CONST
8173            && GET_CODE (XEXP (addr, 0)) == MINUS
8174            && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST
8175            && GET_CODE (XEXP (XEXP (XEXP (addr, 0), 1), 0)) == MINUS
8176            && XEXP (XEXP (XEXP (XEXP (addr, 0), 1), 0), 1) == pc_rtx)
8177     {
8178       addr = XEXP (addr, 0);
8179       output_addr_const (file, XEXP (addr, 0));
8180       /* Group the args of the second CONST in parenthesis.  */
8181       fputs ("-(", file);
8182       /* Skip past the second CONST--it does nothing for us.  */
8183       output_addr_const (file, XEXP (XEXP (addr, 1), 0));
8184       /* Close the parenthesis.  */
8185       fputc (')', file);
8186     }
8187   else
8188     {
8189       output_addr_const (file, addr);
8190     }
8191 }
8192 \f
8193 /* Target hook for assembling integer objects.  The sparc version has
8194    special handling for aligned DI-mode objects.  */
8195
8196 static bool
8197 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
8198 {
8199   /* ??? We only output .xword's for symbols and only then in environments
8200      where the assembler can handle them.  */
8201   if (aligned_p && size == 8
8202       && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
8203     {
8204       if (TARGET_V9)
8205         {
8206           assemble_integer_with_op ("\t.xword\t", x);
8207           return true;
8208         }
8209       else
8210         {
8211           assemble_aligned_integer (4, const0_rtx);
8212           assemble_aligned_integer (4, x);
8213           return true;
8214         }
8215     }
8216   return default_assemble_integer (x, size, aligned_p);
8217 }
8218 \f
8219 /* Return the value of a code used in the .proc pseudo-op that says
8220    what kind of result this function returns.  For non-C types, we pick
8221    the closest C type.  */
8222
8223 #ifndef SHORT_TYPE_SIZE
8224 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
8225 #endif
8226
8227 #ifndef INT_TYPE_SIZE
8228 #define INT_TYPE_SIZE BITS_PER_WORD
8229 #endif
8230
8231 #ifndef LONG_TYPE_SIZE
8232 #define LONG_TYPE_SIZE BITS_PER_WORD
8233 #endif
8234
8235 #ifndef LONG_LONG_TYPE_SIZE
8236 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
8237 #endif
8238
8239 #ifndef FLOAT_TYPE_SIZE
8240 #define FLOAT_TYPE_SIZE BITS_PER_WORD
8241 #endif
8242
8243 #ifndef DOUBLE_TYPE_SIZE
8244 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8245 #endif
8246
8247 #ifndef LONG_DOUBLE_TYPE_SIZE
8248 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8249 #endif
8250
8251 unsigned long
8252 sparc_type_code (register tree type)
8253 {
8254   register unsigned long qualifiers = 0;
8255   register unsigned shift;
8256
8257   /* Only the first 30 bits of the qualifier are valid.  We must refrain from
8258      setting more, since some assemblers will give an error for this.  Also,
8259      we must be careful to avoid shifts of 32 bits or more to avoid getting
8260      unpredictable results.  */
8261
8262   for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
8263     {
8264       switch (TREE_CODE (type))
8265         {
8266         case ERROR_MARK:
8267           return qualifiers;
8268
8269         case ARRAY_TYPE:
8270           qualifiers |= (3 << shift);
8271           break;
8272
8273         case FUNCTION_TYPE:
8274         case METHOD_TYPE:
8275           qualifiers |= (2 << shift);
8276           break;
8277
8278         case POINTER_TYPE:
8279         case REFERENCE_TYPE:
8280         case OFFSET_TYPE:
8281           qualifiers |= (1 << shift);
8282           break;
8283
8284         case RECORD_TYPE:
8285           return (qualifiers | 8);
8286
8287         case UNION_TYPE:
8288         case QUAL_UNION_TYPE:
8289           return (qualifiers | 9);
8290
8291         case ENUMERAL_TYPE:
8292           return (qualifiers | 10);
8293
8294         case VOID_TYPE:
8295           return (qualifiers | 16);
8296
8297         case INTEGER_TYPE:
8298           /* If this is a range type, consider it to be the underlying
8299              type.  */
8300           if (TREE_TYPE (type) != 0)
8301             break;
8302
8303           /* Carefully distinguish all the standard types of C,
8304              without messing up if the language is not C.  We do this by
8305              testing TYPE_PRECISION and TYPE_UNSIGNED.  The old code used to
8306              look at both the names and the above fields, but that's redundant.
8307              Any type whose size is between two C types will be considered
8308              to be the wider of the two types.  Also, we do not have a
8309              special code to use for "long long", so anything wider than
8310              long is treated the same.  Note that we can't distinguish
8311              between "int" and "long" in this code if they are the same
8312              size, but that's fine, since neither can the assembler.  */
8313
8314           if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
8315             return (qualifiers | (TYPE_UNSIGNED (type) ? 12 : 2));
8316
8317           else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
8318             return (qualifiers | (TYPE_UNSIGNED (type) ? 13 : 3));
8319
8320           else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
8321             return (qualifiers | (TYPE_UNSIGNED (type) ? 14 : 4));
8322
8323           else
8324             return (qualifiers | (TYPE_UNSIGNED (type) ? 15 : 5));
8325
8326         case REAL_TYPE:
8327           /* If this is a range type, consider it to be the underlying
8328              type.  */
8329           if (TREE_TYPE (type) != 0)
8330             break;
8331
8332           /* Carefully distinguish all the standard types of C,
8333              without messing up if the language is not C.  */
8334
8335           if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
8336             return (qualifiers | 6);
8337
8338           else
8339             return (qualifiers | 7);
8340
8341         case COMPLEX_TYPE:      /* GNU Fortran COMPLEX type.  */
8342           /* ??? We need to distinguish between double and float complex types,
8343              but I don't know how yet because I can't reach this code from
8344              existing front-ends.  */
8345           return (qualifiers | 7);      /* Who knows? */
8346
8347         case VECTOR_TYPE:
8348         case BOOLEAN_TYPE:      /* Boolean truth value type.  */
8349         case LANG_TYPE:
8350         case NULLPTR_TYPE:
8351           return qualifiers;
8352
8353         default:
8354           gcc_unreachable ();           /* Not a type! */
8355         }
8356     }
8357
8358   return qualifiers;
8359 }
8360 \f
8361 /* Nested function support.  */
8362
8363 /* Emit RTL insns to initialize the variable parts of a trampoline.
8364    FNADDR is an RTX for the address of the function's pure code.
8365    CXT is an RTX for the static chain value for the function.
8366
8367    This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
8368    (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
8369    (to store insns).  This is a bit excessive.  Perhaps a different
8370    mechanism would be better here.
8371
8372    Emit enough FLUSH insns to synchronize the data and instruction caches.  */
8373
8374 static void
8375 sparc32_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8376 {
8377   /* SPARC 32-bit trampoline:
8378
8379         sethi   %hi(fn), %g1
8380         sethi   %hi(static), %g2
8381         jmp     %g1+%lo(fn)
8382         or      %g2, %lo(static), %g2
8383
8384     SETHI i,r  = 00rr rrr1 00ii iiii iiii iiii iiii iiii
8385     JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
8386    */
8387
8388   emit_move_insn
8389     (adjust_address (m_tramp, SImode, 0),
8390      expand_binop (SImode, ior_optab,
8391                    expand_shift (RSHIFT_EXPR, SImode, fnaddr, 10, 0, 1),
8392                    GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
8393                    NULL_RTX, 1, OPTAB_DIRECT));
8394
8395   emit_move_insn
8396     (adjust_address (m_tramp, SImode, 4),
8397      expand_binop (SImode, ior_optab,
8398                    expand_shift (RSHIFT_EXPR, SImode, cxt, 10, 0, 1),
8399                    GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
8400                    NULL_RTX, 1, OPTAB_DIRECT));
8401
8402   emit_move_insn
8403     (adjust_address (m_tramp, SImode, 8),
8404      expand_binop (SImode, ior_optab,
8405                    expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
8406                    GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
8407                    NULL_RTX, 1, OPTAB_DIRECT));
8408
8409   emit_move_insn
8410     (adjust_address (m_tramp, SImode, 12),
8411      expand_binop (SImode, ior_optab,
8412                    expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
8413                    GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
8414                    NULL_RTX, 1, OPTAB_DIRECT));
8415
8416   /* On UltraSPARC a flush flushes an entire cache line.  The trampoline is
8417      aligned on a 16 byte boundary so one flush clears it all.  */
8418   emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 0))));
8419   if (sparc_cpu != PROCESSOR_ULTRASPARC
8420       && sparc_cpu != PROCESSOR_ULTRASPARC3
8421       && sparc_cpu != PROCESSOR_NIAGARA
8422       && sparc_cpu != PROCESSOR_NIAGARA2
8423       && sparc_cpu != PROCESSOR_NIAGARA3
8424       && sparc_cpu != PROCESSOR_NIAGARA4)
8425     emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 8))));
8426
8427   /* Call __enable_execute_stack after writing onto the stack to make sure
8428      the stack address is accessible.  */
8429 #ifdef HAVE_ENABLE_EXECUTE_STACK
8430   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8431                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8432 #endif
8433
8434 }
8435
8436 /* The 64-bit version is simpler because it makes more sense to load the
8437    values as "immediate" data out of the trampoline.  It's also easier since
8438    we can read the PC without clobbering a register.  */
8439
8440 static void
8441 sparc64_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8442 {
8443   /* SPARC 64-bit trampoline:
8444
8445         rd      %pc, %g1
8446         ldx     [%g1+24], %g5
8447         jmp     %g5
8448         ldx     [%g1+16], %g5
8449         +16 bytes data
8450    */
8451
8452   emit_move_insn (adjust_address (m_tramp, SImode, 0),
8453                   GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
8454   emit_move_insn (adjust_address (m_tramp, SImode, 4),
8455                   GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
8456   emit_move_insn (adjust_address (m_tramp, SImode, 8),
8457                   GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
8458   emit_move_insn (adjust_address (m_tramp, SImode, 12),
8459                   GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
8460   emit_move_insn (adjust_address (m_tramp, DImode, 16), cxt);
8461   emit_move_insn (adjust_address (m_tramp, DImode, 24), fnaddr);
8462   emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 0))));
8463
8464   if (sparc_cpu != PROCESSOR_ULTRASPARC
8465       && sparc_cpu != PROCESSOR_ULTRASPARC3
8466       && sparc_cpu != PROCESSOR_NIAGARA
8467       && sparc_cpu != PROCESSOR_NIAGARA2
8468       && sparc_cpu != PROCESSOR_NIAGARA3
8469       && sparc_cpu != PROCESSOR_NIAGARA4)
8470     emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 8))));
8471
8472   /* Call __enable_execute_stack after writing onto the stack to make sure
8473      the stack address is accessible.  */
8474 #ifdef HAVE_ENABLE_EXECUTE_STACK
8475   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8476                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8477 #endif
8478 }
8479
8480 /* Worker for TARGET_TRAMPOLINE_INIT.  */
8481
8482 static void
8483 sparc_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
8484 {
8485   rtx fnaddr = force_reg (Pmode, XEXP (DECL_RTL (fndecl), 0));
8486   cxt = force_reg (Pmode, cxt);
8487   if (TARGET_ARCH64)
8488     sparc64_initialize_trampoline (m_tramp, fnaddr, cxt);
8489   else
8490     sparc32_initialize_trampoline (m_tramp, fnaddr, cxt);
8491 }
8492 \f
8493 /* Adjust the cost of a scheduling dependency.  Return the new cost of
8494    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
8495
8496 static int
8497 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8498 {
8499   enum attr_type insn_type;
8500
8501   if (! recog_memoized (insn))
8502     return 0;
8503
8504   insn_type = get_attr_type (insn);
8505
8506   if (REG_NOTE_KIND (link) == 0)
8507     {
8508       /* Data dependency; DEP_INSN writes a register that INSN reads some
8509          cycles later.  */
8510
8511       /* if a load, then the dependence must be on the memory address;
8512          add an extra "cycle".  Note that the cost could be two cycles
8513          if the reg was written late in an instruction group; we ca not tell
8514          here.  */
8515       if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
8516         return cost + 3;
8517
8518       /* Get the delay only if the address of the store is the dependence.  */
8519       if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
8520         {
8521           rtx pat = PATTERN(insn);
8522           rtx dep_pat = PATTERN (dep_insn);
8523
8524           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8525             return cost;  /* This should not happen!  */
8526
8527           /* The dependency between the two instructions was on the data that
8528              is being stored.  Assume that this implies that the address of the
8529              store is not dependent.  */
8530           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8531             return cost;
8532
8533           return cost + 3;  /* An approximation.  */
8534         }
8535
8536       /* A shift instruction cannot receive its data from an instruction
8537          in the same cycle; add a one cycle penalty.  */
8538       if (insn_type == TYPE_SHIFT)
8539         return cost + 3;   /* Split before cascade into shift.  */
8540     }
8541   else
8542     {
8543       /* Anti- or output- dependency; DEP_INSN reads/writes a register that
8544          INSN writes some cycles later.  */
8545
8546       /* These are only significant for the fpu unit; writing a fp reg before
8547          the fpu has finished with it stalls the processor.  */
8548
8549       /* Reusing an integer register causes no problems.  */
8550       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8551         return 0;
8552     }
8553
8554   return cost;
8555 }
8556
8557 static int
8558 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8559 {
8560   enum attr_type insn_type, dep_type;
8561   rtx pat = PATTERN(insn);
8562   rtx dep_pat = PATTERN (dep_insn);
8563
8564   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
8565     return cost;
8566
8567   insn_type = get_attr_type (insn);
8568   dep_type = get_attr_type (dep_insn);
8569
8570   switch (REG_NOTE_KIND (link))
8571     {
8572     case 0:
8573       /* Data dependency; DEP_INSN writes a register that INSN reads some
8574          cycles later.  */
8575
8576       switch (insn_type)
8577         {
8578         case TYPE_STORE:
8579         case TYPE_FPSTORE:
8580           /* Get the delay iff the address of the store is the dependence.  */
8581           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8582             return cost;
8583
8584           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8585             return cost;
8586           return cost + 3;
8587
8588         case TYPE_LOAD:
8589         case TYPE_SLOAD:
8590         case TYPE_FPLOAD:
8591           /* If a load, then the dependence must be on the memory address.  If
8592              the addresses aren't equal, then it might be a false dependency */
8593           if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
8594             {
8595               if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
8596                   || GET_CODE (SET_DEST (dep_pat)) != MEM
8597                   || GET_CODE (SET_SRC (pat)) != MEM
8598                   || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
8599                                     XEXP (SET_SRC (pat), 0)))
8600                 return cost + 2;
8601
8602               return cost + 8;
8603             }
8604           break;
8605
8606         case TYPE_BRANCH:
8607           /* Compare to branch latency is 0.  There is no benefit from
8608              separating compare and branch.  */
8609           if (dep_type == TYPE_COMPARE)
8610             return 0;
8611           /* Floating point compare to branch latency is less than
8612              compare to conditional move.  */
8613           if (dep_type == TYPE_FPCMP)
8614             return cost - 1;
8615           break;
8616         default:
8617           break;
8618         }
8619         break;
8620
8621     case REG_DEP_ANTI:
8622       /* Anti-dependencies only penalize the fpu unit.  */
8623       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8624         return 0;
8625       break;
8626
8627     default:
8628       break;
8629     }
8630
8631   return cost;
8632 }
8633
8634 static int
8635 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
8636 {
8637   switch (sparc_cpu)
8638     {
8639     case PROCESSOR_SUPERSPARC:
8640       cost = supersparc_adjust_cost (insn, link, dep, cost);
8641       break;
8642     case PROCESSOR_HYPERSPARC:
8643     case PROCESSOR_SPARCLITE86X:
8644       cost = hypersparc_adjust_cost (insn, link, dep, cost);
8645       break;
8646     default:
8647       break;
8648     }
8649   return cost;
8650 }
8651
8652 static void
8653 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
8654                   int sched_verbose ATTRIBUTE_UNUSED,
8655                   int max_ready ATTRIBUTE_UNUSED)
8656 {}
8657
8658 static int
8659 sparc_use_sched_lookahead (void)
8660 {
8661   if (sparc_cpu == PROCESSOR_NIAGARA
8662       || sparc_cpu == PROCESSOR_NIAGARA2
8663       || sparc_cpu == PROCESSOR_NIAGARA3
8664       || sparc_cpu == PROCESSOR_NIAGARA4)
8665     return 0;
8666   if (sparc_cpu == PROCESSOR_ULTRASPARC
8667       || sparc_cpu == PROCESSOR_ULTRASPARC3)
8668     return 4;
8669   if ((1 << sparc_cpu) &
8670       ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
8671        (1 << PROCESSOR_SPARCLITE86X)))
8672     return 3;
8673   return 0;
8674 }
8675
8676 static int
8677 sparc_issue_rate (void)
8678 {
8679   switch (sparc_cpu)
8680     {
8681     case PROCESSOR_NIAGARA:
8682     case PROCESSOR_NIAGARA2:
8683     case PROCESSOR_NIAGARA3:
8684     case PROCESSOR_NIAGARA4:
8685     default:
8686       return 1;
8687     case PROCESSOR_V9:
8688       /* Assume V9 processors are capable of at least dual-issue.  */
8689       return 2;
8690     case PROCESSOR_SUPERSPARC:
8691       return 3;
8692     case PROCESSOR_HYPERSPARC:
8693     case PROCESSOR_SPARCLITE86X:
8694       return 2;
8695     case PROCESSOR_ULTRASPARC:
8696     case PROCESSOR_ULTRASPARC3:
8697       return 4;
8698     }
8699 }
8700
8701 static int
8702 set_extends (rtx insn)
8703 {
8704   register rtx pat = PATTERN (insn);
8705
8706   switch (GET_CODE (SET_SRC (pat)))
8707     {
8708       /* Load and some shift instructions zero extend.  */
8709     case MEM:
8710     case ZERO_EXTEND:
8711       /* sethi clears the high bits */
8712     case HIGH:
8713       /* LO_SUM is used with sethi.  sethi cleared the high
8714          bits and the values used with lo_sum are positive */
8715     case LO_SUM:
8716       /* Store flag stores 0 or 1 */
8717     case LT: case LTU:
8718     case GT: case GTU:
8719     case LE: case LEU:
8720     case GE: case GEU:
8721     case EQ:
8722     case NE:
8723       return 1;
8724     case AND:
8725       {
8726         rtx op0 = XEXP (SET_SRC (pat), 0);
8727         rtx op1 = XEXP (SET_SRC (pat), 1);
8728         if (GET_CODE (op1) == CONST_INT)
8729           return INTVAL (op1) >= 0;
8730         if (GET_CODE (op0) != REG)
8731           return 0;
8732         if (sparc_check_64 (op0, insn) == 1)
8733           return 1;
8734         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8735       }
8736     case IOR:
8737     case XOR:
8738       {
8739         rtx op0 = XEXP (SET_SRC (pat), 0);
8740         rtx op1 = XEXP (SET_SRC (pat), 1);
8741         if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
8742           return 0;
8743         if (GET_CODE (op1) == CONST_INT)
8744           return INTVAL (op1) >= 0;
8745         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8746       }
8747     case LSHIFTRT:
8748       return GET_MODE (SET_SRC (pat)) == SImode;
8749       /* Positive integers leave the high bits zero.  */
8750     case CONST_DOUBLE:
8751       return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
8752     case CONST_INT:
8753       return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
8754     case ASHIFTRT:
8755     case SIGN_EXTEND:
8756       return - (GET_MODE (SET_SRC (pat)) == SImode);
8757     case REG:
8758       return sparc_check_64 (SET_SRC (pat), insn);
8759     default:
8760       return 0;
8761     }
8762 }
8763
8764 /* We _ought_ to have only one kind per function, but...  */
8765 static GTY(()) rtx sparc_addr_diff_list;
8766 static GTY(()) rtx sparc_addr_list;
8767
8768 void
8769 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
8770 {
8771   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
8772   if (diff)
8773     sparc_addr_diff_list
8774       = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
8775   else
8776     sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
8777 }
8778
8779 static void
8780 sparc_output_addr_vec (rtx vec)
8781 {
8782   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8783   int idx, vlen = XVECLEN (body, 0);
8784
8785 #ifdef ASM_OUTPUT_ADDR_VEC_START
8786   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8787 #endif
8788
8789 #ifdef ASM_OUTPUT_CASE_LABEL
8790   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8791                          NEXT_INSN (lab));
8792 #else
8793   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8794 #endif
8795
8796   for (idx = 0; idx < vlen; idx++)
8797     {
8798       ASM_OUTPUT_ADDR_VEC_ELT
8799         (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
8800     }
8801
8802 #ifdef ASM_OUTPUT_ADDR_VEC_END
8803   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8804 #endif
8805 }
8806
8807 static void
8808 sparc_output_addr_diff_vec (rtx vec)
8809 {
8810   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8811   rtx base = XEXP (XEXP (body, 0), 0);
8812   int idx, vlen = XVECLEN (body, 1);
8813
8814 #ifdef ASM_OUTPUT_ADDR_VEC_START
8815   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8816 #endif
8817
8818 #ifdef ASM_OUTPUT_CASE_LABEL
8819   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8820                          NEXT_INSN (lab));
8821 #else
8822   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8823 #endif
8824
8825   for (idx = 0; idx < vlen; idx++)
8826     {
8827       ASM_OUTPUT_ADDR_DIFF_ELT
8828         (asm_out_file,
8829          body,
8830          CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
8831          CODE_LABEL_NUMBER (base));
8832     }
8833
8834 #ifdef ASM_OUTPUT_ADDR_VEC_END
8835   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8836 #endif
8837 }
8838
8839 static void
8840 sparc_output_deferred_case_vectors (void)
8841 {
8842   rtx t;
8843   int align;
8844
8845   if (sparc_addr_list == NULL_RTX
8846       && sparc_addr_diff_list == NULL_RTX)
8847     return;
8848
8849   /* Align to cache line in the function's code section.  */
8850   switch_to_section (current_function_section ());
8851
8852   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
8853   if (align > 0)
8854     ASM_OUTPUT_ALIGN (asm_out_file, align);
8855
8856   for (t = sparc_addr_list; t ; t = XEXP (t, 1))
8857     sparc_output_addr_vec (XEXP (t, 0));
8858   for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
8859     sparc_output_addr_diff_vec (XEXP (t, 0));
8860
8861   sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
8862 }
8863
8864 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
8865    unknown.  Return 1 if the high bits are zero, -1 if the register is
8866    sign extended.  */
8867 int
8868 sparc_check_64 (rtx x, rtx insn)
8869 {
8870   /* If a register is set only once it is safe to ignore insns this
8871      code does not know how to handle.  The loop will either recognize
8872      the single set and return the correct value or fail to recognize
8873      it and return 0.  */
8874   int set_once = 0;
8875   rtx y = x;
8876
8877   gcc_assert (GET_CODE (x) == REG);
8878
8879   if (GET_MODE (x) == DImode)
8880     y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
8881
8882   if (flag_expensive_optimizations
8883       && df && DF_REG_DEF_COUNT (REGNO (y)) == 1)
8884     set_once = 1;
8885
8886   if (insn == 0)
8887     {
8888       if (set_once)
8889         insn = get_last_insn_anywhere ();
8890       else
8891         return 0;
8892     }
8893
8894   while ((insn = PREV_INSN (insn)))
8895     {
8896       switch (GET_CODE (insn))
8897         {
8898         case JUMP_INSN:
8899         case NOTE:
8900           break;
8901         case CODE_LABEL:
8902         case CALL_INSN:
8903         default:
8904           if (! set_once)
8905             return 0;
8906           break;
8907         case INSN:
8908           {
8909             rtx pat = PATTERN (insn);
8910             if (GET_CODE (pat) != SET)
8911               return 0;
8912             if (rtx_equal_p (x, SET_DEST (pat)))
8913               return set_extends (insn);
8914             if (y && rtx_equal_p (y, SET_DEST (pat)))
8915               return set_extends (insn);
8916             if (reg_overlap_mentioned_p (SET_DEST (pat), y))
8917               return 0;
8918           }
8919         }
8920     }
8921   return 0;
8922 }
8923
8924 /* Returns assembly code to perform a DImode shift using
8925    a 64-bit global or out register on SPARC-V8+.  */
8926 const char *
8927 output_v8plus_shift (rtx *operands, rtx insn, const char *opcode)
8928 {
8929   static char asm_code[60];
8930
8931   /* The scratch register is only required when the destination
8932      register is not a 64-bit global or out register.  */
8933   if (which_alternative != 2)
8934     operands[3] = operands[0];
8935
8936   /* We can only shift by constants <= 63. */
8937   if (GET_CODE (operands[2]) == CONST_INT)
8938     operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
8939
8940   if (GET_CODE (operands[1]) == CONST_INT)
8941     {
8942       output_asm_insn ("mov\t%1, %3", operands);
8943     }
8944   else
8945     {
8946       output_asm_insn ("sllx\t%H1, 32, %3", operands);
8947       if (sparc_check_64 (operands[1], insn) <= 0)
8948         output_asm_insn ("srl\t%L1, 0, %L1", operands);
8949       output_asm_insn ("or\t%L1, %3, %3", operands);
8950     }
8951
8952   strcpy(asm_code, opcode);
8953
8954   if (which_alternative != 2)
8955     return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
8956   else
8957     return strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
8958 }
8959 \f
8960 /* Output rtl to increment the profiler label LABELNO
8961    for profiling a function entry.  */
8962
8963 void
8964 sparc_profile_hook (int labelno)
8965 {
8966   char buf[32];
8967   rtx lab, fun;
8968
8969   fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
8970   if (NO_PROFILE_COUNTERS)
8971     {
8972       emit_library_call (fun, LCT_NORMAL, VOIDmode, 0);
8973     }
8974   else
8975     {
8976       ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
8977       lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
8978       emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
8979     }
8980 }
8981 \f
8982 #ifdef TARGET_SOLARIS
8983 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
8984
8985 static void
8986 sparc_solaris_elf_asm_named_section (const char *name, unsigned int flags,
8987                                      tree decl ATTRIBUTE_UNUSED)
8988 {
8989   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
8990     {
8991       solaris_elf_asm_comdat_section (name, flags, decl);
8992       return;
8993     }
8994
8995   fprintf (asm_out_file, "\t.section\t\"%s\"", name);
8996
8997   if (!(flags & SECTION_DEBUG))
8998     fputs (",#alloc", asm_out_file);
8999   if (flags & SECTION_WRITE)
9000     fputs (",#write", asm_out_file);
9001   if (flags & SECTION_TLS)
9002     fputs (",#tls", asm_out_file);
9003   if (flags & SECTION_CODE)
9004     fputs (",#execinstr", asm_out_file);
9005
9006   /* ??? Handle SECTION_BSS.  */
9007
9008   fputc ('\n', asm_out_file);
9009 }
9010 #endif /* TARGET_SOLARIS */
9011
9012 /* We do not allow indirect calls to be optimized into sibling calls.
9013
9014    We cannot use sibling calls when delayed branches are disabled
9015    because they will likely require the call delay slot to be filled.
9016
9017    Also, on SPARC 32-bit we cannot emit a sibling call when the
9018    current function returns a structure.  This is because the "unimp
9019    after call" convention would cause the callee to return to the
9020    wrong place.  The generic code already disallows cases where the
9021    function being called returns a structure.
9022
9023    It may seem strange how this last case could occur.  Usually there
9024    is code after the call which jumps to epilogue code which dumps the
9025    return value into the struct return area.  That ought to invalidate
9026    the sibling call right?  Well, in the C++ case we can end up passing
9027    the pointer to the struct return area to a constructor (which returns
9028    void) and then nothing else happens.  Such a sibling call would look
9029    valid without the added check here.
9030
9031    VxWorks PIC PLT entries require the global pointer to be initialized
9032    on entry.  We therefore can't emit sibling calls to them.  */
9033 static bool
9034 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
9035 {
9036   return (decl
9037           && flag_delayed_branch
9038           && (TARGET_ARCH64 || ! cfun->returns_struct)
9039           && !(TARGET_VXWORKS_RTP
9040                && flag_pic
9041                && !targetm.binds_local_p (decl)));
9042 }
9043 \f
9044 /* libfunc renaming.  */
9045
9046 static void
9047 sparc_init_libfuncs (void)
9048 {
9049   if (TARGET_ARCH32)
9050     {
9051       /* Use the subroutines that Sun's library provides for integer
9052          multiply and divide.  The `*' prevents an underscore from
9053          being prepended by the compiler. .umul is a little faster
9054          than .mul.  */
9055       set_optab_libfunc (smul_optab, SImode, "*.umul");
9056       set_optab_libfunc (sdiv_optab, SImode, "*.div");
9057       set_optab_libfunc (udiv_optab, SImode, "*.udiv");
9058       set_optab_libfunc (smod_optab, SImode, "*.rem");
9059       set_optab_libfunc (umod_optab, SImode, "*.urem");
9060
9061       /* TFmode arithmetic.  These names are part of the SPARC 32bit ABI.  */
9062       set_optab_libfunc (add_optab, TFmode, "_Q_add");
9063       set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
9064       set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
9065       set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
9066       set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
9067
9068       /* We can define the TFmode sqrt optab only if TARGET_FPU.  This
9069          is because with soft-float, the SFmode and DFmode sqrt
9070          instructions will be absent, and the compiler will notice and
9071          try to use the TFmode sqrt instruction for calls to the
9072          builtin function sqrt, but this fails.  */
9073       if (TARGET_FPU)
9074         set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
9075
9076       set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
9077       set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
9078       set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
9079       set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
9080       set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
9081       set_optab_libfunc (le_optab, TFmode, "_Q_fle");
9082
9083       set_conv_libfunc (sext_optab,   TFmode, SFmode, "_Q_stoq");
9084       set_conv_libfunc (sext_optab,   TFmode, DFmode, "_Q_dtoq");
9085       set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_Q_qtos");
9086       set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_Q_qtod");
9087
9088       set_conv_libfunc (sfix_optab,   SImode, TFmode, "_Q_qtoi");
9089       set_conv_libfunc (ufix_optab,   SImode, TFmode, "_Q_qtou");
9090       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
9091       set_conv_libfunc (ufloat_optab, TFmode, SImode, "_Q_utoq");
9092
9093       if (DITF_CONVERSION_LIBFUNCS)
9094         {
9095           set_conv_libfunc (sfix_optab,   DImode, TFmode, "_Q_qtoll");
9096           set_conv_libfunc (ufix_optab,   DImode, TFmode, "_Q_qtoull");
9097           set_conv_libfunc (sfloat_optab, TFmode, DImode, "_Q_lltoq");
9098           set_conv_libfunc (ufloat_optab, TFmode, DImode, "_Q_ulltoq");
9099         }
9100
9101       if (SUN_CONVERSION_LIBFUNCS)
9102         {
9103           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
9104           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
9105           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
9106           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
9107         }
9108     }
9109   if (TARGET_ARCH64)
9110     {
9111       /* In the SPARC 64bit ABI, SImode multiply and divide functions
9112          do not exist in the library.  Make sure the compiler does not
9113          emit calls to them by accident.  (It should always use the
9114          hardware instructions.)  */
9115       set_optab_libfunc (smul_optab, SImode, 0);
9116       set_optab_libfunc (sdiv_optab, SImode, 0);
9117       set_optab_libfunc (udiv_optab, SImode, 0);
9118       set_optab_libfunc (smod_optab, SImode, 0);
9119       set_optab_libfunc (umod_optab, SImode, 0);
9120
9121       if (SUN_INTEGER_MULTIPLY_64)
9122         {
9123           set_optab_libfunc (smul_optab, DImode, "__mul64");
9124           set_optab_libfunc (sdiv_optab, DImode, "__div64");
9125           set_optab_libfunc (udiv_optab, DImode, "__udiv64");
9126           set_optab_libfunc (smod_optab, DImode, "__rem64");
9127           set_optab_libfunc (umod_optab, DImode, "__urem64");
9128         }
9129
9130       if (SUN_CONVERSION_LIBFUNCS)
9131         {
9132           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
9133           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
9134           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
9135           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
9136         }
9137     }
9138 }
9139 \f
9140 static tree def_builtin(const char *name, int code, tree type)
9141 {
9142   return add_builtin_function(name, type, code, BUILT_IN_MD, NULL,
9143                               NULL_TREE);
9144 }
9145
9146 static tree def_builtin_const(const char *name, int code, tree type)
9147 {
9148   tree t = def_builtin(name, code, type);
9149
9150   if (t)
9151     TREE_READONLY (t) = 1;
9152
9153   return t;
9154 }
9155
9156 /* Implement the TARGET_INIT_BUILTINS target hook.
9157    Create builtin functions for special SPARC instructions.  */
9158
9159 static void
9160 sparc_init_builtins (void)
9161 {
9162   if (TARGET_VIS)
9163     sparc_vis_init_builtins ();
9164 }
9165
9166 /* Create builtin functions for VIS 1.0 instructions.  */
9167
9168 static void
9169 sparc_vis_init_builtins (void)
9170 {
9171   tree v4qi = build_vector_type (unsigned_intQI_type_node, 4);
9172   tree v8qi = build_vector_type (unsigned_intQI_type_node, 8);
9173   tree v4hi = build_vector_type (intHI_type_node, 4);
9174   tree v2hi = build_vector_type (intHI_type_node, 2);
9175   tree v2si = build_vector_type (intSI_type_node, 2);
9176   tree v1si = build_vector_type (intSI_type_node, 1);
9177
9178   tree v4qi_ftype_v4hi = build_function_type_list (v4qi, v4hi, 0);
9179   tree v8qi_ftype_v2si_v8qi = build_function_type_list (v8qi, v2si, v8qi, 0);
9180   tree v2hi_ftype_v2si = build_function_type_list (v2hi, v2si, 0);
9181   tree v4hi_ftype_v4qi = build_function_type_list (v4hi, v4qi, 0);
9182   tree v8qi_ftype_v4qi_v4qi = build_function_type_list (v8qi, v4qi, v4qi, 0);
9183   tree v4hi_ftype_v4qi_v4hi = build_function_type_list (v4hi, v4qi, v4hi, 0);
9184   tree v4hi_ftype_v4qi_v2hi = build_function_type_list (v4hi, v4qi, v2hi, 0);
9185   tree v2si_ftype_v4qi_v2hi = build_function_type_list (v2si, v4qi, v2hi, 0);
9186   tree v4hi_ftype_v8qi_v4hi = build_function_type_list (v4hi, v8qi, v4hi, 0);
9187   tree v4hi_ftype_v4hi_v4hi = build_function_type_list (v4hi, v4hi, v4hi, 0);
9188   tree v2si_ftype_v2si_v2si = build_function_type_list (v2si, v2si, v2si, 0);
9189   tree v8qi_ftype_v8qi_v8qi = build_function_type_list (v8qi, v8qi, v8qi, 0);
9190   tree v2hi_ftype_v2hi_v2hi = build_function_type_list (v2hi, v2hi, v2hi, 0);
9191   tree v1si_ftype_v1si_v1si = build_function_type_list (v1si, v1si, v1si, 0);
9192   tree di_ftype_v8qi_v8qi_di = build_function_type_list (intDI_type_node,
9193                                                          v8qi, v8qi,
9194                                                          intDI_type_node, 0);
9195   tree di_ftype_di_di = build_function_type_list (intDI_type_node,
9196                                                   intDI_type_node,
9197                                                   intDI_type_node, 0);
9198   tree si_ftype_si_si = build_function_type_list (intSI_type_node,
9199                                                   intSI_type_node,
9200                                                   intSI_type_node, 0);
9201   tree ptr_ftype_ptr_si = build_function_type_list (ptr_type_node,
9202                                                     ptr_type_node,
9203                                                     intSI_type_node, 0);
9204   tree ptr_ftype_ptr_di = build_function_type_list (ptr_type_node,
9205                                                     ptr_type_node,
9206                                                     intDI_type_node, 0);
9207   tree si_ftype_ptr_ptr = build_function_type_list (intSI_type_node,
9208                                                     ptr_type_node,
9209                                                     ptr_type_node, 0);
9210   tree di_ftype_ptr_ptr = build_function_type_list (intDI_type_node,
9211                                                     ptr_type_node,
9212                                                     ptr_type_node, 0);
9213   tree si_ftype_v4hi_v4hi = build_function_type_list (intSI_type_node,
9214                                                       v4hi, v4hi, 0);
9215   tree si_ftype_v2si_v2si = build_function_type_list (intSI_type_node,
9216                                                       v2si, v2si, 0);
9217   tree di_ftype_v4hi_v4hi = build_function_type_list (intDI_type_node,
9218                                                       v4hi, v4hi, 0);
9219   tree di_ftype_v2si_v2si = build_function_type_list (intDI_type_node,
9220                                                       v2si, v2si, 0);
9221   tree void_ftype_di = build_function_type_list (void_type_node,
9222                                                  intDI_type_node, 0);
9223   tree di_ftype_void = build_function_type_list (intDI_type_node,
9224                                                  void_type_node, 0);
9225
9226   /* Packing and expanding vectors.  */
9227   def_builtin ("__builtin_vis_fpack16", CODE_FOR_fpack16_vis,
9228                v4qi_ftype_v4hi);
9229   def_builtin ("__builtin_vis_fpack32", CODE_FOR_fpack32_vis,
9230                v8qi_ftype_v2si_v8qi);
9231   def_builtin ("__builtin_vis_fpackfix", CODE_FOR_fpackfix_vis,
9232                v2hi_ftype_v2si);
9233   def_builtin_const ("__builtin_vis_fexpand", CODE_FOR_fexpand_vis,
9234                      v4hi_ftype_v4qi);
9235   def_builtin_const ("__builtin_vis_fpmerge", CODE_FOR_fpmerge_vis,
9236                      v8qi_ftype_v4qi_v4qi);
9237
9238   /* Multiplications.  */
9239   def_builtin_const ("__builtin_vis_fmul8x16", CODE_FOR_fmul8x16_vis,
9240                      v4hi_ftype_v4qi_v4hi);
9241   def_builtin_const ("__builtin_vis_fmul8x16au", CODE_FOR_fmul8x16au_vis,
9242                      v4hi_ftype_v4qi_v2hi);
9243   def_builtin_const ("__builtin_vis_fmul8x16al", CODE_FOR_fmul8x16al_vis,
9244                      v4hi_ftype_v4qi_v2hi);
9245   def_builtin_const ("__builtin_vis_fmul8sux16", CODE_FOR_fmul8sux16_vis,
9246                      v4hi_ftype_v8qi_v4hi);
9247   def_builtin_const ("__builtin_vis_fmul8ulx16", CODE_FOR_fmul8ulx16_vis,
9248                      v4hi_ftype_v8qi_v4hi);
9249   def_builtin_const ("__builtin_vis_fmuld8sux16", CODE_FOR_fmuld8sux16_vis,
9250                      v2si_ftype_v4qi_v2hi);
9251   def_builtin_const ("__builtin_vis_fmuld8ulx16", CODE_FOR_fmuld8ulx16_vis,
9252                      v2si_ftype_v4qi_v2hi);
9253
9254   /* Data aligning.  */
9255   def_builtin ("__builtin_vis_faligndatav4hi", CODE_FOR_faligndatav4hi_vis,
9256                v4hi_ftype_v4hi_v4hi);
9257   def_builtin ("__builtin_vis_faligndatav8qi", CODE_FOR_faligndatav8qi_vis,
9258                v8qi_ftype_v8qi_v8qi);
9259   def_builtin ("__builtin_vis_faligndatav2si", CODE_FOR_faligndatav2si_vis,
9260                v2si_ftype_v2si_v2si);
9261   def_builtin ("__builtin_vis_faligndatadi", CODE_FOR_faligndatadi_vis,
9262                di_ftype_di_di);
9263
9264   def_builtin ("__builtin_vis_write_gsr", CODE_FOR_wrgsr_vis,
9265                void_ftype_di);
9266   def_builtin ("__builtin_vis_read_gsr", CODE_FOR_rdgsr_vis,
9267                di_ftype_void);
9268
9269   if (TARGET_ARCH64)
9270     {
9271       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrdi_vis,
9272                    ptr_ftype_ptr_di);
9273       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrldi_vis,
9274                    ptr_ftype_ptr_di);
9275     }
9276   else
9277     {
9278       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrsi_vis,
9279                    ptr_ftype_ptr_si);
9280       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrlsi_vis,
9281                    ptr_ftype_ptr_si);
9282     }
9283
9284   /* Pixel distance.  */
9285   def_builtin_const ("__builtin_vis_pdist", CODE_FOR_pdist_vis,
9286                      di_ftype_v8qi_v8qi_di);
9287
9288   /* Edge handling.  */
9289   if (TARGET_ARCH64)
9290     {
9291       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8di_vis,
9292                          di_ftype_ptr_ptr);
9293       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8ldi_vis,
9294                          di_ftype_ptr_ptr);
9295       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16di_vis,
9296                          di_ftype_ptr_ptr);
9297       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16ldi_vis,
9298                          di_ftype_ptr_ptr);
9299       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32di_vis,
9300                          di_ftype_ptr_ptr);
9301       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32ldi_vis,
9302                          di_ftype_ptr_ptr);
9303     }
9304   else
9305     {
9306       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8si_vis,
9307                          si_ftype_ptr_ptr);
9308       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8lsi_vis,
9309                          si_ftype_ptr_ptr);
9310       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16si_vis,
9311                          si_ftype_ptr_ptr);
9312       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16lsi_vis,
9313                          si_ftype_ptr_ptr);
9314       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32si_vis,
9315                          si_ftype_ptr_ptr);
9316       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32lsi_vis,
9317                          si_ftype_ptr_ptr);
9318     }
9319
9320   /* Pixel compare.  */
9321   if (TARGET_ARCH64)
9322     {
9323       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16di_vis,
9324                          di_ftype_v4hi_v4hi);
9325       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32di_vis,
9326                          di_ftype_v2si_v2si);
9327       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16di_vis,
9328                          di_ftype_v4hi_v4hi);
9329       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32di_vis,
9330                          di_ftype_v2si_v2si);
9331       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16di_vis,
9332                          di_ftype_v4hi_v4hi);
9333       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32di_vis,
9334                          di_ftype_v2si_v2si);
9335       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16di_vis,
9336                          di_ftype_v4hi_v4hi);
9337       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32di_vis,
9338                          di_ftype_v2si_v2si);
9339     }
9340   else
9341     {
9342       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16si_vis,
9343                          si_ftype_v4hi_v4hi);
9344       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32si_vis,
9345                          si_ftype_v2si_v2si);
9346       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16si_vis,
9347                          si_ftype_v4hi_v4hi);
9348       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32si_vis,
9349                          si_ftype_v2si_v2si);
9350       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16si_vis,
9351                          si_ftype_v4hi_v4hi);
9352       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32si_vis,
9353                          si_ftype_v2si_v2si);
9354       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16si_vis,
9355                          si_ftype_v4hi_v4hi);
9356       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32si_vis,
9357                          si_ftype_v2si_v2si);
9358     }
9359
9360   /* Addition and subtraction.  */
9361   def_builtin_const ("__builtin_vis_fpadd16", CODE_FOR_addv4hi3,
9362                      v4hi_ftype_v4hi_v4hi);
9363   def_builtin_const ("__builtin_vis_fpadd16s", CODE_FOR_addv2hi3,
9364                      v2hi_ftype_v2hi_v2hi);
9365   def_builtin_const ("__builtin_vis_fpadd32", CODE_FOR_addv2si3,
9366                      v2si_ftype_v2si_v2si);
9367   def_builtin_const ("__builtin_vis_fpadd32s", CODE_FOR_addsi3,
9368                      v1si_ftype_v1si_v1si);
9369   def_builtin_const ("__builtin_vis_fpsub16", CODE_FOR_subv4hi3,
9370                      v4hi_ftype_v4hi_v4hi);
9371   def_builtin_const ("__builtin_vis_fpsub16s", CODE_FOR_subv2hi3,
9372                      v2hi_ftype_v2hi_v2hi);
9373   def_builtin_const ("__builtin_vis_fpsub32", CODE_FOR_subv2si3,
9374                      v2si_ftype_v2si_v2si);
9375   def_builtin_const ("__builtin_vis_fpsub32s", CODE_FOR_subsi3,
9376                      v1si_ftype_v1si_v1si);
9377
9378   /* Three-dimensional array addressing.  */
9379   if (TARGET_ARCH64)
9380     {
9381       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8di_vis,
9382                          di_ftype_di_di);
9383       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16di_vis,
9384                          di_ftype_di_di);
9385       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32di_vis,
9386                          di_ftype_di_di);
9387     }
9388   else
9389     {
9390       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8si_vis,
9391                          si_ftype_si_si);
9392       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16si_vis,
9393                          si_ftype_si_si);
9394       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32si_vis,
9395                          si_ftype_si_si);
9396   }
9397 }
9398
9399 /* Handle TARGET_EXPAND_BUILTIN target hook.
9400    Expand builtin functions for sparc intrinsics.  */
9401
9402 static rtx
9403 sparc_expand_builtin (tree exp, rtx target,
9404                       rtx subtarget ATTRIBUTE_UNUSED,
9405                       enum machine_mode tmode ATTRIBUTE_UNUSED,
9406                       int ignore ATTRIBUTE_UNUSED)
9407 {
9408   tree arg;
9409   call_expr_arg_iterator iter;
9410   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
9411   unsigned int icode = DECL_FUNCTION_CODE (fndecl);
9412   rtx pat, op[4];
9413   int arg_count = 0;
9414   bool nonvoid;
9415
9416   nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
9417
9418   if (nonvoid)
9419     {
9420       enum machine_mode tmode = insn_data[icode].operand[0].mode;
9421       if (!target
9422           || GET_MODE (target) != tmode
9423           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
9424         op[0] = gen_reg_rtx (tmode);
9425       else
9426         op[0] = target;
9427     }
9428   FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
9429     {
9430       const struct insn_operand_data *insn_op;
9431
9432       if (arg == error_mark_node)
9433         return NULL_RTX;
9434
9435       arg_count++;
9436       insn_op = &insn_data[icode].operand[arg_count - !nonvoid];
9437       op[arg_count] = expand_normal (arg);
9438
9439       if (! (*insn_data[icode].operand[arg_count].predicate) (op[arg_count],
9440                                                               insn_op->mode))
9441         op[arg_count] = copy_to_mode_reg (insn_op->mode, op[arg_count]);
9442     }
9443
9444   switch (arg_count)
9445     {
9446     case 0:
9447       pat = GEN_FCN (icode) (op[0]);
9448       break;
9449     case 1:
9450       if (nonvoid)
9451         pat = GEN_FCN (icode) (op[0], op[1]);
9452       else
9453         pat = GEN_FCN (icode) (op[1]);
9454       break;
9455     case 2:
9456       pat = GEN_FCN (icode) (op[0], op[1], op[2]);
9457       break;
9458     case 3:
9459       pat = GEN_FCN (icode) (op[0], op[1], op[2], op[3]);
9460       break;
9461     default:
9462       gcc_unreachable ();
9463     }
9464
9465   if (!pat)
9466     return NULL_RTX;
9467
9468   emit_insn (pat);
9469
9470   if (nonvoid)
9471     return op[0];
9472   else
9473     return const0_rtx;
9474 }
9475
9476 static int
9477 sparc_vis_mul8x16 (int e8, int e16)
9478 {
9479   return (e8 * e16 + 128) / 256;
9480 }
9481
9482 /* Multiply the vector elements in ELTS0 to the elements in ELTS1 as specified
9483    by FNCODE.  All of the elements in ELTS0 and ELTS1 lists must be integer
9484    constants.  A tree list with the results of the multiplications is returned,
9485    and each element in the list is of INNER_TYPE.  */
9486
9487 static tree
9488 sparc_handle_vis_mul8x16 (int fncode, tree inner_type, tree elts0, tree elts1)
9489 {
9490   tree n_elts = NULL_TREE;
9491   int scale;
9492
9493   switch (fncode)
9494     {
9495     case CODE_FOR_fmul8x16_vis:
9496       for (; elts0 && elts1;
9497            elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
9498         {
9499           int val
9500             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9501                                  TREE_INT_CST_LOW (TREE_VALUE (elts1)));
9502           n_elts = tree_cons (NULL_TREE,
9503                               build_int_cst (inner_type, val),
9504                               n_elts);
9505         }
9506       break;
9507
9508     case CODE_FOR_fmul8x16au_vis:
9509       scale = TREE_INT_CST_LOW (TREE_VALUE (elts1));
9510
9511       for (; elts0; elts0 = TREE_CHAIN (elts0))
9512         {
9513           int val
9514             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9515                                  scale);
9516           n_elts = tree_cons (NULL_TREE,
9517                               build_int_cst (inner_type, val),
9518                               n_elts);
9519         }
9520       break;
9521
9522     case CODE_FOR_fmul8x16al_vis:
9523       scale = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (elts1)));
9524
9525       for (; elts0; elts0 = TREE_CHAIN (elts0))
9526         {
9527           int val
9528             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9529                                  scale);
9530           n_elts = tree_cons (NULL_TREE,
9531                               build_int_cst (inner_type, val),
9532                               n_elts);
9533         }
9534       break;
9535
9536     default:
9537       gcc_unreachable ();
9538     }
9539
9540   return nreverse (n_elts);
9541
9542 }
9543 /* Handle TARGET_FOLD_BUILTIN target hook.
9544    Fold builtin functions for SPARC intrinsics.  If IGNORE is true the
9545    result of the function call is ignored.  NULL_TREE is returned if the
9546    function could not be folded.  */
9547
9548 static tree
9549 sparc_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED,
9550                     tree *args, bool ignore)
9551 {
9552   tree arg0, arg1, arg2;
9553   tree rtype = TREE_TYPE (TREE_TYPE (fndecl));
9554   enum insn_code icode = (enum insn_code) DECL_FUNCTION_CODE (fndecl);
9555
9556   if (ignore
9557       && icode != CODE_FOR_alignaddrsi_vis
9558       && icode != CODE_FOR_alignaddrdi_vis
9559       && icode != CODE_FOR_wrgsr_vis)
9560     return build_zero_cst (rtype);
9561
9562   switch (icode)
9563     {
9564     case CODE_FOR_fexpand_vis:
9565       arg0 = args[0];
9566       STRIP_NOPS (arg0);
9567
9568       if (TREE_CODE (arg0) == VECTOR_CST)
9569         {
9570           tree inner_type = TREE_TYPE (rtype);
9571           tree elts = TREE_VECTOR_CST_ELTS (arg0);
9572           tree n_elts = NULL_TREE;
9573
9574           for (; elts; elts = TREE_CHAIN (elts))
9575             {
9576               unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (elts)) << 4;
9577               n_elts = tree_cons (NULL_TREE,
9578                                   build_int_cst (inner_type, val),
9579                                   n_elts);
9580             }
9581           return build_vector (rtype, nreverse (n_elts));
9582         }
9583       break;
9584
9585     case CODE_FOR_fmul8x16_vis:
9586     case CODE_FOR_fmul8x16au_vis:
9587     case CODE_FOR_fmul8x16al_vis:
9588       arg0 = args[0];
9589       arg1 = args[1];
9590       STRIP_NOPS (arg0);
9591       STRIP_NOPS (arg1);
9592
9593       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
9594         {
9595           tree inner_type = TREE_TYPE (rtype);
9596           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
9597           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
9598           tree n_elts = sparc_handle_vis_mul8x16 (icode, inner_type, elts0,
9599                                                   elts1);
9600
9601           return build_vector (rtype, n_elts);
9602         }
9603       break;
9604
9605     case CODE_FOR_fpmerge_vis:
9606       arg0 = args[0];
9607       arg1 = args[1];
9608       STRIP_NOPS (arg0);
9609       STRIP_NOPS (arg1);
9610
9611       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
9612         {
9613           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
9614           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
9615           tree n_elts = NULL_TREE;
9616
9617           for (; elts0 && elts1;
9618                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
9619             {
9620               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts0), n_elts);
9621               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts1), n_elts);
9622             }
9623
9624           return build_vector (rtype, nreverse (n_elts));
9625         }
9626       break;
9627
9628     case CODE_FOR_pdist_vis:
9629       arg0 = args[0];
9630       arg1 = args[1];
9631       arg2 = args[2];
9632       STRIP_NOPS (arg0);
9633       STRIP_NOPS (arg1);
9634       STRIP_NOPS (arg2);
9635
9636       if (TREE_CODE (arg0) == VECTOR_CST
9637           && TREE_CODE (arg1) == VECTOR_CST
9638           && TREE_CODE (arg2) == INTEGER_CST)
9639         {
9640           int overflow = 0;
9641           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg2);
9642           HOST_WIDE_INT high = TREE_INT_CST_HIGH (arg2);
9643           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
9644           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
9645
9646           for (; elts0 && elts1;
9647                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
9648             {
9649               unsigned HOST_WIDE_INT
9650                 low0 = TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9651                 low1 = TREE_INT_CST_LOW (TREE_VALUE (elts1));
9652               HOST_WIDE_INT high0 = TREE_INT_CST_HIGH (TREE_VALUE (elts0));
9653               HOST_WIDE_INT high1 = TREE_INT_CST_HIGH (TREE_VALUE (elts1));
9654
9655               unsigned HOST_WIDE_INT l;
9656               HOST_WIDE_INT h;
9657
9658               overflow |= neg_double (low1, high1, &l, &h);
9659               overflow |= add_double (low0, high0, l, h, &l, &h);
9660               if (h < 0)
9661                 overflow |= neg_double (l, h, &l, &h);
9662
9663               overflow |= add_double (low, high, l, h, &low, &high);
9664             }
9665
9666           gcc_assert (overflow == 0);
9667
9668           return build_int_cst_wide (rtype, low, high);
9669         }
9670
9671     default:
9672       break;
9673     }
9674
9675   return NULL_TREE;
9676 }
9677 \f
9678 /* ??? This duplicates information provided to the compiler by the
9679    ??? scheduler description.  Some day, teach genautomata to output
9680    ??? the latencies and then CSE will just use that.  */
9681
9682 static bool
9683 sparc_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
9684                  int *total, bool speed ATTRIBUTE_UNUSED)
9685 {
9686   enum machine_mode mode = GET_MODE (x);
9687   bool float_mode_p = FLOAT_MODE_P (mode);
9688
9689   switch (code)
9690     {
9691     case CONST_INT:
9692       if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
9693         {
9694           *total = 0;
9695           return true;
9696         }
9697       /* FALLTHRU */
9698
9699     case HIGH:
9700       *total = 2;
9701       return true;
9702
9703     case CONST:
9704     case LABEL_REF:
9705     case SYMBOL_REF:
9706       *total = 4;
9707       return true;
9708
9709     case CONST_DOUBLE:
9710       if (GET_MODE (x) == VOIDmode
9711           && ((CONST_DOUBLE_HIGH (x) == 0
9712                && CONST_DOUBLE_LOW (x) < 0x1000)
9713               || (CONST_DOUBLE_HIGH (x) == -1
9714                   && CONST_DOUBLE_LOW (x) < 0
9715                   && CONST_DOUBLE_LOW (x) >= -0x1000)))
9716         *total = 0;
9717       else
9718         *total = 8;
9719       return true;
9720
9721     case MEM:
9722       /* If outer-code was a sign or zero extension, a cost
9723          of COSTS_N_INSNS (1) was already added in.  This is
9724          why we are subtracting it back out.  */
9725       if (outer_code == ZERO_EXTEND)
9726         {
9727           *total = sparc_costs->int_zload - COSTS_N_INSNS (1);
9728         }
9729       else if (outer_code == SIGN_EXTEND)
9730         {
9731           *total = sparc_costs->int_sload - COSTS_N_INSNS (1);
9732         }
9733       else if (float_mode_p)
9734         {
9735           *total = sparc_costs->float_load;
9736         }
9737       else
9738         {
9739           *total = sparc_costs->int_load;
9740         }
9741
9742       return true;
9743
9744     case PLUS:
9745     case MINUS:
9746       if (float_mode_p)
9747         *total = sparc_costs->float_plusminus;
9748       else
9749         *total = COSTS_N_INSNS (1);
9750       return false;
9751
9752     case FMA:
9753       {
9754         rtx sub;
9755
9756         gcc_assert (float_mode_p);
9757         *total = sparc_costs->float_mul;
9758
9759         sub = XEXP (x, 0);
9760         if (GET_CODE (sub) == NEG)
9761           sub = XEXP (sub, 0);
9762         *total += rtx_cost (sub, FMA, 0, speed);
9763
9764         sub = XEXP (x, 2);
9765         if (GET_CODE (sub) == NEG)
9766           sub = XEXP (sub, 0);
9767         *total += rtx_cost (sub, FMA, 2, speed);
9768         return true;
9769       }
9770
9771     case MULT:
9772       if (float_mode_p)
9773         *total = sparc_costs->float_mul;
9774       else if (! TARGET_HARD_MUL)
9775         *total = COSTS_N_INSNS (25);
9776       else
9777         {
9778           int bit_cost;
9779
9780           bit_cost = 0;
9781           if (sparc_costs->int_mul_bit_factor)
9782             {
9783               int nbits;
9784
9785               if (GET_CODE (XEXP (x, 1)) == CONST_INT)
9786                 {
9787                   unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
9788                   for (nbits = 0; value != 0; value &= value - 1)
9789                     nbits++;
9790                 }
9791               else if (GET_CODE (XEXP (x, 1)) == CONST_DOUBLE
9792                        && GET_MODE (XEXP (x, 1)) == VOIDmode)
9793                 {
9794                   rtx x1 = XEXP (x, 1);
9795                   unsigned HOST_WIDE_INT value1 = CONST_DOUBLE_LOW (x1);
9796                   unsigned HOST_WIDE_INT value2 = CONST_DOUBLE_HIGH (x1);
9797
9798                   for (nbits = 0; value1 != 0; value1 &= value1 - 1)
9799                     nbits++;
9800                   for (; value2 != 0; value2 &= value2 - 1)
9801                     nbits++;
9802                 }
9803               else
9804                 nbits = 7;
9805
9806               if (nbits < 3)
9807                 nbits = 3;
9808               bit_cost = (nbits - 3) / sparc_costs->int_mul_bit_factor;
9809               bit_cost = COSTS_N_INSNS (bit_cost);
9810             }
9811
9812           if (mode == DImode)
9813             *total = sparc_costs->int_mulX + bit_cost;
9814           else
9815             *total = sparc_costs->int_mul + bit_cost;
9816         }
9817       return false;
9818
9819     case ASHIFT:
9820     case ASHIFTRT:
9821     case LSHIFTRT:
9822       *total = COSTS_N_INSNS (1) + sparc_costs->shift_penalty;
9823       return false;
9824
9825     case DIV:
9826     case UDIV:
9827     case MOD:
9828     case UMOD:
9829       if (float_mode_p)
9830         {
9831           if (mode == DFmode)
9832             *total = sparc_costs->float_div_df;
9833           else
9834             *total = sparc_costs->float_div_sf;
9835         }
9836       else
9837         {
9838           if (mode == DImode)
9839             *total = sparc_costs->int_divX;
9840           else
9841             *total = sparc_costs->int_div;
9842         }
9843       return false;
9844
9845     case NEG:
9846       if (! float_mode_p)
9847         {
9848           *total = COSTS_N_INSNS (1);
9849           return false;
9850         }
9851       /* FALLTHRU */
9852
9853     case ABS:
9854     case FLOAT:
9855     case UNSIGNED_FLOAT:
9856     case FIX:
9857     case UNSIGNED_FIX:
9858     case FLOAT_EXTEND:
9859     case FLOAT_TRUNCATE:
9860       *total = sparc_costs->float_move;
9861       return false;
9862
9863     case SQRT:
9864       if (mode == DFmode)
9865         *total = sparc_costs->float_sqrt_df;
9866       else
9867         *total = sparc_costs->float_sqrt_sf;
9868       return false;
9869
9870     case COMPARE:
9871       if (float_mode_p)
9872         *total = sparc_costs->float_cmp;
9873       else
9874         *total = COSTS_N_INSNS (1);
9875       return false;
9876
9877     case IF_THEN_ELSE:
9878       if (float_mode_p)
9879         *total = sparc_costs->float_cmove;
9880       else
9881         *total = sparc_costs->int_cmove;
9882       return false;
9883
9884     case IOR:
9885       /* Handle the NAND vector patterns.  */
9886       if (sparc_vector_mode_supported_p (GET_MODE (x))
9887           && GET_CODE (XEXP (x, 0)) == NOT
9888           && GET_CODE (XEXP (x, 1)) == NOT)
9889         {
9890           *total = COSTS_N_INSNS (1);
9891           return true;
9892         }
9893       else
9894         return false;
9895
9896     default:
9897       return false;
9898     }
9899 }
9900
9901 /* Return true if CLASS is either GENERAL_REGS or I64_REGS.  */
9902
9903 static inline bool
9904 general_or_i64_p (reg_class_t rclass)
9905 {
9906   return (rclass == GENERAL_REGS || rclass == I64_REGS);
9907 }
9908
9909 /* Implement TARGET_REGISTER_MOVE_COST.  */
9910
9911 static int
9912 sparc_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
9913                           reg_class_t from, reg_class_t to)
9914 {
9915   if ((FP_REG_CLASS_P (from) && general_or_i64_p (to))
9916       || (general_or_i64_p (from) && FP_REG_CLASS_P (to))
9917       || from == FPCC_REGS
9918       || to == FPCC_REGS)
9919     {
9920       if (sparc_cpu == PROCESSOR_ULTRASPARC
9921           || sparc_cpu == PROCESSOR_ULTRASPARC3
9922           || sparc_cpu == PROCESSOR_NIAGARA
9923           || sparc_cpu == PROCESSOR_NIAGARA2
9924           || sparc_cpu == PROCESSOR_NIAGARA3
9925           || sparc_cpu == PROCESSOR_NIAGARA4)
9926         return 12;
9927
9928       return 6;
9929     }
9930
9931   return 2;
9932 }
9933
9934 /* Emit the sequence of insns SEQ while preserving the registers REG and REG2.
9935    This is achieved by means of a manual dynamic stack space allocation in
9936    the current frame.  We make the assumption that SEQ doesn't contain any
9937    function calls, with the possible exception of calls to the GOT helper.  */
9938
9939 static void
9940 emit_and_preserve (rtx seq, rtx reg, rtx reg2)
9941 {
9942   /* We must preserve the lowest 16 words for the register save area.  */
9943   HOST_WIDE_INT offset = 16*UNITS_PER_WORD;
9944   /* We really need only 2 words of fresh stack space.  */
9945   HOST_WIDE_INT size = SPARC_STACK_ALIGN (offset + 2*UNITS_PER_WORD);
9946
9947   rtx slot
9948     = gen_rtx_MEM (word_mode, plus_constant (stack_pointer_rtx,
9949                                              SPARC_STACK_BIAS + offset));
9950
9951   emit_insn (gen_stack_pointer_dec (GEN_INT (size)));
9952   emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
9953   if (reg2)
9954     emit_insn (gen_rtx_SET (VOIDmode,
9955                             adjust_address (slot, word_mode, UNITS_PER_WORD),
9956                             reg2));
9957   emit_insn (seq);
9958   if (reg2)
9959     emit_insn (gen_rtx_SET (VOIDmode,
9960                             reg2,
9961                             adjust_address (slot, word_mode, UNITS_PER_WORD)));
9962   emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
9963   emit_insn (gen_stack_pointer_inc (GEN_INT (size)));
9964 }
9965
9966 /* Output the assembler code for a thunk function.  THUNK_DECL is the
9967    declaration for the thunk function itself, FUNCTION is the decl for
9968    the target function.  DELTA is an immediate constant offset to be
9969    added to THIS.  If VCALL_OFFSET is nonzero, the word at address
9970    (*THIS + VCALL_OFFSET) should be additionally added to THIS.  */
9971
9972 static void
9973 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
9974                        HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
9975                        tree function)
9976 {
9977   rtx this_rtx, insn, funexp;
9978   unsigned int int_arg_first;
9979
9980   reload_completed = 1;
9981   epilogue_completed = 1;
9982
9983   emit_note (NOTE_INSN_PROLOGUE_END);
9984
9985   if (TARGET_FLAT)
9986     {
9987       sparc_leaf_function_p = 1;
9988
9989       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
9990     }
9991   else if (flag_delayed_branch)
9992     {
9993       /* We will emit a regular sibcall below, so we need to instruct
9994          output_sibcall that we are in a leaf function.  */
9995       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 1;
9996
9997       /* This will cause final.c to invoke leaf_renumber_regs so we
9998          must behave as if we were in a not-yet-leafified function.  */
9999       int_arg_first = SPARC_INCOMING_INT_ARG_FIRST;
10000     }
10001   else
10002     {
10003       /* We will emit the sibcall manually below, so we will need to
10004          manually spill non-leaf registers.  */
10005       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 0;
10006
10007       /* We really are in a leaf function.  */
10008       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
10009     }
10010
10011   /* Find the "this" pointer.  Normally in %o0, but in ARCH64 if the function
10012      returns a structure, the structure return pointer is there instead.  */
10013   if (TARGET_ARCH64
10014       && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
10015     this_rtx = gen_rtx_REG (Pmode, int_arg_first + 1);
10016   else
10017     this_rtx = gen_rtx_REG (Pmode, int_arg_first);
10018
10019   /* Add DELTA.  When possible use a plain add, otherwise load it into
10020      a register first.  */
10021   if (delta)
10022     {
10023       rtx delta_rtx = GEN_INT (delta);
10024
10025       if (! SPARC_SIMM13_P (delta))
10026         {
10027           rtx scratch = gen_rtx_REG (Pmode, 1);
10028           emit_move_insn (scratch, delta_rtx);
10029           delta_rtx = scratch;
10030         }
10031
10032       /* THIS_RTX += DELTA.  */
10033       emit_insn (gen_add2_insn (this_rtx, delta_rtx));
10034     }
10035
10036   /* Add the word at address (*THIS_RTX + VCALL_OFFSET).  */
10037   if (vcall_offset)
10038     {
10039       rtx vcall_offset_rtx = GEN_INT (vcall_offset);
10040       rtx scratch = gen_rtx_REG (Pmode, 1);
10041
10042       gcc_assert (vcall_offset < 0);
10043
10044       /* SCRATCH = *THIS_RTX.  */
10045       emit_move_insn (scratch, gen_rtx_MEM (Pmode, this_rtx));
10046
10047       /* Prepare for adding VCALL_OFFSET.  The difficulty is that we
10048          may not have any available scratch register at this point.  */
10049       if (SPARC_SIMM13_P (vcall_offset))
10050         ;
10051       /* This is the case if ARCH64 (unless -ffixed-g5 is passed).  */
10052       else if (! fixed_regs[5]
10053                /* The below sequence is made up of at least 2 insns,
10054                   while the default method may need only one.  */
10055                && vcall_offset < -8192)
10056         {
10057           rtx scratch2 = gen_rtx_REG (Pmode, 5);
10058           emit_move_insn (scratch2, vcall_offset_rtx);
10059           vcall_offset_rtx = scratch2;
10060         }
10061       else
10062         {
10063           rtx increment = GEN_INT (-4096);
10064
10065           /* VCALL_OFFSET is a negative number whose typical range can be
10066              estimated as -32768..0 in 32-bit mode.  In almost all cases
10067              it is therefore cheaper to emit multiple add insns than
10068              spilling and loading the constant into a register (at least
10069              6 insns).  */
10070           while (! SPARC_SIMM13_P (vcall_offset))
10071             {
10072               emit_insn (gen_add2_insn (scratch, increment));
10073               vcall_offset += 4096;
10074             }
10075           vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */
10076         }
10077
10078       /* SCRATCH = *(*THIS_RTX + VCALL_OFFSET).  */
10079       emit_move_insn (scratch, gen_rtx_MEM (Pmode,
10080                                             gen_rtx_PLUS (Pmode,
10081                                                           scratch,
10082                                                           vcall_offset_rtx)));
10083
10084       /* THIS_RTX += *(*THIS_RTX + VCALL_OFFSET).  */
10085       emit_insn (gen_add2_insn (this_rtx, scratch));
10086     }
10087
10088   /* Generate a tail call to the target function.  */
10089   if (! TREE_USED (function))
10090     {
10091       assemble_external (function);
10092       TREE_USED (function) = 1;
10093     }
10094   funexp = XEXP (DECL_RTL (function), 0);
10095
10096   if (flag_delayed_branch)
10097     {
10098       funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
10099       insn = emit_call_insn (gen_sibcall (funexp));
10100       SIBLING_CALL_P (insn) = 1;
10101     }
10102   else
10103     {
10104       /* The hoops we have to jump through in order to generate a sibcall
10105          without using delay slots...  */
10106       rtx spill_reg, seq, scratch = gen_rtx_REG (Pmode, 1);
10107
10108       if (flag_pic)
10109         {
10110           spill_reg = gen_rtx_REG (word_mode, 15);  /* %o7 */
10111           start_sequence ();
10112           load_got_register ();  /* clobbers %o7 */
10113           scratch = sparc_legitimize_pic_address (funexp, scratch);
10114           seq = get_insns ();
10115           end_sequence ();
10116           emit_and_preserve (seq, spill_reg, pic_offset_table_rtx);
10117         }
10118       else if (TARGET_ARCH32)
10119         {
10120           emit_insn (gen_rtx_SET (VOIDmode,
10121                                   scratch,
10122                                   gen_rtx_HIGH (SImode, funexp)));
10123           emit_insn (gen_rtx_SET (VOIDmode,
10124                                   scratch,
10125                                   gen_rtx_LO_SUM (SImode, scratch, funexp)));
10126         }
10127       else  /* TARGET_ARCH64 */
10128         {
10129           switch (sparc_cmodel)
10130             {
10131             case CM_MEDLOW:
10132             case CM_MEDMID:
10133               /* The destination can serve as a temporary.  */
10134               sparc_emit_set_symbolic_const64 (scratch, funexp, scratch);
10135               break;
10136
10137             case CM_MEDANY:
10138             case CM_EMBMEDANY:
10139               /* The destination cannot serve as a temporary.  */
10140               spill_reg = gen_rtx_REG (DImode, 15);  /* %o7 */
10141               start_sequence ();
10142               sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
10143               seq = get_insns ();
10144               end_sequence ();
10145               emit_and_preserve (seq, spill_reg, 0);
10146               break;
10147
10148             default:
10149               gcc_unreachable ();
10150             }
10151         }
10152
10153       emit_jump_insn (gen_indirect_jump (scratch));
10154     }
10155
10156   emit_barrier ();
10157
10158   /* Run just enough of rest_of_compilation to get the insns emitted.
10159      There's not really enough bulk here to make other passes such as
10160      instruction scheduling worth while.  Note that use_thunk calls
10161      assemble_start_function and assemble_end_function.  */
10162   insn = get_insns ();
10163   insn_locators_alloc ();
10164   shorten_branches (insn);
10165   final_start_function (insn, file, 1);
10166   final (insn, file, 1);
10167   final_end_function ();
10168
10169   reload_completed = 0;
10170   epilogue_completed = 0;
10171 }
10172
10173 /* Return true if sparc_output_mi_thunk would be able to output the
10174    assembler code for the thunk function specified by the arguments
10175    it is passed, and false otherwise.  */
10176 static bool
10177 sparc_can_output_mi_thunk (const_tree thunk_fndecl ATTRIBUTE_UNUSED,
10178                            HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
10179                            HOST_WIDE_INT vcall_offset,
10180                            const_tree function ATTRIBUTE_UNUSED)
10181 {
10182   /* Bound the loop used in the default method above.  */
10183   return (vcall_offset >= -32768 || ! fixed_regs[5]);
10184 }
10185
10186 /* How to allocate a 'struct machine_function'.  */
10187
10188 static struct machine_function *
10189 sparc_init_machine_status (void)
10190 {
10191   return ggc_alloc_cleared_machine_function ();
10192 }
10193
10194 /* Locate some local-dynamic symbol still in use by this function
10195    so that we can print its name in local-dynamic base patterns.  */
10196
10197 static const char *
10198 get_some_local_dynamic_name (void)
10199 {
10200   rtx insn;
10201
10202   if (cfun->machine->some_ld_name)
10203     return cfun->machine->some_ld_name;
10204
10205   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
10206     if (INSN_P (insn)
10207         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
10208       return cfun->machine->some_ld_name;
10209
10210   gcc_unreachable ();
10211 }
10212
10213 static int
10214 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
10215 {
10216   rtx x = *px;
10217
10218   if (x
10219       && GET_CODE (x) == SYMBOL_REF
10220       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
10221     {
10222       cfun->machine->some_ld_name = XSTR (x, 0);
10223       return 1;
10224     }
10225
10226   return 0;
10227 }
10228
10229 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
10230    We need to emit DTP-relative relocations.  */
10231
10232 static void
10233 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
10234 {
10235   switch (size)
10236     {
10237     case 4:
10238       fputs ("\t.word\t%r_tls_dtpoff32(", file);
10239       break;
10240     case 8:
10241       fputs ("\t.xword\t%r_tls_dtpoff64(", file);
10242       break;
10243     default:
10244       gcc_unreachable ();
10245     }
10246   output_addr_const (file, x);
10247   fputs (")", file);
10248 }
10249
10250 /* Do whatever processing is required at the end of a file.  */
10251
10252 static void
10253 sparc_file_end (void)
10254 {
10255   /* If we need to emit the special GOT helper function, do so now.  */
10256   if (got_helper_rtx)
10257     {
10258       const char *name = XSTR (got_helper_rtx, 0);
10259       const char *reg_name = reg_names[GLOBAL_OFFSET_TABLE_REGNUM];
10260 #ifdef DWARF2_UNWIND_INFO
10261       bool do_cfi;
10262 #endif
10263
10264       if (USE_HIDDEN_LINKONCE)
10265         {
10266           tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
10267                                   get_identifier (name),
10268                                   build_function_type_list (void_type_node,
10269                                                             NULL_TREE));
10270           DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
10271                                            NULL_TREE, void_type_node);
10272           TREE_STATIC (decl) = 1;
10273           make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
10274           DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
10275           DECL_VISIBILITY_SPECIFIED (decl) = 1;
10276           resolve_unique_section (decl, 0, flag_function_sections);
10277           allocate_struct_function (decl, true);
10278           cfun->is_thunk = 1;
10279           current_function_decl = decl;
10280           init_varasm_status ();
10281           assemble_start_function (decl, name);
10282         }
10283       else
10284         {
10285           const int align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
10286           switch_to_section (text_section);
10287           if (align > 0)
10288             ASM_OUTPUT_ALIGN (asm_out_file, align);
10289           ASM_OUTPUT_LABEL (asm_out_file, name);
10290         }
10291
10292 #ifdef DWARF2_UNWIND_INFO
10293       do_cfi = dwarf2out_do_cfi_asm ();
10294       if (do_cfi)
10295         fprintf (asm_out_file, "\t.cfi_startproc\n");
10296 #endif
10297       if (flag_delayed_branch)
10298         fprintf (asm_out_file, "\tjmp\t%%o7+8\n\t add\t%%o7, %s, %s\n",
10299                  reg_name, reg_name);
10300       else
10301         fprintf (asm_out_file, "\tadd\t%%o7, %s, %s\n\tjmp\t%%o7+8\n\t nop\n",
10302                  reg_name, reg_name);
10303 #ifdef DWARF2_UNWIND_INFO
10304       if (do_cfi)
10305         fprintf (asm_out_file, "\t.cfi_endproc\n");
10306 #endif
10307     }
10308
10309   if (NEED_INDICATE_EXEC_STACK)
10310     file_end_indicate_exec_stack ();
10311
10312 #ifdef TARGET_SOLARIS
10313   solaris_file_end ();
10314 #endif
10315 }
10316
10317 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
10318 /* Implement TARGET_MANGLE_TYPE.  */
10319
10320 static const char *
10321 sparc_mangle_type (const_tree type)
10322 {
10323   if (!TARGET_64BIT
10324       && TYPE_MAIN_VARIANT (type) == long_double_type_node
10325       && TARGET_LONG_DOUBLE_128)
10326     return "g";
10327
10328   /* For all other types, use normal C++ mangling.  */
10329   return NULL;
10330 }
10331 #endif
10332
10333 /* Expand code to perform a 8 or 16-bit compare and swap by doing 32-bit
10334    compare and swap on the word containing the byte or half-word.  */
10335
10336 void
10337 sparc_expand_compare_and_swap_12 (rtx result, rtx mem, rtx oldval, rtx newval)
10338 {
10339   rtx addr1 = force_reg (Pmode, XEXP (mem, 0));
10340   rtx addr = gen_reg_rtx (Pmode);
10341   rtx off = gen_reg_rtx (SImode);
10342   rtx oldv = gen_reg_rtx (SImode);
10343   rtx newv = gen_reg_rtx (SImode);
10344   rtx oldvalue = gen_reg_rtx (SImode);
10345   rtx newvalue = gen_reg_rtx (SImode);
10346   rtx res = gen_reg_rtx (SImode);
10347   rtx resv = gen_reg_rtx (SImode);
10348   rtx memsi, val, mask, end_label, loop_label, cc;
10349
10350   emit_insn (gen_rtx_SET (VOIDmode, addr,
10351                           gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
10352
10353   if (Pmode != SImode)
10354     addr1 = gen_lowpart (SImode, addr1);
10355   emit_insn (gen_rtx_SET (VOIDmode, off,
10356                           gen_rtx_AND (SImode, addr1, GEN_INT (3))));
10357
10358   memsi = gen_rtx_MEM (SImode, addr);
10359   set_mem_alias_set (memsi, ALIAS_SET_MEMORY_BARRIER);
10360   MEM_VOLATILE_P (memsi) = MEM_VOLATILE_P (mem);
10361
10362   val = force_reg (SImode, memsi);
10363
10364   emit_insn (gen_rtx_SET (VOIDmode, off,
10365                           gen_rtx_XOR (SImode, off,
10366                                        GEN_INT (GET_MODE (mem) == QImode
10367                                                 ? 3 : 2))));
10368
10369   emit_insn (gen_rtx_SET (VOIDmode, off,
10370                           gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
10371
10372   if (GET_MODE (mem) == QImode)
10373     mask = force_reg (SImode, GEN_INT (0xff));
10374   else
10375     mask = force_reg (SImode, GEN_INT (0xffff));
10376
10377   emit_insn (gen_rtx_SET (VOIDmode, mask,
10378                           gen_rtx_ASHIFT (SImode, mask, off)));
10379
10380   emit_insn (gen_rtx_SET (VOIDmode, val,
10381                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
10382                                        val)));
10383
10384   oldval = gen_lowpart (SImode, oldval);
10385   emit_insn (gen_rtx_SET (VOIDmode, oldv,
10386                           gen_rtx_ASHIFT (SImode, oldval, off)));
10387
10388   newval = gen_lowpart_common (SImode, newval);
10389   emit_insn (gen_rtx_SET (VOIDmode, newv,
10390                           gen_rtx_ASHIFT (SImode, newval, off)));
10391
10392   emit_insn (gen_rtx_SET (VOIDmode, oldv,
10393                           gen_rtx_AND (SImode, oldv, mask)));
10394
10395   emit_insn (gen_rtx_SET (VOIDmode, newv,
10396                           gen_rtx_AND (SImode, newv, mask)));
10397
10398   end_label = gen_label_rtx ();
10399   loop_label = gen_label_rtx ();
10400   emit_label (loop_label);
10401
10402   emit_insn (gen_rtx_SET (VOIDmode, oldvalue,
10403                           gen_rtx_IOR (SImode, oldv, val)));
10404
10405   emit_insn (gen_rtx_SET (VOIDmode, newvalue,
10406                           gen_rtx_IOR (SImode, newv, val)));
10407
10408   emit_insn (gen_sync_compare_and_swapsi (res, memsi, oldvalue, newvalue));
10409
10410   emit_cmp_and_jump_insns (res, oldvalue, EQ, NULL, SImode, 0, end_label);
10411
10412   emit_insn (gen_rtx_SET (VOIDmode, resv,
10413                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
10414                                        res)));
10415
10416   cc = gen_compare_reg_1 (NE, resv, val);
10417   emit_insn (gen_rtx_SET (VOIDmode, val, resv));
10418
10419   /* Use cbranchcc4 to separate the compare and branch!  */
10420   emit_jump_insn (gen_cbranchcc4 (gen_rtx_NE (VOIDmode, cc, const0_rtx),
10421                                   cc, const0_rtx, loop_label));
10422
10423   emit_label (end_label);
10424
10425   emit_insn (gen_rtx_SET (VOIDmode, res,
10426                           gen_rtx_AND (SImode, res, mask)));
10427
10428   emit_insn (gen_rtx_SET (VOIDmode, res,
10429                           gen_rtx_LSHIFTRT (SImode, res, off)));
10430
10431   emit_move_insn (result, gen_lowpart (GET_MODE (result), res));
10432 }
10433
10434 /* Implement TARGET_FRAME_POINTER_REQUIRED.  */
10435
10436 static bool
10437 sparc_frame_pointer_required (void)
10438 {
10439   /* If the stack pointer is dynamically modified in the function, it cannot
10440      serve as the frame pointer.  */
10441   if (cfun->calls_alloca)
10442     return true;
10443
10444   /* If the function receives nonlocal gotos, it needs to save the frame
10445      pointer in the nonlocal_goto_save_area object.  */
10446   if (cfun->has_nonlocal_label)
10447     return true;
10448
10449   /* In flat mode, that's it.  */
10450   if (TARGET_FLAT)
10451     return false;
10452
10453   /* Otherwise, the frame pointer is required if the function isn't leaf.  */
10454   return !(current_function_is_leaf && only_leaf_regs_used ());
10455 }
10456
10457 /* The way this is structured, we can't eliminate SFP in favor of SP
10458    if the frame pointer is required: we want to use the SFP->HFP elimination
10459    in that case.  But the test in update_eliminables doesn't know we are
10460    assuming below that we only do the former elimination.  */
10461
10462 static bool
10463 sparc_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
10464 {
10465   return to == HARD_FRAME_POINTER_REGNUM || !sparc_frame_pointer_required ();
10466 }
10467
10468 /* Return the hard frame pointer directly to bypass the stack bias.  */
10469
10470 static rtx
10471 sparc_builtin_setjmp_frame_value (void)
10472 {
10473   return hard_frame_pointer_rtx;
10474 }
10475
10476 /* If !TARGET_FPU, then make the fp registers and fp cc regs fixed so that
10477    they won't be allocated.  */
10478
10479 static void
10480 sparc_conditional_register_usage (void)
10481 {
10482   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
10483     {
10484       fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
10485       call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
10486     }
10487   /* If the user has passed -f{fixed,call-{used,saved}}-g5 */
10488   /* then honor it.  */
10489   if (TARGET_ARCH32 && fixed_regs[5])
10490     fixed_regs[5] = 1;
10491   else if (TARGET_ARCH64 && fixed_regs[5] == 2)
10492     fixed_regs[5] = 0;
10493   if (! TARGET_V9)
10494     {
10495       int regno;
10496       for (regno = SPARC_FIRST_V9_FP_REG;
10497            regno <= SPARC_LAST_V9_FP_REG;
10498            regno++)
10499         fixed_regs[regno] = 1;
10500       /* %fcc0 is used by v8 and v9.  */
10501       for (regno = SPARC_FIRST_V9_FCC_REG + 1;
10502            regno <= SPARC_LAST_V9_FCC_REG;
10503            regno++)
10504         fixed_regs[regno] = 1;
10505     }
10506   if (! TARGET_FPU)
10507     {
10508       int regno;
10509       for (regno = 32; regno < SPARC_LAST_V9_FCC_REG; regno++)
10510         fixed_regs[regno] = 1;
10511     }
10512   /* If the user has passed -f{fixed,call-{used,saved}}-g2 */
10513   /* then honor it.  Likewise with g3 and g4.  */
10514   if (fixed_regs[2] == 2)
10515     fixed_regs[2] = ! TARGET_APP_REGS;
10516   if (fixed_regs[3] == 2)
10517     fixed_regs[3] = ! TARGET_APP_REGS;
10518   if (TARGET_ARCH32 && fixed_regs[4] == 2)
10519     fixed_regs[4] = ! TARGET_APP_REGS;
10520   else if (TARGET_CM_EMBMEDANY)
10521     fixed_regs[4] = 1;
10522   else if (fixed_regs[4] == 2)
10523     fixed_regs[4] = 0;
10524   if (TARGET_FLAT)
10525     {
10526       int regno;
10527       /* Disable leaf functions.  */
10528       memset (sparc_leaf_regs, 0, FIRST_PSEUDO_REGISTER);
10529       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
10530         leaf_reg_remap [regno] = regno;
10531     }
10532   if (TARGET_VIS)
10533     global_regs[SPARC_GSR_REG] = 1;
10534 }
10535
10536 /* Implement TARGET_PREFERRED_RELOAD_CLASS
10537
10538    - We can't load constants into FP registers.
10539    - We can't load FP constants into integer registers when soft-float,
10540      because there is no soft-float pattern with a r/F constraint.
10541    - We can't load FP constants into integer registers for TFmode unless
10542      it is 0.0L, because there is no movtf pattern with a r/F constraint.
10543    - Try and reload integer constants (symbolic or otherwise) back into
10544      registers directly, rather than having them dumped to memory.  */
10545
10546 static reg_class_t
10547 sparc_preferred_reload_class (rtx x, reg_class_t rclass)
10548 {
10549   if (CONSTANT_P (x))
10550     {
10551       if (FP_REG_CLASS_P (rclass)
10552           || rclass == GENERAL_OR_FP_REGS
10553           || rclass == GENERAL_OR_EXTRA_FP_REGS
10554           || (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT && ! TARGET_FPU)
10555           || (GET_MODE (x) == TFmode && ! const_zero_operand (x, TFmode)))
10556         return NO_REGS;
10557
10558       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_INT)
10559         return GENERAL_REGS;
10560     }
10561
10562   return rclass;
10563 }
10564
10565 #include "gt-sparc.h"