gcc/config/sparc/sparc.c

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