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