gcc/config/sparc/sparc.c

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