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