gcc/config/sparc/sparc.c

   1 /* Subroutines for insn-output.c for SPARC.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   4    2011, 2012
   5    Free Software Foundation, Inc.
   6    Contributed by Michael Tiemann (tiemann@cygnus.com)
   7    64-bit SPARC-V9 support by Michael Tiemann, Jim Wilson, and Doug Evans,
   8    at Cygnus Support.
   9
  10 This file is part of GCC.
  11
  12 GCC is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 3, or (at your option)
  15 any later version.
  16
  17 GCC is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with GCC; see the file COPYING3.  If not see
  24 <http://www.gnu.org/licenses/>.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "tree.h"
  31 #include "rtl.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "insn-config.h"
  35 #include "insn-codes.h"
  36 #include "conditions.h"
  37 #include "output.h"
  38 #include "insn-attr.h"
  39 #include "flags.h"
  40 #include "function.h"
  41 #include "except.h"
  42 #include "expr.h"
  43 #include "optabs.h"
  44 #include "recog.h"
  45 #include "diagnostic-core.h"
  46 #include "ggc.h"
  47 #include "tm_p.h"
  48 #include "debug.h"
  49 #include "target.h"
  50 #include "target-def.h"
  51 #include "common/common-target.h"
  52 #include "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             {
2728               tree expr = MEM_EXPR (this_arg);
2729               if (expr)
2730                 mark_addressable (expr);
2731               this_arg = XEXP (this_arg, 0);
2732             }
2733           else if (CONSTANT_P (this_arg)
2734                    && ! force_stack_temp)
2735             {
2736               this_slot = force_const_mem (TFmode, this_arg);
2737               this_arg = XEXP (this_slot, 0);
2738             }
2739           else
2740             {
2741               this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2742
2743               /* Operand 0 is the return value.  We'll copy it out later.  */
2744               if (i > 0)
2745                 emit_move_insn (this_slot, this_arg);
2746               else
2747                 ret_slot = this_slot;
2748
2749               this_arg = XEXP (this_slot, 0);
2750             }
2751         }
2752
2753       arg[i] = this_arg;
2754     }
2755
2756   func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2757
2758   if (GET_MODE (operands[0]) == TFmode)
2759     {
2760       if (nargs == 2)
2761         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2762                            arg[0], GET_MODE (arg[0]),
2763                            arg[1], GET_MODE (arg[1]));
2764       else
2765         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2766                            arg[0], GET_MODE (arg[0]),
2767                            arg[1], GET_MODE (arg[1]),
2768                            arg[2], GET_MODE (arg[2]));
2769
2770       if (ret_slot)
2771         emit_move_insn (operands[0], ret_slot);
2772     }
2773   else
2774     {
2775       rtx ret;
2776
2777       gcc_assert (nargs == 2);
2778
2779       ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2780                                      GET_MODE (operands[0]), 1,
2781                                      arg[1], GET_MODE (arg[1]));
2782
2783       if (ret != operands[0])
2784         emit_move_insn (operands[0], ret);
2785     }
2786 }
2787
2788 /* Expand soft-float TFmode calls to sparc abi routines.  */
2789
2790 static void
2791 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2792 {
2793   const char *func;
2794
2795   switch (code)
2796     {
2797     case PLUS:
2798       func = "_Qp_add";
2799       break;
2800     case MINUS:
2801       func = "_Qp_sub";
2802       break;
2803     case MULT:
2804       func = "_Qp_mul";
2805       break;
2806     case DIV:
2807       func = "_Qp_div";
2808       break;
2809     default:
2810       gcc_unreachable ();
2811     }
2812
2813   emit_soft_tfmode_libcall (func, 3, operands);
2814 }
2815
2816 static void
2817 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2818 {
2819   const char *func;
2820
2821   gcc_assert (code == SQRT);
2822   func = "_Qp_sqrt";
2823
2824   emit_soft_tfmode_libcall (func, 2, operands);
2825 }
2826
2827 static void
2828 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2829 {
2830   const char *func;
2831
2832   switch (code)
2833     {
2834     case FLOAT_EXTEND:
2835       switch (GET_MODE (operands[1]))
2836         {
2837         case SFmode:
2838           func = "_Qp_stoq";
2839           break;
2840         case DFmode:
2841           func = "_Qp_dtoq";
2842           break;
2843         default:
2844           gcc_unreachable ();
2845         }
2846       break;
2847
2848     case FLOAT_TRUNCATE:
2849       switch (GET_MODE (operands[0]))
2850         {
2851         case SFmode:
2852           func = "_Qp_qtos";
2853           break;
2854         case DFmode:
2855           func = "_Qp_qtod";
2856           break;
2857         default:
2858           gcc_unreachable ();
2859         }
2860       break;
2861
2862     case FLOAT:
2863       switch (GET_MODE (operands[1]))
2864         {
2865         case SImode:
2866           func = "_Qp_itoq";
2867           if (TARGET_ARCH64)
2868             operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]);
2869           break;
2870         case DImode:
2871           func = "_Qp_xtoq";
2872           break;
2873         default:
2874           gcc_unreachable ();
2875         }
2876       break;
2877
2878     case UNSIGNED_FLOAT:
2879       switch (GET_MODE (operands[1]))
2880         {
2881         case SImode:
2882           func = "_Qp_uitoq";
2883           if (TARGET_ARCH64)
2884             operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
2885           break;
2886         case DImode:
2887           func = "_Qp_uxtoq";
2888           break;
2889         default:
2890           gcc_unreachable ();
2891         }
2892       break;
2893
2894     case FIX:
2895       switch (GET_MODE (operands[0]))
2896         {
2897         case SImode:
2898           func = "_Qp_qtoi";
2899           break;
2900         case DImode:
2901           func = "_Qp_qtox";
2902           break;
2903         default:
2904           gcc_unreachable ();
2905         }
2906       break;
2907
2908     case UNSIGNED_FIX:
2909       switch (GET_MODE (operands[0]))
2910         {
2911         case SImode:
2912           func = "_Qp_qtoui";
2913           break;
2914         case DImode:
2915           func = "_Qp_qtoux";
2916           break;
2917         default:
2918           gcc_unreachable ();
2919         }
2920       break;
2921
2922     default:
2923       gcc_unreachable ();
2924     }
2925
2926   emit_soft_tfmode_libcall (func, 2, operands);
2927 }
2928
2929 /* Expand a hard-float tfmode operation.  All arguments must be in
2930    registers.  */
2931
2932 static void
2933 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2934 {
2935   rtx op, dest;
2936
2937   if (GET_RTX_CLASS (code) == RTX_UNARY)
2938     {
2939       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2940       op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2941     }
2942   else
2943     {
2944       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2945       operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2946       op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2947                            operands[1], operands[2]);
2948     }
2949
2950   if (register_operand (operands[0], VOIDmode))
2951     dest = operands[0];
2952   else
2953     dest = gen_reg_rtx (GET_MODE (operands[0]));
2954
2955   emit_insn (gen_rtx_SET (VOIDmode, dest, op));
2956
2957   if (dest != operands[0])
2958     emit_move_insn (operands[0], dest);
2959 }
2960
2961 void
2962 emit_tfmode_binop (enum rtx_code code, rtx *operands)
2963 {
2964   if (TARGET_HARD_QUAD)
2965     emit_hard_tfmode_operation (code, operands);
2966   else
2967     emit_soft_tfmode_binop (code, operands);
2968 }
2969
2970 void
2971 emit_tfmode_unop (enum rtx_code code, rtx *operands)
2972 {
2973   if (TARGET_HARD_QUAD)
2974     emit_hard_tfmode_operation (code, operands);
2975   else
2976     emit_soft_tfmode_unop (code, operands);
2977 }
2978
2979 void
2980 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
2981 {
2982   if (TARGET_HARD_QUAD)
2983     emit_hard_tfmode_operation (code, operands);
2984   else
2985     emit_soft_tfmode_cvt (code, operands);
2986 }
2987 \f
2988 /* Return nonzero if a branch/jump/call instruction will be emitting
2989    nop into its delay slot.  */
2990
2991 int
2992 empty_delay_slot (rtx insn)
2993 {
2994   rtx seq;
2995
2996   /* If no previous instruction (should not happen), return true.  */
2997   if (PREV_INSN (insn) == NULL)
2998     return 1;
2999
3000   seq = NEXT_INSN (PREV_INSN (insn));
3001   if (GET_CODE (PATTERN (seq)) == SEQUENCE)
3002     return 0;
3003
3004   return 1;
3005 }
3006
3007 /* Return nonzero if TRIAL can go into the call delay slot.  */
3008
3009 int
3010 tls_call_delay (rtx trial)
3011 {
3012   rtx pat;
3013
3014   /* Binutils allows
3015        call __tls_get_addr, %tgd_call (foo)
3016         add %l7, %o0, %o0, %tgd_add (foo)
3017      while Sun as/ld does not.  */
3018   if (TARGET_GNU_TLS || !TARGET_TLS)
3019     return 1;
3020
3021   pat = PATTERN (trial);
3022
3023   /* We must reject tgd_add{32|64}, i.e.
3024        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSGD)))
3025      and tldm_add{32|64}, i.e.
3026        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSLDM)))
3027      for Sun as/ld.  */
3028   if (GET_CODE (pat) == SET
3029       && GET_CODE (SET_SRC (pat)) == PLUS)
3030     {
3031       rtx unspec = XEXP (SET_SRC (pat), 1);
3032
3033       if (GET_CODE (unspec) == UNSPEC
3034           && (XINT (unspec, 1) == UNSPEC_TLSGD
3035               || XINT (unspec, 1) == UNSPEC_TLSLDM))
3036         return 0;
3037     }
3038
3039   return 1;
3040 }
3041
3042 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
3043    instruction.  RETURN_P is true if the v9 variant 'return' is to be
3044    considered in the test too.
3045
3046    TRIAL must be a SET whose destination is a REG appropriate for the
3047    'restore' instruction or, if RETURN_P is true, for the 'return'
3048    instruction.  */
3049
3050 static int
3051 eligible_for_restore_insn (rtx trial, bool return_p)
3052 {
3053   rtx pat = PATTERN (trial);
3054   rtx src = SET_SRC (pat);
3055   bool src_is_freg = false;
3056   rtx src_reg;
3057
3058   /* Since we now can do moves between float and integer registers when
3059      VIS3 is enabled, we have to catch this case.  We can allow such
3060      moves when doing a 'return' however.  */
3061   src_reg = src;
3062   if (GET_CODE (src_reg) == SUBREG)
3063     src_reg = SUBREG_REG (src_reg);
3064   if (GET_CODE (src_reg) == REG
3065       && SPARC_FP_REG_P (REGNO (src_reg)))
3066     src_is_freg = true;
3067
3068   /* The 'restore src,%g0,dest' pattern for word mode and below.  */
3069   if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3070       && arith_operand (src, GET_MODE (src))
3071       && ! src_is_freg)
3072     {
3073       if (TARGET_ARCH64)
3074         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3075       else
3076         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
3077     }
3078
3079   /* The 'restore src,%g0,dest' pattern for double-word mode.  */
3080   else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
3081            && arith_double_operand (src, GET_MODE (src))
3082            && ! src_is_freg)
3083     return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
3084
3085   /* The 'restore src,%g0,dest' pattern for float if no FPU.  */
3086   else if (! TARGET_FPU && register_operand (src, SFmode))
3087     return 1;
3088
3089   /* The 'restore src,%g0,dest' pattern for double if no FPU.  */
3090   else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
3091     return 1;
3092
3093   /* If we have the 'return' instruction, anything that does not use
3094      local or output registers and can go into a delay slot wins.  */
3095   else if (return_p
3096            && TARGET_V9
3097            && !epilogue_renumber (&pat, 1)
3098            && get_attr_in_uncond_branch_delay (trial)
3099                == IN_UNCOND_BRANCH_DELAY_TRUE)
3100     return 1;
3101
3102   /* The 'restore src1,src2,dest' pattern for SImode.  */
3103   else if (GET_CODE (src) == PLUS
3104            && register_operand (XEXP (src, 0), SImode)
3105            && arith_operand (XEXP (src, 1), SImode))
3106     return 1;
3107
3108   /* The 'restore src1,src2,dest' pattern for DImode.  */
3109   else if (GET_CODE (src) == PLUS
3110            && register_operand (XEXP (src, 0), DImode)
3111            && arith_double_operand (XEXP (src, 1), DImode))
3112     return 1;
3113
3114   /* The 'restore src1,%lo(src2),dest' pattern.  */
3115   else if (GET_CODE (src) == LO_SUM
3116            && ! TARGET_CM_MEDMID
3117            && ((register_operand (XEXP (src, 0), SImode)
3118                 && immediate_operand (XEXP (src, 1), SImode))
3119                || (TARGET_ARCH64
3120                    && register_operand (XEXP (src, 0), DImode)
3121                    && immediate_operand (XEXP (src, 1), DImode))))
3122     return 1;
3123
3124   /* The 'restore src,src,dest' pattern.  */
3125   else if (GET_CODE (src) == ASHIFT
3126            && (register_operand (XEXP (src, 0), SImode)
3127                || register_operand (XEXP (src, 0), DImode))
3128            && XEXP (src, 1) == const1_rtx)
3129     return 1;
3130
3131   return 0;
3132 }
3133
3134 /* Return nonzero if TRIAL can go into the function return's delay slot.  */
3135
3136 int
3137 eligible_for_return_delay (rtx trial)
3138 {
3139   int regno;
3140   rtx pat;
3141
3142   if (GET_CODE (trial) != INSN)
3143     return 0;
3144
3145   if (get_attr_length (trial) != 1)
3146     return 0;
3147
3148   /* If the function uses __builtin_eh_return, the eh_return machinery
3149      occupies the delay slot.  */
3150   if (crtl->calls_eh_return)
3151     return 0;
3152
3153   /* In the case of a leaf or flat function, anything can go into the slot.  */
3154   if (sparc_leaf_function_p || TARGET_FLAT)
3155     return
3156       get_attr_in_uncond_branch_delay (trial) == IN_UNCOND_BRANCH_DELAY_TRUE;
3157
3158   pat = PATTERN (trial);
3159   if (GET_CODE (pat) == PARALLEL)
3160     {
3161       int i;
3162
3163       if (! TARGET_V9)
3164         return 0;
3165       for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
3166         {
3167           rtx expr = XVECEXP (pat, 0, i);
3168           if (GET_CODE (expr) != SET)
3169             return 0;
3170           if (GET_CODE (SET_DEST (expr)) != REG)
3171             return 0;
3172           regno = REGNO (SET_DEST (expr));
3173           if (regno >= 8 && regno < 24)
3174             return 0;
3175         }
3176       return !epilogue_renumber (&pat, 1)
3177         && (get_attr_in_uncond_branch_delay (trial)
3178             == IN_UNCOND_BRANCH_DELAY_TRUE);
3179     }
3180
3181   if (GET_CODE (pat) != SET)
3182     return 0;
3183
3184   if (GET_CODE (SET_DEST (pat)) != REG)
3185     return 0;
3186
3187   regno = REGNO (SET_DEST (pat));
3188
3189   /* Otherwise, only operations which can be done in tandem with
3190      a `restore' or `return' insn can go into the delay slot.  */
3191   if (regno >= 8 && regno < 24)
3192     return 0;
3193
3194   /* If this instruction sets up floating point register and we have a return
3195      instruction, it can probably go in.  But restore will not work
3196      with FP_REGS.  */
3197   if (! SPARC_INT_REG_P (regno))
3198     return (TARGET_V9
3199             && !epilogue_renumber (&pat, 1)
3200             && get_attr_in_uncond_branch_delay (trial)
3201                == IN_UNCOND_BRANCH_DELAY_TRUE);
3202
3203   return eligible_for_restore_insn (trial, true);
3204 }
3205
3206 /* Return nonzero if TRIAL can go into the sibling call's delay slot.  */
3207
3208 int
3209 eligible_for_sibcall_delay (rtx trial)
3210 {
3211   rtx pat;
3212
3213   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
3214     return 0;
3215
3216   if (get_attr_length (trial) != 1)
3217     return 0;
3218
3219   pat = PATTERN (trial);
3220
3221   if (sparc_leaf_function_p || TARGET_FLAT)
3222     {
3223       /* If the tail call is done using the call instruction,
3224          we have to restore %o7 in the delay slot.  */
3225       if (LEAF_SIBCALL_SLOT_RESERVED_P)
3226         return 0;
3227
3228       /* %g1 is used to build the function address */
3229       if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
3230         return 0;
3231
3232       return 1;
3233     }
3234
3235   /* Otherwise, only operations which can be done in tandem with
3236      a `restore' insn can go into the delay slot.  */
3237   if (GET_CODE (SET_DEST (pat)) != REG
3238       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
3239       || ! SPARC_INT_REG_P (REGNO (SET_DEST (pat))))
3240     return 0;
3241
3242   /* If it mentions %o7, it can't go in, because sibcall will clobber it
3243      in most cases.  */
3244   if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
3245     return 0;
3246
3247   return eligible_for_restore_insn (trial, false);
3248 }
3249 \f
3250 /* Determine if it's legal to put X into the constant pool.  This
3251    is not possible if X contains the address of a symbol that is
3252    not constant (TLS) or not known at final link time (PIC).  */
3253
3254 static bool
3255 sparc_cannot_force_const_mem (enum machine_mode mode, rtx x)
3256 {
3257   switch (GET_CODE (x))
3258     {
3259     case CONST_INT:
3260     case CONST_DOUBLE:
3261     case CONST_VECTOR:
3262       /* Accept all non-symbolic constants.  */
3263       return false;
3264
3265     case LABEL_REF:
3266       /* Labels are OK iff we are non-PIC.  */
3267       return flag_pic != 0;
3268
3269     case SYMBOL_REF:
3270       /* 'Naked' TLS symbol references are never OK,
3271          non-TLS symbols are OK iff we are non-PIC.  */
3272       if (SYMBOL_REF_TLS_MODEL (x))
3273         return true;
3274       else
3275         return flag_pic != 0;
3276
3277     case CONST:
3278       return sparc_cannot_force_const_mem (mode, XEXP (x, 0));
3279     case PLUS:
3280     case MINUS:
3281       return sparc_cannot_force_const_mem (mode, XEXP (x, 0))
3282          || sparc_cannot_force_const_mem (mode, XEXP (x, 1));
3283     case UNSPEC:
3284       return true;
3285     default:
3286       gcc_unreachable ();
3287     }
3288 }
3289 \f
3290 /* Global Offset Table support.  */
3291 static GTY(()) rtx got_helper_rtx = NULL_RTX;
3292 static GTY(()) rtx global_offset_table_rtx = NULL_RTX;
3293
3294 /* Return the SYMBOL_REF for the Global Offset Table.  */
3295
3296 static GTY(()) rtx sparc_got_symbol = NULL_RTX;
3297
3298 static rtx
3299 sparc_got (void)
3300 {
3301   if (!sparc_got_symbol)
3302     sparc_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3303
3304   return sparc_got_symbol;
3305 }
3306
3307 /* Ensure that we are not using patterns that are not OK with PIC.  */
3308
3309 int
3310 check_pic (int i)
3311 {
3312   rtx op;
3313
3314   switch (flag_pic)
3315     {
3316     case 1:
3317       op = recog_data.operand[i];
3318       gcc_assert (GET_CODE (op) != SYMBOL_REF
3319                   && (GET_CODE (op) != CONST
3320                       || (GET_CODE (XEXP (op, 0)) == MINUS
3321                           && XEXP (XEXP (op, 0), 0) == sparc_got ()
3322                           && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST)));
3323     case 2:
3324     default:
3325       return 1;
3326     }
3327 }
3328
3329 /* Return true if X is an address which needs a temporary register when
3330    reloaded while generating PIC code.  */
3331
3332 int
3333 pic_address_needs_scratch (rtx x)
3334 {
3335   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
3336   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3337       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3338       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3339       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
3340     return 1;
3341
3342   return 0;
3343 }
3344
3345 /* Determine if a given RTX is a valid constant.  We already know this
3346    satisfies CONSTANT_P.  */
3347
3348 static bool
3349 sparc_legitimate_constant_p (enum machine_mode mode, rtx x)
3350 {
3351   switch (GET_CODE (x))
3352     {
3353     case CONST:
3354     case SYMBOL_REF:
3355       if (sparc_tls_referenced_p (x))
3356         return false;
3357       break;
3358
3359     case CONST_DOUBLE:
3360       if (GET_MODE (x) == VOIDmode)
3361         return true;
3362
3363       /* Floating point constants are generally not ok.
3364          The only exception is 0.0 and all-ones in VIS.  */
3365       if (TARGET_VIS
3366           && SCALAR_FLOAT_MODE_P (mode)
3367           && (const_zero_operand (x, mode)
3368               || const_all_ones_operand (x, mode)))
3369         return true;
3370
3371       return false;
3372
3373     case CONST_VECTOR:
3374       /* Vector constants are generally not ok.
3375          The only exception is 0 or -1 in VIS.  */
3376       if (TARGET_VIS
3377           && (const_zero_operand (x, mode)
3378               || const_all_ones_operand (x, mode)))
3379         return true;
3380
3381       return false;
3382
3383     default:
3384       break;
3385     }
3386
3387   return true;
3388 }
3389
3390 /* Determine if a given RTX is a valid constant address.  */
3391
3392 bool
3393 constant_address_p (rtx x)
3394 {
3395   switch (GET_CODE (x))
3396     {
3397     case LABEL_REF:
3398     case CONST_INT:
3399     case HIGH:
3400       return true;
3401
3402     case CONST:
3403       if (flag_pic && pic_address_needs_scratch (x))
3404         return false;
3405       return sparc_legitimate_constant_p (Pmode, x);
3406
3407     case SYMBOL_REF:
3408       return !flag_pic && sparc_legitimate_constant_p (Pmode, x);
3409
3410     default:
3411       return false;
3412     }
3413 }
3414
3415 /* Nonzero if the constant value X is a legitimate general operand
3416    when generating PIC code.  It is given that flag_pic is on and
3417    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
3418
3419 bool
3420 legitimate_pic_operand_p (rtx x)
3421 {
3422   if (pic_address_needs_scratch (x))
3423     return false;
3424   if (sparc_tls_referenced_p (x))
3425     return false;
3426   return true;
3427 }
3428
3429 #define RTX_OK_FOR_OFFSET_P(X, MODE)                    \
3430   (CONST_INT_P (X)                                      \
3431    && INTVAL (X) >= -0x1000                             \
3432    && INTVAL (X) < (0x1000 - GET_MODE_SIZE (MODE)))
3433
3434 #define RTX_OK_FOR_OLO10_P(X, MODE)                     \
3435   (CONST_INT_P (X)                                      \
3436    && INTVAL (X) >= -0x1000                             \
3437    && INTVAL (X) < (0xc00 - GET_MODE_SIZE (MODE)))
3438
3439 /* Handle the TARGET_LEGITIMATE_ADDRESS_P target hook.
3440
3441    On SPARC, the actual legitimate addresses must be REG+REG or REG+SMALLINT
3442    ordinarily.  This changes a bit when generating PIC.  */
3443
3444 static bool
3445 sparc_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3446 {
3447   rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3448
3449   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3450     rs1 = addr;
3451   else if (GET_CODE (addr) == PLUS)
3452     {
3453       rs1 = XEXP (addr, 0);
3454       rs2 = XEXP (addr, 1);
3455
3456       /* Canonicalize.  REG comes first, if there are no regs,
3457          LO_SUM comes first.  */
3458       if (!REG_P (rs1)
3459           && GET_CODE (rs1) != SUBREG
3460           && (REG_P (rs2)
3461               || GET_CODE (rs2) == SUBREG
3462               || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3463         {
3464           rs1 = XEXP (addr, 1);
3465           rs2 = XEXP (addr, 0);
3466         }
3467
3468       if ((flag_pic == 1
3469            && rs1 == pic_offset_table_rtx
3470            && !REG_P (rs2)
3471            && GET_CODE (rs2) != SUBREG
3472            && GET_CODE (rs2) != LO_SUM
3473            && GET_CODE (rs2) != MEM
3474            && !(GET_CODE (rs2) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs2))
3475            && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3476            && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3477           || ((REG_P (rs1)
3478                || GET_CODE (rs1) == SUBREG)
3479               && RTX_OK_FOR_OFFSET_P (rs2, mode)))
3480         {
3481           imm1 = rs2;
3482           rs2 = NULL;
3483         }
3484       else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3485                && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3486         {
3487           /* We prohibit REG + REG for TFmode when there are no quad move insns
3488              and we consequently need to split.  We do this because REG+REG
3489              is not an offsettable address.  If we get the situation in reload
3490              where source and destination of a movtf pattern are both MEMs with
3491              REG+REG address, then only one of them gets converted to an
3492              offsettable address.  */
3493           if (mode == TFmode
3494               && ! (TARGET_ARCH64 && TARGET_HARD_QUAD))
3495             return 0;
3496
3497           /* We prohibit REG + REG on ARCH32 if not optimizing for
3498              DFmode/DImode because then mem_min_alignment is likely to be zero
3499              after reload and the  forced split would lack a matching splitter
3500              pattern.  */
3501           if (TARGET_ARCH32 && !optimize
3502               && (mode == DFmode || mode == DImode))
3503             return 0;
3504         }
3505       else if (USE_AS_OFFSETABLE_LO10
3506                && GET_CODE (rs1) == LO_SUM
3507                && TARGET_ARCH64
3508                && ! TARGET_CM_MEDMID
3509                && RTX_OK_FOR_OLO10_P (rs2, mode))
3510         {
3511           rs2 = NULL;
3512           imm1 = XEXP (rs1, 1);
3513           rs1 = XEXP (rs1, 0);
3514           if (!CONSTANT_P (imm1)
3515               || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3516             return 0;
3517         }
3518     }
3519   else if (GET_CODE (addr) == LO_SUM)
3520     {
3521       rs1 = XEXP (addr, 0);
3522       imm1 = XEXP (addr, 1);
3523
3524       if (!CONSTANT_P (imm1)
3525           || (GET_CODE (rs1) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (rs1)))
3526         return 0;
3527
3528       /* We can't allow TFmode in 32-bit mode, because an offset greater
3529          than the alignment (8) may cause the LO_SUM to overflow.  */
3530       if (mode == TFmode && TARGET_ARCH32)
3531         return 0;
3532     }
3533   else if (GET_CODE (addr) == CONST_INT && SMALL_INT (addr))
3534     return 1;
3535   else
3536     return 0;
3537
3538   if (GET_CODE (rs1) == SUBREG)
3539     rs1 = SUBREG_REG (rs1);
3540   if (!REG_P (rs1))
3541     return 0;
3542
3543   if (rs2)
3544     {
3545       if (GET_CODE (rs2) == SUBREG)
3546         rs2 = SUBREG_REG (rs2);
3547       if (!REG_P (rs2))
3548         return 0;
3549     }
3550
3551   if (strict)
3552     {
3553       if (!REGNO_OK_FOR_BASE_P (REGNO (rs1))
3554           || (rs2 && !REGNO_OK_FOR_BASE_P (REGNO (rs2))))
3555         return 0;
3556     }
3557   else
3558     {
3559       if ((! SPARC_INT_REG_P (REGNO (rs1))
3560            && REGNO (rs1) != FRAME_POINTER_REGNUM
3561            && REGNO (rs1) < FIRST_PSEUDO_REGISTER)
3562           || (rs2
3563               && (! SPARC_INT_REG_P (REGNO (rs2))
3564                   && REGNO (rs2) != FRAME_POINTER_REGNUM
3565                   && REGNO (rs2) < FIRST_PSEUDO_REGISTER)))
3566         return 0;
3567     }
3568   return 1;
3569 }
3570
3571 /* Return the SYMBOL_REF for the tls_get_addr function.  */
3572
3573 static GTY(()) rtx sparc_tls_symbol = NULL_RTX;
3574
3575 static rtx
3576 sparc_tls_get_addr (void)
3577 {
3578   if (!sparc_tls_symbol)
3579     sparc_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_addr");
3580
3581   return sparc_tls_symbol;
3582 }
3583
3584 /* Return the Global Offset Table to be used in TLS mode.  */
3585
3586 static rtx
3587 sparc_tls_got (void)
3588 {
3589   /* In PIC mode, this is just the PIC offset table.  */
3590   if (flag_pic)
3591     {
3592       crtl->uses_pic_offset_table = 1;
3593       return pic_offset_table_rtx;
3594     }
3595
3596   /* In non-PIC mode, Sun as (unlike GNU as) emits PC-relative relocations for
3597      the GOT symbol with the 32-bit ABI, so we reload the GOT register.  */
3598   if (TARGET_SUN_TLS && TARGET_ARCH32)
3599     {
3600       load_got_register ();
3601       return global_offset_table_rtx;
3602     }
3603
3604   /* In all other cases, we load a new pseudo with the GOT symbol.  */
3605   return copy_to_reg (sparc_got ());
3606 }
3607
3608 /* Return true if X contains a thread-local symbol.  */
3609
3610 static bool
3611 sparc_tls_referenced_p (rtx x)
3612 {
3613   if (!TARGET_HAVE_TLS)
3614     return false;
3615
3616   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS)
3617     x = XEXP (XEXP (x, 0), 0);
3618
3619   if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x))
3620     return true;
3621
3622   /* That's all we handle in sparc_legitimize_tls_address for now.  */
3623   return false;
3624 }
3625
3626 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3627    this (thread-local) address.  */
3628
3629 static rtx
3630 sparc_legitimize_tls_address (rtx addr)
3631 {
3632   rtx temp1, temp2, temp3, ret, o0, got, insn;
3633
3634   gcc_assert (can_create_pseudo_p ());
3635
3636   if (GET_CODE (addr) == SYMBOL_REF)
3637     switch (SYMBOL_REF_TLS_MODEL (addr))
3638       {
3639       case TLS_MODEL_GLOBAL_DYNAMIC:
3640         start_sequence ();
3641         temp1 = gen_reg_rtx (SImode);
3642         temp2 = gen_reg_rtx (SImode);
3643         ret = gen_reg_rtx (Pmode);
3644         o0 = gen_rtx_REG (Pmode, 8);
3645         got = sparc_tls_got ();
3646         emit_insn (gen_tgd_hi22 (temp1, addr));
3647         emit_insn (gen_tgd_lo10 (temp2, temp1, addr));
3648         if (TARGET_ARCH32)
3649           {
3650             emit_insn (gen_tgd_add32 (o0, got, temp2, addr));
3651             insn = emit_call_insn (gen_tgd_call32 (o0, sparc_tls_get_addr (),
3652                                                    addr, const1_rtx));
3653           }
3654         else
3655           {
3656             emit_insn (gen_tgd_add64 (o0, got, temp2, addr));
3657             insn = emit_call_insn (gen_tgd_call64 (o0, sparc_tls_get_addr (),
3658                                                    addr, const1_rtx));
3659           }
3660         use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
3661         insn = get_insns ();
3662         end_sequence ();
3663         emit_libcall_block (insn, ret, o0, addr);
3664         break;
3665
3666       case TLS_MODEL_LOCAL_DYNAMIC:
3667         start_sequence ();
3668         temp1 = gen_reg_rtx (SImode);
3669         temp2 = gen_reg_rtx (SImode);
3670         temp3 = gen_reg_rtx (Pmode);
3671         ret = gen_reg_rtx (Pmode);
3672         o0 = gen_rtx_REG (Pmode, 8);
3673         got = sparc_tls_got ();
3674         emit_insn (gen_tldm_hi22 (temp1));
3675         emit_insn (gen_tldm_lo10 (temp2, temp1));
3676         if (TARGET_ARCH32)
3677           {
3678             emit_insn (gen_tldm_add32 (o0, got, temp2));
3679             insn = emit_call_insn (gen_tldm_call32 (o0, sparc_tls_get_addr (),
3680                                                     const1_rtx));
3681           }
3682         else
3683           {
3684             emit_insn (gen_tldm_add64 (o0, got, temp2));
3685             insn = emit_call_insn (gen_tldm_call64 (o0, sparc_tls_get_addr (),
3686                                                     const1_rtx));
3687           }
3688         use_reg (&CALL_INSN_FUNCTION_USAGE (insn), o0);
3689         insn = get_insns ();
3690         end_sequence ();
3691         emit_libcall_block (insn, temp3, o0,
3692                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3693                                             UNSPEC_TLSLD_BASE));
3694         temp1 = gen_reg_rtx (SImode);
3695         temp2 = gen_reg_rtx (SImode);
3696         emit_insn (gen_tldo_hix22 (temp1, addr));
3697         emit_insn (gen_tldo_lox10 (temp2, temp1, addr));
3698         if (TARGET_ARCH32)
3699           emit_insn (gen_tldo_add32 (ret, temp3, temp2, addr));
3700         else
3701           emit_insn (gen_tldo_add64 (ret, temp3, temp2, addr));
3702         break;
3703
3704       case TLS_MODEL_INITIAL_EXEC:
3705         temp1 = gen_reg_rtx (SImode);
3706         temp2 = gen_reg_rtx (SImode);
3707         temp3 = gen_reg_rtx (Pmode);
3708         got = sparc_tls_got ();
3709         emit_insn (gen_tie_hi22 (temp1, addr));
3710         emit_insn (gen_tie_lo10 (temp2, temp1, addr));
3711         if (TARGET_ARCH32)
3712           emit_insn (gen_tie_ld32 (temp3, got, temp2, addr));
3713         else
3714           emit_insn (gen_tie_ld64 (temp3, got, temp2, addr));
3715         if (TARGET_SUN_TLS)
3716           {
3717             ret = gen_reg_rtx (Pmode);
3718             if (TARGET_ARCH32)
3719               emit_insn (gen_tie_add32 (ret, gen_rtx_REG (Pmode, 7),
3720                                         temp3, addr));
3721             else
3722               emit_insn (gen_tie_add64 (ret, gen_rtx_REG (Pmode, 7),
3723                                         temp3, addr));
3724           }
3725         else
3726           ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp3);
3727         break;
3728
3729       case TLS_MODEL_LOCAL_EXEC:
3730         temp1 = gen_reg_rtx (Pmode);
3731         temp2 = gen_reg_rtx (Pmode);
3732         if (TARGET_ARCH32)
3733           {
3734             emit_insn (gen_tle_hix22_sp32 (temp1, addr));
3735             emit_insn (gen_tle_lox10_sp32 (temp2, temp1, addr));
3736           }
3737         else
3738           {
3739             emit_insn (gen_tle_hix22_sp64 (temp1, addr));
3740             emit_insn (gen_tle_lox10_sp64 (temp2, temp1, addr));
3741           }
3742         ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp2);
3743         break;
3744
3745       default:
3746         gcc_unreachable ();
3747       }
3748
3749   else if (GET_CODE (addr) == CONST)
3750     {
3751       rtx base, offset;
3752
3753       gcc_assert (GET_CODE (XEXP (addr, 0)) == PLUS);
3754
3755       base = sparc_legitimize_tls_address (XEXP (XEXP (addr, 0), 0));
3756       offset = XEXP (XEXP (addr, 0), 1);
3757
3758       base = force_operand (base, NULL_RTX);
3759       if (!(GET_CODE (offset) == CONST_INT && SMALL_INT (offset)))
3760         offset = force_reg (Pmode, offset);
3761       ret = gen_rtx_PLUS (Pmode, base, offset);
3762     }
3763
3764   else
3765     gcc_unreachable ();  /* for now ... */
3766
3767   return ret;
3768 }
3769
3770 /* Legitimize PIC addresses.  If the address is already position-independent,
3771    we return ORIG.  Newly generated position-independent addresses go into a
3772    reg.  This is REG if nonzero, otherwise we allocate register(s) as
3773    necessary.  */
3774
3775 static rtx
3776 sparc_legitimize_pic_address (rtx orig, rtx reg)
3777 {
3778   bool gotdata_op = false;
3779
3780   if (GET_CODE (orig) == SYMBOL_REF
3781       /* See the comment in sparc_expand_move.  */
3782       || (GET_CODE (orig) == LABEL_REF && !can_use_mov_pic_label_ref (orig)))
3783     {
3784       rtx pic_ref, address;
3785       rtx insn;
3786
3787       if (reg == 0)
3788         {
3789           gcc_assert (can_create_pseudo_p ());
3790           reg = gen_reg_rtx (Pmode);
3791         }
3792
3793       if (flag_pic == 2)
3794         {
3795           /* If not during reload, allocate another temp reg here for loading
3796              in the address, so that these instructions can be optimized
3797              properly.  */
3798           rtx temp_reg = (! can_create_pseudo_p ()
3799                           ? reg : gen_reg_rtx (Pmode));
3800
3801           /* Must put the SYMBOL_REF inside an UNSPEC here so that cse
3802              won't get confused into thinking that these two instructions
3803              are loading in the true address of the symbol.  If in the
3804              future a PIC rtx exists, that should be used instead.  */
3805           if (TARGET_ARCH64)
3806             {
3807               emit_insn (gen_movdi_high_pic (temp_reg, orig));
3808               emit_insn (gen_movdi_lo_sum_pic (temp_reg, temp_reg, orig));
3809             }
3810           else
3811             {
3812               emit_insn (gen_movsi_high_pic (temp_reg, orig));
3813               emit_insn (gen_movsi_lo_sum_pic (temp_reg, temp_reg, orig));
3814             }
3815           address = temp_reg;
3816           gotdata_op = true;
3817         }
3818       else
3819         address = orig;
3820
3821       crtl->uses_pic_offset_table = 1;
3822       if (gotdata_op)
3823         {
3824           if (TARGET_ARCH64)
3825             insn = emit_insn (gen_movdi_pic_gotdata_op (reg,
3826                                                         pic_offset_table_rtx,
3827                                                         address, orig));
3828           else
3829             insn = emit_insn (gen_movsi_pic_gotdata_op (reg,
3830                                                         pic_offset_table_rtx,
3831                                                         address, orig));
3832         }
3833       else
3834         {
3835           pic_ref
3836             = gen_const_mem (Pmode,
3837                              gen_rtx_PLUS (Pmode,
3838                                            pic_offset_table_rtx, address));
3839           insn = emit_move_insn (reg, pic_ref);
3840         }
3841
3842       /* Put a REG_EQUAL note on this insn, so that it can be optimized
3843          by loop.  */
3844       set_unique_reg_note (insn, REG_EQUAL, orig);
3845       return reg;
3846     }
3847   else if (GET_CODE (orig) == CONST)
3848     {
3849       rtx base, offset;
3850
3851       if (GET_CODE (XEXP (orig, 0)) == PLUS
3852           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
3853         return orig;
3854
3855       if (reg == 0)
3856         {
3857           gcc_assert (can_create_pseudo_p ());
3858           reg = gen_reg_rtx (Pmode);
3859         }
3860
3861       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
3862       base = sparc_legitimize_pic_address (XEXP (XEXP (orig, 0), 0), reg);
3863       offset = sparc_legitimize_pic_address (XEXP (XEXP (orig, 0), 1),
3864                                              base == reg ? NULL_RTX : reg);
3865
3866       if (GET_CODE (offset) == CONST_INT)
3867         {
3868           if (SMALL_INT (offset))
3869             return plus_constant (Pmode, base, INTVAL (offset));
3870           else if (can_create_pseudo_p ())
3871             offset = force_reg (Pmode, offset);
3872           else
3873             /* If we reach here, then something is seriously wrong.  */
3874             gcc_unreachable ();
3875         }
3876       return gen_rtx_PLUS (Pmode, base, offset);
3877     }
3878   else if (GET_CODE (orig) == LABEL_REF)
3879     /* ??? We ought to be checking that the register is live instead, in case
3880        it is eliminated.  */
3881     crtl->uses_pic_offset_table = 1;
3882
3883   return orig;
3884 }
3885
3886 /* Try machine-dependent ways of modifying an illegitimate address X
3887    to be legitimate.  If we find one, return the new, valid address.
3888
3889    OLDX is the address as it was before break_out_memory_refs was called.
3890    In some cases it is useful to look at this to decide what needs to be done.
3891
3892    MODE is the mode of the operand pointed to by X.
3893
3894    On SPARC, change REG+N into REG+REG, and REG+(X*Y) into REG+REG.  */
3895
3896 static rtx
3897 sparc_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3898                           enum machine_mode mode)
3899 {
3900   rtx orig_x = x;
3901
3902   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT)
3903     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3904                       force_operand (XEXP (x, 0), NULL_RTX));
3905   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == MULT)
3906     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3907                       force_operand (XEXP (x, 1), NULL_RTX));
3908   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS)
3909     x = gen_rtx_PLUS (Pmode, force_operand (XEXP (x, 0), NULL_RTX),
3910                       XEXP (x, 1));
3911   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == PLUS)
3912     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3913                       force_operand (XEXP (x, 1), NULL_RTX));
3914
3915   if (x != orig_x && sparc_legitimate_address_p (mode, x, FALSE))
3916     return x;
3917
3918   if (sparc_tls_referenced_p (x))
3919     x = sparc_legitimize_tls_address (x);
3920   else if (flag_pic)
3921     x = sparc_legitimize_pic_address (x, NULL_RTX);
3922   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 1)))
3923     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3924                       copy_to_mode_reg (Pmode, XEXP (x, 1)));
3925   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 0)))
3926     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3927                       copy_to_mode_reg (Pmode, XEXP (x, 0)));
3928   else if (GET_CODE (x) == SYMBOL_REF
3929            || GET_CODE (x) == CONST
3930            || GET_CODE (x) == LABEL_REF)
3931     x = copy_to_suggested_reg (x, NULL_RTX, Pmode);
3932
3933   return x;
3934 }
3935
3936 /* Delegitimize an address that was legitimized by the above function.  */
3937
3938 static rtx
3939 sparc_delegitimize_address (rtx x)
3940 {
3941   x = delegitimize_mem_from_attrs (x);
3942
3943   if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 1)) == UNSPEC)
3944     switch (XINT (XEXP (x, 1), 1))
3945       {
3946       case UNSPEC_MOVE_PIC:
3947       case UNSPEC_TLSLE:
3948         x = XVECEXP (XEXP (x, 1), 0, 0);
3949         gcc_assert (GET_CODE (x) == SYMBOL_REF);
3950         break;
3951       default:
3952         break;
3953       }
3954
3955   /* This is generated by mov{si,di}_pic_label_ref in PIC mode.  */
3956   if (GET_CODE (x) == MINUS
3957       && REG_P (XEXP (x, 0))
3958       && REGNO (XEXP (x, 0)) == PIC_OFFSET_TABLE_REGNUM
3959       && GET_CODE (XEXP (x, 1)) == LO_SUM
3960       && GET_CODE (XEXP (XEXP (x, 1), 1)) == UNSPEC
3961       && XINT (XEXP (XEXP (x, 1), 1), 1) == UNSPEC_MOVE_PIC_LABEL)
3962     {
3963       x = XVECEXP (XEXP (XEXP (x, 1), 1), 0, 0);
3964       gcc_assert (GET_CODE (x) == LABEL_REF);
3965     }
3966
3967   return x;
3968 }
3969
3970 /* SPARC implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
3971    replace the input X, or the original X if no replacement is called for.
3972    The output parameter *WIN is 1 if the calling macro should goto WIN,
3973    0 if it should not.
3974
3975    For SPARC, we wish to handle addresses by splitting them into
3976    HIGH+LO_SUM pairs, retaining the LO_SUM in the memory reference.
3977    This cuts the number of extra insns by one.
3978
3979    Do nothing when generating PIC code and the address is a symbolic
3980    operand or requires a scratch register.  */
3981
3982 rtx
3983 sparc_legitimize_reload_address (rtx x, enum machine_mode mode,
3984                                  int opnum, int type,
3985                                  int ind_levels ATTRIBUTE_UNUSED, int *win)
3986 {
3987   /* Decompose SImode constants into HIGH+LO_SUM.  */
3988   if (CONSTANT_P (x)
3989       && (mode != TFmode || TARGET_ARCH64)
3990       && GET_MODE (x) == SImode
3991       && GET_CODE (x) != LO_SUM
3992       && GET_CODE (x) != HIGH
3993       && sparc_cmodel <= CM_MEDLOW
3994       && !(flag_pic
3995            && (symbolic_operand (x, Pmode) || pic_address_needs_scratch (x))))
3996     {
3997       x = gen_rtx_LO_SUM (GET_MODE (x), gen_rtx_HIGH (GET_MODE (x), x), x);
3998       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3999                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
4000                    opnum, (enum reload_type)type);
4001       *win = 1;
4002       return x;
4003     }
4004
4005   /* We have to recognize what we have already generated above.  */
4006   if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 0)) == HIGH)
4007     {
4008       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
4009                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
4010                    opnum, (enum reload_type)type);
4011       *win = 1;
4012       return x;
4013     }
4014
4015   *win = 0;
4016   return x;
4017 }
4018
4019 /* Return true if ADDR (a legitimate address expression)
4020    has an effect that depends on the machine mode it is used for.
4021
4022    In PIC mode,
4023
4024       (mem:HI [%l7+a])
4025
4026    is not equivalent to
4027
4028       (mem:QI [%l7+a]) (mem:QI [%l7+a+1])
4029
4030    because [%l7+a+1] is interpreted as the address of (a+1).  */
4031
4032
4033 static bool
4034 sparc_mode_dependent_address_p (const_rtx addr)
4035 {
4036   if (flag_pic && GET_CODE (addr) == PLUS)
4037     {
4038       rtx op0 = XEXP (addr, 0);
4039       rtx op1 = XEXP (addr, 1);
4040       if (op0 == pic_offset_table_rtx
4041           && symbolic_operand (op1, VOIDmode))
4042         return true;
4043     }
4044
4045   return false;
4046 }
4047
4048 #ifdef HAVE_GAS_HIDDEN
4049 # define USE_HIDDEN_LINKONCE 1
4050 #else
4051 # define USE_HIDDEN_LINKONCE 0
4052 #endif
4053
4054 static void
4055 get_pc_thunk_name (char name[32], unsigned int regno)
4056 {
4057   const char *reg_name = reg_names[regno];
4058
4059   /* Skip the leading '%' as that cannot be used in a
4060      symbol name.  */
4061   reg_name += 1;
4062
4063   if (USE_HIDDEN_LINKONCE)
4064     sprintf (name, "__sparc_get_pc_thunk.%s", reg_name);
4065   else
4066     ASM_GENERATE_INTERNAL_LABEL (name, "LADDPC", regno);
4067 }
4068
4069 /* Wrapper around the load_pcrel_sym{si,di} patterns.  */
4070
4071 static rtx
4072 gen_load_pcrel_sym (rtx op0, rtx op1, rtx op2, rtx op3)
4073 {
4074   int orig_flag_pic = flag_pic;
4075   rtx insn;
4076
4077   /* The load_pcrel_sym{si,di} patterns require absolute addressing.  */
4078   flag_pic = 0;
4079   if (TARGET_ARCH64)
4080     insn = gen_load_pcrel_symdi (op0, op1, op2, op3);
4081   else
4082     insn = gen_load_pcrel_symsi (op0, op1, op2, op3);
4083   flag_pic = orig_flag_pic;
4084
4085   return insn;
4086 }
4087
4088 /* Emit code to load the GOT register.  */
4089
4090 void
4091 load_got_register (void)
4092 {
4093   /* In PIC mode, this will retrieve pic_offset_table_rtx.  */
4094   if (!global_offset_table_rtx)
4095     global_offset_table_rtx = gen_rtx_REG (Pmode, GLOBAL_OFFSET_TABLE_REGNUM);
4096
4097   if (TARGET_VXWORKS_RTP)
4098     emit_insn (gen_vxworks_load_got ());
4099   else
4100     {
4101       /* The GOT symbol is subject to a PC-relative relocation so we need a
4102          helper function to add the PC value and thus get the final value.  */
4103       if (!got_helper_rtx)
4104         {
4105           char name[32];
4106           get_pc_thunk_name (name, GLOBAL_OFFSET_TABLE_REGNUM);
4107           got_helper_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
4108         }
4109
4110       emit_insn (gen_load_pcrel_sym (global_offset_table_rtx, sparc_got (),
4111                                      got_helper_rtx,
4112                                      GEN_INT (GLOBAL_OFFSET_TABLE_REGNUM)));
4113     }
4114
4115   /* Need to emit this whether or not we obey regdecls,
4116      since setjmp/longjmp can cause life info to screw up.
4117      ??? In the case where we don't obey regdecls, this is not sufficient
4118      since we may not fall out the bottom.  */
4119   emit_use (global_offset_table_rtx);
4120 }
4121
4122 /* Emit a call instruction with the pattern given by PAT.  ADDR is the
4123    address of the call target.  */
4124
4125 void
4126 sparc_emit_call_insn (rtx pat, rtx addr)
4127 {
4128   rtx insn;
4129
4130   insn = emit_call_insn (pat);
4131
4132   /* The PIC register is live on entry to VxWorks PIC PLT entries.  */
4133   if (TARGET_VXWORKS_RTP
4134       && flag_pic
4135       && GET_CODE (addr) == SYMBOL_REF
4136       && (SYMBOL_REF_DECL (addr)
4137           ? !targetm.binds_local_p (SYMBOL_REF_DECL (addr))
4138           : !SYMBOL_REF_LOCAL_P (addr)))
4139     {
4140       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
4141       crtl->uses_pic_offset_table = 1;
4142     }
4143 }
4144 \f
4145 /* Return 1 if RTX is a MEM which is known to be aligned to at
4146    least a DESIRED byte boundary.  */
4147
4148 int
4149 mem_min_alignment (rtx mem, int desired)
4150 {
4151   rtx addr, base, offset;
4152
4153   /* If it's not a MEM we can't accept it.  */
4154   if (GET_CODE (mem) != MEM)
4155     return 0;
4156
4157   /* Obviously...  */
4158   if (!TARGET_UNALIGNED_DOUBLES
4159       && MEM_ALIGN (mem) / BITS_PER_UNIT >= (unsigned)desired)
4160     return 1;
4161
4162   /* ??? The rest of the function predates MEM_ALIGN so
4163      there is probably a bit of redundancy.  */
4164   addr = XEXP (mem, 0);
4165   base = offset = NULL_RTX;
4166   if (GET_CODE (addr) == PLUS)
4167     {
4168       if (GET_CODE (XEXP (addr, 0)) == REG)
4169         {
4170           base = XEXP (addr, 0);
4171
4172           /* What we are saying here is that if the base
4173              REG is aligned properly, the compiler will make
4174              sure any REG based index upon it will be so
4175              as well.  */
4176           if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
4177             offset = XEXP (addr, 1);
4178           else
4179             offset = const0_rtx;
4180         }
4181     }
4182   else if (GET_CODE (addr) == REG)
4183     {
4184       base = addr;
4185       offset = const0_rtx;
4186     }
4187
4188   if (base != NULL_RTX)
4189     {
4190       int regno = REGNO (base);
4191
4192       if (regno != HARD_FRAME_POINTER_REGNUM && regno != STACK_POINTER_REGNUM)
4193         {
4194           /* Check if the compiler has recorded some information
4195              about the alignment of the base REG.  If reload has
4196              completed, we already matched with proper alignments.
4197              If not running global_alloc, reload might give us
4198              unaligned pointer to local stack though.  */
4199           if (((cfun != 0
4200                 && REGNO_POINTER_ALIGN (regno) >= desired * BITS_PER_UNIT)
4201                || (optimize && reload_completed))
4202               && (INTVAL (offset) & (desired - 1)) == 0)
4203             return 1;
4204         }
4205       else
4206         {
4207           if (((INTVAL (offset) - SPARC_STACK_BIAS) & (desired - 1)) == 0)
4208             return 1;
4209         }
4210     }
4211   else if (! TARGET_UNALIGNED_DOUBLES
4212            || CONSTANT_P (addr)
4213            || GET_CODE (addr) == LO_SUM)
4214     {
4215       /* Anything else we know is properly aligned unless TARGET_UNALIGNED_DOUBLES
4216          is true, in which case we can only assume that an access is aligned if
4217          it is to a constant address, or the address involves a LO_SUM.  */
4218       return 1;
4219     }
4220
4221   /* An obviously unaligned address.  */
4222   return 0;
4223 }
4224
4225 \f
4226 /* Vectors to keep interesting information about registers where it can easily
4227    be got.  We used to use the actual mode value as the bit number, but there
4228    are more than 32 modes now.  Instead we use two tables: one indexed by
4229    hard register number, and one indexed by mode.  */
4230
4231 /* The purpose of sparc_mode_class is to shrink the range of modes so that
4232    they all fit (as bit numbers) in a 32-bit word (again).  Each real mode is
4233    mapped into one sparc_mode_class mode.  */
4234
4235 enum sparc_mode_class {
4236   S_MODE, D_MODE, T_MODE, O_MODE,
4237   SF_MODE, DF_MODE, TF_MODE, OF_MODE,
4238   CC_MODE, CCFP_MODE
4239 };
4240
4241 /* Modes for single-word and smaller quantities.  */
4242 #define S_MODES ((1 << (int) S_MODE) | (1 << (int) SF_MODE))
4243
4244 /* Modes for double-word and smaller quantities.  */
4245 #define D_MODES (S_MODES | (1 << (int) D_MODE) | (1 << DF_MODE))
4246
4247 /* Modes for quad-word and smaller quantities.  */
4248 #define T_MODES (D_MODES | (1 << (int) T_MODE) | (1 << (int) TF_MODE))
4249
4250 /* Modes for 8-word and smaller quantities.  */
4251 #define O_MODES (T_MODES | (1 << (int) O_MODE) | (1 << (int) OF_MODE))
4252
4253 /* Modes for single-float quantities.  We must allow any single word or
4254    smaller quantity.  This is because the fix/float conversion instructions
4255    take integer inputs/outputs from the float registers.  */
4256 #define SF_MODES (S_MODES)
4257
4258 /* Modes for double-float and smaller quantities.  */
4259 #define DF_MODES (D_MODES)
4260
4261 /* Modes for quad-float and smaller quantities.  */
4262 #define TF_MODES (DF_MODES | (1 << (int) TF_MODE))
4263
4264 /* Modes for quad-float pairs and smaller quantities.  */
4265 #define OF_MODES (TF_MODES | (1 << (int) OF_MODE))
4266
4267 /* Modes for double-float only quantities.  */
4268 #define DF_MODES_NO_S ((1 << (int) D_MODE) | (1 << (int) DF_MODE))
4269
4270 /* Modes for quad-float and double-float only quantities.  */
4271 #define TF_MODES_NO_S (DF_MODES_NO_S | (1 << (int) TF_MODE))
4272
4273 /* Modes for quad-float pairs and double-float only quantities.  */
4274 #define OF_MODES_NO_S (TF_MODES_NO_S | (1 << (int) OF_MODE))
4275
4276 /* Modes for condition codes.  */
4277 #define CC_MODES (1 << (int) CC_MODE)
4278 #define CCFP_MODES (1 << (int) CCFP_MODE)
4279
4280 /* Value is 1 if register/mode pair is acceptable on sparc.
4281    The funny mixture of D and T modes is because integer operations
4282    do not specially operate on tetra quantities, so non-quad-aligned
4283    registers can hold quadword quantities (except %o4 and %i4 because
4284    they cross fixed registers).  */
4285
4286 /* This points to either the 32 bit or the 64 bit version.  */
4287 const int *hard_regno_mode_classes;
4288
4289 static const int hard_32bit_mode_classes[] = {
4290   S_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4291   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4292   T_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
4293   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
4294
4295   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4296   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4297   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4298   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4299
4300   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
4301      and none can hold SFmode/SImode values.  */
4302   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4303   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4304   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4305   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4306
4307   /* %fcc[0123] */
4308   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4309
4310   /* %icc, %sfp, %gsr */
4311   CC_MODES, 0, D_MODES
4312 };
4313
4314 static const int hard_64bit_mode_classes[] = {
4315   D_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4316   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4317   T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4318   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
4319
4320   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4321   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4322   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
4323   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
4324
4325   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
4326      and none can hold SFmode/SImode values.  */
4327   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4328   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4329   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4330   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
4331
4332   /* %fcc[0123] */
4333   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
4334
4335   /* %icc, %sfp, %gsr */
4336   CC_MODES, 0, D_MODES
4337 };
4338
4339 int sparc_mode_class [NUM_MACHINE_MODES];
4340
4341 enum reg_class sparc_regno_reg_class[FIRST_PSEUDO_REGISTER];
4342
4343 static void
4344 sparc_init_modes (void)
4345 {
4346   int i;
4347
4348   for (i = 0; i < NUM_MACHINE_MODES; i++)
4349     {
4350       switch (GET_MODE_CLASS (i))
4351         {
4352         case MODE_INT:
4353         case MODE_PARTIAL_INT:
4354         case MODE_COMPLEX_INT:
4355           if (GET_MODE_SIZE (i) <= 4)
4356             sparc_mode_class[i] = 1 << (int) S_MODE;
4357           else if (GET_MODE_SIZE (i) == 8)
4358             sparc_mode_class[i] = 1 << (int) D_MODE;
4359           else if (GET_MODE_SIZE (i) == 16)
4360             sparc_mode_class[i] = 1 << (int) T_MODE;
4361           else if (GET_MODE_SIZE (i) == 32)
4362             sparc_mode_class[i] = 1 << (int) O_MODE;
4363           else
4364             sparc_mode_class[i] = 0;
4365           break;
4366         case MODE_VECTOR_INT:
4367           if (GET_MODE_SIZE (i) <= 4)
4368             sparc_mode_class[i] = 1 << (int)SF_MODE;
4369           else if (GET_MODE_SIZE (i) == 8)
4370             sparc_mode_class[i] = 1 << (int)DF_MODE;
4371           break;
4372         case MODE_FLOAT:
4373         case MODE_COMPLEX_FLOAT:
4374           if (GET_MODE_SIZE (i) <= 4)
4375             sparc_mode_class[i] = 1 << (int) SF_MODE;
4376           else if (GET_MODE_SIZE (i) == 8)
4377             sparc_mode_class[i] = 1 << (int) DF_MODE;
4378           else if (GET_MODE_SIZE (i) == 16)
4379             sparc_mode_class[i] = 1 << (int) TF_MODE;
4380           else if (GET_MODE_SIZE (i) == 32)
4381             sparc_mode_class[i] = 1 << (int) OF_MODE;
4382           else
4383             sparc_mode_class[i] = 0;
4384           break;
4385         case MODE_CC:
4386           if (i == (int) CCFPmode || i == (int) CCFPEmode)
4387             sparc_mode_class[i] = 1 << (int) CCFP_MODE;
4388           else
4389             sparc_mode_class[i] = 1 << (int) CC_MODE;
4390           break;
4391         default:
4392           sparc_mode_class[i] = 0;
4393           break;
4394         }
4395     }
4396
4397   if (TARGET_ARCH64)
4398     hard_regno_mode_classes = hard_64bit_mode_classes;
4399   else
4400     hard_regno_mode_classes = hard_32bit_mode_classes;
4401
4402   /* Initialize the array used by REGNO_REG_CLASS.  */
4403   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4404     {
4405       if (i < 16 && TARGET_V8PLUS)
4406         sparc_regno_reg_class[i] = I64_REGS;
4407       else if (i < 32 || i == FRAME_POINTER_REGNUM)
4408         sparc_regno_reg_class[i] = GENERAL_REGS;
4409       else if (i < 64)
4410         sparc_regno_reg_class[i] = FP_REGS;
4411       else if (i < 96)
4412         sparc_regno_reg_class[i] = EXTRA_FP_REGS;
4413       else if (i < 100)
4414         sparc_regno_reg_class[i] = FPCC_REGS;
4415       else
4416         sparc_regno_reg_class[i] = NO_REGS;
4417     }
4418 }
4419 \f
4420 /* Return whether REGNO, a global or FP register, must be saved/restored.  */
4421
4422 static inline bool
4423 save_global_or_fp_reg_p (unsigned int regno,
4424                          int leaf_function ATTRIBUTE_UNUSED)
4425 {
4426   return !call_used_regs[regno] && df_regs_ever_live_p (regno);
4427 }
4428
4429 /* Return whether the return address register (%i7) is needed.  */
4430
4431 static inline bool
4432 return_addr_reg_needed_p (int leaf_function)
4433 {
4434   /* If it is live, for example because of __builtin_return_address (0).  */
4435   if (df_regs_ever_live_p (RETURN_ADDR_REGNUM))
4436     return true;
4437
4438   /* Otherwise, it is needed as save register if %o7 is clobbered.  */
4439   if (!leaf_function
4440       /* Loading the GOT register clobbers %o7.  */
4441       || crtl->uses_pic_offset_table
4442       || df_regs_ever_live_p (INCOMING_RETURN_ADDR_REGNUM))
4443     return true;
4444
4445   return false;
4446 }
4447
4448 /* Return whether REGNO, a local or in register, must be saved/restored.  */
4449
4450 static bool
4451 save_local_or_in_reg_p (unsigned int regno, int leaf_function)
4452 {
4453   /* General case: call-saved registers live at some point.  */
4454   if (!call_used_regs[regno] && df_regs_ever_live_p (regno))
4455     return true;
4456
4457   /* Frame pointer register (%fp) if needed.  */
4458   if (regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
4459     return true;
4460
4461   /* Return address register (%i7) if needed.  */
4462   if (regno == RETURN_ADDR_REGNUM && return_addr_reg_needed_p (leaf_function))
4463     return true;
4464
4465   /* GOT register (%l7) if needed.  */
4466   if (regno == PIC_OFFSET_TABLE_REGNUM && crtl->uses_pic_offset_table)
4467     return true;
4468
4469   /* If the function accesses prior frames, the frame pointer and the return
4470      address of the previous frame must be saved on the stack.  */
4471   if (crtl->accesses_prior_frames
4472       && (regno == HARD_FRAME_POINTER_REGNUM || regno == RETURN_ADDR_REGNUM))
4473     return true;
4474
4475   return false;
4476 }
4477
4478 /* Compute the frame size required by the function.  This function is called
4479    during the reload pass and also by sparc_expand_prologue.  */
4480
4481 HOST_WIDE_INT
4482 sparc_compute_frame_size (HOST_WIDE_INT size, int leaf_function)
4483 {
4484   HOST_WIDE_INT frame_size, apparent_frame_size;
4485   int args_size, n_global_fp_regs = 0;
4486   bool save_local_in_regs_p = false;
4487   unsigned int i;
4488
4489   /* If the function allocates dynamic stack space, the dynamic offset is
4490      computed early and contains REG_PARM_STACK_SPACE, so we need to cope.  */
4491   if (leaf_function && !cfun->calls_alloca)
4492     args_size = 0;
4493   else
4494     args_size = crtl->outgoing_args_size + REG_PARM_STACK_SPACE (cfun->decl);
4495
4496   /* Calculate space needed for global registers.  */
4497   if (TARGET_ARCH64)
4498     for (i = 0; i < 8; i++)
4499       if (save_global_or_fp_reg_p (i, 0))
4500         n_global_fp_regs += 2;
4501   else
4502     for (i = 0; i < 8; i += 2)
4503       if (save_global_or_fp_reg_p (i, 0) || save_global_or_fp_reg_p (i + 1, 0))
4504         n_global_fp_regs += 2;
4505
4506   /* In the flat window model, find out which local and in registers need to
4507      be saved.  We don't reserve space in the current frame for them as they
4508      will be spilled into the register window save area of the caller's frame.
4509      However, as soon as we use this register window save area, we must create
4510      that of the current frame to make it the live one.  */
4511   if (TARGET_FLAT)
4512     for (i = 16; i < 32; i++)
4513       if (save_local_or_in_reg_p (i, leaf_function))
4514         {
4515          save_local_in_regs_p = true;
4516          break;
4517         }
4518
4519   /* Calculate space needed for FP registers.  */
4520   for (i = 32; i < (TARGET_V9 ? 96 : 64); i += 2)
4521     if (save_global_or_fp_reg_p (i, 0) || save_global_or_fp_reg_p (i + 1, 0))
4522       n_global_fp_regs += 2;
4523
4524   if (size == 0
4525       && n_global_fp_regs == 0
4526       && args_size == 0
4527       && !save_local_in_regs_p)
4528     frame_size = apparent_frame_size = 0;
4529   else
4530     {
4531       /* We subtract STARTING_FRAME_OFFSET, remember it's negative.  */
4532       apparent_frame_size = (size - STARTING_FRAME_OFFSET + 7) & -8;
4533       apparent_frame_size += n_global_fp_regs * 4;
4534
4535       /* We need to add the size of the outgoing argument area.  */
4536       frame_size = apparent_frame_size + ((args_size + 7) & -8);
4537
4538       /* And that of the register window save area.  */
4539       frame_size += FIRST_PARM_OFFSET (cfun->decl);
4540
4541       /* Finally, bump to the appropriate alignment.  */
4542       frame_size = SPARC_STACK_ALIGN (frame_size);
4543     }
4544
4545   /* Set up values for use in prologue and epilogue.  */
4546   sparc_frame_size = frame_size;
4547   sparc_apparent_frame_size = apparent_frame_size;
4548   sparc_n_global_fp_regs = n_global_fp_regs;
4549   sparc_save_local_in_regs_p = save_local_in_regs_p;
4550
4551   return frame_size;
4552 }
4553
4554 /* Output any necessary .register pseudo-ops.  */
4555
4556 void
4557 sparc_output_scratch_registers (FILE *file ATTRIBUTE_UNUSED)
4558 {
4559 #ifdef HAVE_AS_REGISTER_PSEUDO_OP
4560   int i;
4561
4562   if (TARGET_ARCH32)
4563     return;
4564
4565   /* Check if %g[2367] were used without
4566      .register being printed for them already.  */
4567   for (i = 2; i < 8; i++)
4568     {
4569       if (df_regs_ever_live_p (i)
4570           && ! sparc_hard_reg_printed [i])
4571         {
4572           sparc_hard_reg_printed [i] = 1;
4573           /* %g7 is used as TLS base register, use #ignore
4574              for it instead of #scratch.  */
4575           fprintf (file, "\t.register\t%%g%d, #%s\n", i,
4576                    i == 7 ? "ignore" : "scratch");
4577         }
4578       if (i == 3) i = 5;
4579     }
4580 #endif
4581 }
4582
4583 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
4584
4585 #if PROBE_INTERVAL > 4096
4586 #error Cannot use indexed addressing mode for stack probing
4587 #endif
4588
4589 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
4590    inclusive.  These are offsets from the current stack pointer.
4591
4592    Note that we don't use the REG+REG addressing mode for the probes because
4593    of the stack bias in 64-bit mode.  And it doesn't really buy us anything
4594    so the advantages of having a single code win here.  */
4595
4596 static void
4597 sparc_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
4598 {
4599   rtx g1 = gen_rtx_REG (Pmode, 1);
4600
4601   /* See if we have a constant small number of probes to generate.  If so,
4602      that's the easy case.  */
4603   if (size <= PROBE_INTERVAL)
4604     {
4605       emit_move_insn (g1, GEN_INT (first));
4606       emit_insn (gen_rtx_SET (VOIDmode, g1,
4607                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4608       emit_stack_probe (plus_constant (Pmode, g1, -size));
4609     }
4610
4611   /* The run-time loop is made up of 10 insns in the generic case while the
4612      compile-time loop is made up of 4+2*(n-2) insns for n # of intervals.  */
4613   else if (size <= 5 * PROBE_INTERVAL)
4614     {
4615       HOST_WIDE_INT i;
4616
4617       emit_move_insn (g1, GEN_INT (first + PROBE_INTERVAL));
4618       emit_insn (gen_rtx_SET (VOIDmode, g1,
4619                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4620       emit_stack_probe (g1);
4621
4622       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 2 until
4623          it exceeds SIZE.  If only two probes are needed, this will not
4624          generate any code.  Then probe at FIRST + SIZE.  */
4625       for (i = 2 * PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
4626         {
4627           emit_insn (gen_rtx_SET (VOIDmode, g1,
4628                                   plus_constant (Pmode, g1, -PROBE_INTERVAL)));
4629           emit_stack_probe (g1);
4630         }
4631
4632       emit_stack_probe (plus_constant (Pmode, g1,
4633                                        (i - PROBE_INTERVAL) - size));
4634     }
4635
4636   /* Otherwise, do the same as above, but in a loop.  Note that we must be
4637      extra careful with variables wrapping around because we might be at
4638      the very top (or the very bottom) of the address space and we have
4639      to be able to handle this case properly; in particular, we use an
4640      equality test for the loop condition.  */
4641   else
4642     {
4643       HOST_WIDE_INT rounded_size;
4644       rtx g4 = gen_rtx_REG (Pmode, 4);
4645
4646       emit_move_insn (g1, GEN_INT (first));
4647
4648
4649       /* Step 1: round SIZE to the previous multiple of the interval.  */
4650
4651       rounded_size = size & -PROBE_INTERVAL;
4652       emit_move_insn (g4, GEN_INT (rounded_size));
4653
4654
4655       /* Step 2: compute initial and final value of the loop counter.  */
4656
4657       /* TEST_ADDR = SP + FIRST.  */
4658       emit_insn (gen_rtx_SET (VOIDmode, g1,
4659                               gen_rtx_MINUS (Pmode, stack_pointer_rtx, g1)));
4660
4661       /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE.  */
4662       emit_insn (gen_rtx_SET (VOIDmode, g4, gen_rtx_MINUS (Pmode, g1, g4)));
4663
4664
4665       /* Step 3: the loop
4666
4667          while (TEST_ADDR != LAST_ADDR)
4668            {
4669              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
4670              probe at TEST_ADDR
4671            }
4672
4673          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
4674          until it is equal to ROUNDED_SIZE.  */
4675
4676       if (TARGET_64BIT)
4677         emit_insn (gen_probe_stack_rangedi (g1, g1, g4));
4678       else
4679         emit_insn (gen_probe_stack_rangesi (g1, g1, g4));
4680
4681
4682       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
4683          that SIZE is equal to ROUNDED_SIZE.  */
4684
4685       if (size != rounded_size)
4686         emit_stack_probe (plus_constant (Pmode, g4, rounded_size - size));
4687     }
4688
4689   /* Make sure nothing is scheduled before we are done.  */
4690   emit_insn (gen_blockage ());
4691 }
4692
4693 /* Probe a range of stack addresses from REG1 to REG2 inclusive.  These are
4694    absolute addresses.  */
4695
4696 const char *
4697 output_probe_stack_range (rtx reg1, rtx reg2)
4698 {
4699   static int labelno = 0;
4700   char loop_lab[32], end_lab[32];
4701   rtx xops[2];
4702
4703   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
4704   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
4705
4706   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
4707
4708    /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
4709   xops[0] = reg1;
4710   xops[1] = reg2;
4711   output_asm_insn ("cmp\t%0, %1", xops);
4712   if (TARGET_ARCH64)
4713     fputs ("\tbe,pn\t%xcc,", asm_out_file);
4714   else
4715     fputs ("\tbe\t", asm_out_file);
4716   assemble_name_raw (asm_out_file, end_lab);
4717   fputc ('\n', asm_out_file);
4718
4719   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
4720   xops[1] = GEN_INT (-PROBE_INTERVAL);
4721   output_asm_insn (" add\t%0, %1, %0", xops);
4722
4723   /* Probe at TEST_ADDR and branch.  */
4724   if (TARGET_ARCH64)
4725     fputs ("\tba,pt\t%xcc,", asm_out_file);
4726   else
4727     fputs ("\tba\t", asm_out_file);
4728   assemble_name_raw (asm_out_file, loop_lab);
4729   fputc ('\n', asm_out_file);
4730   xops[1] = GEN_INT (SPARC_STACK_BIAS);
4731   output_asm_insn (" st\t%%g0, [%0+%1]", xops);
4732
4733   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
4734
4735   return "";
4736 }
4737
4738 /* Emit code to save/restore registers from LOW to HIGH at BASE+OFFSET as
4739    needed.  LOW is supposed to be double-word aligned for 32-bit registers.
4740    SAVE_P decides whether a register must be saved/restored.  ACTION_TRUE
4741    is the action to be performed if SAVE_P returns true and ACTION_FALSE
4742    the action to be performed if it returns false.  Return the new offset.  */
4743
4744 typedef bool (*sorr_pred_t) (unsigned int, int);
4745 typedef enum { SORR_NONE, SORR_ADVANCE, SORR_SAVE, SORR_RESTORE } sorr_act_t;
4746
4747 static int
4748 emit_save_or_restore_regs (unsigned int low, unsigned int high, rtx base,
4749                            int offset, int leaf_function, sorr_pred_t save_p,
4750                            sorr_act_t action_true, sorr_act_t action_false)
4751 {
4752   unsigned int i;
4753   rtx mem, insn;
4754
4755   if (TARGET_ARCH64 && high <= 32)
4756     {
4757       int fp_offset = -1;
4758
4759       for (i = low; i < high; i++)
4760         {
4761           if (save_p (i, leaf_function))
4762             {
4763               mem = gen_frame_mem (DImode, plus_constant (Pmode,
4764                                                           base, offset));
4765               if (action_true == SORR_SAVE)
4766                 {
4767                   insn = emit_move_insn (mem, gen_rtx_REG (DImode, i));
4768                   RTX_FRAME_RELATED_P (insn) = 1;
4769                 }
4770               else  /* action_true == SORR_RESTORE */
4771                 {
4772                   /* The frame pointer must be restored last since its old
4773                      value may be used as base address for the frame.  This
4774                      is problematic in 64-bit mode only because of the lack
4775                      of double-word load instruction.  */
4776                   if (i == HARD_FRAME_POINTER_REGNUM)
4777                     fp_offset = offset;
4778                   else
4779                     emit_move_insn (gen_rtx_REG (DImode, i), mem);
4780                 }
4781               offset += 8;
4782             }
4783           else if (action_false == SORR_ADVANCE)
4784             offset += 8;
4785         }
4786
4787       if (fp_offset >= 0)
4788         {
4789           mem = gen_frame_mem (DImode, plus_constant (Pmode, base, fp_offset));
4790           emit_move_insn (hard_frame_pointer_rtx, mem);
4791         }
4792     }
4793   else
4794     {
4795       for (i = low; i < high; i += 2)
4796         {
4797           bool reg0 = save_p (i, leaf_function);
4798           bool reg1 = save_p (i + 1, leaf_function);
4799           enum machine_mode mode;
4800           int regno;
4801
4802           if (reg0 && reg1)
4803             {
4804               mode = SPARC_INT_REG_P (i) ? DImode : DFmode;
4805               regno = i;
4806             }
4807           else if (reg0)
4808             {
4809               mode = SPARC_INT_REG_P (i) ? SImode : SFmode;
4810               regno = i;
4811             }
4812           else if (reg1)
4813             {
4814               mode = SPARC_INT_REG_P (i) ? SImode : SFmode;
4815               regno = i + 1;
4816               offset += 4;
4817             }
4818           else
4819             {
4820               if (action_false == SORR_ADVANCE)
4821                 offset += 8;
4822               continue;
4823             }
4824
4825           mem = gen_frame_mem (mode, plus_constant (Pmode, base, offset));
4826           if (action_true == SORR_SAVE)
4827             {
4828               insn = emit_move_insn (mem, gen_rtx_REG (mode, regno));
4829               RTX_FRAME_RELATED_P (insn) = 1;
4830               if (mode == DImode)
4831                 {
4832                   rtx set1, set2;
4833                   mem = gen_frame_mem (SImode, plus_constant (Pmode, base,
4834                                                               offset));
4835                   set1 = gen_rtx_SET (VOIDmode, mem,
4836                                       gen_rtx_REG (SImode, regno));
4837                   RTX_FRAME_RELATED_P (set1) = 1;
4838                   mem
4839                     = gen_frame_mem (SImode, plus_constant (Pmode, base,
4840                                                             offset + 4));
4841                   set2 = gen_rtx_SET (VOIDmode, mem,
4842                                       gen_rtx_REG (SImode, regno + 1));
4843                   RTX_FRAME_RELATED_P (set2) = 1;
4844                   add_reg_note (insn, REG_FRAME_RELATED_EXPR,
4845                                 gen_rtx_PARALLEL (VOIDmode,
4846                                                   gen_rtvec (2, set1, set2)));
4847                 }
4848             }
4849           else  /* action_true == SORR_RESTORE */
4850             emit_move_insn (gen_rtx_REG (mode, regno), mem);
4851
4852           /* Always preserve double-word alignment.  */
4853           offset = (offset + 8) & -8;
4854         }
4855     }
4856
4857   return offset;
4858 }
4859
4860 /* Emit code to adjust BASE to OFFSET.  Return the new base.  */
4861
4862 static rtx
4863 emit_adjust_base_to_offset (rtx base, int offset)
4864 {
4865   /* ??? This might be optimized a little as %g1 might already have a
4866      value close enough that a single add insn will do.  */
4867   /* ??? Although, all of this is probably only a temporary fix because
4868      if %g1 can hold a function result, then sparc_expand_epilogue will
4869      lose (the result will be clobbered).  */
4870   rtx new_base = gen_rtx_REG (Pmode, 1);
4871   emit_move_insn (new_base, GEN_INT (offset));
4872   emit_insn (gen_rtx_SET (VOIDmode,
4873                           new_base, gen_rtx_PLUS (Pmode, base, new_base)));
4874   return new_base;
4875 }
4876
4877 /* Emit code to save/restore call-saved global and FP registers.  */
4878
4879 static void
4880 emit_save_or_restore_global_fp_regs (rtx base, int offset, sorr_act_t action)
4881 {
4882   if (offset < -4096 || offset + sparc_n_global_fp_regs * 4 > 4095)
4883     {
4884       base = emit_adjust_base_to_offset  (base, offset);
4885       offset = 0;
4886     }
4887
4888   offset
4889     = emit_save_or_restore_regs (0, 8, base, offset, 0,
4890                                  save_global_or_fp_reg_p, action, SORR_NONE);
4891   emit_save_or_restore_regs (32, TARGET_V9 ? 96 : 64, base, offset, 0,
4892                              save_global_or_fp_reg_p, action, SORR_NONE);
4893 }
4894
4895 /* Emit code to save/restore call-saved local and in registers.  */
4896
4897 static void
4898 emit_save_or_restore_local_in_regs (rtx base, int offset, sorr_act_t action)
4899 {
4900   if (offset < -4096 || offset + 16 * UNITS_PER_WORD > 4095)
4901     {
4902       base = emit_adjust_base_to_offset  (base, offset);
4903       offset = 0;
4904     }
4905
4906   emit_save_or_restore_regs (16, 32, base, offset, sparc_leaf_function_p,
4907                              save_local_or_in_reg_p, action, SORR_ADVANCE);
4908 }
4909
4910 /* Emit a window_save insn.  */
4911
4912 static rtx
4913 emit_window_save (rtx increment)
4914 {
4915   rtx insn = emit_insn (gen_window_save (increment));
4916   RTX_FRAME_RELATED_P (insn) = 1;
4917
4918   /* The incoming return address (%o7) is saved in %i7.  */
4919   add_reg_note (insn, REG_CFA_REGISTER,
4920                 gen_rtx_SET (VOIDmode,
4921                              gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM),
4922                              gen_rtx_REG (Pmode,
4923                                           INCOMING_RETURN_ADDR_REGNUM)));
4924
4925   /* The window save event.  */
4926   add_reg_note (insn, REG_CFA_WINDOW_SAVE, const0_rtx);
4927
4928   /* The CFA is %fp, the hard frame pointer.  */
4929   add_reg_note (insn, REG_CFA_DEF_CFA,
4930                 plus_constant (Pmode, hard_frame_pointer_rtx,
4931                                INCOMING_FRAME_SP_OFFSET));
4932
4933   return insn;
4934 }
4935
4936 /* Generate an increment for the stack pointer.  */
4937
4938 static rtx
4939 gen_stack_pointer_inc (rtx increment)
4940 {
4941   return gen_rtx_SET (VOIDmode,
4942                       stack_pointer_rtx,
4943                       gen_rtx_PLUS (Pmode,
4944                                     stack_pointer_rtx,
4945                                     increment));
4946 }
4947
4948 /* Generate a decrement for the stack pointer.  */
4949
4950 static rtx
4951 gen_stack_pointer_dec (rtx decrement)
4952 {
4953   return gen_rtx_SET (VOIDmode,
4954                       stack_pointer_rtx,
4955                       gen_rtx_MINUS (Pmode,
4956                                      stack_pointer_rtx,
4957                                      decrement));
4958 }
4959
4960 /* Expand the function prologue.  The prologue is responsible for reserving
4961    storage for the frame, saving the call-saved registers and loading the
4962    GOT register if needed.  */
4963
4964 void
4965 sparc_expand_prologue (void)
4966 {
4967   HOST_WIDE_INT size;
4968   rtx insn;
4969
4970   /* Compute a snapshot of current_function_uses_only_leaf_regs.  Relying
4971      on the final value of the flag means deferring the prologue/epilogue
4972      expansion until just before the second scheduling pass, which is too
4973      late to emit multiple epilogues or return insns.
4974
4975      Of course we are making the assumption that the value of the flag
4976      will not change between now and its final value.  Of the three parts
4977      of the formula, only the last one can reasonably vary.  Let's take a
4978      closer look, after assuming that the first two ones are set to true
4979      (otherwise the last value is effectively silenced).
4980
4981      If only_leaf_regs_used returns false, the global predicate will also
4982      be false so the actual frame size calculated below will be positive.
4983      As a consequence, the save_register_window insn will be emitted in
4984      the instruction stream; now this insn explicitly references %fp
4985      which is not a leaf register so only_leaf_regs_used will always
4986      return false subsequently.
4987
4988      If only_leaf_regs_used returns true, we hope that the subsequent
4989      optimization passes won't cause non-leaf registers to pop up.  For
4990      example, the regrename pass has special provisions to not rename to
4991      non-leaf registers in a leaf function.  */
4992   sparc_leaf_function_p
4993     = optimize > 0 && current_function_is_leaf && only_leaf_regs_used ();
4994
4995   size = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
4996
4997   if (flag_stack_usage_info)
4998     current_function_static_stack_size = size;
4999
5000   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && size)
5001     sparc_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
5002
5003   if (size == 0)
5004     ; /* do nothing.  */
5005   else if (sparc_leaf_function_p)
5006     {
5007       rtx size_int_rtx = GEN_INT (-size);
5008
5009       if (size <= 4096)
5010         insn = emit_insn (gen_stack_pointer_inc (size_int_rtx));
5011       else if (size <= 8192)
5012         {
5013           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
5014           RTX_FRAME_RELATED_P (insn) = 1;
5015
5016           /* %sp is still the CFA register.  */
5017           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
5018         }
5019       else
5020         {
5021           rtx size_rtx = gen_rtx_REG (Pmode, 1);
5022           emit_move_insn (size_rtx, size_int_rtx);
5023           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
5024           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
5025                         gen_stack_pointer_inc (size_int_rtx));
5026         }
5027
5028       RTX_FRAME_RELATED_P (insn) = 1;
5029     }
5030   else
5031     {
5032       rtx size_int_rtx = GEN_INT (-size);
5033
5034       if (size <= 4096)
5035         emit_window_save (size_int_rtx);
5036       else if (size <= 8192)
5037         {
5038           emit_window_save (GEN_INT (-4096));
5039
5040           /* %sp is not the CFA register anymore.  */
5041           emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
5042
5043           /* Make sure no %fp-based store is issued until after the frame is
5044              established.  The offset between the frame pointer and the stack
5045              pointer is calculated relative to the value of the stack pointer
5046              at the end of the function prologue, and moving instructions that
5047              access the stack via the frame pointer between the instructions
5048              that decrement the stack pointer could result in accessing the
5049              register window save area, which is volatile.  */
5050           emit_insn (gen_frame_blockage ());
5051         }
5052       else
5053         {
5054           rtx size_rtx = gen_rtx_REG (Pmode, 1);
5055           emit_move_insn (size_rtx, size_int_rtx);
5056           emit_window_save (size_rtx);
5057         }
5058     }
5059
5060   if (sparc_leaf_function_p)
5061     {
5062       sparc_frame_base_reg = stack_pointer_rtx;
5063       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
5064     }
5065   else
5066     {
5067       sparc_frame_base_reg = hard_frame_pointer_rtx;
5068       sparc_frame_base_offset = SPARC_STACK_BIAS;
5069     }
5070
5071   if (sparc_n_global_fp_regs > 0)
5072     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5073                                          sparc_frame_base_offset
5074                                            - sparc_apparent_frame_size,
5075                                          SORR_SAVE);
5076
5077   /* Load the GOT register if needed.  */
5078   if (crtl->uses_pic_offset_table)
5079     load_got_register ();
5080
5081   /* Advertise that the data calculated just above are now valid.  */
5082   sparc_prologue_data_valid_p = true;
5083 }
5084
5085 /* Expand the function prologue.  The prologue is responsible for reserving
5086    storage for the frame, saving the call-saved registers and loading the
5087    GOT register if needed.  */
5088
5089 void
5090 sparc_flat_expand_prologue (void)
5091 {
5092   HOST_WIDE_INT size;
5093   rtx insn;
5094
5095   sparc_leaf_function_p = optimize > 0 && current_function_is_leaf;
5096
5097   size = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
5098
5099   if (flag_stack_usage_info)
5100     current_function_static_stack_size = size;
5101
5102   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && size)
5103     sparc_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
5104
5105   if (sparc_save_local_in_regs_p)
5106     emit_save_or_restore_local_in_regs (stack_pointer_rtx, SPARC_STACK_BIAS,
5107                                         SORR_SAVE);
5108
5109   if (size == 0)
5110     ; /* do nothing.  */
5111   else
5112     {
5113       rtx size_int_rtx, size_rtx;
5114
5115       size_rtx = size_int_rtx = GEN_INT (-size);
5116
5117       /* We establish the frame (i.e. decrement the stack pointer) first, even
5118          if we use a frame pointer, because we cannot clobber any call-saved
5119          registers, including the frame pointer, if we haven't created a new
5120          register save area, for the sake of compatibility with the ABI.  */
5121       if (size <= 4096)
5122         insn = emit_insn (gen_stack_pointer_inc (size_int_rtx));
5123       else if (size <= 8192 && !frame_pointer_needed)
5124         {
5125           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
5126           RTX_FRAME_RELATED_P (insn) = 1;
5127           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
5128         }
5129       else
5130         {
5131           size_rtx = gen_rtx_REG (Pmode, 1);
5132           emit_move_insn (size_rtx, size_int_rtx);
5133           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
5134           add_reg_note (insn, REG_CFA_ADJUST_CFA,
5135                         gen_stack_pointer_inc (size_int_rtx));
5136         }
5137       RTX_FRAME_RELATED_P (insn) = 1;
5138
5139       /* Ensure nothing is scheduled until after the frame is established.  */
5140       emit_insn (gen_blockage ());
5141
5142       if (frame_pointer_needed)
5143         {
5144           insn = emit_insn (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
5145                                          gen_rtx_MINUS (Pmode,
5146                                                         stack_pointer_rtx,
5147                                                         size_rtx)));
5148           RTX_FRAME_RELATED_P (insn) = 1;
5149
5150           add_reg_note (insn, REG_CFA_ADJUST_CFA,
5151                         gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
5152                                      plus_constant (Pmode, stack_pointer_rtx,
5153                                                     size)));
5154         }
5155
5156       if (return_addr_reg_needed_p (sparc_leaf_function_p))
5157         {
5158           rtx o7 = gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM);
5159           rtx i7 = gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM);
5160
5161           insn = emit_move_insn (i7, o7);
5162           RTX_FRAME_RELATED_P (insn) = 1;
5163
5164           add_reg_note (insn, REG_CFA_REGISTER,
5165                         gen_rtx_SET (VOIDmode, i7, o7));
5166
5167           /* Prevent this instruction from ever being considered dead,
5168              even if this function has no epilogue.  */
5169           emit_use (i7);
5170         }
5171     }
5172
5173   if (frame_pointer_needed)
5174     {
5175       sparc_frame_base_reg = hard_frame_pointer_rtx;
5176       sparc_frame_base_offset = SPARC_STACK_BIAS;
5177     }
5178   else
5179     {
5180       sparc_frame_base_reg = stack_pointer_rtx;
5181       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
5182     }
5183
5184   if (sparc_n_global_fp_regs > 0)
5185     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5186                                          sparc_frame_base_offset
5187                                            - sparc_apparent_frame_size,
5188                                          SORR_SAVE);
5189
5190   /* Load the GOT register if needed.  */
5191   if (crtl->uses_pic_offset_table)
5192     load_got_register ();
5193
5194   /* Advertise that the data calculated just above are now valid.  */
5195   sparc_prologue_data_valid_p = true;
5196 }
5197
5198 /* This function generates the assembly code for function entry, which boils
5199    down to emitting the necessary .register directives.  */
5200
5201 static void
5202 sparc_asm_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
5203 {
5204   /* Check that the assumption we made in sparc_expand_prologue is valid.  */
5205   if (!TARGET_FLAT)
5206     gcc_assert (sparc_leaf_function_p == current_function_uses_only_leaf_regs);
5207
5208   sparc_output_scratch_registers (file);
5209 }
5210
5211 /* Expand the function epilogue, either normal or part of a sibcall.
5212    We emit all the instructions except the return or the call.  */
5213
5214 void
5215 sparc_expand_epilogue (bool for_eh)
5216 {
5217   HOST_WIDE_INT size = sparc_frame_size;
5218
5219   if (sparc_n_global_fp_regs > 0)
5220     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5221                                          sparc_frame_base_offset
5222                                            - sparc_apparent_frame_size,
5223                                          SORR_RESTORE);
5224
5225   if (size == 0 || for_eh)
5226     ; /* do nothing.  */
5227   else if (sparc_leaf_function_p)
5228     {
5229       if (size <= 4096)
5230         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
5231       else if (size <= 8192)
5232         {
5233           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
5234           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
5235         }
5236       else
5237         {
5238           rtx reg = gen_rtx_REG (Pmode, 1);
5239           emit_move_insn (reg, GEN_INT (-size));
5240           emit_insn (gen_stack_pointer_dec (reg));
5241         }
5242     }
5243 }
5244
5245 /* Expand the function epilogue, either normal or part of a sibcall.
5246    We emit all the instructions except the return or the call.  */
5247
5248 void
5249 sparc_flat_expand_epilogue (bool for_eh)
5250 {
5251   HOST_WIDE_INT size = sparc_frame_size;
5252
5253   if (sparc_n_global_fp_regs > 0)
5254     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5255                                          sparc_frame_base_offset
5256                                            - sparc_apparent_frame_size,
5257                                          SORR_RESTORE);
5258
5259   /* If we have a frame pointer, we'll need both to restore it before the
5260      frame is destroyed and use its current value in destroying the frame.
5261      Since we don't have an atomic way to do that in the flat window model,
5262      we save the current value into a temporary register (%g1).  */
5263   if (frame_pointer_needed && !for_eh)
5264     emit_move_insn (gen_rtx_REG (Pmode, 1), hard_frame_pointer_rtx);
5265
5266   if (return_addr_reg_needed_p (sparc_leaf_function_p))
5267     emit_move_insn (gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM),
5268                     gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM));
5269
5270   if (sparc_save_local_in_regs_p)
5271     emit_save_or_restore_local_in_regs (sparc_frame_base_reg,
5272                                         sparc_frame_base_offset,
5273                                         SORR_RESTORE);
5274
5275   if (size == 0 || for_eh)
5276     ; /* do nothing.  */
5277   else if (frame_pointer_needed)
5278     {
5279       /* Make sure the frame is destroyed after everything else is done.  */
5280       emit_insn (gen_blockage ());
5281
5282       emit_move_insn (stack_pointer_rtx, gen_rtx_REG (Pmode, 1));
5283     }
5284   else
5285     {
5286       /* Likewise.  */
5287       emit_insn (gen_blockage ());
5288
5289       if (size <= 4096)
5290         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
5291       else if (size <= 8192)
5292         {
5293           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
5294           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
5295         }
5296       else
5297         {
5298           rtx reg = gen_rtx_REG (Pmode, 1);
5299           emit_move_insn (reg, GEN_INT (-size));
5300           emit_insn (gen_stack_pointer_dec (reg));
5301         }
5302     }
5303 }
5304
5305 /* Return true if it is appropriate to emit `return' instructions in the
5306    body of a function.  */
5307
5308 bool
5309 sparc_can_use_return_insn_p (void)
5310 {
5311   return sparc_prologue_data_valid_p
5312          && sparc_n_global_fp_regs == 0
5313          && TARGET_FLAT
5314             ? (sparc_frame_size == 0 && !sparc_save_local_in_regs_p)
5315             : (sparc_frame_size == 0 || !sparc_leaf_function_p);
5316 }
5317
5318 /* This function generates the assembly code for function exit.  */
5319
5320 static void
5321 sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
5322 {
5323   /* If the last two instructions of a function are "call foo; dslot;"
5324      the return address might point to the first instruction in the next
5325      function and we have to output a dummy nop for the sake of sane
5326      backtraces in such cases.  This is pointless for sibling calls since
5327      the return address is explicitly adjusted.  */
5328
5329   rtx insn, last_real_insn;
5330
5331   insn = get_last_insn ();
5332
5333   last_real_insn = prev_real_insn (insn);
5334   if (last_real_insn
5335       && GET_CODE (last_real_insn) == INSN
5336       && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE)
5337     last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0);
5338
5339   if (last_real_insn
5340       && CALL_P (last_real_insn)
5341       && !SIBLING_CALL_P (last_real_insn))
5342     fputs("\tnop\n", file);
5343
5344   sparc_output_deferred_case_vectors ();
5345 }
5346
5347 /* Output a 'restore' instruction.  */
5348
5349 static void
5350 output_restore (rtx pat)
5351 {
5352   rtx operands[3];
5353
5354   if (! pat)
5355     {
5356       fputs ("\t restore\n", asm_out_file);
5357       return;
5358     }
5359
5360   gcc_assert (GET_CODE (pat) == SET);
5361
5362   operands[0] = SET_DEST (pat);
5363   pat = SET_SRC (pat);
5364
5365   switch (GET_CODE (pat))
5366     {
5367       case PLUS:
5368         operands[1] = XEXP (pat, 0);
5369         operands[2] = XEXP (pat, 1);
5370         output_asm_insn (" restore %r1, %2, %Y0", operands);
5371         break;
5372       case LO_SUM:
5373         operands[1] = XEXP (pat, 0);
5374         operands[2] = XEXP (pat, 1);
5375         output_asm_insn (" restore %r1, %%lo(%a2), %Y0", operands);
5376         break;
5377       case ASHIFT:
5378         operands[1] = XEXP (pat, 0);
5379         gcc_assert (XEXP (pat, 1) == const1_rtx);
5380         output_asm_insn (" restore %r1, %r1, %Y0", operands);
5381         break;
5382       default:
5383         operands[1] = pat;
5384         output_asm_insn (" restore %%g0, %1, %Y0", operands);
5385         break;
5386     }
5387 }
5388
5389 /* Output a return.  */
5390
5391 const char *
5392 output_return (rtx insn)
5393 {
5394   if (crtl->calls_eh_return)
5395     {
5396       /* If the function uses __builtin_eh_return, the eh_return
5397          machinery occupies the delay slot.  */
5398       gcc_assert (!final_sequence);
5399
5400       if (flag_delayed_branch)
5401         {
5402           if (!TARGET_FLAT && TARGET_V9)
5403             fputs ("\treturn\t%i7+8\n", asm_out_file);
5404           else
5405             {
5406               if (!TARGET_FLAT)
5407                 fputs ("\trestore\n", asm_out_file);
5408
5409               fputs ("\tjmp\t%o7+8\n", asm_out_file);
5410             }
5411
5412           fputs ("\t add\t%sp, %g1, %sp\n", asm_out_file);
5413         }
5414       else
5415         {
5416           if (!TARGET_FLAT)
5417             fputs ("\trestore\n", asm_out_file);
5418
5419           fputs ("\tadd\t%sp, %g1, %sp\n", asm_out_file);
5420           fputs ("\tjmp\t%o7+8\n\t nop\n", asm_out_file);
5421         }
5422     }
5423   else if (sparc_leaf_function_p || TARGET_FLAT)
5424     {
5425       /* This is a leaf or flat function so we don't have to bother restoring
5426          the register window, which frees us from dealing with the convoluted
5427          semantics of restore/return.  We simply output the jump to the
5428          return address and the insn in the delay slot (if any).  */
5429
5430       return "jmp\t%%o7+%)%#";
5431     }
5432   else
5433     {
5434       /* This is a regular function so we have to restore the register window.
5435          We may have a pending insn for the delay slot, which will be either
5436          combined with the 'restore' instruction or put in the delay slot of
5437          the 'return' instruction.  */
5438
5439       if (final_sequence)
5440         {
5441           rtx delay, pat;
5442
5443           delay = NEXT_INSN (insn);
5444           gcc_assert (delay);
5445
5446           pat = PATTERN (delay);
5447
5448           if (TARGET_V9 && ! epilogue_renumber (&pat, 1))
5449             {
5450               epilogue_renumber (&pat, 0);
5451               return "return\t%%i7+%)%#";
5452             }
5453           else
5454             {
5455               output_asm_insn ("jmp\t%%i7+%)", NULL);
5456               output_restore (pat);
5457               PATTERN (delay) = gen_blockage ();
5458               INSN_CODE (delay) = -1;
5459             }
5460         }
5461       else
5462         {
5463           /* The delay slot is empty.  */
5464           if (TARGET_V9)
5465             return "return\t%%i7+%)\n\t nop";
5466           else if (flag_delayed_branch)
5467             return "jmp\t%%i7+%)\n\t restore";
5468           else
5469             return "restore\n\tjmp\t%%o7+%)\n\t nop";
5470         }
5471     }
5472
5473   return "";
5474 }
5475
5476 /* Output a sibling call.  */
5477
5478 const char *
5479 output_sibcall (rtx insn, rtx call_operand)
5480 {
5481   rtx operands[1];
5482
5483   gcc_assert (flag_delayed_branch);
5484
5485   operands[0] = call_operand;
5486
5487   if (sparc_leaf_function_p || TARGET_FLAT)
5488     {
5489       /* This is a leaf or flat function so we don't have to bother restoring
5490          the register window.  We simply output the jump to the function and
5491          the insn in the delay slot (if any).  */
5492
5493       gcc_assert (!(LEAF_SIBCALL_SLOT_RESERVED_P && final_sequence));
5494
5495       if (final_sequence)
5496         output_asm_insn ("sethi\t%%hi(%a0), %%g1\n\tjmp\t%%g1 + %%lo(%a0)%#",
5497                          operands);
5498       else
5499         /* Use or with rs2 %%g0 instead of mov, so that as/ld can optimize
5500            it into branch if possible.  */
5501         output_asm_insn ("or\t%%o7, %%g0, %%g1\n\tcall\t%a0, 0\n\t or\t%%g1, %%g0, %%o7",
5502                          operands);
5503     }
5504   else
5505     {
5506       /* This is a regular function so we have to restore the register window.
5507          We may have a pending insn for the delay slot, which will be combined
5508          with the 'restore' instruction.  */
5509
5510       output_asm_insn ("call\t%a0, 0", operands);
5511
5512       if (final_sequence)
5513         {
5514           rtx delay = NEXT_INSN (insn);
5515           gcc_assert (delay);
5516
5517           output_restore (PATTERN (delay));
5518
5519           PATTERN (delay) = gen_blockage ();
5520           INSN_CODE (delay) = -1;
5521         }
5522       else
5523         output_restore (NULL_RTX);
5524     }
5525
5526   return "";
5527 }
5528 \f
5529 /* Functions for handling argument passing.
5530
5531    For 32-bit, the first 6 args are normally in registers and the rest are
5532    pushed.  Any arg that starts within the first 6 words is at least
5533    partially passed in a register unless its data type forbids.
5534
5535    For 64-bit, the argument registers are laid out as an array of 16 elements
5536    and arguments are added sequentially.  The first 6 int args and up to the
5537    first 16 fp args (depending on size) are passed in regs.
5538
5539    Slot    Stack   Integral   Float   Float in structure   Double   Long Double
5540    ----    -----   --------   -----   ------------------   ------   -----------
5541     15   [SP+248]              %f31       %f30,%f31         %d30
5542     14   [SP+240]              %f29       %f28,%f29         %d28       %q28
5543     13   [SP+232]              %f27       %f26,%f27         %d26
5544     12   [SP+224]              %f25       %f24,%f25         %d24       %q24
5545     11   [SP+216]              %f23       %f22,%f23         %d22
5546     10   [SP+208]              %f21       %f20,%f21         %d20       %q20
5547      9   [SP+200]              %f19       %f18,%f19         %d18
5548      8   [SP+192]              %f17       %f16,%f17         %d16       %q16
5549      7   [SP+184]              %f15       %f14,%f15         %d14
5550      6   [SP+176]              %f13       %f12,%f13         %d12       %q12
5551      5   [SP+168]     %o5      %f11       %f10,%f11         %d10
5552      4   [SP+160]     %o4       %f9        %f8,%f9           %d8        %q8
5553      3   [SP+152]     %o3       %f7        %f6,%f7           %d6
5554      2   [SP+144]     %o2       %f5        %f4,%f5           %d4        %q4
5555      1   [SP+136]     %o1       %f3        %f2,%f3           %d2
5556      0   [SP+128]     %o0       %f1        %f0,%f1           %d0        %q0
5557
5558    Here SP = %sp if -mno-stack-bias or %sp+stack_bias otherwise.
5559
5560    Integral arguments are always passed as 64-bit quantities appropriately
5561    extended.
5562
5563    Passing of floating point values is handled as follows.
5564    If a prototype is in scope:
5565      If the value is in a named argument (i.e. not a stdarg function or a
5566      value not part of the `...') then the value is passed in the appropriate
5567      fp reg.
5568      If the value is part of the `...' and is passed in one of the first 6
5569      slots then the value is passed in the appropriate int reg.
5570      If the value is part of the `...' and is not passed in one of the first 6
5571      slots then the value is passed in memory.
5572    If a prototype is not in scope:
5573      If the value is one of the first 6 arguments the value is passed in the
5574      appropriate integer reg and the appropriate fp reg.
5575      If the value is not one of the first 6 arguments the value is passed in
5576      the appropriate fp reg and in memory.
5577
5578
5579    Summary of the calling conventions implemented by GCC on the SPARC:
5580
5581    32-bit ABI:
5582                                 size      argument     return value
5583
5584       small integer              <4       int. reg.      int. reg.
5585       word                        4       int. reg.      int. reg.
5586       double word                 8       int. reg.      int. reg.
5587
5588       _Complex small integer     <8       int. reg.      int. reg.
5589       _Complex word               8       int. reg.      int. reg.
5590       _Complex double word       16        memory        int. reg.
5591
5592       vector integer            <=8       int. reg.       FP reg.
5593       vector integer             >8        memory         memory
5594
5595       float                       4       int. reg.       FP reg.
5596       double                      8       int. reg.       FP reg.
5597       long double                16        memory         memory
5598
5599       _Complex float              8        memory         FP reg.
5600       _Complex double            16        memory         FP reg.
5601       _Complex long double       32        memory         FP reg.
5602
5603       vector float              any        memory         memory
5604
5605       aggregate                 any        memory         memory
5606
5607
5608
5609     64-bit ABI:
5610                                 size      argument     return value
5611
5612       small integer              <8       int. reg.      int. reg.
5613       word                        8       int. reg.      int. reg.
5614       double word                16       int. reg.      int. reg.
5615
5616       _Complex small integer    <16       int. reg.      int. reg.
5617       _Complex word              16       int. reg.      int. reg.
5618       _Complex double word       32        memory        int. reg.
5619
5620       vector integer           <=16        FP reg.        FP reg.
5621       vector integer       16<s<=32        memory         FP reg.
5622       vector integer            >32        memory         memory
5623
5624       float                       4        FP reg.        FP reg.
5625       double                      8        FP reg.        FP reg.
5626       long double                16        FP reg.        FP reg.
5627
5628       _Complex float              8        FP reg.        FP reg.
5629       _Complex double            16        FP reg.        FP reg.
5630       _Complex long double       32        memory         FP reg.
5631
5632       vector float             <=16        FP reg.        FP reg.
5633       vector float         16<s<=32        memory         FP reg.
5634       vector float              >32        memory         memory
5635
5636       aggregate                <=16         reg.           reg.
5637       aggregate            16<s<=32        memory          reg.
5638       aggregate                 >32        memory         memory
5639
5640
5641
5642 Note #1: complex floating-point types follow the extended SPARC ABIs as
5643 implemented by the Sun compiler.
5644
5645 Note #2: integral vector types follow the scalar floating-point types
5646 conventions to match what is implemented by the Sun VIS SDK.
5647
5648 Note #3: floating-point vector types follow the aggregate types
5649 conventions.  */
5650
5651
5652 /* Maximum number of int regs for args.  */
5653 #define SPARC_INT_ARG_MAX 6
5654 /* Maximum number of fp regs for args.  */
5655 #define SPARC_FP_ARG_MAX 16
5656
5657 #define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
5658
5659 /* Handle the INIT_CUMULATIVE_ARGS macro.
5660    Initialize a variable CUM of type CUMULATIVE_ARGS
5661    for a call to a function whose data type is FNTYPE.
5662    For a library call, FNTYPE is 0.  */
5663
5664 void
5665 init_cumulative_args (struct sparc_args *cum, tree fntype,
5666                       rtx libname ATTRIBUTE_UNUSED,
5667                       tree fndecl ATTRIBUTE_UNUSED)
5668 {
5669   cum->words = 0;
5670   cum->prototype_p = fntype && prototype_p (fntype);
5671   cum->libcall_p = fntype == 0;
5672 }
5673
5674 /* Handle promotion of pointer and integer arguments.  */
5675
5676 static enum machine_mode
5677 sparc_promote_function_mode (const_tree type,
5678                              enum machine_mode mode,
5679                              int *punsignedp,
5680                              const_tree fntype ATTRIBUTE_UNUSED,
5681                              int for_return ATTRIBUTE_UNUSED)
5682 {
5683   if (type != NULL_TREE && POINTER_TYPE_P (type))
5684     {
5685       *punsignedp = POINTERS_EXTEND_UNSIGNED;
5686       return Pmode;
5687     }
5688
5689   /* Integral arguments are passed as full words, as per the ABI.  */
5690   if (GET_MODE_CLASS (mode) == MODE_INT
5691       && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
5692     return word_mode;
5693
5694   return mode;
5695 }
5696
5697 /* Handle the TARGET_STRICT_ARGUMENT_NAMING target hook.  */
5698
5699 static bool
5700 sparc_strict_argument_naming (cumulative_args_t ca ATTRIBUTE_UNUSED)
5701 {
5702   return TARGET_ARCH64 ? true : false;
5703 }
5704
5705 /* Scan the record type TYPE and return the following predicates:
5706     - INTREGS_P: the record contains at least one field or sub-field
5707       that is eligible for promotion in integer registers.
5708     - FP_REGS_P: the record contains at least one field or sub-field
5709       that is eligible for promotion in floating-point registers.
5710     - PACKED_P: the record contains at least one field that is packed.
5711
5712    Sub-fields are not taken into account for the PACKED_P predicate.  */
5713
5714 static void
5715 scan_record_type (const_tree type, int *intregs_p, int *fpregs_p,
5716                   int *packed_p)
5717 {
5718   tree field;
5719
5720   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5721     {
5722       if (TREE_CODE (field) == FIELD_DECL)
5723         {
5724           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5725             scan_record_type (TREE_TYPE (field), intregs_p, fpregs_p, 0);
5726           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5727                    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5728                   && TARGET_FPU)
5729             *fpregs_p = 1;
5730           else
5731             *intregs_p = 1;
5732
5733           if (packed_p && DECL_PACKED (field))
5734             *packed_p = 1;
5735         }
5736     }
5737 }
5738
5739 /* Compute the slot number to pass an argument in.
5740    Return the slot number or -1 if passing on the stack.
5741
5742    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5743     the preceding args and about the function being called.
5744    MODE is the argument's machine mode.
5745    TYPE is the data type of the argument (as a tree).
5746     This is null for libcalls where that information may
5747     not be available.
5748    NAMED is nonzero if this argument is a named parameter
5749     (otherwise it is an extra parameter matching an ellipsis).
5750    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
5751    *PREGNO records the register number to use if scalar type.
5752    *PPADDING records the amount of padding needed in words.  */
5753
5754 static int
5755 function_arg_slotno (const struct sparc_args *cum, enum machine_mode mode,
5756                      const_tree type, bool named, bool incoming_p,
5757                      int *pregno, int *ppadding)
5758 {
5759   int regbase = (incoming_p
5760                  ? SPARC_INCOMING_INT_ARG_FIRST
5761                  : SPARC_OUTGOING_INT_ARG_FIRST);
5762   int slotno = cum->words;
5763   enum mode_class mclass;
5764   int regno;
5765
5766   *ppadding = 0;
5767
5768   if (type && TREE_ADDRESSABLE (type))
5769     return -1;
5770
5771   if (TARGET_ARCH32
5772       && mode == BLKmode
5773       && type
5774       && TYPE_ALIGN (type) % PARM_BOUNDARY != 0)
5775     return -1;
5776
5777   /* For SPARC64, objects requiring 16-byte alignment get it.  */
5778   if (TARGET_ARCH64
5779       && (type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode)) >= 128
5780       && (slotno & 1) != 0)
5781     slotno++, *ppadding = 1;
5782
5783   mclass = GET_MODE_CLASS (mode);
5784   if (type && TREE_CODE (type) == VECTOR_TYPE)
5785     {
5786       /* Vector types deserve special treatment because they are
5787          polymorphic wrt their mode, depending upon whether VIS
5788          instructions are enabled.  */
5789       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5790         {
5791           /* The SPARC port defines no floating-point vector modes.  */
5792           gcc_assert (mode == BLKmode);
5793         }
5794       else
5795         {
5796           /* Integral vector types should either have a vector
5797              mode or an integral mode, because we are guaranteed
5798              by pass_by_reference that their size is not greater
5799              than 16 bytes and TImode is 16-byte wide.  */
5800           gcc_assert (mode != BLKmode);
5801
5802           /* Vector integers are handled like floats according to
5803              the Sun VIS SDK.  */
5804           mclass = MODE_FLOAT;
5805         }
5806     }
5807
5808   switch (mclass)
5809     {
5810     case MODE_FLOAT:
5811     case MODE_COMPLEX_FLOAT:
5812     case MODE_VECTOR_INT:
5813       if (TARGET_ARCH64 && TARGET_FPU && named)
5814         {
5815           if (slotno >= SPARC_FP_ARG_MAX)
5816             return -1;
5817           regno = SPARC_FP_ARG_FIRST + slotno * 2;
5818           /* Arguments filling only one single FP register are
5819              right-justified in the outer double FP register.  */
5820           if (GET_MODE_SIZE (mode) <= 4)
5821             regno++;
5822           break;
5823         }
5824       /* fallthrough */
5825
5826     case MODE_INT:
5827     case MODE_COMPLEX_INT:
5828       if (slotno >= SPARC_INT_ARG_MAX)
5829         return -1;
5830       regno = regbase + slotno;
5831       break;
5832
5833     case MODE_RANDOM:
5834       if (mode == VOIDmode)
5835         /* MODE is VOIDmode when generating the actual call.  */
5836         return -1;
5837
5838       gcc_assert (mode == BLKmode);
5839
5840       if (TARGET_ARCH32
5841           || !type
5842           || (TREE_CODE (type) != VECTOR_TYPE
5843               && TREE_CODE (type) != RECORD_TYPE))
5844         {
5845           if (slotno >= SPARC_INT_ARG_MAX)
5846             return -1;
5847           regno = regbase + slotno;
5848         }
5849       else  /* TARGET_ARCH64 && type */
5850         {
5851           int intregs_p = 0, fpregs_p = 0, packed_p = 0;
5852
5853           /* First see what kinds of registers we would need.  */
5854           if (TREE_CODE (type) == VECTOR_TYPE)
5855             fpregs_p = 1;
5856           else
5857             scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
5858
5859           /* The ABI obviously doesn't specify how packed structures
5860              are passed.  These are defined to be passed in int regs
5861              if possible, otherwise memory.  */
5862           if (packed_p || !named)
5863             fpregs_p = 0, intregs_p = 1;
5864
5865           /* If all arg slots are filled, then must pass on stack.  */
5866           if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
5867             return -1;
5868
5869           /* If there are only int args and all int arg slots are filled,
5870              then must pass on stack.  */
5871           if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
5872             return -1;
5873
5874           /* Note that even if all int arg slots are filled, fp members may
5875              still be passed in regs if such regs are available.
5876              *PREGNO isn't set because there may be more than one, it's up
5877              to the caller to compute them.  */
5878           return slotno;
5879         }
5880       break;
5881
5882     default :
5883       gcc_unreachable ();
5884     }
5885
5886   *pregno = regno;
5887   return slotno;
5888 }
5889
5890 /* Handle recursive register counting for structure field layout.  */
5891
5892 struct function_arg_record_value_parms
5893 {
5894   rtx ret;              /* return expression being built.  */
5895   int slotno;           /* slot number of the argument.  */
5896   int named;            /* whether the argument is named.  */
5897   int regbase;          /* regno of the base register.  */
5898   int stack;            /* 1 if part of the argument is on the stack.  */
5899   int intoffset;        /* offset of the first pending integer field.  */
5900   unsigned int nregs;   /* number of words passed in registers.  */
5901 };
5902
5903 static void function_arg_record_value_3
5904  (HOST_WIDE_INT, struct function_arg_record_value_parms *);
5905 static void function_arg_record_value_2
5906  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5907 static void function_arg_record_value_1
5908  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5909 static rtx function_arg_record_value (const_tree, enum machine_mode, int, int, int);
5910 static rtx function_arg_union_value (int, enum machine_mode, int, int);
5911
5912 /* A subroutine of function_arg_record_value.  Traverse the structure
5913    recursively and determine how many registers will be required.  */
5914
5915 static void
5916 function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos,
5917                              struct function_arg_record_value_parms *parms,
5918                              bool packed_p)
5919 {
5920   tree field;
5921
5922   /* We need to compute how many registers are needed so we can
5923      allocate the PARALLEL but before we can do that we need to know
5924      whether there are any packed fields.  The ABI obviously doesn't
5925      specify how structures are passed in this case, so they are
5926      defined to be passed in int regs if possible, otherwise memory,
5927      regardless of whether there are fp values present.  */
5928
5929   if (! packed_p)
5930     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5931       {
5932         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5933           {
5934             packed_p = true;
5935             break;
5936           }
5937       }
5938
5939   /* Compute how many registers we need.  */
5940   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5941     {
5942       if (TREE_CODE (field) == FIELD_DECL)
5943         {
5944           HOST_WIDE_INT bitpos = startbitpos;
5945
5946           if (DECL_SIZE (field) != 0)
5947             {
5948               if (integer_zerop (DECL_SIZE (field)))
5949                 continue;
5950
5951               if (host_integerp (bit_position (field), 1))
5952                 bitpos += int_bit_position (field);
5953             }
5954
5955           /* ??? FIXME: else assume zero offset.  */
5956
5957           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5958             function_arg_record_value_1 (TREE_TYPE (field),
5959                                          bitpos,
5960                                          parms,
5961                                          packed_p);
5962           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5963                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5964                    && TARGET_FPU
5965                    && parms->named
5966                    && ! packed_p)
5967             {
5968               if (parms->intoffset != -1)
5969                 {
5970                   unsigned int startbit, endbit;
5971                   int intslots, this_slotno;
5972
5973                   startbit = parms->intoffset & -BITS_PER_WORD;
5974                   endbit   = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5975
5976                   intslots = (endbit - startbit) / BITS_PER_WORD;
5977                   this_slotno = parms->slotno + parms->intoffset
5978                     / BITS_PER_WORD;
5979
5980                   if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5981                     {
5982                       intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5983                       /* We need to pass this field on the stack.  */
5984                       parms->stack = 1;
5985                     }
5986
5987                   parms->nregs += intslots;
5988                   parms->intoffset = -1;
5989                 }
5990
5991               /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
5992                  If it wasn't true we wouldn't be here.  */
5993               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5994                   && DECL_MODE (field) == BLKmode)
5995                 parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5996               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5997                 parms->nregs += 2;
5998               else
5999                 parms->nregs += 1;
6000             }
6001           else
6002             {
6003               if (parms->intoffset == -1)
6004                 parms->intoffset = bitpos;
6005             }
6006         }
6007     }
6008 }
6009
6010 /* A subroutine of function_arg_record_value.  Assign the bits of the
6011    structure between parms->intoffset and bitpos to integer registers.  */
6012
6013 static void
6014 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
6015                              struct function_arg_record_value_parms *parms)
6016 {
6017   enum machine_mode mode;
6018   unsigned int regno;
6019   unsigned int startbit, endbit;
6020   int this_slotno, intslots, intoffset;
6021   rtx reg;
6022
6023   if (parms->intoffset == -1)
6024     return;
6025
6026   intoffset = parms->intoffset;
6027   parms->intoffset = -1;
6028
6029   startbit = intoffset & -BITS_PER_WORD;
6030   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
6031   intslots = (endbit - startbit) / BITS_PER_WORD;
6032   this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
6033
6034   intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
6035   if (intslots <= 0)
6036     return;
6037
6038   /* If this is the trailing part of a word, only load that much into
6039      the register.  Otherwise load the whole register.  Note that in
6040      the latter case we may pick up unwanted bits.  It's not a problem
6041      at the moment but may wish to revisit.  */
6042
6043   if (intoffset % BITS_PER_WORD != 0)
6044     mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
6045                                    MODE_INT);
6046   else
6047     mode = word_mode;
6048
6049   intoffset /= BITS_PER_UNIT;
6050   do
6051     {
6052       regno = parms->regbase + this_slotno;
6053       reg = gen_rtx_REG (mode, regno);
6054       XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6055         = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
6056
6057       this_slotno += 1;
6058       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
6059       mode = word_mode;
6060       parms->nregs += 1;
6061       intslots -= 1;
6062     }
6063   while (intslots > 0);
6064 }
6065
6066 /* A subroutine of function_arg_record_value.  Traverse the structure
6067    recursively and assign bits to floating point registers.  Track which
6068    bits in between need integer registers; invoke function_arg_record_value_3
6069    to make that happen.  */
6070
6071 static void
6072 function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
6073                              struct function_arg_record_value_parms *parms,
6074                              bool packed_p)
6075 {
6076   tree field;
6077
6078   if (! packed_p)
6079     for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6080       {
6081         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
6082           {
6083             packed_p = true;
6084             break;
6085           }
6086       }
6087
6088   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6089     {
6090       if (TREE_CODE (field) == FIELD_DECL)
6091         {
6092           HOST_WIDE_INT bitpos = startbitpos;
6093
6094           if (DECL_SIZE (field) != 0)
6095             {
6096               if (integer_zerop (DECL_SIZE (field)))
6097                 continue;
6098
6099               if (host_integerp (bit_position (field), 1))
6100                 bitpos += int_bit_position (field);
6101             }
6102
6103           /* ??? FIXME: else assume zero offset.  */
6104
6105           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
6106             function_arg_record_value_2 (TREE_TYPE (field),
6107                                          bitpos,
6108                                          parms,
6109                                          packed_p);
6110           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
6111                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
6112                    && TARGET_FPU
6113                    && parms->named
6114                    && ! packed_p)
6115             {
6116               int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
6117               int regno, nregs, pos;
6118               enum machine_mode mode = DECL_MODE (field);
6119               rtx reg;
6120
6121               function_arg_record_value_3 (bitpos, parms);
6122
6123               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
6124                   && mode == BLKmode)
6125                 {
6126                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
6127                   nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
6128                 }
6129               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
6130                 {
6131                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
6132                   nregs = 2;
6133                 }
6134               else
6135                 nregs = 1;
6136
6137               regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
6138               if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
6139                 regno++;
6140               reg = gen_rtx_REG (mode, regno);
6141               pos = bitpos / BITS_PER_UNIT;
6142               XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6143                 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
6144               parms->nregs += 1;
6145               while (--nregs > 0)
6146                 {
6147                   regno += GET_MODE_SIZE (mode) / 4;
6148                   reg = gen_rtx_REG (mode, regno);
6149                   pos += GET_MODE_SIZE (mode);
6150                   XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6151                     = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
6152                   parms->nregs += 1;
6153                 }
6154             }
6155           else
6156             {
6157               if (parms->intoffset == -1)
6158                 parms->intoffset = bitpos;
6159             }
6160         }
6161     }
6162 }
6163
6164 /* Used by function_arg and sparc_function_value_1 to implement the complex
6165    conventions of the 64-bit ABI for passing and returning structures.
6166    Return an expression valid as a return value for the FUNCTION_ARG
6167    and TARGET_FUNCTION_VALUE.
6168
6169    TYPE is the data type of the argument (as a tree).
6170     This is null for libcalls where that information may
6171     not be available.
6172    MODE is the argument's machine mode.
6173    SLOTNO is the index number of the argument's slot in the parameter array.
6174    NAMED is nonzero if this argument is a named parameter
6175     (otherwise it is an extra parameter matching an ellipsis).
6176    REGBASE is the regno of the base register for the parameter array.  */
6177
6178 static rtx
6179 function_arg_record_value (const_tree type, enum machine_mode mode,
6180                            int slotno, int named, int regbase)
6181 {
6182   HOST_WIDE_INT typesize = int_size_in_bytes (type);
6183   struct function_arg_record_value_parms parms;
6184   unsigned int nregs;
6185
6186   parms.ret = NULL_RTX;
6187   parms.slotno = slotno;
6188   parms.named = named;
6189   parms.regbase = regbase;
6190   parms.stack = 0;
6191
6192   /* Compute how many registers we need.  */
6193   parms.nregs = 0;
6194   parms.intoffset = 0;
6195   function_arg_record_value_1 (type, 0, &parms, false);
6196
6197   /* Take into account pending integer fields.  */
6198   if (parms.intoffset != -1)
6199     {
6200       unsigned int startbit, endbit;
6201       int intslots, this_slotno;
6202
6203       startbit = parms.intoffset & -BITS_PER_WORD;
6204       endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
6205       intslots = (endbit - startbit) / BITS_PER_WORD;
6206       this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
6207
6208       if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
6209         {
6210           intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
6211           /* We need to pass this field on the stack.  */
6212           parms.stack = 1;
6213         }
6214
6215       parms.nregs += intslots;
6216     }
6217   nregs = parms.nregs;
6218
6219   /* Allocate the vector and handle some annoying special cases.  */
6220   if (nregs == 0)
6221     {
6222       /* ??? Empty structure has no value?  Duh?  */
6223       if (typesize <= 0)
6224         {
6225           /* Though there's nothing really to store, return a word register
6226              anyway so the rest of gcc doesn't go nuts.  Returning a PARALLEL
6227              leads to breakage due to the fact that there are zero bytes to
6228              load.  */
6229           return gen_rtx_REG (mode, regbase);
6230         }
6231       else
6232         {
6233           /* ??? C++ has structures with no fields, and yet a size.  Give up
6234              for now and pass everything back in integer registers.  */
6235           nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6236         }
6237       if (nregs + slotno > SPARC_INT_ARG_MAX)
6238         nregs = SPARC_INT_ARG_MAX - slotno;
6239     }
6240   gcc_assert (nregs != 0);
6241
6242   parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
6243
6244   /* If at least one field must be passed on the stack, generate
6245      (parallel [(expr_list (nil) ...) ...]) so that all fields will
6246      also be passed on the stack.  We can't do much better because the
6247      semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
6248      of structures for which the fields passed exclusively in registers
6249      are not at the beginning of the structure.  */
6250   if (parms.stack)
6251     XVECEXP (parms.ret, 0, 0)
6252       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6253
6254   /* Fill in the entries.  */
6255   parms.nregs = 0;
6256   parms.intoffset = 0;
6257   function_arg_record_value_2 (type, 0, &parms, false);
6258   function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
6259
6260   gcc_assert (parms.nregs == nregs);
6261
6262   return parms.ret;
6263 }
6264
6265 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6266    of the 64-bit ABI for passing and returning unions.
6267    Return an expression valid as a return value for the FUNCTION_ARG
6268    and TARGET_FUNCTION_VALUE.
6269
6270    SIZE is the size in bytes of the union.
6271    MODE is the argument's machine mode.
6272    REGNO is the hard register the union will be passed in.  */
6273
6274 static rtx
6275 function_arg_union_value (int size, enum machine_mode mode, int slotno,
6276                           int regno)
6277 {
6278   int nwords = ROUND_ADVANCE (size), i;
6279   rtx regs;
6280
6281   /* See comment in previous function for empty structures.  */
6282   if (nwords == 0)
6283     return gen_rtx_REG (mode, regno);
6284
6285   if (slotno == SPARC_INT_ARG_MAX - 1)
6286     nwords = 1;
6287
6288   regs = gen_rtx_PARALLEL (mode, rtvec_alloc (nwords));
6289
6290   for (i = 0; i < nwords; i++)
6291     {
6292       /* Unions are passed left-justified.  */
6293       XVECEXP (regs, 0, i)
6294         = gen_rtx_EXPR_LIST (VOIDmode,
6295                              gen_rtx_REG (word_mode, regno),
6296                              GEN_INT (UNITS_PER_WORD * i));
6297       regno++;
6298     }
6299
6300   return regs;
6301 }
6302
6303 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6304    for passing and returning large (BLKmode) vectors.
6305    Return an expression valid as a return value for the FUNCTION_ARG
6306    and TARGET_FUNCTION_VALUE.
6307
6308    SIZE is the size in bytes of the vector (at least 8 bytes).
6309    REGNO is the FP hard register the vector will be passed in.  */
6310
6311 static rtx
6312 function_arg_vector_value (int size, int regno)
6313 {
6314   int i, nregs = size / 8;
6315   rtx regs;
6316
6317   regs = gen_rtx_PARALLEL (BLKmode, rtvec_alloc (nregs));
6318
6319   for (i = 0; i < nregs; i++)
6320     {
6321       XVECEXP (regs, 0, i)
6322         = gen_rtx_EXPR_LIST (VOIDmode,
6323                              gen_rtx_REG (DImode, regno + 2*i),
6324                              GEN_INT (i*8));
6325     }
6326
6327   return regs;
6328 }
6329
6330 /* Determine where to put an argument to a function.
6331    Value is zero to push the argument on the stack,
6332    or a hard register in which to store the argument.
6333
6334    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6335     the preceding args and about the function being called.
6336    MODE is the argument's machine mode.
6337    TYPE is the data type of the argument (as a tree).
6338     This is null for libcalls where that information may
6339     not be available.
6340    NAMED is true if this argument is a named parameter
6341     (otherwise it is an extra parameter matching an ellipsis).
6342    INCOMING_P is false for TARGET_FUNCTION_ARG, true for
6343     TARGET_FUNCTION_INCOMING_ARG.  */
6344
6345 static rtx
6346 sparc_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
6347                       const_tree type, bool named, bool incoming_p)
6348 {
6349   const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6350
6351   int regbase = (incoming_p
6352                  ? SPARC_INCOMING_INT_ARG_FIRST
6353                  : SPARC_OUTGOING_INT_ARG_FIRST);
6354   int slotno, regno, padding;
6355   enum mode_class mclass = GET_MODE_CLASS (mode);
6356
6357   slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
6358                                 &regno, &padding);
6359   if (slotno == -1)
6360     return 0;
6361
6362   /* Vector types deserve special treatment because they are polymorphic wrt
6363      their mode, depending upon whether VIS instructions are enabled.  */
6364   if (type && TREE_CODE (type) == VECTOR_TYPE)
6365     {
6366       HOST_WIDE_INT size = int_size_in_bytes (type);
6367       gcc_assert ((TARGET_ARCH32 && size <= 8)
6368                   || (TARGET_ARCH64 && size <= 16));
6369
6370       if (mode == BLKmode)
6371         return function_arg_vector_value (size,
6372                                           SPARC_FP_ARG_FIRST + 2*slotno);
6373       else
6374         mclass = MODE_FLOAT;
6375     }
6376
6377   if (TARGET_ARCH32)
6378     return gen_rtx_REG (mode, regno);
6379
6380   /* Structures up to 16 bytes in size are passed in arg slots on the stack
6381      and are promoted to registers if possible.  */
6382   if (type && TREE_CODE (type) == RECORD_TYPE)
6383     {
6384       HOST_WIDE_INT size = int_size_in_bytes (type);
6385       gcc_assert (size <= 16);
6386
6387       return function_arg_record_value (type, mode, slotno, named, regbase);
6388     }
6389
6390   /* Unions up to 16 bytes in size are passed in integer registers.  */
6391   else if (type && TREE_CODE (type) == UNION_TYPE)
6392     {
6393       HOST_WIDE_INT size = int_size_in_bytes (type);
6394       gcc_assert (size <= 16);
6395
6396       return function_arg_union_value (size, mode, slotno, regno);
6397     }
6398
6399   /* v9 fp args in reg slots beyond the int reg slots get passed in regs
6400      but also have the slot allocated for them.
6401      If no prototype is in scope fp values in register slots get passed
6402      in two places, either fp regs and int regs or fp regs and memory.  */
6403   else if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6404            && SPARC_FP_REG_P (regno))
6405     {
6406       rtx reg = gen_rtx_REG (mode, regno);
6407       if (cum->prototype_p || cum->libcall_p)
6408         {
6409           /* "* 2" because fp reg numbers are recorded in 4 byte
6410              quantities.  */
6411 #if 0
6412           /* ??? This will cause the value to be passed in the fp reg and
6413              in the stack.  When a prototype exists we want to pass the
6414              value in the reg but reserve space on the stack.  That's an
6415              optimization, and is deferred [for a bit].  */
6416           if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
6417             return gen_rtx_PARALLEL (mode,
6418                             gen_rtvec (2,
6419                                        gen_rtx_EXPR_LIST (VOIDmode,
6420                                                 NULL_RTX, const0_rtx),
6421                                        gen_rtx_EXPR_LIST (VOIDmode,
6422                                                 reg, const0_rtx)));
6423           else
6424 #else
6425           /* ??? It seems that passing back a register even when past
6426              the area declared by REG_PARM_STACK_SPACE will allocate
6427              space appropriately, and will not copy the data onto the
6428              stack, exactly as we desire.
6429
6430              This is due to locate_and_pad_parm being called in
6431              expand_call whenever reg_parm_stack_space > 0, which
6432              while beneficial to our example here, would seem to be
6433              in error from what had been intended.  Ho hum...  -- r~ */
6434 #endif
6435             return reg;
6436         }
6437       else
6438         {
6439           rtx v0, v1;
6440
6441           if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
6442             {
6443               int intreg;
6444
6445               /* On incoming, we don't need to know that the value
6446                  is passed in %f0 and %i0, and it confuses other parts
6447                  causing needless spillage even on the simplest cases.  */
6448               if (incoming_p)
6449                 return reg;
6450
6451               intreg = (SPARC_OUTGOING_INT_ARG_FIRST
6452                         + (regno - SPARC_FP_ARG_FIRST) / 2);
6453
6454               v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6455               v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
6456                                       const0_rtx);
6457               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6458             }
6459           else
6460             {
6461               v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6462               v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6463               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6464             }
6465         }
6466     }
6467
6468   /* All other aggregate types are passed in an integer register in a mode
6469      corresponding to the size of the type.  */
6470   else if (type && AGGREGATE_TYPE_P (type))
6471     {
6472       HOST_WIDE_INT size = int_size_in_bytes (type);
6473       gcc_assert (size <= 16);
6474
6475       mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6476     }
6477
6478   return gen_rtx_REG (mode, regno);
6479 }
6480
6481 /* Handle the TARGET_FUNCTION_ARG target hook.  */
6482
6483 static rtx
6484 sparc_function_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, false);
6488 }
6489
6490 /* Handle the TARGET_FUNCTION_INCOMING_ARG target hook.  */
6491
6492 static rtx
6493 sparc_function_incoming_arg (cumulative_args_t cum, enum machine_mode mode,
6494                              const_tree type, bool named)
6495 {
6496   return sparc_function_arg_1 (cum, mode, type, named, true);
6497 }
6498
6499 /* For sparc64, objects requiring 16 byte alignment are passed that way.  */
6500
6501 static unsigned int
6502 sparc_function_arg_boundary (enum machine_mode mode, const_tree type)
6503 {
6504   return ((TARGET_ARCH64
6505            && (GET_MODE_ALIGNMENT (mode) == 128
6506                || (type && TYPE_ALIGN (type) == 128)))
6507           ? 128
6508           : PARM_BOUNDARY);
6509 }
6510
6511 /* For an arg passed partly in registers and partly in memory,
6512    this is the number of bytes of registers used.
6513    For args passed entirely in registers or entirely in memory, zero.
6514
6515    Any arg that starts in the first 6 regs but won't entirely fit in them
6516    needs partial registers on v8.  On v9, structures with integer
6517    values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
6518    values that begin in the last fp reg [where "last fp reg" varies with the
6519    mode] will be split between that reg and memory.  */
6520
6521 static int
6522 sparc_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
6523                          tree type, bool named)
6524 {
6525   int slotno, regno, padding;
6526
6527   /* We pass false for incoming_p here, it doesn't matter.  */
6528   slotno = function_arg_slotno (get_cumulative_args (cum), mode, type, named,
6529                                 false, &regno, &padding);
6530
6531   if (slotno == -1)
6532     return 0;
6533
6534   if (TARGET_ARCH32)
6535     {
6536       if ((slotno + (mode == BLKmode
6537                      ? ROUND_ADVANCE (int_size_in_bytes (type))
6538                      : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
6539           > SPARC_INT_ARG_MAX)
6540         return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
6541     }
6542   else
6543     {
6544       /* We are guaranteed by pass_by_reference that the size of the
6545          argument is not greater than 16 bytes, so we only need to return
6546          one word if the argument is partially passed in registers.  */
6547
6548       if (type && AGGREGATE_TYPE_P (type))
6549         {
6550           int size = int_size_in_bytes (type);
6551
6552           if (size > 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_INT
6557                || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
6558                    && ! (TARGET_FPU && named)))
6559         {
6560           /* The complex types are passed as packed types.  */
6561           if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
6562               && slotno == SPARC_INT_ARG_MAX - 1)
6563             return UNITS_PER_WORD;
6564         }
6565       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
6566         {
6567           if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
6568               > SPARC_FP_ARG_MAX)
6569             return UNITS_PER_WORD;
6570         }
6571     }
6572
6573   return 0;
6574 }
6575
6576 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
6577    Specify whether to pass the argument by reference.  */
6578
6579 static bool
6580 sparc_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
6581                          enum machine_mode mode, const_tree type,
6582                          bool named ATTRIBUTE_UNUSED)
6583 {
6584   if (TARGET_ARCH32)
6585     /* Original SPARC 32-bit ABI says that structures and unions,
6586        and quad-precision floats are passed by reference.  For Pascal,
6587        also pass arrays by reference.  All other base types are passed
6588        in registers.
6589
6590        Extended ABI (as implemented by the Sun compiler) says that all
6591        complex floats are passed by reference.  Pass complex integers
6592        in registers up to 8 bytes.  More generally, enforce the 2-word
6593        cap for passing arguments in registers.
6594
6595        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6596        integers are passed like floats of the same size, that is in
6597        registers up to 8 bytes.  Pass all vector floats by reference
6598        like structure and unions.  */
6599     return ((type && (AGGREGATE_TYPE_P (type) || VECTOR_FLOAT_TYPE_P (type)))
6600             || mode == SCmode
6601             /* Catch CDImode, TFmode, DCmode and TCmode.  */
6602             || GET_MODE_SIZE (mode) > 8
6603             || (type
6604                 && TREE_CODE (type) == VECTOR_TYPE
6605                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6606   else
6607     /* Original SPARC 64-bit ABI says that structures and unions
6608        smaller than 16 bytes are passed in registers, as well as
6609        all other base types.
6610
6611        Extended ABI (as implemented by the Sun compiler) says that
6612        complex floats are passed in registers up to 16 bytes.  Pass
6613        all complex integers in registers up to 16 bytes.  More generally,
6614        enforce the 2-word cap for passing arguments in registers.
6615
6616        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6617        integers are passed like floats of the same size, that is in
6618        registers (up to 16 bytes).  Pass all vector floats like structure
6619        and unions.  */
6620     return ((type
6621              && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE)
6622              && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16)
6623             /* Catch CTImode and TCmode.  */
6624             || GET_MODE_SIZE (mode) > 16);
6625 }
6626
6627 /* Handle the TARGET_FUNCTION_ARG_ADVANCE hook.
6628    Update the data in CUM to advance over an argument
6629    of mode MODE and data type TYPE.
6630    TYPE is null for libcalls where that information may not be available.  */
6631
6632 static void
6633 sparc_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6634                             const_tree type, bool named)
6635 {
6636   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6637   int regno, padding;
6638
6639   /* We pass false for incoming_p here, it doesn't matter.  */
6640   function_arg_slotno (cum, mode, type, named, false, &regno, &padding);
6641
6642   /* If argument requires leading padding, add it.  */
6643   cum->words += padding;
6644
6645   if (TARGET_ARCH32)
6646     {
6647       cum->words += (mode != BLKmode
6648                      ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6649                      : ROUND_ADVANCE (int_size_in_bytes (type)));
6650     }
6651   else
6652     {
6653       if (type && AGGREGATE_TYPE_P (type))
6654         {
6655           int size = int_size_in_bytes (type);
6656
6657           if (size <= 8)
6658             ++cum->words;
6659           else if (size <= 16)
6660             cum->words += 2;
6661           else /* passed by reference */
6662             ++cum->words;
6663         }
6664       else
6665         {
6666           cum->words += (mode != BLKmode
6667                          ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6668                          : ROUND_ADVANCE (int_size_in_bytes (type)));
6669         }
6670     }
6671 }
6672
6673 /* Handle the FUNCTION_ARG_PADDING macro.
6674    For the 64 bit ABI structs are always stored left shifted in their
6675    argument slot.  */
6676
6677 enum direction
6678 function_arg_padding (enum machine_mode mode, const_tree type)
6679 {
6680   if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
6681     return upward;
6682
6683   /* Fall back to the default.  */
6684   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
6685 }
6686
6687 /* Handle the TARGET_RETURN_IN_MEMORY target hook.
6688    Specify whether to return the return value in memory.  */
6689
6690 static bool
6691 sparc_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
6692 {
6693   if (TARGET_ARCH32)
6694     /* Original SPARC 32-bit ABI says that structures and unions,
6695        and quad-precision floats are returned in memory.  All other
6696        base types are returned in registers.
6697
6698        Extended ABI (as implemented by the Sun compiler) says that
6699        all complex floats are returned in registers (8 FP registers
6700        at most for '_Complex long double').  Return all complex integers
6701        in registers (4 at most for '_Complex long long').
6702
6703        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6704        integers are returned like floats of the same size, that is in
6705        registers up to 8 bytes and in memory otherwise.  Return all
6706        vector floats in memory like structure and unions; note that
6707        they always have BLKmode like the latter.  */
6708     return (TYPE_MODE (type) == BLKmode
6709             || TYPE_MODE (type) == TFmode
6710             || (TREE_CODE (type) == VECTOR_TYPE
6711                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6712   else
6713     /* Original SPARC 64-bit ABI says that structures and unions
6714        smaller than 32 bytes are returned in registers, as well as
6715        all other base types.
6716
6717        Extended ABI (as implemented by the Sun compiler) says that all
6718        complex floats are returned in registers (8 FP registers at most
6719        for '_Complex long double').  Return all complex integers in
6720        registers (4 at most for '_Complex TItype').
6721
6722        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6723        integers are returned like floats of the same size, that is in
6724        registers.  Return all vector floats like structure and unions;
6725        note that they always have BLKmode like the latter.  */
6726     return (TYPE_MODE (type) == BLKmode
6727             && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 32);
6728 }
6729
6730 /* Handle the TARGET_STRUCT_VALUE target hook.
6731    Return where to find the structure return value address.  */
6732
6733 static rtx
6734 sparc_struct_value_rtx (tree fndecl, int incoming)
6735 {
6736   if (TARGET_ARCH64)
6737     return 0;
6738   else
6739     {
6740       rtx mem;
6741
6742       if (incoming)
6743         mem = gen_frame_mem (Pmode, plus_constant (Pmode, frame_pointer_rtx,
6744                                                    STRUCT_VALUE_OFFSET));
6745       else
6746         mem = gen_frame_mem (Pmode, plus_constant (Pmode, stack_pointer_rtx,
6747                                                    STRUCT_VALUE_OFFSET));
6748
6749       /* Only follow the SPARC ABI for fixed-size structure returns.
6750          Variable size structure returns are handled per the normal
6751          procedures in GCC. This is enabled by -mstd-struct-return */
6752       if (incoming == 2
6753           && sparc_std_struct_return
6754           && TYPE_SIZE_UNIT (TREE_TYPE (fndecl))
6755           && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (fndecl))) == INTEGER_CST)
6756         {
6757           /* We must check and adjust the return address, as it is
6758              optional as to whether the return object is really
6759              provided.  */
6760           rtx ret_reg = gen_rtx_REG (Pmode, 31);
6761           rtx scratch = gen_reg_rtx (SImode);
6762           rtx endlab = gen_label_rtx ();
6763
6764           /* Calculate the return object size */
6765           tree size = TYPE_SIZE_UNIT (TREE_TYPE (fndecl));
6766           rtx size_rtx = GEN_INT (TREE_INT_CST_LOW (size) & 0xfff);
6767           /* Construct a temporary return value */
6768           rtx temp_val
6769             = assign_stack_local (Pmode, TREE_INT_CST_LOW (size), 0);
6770
6771           /* Implement SPARC 32-bit psABI callee return struct checking:
6772
6773              Fetch the instruction where we will return to and see if
6774              it's an unimp instruction (the most significant 10 bits
6775              will be zero).  */
6776           emit_move_insn (scratch, gen_rtx_MEM (SImode,
6777                                                 plus_constant (Pmode,
6778                                                                ret_reg, 8)));
6779           /* Assume the size is valid and pre-adjust */
6780           emit_insn (gen_add3_insn (ret_reg, ret_reg, GEN_INT (4)));
6781           emit_cmp_and_jump_insns (scratch, size_rtx, EQ, const0_rtx, SImode,
6782                                    0, endlab);
6783           emit_insn (gen_sub3_insn (ret_reg, ret_reg, GEN_INT (4)));
6784           /* Write the address of the memory pointed to by temp_val into
6785              the memory pointed to by mem */
6786           emit_move_insn (mem, XEXP (temp_val, 0));
6787           emit_label (endlab);
6788         }
6789
6790       return mem;
6791     }
6792 }
6793
6794 /* Handle TARGET_FUNCTION_VALUE, and TARGET_LIBCALL_VALUE target hook.
6795    For v9, function return values are subject to the same rules as arguments,
6796    except that up to 32 bytes may be returned in registers.  */
6797
6798 static rtx
6799 sparc_function_value_1 (const_tree type, enum machine_mode mode,
6800                         bool outgoing)
6801 {
6802   /* Beware that the two values are swapped here wrt function_arg.  */
6803   int regbase = (outgoing
6804                  ? SPARC_INCOMING_INT_ARG_FIRST
6805                  : SPARC_OUTGOING_INT_ARG_FIRST);
6806   enum mode_class mclass = GET_MODE_CLASS (mode);
6807   int regno;
6808
6809   /* Vector types deserve special treatment because they are polymorphic wrt
6810      their mode, depending upon whether VIS instructions are enabled.  */
6811   if (type && TREE_CODE (type) == VECTOR_TYPE)
6812     {
6813       HOST_WIDE_INT size = int_size_in_bytes (type);
6814       gcc_assert ((TARGET_ARCH32 && size <= 8)
6815                   || (TARGET_ARCH64 && size <= 32));
6816
6817       if (mode == BLKmode)
6818         return function_arg_vector_value (size,
6819                                           SPARC_FP_ARG_FIRST);
6820       else
6821         mclass = MODE_FLOAT;
6822     }
6823
6824   if (TARGET_ARCH64 && type)
6825     {
6826       /* Structures up to 32 bytes in size are returned in registers.  */
6827       if (TREE_CODE (type) == RECORD_TYPE)
6828         {
6829           HOST_WIDE_INT size = int_size_in_bytes (type);
6830           gcc_assert (size <= 32);
6831
6832           return function_arg_record_value (type, mode, 0, 1, regbase);
6833         }
6834
6835       /* Unions up to 32 bytes in size are returned in integer registers.  */
6836       else if (TREE_CODE (type) == UNION_TYPE)
6837         {
6838           HOST_WIDE_INT size = int_size_in_bytes (type);
6839           gcc_assert (size <= 32);
6840
6841           return function_arg_union_value (size, mode, 0, regbase);
6842         }
6843
6844       /* Objects that require it are returned in FP registers.  */
6845       else if (mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6846         ;
6847
6848       /* All other aggregate types are returned in an integer register in a
6849          mode corresponding to the size of the type.  */
6850       else if (AGGREGATE_TYPE_P (type))
6851         {
6852           /* All other aggregate types are passed in an integer register
6853              in a mode corresponding to the size of the type.  */
6854           HOST_WIDE_INT size = int_size_in_bytes (type);
6855           gcc_assert (size <= 32);
6856
6857           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6858
6859           /* ??? We probably should have made the same ABI change in
6860              3.4.0 as the one we made for unions.   The latter was
6861              required by the SCD though, while the former is not
6862              specified, so we favored compatibility and efficiency.
6863
6864              Now we're stuck for aggregates larger than 16 bytes,
6865              because OImode vanished in the meantime.  Let's not
6866              try to be unduly clever, and simply follow the ABI
6867              for unions in that case.  */
6868           if (mode == BLKmode)
6869             return function_arg_union_value (size, mode, 0, regbase);
6870           else
6871             mclass = MODE_INT;
6872         }
6873
6874       /* We should only have pointer and integer types at this point.  This
6875          must match sparc_promote_function_mode.  */
6876       else if (mclass == MODE_INT && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6877         mode = word_mode;
6878     }
6879
6880   /* We should only have pointer and integer types at this point.  This must
6881      match sparc_promote_function_mode.  */
6882   else if (TARGET_ARCH32
6883            && mclass == MODE_INT
6884            && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6885     mode = word_mode;
6886
6887   if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT) && TARGET_FPU)
6888     regno = SPARC_FP_ARG_FIRST;
6889   else
6890     regno = regbase;
6891
6892   return gen_rtx_REG (mode, regno);
6893 }
6894
6895 /* Handle TARGET_FUNCTION_VALUE.
6896    On the SPARC, the value is found in the first "output" register, but the
6897    called function leaves it in the first "input" register.  */
6898
6899 static rtx
6900 sparc_function_value (const_tree valtype,
6901                       const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
6902                       bool outgoing)
6903 {
6904   return sparc_function_value_1 (valtype, TYPE_MODE (valtype), outgoing);
6905 }
6906
6907 /* Handle TARGET_LIBCALL_VALUE.  */
6908
6909 static rtx
6910 sparc_libcall_value (enum machine_mode mode,
6911                      const_rtx fun ATTRIBUTE_UNUSED)
6912 {
6913   return sparc_function_value_1 (NULL_TREE, mode, false);
6914 }
6915
6916 /* Handle FUNCTION_VALUE_REGNO_P.
6917    On the SPARC, the first "output" reg is used for integer values, and the
6918    first floating point register is used for floating point values.  */
6919
6920 static bool
6921 sparc_function_value_regno_p (const unsigned int regno)
6922 {
6923   return (regno == 8 || regno == 32);
6924 }
6925
6926 /* Do what is necessary for `va_start'.  We look at the current function
6927    to determine if stdarg or varargs is used and return the address of
6928    the first unnamed parameter.  */
6929
6930 static rtx
6931 sparc_builtin_saveregs (void)
6932 {
6933   int first_reg = crtl->args.info.words;
6934   rtx address;
6935   int regno;
6936
6937   for (regno = first_reg; regno < SPARC_INT_ARG_MAX; regno++)
6938     emit_move_insn (gen_rtx_MEM (word_mode,
6939                                  gen_rtx_PLUS (Pmode,
6940                                                frame_pointer_rtx,
6941                                                GEN_INT (FIRST_PARM_OFFSET (0)
6942                                                         + (UNITS_PER_WORD
6943                                                            * regno)))),
6944                     gen_rtx_REG (word_mode,
6945                                  SPARC_INCOMING_INT_ARG_FIRST + regno));
6946
6947   address = gen_rtx_PLUS (Pmode,
6948                           frame_pointer_rtx,
6949                           GEN_INT (FIRST_PARM_OFFSET (0)
6950                                    + UNITS_PER_WORD * first_reg));
6951
6952   return address;
6953 }
6954
6955 /* Implement `va_start' for stdarg.  */
6956
6957 static void
6958 sparc_va_start (tree valist, rtx nextarg)
6959 {
6960   nextarg = expand_builtin_saveregs ();
6961   std_expand_builtin_va_start (valist, nextarg);
6962 }
6963
6964 /* Implement `va_arg' for stdarg.  */
6965
6966 static tree
6967 sparc_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
6968                        gimple_seq *post_p)
6969 {
6970   HOST_WIDE_INT size, rsize, align;
6971   tree addr, incr;
6972   bool indirect;
6973   tree ptrtype = build_pointer_type (type);
6974
6975   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
6976     {
6977       indirect = true;
6978       size = rsize = UNITS_PER_WORD;
6979       align = 0;
6980     }
6981   else
6982     {
6983       indirect = false;
6984       size = int_size_in_bytes (type);
6985       rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
6986       align = 0;
6987
6988       if (TARGET_ARCH64)
6989         {
6990           /* For SPARC64, objects requiring 16-byte alignment get it.  */
6991           if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
6992             align = 2 * UNITS_PER_WORD;
6993
6994           /* SPARC-V9 ABI states that structures up to 16 bytes in size
6995              are left-justified in their slots.  */
6996           if (AGGREGATE_TYPE_P (type))
6997             {
6998               if (size == 0)
6999                 size = rsize = UNITS_PER_WORD;
7000               else
7001                 size = rsize;
7002             }
7003         }
7004     }
7005
7006   incr = valist;
7007   if (align)
7008     {
7009       incr = fold_build_pointer_plus_hwi (incr, align - 1);
7010       incr = fold_convert (sizetype, incr);
7011       incr = fold_build2 (BIT_AND_EXPR, sizetype, incr,
7012                           size_int (-align));
7013       incr = fold_convert (ptr_type_node, incr);
7014     }
7015
7016   gimplify_expr (&incr, pre_p, post_p, is_gimple_val, fb_rvalue);
7017   addr = incr;
7018
7019   if (BYTES_BIG_ENDIAN && size < rsize)
7020     addr = fold_build_pointer_plus_hwi (incr, rsize - size);
7021
7022   if (indirect)
7023     {
7024       addr = fold_convert (build_pointer_type (ptrtype), addr);
7025       addr = build_va_arg_indirect_ref (addr);
7026     }
7027
7028   /* If the address isn't aligned properly for the type, we need a temporary.
7029      FIXME: This is inefficient, usually we can do this in registers.  */
7030   else if (align == 0 && TYPE_ALIGN (type) > BITS_PER_WORD)
7031     {
7032       tree tmp = create_tmp_var (type, "va_arg_tmp");
7033       tree dest_addr = build_fold_addr_expr (tmp);
7034       tree copy = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
7035                                    3, dest_addr, addr, size_int (rsize));
7036       TREE_ADDRESSABLE (tmp) = 1;
7037       gimplify_and_add (copy, pre_p);
7038       addr = dest_addr;
7039     }
7040
7041   else
7042     addr = fold_convert (ptrtype, addr);
7043
7044   incr = fold_build_pointer_plus_hwi (incr, rsize);
7045   gimplify_assign (valist, incr, post_p);
7046
7047   return build_va_arg_indirect_ref (addr);
7048 }
7049 \f
7050 /* Implement the TARGET_VECTOR_MODE_SUPPORTED_P target hook.
7051    Specify whether the vector mode is supported by the hardware.  */
7052
7053 static bool
7054 sparc_vector_mode_supported_p (enum machine_mode mode)
7055 {
7056   return TARGET_VIS && VECTOR_MODE_P (mode) ? true : false;
7057 }
7058 \f
7059 /* Implement the TARGET_VECTORIZE_PREFERRED_SIMD_MODE target hook.  */
7060
7061 static enum machine_mode
7062 sparc_preferred_simd_mode (enum machine_mode mode)
7063 {
7064   if (TARGET_VIS)
7065     switch (mode)
7066       {
7067       case SImode:
7068         return V2SImode;
7069       case HImode:
7070         return V4HImode;
7071       case QImode:
7072         return V8QImode;
7073
7074       default:;
7075       }
7076
7077   return word_mode;
7078 }
7079 \f
7080 /* Return the string to output an unconditional branch to LABEL, which is
7081    the operand number of the label.
7082
7083    DEST is the destination insn (i.e. the label), INSN is the source.  */
7084
7085 const char *
7086 output_ubranch (rtx dest, int label, rtx insn)
7087 {
7088   static char string[64];
7089   bool v9_form = false;
7090   char *p;
7091
7092   if (TARGET_V9 && INSN_ADDRESSES_SET_P ())
7093     {
7094       int delta = (INSN_ADDRESSES (INSN_UID (dest))
7095                    - INSN_ADDRESSES (INSN_UID (insn)));
7096       /* Leave some instructions for "slop".  */
7097       if (delta >= -260000 && delta < 260000)
7098         v9_form = true;
7099     }
7100
7101   if (v9_form)
7102     strcpy (string, "ba%*,pt\t%%xcc, ");
7103   else
7104     strcpy (string, "b%*\t");
7105
7106   p = strchr (string, '\0');
7107   *p++ = '%';
7108   *p++ = 'l';
7109   *p++ = '0' + label;
7110   *p++ = '%';
7111   *p++ = '(';
7112   *p = '\0';
7113
7114   return string;
7115 }
7116
7117 /* Return the string to output a conditional branch to LABEL, which is
7118    the operand number of the label.  OP is the conditional expression.
7119    XEXP (OP, 0) is assumed to be a condition code register (integer or
7120    floating point) and its mode specifies what kind of comparison we made.
7121
7122    DEST is the destination insn (i.e. the label), INSN is the source.
7123
7124    REVERSED is nonzero if we should reverse the sense of the comparison.
7125
7126    ANNUL is nonzero if we should generate an annulling branch.  */
7127
7128 const char *
7129 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
7130                 rtx insn)
7131 {
7132   static char string[64];
7133   enum rtx_code code = GET_CODE (op);
7134   rtx cc_reg = XEXP (op, 0);
7135   enum machine_mode mode = GET_MODE (cc_reg);
7136   const char *labelno, *branch;
7137   int spaces = 8, far;
7138   char *p;
7139
7140   /* v9 branches are limited to +-1MB.  If it is too far away,
7141      change
7142
7143      bne,pt %xcc, .LC30
7144
7145      to
7146
7147      be,pn %xcc, .+12
7148       nop
7149      ba .LC30
7150
7151      and
7152
7153      fbne,a,pn %fcc2, .LC29
7154
7155      to
7156
7157      fbe,pt %fcc2, .+16
7158       nop
7159      ba .LC29  */
7160
7161   far = TARGET_V9 && (get_attr_length (insn) >= 3);
7162   if (reversed ^ far)
7163     {
7164       /* Reversal of FP compares takes care -- an ordered compare
7165          becomes an unordered compare and vice versa.  */
7166       if (mode == CCFPmode || mode == CCFPEmode)
7167         code = reverse_condition_maybe_unordered (code);
7168       else
7169         code = reverse_condition (code);
7170     }
7171
7172   /* Start by writing the branch condition.  */
7173   if (mode == CCFPmode || mode == CCFPEmode)
7174     {
7175       switch (code)
7176         {
7177         case NE:
7178           branch = "fbne";
7179           break;
7180         case EQ:
7181           branch = "fbe";
7182           break;
7183         case GE:
7184           branch = "fbge";
7185           break;
7186         case GT:
7187           branch = "fbg";
7188           break;
7189         case LE:
7190           branch = "fble";
7191           break;
7192         case LT:
7193           branch = "fbl";
7194           break;
7195         case UNORDERED:
7196           branch = "fbu";
7197           break;
7198         case ORDERED:
7199           branch = "fbo";
7200           break;
7201         case UNGT:
7202           branch = "fbug";
7203           break;
7204         case UNLT:
7205           branch = "fbul";
7206           break;
7207         case UNEQ:
7208           branch = "fbue";
7209           break;
7210         case UNGE:
7211           branch = "fbuge";
7212           break;
7213         case UNLE:
7214           branch = "fbule";
7215           break;
7216         case LTGT:
7217           branch = "fblg";
7218           break;
7219
7220         default:
7221           gcc_unreachable ();
7222         }
7223
7224       /* ??? !v9: FP branches cannot be preceded by another floating point
7225          insn.  Because there is currently no concept of pre-delay slots,
7226          we can fix this only by always emitting a nop before a floating
7227          point branch.  */
7228
7229       string[0] = '\0';
7230       if (! TARGET_V9)
7231         strcpy (string, "nop\n\t");
7232       strcat (string, branch);
7233     }
7234   else
7235     {
7236       switch (code)
7237         {
7238         case NE:
7239           branch = "bne";
7240           break;
7241         case EQ:
7242           branch = "be";
7243           break;
7244         case GE:
7245           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
7246             branch = "bpos";
7247           else
7248             branch = "bge";
7249           break;
7250         case GT:
7251           branch = "bg";
7252           break;
7253         case LE:
7254           branch = "ble";
7255           break;
7256         case LT:
7257           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
7258             branch = "bneg";
7259           else
7260             branch = "bl";
7261           break;
7262         case GEU:
7263           branch = "bgeu";
7264           break;
7265         case GTU:
7266           branch = "bgu";
7267           break;
7268         case LEU:
7269           branch = "bleu";
7270           break;
7271         case LTU:
7272           branch = "blu";
7273           break;
7274
7275         default:
7276           gcc_unreachable ();
7277         }
7278       strcpy (string, branch);
7279     }
7280   spaces -= strlen (branch);
7281   p = strchr (string, '\0');
7282
7283   /* Now add the annulling, the label, and a possible noop.  */
7284   if (annul && ! far)
7285     {
7286       strcpy (p, ",a");
7287       p += 2;
7288       spaces -= 2;
7289     }
7290
7291   if (TARGET_V9)
7292     {
7293       rtx note;
7294       int v8 = 0;
7295
7296       if (! far && insn && INSN_ADDRESSES_SET_P ())
7297         {
7298           int delta = (INSN_ADDRESSES (INSN_UID (dest))
7299                        - INSN_ADDRESSES (INSN_UID (insn)));
7300           /* Leave some instructions for "slop".  */
7301           if (delta < -260000 || delta >= 260000)
7302             v8 = 1;
7303         }
7304
7305       if (mode == CCFPmode || mode == CCFPEmode)
7306         {
7307           static char v9_fcc_labelno[] = "%%fccX, ";
7308           /* Set the char indicating the number of the fcc reg to use.  */
7309           v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
7310           labelno = v9_fcc_labelno;
7311           if (v8)
7312             {
7313               gcc_assert (REGNO (cc_reg) == SPARC_FCC_REG);
7314               labelno = "";
7315             }
7316         }
7317       else if (mode == CCXmode || mode == CCX_NOOVmode)
7318         {
7319           labelno = "%%xcc, ";
7320           gcc_assert (! v8);
7321         }
7322       else
7323         {
7324           labelno = "%%icc, ";
7325           if (v8)
7326             labelno = "";
7327         }
7328
7329       if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7330         {
7331           strcpy (p,
7332                   ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7333                   ? ",pt" : ",pn");
7334           p += 3;
7335           spaces -= 3;
7336         }
7337     }
7338   else
7339     labelno = "";
7340
7341   if (spaces > 0)
7342     *p++ = '\t';
7343   else
7344     *p++ = ' ';
7345   strcpy (p, labelno);
7346   p = strchr (p, '\0');
7347   if (far)
7348     {
7349       strcpy (p, ".+12\n\t nop\n\tb\t");
7350       /* Skip the next insn if requested or
7351          if we know that it will be a nop.  */
7352       if (annul || ! final_sequence)
7353         p[3] = '6';
7354       p += 14;
7355     }
7356   *p++ = '%';
7357   *p++ = 'l';
7358   *p++ = label + '0';
7359   *p++ = '%';
7360   *p++ = '#';
7361   *p = '\0';
7362
7363   return string;
7364 }
7365
7366 /* Emit a library call comparison between floating point X and Y.
7367    COMPARISON is the operator to compare with (EQ, NE, GT, etc).
7368    Return the new operator to be used in the comparison sequence.
7369
7370    TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
7371    values as arguments instead of the TFmode registers themselves,
7372    that's why we cannot call emit_float_lib_cmp.  */
7373
7374 rtx
7375 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
7376 {
7377   const char *qpfunc;
7378   rtx slot0, slot1, result, tem, tem2, libfunc;
7379   enum machine_mode mode;
7380   enum rtx_code new_comparison;
7381
7382   switch (comparison)
7383     {
7384     case EQ:
7385       qpfunc = (TARGET_ARCH64 ? "_Qp_feq" : "_Q_feq");
7386       break;
7387
7388     case NE:
7389       qpfunc = (TARGET_ARCH64 ? "_Qp_fne" : "_Q_fne");
7390       break;
7391
7392     case GT:
7393       qpfunc = (TARGET_ARCH64 ? "_Qp_fgt" : "_Q_fgt");
7394       break;
7395
7396     case GE:
7397       qpfunc = (TARGET_ARCH64 ? "_Qp_fge" : "_Q_fge");
7398       break;
7399
7400     case LT:
7401       qpfunc = (TARGET_ARCH64 ? "_Qp_flt" : "_Q_flt");
7402       break;
7403
7404     case LE:
7405       qpfunc = (TARGET_ARCH64 ? "_Qp_fle" : "_Q_fle");
7406       break;
7407
7408     case ORDERED:
7409     case UNORDERED:
7410     case UNGT:
7411     case UNLT:
7412     case UNEQ:
7413     case UNGE:
7414     case UNLE:
7415     case LTGT:
7416       qpfunc = (TARGET_ARCH64 ? "_Qp_cmp" : "_Q_cmp");
7417       break;
7418
7419     default:
7420       gcc_unreachable ();
7421     }
7422
7423   if (TARGET_ARCH64)
7424     {
7425       if (MEM_P (x))
7426         {
7427           tree expr = MEM_EXPR (x);
7428           if (expr)
7429             mark_addressable (expr);
7430           slot0 = x;
7431         }
7432       else
7433         {
7434           slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7435           emit_move_insn (slot0, x);
7436         }
7437
7438       if (MEM_P (y))
7439         {
7440           tree expr = MEM_EXPR (y);
7441           if (expr)
7442             mark_addressable (expr);
7443           slot1 = y;
7444         }
7445       else
7446         {
7447           slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7448           emit_move_insn (slot1, y);
7449         }
7450
7451       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7452       emit_library_call (libfunc, LCT_NORMAL,
7453                          DImode, 2,
7454                          XEXP (slot0, 0), Pmode,
7455                          XEXP (slot1, 0), Pmode);
7456       mode = DImode;
7457     }
7458   else
7459     {
7460       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7461       emit_library_call (libfunc, LCT_NORMAL,
7462                          SImode, 2,
7463                          x, TFmode, y, TFmode);
7464       mode = SImode;
7465     }
7466
7467
7468   /* Immediately move the result of the libcall into a pseudo
7469      register so reload doesn't clobber the value if it needs
7470      the return register for a spill reg.  */
7471   result = gen_reg_rtx (mode);
7472   emit_move_insn (result, hard_libcall_value (mode, libfunc));
7473
7474   switch (comparison)
7475     {
7476     default:
7477       return gen_rtx_NE (VOIDmode, result, const0_rtx);
7478     case ORDERED:
7479     case UNORDERED:
7480       new_comparison = (comparison == UNORDERED ? EQ : NE);
7481       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, GEN_INT(3));
7482     case UNGT:
7483     case UNGE:
7484       new_comparison = (comparison == UNGT ? GT : NE);
7485       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, const1_rtx);
7486     case UNLE:
7487       return gen_rtx_NE (VOIDmode, result, const2_rtx);
7488     case UNLT:
7489       tem = gen_reg_rtx (mode);
7490       if (TARGET_ARCH32)
7491         emit_insn (gen_andsi3 (tem, result, const1_rtx));
7492       else
7493         emit_insn (gen_anddi3 (tem, result, const1_rtx));
7494       return gen_rtx_NE (VOIDmode, tem, const0_rtx);
7495     case UNEQ:
7496     case LTGT:
7497       tem = gen_reg_rtx (mode);
7498       if (TARGET_ARCH32)
7499         emit_insn (gen_addsi3 (tem, result, const1_rtx));
7500       else
7501         emit_insn (gen_adddi3 (tem, result, const1_rtx));
7502       tem2 = gen_reg_rtx (mode);
7503       if (TARGET_ARCH32)
7504         emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
7505       else
7506         emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
7507       new_comparison = (comparison == UNEQ ? EQ : NE);
7508       return gen_rtx_fmt_ee (new_comparison, VOIDmode, tem2, const0_rtx);
7509     }
7510
7511   gcc_unreachable ();
7512 }
7513
7514 /* Generate an unsigned DImode to FP conversion.  This is the same code
7515    optabs would emit if we didn't have TFmode patterns.  */
7516
7517 void
7518 sparc_emit_floatunsdi (rtx *operands, enum machine_mode mode)
7519 {
7520   rtx neglab, donelab, i0, i1, f0, in, out;
7521
7522   out = operands[0];
7523   in = force_reg (DImode, operands[1]);
7524   neglab = gen_label_rtx ();
7525   donelab = gen_label_rtx ();
7526   i0 = gen_reg_rtx (DImode);
7527   i1 = gen_reg_rtx (DImode);
7528   f0 = gen_reg_rtx (mode);
7529
7530   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
7531
7532   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
7533   emit_jump_insn (gen_jump (donelab));
7534   emit_barrier ();
7535
7536   emit_label (neglab);
7537
7538   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
7539   emit_insn (gen_anddi3 (i1, in, const1_rtx));
7540   emit_insn (gen_iordi3 (i0, i0, i1));
7541   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
7542   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
7543
7544   emit_label (donelab);
7545 }
7546
7547 /* Generate an FP to unsigned DImode conversion.  This is the same code
7548    optabs would emit if we didn't have TFmode patterns.  */
7549
7550 void
7551 sparc_emit_fixunsdi (rtx *operands, enum machine_mode mode)
7552 {
7553   rtx neglab, donelab, i0, i1, f0, in, out, limit;
7554
7555   out = operands[0];
7556   in = force_reg (mode, operands[1]);
7557   neglab = gen_label_rtx ();
7558   donelab = gen_label_rtx ();
7559   i0 = gen_reg_rtx (DImode);
7560   i1 = gen_reg_rtx (DImode);
7561   limit = gen_reg_rtx (mode);
7562   f0 = gen_reg_rtx (mode);
7563
7564   emit_move_insn (limit,
7565                   CONST_DOUBLE_FROM_REAL_VALUE (
7566                     REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
7567   emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
7568
7569   emit_insn (gen_rtx_SET (VOIDmode,
7570                           out,
7571                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
7572   emit_jump_insn (gen_jump (donelab));
7573   emit_barrier ();
7574
7575   emit_label (neglab);
7576
7577   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
7578   emit_insn (gen_rtx_SET (VOIDmode,
7579                           i0,
7580                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
7581   emit_insn (gen_movdi (i1, const1_rtx));
7582   emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
7583   emit_insn (gen_xordi3 (out, i0, i1));
7584
7585   emit_label (donelab);
7586 }
7587
7588 /* Return the string to output a conditional branch to LABEL, testing
7589    register REG.  LABEL is the operand number of the label; REG is the
7590    operand number of the reg.  OP is the conditional expression.  The mode
7591    of REG says what kind of comparison we made.
7592
7593    DEST is the destination insn (i.e. the label), INSN is the source.
7594
7595    REVERSED is nonzero if we should reverse the sense of the comparison.
7596
7597    ANNUL is nonzero if we should generate an annulling branch.  */
7598
7599 const char *
7600 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
7601                  int annul, rtx insn)
7602 {
7603   static char string[64];
7604   enum rtx_code code = GET_CODE (op);
7605   enum machine_mode mode = GET_MODE (XEXP (op, 0));
7606   rtx note;
7607   int far;
7608   char *p;
7609
7610   /* branch on register are limited to +-128KB.  If it is too far away,
7611      change
7612
7613      brnz,pt %g1, .LC30
7614
7615      to
7616
7617      brz,pn %g1, .+12
7618       nop
7619      ba,pt %xcc, .LC30
7620
7621      and
7622
7623      brgez,a,pn %o1, .LC29
7624
7625      to
7626
7627      brlz,pt %o1, .+16
7628       nop
7629      ba,pt %xcc, .LC29  */
7630
7631   far = get_attr_length (insn) >= 3;
7632
7633   /* If not floating-point or if EQ or NE, we can just reverse the code.  */
7634   if (reversed ^ far)
7635     code = reverse_condition (code);
7636
7637   /* Only 64 bit versions of these instructions exist.  */
7638   gcc_assert (mode == DImode);
7639
7640   /* Start by writing the branch condition.  */
7641
7642   switch (code)
7643     {
7644     case NE:
7645       strcpy (string, "brnz");
7646       break;
7647
7648     case EQ:
7649       strcpy (string, "brz");
7650       break;
7651
7652     case GE:
7653       strcpy (string, "brgez");
7654       break;
7655
7656     case LT:
7657       strcpy (string, "brlz");
7658       break;
7659
7660     case LE:
7661       strcpy (string, "brlez");
7662       break;
7663
7664     case GT:
7665       strcpy (string, "brgz");
7666       break;
7667
7668     default:
7669       gcc_unreachable ();
7670     }
7671
7672   p = strchr (string, '\0');
7673
7674   /* Now add the annulling, reg, label, and nop.  */
7675   if (annul && ! far)
7676     {
7677       strcpy (p, ",a");
7678       p += 2;
7679     }
7680
7681   if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7682     {
7683       strcpy (p,
7684               ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7685               ? ",pt" : ",pn");
7686       p += 3;
7687     }
7688
7689   *p = p < string + 8 ? '\t' : ' ';
7690   p++;
7691   *p++ = '%';
7692   *p++ = '0' + reg;
7693   *p++ = ',';
7694   *p++ = ' ';
7695   if (far)
7696     {
7697       int veryfar = 1, delta;
7698
7699       if (INSN_ADDRESSES_SET_P ())
7700         {
7701           delta = (INSN_ADDRESSES (INSN_UID (dest))
7702                    - INSN_ADDRESSES (INSN_UID (insn)));
7703           /* Leave some instructions for "slop".  */
7704           if (delta >= -260000 && delta < 260000)
7705             veryfar = 0;
7706         }
7707
7708       strcpy (p, ".+12\n\t nop\n\t");
7709       /* Skip the next insn if requested or
7710          if we know that it will be a nop.  */
7711       if (annul || ! final_sequence)
7712         p[3] = '6';
7713       p += 12;
7714       if (veryfar)
7715         {
7716           strcpy (p, "b\t");
7717           p += 2;
7718         }
7719       else
7720         {
7721           strcpy (p, "ba,pt\t%%xcc, ");
7722           p += 13;
7723         }
7724     }
7725   *p++ = '%';
7726   *p++ = 'l';
7727   *p++ = '0' + label;
7728   *p++ = '%';
7729   *p++ = '#';
7730   *p = '\0';
7731
7732   return string;
7733 }
7734
7735 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
7736    Such instructions cannot be used in the delay slot of return insn on v9.
7737    If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
7738  */
7739
7740 static int
7741 epilogue_renumber (register rtx *where, int test)
7742 {
7743   register const char *fmt;
7744   register int i;
7745   register enum rtx_code code;
7746
7747   if (*where == 0)
7748     return 0;
7749
7750   code = GET_CODE (*where);
7751
7752   switch (code)
7753     {
7754     case REG:
7755       if (REGNO (*where) >= 8 && REGNO (*where) < 24)      /* oX or lX */
7756         return 1;
7757       if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
7758         *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
7759     case SCRATCH:
7760     case CC0:
7761     case PC:
7762     case CONST_INT:
7763     case CONST_DOUBLE:
7764       return 0;
7765
7766       /* Do not replace the frame pointer with the stack pointer because
7767          it can cause the delayed instruction to load below the stack.
7768          This occurs when instructions like:
7769
7770          (set (reg/i:SI 24 %i0)
7771              (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
7772                        (const_int -20 [0xffffffec])) 0))
7773
7774          are in the return delayed slot.  */
7775     case PLUS:
7776       if (GET_CODE (XEXP (*where, 0)) == REG
7777           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
7778           && (GET_CODE (XEXP (*where, 1)) != CONST_INT
7779               || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
7780         return 1;
7781       break;
7782
7783     case MEM:
7784       if (SPARC_STACK_BIAS
7785           && GET_CODE (XEXP (*where, 0)) == REG
7786           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
7787         return 1;
7788       break;
7789
7790     default:
7791       break;
7792     }
7793
7794   fmt = GET_RTX_FORMAT (code);
7795
7796   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7797     {
7798       if (fmt[i] == 'E')
7799         {
7800           register int j;
7801           for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
7802             if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
7803               return 1;
7804         }
7805       else if (fmt[i] == 'e'
7806                && epilogue_renumber (&(XEXP (*where, i)), test))
7807         return 1;
7808     }
7809   return 0;
7810 }
7811 \f
7812 /* Leaf functions and non-leaf functions have different needs.  */
7813
7814 static const int
7815 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
7816
7817 static const int
7818 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
7819
7820 static const int *const reg_alloc_orders[] = {
7821   reg_leaf_alloc_order,
7822   reg_nonleaf_alloc_order};
7823
7824 void
7825 order_regs_for_local_alloc (void)
7826 {
7827   static int last_order_nonleaf = 1;
7828
7829   if (df_regs_ever_live_p (15) != last_order_nonleaf)
7830     {
7831       last_order_nonleaf = !last_order_nonleaf;
7832       memcpy ((char *) reg_alloc_order,
7833               (const char *) reg_alloc_orders[last_order_nonleaf],
7834               FIRST_PSEUDO_REGISTER * sizeof (int));
7835     }
7836 }
7837 \f
7838 /* Return 1 if REG and MEM are legitimate enough to allow the various
7839    mem<-->reg splits to be run.  */
7840
7841 int
7842 sparc_splitdi_legitimate (rtx reg, rtx mem)
7843 {
7844   /* Punt if we are here by mistake.  */
7845   gcc_assert (reload_completed);
7846
7847   /* We must have an offsettable memory reference.  */
7848   if (! offsettable_memref_p (mem))
7849     return 0;
7850
7851   /* If we have legitimate args for ldd/std, we do not want
7852      the split to happen.  */
7853   if ((REGNO (reg) % 2) == 0
7854       && mem_min_alignment (mem, 8))
7855     return 0;
7856
7857   /* Success.  */
7858   return 1;
7859 }
7860
7861 /* Like sparc_splitdi_legitimate but for REG <--> REG moves.  */
7862
7863 int
7864 sparc_split_regreg_legitimate (rtx reg1, rtx reg2)
7865 {
7866   int regno1, regno2;
7867
7868   if (GET_CODE (reg1) == SUBREG)
7869     reg1 = SUBREG_REG (reg1);
7870   if (GET_CODE (reg1) != REG)
7871     return 0;
7872   regno1 = REGNO (reg1);
7873
7874   if (GET_CODE (reg2) == SUBREG)
7875     reg2 = SUBREG_REG (reg2);
7876   if (GET_CODE (reg2) != REG)
7877     return 0;
7878   regno2 = REGNO (reg2);
7879
7880   if (SPARC_INT_REG_P (regno1) && SPARC_INT_REG_P (regno2))
7881     return 1;
7882
7883   if (TARGET_VIS3)
7884     {
7885       if ((SPARC_INT_REG_P (regno1) && SPARC_FP_REG_P (regno2))
7886           || (SPARC_FP_REG_P (regno1) && SPARC_INT_REG_P (regno2)))
7887         return 1;
7888     }
7889
7890   return 0;
7891 }
7892
7893 /* Return 1 if x and y are some kind of REG and they refer to
7894    different hard registers.  This test is guaranteed to be
7895    run after reload.  */
7896
7897 int
7898 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
7899 {
7900   if (GET_CODE (x) != REG)
7901     return 0;
7902   if (GET_CODE (y) != REG)
7903     return 0;
7904   if (REGNO (x) == REGNO (y))
7905     return 0;
7906   return 1;
7907 }
7908
7909 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
7910    This makes them candidates for using ldd and std insns.
7911
7912    Note reg1 and reg2 *must* be hard registers.  */
7913
7914 int
7915 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
7916 {
7917   /* We might have been passed a SUBREG.  */
7918   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
7919     return 0;
7920
7921   if (REGNO (reg1) % 2 != 0)
7922     return 0;
7923
7924   /* Integer ldd is deprecated in SPARC V9 */
7925   if (TARGET_V9 && SPARC_INT_REG_P (REGNO (reg1)))
7926     return 0;
7927
7928   return (REGNO (reg1) == REGNO (reg2) - 1);
7929 }
7930
7931 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
7932    an ldd or std insn.
7933
7934    This can only happen when addr1 and addr2, the addresses in mem1
7935    and mem2, are consecutive memory locations (addr1 + 4 == addr2).
7936    addr1 must also be aligned on a 64-bit boundary.
7937
7938    Also iff dependent_reg_rtx is not null it should not be used to
7939    compute the address for mem1, i.e. we cannot optimize a sequence
7940    like:
7941         ld [%o0], %o0
7942         ld [%o0 + 4], %o1
7943    to
7944         ldd [%o0], %o0
7945    nor:
7946         ld [%g3 + 4], %g3
7947         ld [%g3], %g2
7948    to
7949         ldd [%g3], %g2
7950
7951    But, note that the transformation from:
7952         ld [%g2 + 4], %g3
7953         ld [%g2], %g2
7954    to
7955         ldd [%g2], %g2
7956    is perfectly fine.  Thus, the peephole2 patterns always pass us
7957    the destination register of the first load, never the second one.
7958
7959    For stores we don't have a similar problem, so dependent_reg_rtx is
7960    NULL_RTX.  */
7961
7962 int
7963 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
7964 {
7965   rtx addr1, addr2;
7966   unsigned int reg1;
7967   HOST_WIDE_INT offset1;
7968
7969   /* The mems cannot be volatile.  */
7970   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
7971     return 0;
7972
7973   /* MEM1 should be aligned on a 64-bit boundary.  */
7974   if (MEM_ALIGN (mem1) < 64)
7975     return 0;
7976
7977   addr1 = XEXP (mem1, 0);
7978   addr2 = XEXP (mem2, 0);
7979
7980   /* Extract a register number and offset (if used) from the first addr.  */
7981   if (GET_CODE (addr1) == PLUS)
7982     {
7983       /* If not a REG, return zero.  */
7984       if (GET_CODE (XEXP (addr1, 0)) != REG)
7985         return 0;
7986       else
7987         {
7988           reg1 = REGNO (XEXP (addr1, 0));
7989           /* The offset must be constant!  */
7990           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
7991             return 0;
7992           offset1 = INTVAL (XEXP (addr1, 1));
7993         }
7994     }
7995   else if (GET_CODE (addr1) != REG)
7996     return 0;
7997   else
7998     {
7999       reg1 = REGNO (addr1);
8000       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
8001       offset1 = 0;
8002     }
8003
8004   /* Make sure the second address is a (mem (plus (reg) (const_int).  */
8005   if (GET_CODE (addr2) != PLUS)
8006     return 0;
8007
8008   if (GET_CODE (XEXP (addr2, 0)) != REG
8009       || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
8010     return 0;
8011
8012   if (reg1 != REGNO (XEXP (addr2, 0)))
8013     return 0;
8014
8015   if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
8016     return 0;
8017
8018   /* The first offset must be evenly divisible by 8 to ensure the
8019      address is 64 bit aligned.  */
8020   if (offset1 % 8 != 0)
8021     return 0;
8022
8023   /* The offset for the second addr must be 4 more than the first addr.  */
8024   if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
8025     return 0;
8026
8027   /* All the tests passed.  addr1 and addr2 are valid for ldd and std
8028      instructions.  */
8029   return 1;
8030 }
8031
8032 /* Return 1 if reg is a pseudo, or is the first register in
8033    a hard register pair.  This makes it suitable for use in
8034    ldd and std insns.  */
8035
8036 int
8037 register_ok_for_ldd (rtx reg)
8038 {
8039   /* We might have been passed a SUBREG.  */
8040   if (!REG_P (reg))
8041     return 0;
8042
8043   if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
8044     return (REGNO (reg) % 2 == 0);
8045
8046   return 1;
8047 }
8048
8049 /* Return 1 if OP is a memory whose address is known to be
8050    aligned to 8-byte boundary, or a pseudo during reload.
8051    This makes it suitable for use in ldd and std insns.  */
8052
8053 int
8054 memory_ok_for_ldd (rtx op)
8055 {
8056   if (MEM_P (op))
8057     {
8058       /* In 64-bit mode, we assume that the address is word-aligned.  */
8059       if (TARGET_ARCH32 && !mem_min_alignment (op, 8))
8060         return 0;
8061
8062       if (! can_create_pseudo_p ()
8063           && !strict_memory_address_p (Pmode, XEXP (op, 0)))
8064         return 0;
8065     }
8066   else if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
8067     {
8068       if (!(reload_in_progress && reg_renumber [REGNO (op)] < 0))
8069         return 0;
8070     }
8071   else
8072     return 0;
8073
8074   return 1;
8075 }
8076 \f
8077 /* Implement TARGET_PRINT_OPERAND_PUNCT_VALID_P.  */
8078
8079 static bool
8080 sparc_print_operand_punct_valid_p (unsigned char code)
8081 {
8082   if (code == '#'
8083       || code == '*'
8084       || code == '('
8085       || code == ')'
8086       || code == '_'
8087       || code == '&')
8088     return true;
8089
8090   return false;
8091 }
8092
8093 /* Implement TARGET_PRINT_OPERAND.
8094    Print operand X (an rtx) in assembler syntax to file FILE.
8095    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
8096    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
8097
8098 static void
8099 sparc_print_operand (FILE *file, rtx x, int code)
8100 {
8101   switch (code)
8102     {
8103     case '#':
8104       /* Output an insn in a delay slot.  */
8105       if (final_sequence)
8106         sparc_indent_opcode = 1;
8107       else
8108         fputs ("\n\t nop", file);
8109       return;
8110     case '*':
8111       /* Output an annul flag if there's nothing for the delay slot and we
8112          are optimizing.  This is always used with '(' below.
8113          Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
8114          this is a dbx bug.  So, we only do this when optimizing.
8115          On UltraSPARC, a branch in a delay slot causes a pipeline flush.
8116          Always emit a nop in case the next instruction is a branch.  */
8117       if (! final_sequence && (optimize && (int)sparc_cpu < PROCESSOR_V9))
8118         fputs (",a", file);
8119       return;
8120     case '(':
8121       /* Output a 'nop' if there's nothing for the delay slot and we are
8122          not optimizing.  This is always used with '*' above.  */
8123       if (! final_sequence && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
8124         fputs ("\n\t nop", file);
8125       else if (final_sequence)
8126         sparc_indent_opcode = 1;
8127       return;
8128     case ')':
8129       /* Output the right displacement from the saved PC on function return.
8130          The caller may have placed an "unimp" insn immediately after the call
8131          so we have to account for it.  This insn is used in the 32-bit ABI
8132          when calling a function that returns a non zero-sized structure.  The
8133          64-bit ABI doesn't have it.  Be careful to have this test be the same
8134          as that for the call.  The exception is when sparc_std_struct_return
8135          is enabled, the psABI is followed exactly and the adjustment is made
8136          by the code in sparc_struct_value_rtx.  The call emitted is the same
8137          when sparc_std_struct_return is enabled. */
8138      if (!TARGET_ARCH64
8139          && cfun->returns_struct
8140          && !sparc_std_struct_return
8141          && DECL_SIZE (DECL_RESULT (current_function_decl))
8142          && TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))
8143              == INTEGER_CST
8144          && !integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl))))
8145         fputs ("12", file);
8146       else
8147         fputc ('8', file);
8148       return;
8149     case '_':
8150       /* Output the Embedded Medium/Anywhere code model base register.  */
8151       fputs (EMBMEDANY_BASE_REG, file);
8152       return;
8153     case '&':
8154       /* Print some local dynamic TLS name.  */
8155       assemble_name (file, get_some_local_dynamic_name ());
8156       return;
8157
8158     case 'Y':
8159       /* Adjust the operand to take into account a RESTORE operation.  */
8160       if (GET_CODE (x) == CONST_INT)
8161         break;
8162       else if (GET_CODE (x) != REG)
8163         output_operand_lossage ("invalid %%Y operand");
8164       else if (REGNO (x) < 8)
8165         fputs (reg_names[REGNO (x)], file);
8166       else if (REGNO (x) >= 24 && REGNO (x) < 32)
8167         fputs (reg_names[REGNO (x)-16], file);
8168       else
8169         output_operand_lossage ("invalid %%Y operand");
8170       return;
8171     case 'L':
8172       /* Print out the low order register name of a register pair.  */
8173       if (WORDS_BIG_ENDIAN)
8174         fputs (reg_names[REGNO (x)+1], file);
8175       else
8176         fputs (reg_names[REGNO (x)], file);
8177       return;
8178     case 'H':
8179       /* Print out the high order register name of a register pair.  */
8180       if (WORDS_BIG_ENDIAN)
8181         fputs (reg_names[REGNO (x)], file);
8182       else
8183         fputs (reg_names[REGNO (x)+1], file);
8184       return;
8185     case 'R':
8186       /* Print out the second register name of a register pair or quad.
8187          I.e., R (%o0) => %o1.  */
8188       fputs (reg_names[REGNO (x)+1], file);
8189       return;
8190     case 'S':
8191       /* Print out the third register name of a register quad.
8192          I.e., S (%o0) => %o2.  */
8193       fputs (reg_names[REGNO (x)+2], file);
8194       return;
8195     case 'T':
8196       /* Print out the fourth register name of a register quad.
8197          I.e., T (%o0) => %o3.  */
8198       fputs (reg_names[REGNO (x)+3], file);
8199       return;
8200     case 'x':
8201       /* Print a condition code register.  */
8202       if (REGNO (x) == SPARC_ICC_REG)
8203         {
8204           /* We don't handle CC[X]_NOOVmode because they're not supposed
8205              to occur here.  */
8206           if (GET_MODE (x) == CCmode)
8207             fputs ("%icc", file);
8208           else if (GET_MODE (x) == CCXmode)
8209             fputs ("%xcc", file);
8210           else
8211             gcc_unreachable ();
8212         }
8213       else
8214         /* %fccN register */
8215         fputs (reg_names[REGNO (x)], file);
8216       return;
8217     case 'm':
8218       /* Print the operand's address only.  */
8219       output_address (XEXP (x, 0));
8220       return;
8221     case 'r':
8222       /* In this case we need a register.  Use %g0 if the
8223          operand is const0_rtx.  */
8224       if (x == const0_rtx
8225           || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
8226         {
8227           fputs ("%g0", file);
8228           return;
8229         }
8230       else
8231         break;
8232
8233     case 'A':
8234       switch (GET_CODE (x))
8235         {
8236         case IOR: fputs ("or", file); break;
8237         case AND: fputs ("and", file); break;
8238         case XOR: fputs ("xor", file); break;
8239         default: output_operand_lossage ("invalid %%A operand");
8240         }
8241       return;
8242
8243     case 'B':
8244       switch (GET_CODE (x))
8245         {
8246         case IOR: fputs ("orn", file); break;
8247         case AND: fputs ("andn", file); break;
8248         case XOR: fputs ("xnor", file); break;
8249         default: output_operand_lossage ("invalid %%B operand");
8250         }
8251       return;
8252
8253       /* This is used by the conditional move instructions.  */
8254     case 'C':
8255       {
8256         enum rtx_code rc = GET_CODE (x);
8257
8258         switch (rc)
8259           {
8260           case NE: fputs ("ne", file); break;
8261           case EQ: fputs ("e", file); break;
8262           case GE: fputs ("ge", file); break;
8263           case GT: fputs ("g", file); break;
8264           case LE: fputs ("le", file); break;
8265           case LT: fputs ("l", file); break;
8266           case GEU: fputs ("geu", file); break;
8267           case GTU: fputs ("gu", file); break;
8268           case LEU: fputs ("leu", file); break;
8269           case LTU: fputs ("lu", file); break;
8270           case LTGT: fputs ("lg", file); break;
8271           case UNORDERED: fputs ("u", file); break;
8272           case ORDERED: fputs ("o", file); break;
8273           case UNLT: fputs ("ul", file); break;
8274           case UNLE: fputs ("ule", file); break;
8275           case UNGT: fputs ("ug", file); break;
8276           case UNGE: fputs ("uge", file); break;
8277           case UNEQ: fputs ("ue", file); break;
8278           default: output_operand_lossage ("invalid %%C operand");
8279           }
8280         return;
8281       }
8282
8283       /* This are used by the movr instruction pattern.  */
8284     case 'D':
8285       {
8286         enum rtx_code rc = GET_CODE (x);
8287         switch (rc)
8288           {
8289           case NE: fputs ("ne", file); break;
8290           case EQ: fputs ("e", file); break;
8291           case GE: fputs ("gez", file); break;
8292           case LT: fputs ("lz", file); break;
8293           case LE: fputs ("lez", file); break;
8294           case GT: fputs ("gz", file); break;
8295           default: output_operand_lossage ("invalid %%D operand");
8296           }
8297         return;
8298       }
8299
8300     case 'b':
8301       {
8302         /* Print a sign-extended character.  */
8303         int i = trunc_int_for_mode (INTVAL (x), QImode);
8304         fprintf (file, "%d", i);
8305         return;
8306       }
8307
8308     case 'f':
8309       /* Operand must be a MEM; write its address.  */
8310       if (GET_CODE (x) != MEM)
8311         output_operand_lossage ("invalid %%f operand");
8312       output_address (XEXP (x, 0));
8313       return;
8314
8315     case 's':
8316       {
8317         /* Print a sign-extended 32-bit value.  */
8318         HOST_WIDE_INT i;
8319         if (GET_CODE(x) == CONST_INT)
8320           i = INTVAL (x);
8321         else if (GET_CODE(x) == CONST_DOUBLE)
8322           i = CONST_DOUBLE_LOW (x);
8323         else
8324           {
8325             output_operand_lossage ("invalid %%s operand");
8326             return;
8327           }
8328         i = trunc_int_for_mode (i, SImode);
8329         fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
8330         return;
8331       }
8332
8333     case 0:
8334       /* Do nothing special.  */
8335       break;
8336
8337     default:
8338       /* Undocumented flag.  */
8339       output_operand_lossage ("invalid operand output code");
8340     }
8341
8342   if (GET_CODE (x) == REG)
8343     fputs (reg_names[REGNO (x)], file);
8344   else if (GET_CODE (x) == MEM)
8345     {
8346       fputc ('[', file);
8347         /* Poor Sun assembler doesn't understand absolute addressing.  */
8348       if (CONSTANT_P (XEXP (x, 0)))
8349         fputs ("%g0+", file);
8350       output_address (XEXP (x, 0));
8351       fputc (']', file);
8352     }
8353   else if (GET_CODE (x) == HIGH)
8354     {
8355       fputs ("%hi(", file);
8356       output_addr_const (file, XEXP (x, 0));
8357       fputc (')', file);
8358     }
8359   else if (GET_CODE (x) == LO_SUM)
8360     {
8361       sparc_print_operand (file, XEXP (x, 0), 0);
8362       if (TARGET_CM_MEDMID)
8363         fputs ("+%l44(", file);
8364       else
8365         fputs ("+%lo(", file);
8366       output_addr_const (file, XEXP (x, 1));
8367       fputc (')', file);
8368     }
8369   else if (GET_CODE (x) == CONST_DOUBLE
8370            && (GET_MODE (x) == VOIDmode
8371                || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
8372     {
8373       if (CONST_DOUBLE_HIGH (x) == 0)
8374         fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
8375       else if (CONST_DOUBLE_HIGH (x) == -1
8376                && CONST_DOUBLE_LOW (x) < 0)
8377         fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
8378       else
8379         output_operand_lossage ("long long constant not a valid immediate operand");
8380     }
8381   else if (GET_CODE (x) == CONST_DOUBLE)
8382     output_operand_lossage ("floating point constant not a valid immediate operand");
8383   else { output_addr_const (file, x); }
8384 }
8385
8386 /* Implement TARGET_PRINT_OPERAND_ADDRESS.  */
8387
8388 static void
8389 sparc_print_operand_address (FILE *file, rtx x)
8390 {
8391   register rtx base, index = 0;
8392   int offset = 0;
8393   register rtx addr = x;
8394
8395   if (REG_P (addr))
8396     fputs (reg_names[REGNO (addr)], file);
8397   else if (GET_CODE (addr) == PLUS)
8398     {
8399       if (CONST_INT_P (XEXP (addr, 0)))
8400         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);
8401       else if (CONST_INT_P (XEXP (addr, 1)))
8402         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);
8403       else
8404         base = XEXP (addr, 0), index = XEXP (addr, 1);
8405       if (GET_CODE (base) == LO_SUM)
8406         {
8407           gcc_assert (USE_AS_OFFSETABLE_LO10
8408                       && TARGET_ARCH64
8409                       && ! TARGET_CM_MEDMID);
8410           output_operand (XEXP (base, 0), 0);
8411           fputs ("+%lo(", file);
8412           output_address (XEXP (base, 1));
8413           fprintf (file, ")+%d", offset);
8414         }
8415       else
8416         {
8417           fputs (reg_names[REGNO (base)], file);
8418           if (index == 0)
8419             fprintf (file, "%+d", offset);
8420           else if (REG_P (index))
8421             fprintf (file, "+%s", reg_names[REGNO (index)]);
8422           else if (GET_CODE (index) == SYMBOL_REF
8423                    || GET_CODE (index) == LABEL_REF
8424                    || GET_CODE (index) == CONST)
8425             fputc ('+', file), output_addr_const (file, index);
8426           else gcc_unreachable ();
8427         }
8428     }
8429   else if (GET_CODE (addr) == MINUS
8430            && GET_CODE (XEXP (addr, 1)) == LABEL_REF)
8431     {
8432       output_addr_const (file, XEXP (addr, 0));
8433       fputs ("-(", file);
8434       output_addr_const (file, XEXP (addr, 1));
8435       fputs ("-.)", file);
8436     }
8437   else if (GET_CODE (addr) == LO_SUM)
8438     {
8439       output_operand (XEXP (addr, 0), 0);
8440       if (TARGET_CM_MEDMID)
8441         fputs ("+%l44(", file);
8442       else
8443         fputs ("+%lo(", file);
8444       output_address (XEXP (addr, 1));
8445       fputc (')', file);
8446     }
8447   else if (flag_pic
8448            && GET_CODE (addr) == CONST
8449            && GET_CODE (XEXP (addr, 0)) == MINUS
8450            && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST
8451            && GET_CODE (XEXP (XEXP (XEXP (addr, 0), 1), 0)) == MINUS
8452            && XEXP (XEXP (XEXP (XEXP (addr, 0), 1), 0), 1) == pc_rtx)
8453     {
8454       addr = XEXP (addr, 0);
8455       output_addr_const (file, XEXP (addr, 0));
8456       /* Group the args of the second CONST in parenthesis.  */
8457       fputs ("-(", file);
8458       /* Skip past the second CONST--it does nothing for us.  */
8459       output_addr_const (file, XEXP (XEXP (addr, 1), 0));
8460       /* Close the parenthesis.  */
8461       fputc (')', file);
8462     }
8463   else
8464     {
8465       output_addr_const (file, addr);
8466     }
8467 }
8468 \f
8469 /* Target hook for assembling integer objects.  The sparc version has
8470    special handling for aligned DI-mode objects.  */
8471
8472 static bool
8473 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
8474 {
8475   /* ??? We only output .xword's for symbols and only then in environments
8476      where the assembler can handle them.  */
8477   if (aligned_p && size == 8
8478       && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
8479     {
8480       if (TARGET_V9)
8481         {
8482           assemble_integer_with_op ("\t.xword\t", x);
8483           return true;
8484         }
8485       else
8486         {
8487           assemble_aligned_integer (4, const0_rtx);
8488           assemble_aligned_integer (4, x);
8489           return true;
8490         }
8491     }
8492   return default_assemble_integer (x, size, aligned_p);
8493 }
8494 \f
8495 /* Return the value of a code used in the .proc pseudo-op that says
8496    what kind of result this function returns.  For non-C types, we pick
8497    the closest C type.  */
8498
8499 #ifndef SHORT_TYPE_SIZE
8500 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
8501 #endif
8502
8503 #ifndef INT_TYPE_SIZE
8504 #define INT_TYPE_SIZE BITS_PER_WORD
8505 #endif
8506
8507 #ifndef LONG_TYPE_SIZE
8508 #define LONG_TYPE_SIZE BITS_PER_WORD
8509 #endif
8510
8511 #ifndef LONG_LONG_TYPE_SIZE
8512 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
8513 #endif
8514
8515 #ifndef FLOAT_TYPE_SIZE
8516 #define FLOAT_TYPE_SIZE BITS_PER_WORD
8517 #endif
8518
8519 #ifndef DOUBLE_TYPE_SIZE
8520 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8521 #endif
8522
8523 #ifndef LONG_DOUBLE_TYPE_SIZE
8524 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8525 #endif
8526
8527 unsigned long
8528 sparc_type_code (register tree type)
8529 {
8530   register unsigned long qualifiers = 0;
8531   register unsigned shift;
8532
8533   /* Only the first 30 bits of the qualifier are valid.  We must refrain from
8534      setting more, since some assemblers will give an error for this.  Also,
8535      we must be careful to avoid shifts of 32 bits or more to avoid getting
8536      unpredictable results.  */
8537
8538   for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
8539     {
8540       switch (TREE_CODE (type))
8541         {
8542         case ERROR_MARK:
8543           return qualifiers;
8544
8545         case ARRAY_TYPE:
8546           qualifiers |= (3 << shift);
8547           break;
8548
8549         case FUNCTION_TYPE:
8550         case METHOD_TYPE:
8551           qualifiers |= (2 << shift);
8552           break;
8553
8554         case POINTER_TYPE:
8555         case REFERENCE_TYPE:
8556         case OFFSET_TYPE:
8557           qualifiers |= (1 << shift);
8558           break;
8559
8560         case RECORD_TYPE:
8561           return (qualifiers | 8);
8562
8563         case UNION_TYPE:
8564         case QUAL_UNION_TYPE:
8565           return (qualifiers | 9);
8566
8567         case ENUMERAL_TYPE:
8568           return (qualifiers | 10);
8569
8570         case VOID_TYPE:
8571           return (qualifiers | 16);
8572
8573         case INTEGER_TYPE:
8574           /* If this is a range type, consider it to be the underlying
8575              type.  */
8576           if (TREE_TYPE (type) != 0)
8577             break;
8578
8579           /* Carefully distinguish all the standard types of C,
8580              without messing up if the language is not C.  We do this by
8581              testing TYPE_PRECISION and TYPE_UNSIGNED.  The old code used to
8582              look at both the names and the above fields, but that's redundant.
8583              Any type whose size is between two C types will be considered
8584              to be the wider of the two types.  Also, we do not have a
8585              special code to use for "long long", so anything wider than
8586              long is treated the same.  Note that we can't distinguish
8587              between "int" and "long" in this code if they are the same
8588              size, but that's fine, since neither can the assembler.  */
8589
8590           if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
8591             return (qualifiers | (TYPE_UNSIGNED (type) ? 12 : 2));
8592
8593           else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
8594             return (qualifiers | (TYPE_UNSIGNED (type) ? 13 : 3));
8595
8596           else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
8597             return (qualifiers | (TYPE_UNSIGNED (type) ? 14 : 4));
8598
8599           else
8600             return (qualifiers | (TYPE_UNSIGNED (type) ? 15 : 5));
8601
8602         case REAL_TYPE:
8603           /* If this is a range type, consider it to be the underlying
8604              type.  */
8605           if (TREE_TYPE (type) != 0)
8606             break;
8607
8608           /* Carefully distinguish all the standard types of C,
8609              without messing up if the language is not C.  */
8610
8611           if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
8612             return (qualifiers | 6);
8613
8614           else
8615             return (qualifiers | 7);
8616
8617         case COMPLEX_TYPE:      /* GNU Fortran COMPLEX type.  */
8618           /* ??? We need to distinguish between double and float complex types,
8619              but I don't know how yet because I can't reach this code from
8620              existing front-ends.  */
8621           return (qualifiers | 7);      /* Who knows? */
8622
8623         case VECTOR_TYPE:
8624         case BOOLEAN_TYPE:      /* Boolean truth value type.  */
8625         case LANG_TYPE:
8626         case NULLPTR_TYPE:
8627           return qualifiers;
8628
8629         default:
8630           gcc_unreachable ();           /* Not a type! */
8631         }
8632     }
8633
8634   return qualifiers;
8635 }
8636 \f
8637 /* Nested function support.  */
8638
8639 /* Emit RTL insns to initialize the variable parts of a trampoline.
8640    FNADDR is an RTX for the address of the function's pure code.
8641    CXT is an RTX for the static chain value for the function.
8642
8643    This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
8644    (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
8645    (to store insns).  This is a bit excessive.  Perhaps a different
8646    mechanism would be better here.
8647
8648    Emit enough FLUSH insns to synchronize the data and instruction caches.  */
8649
8650 static void
8651 sparc32_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8652 {
8653   /* SPARC 32-bit trampoline:
8654
8655         sethi   %hi(fn), %g1
8656         sethi   %hi(static), %g2
8657         jmp     %g1+%lo(fn)
8658         or      %g2, %lo(static), %g2
8659
8660     SETHI i,r  = 00rr rrr1 00ii iiii iiii iiii iiii iiii
8661     JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
8662    */
8663
8664   emit_move_insn
8665     (adjust_address (m_tramp, SImode, 0),
8666      expand_binop (SImode, ior_optab,
8667                    expand_shift (RSHIFT_EXPR, SImode, fnaddr, 10, 0, 1),
8668                    GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
8669                    NULL_RTX, 1, OPTAB_DIRECT));
8670
8671   emit_move_insn
8672     (adjust_address (m_tramp, SImode, 4),
8673      expand_binop (SImode, ior_optab,
8674                    expand_shift (RSHIFT_EXPR, SImode, cxt, 10, 0, 1),
8675                    GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
8676                    NULL_RTX, 1, OPTAB_DIRECT));
8677
8678   emit_move_insn
8679     (adjust_address (m_tramp, SImode, 8),
8680      expand_binop (SImode, ior_optab,
8681                    expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
8682                    GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
8683                    NULL_RTX, 1, OPTAB_DIRECT));
8684
8685   emit_move_insn
8686     (adjust_address (m_tramp, SImode, 12),
8687      expand_binop (SImode, ior_optab,
8688                    expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
8689                    GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
8690                    NULL_RTX, 1, OPTAB_DIRECT));
8691
8692   /* On UltraSPARC a flush flushes an entire cache line.  The trampoline is
8693      aligned on a 16 byte boundary so one flush clears it all.  */
8694   emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 0))));
8695   if (sparc_cpu != PROCESSOR_ULTRASPARC
8696       && sparc_cpu != PROCESSOR_ULTRASPARC3
8697       && sparc_cpu != PROCESSOR_NIAGARA
8698       && sparc_cpu != PROCESSOR_NIAGARA2
8699       && sparc_cpu != PROCESSOR_NIAGARA3
8700       && sparc_cpu != PROCESSOR_NIAGARA4)
8701     emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 8))));
8702
8703   /* Call __enable_execute_stack after writing onto the stack to make sure
8704      the stack address is accessible.  */
8705 #ifdef HAVE_ENABLE_EXECUTE_STACK
8706   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8707                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8708 #endif
8709
8710 }
8711
8712 /* The 64-bit version is simpler because it makes more sense to load the
8713    values as "immediate" data out of the trampoline.  It's also easier since
8714    we can read the PC without clobbering a register.  */
8715
8716 static void
8717 sparc64_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8718 {
8719   /* SPARC 64-bit trampoline:
8720
8721         rd      %pc, %g1
8722         ldx     [%g1+24], %g5
8723         jmp     %g5
8724         ldx     [%g1+16], %g5
8725         +16 bytes data
8726    */
8727
8728   emit_move_insn (adjust_address (m_tramp, SImode, 0),
8729                   GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
8730   emit_move_insn (adjust_address (m_tramp, SImode, 4),
8731                   GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
8732   emit_move_insn (adjust_address (m_tramp, SImode, 8),
8733                   GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
8734   emit_move_insn (adjust_address (m_tramp, SImode, 12),
8735                   GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
8736   emit_move_insn (adjust_address (m_tramp, DImode, 16), cxt);
8737   emit_move_insn (adjust_address (m_tramp, DImode, 24), fnaddr);
8738   emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 0))));
8739
8740   if (sparc_cpu != PROCESSOR_ULTRASPARC
8741       && sparc_cpu != PROCESSOR_ULTRASPARC3
8742       && sparc_cpu != PROCESSOR_NIAGARA
8743       && sparc_cpu != PROCESSOR_NIAGARA2
8744       && sparc_cpu != PROCESSOR_NIAGARA3
8745       && sparc_cpu != PROCESSOR_NIAGARA4)
8746     emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 8))));
8747
8748   /* Call __enable_execute_stack after writing onto the stack to make sure
8749      the stack address is accessible.  */
8750 #ifdef HAVE_ENABLE_EXECUTE_STACK
8751   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8752                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8753 #endif
8754 }
8755
8756 /* Worker for TARGET_TRAMPOLINE_INIT.  */
8757
8758 static void
8759 sparc_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
8760 {
8761   rtx fnaddr = force_reg (Pmode, XEXP (DECL_RTL (fndecl), 0));
8762   cxt = force_reg (Pmode, cxt);
8763   if (TARGET_ARCH64)
8764     sparc64_initialize_trampoline (m_tramp, fnaddr, cxt);
8765   else
8766     sparc32_initialize_trampoline (m_tramp, fnaddr, cxt);
8767 }
8768 \f
8769 /* Adjust the cost of a scheduling dependency.  Return the new cost of
8770    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
8771
8772 static int
8773 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8774 {
8775   enum attr_type insn_type;
8776
8777   if (! recog_memoized (insn))
8778     return 0;
8779
8780   insn_type = get_attr_type (insn);
8781
8782   if (REG_NOTE_KIND (link) == 0)
8783     {
8784       /* Data dependency; DEP_INSN writes a register that INSN reads some
8785          cycles later.  */
8786
8787       /* if a load, then the dependence must be on the memory address;
8788          add an extra "cycle".  Note that the cost could be two cycles
8789          if the reg was written late in an instruction group; we ca not tell
8790          here.  */
8791       if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
8792         return cost + 3;
8793
8794       /* Get the delay only if the address of the store is the dependence.  */
8795       if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
8796         {
8797           rtx pat = PATTERN(insn);
8798           rtx dep_pat = PATTERN (dep_insn);
8799
8800           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8801             return cost;  /* This should not happen!  */
8802
8803           /* The dependency between the two instructions was on the data that
8804              is being stored.  Assume that this implies that the address of the
8805              store is not dependent.  */
8806           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8807             return cost;
8808
8809           return cost + 3;  /* An approximation.  */
8810         }
8811
8812       /* A shift instruction cannot receive its data from an instruction
8813          in the same cycle; add a one cycle penalty.  */
8814       if (insn_type == TYPE_SHIFT)
8815         return cost + 3;   /* Split before cascade into shift.  */
8816     }
8817   else
8818     {
8819       /* Anti- or output- dependency; DEP_INSN reads/writes a register that
8820          INSN writes some cycles later.  */
8821
8822       /* These are only significant for the fpu unit; writing a fp reg before
8823          the fpu has finished with it stalls the processor.  */
8824
8825       /* Reusing an integer register causes no problems.  */
8826       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8827         return 0;
8828     }
8829
8830   return cost;
8831 }
8832
8833 static int
8834 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8835 {
8836   enum attr_type insn_type, dep_type;
8837   rtx pat = PATTERN(insn);
8838   rtx dep_pat = PATTERN (dep_insn);
8839
8840   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
8841     return cost;
8842
8843   insn_type = get_attr_type (insn);
8844   dep_type = get_attr_type (dep_insn);
8845
8846   switch (REG_NOTE_KIND (link))
8847     {
8848     case 0:
8849       /* Data dependency; DEP_INSN writes a register that INSN reads some
8850          cycles later.  */
8851
8852       switch (insn_type)
8853         {
8854         case TYPE_STORE:
8855         case TYPE_FPSTORE:
8856           /* Get the delay iff the address of the store is the dependence.  */
8857           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8858             return cost;
8859
8860           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8861             return cost;
8862           return cost + 3;
8863
8864         case TYPE_LOAD:
8865         case TYPE_SLOAD:
8866         case TYPE_FPLOAD:
8867           /* If a load, then the dependence must be on the memory address.  If
8868              the addresses aren't equal, then it might be a false dependency */
8869           if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
8870             {
8871               if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
8872                   || GET_CODE (SET_DEST (dep_pat)) != MEM
8873                   || GET_CODE (SET_SRC (pat)) != MEM
8874                   || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
8875                                     XEXP (SET_SRC (pat), 0)))
8876                 return cost + 2;
8877
8878               return cost + 8;
8879             }
8880           break;
8881
8882         case TYPE_BRANCH:
8883           /* Compare to branch latency is 0.  There is no benefit from
8884              separating compare and branch.  */
8885           if (dep_type == TYPE_COMPARE)
8886             return 0;
8887           /* Floating point compare to branch latency is less than
8888              compare to conditional move.  */
8889           if (dep_type == TYPE_FPCMP)
8890             return cost - 1;
8891           break;
8892         default:
8893           break;
8894         }
8895         break;
8896
8897     case REG_DEP_ANTI:
8898       /* Anti-dependencies only penalize the fpu unit.  */
8899       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8900         return 0;
8901       break;
8902
8903     default:
8904       break;
8905     }
8906
8907   return cost;
8908 }
8909
8910 static int
8911 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
8912 {
8913   switch (sparc_cpu)
8914     {
8915     case PROCESSOR_SUPERSPARC:
8916       cost = supersparc_adjust_cost (insn, link, dep, cost);
8917       break;
8918     case PROCESSOR_HYPERSPARC:
8919     case PROCESSOR_SPARCLITE86X:
8920       cost = hypersparc_adjust_cost (insn, link, dep, cost);
8921       break;
8922     default:
8923       break;
8924     }
8925   return cost;
8926 }
8927
8928 static void
8929 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
8930                   int sched_verbose ATTRIBUTE_UNUSED,
8931                   int max_ready ATTRIBUTE_UNUSED)
8932 {}
8933
8934 static int
8935 sparc_use_sched_lookahead (void)
8936 {
8937   if (sparc_cpu == PROCESSOR_NIAGARA
8938       || sparc_cpu == PROCESSOR_NIAGARA2
8939       || sparc_cpu == PROCESSOR_NIAGARA3)
8940     return 0;
8941   if (sparc_cpu == PROCESSOR_NIAGARA4)
8942     return 2;
8943   if (sparc_cpu == PROCESSOR_ULTRASPARC
8944       || sparc_cpu == PROCESSOR_ULTRASPARC3)
8945     return 4;
8946   if ((1 << sparc_cpu) &
8947       ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
8948        (1 << PROCESSOR_SPARCLITE86X)))
8949     return 3;
8950   return 0;
8951 }
8952
8953 static int
8954 sparc_issue_rate (void)
8955 {
8956   switch (sparc_cpu)
8957     {
8958     case PROCESSOR_NIAGARA:
8959     case PROCESSOR_NIAGARA2:
8960     case PROCESSOR_NIAGARA3:
8961     default:
8962       return 1;
8963     case PROCESSOR_NIAGARA4:
8964     case PROCESSOR_V9:
8965       /* Assume V9 processors are capable of at least dual-issue.  */
8966       return 2;
8967     case PROCESSOR_SUPERSPARC:
8968       return 3;
8969     case PROCESSOR_HYPERSPARC:
8970     case PROCESSOR_SPARCLITE86X:
8971       return 2;
8972     case PROCESSOR_ULTRASPARC:
8973     case PROCESSOR_ULTRASPARC3:
8974       return 4;
8975     }
8976 }
8977
8978 static int
8979 set_extends (rtx insn)
8980 {
8981   register rtx pat = PATTERN (insn);
8982
8983   switch (GET_CODE (SET_SRC (pat)))
8984     {
8985       /* Load and some shift instructions zero extend.  */
8986     case MEM:
8987     case ZERO_EXTEND:
8988       /* sethi clears the high bits */
8989     case HIGH:
8990       /* LO_SUM is used with sethi.  sethi cleared the high
8991          bits and the values used with lo_sum are positive */
8992     case LO_SUM:
8993       /* Store flag stores 0 or 1 */
8994     case LT: case LTU:
8995     case GT: case GTU:
8996     case LE: case LEU:
8997     case GE: case GEU:
8998     case EQ:
8999     case NE:
9000       return 1;
9001     case AND:
9002       {
9003         rtx op0 = XEXP (SET_SRC (pat), 0);
9004         rtx op1 = XEXP (SET_SRC (pat), 1);
9005         if (GET_CODE (op1) == CONST_INT)
9006           return INTVAL (op1) >= 0;
9007         if (GET_CODE (op0) != REG)
9008           return 0;
9009         if (sparc_check_64 (op0, insn) == 1)
9010           return 1;
9011         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
9012       }
9013     case IOR:
9014     case XOR:
9015       {
9016         rtx op0 = XEXP (SET_SRC (pat), 0);
9017         rtx op1 = XEXP (SET_SRC (pat), 1);
9018         if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
9019           return 0;
9020         if (GET_CODE (op1) == CONST_INT)
9021           return INTVAL (op1) >= 0;
9022         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
9023       }
9024     case LSHIFTRT:
9025       return GET_MODE (SET_SRC (pat)) == SImode;
9026       /* Positive integers leave the high bits zero.  */
9027     case CONST_DOUBLE:
9028       return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
9029     case CONST_INT:
9030       return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
9031     case ASHIFTRT:
9032     case SIGN_EXTEND:
9033       return - (GET_MODE (SET_SRC (pat)) == SImode);
9034     case REG:
9035       return sparc_check_64 (SET_SRC (pat), insn);
9036     default:
9037       return 0;
9038     }
9039 }
9040
9041 /* We _ought_ to have only one kind per function, but...  */
9042 static GTY(()) rtx sparc_addr_diff_list;
9043 static GTY(()) rtx sparc_addr_list;
9044
9045 void
9046 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
9047 {
9048   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
9049   if (diff)
9050     sparc_addr_diff_list
9051       = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
9052   else
9053     sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
9054 }
9055
9056 static void
9057 sparc_output_addr_vec (rtx vec)
9058 {
9059   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
9060   int idx, vlen = XVECLEN (body, 0);
9061
9062 #ifdef ASM_OUTPUT_ADDR_VEC_START
9063   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
9064 #endif
9065
9066 #ifdef ASM_OUTPUT_CASE_LABEL
9067   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
9068                          NEXT_INSN (lab));
9069 #else
9070   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
9071 #endif
9072
9073   for (idx = 0; idx < vlen; idx++)
9074     {
9075       ASM_OUTPUT_ADDR_VEC_ELT
9076         (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
9077     }
9078
9079 #ifdef ASM_OUTPUT_ADDR_VEC_END
9080   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
9081 #endif
9082 }
9083
9084 static void
9085 sparc_output_addr_diff_vec (rtx vec)
9086 {
9087   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
9088   rtx base = XEXP (XEXP (body, 0), 0);
9089   int idx, vlen = XVECLEN (body, 1);
9090
9091 #ifdef ASM_OUTPUT_ADDR_VEC_START
9092   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
9093 #endif
9094
9095 #ifdef ASM_OUTPUT_CASE_LABEL
9096   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
9097                          NEXT_INSN (lab));
9098 #else
9099   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
9100 #endif
9101
9102   for (idx = 0; idx < vlen; idx++)
9103     {
9104       ASM_OUTPUT_ADDR_DIFF_ELT
9105         (asm_out_file,
9106          body,
9107          CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
9108          CODE_LABEL_NUMBER (base));
9109     }
9110
9111 #ifdef ASM_OUTPUT_ADDR_VEC_END
9112   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
9113 #endif
9114 }
9115
9116 static void
9117 sparc_output_deferred_case_vectors (void)
9118 {
9119   rtx t;
9120   int align;
9121
9122   if (sparc_addr_list == NULL_RTX
9123       && sparc_addr_diff_list == NULL_RTX)
9124     return;
9125
9126   /* Align to cache line in the function's code section.  */
9127   switch_to_section (current_function_section ());
9128
9129   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
9130   if (align > 0)
9131     ASM_OUTPUT_ALIGN (asm_out_file, align);
9132
9133   for (t = sparc_addr_list; t ; t = XEXP (t, 1))
9134     sparc_output_addr_vec (XEXP (t, 0));
9135   for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
9136     sparc_output_addr_diff_vec (XEXP (t, 0));
9137
9138   sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
9139 }
9140
9141 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
9142    unknown.  Return 1 if the high bits are zero, -1 if the register is
9143    sign extended.  */
9144 int
9145 sparc_check_64 (rtx x, rtx insn)
9146 {
9147   /* If a register is set only once it is safe to ignore insns this
9148      code does not know how to handle.  The loop will either recognize
9149      the single set and return the correct value or fail to recognize
9150      it and return 0.  */
9151   int set_once = 0;
9152   rtx y = x;
9153
9154   gcc_assert (GET_CODE (x) == REG);
9155
9156   if (GET_MODE (x) == DImode)
9157     y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
9158
9159   if (flag_expensive_optimizations
9160       && df && DF_REG_DEF_COUNT (REGNO (y)) == 1)
9161     set_once = 1;
9162
9163   if (insn == 0)
9164     {
9165       if (set_once)
9166         insn = get_last_insn_anywhere ();
9167       else
9168         return 0;
9169     }
9170
9171   while ((insn = PREV_INSN (insn)))
9172     {
9173       switch (GET_CODE (insn))
9174         {
9175         case JUMP_INSN:
9176         case NOTE:
9177           break;
9178         case CODE_LABEL:
9179         case CALL_INSN:
9180         default:
9181           if (! set_once)
9182             return 0;
9183           break;
9184         case INSN:
9185           {
9186             rtx pat = PATTERN (insn);
9187             if (GET_CODE (pat) != SET)
9188               return 0;
9189             if (rtx_equal_p (x, SET_DEST (pat)))
9190               return set_extends (insn);
9191             if (y && rtx_equal_p (y, SET_DEST (pat)))
9192               return set_extends (insn);
9193             if (reg_overlap_mentioned_p (SET_DEST (pat), y))
9194               return 0;
9195           }
9196         }
9197     }
9198   return 0;
9199 }
9200
9201 /* Output a wide shift instruction in V8+ mode.  INSN is the instruction,
9202    OPERANDS are its operands and OPCODE is the mnemonic to be used.  */
9203
9204 const char *
9205 output_v8plus_shift (rtx insn, rtx *operands, const char *opcode)
9206 {
9207   static char asm_code[60];
9208
9209   /* The scratch register is only required when the destination
9210      register is not a 64-bit global or out register.  */
9211   if (which_alternative != 2)
9212     operands[3] = operands[0];
9213
9214   /* We can only shift by constants <= 63. */
9215   if (GET_CODE (operands[2]) == CONST_INT)
9216     operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
9217
9218   if (GET_CODE (operands[1]) == CONST_INT)
9219     {
9220       output_asm_insn ("mov\t%1, %3", operands);
9221     }
9222   else
9223     {
9224       output_asm_insn ("sllx\t%H1, 32, %3", operands);
9225       if (sparc_check_64 (operands[1], insn) <= 0)
9226         output_asm_insn ("srl\t%L1, 0, %L1", operands);
9227       output_asm_insn ("or\t%L1, %3, %3", operands);
9228     }
9229
9230   strcpy (asm_code, opcode);
9231
9232   if (which_alternative != 2)
9233     return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
9234   else
9235     return
9236       strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
9237 }
9238 \f
9239 /* Output rtl to increment the profiler label LABELNO
9240    for profiling a function entry.  */
9241
9242 void
9243 sparc_profile_hook (int labelno)
9244 {
9245   char buf[32];
9246   rtx lab, fun;
9247
9248   fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
9249   if (NO_PROFILE_COUNTERS)
9250     {
9251       emit_library_call (fun, LCT_NORMAL, VOIDmode, 0);
9252     }
9253   else
9254     {
9255       ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
9256       lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
9257       emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
9258     }
9259 }
9260 \f
9261 #ifdef TARGET_SOLARIS
9262 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
9263
9264 static void
9265 sparc_solaris_elf_asm_named_section (const char *name, unsigned int flags,
9266                                      tree decl ATTRIBUTE_UNUSED)
9267 {
9268   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
9269     {
9270       solaris_elf_asm_comdat_section (name, flags, decl);
9271       return;
9272     }
9273
9274   fprintf (asm_out_file, "\t.section\t\"%s\"", name);
9275
9276   if (!(flags & SECTION_DEBUG))
9277     fputs (",#alloc", asm_out_file);
9278   if (flags & SECTION_WRITE)
9279     fputs (",#write", asm_out_file);
9280   if (flags & SECTION_TLS)
9281     fputs (",#tls", asm_out_file);
9282   if (flags & SECTION_CODE)
9283     fputs (",#execinstr", asm_out_file);
9284
9285   /* ??? Handle SECTION_BSS.  */
9286
9287   fputc ('\n', asm_out_file);
9288 }
9289 #endif /* TARGET_SOLARIS */
9290
9291 /* We do not allow indirect calls to be optimized into sibling calls.
9292
9293    We cannot use sibling calls when delayed branches are disabled
9294    because they will likely require the call delay slot to be filled.
9295
9296    Also, on SPARC 32-bit we cannot emit a sibling call when the
9297    current function returns a structure.  This is because the "unimp
9298    after call" convention would cause the callee to return to the
9299    wrong place.  The generic code already disallows cases where the
9300    function being called returns a structure.
9301
9302    It may seem strange how this last case could occur.  Usually there
9303    is code after the call which jumps to epilogue code which dumps the
9304    return value into the struct return area.  That ought to invalidate
9305    the sibling call right?  Well, in the C++ case we can end up passing
9306    the pointer to the struct return area to a constructor (which returns
9307    void) and then nothing else happens.  Such a sibling call would look
9308    valid without the added check here.
9309
9310    VxWorks PIC PLT entries require the global pointer to be initialized
9311    on entry.  We therefore can't emit sibling calls to them.  */
9312 static bool
9313 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
9314 {
9315   return (decl
9316           && flag_delayed_branch
9317           && (TARGET_ARCH64 || ! cfun->returns_struct)
9318           && !(TARGET_VXWORKS_RTP
9319                && flag_pic
9320                && !targetm.binds_local_p (decl)));
9321 }
9322 \f
9323 /* libfunc renaming.  */
9324
9325 static void
9326 sparc_init_libfuncs (void)
9327 {
9328   if (TARGET_ARCH32)
9329     {
9330       /* Use the subroutines that Sun's library provides for integer
9331          multiply and divide.  The `*' prevents an underscore from
9332          being prepended by the compiler. .umul is a little faster
9333          than .mul.  */
9334       set_optab_libfunc (smul_optab, SImode, "*.umul");
9335       set_optab_libfunc (sdiv_optab, SImode, "*.div");
9336       set_optab_libfunc (udiv_optab, SImode, "*.udiv");
9337       set_optab_libfunc (smod_optab, SImode, "*.rem");
9338       set_optab_libfunc (umod_optab, SImode, "*.urem");
9339
9340       /* TFmode arithmetic.  These names are part of the SPARC 32bit ABI.  */
9341       set_optab_libfunc (add_optab, TFmode, "_Q_add");
9342       set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
9343       set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
9344       set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
9345       set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
9346
9347       /* We can define the TFmode sqrt optab only if TARGET_FPU.  This
9348          is because with soft-float, the SFmode and DFmode sqrt
9349          instructions will be absent, and the compiler will notice and
9350          try to use the TFmode sqrt instruction for calls to the
9351          builtin function sqrt, but this fails.  */
9352       if (TARGET_FPU)
9353         set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
9354
9355       set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
9356       set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
9357       set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
9358       set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
9359       set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
9360       set_optab_libfunc (le_optab, TFmode, "_Q_fle");
9361
9362       set_conv_libfunc (sext_optab,   TFmode, SFmode, "_Q_stoq");
9363       set_conv_libfunc (sext_optab,   TFmode, DFmode, "_Q_dtoq");
9364       set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_Q_qtos");
9365       set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_Q_qtod");
9366
9367       set_conv_libfunc (sfix_optab,   SImode, TFmode, "_Q_qtoi");
9368       set_conv_libfunc (ufix_optab,   SImode, TFmode, "_Q_qtou");
9369       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
9370       set_conv_libfunc (ufloat_optab, TFmode, SImode, "_Q_utoq");
9371
9372       if (DITF_CONVERSION_LIBFUNCS)
9373         {
9374           set_conv_libfunc (sfix_optab,   DImode, TFmode, "_Q_qtoll");
9375           set_conv_libfunc (ufix_optab,   DImode, TFmode, "_Q_qtoull");
9376           set_conv_libfunc (sfloat_optab, TFmode, DImode, "_Q_lltoq");
9377           set_conv_libfunc (ufloat_optab, TFmode, DImode, "_Q_ulltoq");
9378         }
9379
9380       if (SUN_CONVERSION_LIBFUNCS)
9381         {
9382           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
9383           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
9384           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
9385           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
9386         }
9387     }
9388   if (TARGET_ARCH64)
9389     {
9390       /* In the SPARC 64bit ABI, SImode multiply and divide functions
9391          do not exist in the library.  Make sure the compiler does not
9392          emit calls to them by accident.  (It should always use the
9393          hardware instructions.)  */
9394       set_optab_libfunc (smul_optab, SImode, 0);
9395       set_optab_libfunc (sdiv_optab, SImode, 0);
9396       set_optab_libfunc (udiv_optab, SImode, 0);
9397       set_optab_libfunc (smod_optab, SImode, 0);
9398       set_optab_libfunc (umod_optab, SImode, 0);
9399
9400       if (SUN_INTEGER_MULTIPLY_64)
9401         {
9402           set_optab_libfunc (smul_optab, DImode, "__mul64");
9403           set_optab_libfunc (sdiv_optab, DImode, "__div64");
9404           set_optab_libfunc (udiv_optab, DImode, "__udiv64");
9405           set_optab_libfunc (smod_optab, DImode, "__rem64");
9406           set_optab_libfunc (umod_optab, DImode, "__urem64");
9407         }
9408
9409       if (SUN_CONVERSION_LIBFUNCS)
9410         {
9411           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
9412           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
9413           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
9414           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
9415         }
9416     }
9417 }
9418 \f
9419 static tree def_builtin(const char *name, int code, tree type)
9420 {
9421   return add_builtin_function(name, type, code, BUILT_IN_MD, NULL,
9422                               NULL_TREE);
9423 }
9424
9425 static tree def_builtin_const(const char *name, int code, tree type)
9426 {
9427   tree t = def_builtin(name, code, type);
9428
9429   if (t)
9430     TREE_READONLY (t) = 1;
9431
9432   return t;
9433 }
9434
9435 /* Implement the TARGET_INIT_BUILTINS target hook.
9436    Create builtin functions for special SPARC instructions.  */
9437
9438 static void
9439 sparc_init_builtins (void)
9440 {
9441   if (TARGET_VIS)
9442     sparc_vis_init_builtins ();
9443 }
9444
9445 /* Create builtin functions for VIS 1.0 instructions.  */
9446
9447 static void
9448 sparc_vis_init_builtins (void)
9449 {
9450   tree v4qi = build_vector_type (unsigned_intQI_type_node, 4);
9451   tree v8qi = build_vector_type (unsigned_intQI_type_node, 8);
9452   tree v4hi = build_vector_type (intHI_type_node, 4);
9453   tree v2hi = build_vector_type (intHI_type_node, 2);
9454   tree v2si = build_vector_type (intSI_type_node, 2);
9455   tree v1si = build_vector_type (intSI_type_node, 1);
9456
9457   tree v4qi_ftype_v4hi = build_function_type_list (v4qi, v4hi, 0);
9458   tree v8qi_ftype_v2si_v8qi = build_function_type_list (v8qi, v2si, v8qi, 0);
9459   tree v2hi_ftype_v2si = build_function_type_list (v2hi, v2si, 0);
9460   tree v4hi_ftype_v4qi = build_function_type_list (v4hi, v4qi, 0);
9461   tree v8qi_ftype_v4qi_v4qi = build_function_type_list (v8qi, v4qi, v4qi, 0);
9462   tree v4hi_ftype_v4qi_v4hi = build_function_type_list (v4hi, v4qi, v4hi, 0);
9463   tree v4hi_ftype_v4qi_v2hi = build_function_type_list (v4hi, v4qi, v2hi, 0);
9464   tree v2si_ftype_v4qi_v2hi = build_function_type_list (v2si, v4qi, v2hi, 0);
9465   tree v4hi_ftype_v8qi_v4hi = build_function_type_list (v4hi, v8qi, v4hi, 0);
9466   tree v4hi_ftype_v4hi_v4hi = build_function_type_list (v4hi, v4hi, v4hi, 0);
9467   tree v2si_ftype_v2si_v2si = build_function_type_list (v2si, v2si, v2si, 0);
9468   tree v8qi_ftype_v8qi_v8qi = build_function_type_list (v8qi, v8qi, v8qi, 0);
9469   tree v2hi_ftype_v2hi_v2hi = build_function_type_list (v2hi, v2hi, v2hi, 0);
9470   tree v1si_ftype_v1si_v1si = build_function_type_list (v1si, v1si, v1si, 0);
9471   tree di_ftype_v8qi_v8qi_di = build_function_type_list (intDI_type_node,
9472                                                          v8qi, v8qi,
9473                                                          intDI_type_node, 0);
9474   tree di_ftype_v8qi_v8qi = build_function_type_list (intDI_type_node,
9475                                                       v8qi, v8qi, 0);
9476   tree si_ftype_v8qi_v8qi = build_function_type_list (intSI_type_node,
9477                                                       v8qi, v8qi, 0);
9478   tree di_ftype_di_di = build_function_type_list (intDI_type_node,
9479                                                   intDI_type_node,
9480                                                   intDI_type_node, 0);
9481   tree si_ftype_si_si = build_function_type_list (intSI_type_node,
9482                                                   intSI_type_node,
9483                                                   intSI_type_node, 0);
9484   tree ptr_ftype_ptr_si = build_function_type_list (ptr_type_node,
9485                                                     ptr_type_node,
9486                                                     intSI_type_node, 0);
9487   tree ptr_ftype_ptr_di = build_function_type_list (ptr_type_node,
9488                                                     ptr_type_node,
9489                                                     intDI_type_node, 0);
9490   tree si_ftype_ptr_ptr = build_function_type_list (intSI_type_node,
9491                                                     ptr_type_node,
9492                                                     ptr_type_node, 0);
9493   tree di_ftype_ptr_ptr = build_function_type_list (intDI_type_node,
9494                                                     ptr_type_node,
9495                                                     ptr_type_node, 0);
9496   tree si_ftype_v4hi_v4hi = build_function_type_list (intSI_type_node,
9497                                                       v4hi, v4hi, 0);
9498   tree si_ftype_v2si_v2si = build_function_type_list (intSI_type_node,
9499                                                       v2si, v2si, 0);
9500   tree di_ftype_v4hi_v4hi = build_function_type_list (intDI_type_node,
9501                                                       v4hi, v4hi, 0);
9502   tree di_ftype_v2si_v2si = build_function_type_list (intDI_type_node,
9503                                                       v2si, v2si, 0);
9504   tree void_ftype_di = build_function_type_list (void_type_node,
9505                                                  intDI_type_node, 0);
9506   tree di_ftype_void = build_function_type_list (intDI_type_node,
9507                                                  void_type_node, 0);
9508   tree void_ftype_si = build_function_type_list (void_type_node,
9509                                                  intSI_type_node, 0);
9510   tree sf_ftype_sf_sf = build_function_type_list (float_type_node,
9511                                                   float_type_node,
9512                                                   float_type_node, 0);
9513   tree df_ftype_df_df = build_function_type_list (double_type_node,
9514                                                   double_type_node,
9515                                                   double_type_node, 0);
9516
9517   /* Packing and expanding vectors.  */
9518   def_builtin ("__builtin_vis_fpack16", CODE_FOR_fpack16_vis,
9519                v4qi_ftype_v4hi);
9520   def_builtin ("__builtin_vis_fpack32", CODE_FOR_fpack32_vis,
9521                v8qi_ftype_v2si_v8qi);
9522   def_builtin ("__builtin_vis_fpackfix", CODE_FOR_fpackfix_vis,
9523                v2hi_ftype_v2si);
9524   def_builtin_const ("__builtin_vis_fexpand", CODE_FOR_fexpand_vis,
9525                      v4hi_ftype_v4qi);
9526   def_builtin_const ("__builtin_vis_fpmerge", CODE_FOR_fpmerge_vis,
9527                      v8qi_ftype_v4qi_v4qi);
9528
9529   /* Multiplications.  */
9530   def_builtin_const ("__builtin_vis_fmul8x16", CODE_FOR_fmul8x16_vis,
9531                      v4hi_ftype_v4qi_v4hi);
9532   def_builtin_const ("__builtin_vis_fmul8x16au", CODE_FOR_fmul8x16au_vis,
9533                      v4hi_ftype_v4qi_v2hi);
9534   def_builtin_const ("__builtin_vis_fmul8x16al", CODE_FOR_fmul8x16al_vis,
9535                      v4hi_ftype_v4qi_v2hi);
9536   def_builtin_const ("__builtin_vis_fmul8sux16", CODE_FOR_fmul8sux16_vis,
9537                      v4hi_ftype_v8qi_v4hi);
9538   def_builtin_const ("__builtin_vis_fmul8ulx16", CODE_FOR_fmul8ulx16_vis,
9539                      v4hi_ftype_v8qi_v4hi);
9540   def_builtin_const ("__builtin_vis_fmuld8sux16", CODE_FOR_fmuld8sux16_vis,
9541                      v2si_ftype_v4qi_v2hi);
9542   def_builtin_const ("__builtin_vis_fmuld8ulx16", CODE_FOR_fmuld8ulx16_vis,
9543                      v2si_ftype_v4qi_v2hi);
9544
9545   /* Data aligning.  */
9546   def_builtin ("__builtin_vis_faligndatav4hi", CODE_FOR_faligndatav4hi_vis,
9547                v4hi_ftype_v4hi_v4hi);
9548   def_builtin ("__builtin_vis_faligndatav8qi", CODE_FOR_faligndatav8qi_vis,
9549                v8qi_ftype_v8qi_v8qi);
9550   def_builtin ("__builtin_vis_faligndatav2si", CODE_FOR_faligndatav2si_vis,
9551                v2si_ftype_v2si_v2si);
9552   def_builtin ("__builtin_vis_faligndatadi", CODE_FOR_faligndatav1di_vis,
9553                di_ftype_di_di);
9554
9555   def_builtin ("__builtin_vis_write_gsr", CODE_FOR_wrgsr_vis,
9556                void_ftype_di);
9557   def_builtin ("__builtin_vis_read_gsr", CODE_FOR_rdgsr_vis,
9558                di_ftype_void);
9559
9560   if (TARGET_ARCH64)
9561     {
9562       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrdi_vis,
9563                    ptr_ftype_ptr_di);
9564       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrldi_vis,
9565                    ptr_ftype_ptr_di);
9566     }
9567   else
9568     {
9569       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrsi_vis,
9570                    ptr_ftype_ptr_si);
9571       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrlsi_vis,
9572                    ptr_ftype_ptr_si);
9573     }
9574
9575   /* Pixel distance.  */
9576   def_builtin_const ("__builtin_vis_pdist", CODE_FOR_pdist_vis,
9577                      di_ftype_v8qi_v8qi_di);
9578
9579   /* Edge handling.  */
9580   if (TARGET_ARCH64)
9581     {
9582       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8di_vis,
9583                          di_ftype_ptr_ptr);
9584       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8ldi_vis,
9585                          di_ftype_ptr_ptr);
9586       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16di_vis,
9587                          di_ftype_ptr_ptr);
9588       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16ldi_vis,
9589                          di_ftype_ptr_ptr);
9590       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32di_vis,
9591                          di_ftype_ptr_ptr);
9592       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32ldi_vis,
9593                          di_ftype_ptr_ptr);
9594       if (TARGET_VIS2)
9595         {
9596           def_builtin_const ("__builtin_vis_edge8n", CODE_FOR_edge8ndi_vis,
9597                              di_ftype_ptr_ptr);
9598           def_builtin_const ("__builtin_vis_edge8ln", CODE_FOR_edge8lndi_vis,
9599                              di_ftype_ptr_ptr);
9600           def_builtin_const ("__builtin_vis_edge16n", CODE_FOR_edge16ndi_vis,
9601                              di_ftype_ptr_ptr);
9602           def_builtin_const ("__builtin_vis_edge16ln", CODE_FOR_edge16lndi_vis,
9603                              di_ftype_ptr_ptr);
9604           def_builtin_const ("__builtin_vis_edge32n", CODE_FOR_edge32ndi_vis,
9605                              di_ftype_ptr_ptr);
9606           def_builtin_const ("__builtin_vis_edge32ln", CODE_FOR_edge32lndi_vis,
9607                              di_ftype_ptr_ptr);
9608         }
9609     }
9610   else
9611     {
9612       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8si_vis,
9613                          si_ftype_ptr_ptr);
9614       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8lsi_vis,
9615                          si_ftype_ptr_ptr);
9616       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16si_vis,
9617                          si_ftype_ptr_ptr);
9618       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16lsi_vis,
9619                          si_ftype_ptr_ptr);
9620       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32si_vis,
9621                          si_ftype_ptr_ptr);
9622       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32lsi_vis,
9623                          si_ftype_ptr_ptr);
9624       if (TARGET_VIS2)
9625         {
9626           def_builtin_const ("__builtin_vis_edge8n", CODE_FOR_edge8nsi_vis,
9627                              si_ftype_ptr_ptr);
9628           def_builtin_const ("__builtin_vis_edge8ln", CODE_FOR_edge8lnsi_vis,
9629                              si_ftype_ptr_ptr);
9630           def_builtin_const ("__builtin_vis_edge16n", CODE_FOR_edge16nsi_vis,
9631                              si_ftype_ptr_ptr);
9632           def_builtin_const ("__builtin_vis_edge16ln", CODE_FOR_edge16lnsi_vis,
9633                              si_ftype_ptr_ptr);
9634           def_builtin_const ("__builtin_vis_edge32n", CODE_FOR_edge32nsi_vis,
9635                              si_ftype_ptr_ptr);
9636           def_builtin_const ("__builtin_vis_edge32ln", CODE_FOR_edge32lnsi_vis,
9637                              si_ftype_ptr_ptr);
9638         }
9639     }
9640
9641   /* Pixel compare.  */
9642   if (TARGET_ARCH64)
9643     {
9644       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16di_vis,
9645                          di_ftype_v4hi_v4hi);
9646       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32di_vis,
9647                          di_ftype_v2si_v2si);
9648       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16di_vis,
9649                          di_ftype_v4hi_v4hi);
9650       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32di_vis,
9651                          di_ftype_v2si_v2si);
9652       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16di_vis,
9653                          di_ftype_v4hi_v4hi);
9654       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32di_vis,
9655                          di_ftype_v2si_v2si);
9656       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16di_vis,
9657                          di_ftype_v4hi_v4hi);
9658       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32di_vis,
9659                          di_ftype_v2si_v2si);
9660     }
9661   else
9662     {
9663       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16si_vis,
9664                          si_ftype_v4hi_v4hi);
9665       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32si_vis,
9666                          si_ftype_v2si_v2si);
9667       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16si_vis,
9668                          si_ftype_v4hi_v4hi);
9669       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32si_vis,
9670                          si_ftype_v2si_v2si);
9671       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16si_vis,
9672                          si_ftype_v4hi_v4hi);
9673       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32si_vis,
9674                          si_ftype_v2si_v2si);
9675       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16si_vis,
9676                          si_ftype_v4hi_v4hi);
9677       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32si_vis,
9678                          si_ftype_v2si_v2si);
9679     }
9680
9681   /* Addition and subtraction.  */
9682   def_builtin_const ("__builtin_vis_fpadd16", CODE_FOR_addv4hi3,
9683                      v4hi_ftype_v4hi_v4hi);
9684   def_builtin_const ("__builtin_vis_fpadd16s", CODE_FOR_addv2hi3,
9685                      v2hi_ftype_v2hi_v2hi);
9686   def_builtin_const ("__builtin_vis_fpadd32", CODE_FOR_addv2si3,
9687                      v2si_ftype_v2si_v2si);
9688   def_builtin_const ("__builtin_vis_fpadd32s", CODE_FOR_addv1si3,
9689                      v1si_ftype_v1si_v1si);
9690   def_builtin_const ("__builtin_vis_fpsub16", CODE_FOR_subv4hi3,
9691                      v4hi_ftype_v4hi_v4hi);
9692   def_builtin_const ("__builtin_vis_fpsub16s", CODE_FOR_subv2hi3,
9693                      v2hi_ftype_v2hi_v2hi);
9694   def_builtin_const ("__builtin_vis_fpsub32", CODE_FOR_subv2si3,
9695                      v2si_ftype_v2si_v2si);
9696   def_builtin_const ("__builtin_vis_fpsub32s", CODE_FOR_subv1si3,
9697                      v1si_ftype_v1si_v1si);
9698
9699   /* Three-dimensional array addressing.  */
9700   if (TARGET_ARCH64)
9701     {
9702       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8di_vis,
9703                          di_ftype_di_di);
9704       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16di_vis,
9705                          di_ftype_di_di);
9706       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32di_vis,
9707                          di_ftype_di_di);
9708     }
9709   else
9710     {
9711       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8si_vis,
9712                          si_ftype_si_si);
9713       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16si_vis,
9714                          si_ftype_si_si);
9715       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32si_vis,
9716                          si_ftype_si_si);
9717   }
9718
9719   if (TARGET_VIS2)
9720     {
9721       /* Byte mask and shuffle */
9722       if (TARGET_ARCH64)
9723         def_builtin ("__builtin_vis_bmask", CODE_FOR_bmaskdi_vis,
9724                      di_ftype_di_di);
9725       else
9726         def_builtin ("__builtin_vis_bmask", CODE_FOR_bmasksi_vis,
9727                      si_ftype_si_si);
9728       def_builtin ("__builtin_vis_bshufflev4hi", CODE_FOR_bshufflev4hi_vis,
9729                    v4hi_ftype_v4hi_v4hi);
9730       def_builtin ("__builtin_vis_bshufflev8qi", CODE_FOR_bshufflev8qi_vis,
9731                    v8qi_ftype_v8qi_v8qi);
9732       def_builtin ("__builtin_vis_bshufflev2si", CODE_FOR_bshufflev2si_vis,
9733                    v2si_ftype_v2si_v2si);
9734       def_builtin ("__builtin_vis_bshuffledi", CODE_FOR_bshufflev1di_vis,
9735                    di_ftype_di_di);
9736     }
9737
9738   if (TARGET_VIS3)
9739     {
9740       if (TARGET_ARCH64)
9741         {
9742           def_builtin ("__builtin_vis_cmask8", CODE_FOR_cmask8di_vis,
9743                        void_ftype_di);
9744           def_builtin ("__builtin_vis_cmask16", CODE_FOR_cmask16di_vis,
9745                        void_ftype_di);
9746           def_builtin ("__builtin_vis_cmask32", CODE_FOR_cmask32di_vis,
9747                        void_ftype_di);
9748         }
9749       else
9750         {
9751           def_builtin ("__builtin_vis_cmask8", CODE_FOR_cmask8si_vis,
9752                        void_ftype_si);
9753           def_builtin ("__builtin_vis_cmask16", CODE_FOR_cmask16si_vis,
9754                        void_ftype_si);
9755           def_builtin ("__builtin_vis_cmask32", CODE_FOR_cmask32si_vis,
9756                        void_ftype_si);
9757         }
9758
9759       def_builtin_const ("__builtin_vis_fchksm16", CODE_FOR_fchksm16_vis,
9760                          v4hi_ftype_v4hi_v4hi);
9761
9762       def_builtin_const ("__builtin_vis_fsll16", CODE_FOR_vashlv4hi3,
9763                          v4hi_ftype_v4hi_v4hi);
9764       def_builtin_const ("__builtin_vis_fslas16", CODE_FOR_vssashlv4hi3,
9765                          v4hi_ftype_v4hi_v4hi);
9766       def_builtin_const ("__builtin_vis_fsrl16", CODE_FOR_vlshrv4hi3,
9767                          v4hi_ftype_v4hi_v4hi);
9768       def_builtin_const ("__builtin_vis_fsra16", CODE_FOR_vashrv4hi3,
9769                          v4hi_ftype_v4hi_v4hi);
9770       def_builtin_const ("__builtin_vis_fsll32", CODE_FOR_vashlv2si3,
9771                          v2si_ftype_v2si_v2si);
9772       def_builtin_const ("__builtin_vis_fslas32", CODE_FOR_vssashlv2si3,
9773                          v2si_ftype_v2si_v2si);
9774       def_builtin_const ("__builtin_vis_fsrl32", CODE_FOR_vlshrv2si3,
9775                          v2si_ftype_v2si_v2si);
9776       def_builtin_const ("__builtin_vis_fsra32", CODE_FOR_vashrv2si3,
9777                          v2si_ftype_v2si_v2si);
9778
9779       if (TARGET_ARCH64)
9780         def_builtin_const ("__builtin_vis_pdistn", CODE_FOR_pdistndi_vis,
9781                            di_ftype_v8qi_v8qi);
9782       else
9783         def_builtin_const ("__builtin_vis_pdistn", CODE_FOR_pdistnsi_vis,
9784                            si_ftype_v8qi_v8qi);
9785
9786       def_builtin_const ("__builtin_vis_fmean16", CODE_FOR_fmean16_vis,
9787                          v4hi_ftype_v4hi_v4hi);
9788       def_builtin_const ("__builtin_vis_fpadd64", CODE_FOR_fpadd64_vis,
9789                          di_ftype_di_di);
9790       def_builtin_const ("__builtin_vis_fpsub64", CODE_FOR_fpsub64_vis,
9791                          di_ftype_di_di);
9792
9793       def_builtin_const ("__builtin_vis_fpadds16", CODE_FOR_ssaddv4hi3,
9794                          v4hi_ftype_v4hi_v4hi);
9795       def_builtin_const ("__builtin_vis_fpadds16s", CODE_FOR_ssaddv2hi3,
9796                          v2hi_ftype_v2hi_v2hi);
9797       def_builtin_const ("__builtin_vis_fpsubs16", CODE_FOR_sssubv4hi3,
9798                          v4hi_ftype_v4hi_v4hi);
9799       def_builtin_const ("__builtin_vis_fpsubs16s", CODE_FOR_sssubv2hi3,
9800                          v2hi_ftype_v2hi_v2hi);
9801       def_builtin_const ("__builtin_vis_fpadds32", CODE_FOR_ssaddv2si3,
9802                          v2si_ftype_v2si_v2si);
9803       def_builtin_const ("__builtin_vis_fpadds32s", CODE_FOR_ssaddv1si3,
9804                          v1si_ftype_v1si_v1si);
9805       def_builtin_const ("__builtin_vis_fpsubs32", CODE_FOR_sssubv2si3,
9806                          v2si_ftype_v2si_v2si);
9807       def_builtin_const ("__builtin_vis_fpsubs32s", CODE_FOR_sssubv1si3,
9808                          v1si_ftype_v1si_v1si);
9809
9810       if (TARGET_ARCH64)
9811         {
9812           def_builtin_const ("__builtin_vis_fucmple8", CODE_FOR_fucmple8di_vis,
9813                              di_ftype_v8qi_v8qi);
9814           def_builtin_const ("__builtin_vis_fucmpne8", CODE_FOR_fucmpne8di_vis,
9815                              di_ftype_v8qi_v8qi);
9816           def_builtin_const ("__builtin_vis_fucmpgt8", CODE_FOR_fucmpgt8di_vis,
9817                              di_ftype_v8qi_v8qi);
9818           def_builtin_const ("__builtin_vis_fucmpeq8", CODE_FOR_fucmpeq8di_vis,
9819                              di_ftype_v8qi_v8qi);
9820         }
9821       else
9822         {
9823           def_builtin_const ("__builtin_vis_fucmple8", CODE_FOR_fucmple8si_vis,
9824                              si_ftype_v8qi_v8qi);
9825           def_builtin_const ("__builtin_vis_fucmpne8", CODE_FOR_fucmpne8si_vis,
9826                              si_ftype_v8qi_v8qi);
9827           def_builtin_const ("__builtin_vis_fucmpgt8", CODE_FOR_fucmpgt8si_vis,
9828                              si_ftype_v8qi_v8qi);
9829           def_builtin_const ("__builtin_vis_fucmpeq8", CODE_FOR_fucmpeq8si_vis,
9830                              si_ftype_v8qi_v8qi);
9831         }
9832
9833       def_builtin_const ("__builtin_vis_fhadds", CODE_FOR_fhaddsf_vis,
9834                          sf_ftype_sf_sf);
9835       def_builtin_const ("__builtin_vis_fhaddd", CODE_FOR_fhadddf_vis,
9836                          df_ftype_df_df);
9837       def_builtin_const ("__builtin_vis_fhsubs", CODE_FOR_fhsubsf_vis,
9838                          sf_ftype_sf_sf);
9839       def_builtin_const ("__builtin_vis_fhsubd", CODE_FOR_fhsubdf_vis,
9840                          df_ftype_df_df);
9841       def_builtin_const ("__builtin_vis_fnhadds", CODE_FOR_fnhaddsf_vis,
9842                          sf_ftype_sf_sf);
9843       def_builtin_const ("__builtin_vis_fnhaddd", CODE_FOR_fnhadddf_vis,
9844                          df_ftype_df_df);
9845
9846       def_builtin_const ("__builtin_vis_umulxhi", CODE_FOR_umulxhi_vis,
9847                          di_ftype_di_di);
9848       def_builtin_const ("__builtin_vis_xmulx", CODE_FOR_xmulx_vis,
9849                          di_ftype_di_di);
9850       def_builtin_const ("__builtin_vis_xmulxhi", CODE_FOR_xmulxhi_vis,
9851                          di_ftype_di_di);
9852     }
9853 }
9854
9855 /* Handle TARGET_EXPAND_BUILTIN target hook.
9856    Expand builtin functions for sparc intrinsics.  */
9857
9858 static rtx
9859 sparc_expand_builtin (tree exp, rtx target,
9860                       rtx subtarget ATTRIBUTE_UNUSED,
9861                       enum machine_mode tmode ATTRIBUTE_UNUSED,
9862                       int ignore ATTRIBUTE_UNUSED)
9863 {
9864   tree arg;
9865   call_expr_arg_iterator iter;
9866   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
9867   unsigned int icode = DECL_FUNCTION_CODE (fndecl);
9868   rtx pat, op[4];
9869   int arg_count = 0;
9870   bool nonvoid;
9871
9872   nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
9873
9874   if (nonvoid)
9875     {
9876       enum machine_mode tmode = insn_data[icode].operand[0].mode;
9877       if (!target
9878           || GET_MODE (target) != tmode
9879           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
9880         op[0] = gen_reg_rtx (tmode);
9881       else
9882         op[0] = target;
9883     }
9884   FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
9885     {
9886       const struct insn_operand_data *insn_op;
9887       int idx;
9888
9889       if (arg == error_mark_node)
9890         return NULL_RTX;
9891
9892       arg_count++;
9893       idx = arg_count - !nonvoid;
9894       insn_op = &insn_data[icode].operand[idx];
9895       op[arg_count] = expand_normal (arg);
9896
9897       if (insn_op->mode == V1DImode
9898           && GET_MODE (op[arg_count]) == DImode)
9899         op[arg_count] = gen_lowpart (V1DImode, op[arg_count]);
9900       else if (insn_op->mode == V1SImode
9901           && GET_MODE (op[arg_count]) == SImode)
9902         op[arg_count] = gen_lowpart (V1SImode, op[arg_count]);
9903
9904       if (! (*insn_data[icode].operand[idx].predicate) (op[arg_count],
9905                                                         insn_op->mode))
9906         op[arg_count] = copy_to_mode_reg (insn_op->mode, op[arg_count]);
9907     }
9908
9909   switch (arg_count)
9910     {
9911     case 0:
9912       pat = GEN_FCN (icode) (op[0]);
9913       break;
9914     case 1:
9915       if (nonvoid)
9916         pat = GEN_FCN (icode) (op[0], op[1]);
9917       else
9918         pat = GEN_FCN (icode) (op[1]);
9919       break;
9920     case 2:
9921       pat = GEN_FCN (icode) (op[0], op[1], op[2]);
9922       break;
9923     case 3:
9924       pat = GEN_FCN (icode) (op[0], op[1], op[2], op[3]);
9925       break;
9926     default:
9927       gcc_unreachable ();
9928     }
9929
9930   if (!pat)
9931     return NULL_RTX;
9932
9933   emit_insn (pat);
9934
9935   if (nonvoid)
9936     return op[0];
9937   else
9938     return const0_rtx;
9939 }
9940
9941 static int
9942 sparc_vis_mul8x16 (int e8, int e16)
9943 {
9944   return (e8 * e16 + 128) / 256;
9945 }
9946
9947 /* Multiply the VECTOR_CSTs CST0 and CST1 as specified by FNCODE and put
9948    the result into the array N_ELTS, whose elements are of INNER_TYPE.  */
9949
9950 static void
9951 sparc_handle_vis_mul8x16 (tree *n_elts, int fncode, tree inner_type,
9952                           tree cst0, tree cst1)
9953 {
9954   unsigned i, num = VECTOR_CST_NELTS (cst0);
9955   int scale;
9956
9957   switch (fncode)
9958     {
9959     case CODE_FOR_fmul8x16_vis:
9960       for (i = 0; i < num; ++i)
9961         {
9962           int val
9963             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
9964                                  TREE_INT_CST_LOW (VECTOR_CST_ELT (cst1, i)));
9965           n_elts[i] = build_int_cst (inner_type, val);
9966         }
9967       break;
9968
9969     case CODE_FOR_fmul8x16au_vis:
9970       scale = TREE_INT_CST_LOW (VECTOR_CST_ELT (cst1, 0));
9971
9972       for (i = 0; i < num; ++i)
9973         {
9974           int val
9975             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
9976                                  scale);
9977           n_elts[i] = build_int_cst (inner_type, val);
9978         }
9979       break;
9980
9981     case CODE_FOR_fmul8x16al_vis:
9982       scale = TREE_INT_CST_LOW (VECTOR_CST_ELT (cst1, 1));
9983
9984       for (i = 0; i < num; ++i)
9985         {
9986           int val
9987             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (VECTOR_CST_ELT (cst0, i)),
9988                                  scale);
9989           n_elts[i] = build_int_cst (inner_type, val);
9990         }
9991       break;
9992
9993     default:
9994       gcc_unreachable ();
9995     }
9996 }
9997
9998 /* Handle TARGET_FOLD_BUILTIN target hook.
9999    Fold builtin functions for SPARC intrinsics.  If IGNORE is true the
10000    result of the function call is ignored.  NULL_TREE is returned if the
10001    function could not be folded.  */
10002
10003 static tree
10004 sparc_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED,
10005                     tree *args, bool ignore)
10006 {
10007   tree arg0, arg1, arg2;
10008   tree rtype = TREE_TYPE (TREE_TYPE (fndecl));
10009   enum insn_code icode = (enum insn_code) DECL_FUNCTION_CODE (fndecl);
10010
10011   if (ignore)
10012     {
10013       /* Note that a switch statement instead of the sequence of tests would
10014          be incorrect as many of the CODE_FOR values could be CODE_FOR_nothing
10015          and that would yield multiple alternatives with identical values.  */
10016       if (icode == CODE_FOR_alignaddrsi_vis
10017           || icode == CODE_FOR_alignaddrdi_vis
10018           || icode == CODE_FOR_wrgsr_vis
10019           || icode == CODE_FOR_bmasksi_vis
10020           || icode == CODE_FOR_bmaskdi_vis
10021           || icode == CODE_FOR_cmask8si_vis
10022           || icode == CODE_FOR_cmask8di_vis
10023           || icode == CODE_FOR_cmask16si_vis
10024           || icode == CODE_FOR_cmask16di_vis
10025           || icode == CODE_FOR_cmask32si_vis
10026           || icode == CODE_FOR_cmask32di_vis)
10027         ;
10028       else
10029         return build_zero_cst (rtype);
10030     }
10031
10032   switch (icode)
10033     {
10034     case CODE_FOR_fexpand_vis:
10035       arg0 = args[0];
10036       STRIP_NOPS (arg0);
10037
10038       if (TREE_CODE (arg0) == VECTOR_CST)
10039         {
10040           tree inner_type = TREE_TYPE (rtype);
10041           tree *n_elts;
10042           unsigned i;
10043
10044           n_elts = XALLOCAVEC (tree, VECTOR_CST_NELTS (arg0));
10045           for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
10046             n_elts[i] = build_int_cst (inner_type,
10047                                        TREE_INT_CST_LOW
10048                                          (VECTOR_CST_ELT (arg0, i)) << 4);
10049           return build_vector (rtype, n_elts);
10050         }
10051       break;
10052
10053     case CODE_FOR_fmul8x16_vis:
10054     case CODE_FOR_fmul8x16au_vis:
10055     case CODE_FOR_fmul8x16al_vis:
10056       arg0 = args[0];
10057       arg1 = args[1];
10058       STRIP_NOPS (arg0);
10059       STRIP_NOPS (arg1);
10060
10061       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
10062         {
10063           tree inner_type = TREE_TYPE (rtype);
10064           tree *n_elts = XALLOCAVEC (tree, VECTOR_CST_NELTS (arg0));
10065           sparc_handle_vis_mul8x16 (n_elts, icode, inner_type, arg0, arg1);
10066           return build_vector (rtype, n_elts);
10067         }
10068       break;
10069
10070     case CODE_FOR_fpmerge_vis:
10071       arg0 = args[0];
10072       arg1 = args[1];
10073       STRIP_NOPS (arg0);
10074       STRIP_NOPS (arg1);
10075
10076       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
10077         {
10078           tree *n_elts = XALLOCAVEC (tree, 2 * VECTOR_CST_NELTS (arg0));
10079           unsigned i;
10080           for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
10081             {
10082               n_elts[2*i] = VECTOR_CST_ELT (arg0, i);
10083               n_elts[2*i+1] = VECTOR_CST_ELT (arg1, i);
10084             }
10085
10086           return build_vector (rtype, n_elts);
10087         }
10088       break;
10089
10090     case CODE_FOR_pdist_vis:
10091       arg0 = args[0];
10092       arg1 = args[1];
10093       arg2 = args[2];
10094       STRIP_NOPS (arg0);
10095       STRIP_NOPS (arg1);
10096       STRIP_NOPS (arg2);
10097
10098       if (TREE_CODE (arg0) == VECTOR_CST
10099           && TREE_CODE (arg1) == VECTOR_CST
10100           && TREE_CODE (arg2) == INTEGER_CST)
10101         {
10102           int overflow = 0;
10103           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg2);
10104           HOST_WIDE_INT high = TREE_INT_CST_HIGH (arg2);
10105           unsigned i;
10106
10107           for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
10108             {
10109               unsigned HOST_WIDE_INT
10110                 low0 = TREE_INT_CST_LOW (VECTOR_CST_ELT (arg0, i)),
10111                 low1 = TREE_INT_CST_LOW (VECTOR_CST_ELT (arg1, i));
10112               HOST_WIDE_INT
10113                 high0 = TREE_INT_CST_HIGH (VECTOR_CST_ELT (arg0, i));
10114               HOST_WIDE_INT
10115                 high1 = TREE_INT_CST_HIGH (VECTOR_CST_ELT (arg1, i));
10116
10117               unsigned HOST_WIDE_INT l;
10118               HOST_WIDE_INT h;
10119
10120               overflow |= neg_double (low1, high1, &l, &h);
10121               overflow |= add_double (low0, high0, l, h, &l, &h);
10122               if (h < 0)
10123                 overflow |= neg_double (l, h, &l, &h);
10124
10125               overflow |= add_double (low, high, l, h, &low, &high);
10126             }
10127
10128           gcc_assert (overflow == 0);
10129
10130           return build_int_cst_wide (rtype, low, high);
10131         }
10132
10133     default:
10134       break;
10135     }
10136
10137   return NULL_TREE;
10138 }
10139 \f
10140 /* ??? This duplicates information provided to the compiler by the
10141    ??? scheduler description.  Some day, teach genautomata to output
10142    ??? the latencies and then CSE will just use that.  */
10143
10144 static bool
10145 sparc_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
10146                  int *total, bool speed ATTRIBUTE_UNUSED)
10147 {
10148   enum machine_mode mode = GET_MODE (x);
10149   bool float_mode_p = FLOAT_MODE_P (mode);
10150
10151   switch (code)
10152     {
10153     case CONST_INT:
10154       if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
10155         {
10156           *total = 0;
10157           return true;
10158         }
10159       /* FALLTHRU */
10160
10161     case HIGH:
10162       *total = 2;
10163       return true;
10164
10165     case CONST:
10166     case LABEL_REF:
10167     case SYMBOL_REF:
10168       *total = 4;
10169       return true;
10170
10171     case CONST_DOUBLE:
10172       if (GET_MODE (x) == VOIDmode
10173           && ((CONST_DOUBLE_HIGH (x) == 0
10174                && CONST_DOUBLE_LOW (x) < 0x1000)
10175               || (CONST_DOUBLE_HIGH (x) == -1
10176                   && CONST_DOUBLE_LOW (x) < 0
10177                   && CONST_DOUBLE_LOW (x) >= -0x1000)))
10178         *total = 0;
10179       else
10180         *total = 8;
10181       return true;
10182
10183     case MEM:
10184       /* If outer-code was a sign or zero extension, a cost
10185          of COSTS_N_INSNS (1) was already added in.  This is
10186          why we are subtracting it back out.  */
10187       if (outer_code == ZERO_EXTEND)
10188         {
10189           *total = sparc_costs->int_zload - COSTS_N_INSNS (1);
10190         }
10191       else if (outer_code == SIGN_EXTEND)
10192         {
10193           *total = sparc_costs->int_sload - COSTS_N_INSNS (1);
10194         }
10195       else if (float_mode_p)
10196         {
10197           *total = sparc_costs->float_load;
10198         }
10199       else
10200         {
10201           *total = sparc_costs->int_load;
10202         }
10203
10204       return true;
10205
10206     case PLUS:
10207     case MINUS:
10208       if (float_mode_p)
10209         *total = sparc_costs->float_plusminus;
10210       else
10211         *total = COSTS_N_INSNS (1);
10212       return false;
10213
10214     case FMA:
10215       {
10216         rtx sub;
10217
10218         gcc_assert (float_mode_p);
10219         *total = sparc_costs->float_mul;
10220
10221         sub = XEXP (x, 0);
10222         if (GET_CODE (sub) == NEG)
10223           sub = XEXP (sub, 0);
10224         *total += rtx_cost (sub, FMA, 0, speed);
10225
10226         sub = XEXP (x, 2);
10227         if (GET_CODE (sub) == NEG)
10228           sub = XEXP (sub, 0);
10229         *total += rtx_cost (sub, FMA, 2, speed);
10230         return true;
10231       }
10232
10233     case MULT:
10234       if (float_mode_p)
10235         *total = sparc_costs->float_mul;
10236       else if (! TARGET_HARD_MUL)
10237         *total = COSTS_N_INSNS (25);
10238       else
10239         {
10240           int bit_cost;
10241
10242           bit_cost = 0;
10243           if (sparc_costs->int_mul_bit_factor)
10244             {
10245               int nbits;
10246
10247               if (GET_CODE (XEXP (x, 1)) == CONST_INT)
10248                 {
10249                   unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
10250                   for (nbits = 0; value != 0; value &= value - 1)
10251                     nbits++;
10252                 }
10253               else if (GET_CODE (XEXP (x, 1)) == CONST_DOUBLE
10254                        && GET_MODE (XEXP (x, 1)) == VOIDmode)
10255                 {
10256                   rtx x1 = XEXP (x, 1);
10257                   unsigned HOST_WIDE_INT value1 = CONST_DOUBLE_LOW (x1);
10258                   unsigned HOST_WIDE_INT value2 = CONST_DOUBLE_HIGH (x1);
10259
10260                   for (nbits = 0; value1 != 0; value1 &= value1 - 1)
10261                     nbits++;
10262                   for (; value2 != 0; value2 &= value2 - 1)
10263                     nbits++;
10264                 }
10265               else
10266                 nbits = 7;
10267
10268               if (nbits < 3)
10269                 nbits = 3;
10270               bit_cost = (nbits - 3) / sparc_costs->int_mul_bit_factor;
10271               bit_cost = COSTS_N_INSNS (bit_cost);
10272             }
10273
10274           if (mode == DImode)
10275             *total = sparc_costs->int_mulX + bit_cost;
10276           else
10277             *total = sparc_costs->int_mul + bit_cost;
10278         }
10279       return false;
10280
10281     case ASHIFT:
10282     case ASHIFTRT:
10283     case LSHIFTRT:
10284       *total = COSTS_N_INSNS (1) + sparc_costs->shift_penalty;
10285       return false;
10286
10287     case DIV:
10288     case UDIV:
10289     case MOD:
10290     case UMOD:
10291       if (float_mode_p)
10292         {
10293           if (mode == DFmode)
10294             *total = sparc_costs->float_div_df;
10295           else
10296             *total = sparc_costs->float_div_sf;
10297         }
10298       else
10299         {
10300           if (mode == DImode)
10301             *total = sparc_costs->int_divX;
10302           else
10303             *total = sparc_costs->int_div;
10304         }
10305       return false;
10306
10307     case NEG:
10308       if (! float_mode_p)
10309         {
10310           *total = COSTS_N_INSNS (1);
10311           return false;
10312         }
10313       /* FALLTHRU */
10314
10315     case ABS:
10316     case FLOAT:
10317     case UNSIGNED_FLOAT:
10318     case FIX:
10319     case UNSIGNED_FIX:
10320     case FLOAT_EXTEND:
10321     case FLOAT_TRUNCATE:
10322       *total = sparc_costs->float_move;
10323       return false;
10324
10325     case SQRT:
10326       if (mode == DFmode)
10327         *total = sparc_costs->float_sqrt_df;
10328       else
10329         *total = sparc_costs->float_sqrt_sf;
10330       return false;
10331
10332     case COMPARE:
10333       if (float_mode_p)
10334         *total = sparc_costs->float_cmp;
10335       else
10336         *total = COSTS_N_INSNS (1);
10337       return false;
10338
10339     case IF_THEN_ELSE:
10340       if (float_mode_p)
10341         *total = sparc_costs->float_cmove;
10342       else
10343         *total = sparc_costs->int_cmove;
10344       return false;
10345
10346     case IOR:
10347       /* Handle the NAND vector patterns.  */
10348       if (sparc_vector_mode_supported_p (GET_MODE (x))
10349           && GET_CODE (XEXP (x, 0)) == NOT
10350           && GET_CODE (XEXP (x, 1)) == NOT)
10351         {
10352           *total = COSTS_N_INSNS (1);
10353           return true;
10354         }
10355       else
10356         return false;
10357
10358     default:
10359       return false;
10360     }
10361 }
10362
10363 /* Return true if CLASS is either GENERAL_REGS or I64_REGS.  */
10364
10365 static inline bool
10366 general_or_i64_p (reg_class_t rclass)
10367 {
10368   return (rclass == GENERAL_REGS || rclass == I64_REGS);
10369 }
10370
10371 /* Implement TARGET_REGISTER_MOVE_COST.  */
10372
10373 static int
10374 sparc_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
10375                           reg_class_t from, reg_class_t to)
10376 {
10377   bool need_memory = false;
10378
10379   if (from == FPCC_REGS || to == FPCC_REGS)
10380     need_memory = true;
10381   else if ((FP_REG_CLASS_P (from) && general_or_i64_p (to))
10382            || (general_or_i64_p (from) && FP_REG_CLASS_P (to)))
10383     {
10384       if (TARGET_VIS3)
10385         {
10386           int size = GET_MODE_SIZE (mode);
10387           if (size == 8 || size == 4)
10388             {
10389               if (! TARGET_ARCH32 || size == 4)
10390                 return 4;
10391               else
10392                 return 6;
10393             }
10394         }
10395       need_memory = true;
10396     }
10397
10398   if (need_memory)
10399     {
10400       if (sparc_cpu == PROCESSOR_ULTRASPARC
10401           || sparc_cpu == PROCESSOR_ULTRASPARC3
10402           || sparc_cpu == PROCESSOR_NIAGARA
10403           || sparc_cpu == PROCESSOR_NIAGARA2
10404           || sparc_cpu == PROCESSOR_NIAGARA3
10405           || sparc_cpu == PROCESSOR_NIAGARA4)
10406         return 12;
10407
10408       return 6;
10409     }
10410
10411   return 2;
10412 }
10413
10414 /* Emit the sequence of insns SEQ while preserving the registers REG and REG2.
10415    This is achieved by means of a manual dynamic stack space allocation in
10416    the current frame.  We make the assumption that SEQ doesn't contain any
10417    function calls, with the possible exception of calls to the GOT helper.  */
10418
10419 static void
10420 emit_and_preserve (rtx seq, rtx reg, rtx reg2)
10421 {
10422   /* We must preserve the lowest 16 words for the register save area.  */
10423   HOST_WIDE_INT offset = 16*UNITS_PER_WORD;
10424   /* We really need only 2 words of fresh stack space.  */
10425   HOST_WIDE_INT size = SPARC_STACK_ALIGN (offset + 2*UNITS_PER_WORD);
10426
10427   rtx slot
10428     = gen_rtx_MEM (word_mode, plus_constant (Pmode, stack_pointer_rtx,
10429                                              SPARC_STACK_BIAS + offset));
10430
10431   emit_insn (gen_stack_pointer_dec (GEN_INT (size)));
10432   emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
10433   if (reg2)
10434     emit_insn (gen_rtx_SET (VOIDmode,
10435                             adjust_address (slot, word_mode, UNITS_PER_WORD),
10436                             reg2));
10437   emit_insn (seq);
10438   if (reg2)
10439     emit_insn (gen_rtx_SET (VOIDmode,
10440                             reg2,
10441                             adjust_address (slot, word_mode, UNITS_PER_WORD)));
10442   emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
10443   emit_insn (gen_stack_pointer_inc (GEN_INT (size)));
10444 }
10445
10446 /* Output the assembler code for a thunk function.  THUNK_DECL is the
10447    declaration for the thunk function itself, FUNCTION is the decl for
10448    the target function.  DELTA is an immediate constant offset to be
10449    added to THIS.  If VCALL_OFFSET is nonzero, the word at address
10450    (*THIS + VCALL_OFFSET) should be additionally added to THIS.  */
10451
10452 static void
10453 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
10454                        HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
10455                        tree function)
10456 {
10457   rtx this_rtx, insn, funexp;
10458   unsigned int int_arg_first;
10459
10460   reload_completed = 1;
10461   epilogue_completed = 1;
10462
10463   emit_note (NOTE_INSN_PROLOGUE_END);
10464
10465   if (TARGET_FLAT)
10466     {
10467       sparc_leaf_function_p = 1;
10468
10469       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
10470     }
10471   else if (flag_delayed_branch)
10472     {
10473       /* We will emit a regular sibcall below, so we need to instruct
10474          output_sibcall that we are in a leaf function.  */
10475       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 1;
10476
10477       /* This will cause final.c to invoke leaf_renumber_regs so we
10478          must behave as if we were in a not-yet-leafified function.  */
10479       int_arg_first = SPARC_INCOMING_INT_ARG_FIRST;
10480     }
10481   else
10482     {
10483       /* We will emit the sibcall manually below, so we will need to
10484          manually spill non-leaf registers.  */
10485       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 0;
10486
10487       /* We really are in a leaf function.  */
10488       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
10489     }
10490
10491   /* Find the "this" pointer.  Normally in %o0, but in ARCH64 if the function
10492      returns a structure, the structure return pointer is there instead.  */
10493   if (TARGET_ARCH64
10494       && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
10495     this_rtx = gen_rtx_REG (Pmode, int_arg_first + 1);
10496   else
10497     this_rtx = gen_rtx_REG (Pmode, int_arg_first);
10498
10499   /* Add DELTA.  When possible use a plain add, otherwise load it into
10500      a register first.  */
10501   if (delta)
10502     {
10503       rtx delta_rtx = GEN_INT (delta);
10504
10505       if (! SPARC_SIMM13_P (delta))
10506         {
10507           rtx scratch = gen_rtx_REG (Pmode, 1);
10508           emit_move_insn (scratch, delta_rtx);
10509           delta_rtx = scratch;
10510         }
10511
10512       /* THIS_RTX += DELTA.  */
10513       emit_insn (gen_add2_insn (this_rtx, delta_rtx));
10514     }
10515
10516   /* Add the word at address (*THIS_RTX + VCALL_OFFSET).  */
10517   if (vcall_offset)
10518     {
10519       rtx vcall_offset_rtx = GEN_INT (vcall_offset);
10520       rtx scratch = gen_rtx_REG (Pmode, 1);
10521
10522       gcc_assert (vcall_offset < 0);
10523
10524       /* SCRATCH = *THIS_RTX.  */
10525       emit_move_insn (scratch, gen_rtx_MEM (Pmode, this_rtx));
10526
10527       /* Prepare for adding VCALL_OFFSET.  The difficulty is that we
10528          may not have any available scratch register at this point.  */
10529       if (SPARC_SIMM13_P (vcall_offset))
10530         ;
10531       /* This is the case if ARCH64 (unless -ffixed-g5 is passed).  */
10532       else if (! fixed_regs[5]
10533                /* The below sequence is made up of at least 2 insns,
10534                   while the default method may need only one.  */
10535                && vcall_offset < -8192)
10536         {
10537           rtx scratch2 = gen_rtx_REG (Pmode, 5);
10538           emit_move_insn (scratch2, vcall_offset_rtx);
10539           vcall_offset_rtx = scratch2;
10540         }
10541       else
10542         {
10543           rtx increment = GEN_INT (-4096);
10544
10545           /* VCALL_OFFSET is a negative number whose typical range can be
10546              estimated as -32768..0 in 32-bit mode.  In almost all cases
10547              it is therefore cheaper to emit multiple add insns than
10548              spilling and loading the constant into a register (at least
10549              6 insns).  */
10550           while (! SPARC_SIMM13_P (vcall_offset))
10551             {
10552               emit_insn (gen_add2_insn (scratch, increment));
10553               vcall_offset += 4096;
10554             }
10555           vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */
10556         }
10557
10558       /* SCRATCH = *(*THIS_RTX + VCALL_OFFSET).  */
10559       emit_move_insn (scratch, gen_rtx_MEM (Pmode,
10560                                             gen_rtx_PLUS (Pmode,
10561                                                           scratch,
10562                                                           vcall_offset_rtx)));
10563
10564       /* THIS_RTX += *(*THIS_RTX + VCALL_OFFSET).  */
10565       emit_insn (gen_add2_insn (this_rtx, scratch));
10566     }
10567
10568   /* Generate a tail call to the target function.  */
10569   if (! TREE_USED (function))
10570     {
10571       assemble_external (function);
10572       TREE_USED (function) = 1;
10573     }
10574   funexp = XEXP (DECL_RTL (function), 0);
10575
10576   if (flag_delayed_branch)
10577     {
10578       funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
10579       insn = emit_call_insn (gen_sibcall (funexp));
10580       SIBLING_CALL_P (insn) = 1;
10581     }
10582   else
10583     {
10584       /* The hoops we have to jump through in order to generate a sibcall
10585          without using delay slots...  */
10586       rtx spill_reg, seq, scratch = gen_rtx_REG (Pmode, 1);
10587
10588       if (flag_pic)
10589         {
10590           spill_reg = gen_rtx_REG (word_mode, 15);  /* %o7 */
10591           start_sequence ();
10592           load_got_register ();  /* clobbers %o7 */
10593           scratch = sparc_legitimize_pic_address (funexp, scratch);
10594           seq = get_insns ();
10595           end_sequence ();
10596           emit_and_preserve (seq, spill_reg, pic_offset_table_rtx);
10597         }
10598       else if (TARGET_ARCH32)
10599         {
10600           emit_insn (gen_rtx_SET (VOIDmode,
10601                                   scratch,
10602                                   gen_rtx_HIGH (SImode, funexp)));
10603           emit_insn (gen_rtx_SET (VOIDmode,
10604                                   scratch,
10605                                   gen_rtx_LO_SUM (SImode, scratch, funexp)));
10606         }
10607       else  /* TARGET_ARCH64 */
10608         {
10609           switch (sparc_cmodel)
10610             {
10611             case CM_MEDLOW:
10612             case CM_MEDMID:
10613               /* The destination can serve as a temporary.  */
10614               sparc_emit_set_symbolic_const64 (scratch, funexp, scratch);
10615               break;
10616
10617             case CM_MEDANY:
10618             case CM_EMBMEDANY:
10619               /* The destination cannot serve as a temporary.  */
10620               spill_reg = gen_rtx_REG (DImode, 15);  /* %o7 */
10621               start_sequence ();
10622               sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
10623               seq = get_insns ();
10624               end_sequence ();
10625               emit_and_preserve (seq, spill_reg, 0);
10626               break;
10627
10628             default:
10629               gcc_unreachable ();
10630             }
10631         }
10632
10633       emit_jump_insn (gen_indirect_jump (scratch));
10634     }
10635
10636   emit_barrier ();
10637
10638   /* Run just enough of rest_of_compilation to get the insns emitted.
10639      There's not really enough bulk here to make other passes such as
10640      instruction scheduling worth while.  Note that use_thunk calls
10641      assemble_start_function and assemble_end_function.  */
10642   insn = get_insns ();
10643   insn_locators_alloc ();
10644   shorten_branches (insn);
10645   final_start_function (insn, file, 1);
10646   final (insn, file, 1);
10647   final_end_function ();
10648
10649   reload_completed = 0;
10650   epilogue_completed = 0;
10651 }
10652
10653 /* Return true if sparc_output_mi_thunk would be able to output the
10654    assembler code for the thunk function specified by the arguments
10655    it is passed, and false otherwise.  */
10656 static bool
10657 sparc_can_output_mi_thunk (const_tree thunk_fndecl ATTRIBUTE_UNUSED,
10658                            HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
10659                            HOST_WIDE_INT vcall_offset,
10660                            const_tree function ATTRIBUTE_UNUSED)
10661 {
10662   /* Bound the loop used in the default method above.  */
10663   return (vcall_offset >= -32768 || ! fixed_regs[5]);
10664 }
10665
10666 /* We use the machine specific reorg pass to enable workarounds for errata.  */
10667
10668 static void
10669 sparc_reorg (void)
10670 {
10671   rtx insn, next;
10672
10673   /* The only erratum we handle for now is that of the AT697F processor.  */
10674   if (!sparc_fix_at697f)
10675     return;
10676
10677   /* We need to have the (essentially) final form of the insn stream in order
10678      to properly detect the various hazards.  Run delay slot scheduling.  */
10679   if (optimize > 0 && flag_delayed_branch)
10680     dbr_schedule (get_insns ());
10681
10682   /* Now look for specific patterns in the insn stream.  */
10683   for (insn = get_insns (); insn; insn = next)
10684     {
10685       bool insert_nop = false;
10686       rtx set;
10687
10688       /* Look for a single-word load into an odd-numbered FP register.  */
10689       if (NONJUMP_INSN_P (insn)
10690           && (set = single_set (insn)) != NULL_RTX
10691           && GET_MODE_SIZE (GET_MODE (SET_SRC (set))) == 4
10692           && MEM_P (SET_SRC (set))
10693           && REG_P (SET_DEST (set))
10694           && REGNO (SET_DEST (set)) > 31
10695           && REGNO (SET_DEST (set)) % 2 != 0)
10696         {
10697           /* The wrong dependency is on the enclosing double register.  */
10698           unsigned int x = REGNO (SET_DEST (set)) - 1;
10699           unsigned int src1, src2, dest;
10700           int code;
10701
10702           /* If the insn has a delay slot, then it cannot be problematic.  */
10703           next = next_active_insn (insn);
10704           if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
10705             code = -1;
10706           else
10707             {
10708               extract_insn (next);
10709               code = INSN_CODE (next);
10710             }
10711
10712           switch (code)
10713             {
10714             case CODE_FOR_adddf3:
10715             case CODE_FOR_subdf3:
10716             case CODE_FOR_muldf3:
10717             case CODE_FOR_divdf3:
10718               dest = REGNO (recog_data.operand[0]);
10719               src1 = REGNO (recog_data.operand[1]);
10720               src2 = REGNO (recog_data.operand[2]);
10721               if (src1 != src2)
10722                 {
10723                   /* Case [1-4]:
10724                                  ld [address], %fx+1
10725                                  FPOPd %f{x,y}, %f{y,x}, %f{x,y}  */
10726                   if ((src1 == x || src2 == x)
10727                       && (dest == src1 || dest == src2))
10728                     insert_nop = true;
10729                 }
10730               else
10731                 {
10732                   /* Case 5:
10733                              ld [address], %fx+1
10734                              FPOPd %fx, %fx, %fx  */
10735                   if (src1 == x
10736                       && dest == src1
10737                       && (code == CODE_FOR_adddf3 || code == CODE_FOR_muldf3))
10738                     insert_nop = true;
10739                 }
10740               break;
10741
10742             case CODE_FOR_sqrtdf2:
10743               dest = REGNO (recog_data.operand[0]);
10744               src1 = REGNO (recog_data.operand[1]);
10745               /* Case 6:
10746                          ld [address], %fx+1
10747                          fsqrtd %fx, %fx  */
10748               if (src1 == x && dest == src1)
10749                 insert_nop = true;
10750               break;
10751
10752             default:
10753               break;
10754             }
10755         }
10756       else
10757         next = NEXT_INSN (insn);
10758
10759       if (insert_nop)
10760         emit_insn_after (gen_nop (), insn);
10761     }
10762 }
10763
10764 /* How to allocate a 'struct machine_function'.  */
10765
10766 static struct machine_function *
10767 sparc_init_machine_status (void)
10768 {
10769   return ggc_alloc_cleared_machine_function ();
10770 }
10771
10772 /* Locate some local-dynamic symbol still in use by this function
10773    so that we can print its name in local-dynamic base patterns.  */
10774
10775 static const char *
10776 get_some_local_dynamic_name (void)
10777 {
10778   rtx insn;
10779
10780   if (cfun->machine->some_ld_name)
10781     return cfun->machine->some_ld_name;
10782
10783   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
10784     if (INSN_P (insn)
10785         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
10786       return cfun->machine->some_ld_name;
10787
10788   gcc_unreachable ();
10789 }
10790
10791 static int
10792 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
10793 {
10794   rtx x = *px;
10795
10796   if (x
10797       && GET_CODE (x) == SYMBOL_REF
10798       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
10799     {
10800       cfun->machine->some_ld_name = XSTR (x, 0);
10801       return 1;
10802     }
10803
10804   return 0;
10805 }
10806
10807 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
10808    We need to emit DTP-relative relocations.  */
10809
10810 static void
10811 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
10812 {
10813   switch (size)
10814     {
10815     case 4:
10816       fputs ("\t.word\t%r_tls_dtpoff32(", file);
10817       break;
10818     case 8:
10819       fputs ("\t.xword\t%r_tls_dtpoff64(", file);
10820       break;
10821     default:
10822       gcc_unreachable ();
10823     }
10824   output_addr_const (file, x);
10825   fputs (")", file);
10826 }
10827
10828 /* Do whatever processing is required at the end of a file.  */
10829
10830 static void
10831 sparc_file_end (void)
10832 {
10833   /* If we need to emit the special GOT helper function, do so now.  */
10834   if (got_helper_rtx)
10835     {
10836       const char *name = XSTR (got_helper_rtx, 0);
10837       const char *reg_name = reg_names[GLOBAL_OFFSET_TABLE_REGNUM];
10838 #ifdef DWARF2_UNWIND_INFO
10839       bool do_cfi;
10840 #endif
10841
10842       if (USE_HIDDEN_LINKONCE)
10843         {
10844           tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
10845                                   get_identifier (name),
10846                                   build_function_type_list (void_type_node,
10847                                                             NULL_TREE));
10848           DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
10849                                            NULL_TREE, void_type_node);
10850           TREE_PUBLIC (decl) = 1;
10851           TREE_STATIC (decl) = 1;
10852           make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
10853           DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
10854           DECL_VISIBILITY_SPECIFIED (decl) = 1;
10855           resolve_unique_section (decl, 0, flag_function_sections);
10856           allocate_struct_function (decl, true);
10857           cfun->is_thunk = 1;
10858           current_function_decl = decl;
10859           init_varasm_status ();
10860           assemble_start_function (decl, name);
10861         }
10862       else
10863         {
10864           const int align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
10865           switch_to_section (text_section);
10866           if (align > 0)
10867             ASM_OUTPUT_ALIGN (asm_out_file, align);
10868           ASM_OUTPUT_LABEL (asm_out_file, name);
10869         }
10870
10871 #ifdef DWARF2_UNWIND_INFO
10872       do_cfi = dwarf2out_do_cfi_asm ();
10873       if (do_cfi)
10874         fprintf (asm_out_file, "\t.cfi_startproc\n");
10875 #endif
10876       if (flag_delayed_branch)
10877         fprintf (asm_out_file, "\tjmp\t%%o7+8\n\t add\t%%o7, %s, %s\n",
10878                  reg_name, reg_name);
10879       else
10880         fprintf (asm_out_file, "\tadd\t%%o7, %s, %s\n\tjmp\t%%o7+8\n\t nop\n",
10881                  reg_name, reg_name);
10882 #ifdef DWARF2_UNWIND_INFO
10883       if (do_cfi)
10884         fprintf (asm_out_file, "\t.cfi_endproc\n");
10885 #endif
10886     }
10887
10888   if (NEED_INDICATE_EXEC_STACK)
10889     file_end_indicate_exec_stack ();
10890
10891 #ifdef TARGET_SOLARIS
10892   solaris_file_end ();
10893 #endif
10894 }
10895
10896 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
10897 /* Implement TARGET_MANGLE_TYPE.  */
10898
10899 static const char *
10900 sparc_mangle_type (const_tree type)
10901 {
10902   if (!TARGET_64BIT
10903       && TYPE_MAIN_VARIANT (type) == long_double_type_node
10904       && TARGET_LONG_DOUBLE_128)
10905     return "g";
10906
10907   /* For all other types, use normal C++ mangling.  */
10908   return NULL;
10909 }
10910 #endif
10911
10912 /* Expand a membar instruction for various use cases.  Both the LOAD_STORE
10913    and BEFORE_AFTER arguments of the form X_Y.  They are two-bit masks where
10914    bit 0 indicates that X is true, and bit 1 indicates Y is true.  */
10915
10916 void
10917 sparc_emit_membar_for_model (enum memmodel model,
10918                              int load_store, int before_after)
10919 {
10920   /* Bits for the MEMBAR mmask field.  */
10921   const int LoadLoad = 1;
10922   const int StoreLoad = 2;
10923   const int LoadStore = 4;
10924   const int StoreStore = 8;
10925
10926   int mm = 0, implied = 0;
10927
10928   switch (sparc_memory_model)
10929     {
10930     case SMM_SC:
10931       /* Sequential Consistency.  All memory transactions are immediately
10932          visible in sequential execution order.  No barriers needed.  */
10933       implied = LoadLoad | StoreLoad | LoadStore | StoreStore;
10934       break;
10935
10936     case SMM_TSO:
10937       /* Total Store Ordering: all memory transactions with store semantics
10938          are followed by an implied StoreStore.  */
10939       implied |= StoreStore;
10940       /* FALLTHRU */
10941
10942     case SMM_PSO:
10943       /* Partial Store Ordering: all memory transactions with load semantics
10944          are followed by an implied LoadLoad | LoadStore.  */
10945       implied |= LoadLoad | LoadStore;
10946
10947       /* If we're not looking for a raw barrer (before+after), then atomic
10948          operations get the benefit of being both load and store.  */
10949       if (load_store == 3 && before_after == 2)
10950         implied |= StoreLoad | StoreStore;
10951       /* FALLTHRU */
10952
10953     case SMM_RMO:
10954       /* Relaxed Memory Ordering: no implicit bits.  */
10955       break;
10956
10957     default:
10958       gcc_unreachable ();
10959     }
10960
10961   if (before_after & 1)
10962     {
10963       if (model == MEMMODEL_ACQUIRE
10964           || model == MEMMODEL_ACQ_REL
10965           || model == MEMMODEL_SEQ_CST)
10966         {
10967           if (load_store & 1)
10968             mm |= LoadLoad | LoadStore;
10969           if (load_store & 2)
10970             mm |= StoreLoad | StoreStore;
10971         }
10972     }
10973   if (before_after & 2)
10974     {
10975       if (model == MEMMODEL_RELEASE
10976           || model == MEMMODEL_ACQ_REL
10977           || model == MEMMODEL_SEQ_CST)
10978         {
10979           if (load_store & 1)
10980             mm |= LoadLoad | StoreLoad;
10981           if (load_store & 2)
10982             mm |= LoadStore | StoreStore;
10983         }
10984     }
10985
10986   /* Remove the bits implied by the system memory model.  */
10987   mm &= ~implied;
10988
10989   /* For raw barriers (before+after), always emit a barrier.
10990      This will become a compile-time barrier if needed.  */
10991   if (mm || before_after == 3)
10992     emit_insn (gen_membar (GEN_INT (mm)));
10993 }
10994
10995 /* Expand code to perform a 8 or 16-bit compare and swap by doing 32-bit
10996    compare and swap on the word containing the byte or half-word.  */
10997
10998 static void
10999 sparc_expand_compare_and_swap_12 (rtx bool_result, rtx result, rtx mem,
11000                                   rtx oldval, rtx newval)
11001 {
11002   rtx addr1 = force_reg (Pmode, XEXP (mem, 0));
11003   rtx addr = gen_reg_rtx (Pmode);
11004   rtx off = gen_reg_rtx (SImode);
11005   rtx oldv = gen_reg_rtx (SImode);
11006   rtx newv = gen_reg_rtx (SImode);
11007   rtx oldvalue = gen_reg_rtx (SImode);
11008   rtx newvalue = gen_reg_rtx (SImode);
11009   rtx res = gen_reg_rtx (SImode);
11010   rtx resv = gen_reg_rtx (SImode);
11011   rtx memsi, val, mask, end_label, loop_label, cc;
11012
11013   emit_insn (gen_rtx_SET (VOIDmode, addr,
11014                           gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
11015
11016   if (Pmode != SImode)
11017     addr1 = gen_lowpart (SImode, addr1);
11018   emit_insn (gen_rtx_SET (VOIDmode, off,
11019                           gen_rtx_AND (SImode, addr1, GEN_INT (3))));
11020
11021   memsi = gen_rtx_MEM (SImode, addr);
11022   set_mem_alias_set (memsi, ALIAS_SET_MEMORY_BARRIER);
11023   MEM_VOLATILE_P (memsi) = MEM_VOLATILE_P (mem);
11024
11025   val = copy_to_reg (memsi);
11026
11027   emit_insn (gen_rtx_SET (VOIDmode, off,
11028                           gen_rtx_XOR (SImode, off,
11029                                        GEN_INT (GET_MODE (mem) == QImode
11030                                                 ? 3 : 2))));
11031
11032   emit_insn (gen_rtx_SET (VOIDmode, off,
11033                           gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
11034
11035   if (GET_MODE (mem) == QImode)
11036     mask = force_reg (SImode, GEN_INT (0xff));
11037   else
11038     mask = force_reg (SImode, GEN_INT (0xffff));
11039
11040   emit_insn (gen_rtx_SET (VOIDmode, mask,
11041                           gen_rtx_ASHIFT (SImode, mask, off)));
11042
11043   emit_insn (gen_rtx_SET (VOIDmode, val,
11044                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
11045                                        val)));
11046
11047   oldval = gen_lowpart (SImode, oldval);
11048   emit_insn (gen_rtx_SET (VOIDmode, oldv,
11049                           gen_rtx_ASHIFT (SImode, oldval, off)));
11050
11051   newval = gen_lowpart_common (SImode, newval);
11052   emit_insn (gen_rtx_SET (VOIDmode, newv,
11053                           gen_rtx_ASHIFT (SImode, newval, off)));
11054
11055   emit_insn (gen_rtx_SET (VOIDmode, oldv,
11056                           gen_rtx_AND (SImode, oldv, mask)));
11057
11058   emit_insn (gen_rtx_SET (VOIDmode, newv,
11059                           gen_rtx_AND (SImode, newv, mask)));
11060
11061   end_label = gen_label_rtx ();
11062   loop_label = gen_label_rtx ();
11063   emit_label (loop_label);
11064
11065   emit_insn (gen_rtx_SET (VOIDmode, oldvalue,
11066                           gen_rtx_IOR (SImode, oldv, val)));
11067
11068   emit_insn (gen_rtx_SET (VOIDmode, newvalue,
11069                           gen_rtx_IOR (SImode, newv, val)));
11070
11071   emit_move_insn (bool_result, const1_rtx);
11072
11073   emit_insn (gen_atomic_compare_and_swapsi_1 (res, memsi, oldvalue, newvalue));
11074
11075   emit_cmp_and_jump_insns (res, oldvalue, EQ, NULL, SImode, 0, end_label);
11076
11077   emit_insn (gen_rtx_SET (VOIDmode, resv,
11078                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
11079                                        res)));
11080
11081   emit_move_insn (bool_result, const0_rtx);
11082
11083   cc = gen_compare_reg_1 (NE, resv, val);
11084   emit_insn (gen_rtx_SET (VOIDmode, val, resv));
11085
11086   /* Use cbranchcc4 to separate the compare and branch!  */
11087   emit_jump_insn (gen_cbranchcc4 (gen_rtx_NE (VOIDmode, cc, const0_rtx),
11088                                   cc, const0_rtx, loop_label));
11089
11090   emit_label (end_label);
11091
11092   emit_insn (gen_rtx_SET (VOIDmode, res,
11093                           gen_rtx_AND (SImode, res, mask)));
11094
11095   emit_insn (gen_rtx_SET (VOIDmode, res,
11096                           gen_rtx_LSHIFTRT (SImode, res, off)));
11097
11098   emit_move_insn (result, gen_lowpart (GET_MODE (result), res));
11099 }
11100
11101 /* Expand code to perform a compare-and-swap.  */
11102
11103 void
11104 sparc_expand_compare_and_swap (rtx operands[])
11105 {
11106   rtx bval, retval, mem, oldval, newval;
11107   enum machine_mode mode;
11108   enum memmodel model;
11109
11110   bval = operands[0];
11111   retval = operands[1];
11112   mem = operands[2];
11113   oldval = operands[3];
11114   newval = operands[4];
11115   model = (enum memmodel) INTVAL (operands[6]);
11116   mode = GET_MODE (mem);
11117
11118   sparc_emit_membar_for_model (model, 3, 1);
11119
11120   if (reg_overlap_mentioned_p (retval, oldval))
11121     oldval = copy_to_reg (oldval);
11122
11123   if (mode == QImode || mode == HImode)
11124     sparc_expand_compare_and_swap_12 (bval, retval, mem, oldval, newval);
11125   else
11126     {
11127       rtx (*gen) (rtx, rtx, rtx, rtx);
11128       rtx x;
11129
11130       if (mode == SImode)
11131         gen = gen_atomic_compare_and_swapsi_1;
11132       else
11133         gen = gen_atomic_compare_and_swapdi_1;
11134       emit_insn (gen (retval, mem, oldval, newval));
11135
11136       x = emit_store_flag (bval, EQ, retval, oldval, mode, 1, 1);
11137       if (x != bval)
11138         convert_move (bval, x, 1);
11139     }
11140
11141   sparc_emit_membar_for_model (model, 3, 2);
11142 }
11143
11144 void
11145 sparc_expand_vec_perm_bmask (enum machine_mode vmode, rtx sel)
11146 {
11147   rtx t_1, t_2, t_3;
11148
11149   sel = gen_lowpart (DImode, sel);
11150   switch (vmode)
11151     {
11152     case V2SImode:
11153       /* inp = xxxxxxxAxxxxxxxB */
11154       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11155                                  NULL_RTX, 1, OPTAB_DIRECT);
11156       /* t_1 = ....xxxxxxxAxxx. */
11157       sel = expand_simple_binop (SImode, AND, gen_lowpart (SImode, sel),
11158                                  GEN_INT (3), NULL_RTX, 1, OPTAB_DIRECT);
11159       t_1 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_1),
11160                                  GEN_INT (0x30000), NULL_RTX, 1, OPTAB_DIRECT);
11161       /* sel = .......B */
11162       /* t_1 = ...A.... */
11163       sel = expand_simple_binop (SImode, IOR, sel, t_1, sel, 1, OPTAB_DIRECT);
11164       /* sel = ...A...B */
11165       sel = expand_mult (SImode, sel, GEN_INT (0x4444), sel, 1);
11166       /* sel = AAAABBBB * 4 */
11167       t_1 = force_reg (SImode, GEN_INT (0x01230123));
11168       /* sel = { A*4, A*4+1, A*4+2, ... } */
11169       break;
11170
11171     case V4HImode:
11172       /* inp = xxxAxxxBxxxCxxxD */
11173       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (8),
11174                                  NULL_RTX, 1, OPTAB_DIRECT);
11175       t_2 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11176                                  NULL_RTX, 1, OPTAB_DIRECT);
11177       t_3 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (24),
11178                                  NULL_RTX, 1, OPTAB_DIRECT);
11179       /* t_1 = ..xxxAxxxBxxxCxx */
11180       /* t_2 = ....xxxAxxxBxxxC */
11181       /* t_3 = ......xxxAxxxBxx */
11182       sel = expand_simple_binop (SImode, AND, gen_lowpart (SImode, sel),
11183                                  GEN_INT (0x07),
11184                                  NULL_RTX, 1, OPTAB_DIRECT);
11185       t_1 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_1),
11186                                  GEN_INT (0x0700),
11187                                  NULL_RTX, 1, OPTAB_DIRECT);
11188       t_2 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_2),
11189                                  GEN_INT (0x070000),
11190                                  NULL_RTX, 1, OPTAB_DIRECT);
11191       t_3 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_3),
11192                                  GEN_INT (0x07000000),
11193                                  NULL_RTX, 1, OPTAB_DIRECT);
11194       /* sel = .......D */
11195       /* t_1 = .....C.. */
11196       /* t_2 = ...B.... */
11197       /* t_3 = .A...... */
11198       sel = expand_simple_binop (SImode, IOR, sel, t_1, sel, 1, OPTAB_DIRECT);
11199       t_2 = expand_simple_binop (SImode, IOR, t_2, t_3, t_2, 1, OPTAB_DIRECT);
11200       sel = expand_simple_binop (SImode, IOR, sel, t_2, sel, 1, OPTAB_DIRECT);
11201       /* sel = .A.B.C.D */
11202       sel = expand_mult (SImode, sel, GEN_INT (0x22), sel, 1);
11203       /* sel = AABBCCDD * 2 */
11204       t_1 = force_reg (SImode, GEN_INT (0x01010101));
11205       /* sel = { A*2, A*2+1, B*2, B*2+1, ... } */
11206       break;
11207
11208     case V8QImode:
11209       /* input = xAxBxCxDxExFxGxH */
11210       sel = expand_simple_binop (DImode, AND, sel,
11211                                  GEN_INT ((HOST_WIDE_INT)0x0f0f0f0f << 32
11212                                           | 0x0f0f0f0f),
11213                                  NULL_RTX, 1, OPTAB_DIRECT);
11214       /* sel = .A.B.C.D.E.F.G.H */
11215       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (4),
11216                                  NULL_RTX, 1, OPTAB_DIRECT);
11217       /* t_1 = ..A.B.C.D.E.F.G. */
11218       sel = expand_simple_binop (DImode, IOR, sel, t_1,
11219                                  NULL_RTX, 1, OPTAB_DIRECT);
11220       /* sel = .AABBCCDDEEFFGGH */
11221       sel = expand_simple_binop (DImode, AND, sel,
11222                                  GEN_INT ((HOST_WIDE_INT)0xff00ff << 32
11223                                           | 0xff00ff),
11224                                  NULL_RTX, 1, OPTAB_DIRECT);
11225       /* sel = ..AB..CD..EF..GH */
11226       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (8),
11227                                  NULL_RTX, 1, OPTAB_DIRECT);
11228       /* t_1 = ....AB..CD..EF.. */
11229       sel = expand_simple_binop (DImode, IOR, sel, t_1,
11230                                  NULL_RTX, 1, OPTAB_DIRECT);
11231       /* sel = ..ABABCDCDEFEFGH */
11232       sel = expand_simple_binop (DImode, AND, sel,
11233                                  GEN_INT ((HOST_WIDE_INT)0xffff << 32 | 0xffff),
11234                                  NULL_RTX, 1, OPTAB_DIRECT);
11235       /* sel = ....ABCD....EFGH */
11236       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11237                                  NULL_RTX, 1, OPTAB_DIRECT);
11238       /* t_1 = ........ABCD.... */
11239       sel = gen_lowpart (SImode, sel);
11240       t_1 = gen_lowpart (SImode, t_1);
11241       break;
11242
11243     default:
11244       gcc_unreachable ();
11245     }
11246
11247   /* Always perform the final addition/merge within the bmask insn.  */
11248   emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), sel, t_1));
11249 }
11250
11251 /* Implement TARGET_FRAME_POINTER_REQUIRED.  */
11252
11253 static bool
11254 sparc_frame_pointer_required (void)
11255 {
11256   /* If the stack pointer is dynamically modified in the function, it cannot
11257      serve as the frame pointer.  */
11258   if (cfun->calls_alloca)
11259     return true;
11260
11261   /* If the function receives nonlocal gotos, it needs to save the frame
11262      pointer in the nonlocal_goto_save_area object.  */
11263   if (cfun->has_nonlocal_label)
11264     return true;
11265
11266   /* In flat mode, that's it.  */
11267   if (TARGET_FLAT)
11268     return false;
11269
11270   /* Otherwise, the frame pointer is required if the function isn't leaf.  */
11271   return !(current_function_is_leaf && only_leaf_regs_used ());
11272 }
11273
11274 /* The way this is structured, we can't eliminate SFP in favor of SP
11275    if the frame pointer is required: we want to use the SFP->HFP elimination
11276    in that case.  But the test in update_eliminables doesn't know we are
11277    assuming below that we only do the former elimination.  */
11278
11279 static bool
11280 sparc_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
11281 {
11282   return to == HARD_FRAME_POINTER_REGNUM || !sparc_frame_pointer_required ();
11283 }
11284
11285 /* Return the hard frame pointer directly to bypass the stack bias.  */
11286
11287 static rtx
11288 sparc_builtin_setjmp_frame_value (void)
11289 {
11290   return hard_frame_pointer_rtx;
11291 }
11292
11293 /* If !TARGET_FPU, then make the fp registers and fp cc regs fixed so that
11294    they won't be allocated.  */
11295
11296 static void
11297 sparc_conditional_register_usage (void)
11298 {
11299   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
11300     {
11301       fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
11302       call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
11303     }
11304   /* If the user has passed -f{fixed,call-{used,saved}}-g5 */
11305   /* then honor it.  */
11306   if (TARGET_ARCH32 && fixed_regs[5])
11307     fixed_regs[5] = 1;
11308   else if (TARGET_ARCH64 && fixed_regs[5] == 2)
11309     fixed_regs[5] = 0;
11310   if (! TARGET_V9)
11311     {
11312       int regno;
11313       for (regno = SPARC_FIRST_V9_FP_REG;
11314            regno <= SPARC_LAST_V9_FP_REG;
11315            regno++)
11316         fixed_regs[regno] = 1;
11317       /* %fcc0 is used by v8 and v9.  */
11318       for (regno = SPARC_FIRST_V9_FCC_REG + 1;
11319            regno <= SPARC_LAST_V9_FCC_REG;
11320            regno++)
11321         fixed_regs[regno] = 1;
11322     }
11323   if (! TARGET_FPU)
11324     {
11325       int regno;
11326       for (regno = 32; regno < SPARC_LAST_V9_FCC_REG; regno++)
11327         fixed_regs[regno] = 1;
11328     }
11329   /* If the user has passed -f{fixed,call-{used,saved}}-g2 */
11330   /* then honor it.  Likewise with g3 and g4.  */
11331   if (fixed_regs[2] == 2)
11332     fixed_regs[2] = ! TARGET_APP_REGS;
11333   if (fixed_regs[3] == 2)
11334     fixed_regs[3] = ! TARGET_APP_REGS;
11335   if (TARGET_ARCH32 && fixed_regs[4] == 2)
11336     fixed_regs[4] = ! TARGET_APP_REGS;
11337   else if (TARGET_CM_EMBMEDANY)
11338     fixed_regs[4] = 1;
11339   else if (fixed_regs[4] == 2)
11340     fixed_regs[4] = 0;
11341   if (TARGET_FLAT)
11342     {
11343       int regno;
11344       /* Disable leaf functions.  */
11345       memset (sparc_leaf_regs, 0, FIRST_PSEUDO_REGISTER);
11346       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
11347         leaf_reg_remap [regno] = regno;
11348     }
11349   if (TARGET_VIS)
11350     global_regs[SPARC_GSR_REG] = 1;
11351 }
11352
11353 /* Implement TARGET_PREFERRED_RELOAD_CLASS:
11354
11355    - We can't load constants into FP registers.
11356    - We can't load FP constants into integer registers when soft-float,
11357      because there is no soft-float pattern with a r/F constraint.
11358    - We can't load FP constants into integer registers for TFmode unless
11359      it is 0.0L, because there is no movtf pattern with a r/F constraint.
11360    - Try and reload integer constants (symbolic or otherwise) back into
11361      registers directly, rather than having them dumped to memory.  */
11362
11363 static reg_class_t
11364 sparc_preferred_reload_class (rtx x, reg_class_t rclass)
11365 {
11366   enum machine_mode mode = GET_MODE (x);
11367   if (CONSTANT_P (x))
11368     {
11369       if (FP_REG_CLASS_P (rclass)
11370           || rclass == GENERAL_OR_FP_REGS
11371           || rclass == GENERAL_OR_EXTRA_FP_REGS
11372           || (GET_MODE_CLASS (mode) == MODE_FLOAT && ! TARGET_FPU)
11373           || (mode == TFmode && ! const_zero_operand (x, mode)))
11374         return NO_REGS;
11375
11376       if (GET_MODE_CLASS (mode) == MODE_INT)
11377         return GENERAL_REGS;
11378
11379       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
11380         {
11381           if (! FP_REG_CLASS_P (rclass)
11382               || !(const_zero_operand (x, mode)
11383                    || const_all_ones_operand (x, mode)))
11384             return NO_REGS;
11385         }
11386     }
11387
11388   if (TARGET_VIS3
11389       && ! TARGET_ARCH64
11390       && (rclass == EXTRA_FP_REGS
11391           || rclass == GENERAL_OR_EXTRA_FP_REGS))
11392     {
11393       int regno = true_regnum (x);
11394
11395       if (SPARC_INT_REG_P (regno))
11396         return (rclass == EXTRA_FP_REGS
11397                 ? FP_REGS : GENERAL_OR_FP_REGS);
11398     }
11399
11400   return rclass;
11401 }
11402
11403 /* Output a wide multiply instruction in V8+ mode.  INSN is the instruction,
11404    OPERANDS are its operands and OPCODE is the mnemonic to be used.  */
11405
11406 const char *
11407 output_v8plus_mult (rtx insn, rtx *operands, const char *opcode)
11408 {
11409   char mulstr[32];
11410
11411   gcc_assert (! TARGET_ARCH64);
11412
11413   if (sparc_check_64 (operands[1], insn) <= 0)
11414     output_asm_insn ("srl\t%L1, 0, %L1", operands);
11415   if (which_alternative == 1)
11416     output_asm_insn ("sllx\t%H1, 32, %H1", operands);
11417   if (GET_CODE (operands[2]) == CONST_INT)
11418     {
11419       if (which_alternative == 1)
11420         {
11421           output_asm_insn ("or\t%L1, %H1, %H1", operands);
11422           sprintf (mulstr, "%s\t%%H1, %%2, %%L0", opcode);
11423           output_asm_insn (mulstr, operands);
11424           return "srlx\t%L0, 32, %H0";
11425         }
11426       else
11427         {
11428           output_asm_insn ("sllx\t%H1, 32, %3", operands);
11429           output_asm_insn ("or\t%L1, %3, %3", operands);
11430           sprintf (mulstr, "%s\t%%3, %%2, %%3", opcode);
11431           output_asm_insn (mulstr, operands);
11432           output_asm_insn ("srlx\t%3, 32, %H0", operands);
11433           return "mov\t%3, %L0";
11434         }
11435     }
11436   else if (rtx_equal_p (operands[1], operands[2]))
11437     {
11438       if (which_alternative == 1)
11439         {
11440           output_asm_insn ("or\t%L1, %H1, %H1", operands);
11441           sprintf (mulstr, "%s\t%%H1, %%H1, %%L0", opcode);
11442           output_asm_insn (mulstr, operands);
11443           return "srlx\t%L0, 32, %H0";
11444         }
11445       else
11446         {
11447           output_asm_insn ("sllx\t%H1, 32, %3", operands);
11448           output_asm_insn ("or\t%L1, %3, %3", operands);
11449           sprintf (mulstr, "%s\t%%3, %%3, %%3", opcode);
11450           output_asm_insn (mulstr, operands);
11451           output_asm_insn ("srlx\t%3, 32, %H0", operands);
11452           return "mov\t%3, %L0";
11453         }
11454     }
11455   if (sparc_check_64 (operands[2], insn) <= 0)
11456     output_asm_insn ("srl\t%L2, 0, %L2", operands);
11457   if (which_alternative == 1)
11458     {
11459       output_asm_insn ("or\t%L1, %H1, %H1", operands);
11460       output_asm_insn ("sllx\t%H2, 32, %L1", operands);
11461       output_asm_insn ("or\t%L2, %L1, %L1", operands);
11462       sprintf (mulstr, "%s\t%%H1, %%L1, %%L0", opcode);
11463       output_asm_insn (mulstr, operands);
11464       return "srlx\t%L0, 32, %H0";
11465     }
11466   else
11467     {
11468       output_asm_insn ("sllx\t%H1, 32, %3", operands);
11469       output_asm_insn ("sllx\t%H2, 32, %4", operands);
11470       output_asm_insn ("or\t%L1, %3, %3", operands);
11471       output_asm_insn ("or\t%L2, %4, %4", operands);
11472       sprintf (mulstr, "%s\t%%3, %%4, %%3", opcode);
11473       output_asm_insn (mulstr, operands);
11474       output_asm_insn ("srlx\t%3, 32, %H0", operands);
11475       return "mov\t%3, %L0";
11476     }
11477 }
11478
11479 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11480    all fields of TARGET to ELT by means of VIS2 BSHUFFLE insn.  MODE
11481    and INNER_MODE are the modes describing TARGET.  */
11482
11483 static void
11484 vector_init_bshuffle (rtx target, rtx elt, enum machine_mode mode,
11485                       enum machine_mode inner_mode)
11486 {
11487   rtx t1, final_insn;
11488   int bmask;
11489
11490   t1 = gen_reg_rtx (mode);
11491
11492   elt = convert_modes (SImode, inner_mode, elt, true);
11493   emit_move_insn (gen_lowpart(SImode, t1), elt);
11494
11495   switch (mode)
11496     {
11497     case V2SImode:
11498       final_insn = gen_bshufflev2si_vis (target, t1, t1);
11499       bmask = 0x45674567;
11500       break;
11501     case V4HImode:
11502       final_insn = gen_bshufflev4hi_vis (target, t1, t1);
11503       bmask = 0x67676767;
11504       break;
11505     case V8QImode:
11506       final_insn = gen_bshufflev8qi_vis (target, t1, t1);
11507       bmask = 0x77777777;
11508       break;
11509     default:
11510       gcc_unreachable ();
11511     }
11512
11513   emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), CONST0_RTX (SImode),
11514                               force_reg (SImode, GEN_INT (bmask))));
11515   emit_insn (final_insn);
11516 }
11517
11518 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11519    all fields of TARGET to ELT in V8QI by means of VIS FPMERGE insn.  */
11520
11521 static void
11522 vector_init_fpmerge (rtx target, rtx elt)
11523 {
11524   rtx t1, t2, t2_low, t3, t3_low;
11525
11526   t1 = gen_reg_rtx (V4QImode);
11527   elt = convert_modes (SImode, QImode, elt, true);
11528   emit_move_insn (gen_lowpart (SImode, t1), elt);
11529
11530   t2 = gen_reg_rtx (V8QImode);
11531   t2_low = gen_lowpart (V4QImode, t2);
11532   emit_insn (gen_fpmerge_vis (t2, t1, t1));
11533
11534   t3 = gen_reg_rtx (V8QImode);
11535   t3_low = gen_lowpart (V4QImode, t3);
11536   emit_insn (gen_fpmerge_vis (t3, t2_low, t2_low));
11537
11538   emit_insn (gen_fpmerge_vis (target, t3_low, t3_low));
11539 }
11540
11541 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11542    all fields of TARGET to ELT in V4HI by means of VIS FALIGNDATA insn.  */
11543
11544 static void
11545 vector_init_faligndata (rtx target, rtx elt)
11546 {
11547   rtx t1 = gen_reg_rtx (V4HImode);
11548   int i;
11549
11550   elt = convert_modes (SImode, HImode, elt, true);
11551   emit_move_insn (gen_lowpart (SImode, t1), elt);
11552
11553   emit_insn (gen_alignaddrsi_vis (gen_reg_rtx (SImode),
11554                                   force_reg (SImode, GEN_INT (6)),
11555                                   const0_rtx));
11556
11557   for (i = 0; i < 4; i++)
11558     emit_insn (gen_faligndatav4hi_vis (target, t1, target));
11559 }
11560
11561 /* Emit code to initialize TARGET to values for individual fields VALS.  */
11562
11563 void
11564 sparc_expand_vector_init (rtx target, rtx vals)
11565 {
11566   const enum machine_mode mode = GET_MODE (target);
11567   const enum machine_mode inner_mode = GET_MODE_INNER (mode);
11568   const int n_elts = GET_MODE_NUNITS (mode);
11569   int i, n_var = 0;
11570   bool all_same;
11571   rtx mem;
11572
11573   all_same = true;
11574   for (i = 0; i < n_elts; i++)
11575     {
11576       rtx x = XVECEXP (vals, 0, i);
11577       if (!CONSTANT_P (x))
11578         n_var++;
11579
11580       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
11581         all_same = false;
11582     }
11583
11584   if (n_var == 0)
11585     {
11586       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
11587       return;
11588     }
11589
11590   if (GET_MODE_SIZE (inner_mode) == GET_MODE_SIZE (mode))
11591     {
11592       if (GET_MODE_SIZE (inner_mode) == 4)
11593         {
11594           emit_move_insn (gen_lowpart (SImode, target),
11595                           gen_lowpart (SImode, XVECEXP (vals, 0, 0)));
11596           return;
11597         }
11598       else if (GET_MODE_SIZE (inner_mode) == 8)
11599         {
11600           emit_move_insn (gen_lowpart (DImode, target),
11601                           gen_lowpart (DImode, XVECEXP (vals, 0, 0)));
11602           return;
11603         }
11604     }
11605   else if (GET_MODE_SIZE (inner_mode) == GET_MODE_SIZE (word_mode)
11606            && GET_MODE_SIZE (mode) == 2 * GET_MODE_SIZE (word_mode))
11607     {
11608       emit_move_insn (gen_highpart (word_mode, target),
11609                       gen_lowpart (word_mode, XVECEXP (vals, 0, 0)));
11610       emit_move_insn (gen_lowpart (word_mode, target),
11611                       gen_lowpart (word_mode, XVECEXP (vals, 0, 1)));
11612       return;
11613     }
11614
11615   if (all_same && GET_MODE_SIZE (mode) == 8)
11616     {
11617       if (TARGET_VIS2)
11618         {
11619           vector_init_bshuffle (target, XVECEXP (vals, 0, 0), mode, inner_mode);
11620           return;
11621         }
11622       if (mode == V8QImode)
11623         {
11624           vector_init_fpmerge (target, XVECEXP (vals, 0, 0));
11625           return;
11626         }
11627       if (mode == V4HImode)
11628         {
11629           vector_init_faligndata (target, XVECEXP (vals, 0, 0));
11630           return;
11631         }
11632     }
11633
11634   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
11635   for (i = 0; i < n_elts; i++)
11636     emit_move_insn (adjust_address_nv (mem, inner_mode,
11637                                        i * GET_MODE_SIZE (inner_mode)),
11638                     XVECEXP (vals, 0, i));
11639   emit_move_insn (target, mem);
11640 }
11641
11642 /* Implement TARGET_SECONDARY_RELOAD.  */
11643
11644 static reg_class_t
11645 sparc_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
11646                         enum machine_mode mode, secondary_reload_info *sri)
11647 {
11648   enum reg_class rclass = (enum reg_class) rclass_i;
11649
11650   sri->icode = CODE_FOR_nothing;
11651   sri->extra_cost = 0;
11652
11653   /* We need a temporary when loading/storing a HImode/QImode value
11654      between memory and the FPU registers.  This can happen when combine puts
11655      a paradoxical subreg in a float/fix conversion insn.  */
11656   if (FP_REG_CLASS_P (rclass)
11657       && (mode == HImode || mode == QImode)
11658       && (GET_CODE (x) == MEM
11659           || ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
11660               && true_regnum (x) == -1)))
11661     return GENERAL_REGS;
11662
11663   /* On 32-bit we need a temporary when loading/storing a DFmode value
11664      between unaligned memory and the upper FPU registers.  */
11665   if (TARGET_ARCH32
11666       && rclass == EXTRA_FP_REGS
11667       && mode == DFmode
11668       && GET_CODE (x) == MEM
11669       && ! mem_min_alignment (x, 8))
11670     return FP_REGS;
11671
11672   if (((TARGET_CM_MEDANY
11673         && symbolic_operand (x, mode))
11674        || (TARGET_CM_EMBMEDANY
11675            && text_segment_operand (x, mode)))
11676       && ! flag_pic)
11677     {
11678       if (in_p)
11679         sri->icode = direct_optab_handler (reload_in_optab, mode);
11680       else
11681         sri->icode = direct_optab_handler (reload_out_optab, mode);
11682       return NO_REGS;
11683     }
11684
11685   if (TARGET_VIS3 && TARGET_ARCH32)
11686     {
11687       int regno = true_regnum (x);
11688
11689       /* When using VIS3 fp<-->int register moves, on 32-bit we have
11690          to move 8-byte values in 4-byte pieces.  This only works via
11691          FP_REGS, and not via EXTRA_FP_REGS.  Therefore if we try to
11692          move between EXTRA_FP_REGS and GENERAL_REGS, we will need
11693          an FP_REGS intermediate move.  */
11694       if ((rclass == EXTRA_FP_REGS && SPARC_INT_REG_P (regno))
11695           || ((general_or_i64_p (rclass)
11696                || rclass == GENERAL_OR_FP_REGS)
11697               && SPARC_FP_REG_P (regno)))
11698         {
11699           sri->extra_cost = 2;
11700           return FP_REGS;
11701         }
11702     }
11703
11704   return NO_REGS;
11705 }
11706
11707 /* Emit code to conditionally move either OPERANDS[2] or OPERANDS[3] into
11708    OPERANDS[0] in MODE.  OPERANDS[1] is the operator of the condition.  */
11709
11710 bool
11711 sparc_expand_conditional_move (enum machine_mode mode, rtx *operands)
11712 {
11713   enum rtx_code rc = GET_CODE (operands[1]);
11714   enum machine_mode cmp_mode;
11715   rtx cc_reg, dst, cmp;
11716
11717   cmp = operands[1];
11718   if (GET_MODE (XEXP (cmp, 0)) == DImode && !TARGET_ARCH64)
11719     return false;
11720
11721   if (GET_MODE (XEXP (cmp, 0)) == TFmode && !TARGET_HARD_QUAD)
11722     cmp = sparc_emit_float_lib_cmp (XEXP (cmp, 0), XEXP (cmp, 1), rc);
11723
11724   cmp_mode = GET_MODE (XEXP (cmp, 0));
11725   rc = GET_CODE (cmp);
11726
11727   dst = operands[0];
11728   if (! rtx_equal_p (operands[2], dst)
11729       && ! rtx_equal_p (operands[3], dst))
11730     {
11731       if (reg_overlap_mentioned_p (dst, cmp))
11732         dst = gen_reg_rtx (mode);
11733
11734       emit_move_insn (dst, operands[3]);
11735     }
11736   else if (operands[2] == dst)
11737     {
11738       operands[2] = operands[3];
11739
11740       if (GET_MODE_CLASS (cmp_mode) == MODE_FLOAT)
11741         rc = reverse_condition_maybe_unordered (rc);
11742       else
11743         rc = reverse_condition (rc);
11744     }
11745
11746   if (XEXP (cmp, 1) == const0_rtx
11747       && GET_CODE (XEXP (cmp, 0)) == REG
11748       && cmp_mode == DImode
11749       && v9_regcmp_p (rc))
11750     cc_reg = XEXP (cmp, 0);
11751   else
11752     cc_reg = gen_compare_reg_1 (rc, XEXP (cmp, 0), XEXP (cmp, 1));
11753
11754   cmp = gen_rtx_fmt_ee (rc, GET_MODE (cc_reg), cc_reg, const0_rtx);
11755
11756   emit_insn (gen_rtx_SET (VOIDmode, dst,
11757                           gen_rtx_IF_THEN_ELSE (mode, cmp, operands[2], dst)));
11758
11759   if (dst != operands[0])
11760     emit_move_insn (operands[0], dst);
11761
11762   return true;
11763 }
11764
11765 /* Emit code to conditionally move a combination of OPERANDS[1] and OPERANDS[2]
11766    into OPERANDS[0] in MODE, depending on the outcome of the comparison of
11767    OPERANDS[4] and OPERANDS[5].  OPERANDS[3] is the operator of the condition.
11768    FCODE is the machine code to be used for OPERANDS[3] and CCODE the machine
11769    code to be used for the condition mask.  */
11770
11771 void
11772 sparc_expand_vcond (enum machine_mode mode, rtx *operands, int ccode, int fcode)
11773 {
11774   rtx mask, cop0, cop1, fcmp, cmask, bshuf, gsr;
11775   enum rtx_code code = GET_CODE (operands[3]);
11776
11777   mask = gen_reg_rtx (Pmode);
11778   cop0 = operands[4];
11779   cop1 = operands[5];
11780   if (code == LT || code == GE)
11781     {
11782       rtx t;
11783
11784       code = swap_condition (code);
11785       t = cop0; cop0 = cop1; cop1 = t;
11786     }
11787
11788   gsr = gen_rtx_REG (DImode, SPARC_GSR_REG);
11789
11790   fcmp = gen_rtx_UNSPEC (Pmode,
11791                          gen_rtvec (1, gen_rtx_fmt_ee (code, mode, cop0, cop1)),
11792                          fcode);
11793
11794   cmask = gen_rtx_UNSPEC (DImode,
11795                           gen_rtvec (2, mask, gsr),
11796                           ccode);
11797
11798   bshuf = gen_rtx_UNSPEC (mode,
11799                           gen_rtvec (3, operands[1], operands[2], gsr),
11800                           UNSPEC_BSHUFFLE);
11801
11802   emit_insn (gen_rtx_SET (VOIDmode, mask, fcmp));
11803   emit_insn (gen_rtx_SET (VOIDmode, gsr, cmask));
11804
11805   emit_insn (gen_rtx_SET (VOIDmode, operands[0], bshuf));
11806 }
11807
11808 /* On sparc, any mode which naturally allocates into the float
11809    registers should return 4 here.  */
11810
11811 unsigned int
11812 sparc_regmode_natural_size (enum machine_mode mode)
11813 {
11814   int size = UNITS_PER_WORD;
11815
11816   if (TARGET_ARCH64)
11817     {
11818       enum mode_class mclass = GET_MODE_CLASS (mode);
11819
11820       if (mclass == MODE_FLOAT || mclass == MODE_VECTOR_INT)
11821         size = 4;
11822     }
11823
11824   return size;
11825 }
11826
11827 /* Return TRUE if it is a good idea to tie two pseudo registers
11828    when one has mode MODE1 and one has mode MODE2.
11829    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
11830    for any hard reg, then this must be FALSE for correct output.
11831
11832    For V9 we have to deal with the fact that only the lower 32 floating
11833    point registers are 32-bit addressable.  */
11834
11835 bool
11836 sparc_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
11837 {
11838   enum mode_class mclass1, mclass2;
11839   unsigned short size1, size2;
11840
11841   if (mode1 == mode2)
11842     return true;
11843
11844   mclass1 = GET_MODE_CLASS (mode1);
11845   mclass2 = GET_MODE_CLASS (mode2);
11846   if (mclass1 != mclass2)
11847     return false;
11848
11849   if (! TARGET_V9)
11850     return true;
11851
11852   /* Classes are the same and we are V9 so we have to deal with upper
11853      vs. lower floating point registers.  If one of the modes is a
11854      4-byte mode, and the other is not, we have to mark them as not
11855      tieable because only the lower 32 floating point register are
11856      addressable 32-bits at a time.
11857
11858      We can't just test explicitly for SFmode, otherwise we won't
11859      cover the vector mode cases properly.  */
11860
11861   if (mclass1 != MODE_FLOAT && mclass1 != MODE_VECTOR_INT)
11862     return true;
11863
11864   size1 = GET_MODE_SIZE (mode1);
11865   size2 = GET_MODE_SIZE (mode2);
11866   if ((size1 > 4 && size2 == 4)
11867       || (size2 > 4 && size1 == 4))
11868     return false;
11869
11870   return true;
11871 }
11872
11873 #include "gt-sparc.h"