gcc/config/sparc/sparc.c

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