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