gcc/config/sparc/sparc.c

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