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