gcc/config/sparc/sparc.c

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