gcc/config/sparc/sparc.c

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