gcc/config/sparc/sparc.c

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