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
4988             = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
4989         }
4990       else
4991         {
4992           rtx size_rtx = gen_rtx_REG (Pmode, 1);
4993           emit_move_insn (size_rtx, size_int_rtx);
4994           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
4995           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
4996                         gen_stack_pointer_inc (size_int_rtx));
4997         }
4998
4999       RTX_FRAME_RELATED_P (insn) = 1;
5000     }
5001   else
5002     {
5003       rtx size_int_rtx = GEN_INT (-size);
5004
5005       if (size <= 4096)
5006         emit_window_save (size_int_rtx);
5007       else if (size <= 8192)
5008         {
5009           emit_window_save (GEN_INT (-4096));
5010
5011
5012           /* %sp is not the CFA register anymore.  */
5013           emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
5014
5015           /* Make sure no %fp-based store is issued until after the frame is
5016              established.  The offset between the frame pointer and the stack
5017              pointer is calculated relative to the value of the stack pointer
5018              at the end of the function prologue, and moving instructions that
5019              access the stack via the frame pointer between the instructions
5020              that decrement the stack pointer could result in accessing the
5021              register window save area, which is volatile.  */
5022           emit_insn (gen_frame_blockage ());
5023         }
5024       else
5025         {
5026           rtx size_rtx = gen_rtx_REG (Pmode, 1);
5027           emit_move_insn (size_rtx, size_int_rtx);
5028           emit_window_save (size_rtx);
5029         }
5030     }
5031
5032   if (sparc_leaf_function_p)
5033     {
5034       sparc_frame_base_reg = stack_pointer_rtx;
5035       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
5036     }
5037   else
5038     {
5039       sparc_frame_base_reg = hard_frame_pointer_rtx;
5040       sparc_frame_base_offset = SPARC_STACK_BIAS;
5041     }
5042
5043   if (sparc_n_global_fp_regs > 0)
5044     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5045                                          sparc_frame_base_offset
5046                                            - sparc_apparent_frame_size,
5047                                          SORR_SAVE);
5048
5049   /* Load the GOT register if needed.  */
5050   if (crtl->uses_pic_offset_table)
5051     load_got_register ();
5052
5053   /* Advertise that the data calculated just above are now valid.  */
5054   sparc_prologue_data_valid_p = true;
5055 }
5056
5057 /* Expand the function prologue.  The prologue is responsible for reserving
5058    storage for the frame, saving the call-saved registers and loading the
5059    GOT register if needed.  */
5060
5061 void
5062 sparc_flat_expand_prologue (void)
5063 {
5064   HOST_WIDE_INT size;
5065   rtx insn;
5066
5067   sparc_leaf_function_p = optimize > 0 && current_function_is_leaf;
5068
5069   size = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
5070
5071   if (flag_stack_usage_info)
5072     current_function_static_stack_size = size;
5073
5074   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && size)
5075     sparc_emit_probe_stack_range (STACK_CHECK_PROTECT, size);
5076
5077   if (sparc_save_local_in_regs_p)
5078     emit_save_or_restore_local_in_regs (stack_pointer_rtx, SPARC_STACK_BIAS,
5079                                         SORR_SAVE);
5080
5081   if (size == 0)
5082     ; /* do nothing.  */
5083   else
5084     {
5085       rtx size_int_rtx, size_rtx;
5086
5087       size_rtx = size_int_rtx = GEN_INT (-size);
5088
5089       /* We establish the frame (i.e. decrement the stack pointer) first, even
5090          if we use a frame pointer, because we cannot clobber any call-saved
5091          registers, including the frame pointer, if we haven't created a new
5092          register save area, for the sake of compatibility with the ABI.  */
5093       if (size <= 4096)
5094         insn = emit_insn (gen_stack_pointer_inc (size_int_rtx));
5095       else if (size <= 8192 && !frame_pointer_needed)
5096         {
5097           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
5098           RTX_FRAME_RELATED_P (insn) = 1;
5099           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (4096 - size)));
5100         }
5101       else
5102         {
5103           size_rtx = gen_rtx_REG (Pmode, 1);
5104           emit_move_insn (size_rtx, size_int_rtx);
5105           insn = emit_insn (gen_stack_pointer_inc (size_rtx));
5106           add_reg_note (insn, REG_CFA_ADJUST_CFA,
5107                         gen_stack_pointer_inc (size_int_rtx));
5108         }
5109       RTX_FRAME_RELATED_P (insn) = 1;
5110
5111       /* Ensure nothing is scheduled until after the frame is established.  */
5112       emit_insn (gen_blockage ());
5113
5114       if (frame_pointer_needed)
5115         {
5116           insn = emit_insn (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
5117                                          gen_rtx_MINUS (Pmode,
5118                                                         stack_pointer_rtx,
5119                                                         size_rtx)));
5120           RTX_FRAME_RELATED_P (insn) = 1;
5121
5122           add_reg_note (insn, REG_CFA_ADJUST_CFA,
5123                         gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
5124                                      plus_constant (stack_pointer_rtx,
5125                                                     size)));
5126         }
5127
5128       if (return_addr_reg_needed_p (sparc_leaf_function_p))
5129         {
5130           rtx o7 = gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM);
5131           rtx i7 = gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM);
5132
5133           insn = emit_move_insn (i7, o7);
5134           RTX_FRAME_RELATED_P (insn) = 1;
5135
5136           add_reg_note (insn, REG_CFA_REGISTER,
5137                         gen_rtx_SET (VOIDmode, i7, o7));
5138
5139           /* Prevent this instruction from ever being considered dead,
5140              even if this function has no epilogue.  */
5141           emit_use (i7);
5142         }
5143     }
5144
5145   if (frame_pointer_needed)
5146     {
5147       sparc_frame_base_reg = hard_frame_pointer_rtx;
5148       sparc_frame_base_offset = SPARC_STACK_BIAS;
5149     }
5150   else
5151     {
5152       sparc_frame_base_reg = stack_pointer_rtx;
5153       sparc_frame_base_offset = size + SPARC_STACK_BIAS;
5154     }
5155
5156   if (sparc_n_global_fp_regs > 0)
5157     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5158                                          sparc_frame_base_offset
5159                                            - sparc_apparent_frame_size,
5160                                          SORR_SAVE);
5161
5162   /* Load the GOT register if needed.  */
5163   if (crtl->uses_pic_offset_table)
5164     load_got_register ();
5165
5166   /* Advertise that the data calculated just above are now valid.  */
5167   sparc_prologue_data_valid_p = true;
5168 }
5169
5170 /* This function generates the assembly code for function entry, which boils
5171    down to emitting the necessary .register directives.  */
5172
5173 static void
5174 sparc_asm_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
5175 {
5176   /* Check that the assumption we made in sparc_expand_prologue is valid.  */
5177   if (!TARGET_FLAT)
5178     gcc_assert (sparc_leaf_function_p == current_function_uses_only_leaf_regs);
5179
5180   sparc_output_scratch_registers (file);
5181 }
5182
5183 /* Expand the function epilogue, either normal or part of a sibcall.
5184    We emit all the instructions except the return or the call.  */
5185
5186 void
5187 sparc_expand_epilogue (bool for_eh)
5188 {
5189   HOST_WIDE_INT size = sparc_frame_size;
5190
5191   if (sparc_n_global_fp_regs > 0)
5192     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5193                                          sparc_frame_base_offset
5194                                            - sparc_apparent_frame_size,
5195                                          SORR_RESTORE);
5196
5197   if (size == 0 || for_eh)
5198     ; /* do nothing.  */
5199   else if (sparc_leaf_function_p)
5200     {
5201       if (size <= 4096)
5202         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
5203       else if (size <= 8192)
5204         {
5205           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
5206           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
5207         }
5208       else
5209         {
5210           rtx reg = gen_rtx_REG (Pmode, 1);
5211           emit_move_insn (reg, GEN_INT (-size));
5212           emit_insn (gen_stack_pointer_dec (reg));
5213         }
5214     }
5215 }
5216
5217 /* Expand the function epilogue, either normal or part of a sibcall.
5218    We emit all the instructions except the return or the call.  */
5219
5220 void
5221 sparc_flat_expand_epilogue (bool for_eh)
5222 {
5223   HOST_WIDE_INT size = sparc_frame_size;
5224
5225   if (sparc_n_global_fp_regs > 0)
5226     emit_save_or_restore_global_fp_regs (sparc_frame_base_reg,
5227                                          sparc_frame_base_offset
5228                                            - sparc_apparent_frame_size,
5229                                          SORR_RESTORE);
5230
5231   /* If we have a frame pointer, we'll need both to restore it before the
5232      frame is destroyed and use its current value in destroying the frame.
5233      Since we don't have an atomic way to do that in the flat window model,
5234      we save the current value into a temporary register (%g1).  */
5235   if (frame_pointer_needed && !for_eh)
5236     emit_move_insn (gen_rtx_REG (Pmode, 1), hard_frame_pointer_rtx);
5237
5238   if (return_addr_reg_needed_p (sparc_leaf_function_p))
5239     emit_move_insn (gen_rtx_REG (Pmode, INCOMING_RETURN_ADDR_REGNUM),
5240                     gen_rtx_REG (Pmode, RETURN_ADDR_REGNUM));
5241
5242   if (sparc_save_local_in_regs_p)
5243     emit_save_or_restore_local_in_regs (sparc_frame_base_reg,
5244                                         sparc_frame_base_offset,
5245                                         SORR_RESTORE);
5246
5247   if (size == 0 || for_eh)
5248     ; /* do nothing.  */
5249   else if (frame_pointer_needed)
5250     {
5251       /* Make sure the frame is destroyed after everything else is done.  */
5252       emit_insn (gen_blockage ());
5253
5254       emit_move_insn (stack_pointer_rtx, gen_rtx_REG (Pmode, 1));
5255     }
5256   else
5257     {
5258       /* Likewise.  */
5259       emit_insn (gen_blockage ());
5260
5261       if (size <= 4096)
5262         emit_insn (gen_stack_pointer_dec (GEN_INT (-size)));
5263       else if (size <= 8192)
5264         {
5265           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
5266           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - size)));
5267         }
5268       else
5269         {
5270           rtx reg = gen_rtx_REG (Pmode, 1);
5271           emit_move_insn (reg, GEN_INT (-size));
5272           emit_insn (gen_stack_pointer_dec (reg));
5273         }
5274     }
5275 }
5276
5277 /* Return true if it is appropriate to emit `return' instructions in the
5278    body of a function.  */
5279
5280 bool
5281 sparc_can_use_return_insn_p (void)
5282 {
5283   return sparc_prologue_data_valid_p
5284          && sparc_n_global_fp_regs == 0
5285          && TARGET_FLAT
5286             ? (sparc_frame_size == 0 && !sparc_save_local_in_regs_p)
5287             : (sparc_frame_size == 0 || !sparc_leaf_function_p);
5288 }
5289
5290 /* This function generates the assembly code for function exit.  */
5291
5292 static void
5293 sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
5294 {
5295   /* If the last two instructions of a function are "call foo; dslot;"
5296      the return address might point to the first instruction in the next
5297      function and we have to output a dummy nop for the sake of sane
5298      backtraces in such cases.  This is pointless for sibling calls since
5299      the return address is explicitly adjusted.  */
5300
5301   rtx insn, last_real_insn;
5302
5303   insn = get_last_insn ();
5304
5305   last_real_insn = prev_real_insn (insn);
5306   if (last_real_insn
5307       && GET_CODE (last_real_insn) == INSN
5308       && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE)
5309     last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0);
5310
5311   if (last_real_insn
5312       && CALL_P (last_real_insn)
5313       && !SIBLING_CALL_P (last_real_insn))
5314     fputs("\tnop\n", file);
5315
5316   sparc_output_deferred_case_vectors ();
5317 }
5318
5319 /* Output a 'restore' instruction.  */
5320
5321 static void
5322 output_restore (rtx pat)
5323 {
5324   rtx operands[3];
5325
5326   if (! pat)
5327     {
5328       fputs ("\t restore\n", asm_out_file);
5329       return;
5330     }
5331
5332   gcc_assert (GET_CODE (pat) == SET);
5333
5334   operands[0] = SET_DEST (pat);
5335   pat = SET_SRC (pat);
5336
5337   switch (GET_CODE (pat))
5338     {
5339       case PLUS:
5340         operands[1] = XEXP (pat, 0);
5341         operands[2] = XEXP (pat, 1);
5342         output_asm_insn (" restore %r1, %2, %Y0", operands);
5343         break;
5344       case LO_SUM:
5345         operands[1] = XEXP (pat, 0);
5346         operands[2] = XEXP (pat, 1);
5347         output_asm_insn (" restore %r1, %%lo(%a2), %Y0", operands);
5348         break;
5349       case ASHIFT:
5350         operands[1] = XEXP (pat, 0);
5351         gcc_assert (XEXP (pat, 1) == const1_rtx);
5352         output_asm_insn (" restore %r1, %r1, %Y0", operands);
5353         break;
5354       default:
5355         operands[1] = pat;
5356         output_asm_insn (" restore %%g0, %1, %Y0", operands);
5357         break;
5358     }
5359 }
5360
5361 /* Output a return.  */
5362
5363 const char *
5364 output_return (rtx insn)
5365 {
5366   if (crtl->calls_eh_return)
5367     {
5368       /* If the function uses __builtin_eh_return, the eh_return
5369          machinery occupies the delay slot.  */
5370       gcc_assert (!final_sequence);
5371
5372       if (flag_delayed_branch)
5373         {
5374           if (!TARGET_FLAT && TARGET_V9)
5375             fputs ("\treturn\t%i7+8\n", asm_out_file);
5376           else
5377             {
5378               if (!TARGET_FLAT)
5379                 fputs ("\trestore\n", asm_out_file);
5380
5381               fputs ("\tjmp\t%o7+8\n", asm_out_file);
5382             }
5383
5384           fputs ("\t add\t%sp, %g1, %sp\n", asm_out_file);
5385         }
5386       else
5387         {
5388           if (!TARGET_FLAT)
5389             fputs ("\trestore\n", asm_out_file);
5390
5391           fputs ("\tadd\t%sp, %g1, %sp\n", asm_out_file);
5392           fputs ("\tjmp\t%o7+8\n\t nop\n", asm_out_file);
5393         }
5394     }
5395   else if (sparc_leaf_function_p || TARGET_FLAT)
5396     {
5397       /* This is a leaf or flat function so we don't have to bother restoring
5398          the register window, which frees us from dealing with the convoluted
5399          semantics of restore/return.  We simply output the jump to the
5400          return address and the insn in the delay slot (if any).  */
5401
5402       return "jmp\t%%o7+%)%#";
5403     }
5404   else
5405     {
5406       /* This is a regular function so we have to restore the register window.
5407          We may have a pending insn for the delay slot, which will be either
5408          combined with the 'restore' instruction or put in the delay slot of
5409          the 'return' instruction.  */
5410
5411       if (final_sequence)
5412         {
5413           rtx delay, pat;
5414
5415           delay = NEXT_INSN (insn);
5416           gcc_assert (delay);
5417
5418           pat = PATTERN (delay);
5419
5420           if (TARGET_V9 && ! epilogue_renumber (&pat, 1))
5421             {
5422               epilogue_renumber (&pat, 0);
5423               return "return\t%%i7+%)%#";
5424             }
5425           else
5426             {
5427               output_asm_insn ("jmp\t%%i7+%)", NULL);
5428               output_restore (pat);
5429               PATTERN (delay) = gen_blockage ();
5430               INSN_CODE (delay) = -1;
5431             }
5432         }
5433       else
5434         {
5435           /* The delay slot is empty.  */
5436           if (TARGET_V9)
5437             return "return\t%%i7+%)\n\t nop";
5438           else if (flag_delayed_branch)
5439             return "jmp\t%%i7+%)\n\t restore";
5440           else
5441             return "restore\n\tjmp\t%%o7+%)\n\t nop";
5442         }
5443     }
5444
5445   return "";
5446 }
5447
5448 /* Output a sibling call.  */
5449
5450 const char *
5451 output_sibcall (rtx insn, rtx call_operand)
5452 {
5453   rtx operands[1];
5454
5455   gcc_assert (flag_delayed_branch);
5456
5457   operands[0] = call_operand;
5458
5459   if (sparc_leaf_function_p || TARGET_FLAT)
5460     {
5461       /* This is a leaf or flat function so we don't have to bother restoring
5462          the register window.  We simply output the jump to the function and
5463          the insn in the delay slot (if any).  */
5464
5465       gcc_assert (!(LEAF_SIBCALL_SLOT_RESERVED_P && final_sequence));
5466
5467       if (final_sequence)
5468         output_asm_insn ("sethi\t%%hi(%a0), %%g1\n\tjmp\t%%g1 + %%lo(%a0)%#",
5469                          operands);
5470       else
5471         /* Use or with rs2 %%g0 instead of mov, so that as/ld can optimize
5472            it into branch if possible.  */
5473         output_asm_insn ("or\t%%o7, %%g0, %%g1\n\tcall\t%a0, 0\n\t or\t%%g1, %%g0, %%o7",
5474                          operands);
5475     }
5476   else
5477     {
5478       /* This is a regular function so we have to restore the register window.
5479          We may have a pending insn for the delay slot, which will be combined
5480          with the 'restore' instruction.  */
5481
5482       output_asm_insn ("call\t%a0, 0", operands);
5483
5484       if (final_sequence)
5485         {
5486           rtx delay = NEXT_INSN (insn);
5487           gcc_assert (delay);
5488
5489           output_restore (PATTERN (delay));
5490
5491           PATTERN (delay) = gen_blockage ();
5492           INSN_CODE (delay) = -1;
5493         }
5494       else
5495         output_restore (NULL_RTX);
5496     }
5497
5498   return "";
5499 }
5500 \f
5501 /* Functions for handling argument passing.
5502
5503    For 32-bit, the first 6 args are normally in registers and the rest are
5504    pushed.  Any arg that starts within the first 6 words is at least
5505    partially passed in a register unless its data type forbids.
5506
5507    For 64-bit, the argument registers are laid out as an array of 16 elements
5508    and arguments are added sequentially.  The first 6 int args and up to the
5509    first 16 fp args (depending on size) are passed in regs.
5510
5511    Slot    Stack   Integral   Float   Float in structure   Double   Long Double
5512    ----    -----   --------   -----   ------------------   ------   -----------
5513     15   [SP+248]              %f31       %f30,%f31         %d30
5514     14   [SP+240]              %f29       %f28,%f29         %d28       %q28
5515     13   [SP+232]              %f27       %f26,%f27         %d26
5516     12   [SP+224]              %f25       %f24,%f25         %d24       %q24
5517     11   [SP+216]              %f23       %f22,%f23         %d22
5518     10   [SP+208]              %f21       %f20,%f21         %d20       %q20
5519      9   [SP+200]              %f19       %f18,%f19         %d18
5520      8   [SP+192]              %f17       %f16,%f17         %d16       %q16
5521      7   [SP+184]              %f15       %f14,%f15         %d14
5522      6   [SP+176]              %f13       %f12,%f13         %d12       %q12
5523      5   [SP+168]     %o5      %f11       %f10,%f11         %d10
5524      4   [SP+160]     %o4       %f9        %f8,%f9           %d8        %q8
5525      3   [SP+152]     %o3       %f7        %f6,%f7           %d6
5526      2   [SP+144]     %o2       %f5        %f4,%f5           %d4        %q4
5527      1   [SP+136]     %o1       %f3        %f2,%f3           %d2
5528      0   [SP+128]     %o0       %f1        %f0,%f1           %d0        %q0
5529
5530    Here SP = %sp if -mno-stack-bias or %sp+stack_bias otherwise.
5531
5532    Integral arguments are always passed as 64-bit quantities appropriately
5533    extended.
5534
5535    Passing of floating point values is handled as follows.
5536    If a prototype is in scope:
5537      If the value is in a named argument (i.e. not a stdarg function or a
5538      value not part of the `...') then the value is passed in the appropriate
5539      fp reg.
5540      If the value is part of the `...' and is passed in one of the first 6
5541      slots then the value is passed in the appropriate int reg.
5542      If the value is part of the `...' and is not passed in one of the first 6
5543      slots then the value is passed in memory.
5544    If a prototype is not in scope:
5545      If the value is one of the first 6 arguments the value is passed in the
5546      appropriate integer reg and the appropriate fp reg.
5547      If the value is not one of the first 6 arguments the value is passed in
5548      the appropriate fp reg and in memory.
5549
5550
5551    Summary of the calling conventions implemented by GCC on the SPARC:
5552
5553    32-bit ABI:
5554                                 size      argument     return value
5555
5556       small integer              <4       int. reg.      int. reg.
5557       word                        4       int. reg.      int. reg.
5558       double word                 8       int. reg.      int. reg.
5559
5560       _Complex small integer     <8       int. reg.      int. reg.
5561       _Complex word               8       int. reg.      int. reg.
5562       _Complex double word       16        memory        int. reg.
5563
5564       vector integer            <=8       int. reg.       FP reg.
5565       vector integer             >8        memory         memory
5566
5567       float                       4       int. reg.       FP reg.
5568       double                      8       int. reg.       FP reg.
5569       long double                16        memory         memory
5570
5571       _Complex float              8        memory         FP reg.
5572       _Complex double            16        memory         FP reg.
5573       _Complex long double       32        memory         FP reg.
5574
5575       vector float              any        memory         memory
5576
5577       aggregate                 any        memory         memory
5578
5579
5580
5581     64-bit ABI:
5582                                 size      argument     return value
5583
5584       small integer              <8       int. reg.      int. reg.
5585       word                        8       int. reg.      int. reg.
5586       double word                16       int. reg.      int. reg.
5587
5588       _Complex small integer    <16       int. reg.      int. reg.
5589       _Complex word              16       int. reg.      int. reg.
5590       _Complex double word       32        memory        int. reg.
5591
5592       vector integer           <=16        FP reg.        FP reg.
5593       vector integer       16<s<=32        memory         FP reg.
5594       vector integer            >32        memory         memory
5595
5596       float                       4        FP reg.        FP reg.
5597       double                      8        FP reg.        FP reg.
5598       long double                16        FP reg.        FP reg.
5599
5600       _Complex float              8        FP reg.        FP reg.
5601       _Complex double            16        FP reg.        FP reg.
5602       _Complex long double       32        memory         FP reg.
5603
5604       vector float             <=16        FP reg.        FP reg.
5605       vector float         16<s<=32        memory         FP reg.
5606       vector float              >32        memory         memory
5607
5608       aggregate                <=16         reg.           reg.
5609       aggregate            16<s<=32        memory          reg.
5610       aggregate                 >32        memory         memory
5611
5612
5613
5614 Note #1: complex floating-point types follow the extended SPARC ABIs as
5615 implemented by the Sun compiler.
5616
5617 Note #2: integral vector types follow the scalar floating-point types
5618 conventions to match what is implemented by the Sun VIS SDK.
5619
5620 Note #3: floating-point vector types follow the aggregate types
5621 conventions.  */
5622
5623
5624 /* Maximum number of int regs for args.  */
5625 #define SPARC_INT_ARG_MAX 6
5626 /* Maximum number of fp regs for args.  */
5627 #define SPARC_FP_ARG_MAX 16
5628
5629 #define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
5630
5631 /* Handle the INIT_CUMULATIVE_ARGS macro.
5632    Initialize a variable CUM of type CUMULATIVE_ARGS
5633    for a call to a function whose data type is FNTYPE.
5634    For a library call, FNTYPE is 0.  */
5635
5636 void
5637 init_cumulative_args (struct sparc_args *cum, tree fntype,
5638                       rtx libname ATTRIBUTE_UNUSED,
5639                       tree fndecl ATTRIBUTE_UNUSED)
5640 {
5641   cum->words = 0;
5642   cum->prototype_p = fntype && prototype_p (fntype);
5643   cum->libcall_p = fntype == 0;
5644 }
5645
5646 /* Handle promotion of pointer and integer arguments.  */
5647
5648 static enum machine_mode
5649 sparc_promote_function_mode (const_tree type,
5650                              enum machine_mode mode,
5651                              int *punsignedp,
5652                              const_tree fntype ATTRIBUTE_UNUSED,
5653                              int for_return ATTRIBUTE_UNUSED)
5654 {
5655   if (type != NULL_TREE && POINTER_TYPE_P (type))
5656     {
5657       *punsignedp = POINTERS_EXTEND_UNSIGNED;
5658       return Pmode;
5659     }
5660
5661   /* Integral arguments are passed as full words, as per the ABI.  */
5662   if (GET_MODE_CLASS (mode) == MODE_INT
5663       && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
5664     return word_mode;
5665
5666   return mode;
5667 }
5668
5669 /* Handle the TARGET_STRICT_ARGUMENT_NAMING target hook.  */
5670
5671 static bool
5672 sparc_strict_argument_naming (cumulative_args_t ca ATTRIBUTE_UNUSED)
5673 {
5674   return TARGET_ARCH64 ? true : false;
5675 }
5676
5677 /* Scan the record type TYPE and return the following predicates:
5678     - INTREGS_P: the record contains at least one field or sub-field
5679       that is eligible for promotion in integer registers.
5680     - FP_REGS_P: the record contains at least one field or sub-field
5681       that is eligible for promotion in floating-point registers.
5682     - PACKED_P: the record contains at least one field that is packed.
5683
5684    Sub-fields are not taken into account for the PACKED_P predicate.  */
5685
5686 static void
5687 scan_record_type (const_tree type, int *intregs_p, int *fpregs_p,
5688                   int *packed_p)
5689 {
5690   tree field;
5691
5692   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5693     {
5694       if (TREE_CODE (field) == FIELD_DECL)
5695         {
5696           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5697             scan_record_type (TREE_TYPE (field), intregs_p, fpregs_p, 0);
5698           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5699                    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5700                   && TARGET_FPU)
5701             *fpregs_p = 1;
5702           else
5703             *intregs_p = 1;
5704
5705           if (packed_p && DECL_PACKED (field))
5706             *packed_p = 1;
5707         }
5708     }
5709 }
5710
5711 /* Compute the slot number to pass an argument in.
5712    Return the slot number or -1 if passing on the stack.
5713
5714    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5715     the preceding args and about the function being called.
5716    MODE is the argument's machine mode.
5717    TYPE is the data type of the argument (as a tree).
5718     This is null for libcalls where that information may
5719     not be available.
5720    NAMED is nonzero if this argument is a named parameter
5721     (otherwise it is an extra parameter matching an ellipsis).
5722    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
5723    *PREGNO records the register number to use if scalar type.
5724    *PPADDING records the amount of padding needed in words.  */
5725
5726 static int
5727 function_arg_slotno (const struct sparc_args *cum, enum machine_mode mode,
5728                      const_tree type, bool named, bool incoming_p,
5729                      int *pregno, int *ppadding)
5730 {
5731   int regbase = (incoming_p
5732                  ? SPARC_INCOMING_INT_ARG_FIRST
5733                  : SPARC_OUTGOING_INT_ARG_FIRST);
5734   int slotno = cum->words;
5735   enum mode_class mclass;
5736   int regno;
5737
5738   *ppadding = 0;
5739
5740   if (type && TREE_ADDRESSABLE (type))
5741     return -1;
5742
5743   if (TARGET_ARCH32
5744       && mode == BLKmode
5745       && type
5746       && TYPE_ALIGN (type) % PARM_BOUNDARY != 0)
5747     return -1;
5748
5749   /* For SPARC64, objects requiring 16-byte alignment get it.  */
5750   if (TARGET_ARCH64
5751       && (type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode)) >= 128
5752       && (slotno & 1) != 0)
5753     slotno++, *ppadding = 1;
5754
5755   mclass = GET_MODE_CLASS (mode);
5756   if (type && TREE_CODE (type) == VECTOR_TYPE)
5757     {
5758       /* Vector types deserve special treatment because they are
5759          polymorphic wrt their mode, depending upon whether VIS
5760          instructions are enabled.  */
5761       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
5762         {
5763           /* The SPARC port defines no floating-point vector modes.  */
5764           gcc_assert (mode == BLKmode);
5765         }
5766       else
5767         {
5768           /* Integral vector types should either have a vector
5769              mode or an integral mode, because we are guaranteed
5770              by pass_by_reference that their size is not greater
5771              than 16 bytes and TImode is 16-byte wide.  */
5772           gcc_assert (mode != BLKmode);
5773
5774           /* Vector integers are handled like floats according to
5775              the Sun VIS SDK.  */
5776           mclass = MODE_FLOAT;
5777         }
5778     }
5779
5780   switch (mclass)
5781     {
5782     case MODE_FLOAT:
5783     case MODE_COMPLEX_FLOAT:
5784     case MODE_VECTOR_INT:
5785       if (TARGET_ARCH64 && TARGET_FPU && named)
5786         {
5787           if (slotno >= SPARC_FP_ARG_MAX)
5788             return -1;
5789           regno = SPARC_FP_ARG_FIRST + slotno * 2;
5790           /* Arguments filling only one single FP register are
5791              right-justified in the outer double FP register.  */
5792           if (GET_MODE_SIZE (mode) <= 4)
5793             regno++;
5794           break;
5795         }
5796       /* fallthrough */
5797
5798     case MODE_INT:
5799     case MODE_COMPLEX_INT:
5800       if (slotno >= SPARC_INT_ARG_MAX)
5801         return -1;
5802       regno = regbase + slotno;
5803       break;
5804
5805     case MODE_RANDOM:
5806       if (mode == VOIDmode)
5807         /* MODE is VOIDmode when generating the actual call.  */
5808         return -1;
5809
5810       gcc_assert (mode == BLKmode);
5811
5812       if (TARGET_ARCH32
5813           || !type
5814           || (TREE_CODE (type) != VECTOR_TYPE
5815               && TREE_CODE (type) != RECORD_TYPE))
5816         {
5817           if (slotno >= SPARC_INT_ARG_MAX)
5818             return -1;
5819           regno = regbase + slotno;
5820         }
5821       else  /* TARGET_ARCH64 && type */
5822         {
5823           int intregs_p = 0, fpregs_p = 0, packed_p = 0;
5824
5825           /* First see what kinds of registers we would need.  */
5826           if (TREE_CODE (type) == VECTOR_TYPE)
5827             fpregs_p = 1;
5828           else
5829             scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
5830
5831           /* The ABI obviously doesn't specify how packed structures
5832              are passed.  These are defined to be passed in int regs
5833              if possible, otherwise memory.  */
5834           if (packed_p || !named)
5835             fpregs_p = 0, intregs_p = 1;
5836
5837           /* If all arg slots are filled, then must pass on stack.  */
5838           if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
5839             return -1;
5840
5841           /* If there are only int args and all int arg slots are filled,
5842              then must pass on stack.  */
5843           if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
5844             return -1;
5845
5846           /* Note that even if all int arg slots are filled, fp members may
5847              still be passed in regs if such regs are available.
5848              *PREGNO isn't set because there may be more than one, it's up
5849              to the caller to compute them.  */
5850           return slotno;
5851         }
5852       break;
5853
5854     default :
5855       gcc_unreachable ();
5856     }
5857
5858   *pregno = regno;
5859   return slotno;
5860 }
5861
5862 /* Handle recursive register counting for structure field layout.  */
5863
5864 struct function_arg_record_value_parms
5865 {
5866   rtx ret;              /* return expression being built.  */
5867   int slotno;           /* slot number of the argument.  */
5868   int named;            /* whether the argument is named.  */
5869   int regbase;          /* regno of the base register.  */
5870   int stack;            /* 1 if part of the argument is on the stack.  */
5871   int intoffset;        /* offset of the first pending integer field.  */
5872   unsigned int nregs;   /* number of words passed in registers.  */
5873 };
5874
5875 static void function_arg_record_value_3
5876  (HOST_WIDE_INT, struct function_arg_record_value_parms *);
5877 static void function_arg_record_value_2
5878  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5879 static void function_arg_record_value_1
5880  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
5881 static rtx function_arg_record_value (const_tree, enum machine_mode, int, int, int);
5882 static rtx function_arg_union_value (int, enum machine_mode, int, int);
5883
5884 /* A subroutine of function_arg_record_value.  Traverse the structure
5885    recursively and determine how many registers will be required.  */
5886
5887 static void
5888 function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos,
5889                              struct function_arg_record_value_parms *parms,
5890                              bool packed_p)
5891 {
5892   tree field;
5893
5894   /* We need to compute how many registers are needed so we can
5895      allocate the PARALLEL but before we can do that we need to know
5896      whether there are any packed fields.  The ABI obviously doesn't
5897      specify how structures are passed in this case, so they are
5898      defined to be passed in int regs if possible, otherwise memory,
5899      regardless of whether there are fp values present.  */
5900
5901   if (! packed_p)
5902     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5903       {
5904         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5905           {
5906             packed_p = true;
5907             break;
5908           }
5909       }
5910
5911   /* Compute how many registers we need.  */
5912   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5913     {
5914       if (TREE_CODE (field) == FIELD_DECL)
5915         {
5916           HOST_WIDE_INT bitpos = startbitpos;
5917
5918           if (DECL_SIZE (field) != 0)
5919             {
5920               if (integer_zerop (DECL_SIZE (field)))
5921                 continue;
5922
5923               if (host_integerp (bit_position (field), 1))
5924                 bitpos += int_bit_position (field);
5925             }
5926
5927           /* ??? FIXME: else assume zero offset.  */
5928
5929           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5930             function_arg_record_value_1 (TREE_TYPE (field),
5931                                          bitpos,
5932                                          parms,
5933                                          packed_p);
5934           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5935                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5936                    && TARGET_FPU
5937                    && parms->named
5938                    && ! packed_p)
5939             {
5940               if (parms->intoffset != -1)
5941                 {
5942                   unsigned int startbit, endbit;
5943                   int intslots, this_slotno;
5944
5945                   startbit = parms->intoffset & -BITS_PER_WORD;
5946                   endbit   = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5947
5948                   intslots = (endbit - startbit) / BITS_PER_WORD;
5949                   this_slotno = parms->slotno + parms->intoffset
5950                     / BITS_PER_WORD;
5951
5952                   if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5953                     {
5954                       intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5955                       /* We need to pass this field on the stack.  */
5956                       parms->stack = 1;
5957                     }
5958
5959                   parms->nregs += intslots;
5960                   parms->intoffset = -1;
5961                 }
5962
5963               /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
5964                  If it wasn't true we wouldn't be here.  */
5965               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5966                   && DECL_MODE (field) == BLKmode)
5967                 parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5968               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5969                 parms->nregs += 2;
5970               else
5971                 parms->nregs += 1;
5972             }
5973           else
5974             {
5975               if (parms->intoffset == -1)
5976                 parms->intoffset = bitpos;
5977             }
5978         }
5979     }
5980 }
5981
5982 /* A subroutine of function_arg_record_value.  Assign the bits of the
5983    structure between parms->intoffset and bitpos to integer registers.  */
5984
5985 static void
5986 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
5987                              struct function_arg_record_value_parms *parms)
5988 {
5989   enum machine_mode mode;
5990   unsigned int regno;
5991   unsigned int startbit, endbit;
5992   int this_slotno, intslots, intoffset;
5993   rtx reg;
5994
5995   if (parms->intoffset == -1)
5996     return;
5997
5998   intoffset = parms->intoffset;
5999   parms->intoffset = -1;
6000
6001   startbit = intoffset & -BITS_PER_WORD;
6002   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
6003   intslots = (endbit - startbit) / BITS_PER_WORD;
6004   this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
6005
6006   intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
6007   if (intslots <= 0)
6008     return;
6009
6010   /* If this is the trailing part of a word, only load that much into
6011      the register.  Otherwise load the whole register.  Note that in
6012      the latter case we may pick up unwanted bits.  It's not a problem
6013      at the moment but may wish to revisit.  */
6014
6015   if (intoffset % BITS_PER_WORD != 0)
6016     mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
6017                                    MODE_INT);
6018   else
6019     mode = word_mode;
6020
6021   intoffset /= BITS_PER_UNIT;
6022   do
6023     {
6024       regno = parms->regbase + this_slotno;
6025       reg = gen_rtx_REG (mode, regno);
6026       XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6027         = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
6028
6029       this_slotno += 1;
6030       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
6031       mode = word_mode;
6032       parms->nregs += 1;
6033       intslots -= 1;
6034     }
6035   while (intslots > 0);
6036 }
6037
6038 /* A subroutine of function_arg_record_value.  Traverse the structure
6039    recursively and assign bits to floating point registers.  Track which
6040    bits in between need integer registers; invoke function_arg_record_value_3
6041    to make that happen.  */
6042
6043 static void
6044 function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
6045                              struct function_arg_record_value_parms *parms,
6046                              bool packed_p)
6047 {
6048   tree field;
6049
6050   if (! packed_p)
6051     for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6052       {
6053         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
6054           {
6055             packed_p = true;
6056             break;
6057           }
6058       }
6059
6060   for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
6061     {
6062       if (TREE_CODE (field) == FIELD_DECL)
6063         {
6064           HOST_WIDE_INT bitpos = startbitpos;
6065
6066           if (DECL_SIZE (field) != 0)
6067             {
6068               if (integer_zerop (DECL_SIZE (field)))
6069                 continue;
6070
6071               if (host_integerp (bit_position (field), 1))
6072                 bitpos += int_bit_position (field);
6073             }
6074
6075           /* ??? FIXME: else assume zero offset.  */
6076
6077           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
6078             function_arg_record_value_2 (TREE_TYPE (field),
6079                                          bitpos,
6080                                          parms,
6081                                          packed_p);
6082           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
6083                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
6084                    && TARGET_FPU
6085                    && parms->named
6086                    && ! packed_p)
6087             {
6088               int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
6089               int regno, nregs, pos;
6090               enum machine_mode mode = DECL_MODE (field);
6091               rtx reg;
6092
6093               function_arg_record_value_3 (bitpos, parms);
6094
6095               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
6096                   && mode == BLKmode)
6097                 {
6098                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
6099                   nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
6100                 }
6101               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
6102                 {
6103                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
6104                   nregs = 2;
6105                 }
6106               else
6107                 nregs = 1;
6108
6109               regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
6110               if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
6111                 regno++;
6112               reg = gen_rtx_REG (mode, regno);
6113               pos = bitpos / BITS_PER_UNIT;
6114               XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6115                 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
6116               parms->nregs += 1;
6117               while (--nregs > 0)
6118                 {
6119                   regno += GET_MODE_SIZE (mode) / 4;
6120                   reg = gen_rtx_REG (mode, regno);
6121                   pos += GET_MODE_SIZE (mode);
6122                   XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
6123                     = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
6124                   parms->nregs += 1;
6125                 }
6126             }
6127           else
6128             {
6129               if (parms->intoffset == -1)
6130                 parms->intoffset = bitpos;
6131             }
6132         }
6133     }
6134 }
6135
6136 /* Used by function_arg and sparc_function_value_1 to implement the complex
6137    conventions of the 64-bit ABI for passing and returning structures.
6138    Return an expression valid as a return value for the FUNCTION_ARG
6139    and TARGET_FUNCTION_VALUE.
6140
6141    TYPE is the data type of the argument (as a tree).
6142     This is null for libcalls where that information may
6143     not be available.
6144    MODE is the argument's machine mode.
6145    SLOTNO is the index number of the argument's slot in the parameter array.
6146    NAMED is nonzero if this argument is a named parameter
6147     (otherwise it is an extra parameter matching an ellipsis).
6148    REGBASE is the regno of the base register for the parameter array.  */
6149
6150 static rtx
6151 function_arg_record_value (const_tree type, enum machine_mode mode,
6152                            int slotno, int named, int regbase)
6153 {
6154   HOST_WIDE_INT typesize = int_size_in_bytes (type);
6155   struct function_arg_record_value_parms parms;
6156   unsigned int nregs;
6157
6158   parms.ret = NULL_RTX;
6159   parms.slotno = slotno;
6160   parms.named = named;
6161   parms.regbase = regbase;
6162   parms.stack = 0;
6163
6164   /* Compute how many registers we need.  */
6165   parms.nregs = 0;
6166   parms.intoffset = 0;
6167   function_arg_record_value_1 (type, 0, &parms, false);
6168
6169   /* Take into account pending integer fields.  */
6170   if (parms.intoffset != -1)
6171     {
6172       unsigned int startbit, endbit;
6173       int intslots, this_slotno;
6174
6175       startbit = parms.intoffset & -BITS_PER_WORD;
6176       endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
6177       intslots = (endbit - startbit) / BITS_PER_WORD;
6178       this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
6179
6180       if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
6181         {
6182           intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
6183           /* We need to pass this field on the stack.  */
6184           parms.stack = 1;
6185         }
6186
6187       parms.nregs += intslots;
6188     }
6189   nregs = parms.nregs;
6190
6191   /* Allocate the vector and handle some annoying special cases.  */
6192   if (nregs == 0)
6193     {
6194       /* ??? Empty structure has no value?  Duh?  */
6195       if (typesize <= 0)
6196         {
6197           /* Though there's nothing really to store, return a word register
6198              anyway so the rest of gcc doesn't go nuts.  Returning a PARALLEL
6199              leads to breakage due to the fact that there are zero bytes to
6200              load.  */
6201           return gen_rtx_REG (mode, regbase);
6202         }
6203       else
6204         {
6205           /* ??? C++ has structures with no fields, and yet a size.  Give up
6206              for now and pass everything back in integer registers.  */
6207           nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
6208         }
6209       if (nregs + slotno > SPARC_INT_ARG_MAX)
6210         nregs = SPARC_INT_ARG_MAX - slotno;
6211     }
6212   gcc_assert (nregs != 0);
6213
6214   parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
6215
6216   /* If at least one field must be passed on the stack, generate
6217      (parallel [(expr_list (nil) ...) ...]) so that all fields will
6218      also be passed on the stack.  We can't do much better because the
6219      semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
6220      of structures for which the fields passed exclusively in registers
6221      are not at the beginning of the structure.  */
6222   if (parms.stack)
6223     XVECEXP (parms.ret, 0, 0)
6224       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6225
6226   /* Fill in the entries.  */
6227   parms.nregs = 0;
6228   parms.intoffset = 0;
6229   function_arg_record_value_2 (type, 0, &parms, false);
6230   function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
6231
6232   gcc_assert (parms.nregs == nregs);
6233
6234   return parms.ret;
6235 }
6236
6237 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6238    of the 64-bit ABI for passing and returning unions.
6239    Return an expression valid as a return value for the FUNCTION_ARG
6240    and TARGET_FUNCTION_VALUE.
6241
6242    SIZE is the size in bytes of the union.
6243    MODE is the argument's machine mode.
6244    REGNO is the hard register the union will be passed in.  */
6245
6246 static rtx
6247 function_arg_union_value (int size, enum machine_mode mode, int slotno,
6248                           int regno)
6249 {
6250   int nwords = ROUND_ADVANCE (size), i;
6251   rtx regs;
6252
6253   /* See comment in previous function for empty structures.  */
6254   if (nwords == 0)
6255     return gen_rtx_REG (mode, regno);
6256
6257   if (slotno == SPARC_INT_ARG_MAX - 1)
6258     nwords = 1;
6259
6260   regs = gen_rtx_PARALLEL (mode, rtvec_alloc (nwords));
6261
6262   for (i = 0; i < nwords; i++)
6263     {
6264       /* Unions are passed left-justified.  */
6265       XVECEXP (regs, 0, i)
6266         = gen_rtx_EXPR_LIST (VOIDmode,
6267                              gen_rtx_REG (word_mode, regno),
6268                              GEN_INT (UNITS_PER_WORD * i));
6269       regno++;
6270     }
6271
6272   return regs;
6273 }
6274
6275 /* Used by function_arg and sparc_function_value_1 to implement the conventions
6276    for passing and returning large (BLKmode) vectors.
6277    Return an expression valid as a return value for the FUNCTION_ARG
6278    and TARGET_FUNCTION_VALUE.
6279
6280    SIZE is the size in bytes of the vector (at least 8 bytes).
6281    REGNO is the FP hard register the vector will be passed in.  */
6282
6283 static rtx
6284 function_arg_vector_value (int size, int regno)
6285 {
6286   int i, nregs = size / 8;
6287   rtx regs;
6288
6289   regs = gen_rtx_PARALLEL (BLKmode, rtvec_alloc (nregs));
6290
6291   for (i = 0; i < nregs; i++)
6292     {
6293       XVECEXP (regs, 0, i)
6294         = gen_rtx_EXPR_LIST (VOIDmode,
6295                              gen_rtx_REG (DImode, regno + 2*i),
6296                              GEN_INT (i*8));
6297     }
6298
6299   return regs;
6300 }
6301
6302 /* Determine where to put an argument to a function.
6303    Value is zero to push the argument on the stack,
6304    or a hard register in which to store the argument.
6305
6306    CUM is a variable of type CUMULATIVE_ARGS which gives info about
6307     the preceding args and about the function being called.
6308    MODE is the argument's machine mode.
6309    TYPE is the data type of the argument (as a tree).
6310     This is null for libcalls where that information may
6311     not be available.
6312    NAMED is true if this argument is a named parameter
6313     (otherwise it is an extra parameter matching an ellipsis).
6314    INCOMING_P is false for TARGET_FUNCTION_ARG, true for
6315     TARGET_FUNCTION_INCOMING_ARG.  */
6316
6317 static rtx
6318 sparc_function_arg_1 (cumulative_args_t cum_v, enum machine_mode mode,
6319                       const_tree type, bool named, bool incoming_p)
6320 {
6321   const CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6322
6323   int regbase = (incoming_p
6324                  ? SPARC_INCOMING_INT_ARG_FIRST
6325                  : SPARC_OUTGOING_INT_ARG_FIRST);
6326   int slotno, regno, padding;
6327   enum mode_class mclass = GET_MODE_CLASS (mode);
6328
6329   slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
6330                                 &regno, &padding);
6331   if (slotno == -1)
6332     return 0;
6333
6334   /* Vector types deserve special treatment because they are polymorphic wrt
6335      their mode, depending upon whether VIS instructions are enabled.  */
6336   if (type && TREE_CODE (type) == VECTOR_TYPE)
6337     {
6338       HOST_WIDE_INT size = int_size_in_bytes (type);
6339       gcc_assert ((TARGET_ARCH32 && size <= 8)
6340                   || (TARGET_ARCH64 && size <= 16));
6341
6342       if (mode == BLKmode)
6343         return function_arg_vector_value (size,
6344                                           SPARC_FP_ARG_FIRST + 2*slotno);
6345       else
6346         mclass = MODE_FLOAT;
6347     }
6348
6349   if (TARGET_ARCH32)
6350     return gen_rtx_REG (mode, regno);
6351
6352   /* Structures up to 16 bytes in size are passed in arg slots on the stack
6353      and are promoted to registers if possible.  */
6354   if (type && TREE_CODE (type) == RECORD_TYPE)
6355     {
6356       HOST_WIDE_INT size = int_size_in_bytes (type);
6357       gcc_assert (size <= 16);
6358
6359       return function_arg_record_value (type, mode, slotno, named, regbase);
6360     }
6361
6362   /* Unions up to 16 bytes in size are passed in integer registers.  */
6363   else if (type && TREE_CODE (type) == UNION_TYPE)
6364     {
6365       HOST_WIDE_INT size = int_size_in_bytes (type);
6366       gcc_assert (size <= 16);
6367
6368       return function_arg_union_value (size, mode, slotno, regno);
6369     }
6370
6371   /* v9 fp args in reg slots beyond the int reg slots get passed in regs
6372      but also have the slot allocated for them.
6373      If no prototype is in scope fp values in register slots get passed
6374      in two places, either fp regs and int regs or fp regs and memory.  */
6375   else if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6376            && SPARC_FP_REG_P (regno))
6377     {
6378       rtx reg = gen_rtx_REG (mode, regno);
6379       if (cum->prototype_p || cum->libcall_p)
6380         {
6381           /* "* 2" because fp reg numbers are recorded in 4 byte
6382              quantities.  */
6383 #if 0
6384           /* ??? This will cause the value to be passed in the fp reg and
6385              in the stack.  When a prototype exists we want to pass the
6386              value in the reg but reserve space on the stack.  That's an
6387              optimization, and is deferred [for a bit].  */
6388           if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
6389             return gen_rtx_PARALLEL (mode,
6390                             gen_rtvec (2,
6391                                        gen_rtx_EXPR_LIST (VOIDmode,
6392                                                 NULL_RTX, const0_rtx),
6393                                        gen_rtx_EXPR_LIST (VOIDmode,
6394                                                 reg, const0_rtx)));
6395           else
6396 #else
6397           /* ??? It seems that passing back a register even when past
6398              the area declared by REG_PARM_STACK_SPACE will allocate
6399              space appropriately, and will not copy the data onto the
6400              stack, exactly as we desire.
6401
6402              This is due to locate_and_pad_parm being called in
6403              expand_call whenever reg_parm_stack_space > 0, which
6404              while beneficial to our example here, would seem to be
6405              in error from what had been intended.  Ho hum...  -- r~ */
6406 #endif
6407             return reg;
6408         }
6409       else
6410         {
6411           rtx v0, v1;
6412
6413           if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
6414             {
6415               int intreg;
6416
6417               /* On incoming, we don't need to know that the value
6418                  is passed in %f0 and %i0, and it confuses other parts
6419                  causing needless spillage even on the simplest cases.  */
6420               if (incoming_p)
6421                 return reg;
6422
6423               intreg = (SPARC_OUTGOING_INT_ARG_FIRST
6424                         + (regno - SPARC_FP_ARG_FIRST) / 2);
6425
6426               v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6427               v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
6428                                       const0_rtx);
6429               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6430             }
6431           else
6432             {
6433               v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
6434               v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
6435               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
6436             }
6437         }
6438     }
6439
6440   /* All other aggregate types are passed in an integer register in a mode
6441      corresponding to the size of the type.  */
6442   else if (type && AGGREGATE_TYPE_P (type))
6443     {
6444       HOST_WIDE_INT size = int_size_in_bytes (type);
6445       gcc_assert (size <= 16);
6446
6447       mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6448     }
6449
6450   return gen_rtx_REG (mode, regno);
6451 }
6452
6453 /* Handle the TARGET_FUNCTION_ARG target hook.  */
6454
6455 static rtx
6456 sparc_function_arg (cumulative_args_t cum, enum machine_mode mode,
6457                     const_tree type, bool named)
6458 {
6459   return sparc_function_arg_1 (cum, mode, type, named, false);
6460 }
6461
6462 /* Handle the TARGET_FUNCTION_INCOMING_ARG target hook.  */
6463
6464 static rtx
6465 sparc_function_incoming_arg (cumulative_args_t cum, enum machine_mode mode,
6466                              const_tree type, bool named)
6467 {
6468   return sparc_function_arg_1 (cum, mode, type, named, true);
6469 }
6470
6471 /* For sparc64, objects requiring 16 byte alignment are passed that way.  */
6472
6473 static unsigned int
6474 sparc_function_arg_boundary (enum machine_mode mode, const_tree type)
6475 {
6476   return ((TARGET_ARCH64
6477            && (GET_MODE_ALIGNMENT (mode) == 128
6478                || (type && TYPE_ALIGN (type) == 128)))
6479           ? 128
6480           : PARM_BOUNDARY);
6481 }
6482
6483 /* For an arg passed partly in registers and partly in memory,
6484    this is the number of bytes of registers used.
6485    For args passed entirely in registers or entirely in memory, zero.
6486
6487    Any arg that starts in the first 6 regs but won't entirely fit in them
6488    needs partial registers on v8.  On v9, structures with integer
6489    values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
6490    values that begin in the last fp reg [where "last fp reg" varies with the
6491    mode] will be split between that reg and memory.  */
6492
6493 static int
6494 sparc_arg_partial_bytes (cumulative_args_t cum, enum machine_mode mode,
6495                          tree type, bool named)
6496 {
6497   int slotno, regno, padding;
6498
6499   /* We pass false for incoming_p here, it doesn't matter.  */
6500   slotno = function_arg_slotno (get_cumulative_args (cum), mode, type, named,
6501                                 false, &regno, &padding);
6502
6503   if (slotno == -1)
6504     return 0;
6505
6506   if (TARGET_ARCH32)
6507     {
6508       if ((slotno + (mode == BLKmode
6509                      ? ROUND_ADVANCE (int_size_in_bytes (type))
6510                      : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
6511           > SPARC_INT_ARG_MAX)
6512         return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
6513     }
6514   else
6515     {
6516       /* We are guaranteed by pass_by_reference that the size of the
6517          argument is not greater than 16 bytes, so we only need to return
6518          one word if the argument is partially passed in registers.  */
6519
6520       if (type && AGGREGATE_TYPE_P (type))
6521         {
6522           int size = int_size_in_bytes (type);
6523
6524           if (size > UNITS_PER_WORD
6525               && slotno == SPARC_INT_ARG_MAX - 1)
6526             return UNITS_PER_WORD;
6527         }
6528       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
6529                || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
6530                    && ! (TARGET_FPU && named)))
6531         {
6532           /* The complex types are passed as packed types.  */
6533           if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
6534               && slotno == SPARC_INT_ARG_MAX - 1)
6535             return UNITS_PER_WORD;
6536         }
6537       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
6538         {
6539           if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
6540               > SPARC_FP_ARG_MAX)
6541             return UNITS_PER_WORD;
6542         }
6543     }
6544
6545   return 0;
6546 }
6547
6548 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
6549    Specify whether to pass the argument by reference.  */
6550
6551 static bool
6552 sparc_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
6553                          enum machine_mode mode, const_tree type,
6554                          bool named ATTRIBUTE_UNUSED)
6555 {
6556   if (TARGET_ARCH32)
6557     /* Original SPARC 32-bit ABI says that structures and unions,
6558        and quad-precision floats are passed by reference.  For Pascal,
6559        also pass arrays by reference.  All other base types are passed
6560        in registers.
6561
6562        Extended ABI (as implemented by the Sun compiler) says that all
6563        complex floats are passed by reference.  Pass complex integers
6564        in registers up to 8 bytes.  More generally, enforce the 2-word
6565        cap for passing arguments in registers.
6566
6567        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6568        integers are passed like floats of the same size, that is in
6569        registers up to 8 bytes.  Pass all vector floats by reference
6570        like structure and unions.  */
6571     return ((type && (AGGREGATE_TYPE_P (type) || VECTOR_FLOAT_TYPE_P (type)))
6572             || mode == SCmode
6573             /* Catch CDImode, TFmode, DCmode and TCmode.  */
6574             || GET_MODE_SIZE (mode) > 8
6575             || (type
6576                 && TREE_CODE (type) == VECTOR_TYPE
6577                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6578   else
6579     /* Original SPARC 64-bit ABI says that structures and unions
6580        smaller than 16 bytes are passed in registers, as well as
6581        all other base types.
6582
6583        Extended ABI (as implemented by the Sun compiler) says that
6584        complex floats are passed in registers up to 16 bytes.  Pass
6585        all complex integers in registers up to 16 bytes.  More generally,
6586        enforce the 2-word cap for passing arguments in registers.
6587
6588        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6589        integers are passed like floats of the same size, that is in
6590        registers (up to 16 bytes).  Pass all vector floats like structure
6591        and unions.  */
6592     return ((type
6593              && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE)
6594              && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16)
6595             /* Catch CTImode and TCmode.  */
6596             || GET_MODE_SIZE (mode) > 16);
6597 }
6598
6599 /* Handle the TARGET_FUNCTION_ARG_ADVANCE hook.
6600    Update the data in CUM to advance over an argument
6601    of mode MODE and data type TYPE.
6602    TYPE is null for libcalls where that information may not be available.  */
6603
6604 static void
6605 sparc_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
6606                             const_tree type, bool named)
6607 {
6608   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
6609   int regno, padding;
6610
6611   /* We pass false for incoming_p here, it doesn't matter.  */
6612   function_arg_slotno (cum, mode, type, named, false, &regno, &padding);
6613
6614   /* If argument requires leading padding, add it.  */
6615   cum->words += padding;
6616
6617   if (TARGET_ARCH32)
6618     {
6619       cum->words += (mode != BLKmode
6620                      ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6621                      : ROUND_ADVANCE (int_size_in_bytes (type)));
6622     }
6623   else
6624     {
6625       if (type && AGGREGATE_TYPE_P (type))
6626         {
6627           int size = int_size_in_bytes (type);
6628
6629           if (size <= 8)
6630             ++cum->words;
6631           else if (size <= 16)
6632             cum->words += 2;
6633           else /* passed by reference */
6634             ++cum->words;
6635         }
6636       else
6637         {
6638           cum->words += (mode != BLKmode
6639                          ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
6640                          : ROUND_ADVANCE (int_size_in_bytes (type)));
6641         }
6642     }
6643 }
6644
6645 /* Handle the FUNCTION_ARG_PADDING macro.
6646    For the 64 bit ABI structs are always stored left shifted in their
6647    argument slot.  */
6648
6649 enum direction
6650 function_arg_padding (enum machine_mode mode, const_tree type)
6651 {
6652   if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
6653     return upward;
6654
6655   /* Fall back to the default.  */
6656   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
6657 }
6658
6659 /* Handle the TARGET_RETURN_IN_MEMORY target hook.
6660    Specify whether to return the return value in memory.  */
6661
6662 static bool
6663 sparc_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
6664 {
6665   if (TARGET_ARCH32)
6666     /* Original SPARC 32-bit ABI says that structures and unions,
6667        and quad-precision floats are returned in memory.  All other
6668        base types are returned in registers.
6669
6670        Extended ABI (as implemented by the Sun compiler) says that
6671        all complex floats are returned in registers (8 FP registers
6672        at most for '_Complex long double').  Return all complex integers
6673        in registers (4 at most for '_Complex long long').
6674
6675        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6676        integers are returned like floats of the same size, that is in
6677        registers up to 8 bytes and in memory otherwise.  Return all
6678        vector floats in memory like structure and unions; note that
6679        they always have BLKmode like the latter.  */
6680     return (TYPE_MODE (type) == BLKmode
6681             || TYPE_MODE (type) == TFmode
6682             || (TREE_CODE (type) == VECTOR_TYPE
6683                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
6684   else
6685     /* Original SPARC 64-bit ABI says that structures and unions
6686        smaller than 32 bytes are returned in registers, as well as
6687        all other base types.
6688
6689        Extended ABI (as implemented by the Sun compiler) says that all
6690        complex floats are returned in registers (8 FP registers at most
6691        for '_Complex long double').  Return all complex integers in
6692        registers (4 at most for '_Complex TItype').
6693
6694        Vector ABI (as implemented by the Sun VIS SDK) says that vector
6695        integers are returned like floats of the same size, that is in
6696        registers.  Return all vector floats like structure and unions;
6697        note that they always have BLKmode like the latter.  */
6698     return (TYPE_MODE (type) == BLKmode
6699             && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 32);
6700 }
6701
6702 /* Handle the TARGET_STRUCT_VALUE target hook.
6703    Return where to find the structure return value address.  */
6704
6705 static rtx
6706 sparc_struct_value_rtx (tree fndecl, int incoming)
6707 {
6708   if (TARGET_ARCH64)
6709     return 0;
6710   else
6711     {
6712       rtx mem;
6713
6714       if (incoming)
6715         mem = gen_frame_mem (Pmode, plus_constant (frame_pointer_rtx,
6716                                                    STRUCT_VALUE_OFFSET));
6717       else
6718         mem = gen_frame_mem (Pmode, plus_constant (stack_pointer_rtx,
6719                                                    STRUCT_VALUE_OFFSET));
6720
6721       /* Only follow the SPARC ABI for fixed-size structure returns.
6722          Variable size structure returns are handled per the normal
6723          procedures in GCC. This is enabled by -mstd-struct-return */
6724       if (incoming == 2
6725           && sparc_std_struct_return
6726           && TYPE_SIZE_UNIT (TREE_TYPE (fndecl))
6727           && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (fndecl))) == INTEGER_CST)
6728         {
6729           /* We must check and adjust the return address, as it is
6730              optional as to whether the return object is really
6731              provided.  */
6732           rtx ret_reg = gen_rtx_REG (Pmode, 31);
6733           rtx scratch = gen_reg_rtx (SImode);
6734           rtx endlab = gen_label_rtx ();
6735
6736           /* Calculate the return object size */
6737           tree size = TYPE_SIZE_UNIT (TREE_TYPE (fndecl));
6738           rtx size_rtx = GEN_INT (TREE_INT_CST_LOW (size) & 0xfff);
6739           /* Construct a temporary return value */
6740           rtx temp_val
6741             = assign_stack_local (Pmode, TREE_INT_CST_LOW (size), 0);
6742
6743           /* Implement SPARC 32-bit psABI callee return struct checking:
6744
6745              Fetch the instruction where we will return to and see if
6746              it's an unimp instruction (the most significant 10 bits
6747              will be zero).  */
6748           emit_move_insn (scratch, gen_rtx_MEM (SImode,
6749                                                 plus_constant (ret_reg, 8)));
6750           /* Assume the size is valid and pre-adjust */
6751           emit_insn (gen_add3_insn (ret_reg, ret_reg, GEN_INT (4)));
6752           emit_cmp_and_jump_insns (scratch, size_rtx, EQ, const0_rtx, SImode,
6753                                    0, endlab);
6754           emit_insn (gen_sub3_insn (ret_reg, ret_reg, GEN_INT (4)));
6755           /* Write the address of the memory pointed to by temp_val into
6756              the memory pointed to by mem */
6757           emit_move_insn (mem, XEXP (temp_val, 0));
6758           emit_label (endlab);
6759         }
6760
6761       return mem;
6762     }
6763 }
6764
6765 /* Handle TARGET_FUNCTION_VALUE, and TARGET_LIBCALL_VALUE target hook.
6766    For v9, function return values are subject to the same rules as arguments,
6767    except that up to 32 bytes may be returned in registers.  */
6768
6769 static rtx
6770 sparc_function_value_1 (const_tree type, enum machine_mode mode,
6771                         bool outgoing)
6772 {
6773   /* Beware that the two values are swapped here wrt function_arg.  */
6774   int regbase = (outgoing
6775                  ? SPARC_INCOMING_INT_ARG_FIRST
6776                  : SPARC_OUTGOING_INT_ARG_FIRST);
6777   enum mode_class mclass = GET_MODE_CLASS (mode);
6778   int regno;
6779
6780   /* Vector types deserve special treatment because they are polymorphic wrt
6781      their mode, depending upon whether VIS instructions are enabled.  */
6782   if (type && TREE_CODE (type) == VECTOR_TYPE)
6783     {
6784       HOST_WIDE_INT size = int_size_in_bytes (type);
6785       gcc_assert ((TARGET_ARCH32 && size <= 8)
6786                   || (TARGET_ARCH64 && size <= 32));
6787
6788       if (mode == BLKmode)
6789         return function_arg_vector_value (size,
6790                                           SPARC_FP_ARG_FIRST);
6791       else
6792         mclass = MODE_FLOAT;
6793     }
6794
6795   if (TARGET_ARCH64 && type)
6796     {
6797       /* Structures up to 32 bytes in size are returned in registers.  */
6798       if (TREE_CODE (type) == RECORD_TYPE)
6799         {
6800           HOST_WIDE_INT size = int_size_in_bytes (type);
6801           gcc_assert (size <= 32);
6802
6803           return function_arg_record_value (type, mode, 0, 1, regbase);
6804         }
6805
6806       /* Unions up to 32 bytes in size are returned in integer registers.  */
6807       else if (TREE_CODE (type) == UNION_TYPE)
6808         {
6809           HOST_WIDE_INT size = int_size_in_bytes (type);
6810           gcc_assert (size <= 32);
6811
6812           return function_arg_union_value (size, mode, 0, regbase);
6813         }
6814
6815       /* Objects that require it are returned in FP registers.  */
6816       else if (mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
6817         ;
6818
6819       /* All other aggregate types are returned in an integer register in a
6820          mode corresponding to the size of the type.  */
6821       else if (AGGREGATE_TYPE_P (type))
6822         {
6823           /* All other aggregate types are passed in an integer register
6824              in a mode corresponding to the size of the type.  */
6825           HOST_WIDE_INT size = int_size_in_bytes (type);
6826           gcc_assert (size <= 32);
6827
6828           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
6829
6830           /* ??? We probably should have made the same ABI change in
6831              3.4.0 as the one we made for unions.   The latter was
6832              required by the SCD though, while the former is not
6833              specified, so we favored compatibility and efficiency.
6834
6835              Now we're stuck for aggregates larger than 16 bytes,
6836              because OImode vanished in the meantime.  Let's not
6837              try to be unduly clever, and simply follow the ABI
6838              for unions in that case.  */
6839           if (mode == BLKmode)
6840             return function_arg_union_value (size, mode, 0, regbase);
6841           else
6842             mclass = MODE_INT;
6843         }
6844
6845       /* We should only have pointer and integer types at this point.  This
6846          must match sparc_promote_function_mode.  */
6847       else if (mclass == MODE_INT && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6848         mode = word_mode;
6849     }
6850
6851   /* We should only have pointer and integer types at this point.  This must
6852      match sparc_promote_function_mode.  */
6853   else if (TARGET_ARCH32
6854            && mclass == MODE_INT
6855            && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
6856     mode = word_mode;
6857
6858   if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT) && TARGET_FPU)
6859     regno = SPARC_FP_ARG_FIRST;
6860   else
6861     regno = regbase;
6862
6863   return gen_rtx_REG (mode, regno);
6864 }
6865
6866 /* Handle TARGET_FUNCTION_VALUE.
6867    On the SPARC, the value is found in the first "output" register, but the
6868    called function leaves it in the first "input" register.  */
6869
6870 static rtx
6871 sparc_function_value (const_tree valtype,
6872                       const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
6873                       bool outgoing)
6874 {
6875   return sparc_function_value_1 (valtype, TYPE_MODE (valtype), outgoing);
6876 }
6877
6878 /* Handle TARGET_LIBCALL_VALUE.  */
6879
6880 static rtx
6881 sparc_libcall_value (enum machine_mode mode,
6882                      const_rtx fun ATTRIBUTE_UNUSED)
6883 {
6884   return sparc_function_value_1 (NULL_TREE, mode, false);
6885 }
6886
6887 /* Handle FUNCTION_VALUE_REGNO_P.
6888    On the SPARC, the first "output" reg is used for integer values, and the
6889    first floating point register is used for floating point values.  */
6890
6891 static bool
6892 sparc_function_value_regno_p (const unsigned int regno)
6893 {
6894   return (regno == 8 || regno == 32);
6895 }
6896
6897 /* Do what is necessary for `va_start'.  We look at the current function
6898    to determine if stdarg or varargs is used and return the address of
6899    the first unnamed parameter.  */
6900
6901 static rtx
6902 sparc_builtin_saveregs (void)
6903 {
6904   int first_reg = crtl->args.info.words;
6905   rtx address;
6906   int regno;
6907
6908   for (regno = first_reg; regno < SPARC_INT_ARG_MAX; regno++)
6909     emit_move_insn (gen_rtx_MEM (word_mode,
6910                                  gen_rtx_PLUS (Pmode,
6911                                                frame_pointer_rtx,
6912                                                GEN_INT (FIRST_PARM_OFFSET (0)
6913                                                         + (UNITS_PER_WORD
6914                                                            * regno)))),
6915                     gen_rtx_REG (word_mode,
6916                                  SPARC_INCOMING_INT_ARG_FIRST + regno));
6917
6918   address = gen_rtx_PLUS (Pmode,
6919                           frame_pointer_rtx,
6920                           GEN_INT (FIRST_PARM_OFFSET (0)
6921                                    + UNITS_PER_WORD * first_reg));
6922
6923   return address;
6924 }
6925
6926 /* Implement `va_start' for stdarg.  */
6927
6928 static void
6929 sparc_va_start (tree valist, rtx nextarg)
6930 {
6931   nextarg = expand_builtin_saveregs ();
6932   std_expand_builtin_va_start (valist, nextarg);
6933 }
6934
6935 /* Implement `va_arg' for stdarg.  */
6936
6937 static tree
6938 sparc_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
6939                        gimple_seq *post_p)
6940 {
6941   HOST_WIDE_INT size, rsize, align;
6942   tree addr, incr;
6943   bool indirect;
6944   tree ptrtype = build_pointer_type (type);
6945
6946   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
6947     {
6948       indirect = true;
6949       size = rsize = UNITS_PER_WORD;
6950       align = 0;
6951     }
6952   else
6953     {
6954       indirect = false;
6955       size = int_size_in_bytes (type);
6956       rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
6957       align = 0;
6958
6959       if (TARGET_ARCH64)
6960         {
6961           /* For SPARC64, objects requiring 16-byte alignment get it.  */
6962           if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
6963             align = 2 * UNITS_PER_WORD;
6964
6965           /* SPARC-V9 ABI states that structures up to 16 bytes in size
6966              are left-justified in their slots.  */
6967           if (AGGREGATE_TYPE_P (type))
6968             {
6969               if (size == 0)
6970                 size = rsize = UNITS_PER_WORD;
6971               else
6972                 size = rsize;
6973             }
6974         }
6975     }
6976
6977   incr = valist;
6978   if (align)
6979     {
6980       incr = fold_build_pointer_plus_hwi (incr, align - 1);
6981       incr = fold_convert (sizetype, incr);
6982       incr = fold_build2 (BIT_AND_EXPR, sizetype, incr,
6983                           size_int (-align));
6984       incr = fold_convert (ptr_type_node, incr);
6985     }
6986
6987   gimplify_expr (&incr, pre_p, post_p, is_gimple_val, fb_rvalue);
6988   addr = incr;
6989
6990   if (BYTES_BIG_ENDIAN && size < rsize)
6991     addr = fold_build_pointer_plus_hwi (incr, rsize - size);
6992
6993   if (indirect)
6994     {
6995       addr = fold_convert (build_pointer_type (ptrtype), addr);
6996       addr = build_va_arg_indirect_ref (addr);
6997     }
6998
6999   /* If the address isn't aligned properly for the type, we need a temporary.
7000      FIXME: This is inefficient, usually we can do this in registers.  */
7001   else if (align == 0 && TYPE_ALIGN (type) > BITS_PER_WORD)
7002     {
7003       tree tmp = create_tmp_var (type, "va_arg_tmp");
7004       tree dest_addr = build_fold_addr_expr (tmp);
7005       tree copy = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
7006                                    3, dest_addr, addr, size_int (rsize));
7007       TREE_ADDRESSABLE (tmp) = 1;
7008       gimplify_and_add (copy, pre_p);
7009       addr = dest_addr;
7010     }
7011
7012   else
7013     addr = fold_convert (ptrtype, addr);
7014
7015   incr = fold_build_pointer_plus_hwi (incr, rsize);
7016   gimplify_assign (valist, incr, post_p);
7017
7018   return build_va_arg_indirect_ref (addr);
7019 }
7020 \f
7021 /* Implement the TARGET_VECTOR_MODE_SUPPORTED_P target hook.
7022    Specify whether the vector mode is supported by the hardware.  */
7023
7024 static bool
7025 sparc_vector_mode_supported_p (enum machine_mode mode)
7026 {
7027   return TARGET_VIS && VECTOR_MODE_P (mode) ? true : false;
7028 }
7029 \f
7030 /* Implement the TARGET_VECTORIZE_PREFERRED_SIMD_MODE target hook.  */
7031
7032 static enum machine_mode
7033 sparc_preferred_simd_mode (enum machine_mode mode)
7034 {
7035   if (TARGET_VIS)
7036     switch (mode)
7037       {
7038       case SImode:
7039         return V2SImode;
7040       case HImode:
7041         return V4HImode;
7042       case QImode:
7043         return V8QImode;
7044
7045       default:;
7046       }
7047
7048   return word_mode;
7049 }
7050 \f
7051 /* Return the string to output an unconditional branch to LABEL, which is
7052    the operand number of the label.
7053
7054    DEST is the destination insn (i.e. the label), INSN is the source.  */
7055
7056 const char *
7057 output_ubranch (rtx dest, int label, rtx insn)
7058 {
7059   static char string[64];
7060   bool v9_form = false;
7061   char *p;
7062
7063   if (TARGET_V9 && INSN_ADDRESSES_SET_P ())
7064     {
7065       int delta = (INSN_ADDRESSES (INSN_UID (dest))
7066                    - INSN_ADDRESSES (INSN_UID (insn)));
7067       /* Leave some instructions for "slop".  */
7068       if (delta >= -260000 && delta < 260000)
7069         v9_form = true;
7070     }
7071
7072   if (v9_form)
7073     strcpy (string, "ba%*,pt\t%%xcc, ");
7074   else
7075     strcpy (string, "b%*\t");
7076
7077   p = strchr (string, '\0');
7078   *p++ = '%';
7079   *p++ = 'l';
7080   *p++ = '0' + label;
7081   *p++ = '%';
7082   *p++ = '(';
7083   *p = '\0';
7084
7085   return string;
7086 }
7087
7088 /* Return the string to output a conditional branch to LABEL, which is
7089    the operand number of the label.  OP is the conditional expression.
7090    XEXP (OP, 0) is assumed to be a condition code register (integer or
7091    floating point) and its mode specifies what kind of comparison we made.
7092
7093    DEST is the destination insn (i.e. the label), INSN is the source.
7094
7095    REVERSED is nonzero if we should reverse the sense of the comparison.
7096
7097    ANNUL is nonzero if we should generate an annulling branch.  */
7098
7099 const char *
7100 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
7101                 rtx insn)
7102 {
7103   static char string[64];
7104   enum rtx_code code = GET_CODE (op);
7105   rtx cc_reg = XEXP (op, 0);
7106   enum machine_mode mode = GET_MODE (cc_reg);
7107   const char *labelno, *branch;
7108   int spaces = 8, far;
7109   char *p;
7110
7111   /* v9 branches are limited to +-1MB.  If it is too far away,
7112      change
7113
7114      bne,pt %xcc, .LC30
7115
7116      to
7117
7118      be,pn %xcc, .+12
7119       nop
7120      ba .LC30
7121
7122      and
7123
7124      fbne,a,pn %fcc2, .LC29
7125
7126      to
7127
7128      fbe,pt %fcc2, .+16
7129       nop
7130      ba .LC29  */
7131
7132   far = TARGET_V9 && (get_attr_length (insn) >= 3);
7133   if (reversed ^ far)
7134     {
7135       /* Reversal of FP compares takes care -- an ordered compare
7136          becomes an unordered compare and vice versa.  */
7137       if (mode == CCFPmode || mode == CCFPEmode)
7138         code = reverse_condition_maybe_unordered (code);
7139       else
7140         code = reverse_condition (code);
7141     }
7142
7143   /* Start by writing the branch condition.  */
7144   if (mode == CCFPmode || mode == CCFPEmode)
7145     {
7146       switch (code)
7147         {
7148         case NE:
7149           branch = "fbne";
7150           break;
7151         case EQ:
7152           branch = "fbe";
7153           break;
7154         case GE:
7155           branch = "fbge";
7156           break;
7157         case GT:
7158           branch = "fbg";
7159           break;
7160         case LE:
7161           branch = "fble";
7162           break;
7163         case LT:
7164           branch = "fbl";
7165           break;
7166         case UNORDERED:
7167           branch = "fbu";
7168           break;
7169         case ORDERED:
7170           branch = "fbo";
7171           break;
7172         case UNGT:
7173           branch = "fbug";
7174           break;
7175         case UNLT:
7176           branch = "fbul";
7177           break;
7178         case UNEQ:
7179           branch = "fbue";
7180           break;
7181         case UNGE:
7182           branch = "fbuge";
7183           break;
7184         case UNLE:
7185           branch = "fbule";
7186           break;
7187         case LTGT:
7188           branch = "fblg";
7189           break;
7190
7191         default:
7192           gcc_unreachable ();
7193         }
7194
7195       /* ??? !v9: FP branches cannot be preceded by another floating point
7196          insn.  Because there is currently no concept of pre-delay slots,
7197          we can fix this only by always emitting a nop before a floating
7198          point branch.  */
7199
7200       string[0] = '\0';
7201       if (! TARGET_V9)
7202         strcpy (string, "nop\n\t");
7203       strcat (string, branch);
7204     }
7205   else
7206     {
7207       switch (code)
7208         {
7209         case NE:
7210           branch = "bne";
7211           break;
7212         case EQ:
7213           branch = "be";
7214           break;
7215         case GE:
7216           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
7217             branch = "bpos";
7218           else
7219             branch = "bge";
7220           break;
7221         case GT:
7222           branch = "bg";
7223           break;
7224         case LE:
7225           branch = "ble";
7226           break;
7227         case LT:
7228           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
7229             branch = "bneg";
7230           else
7231             branch = "bl";
7232           break;
7233         case GEU:
7234           branch = "bgeu";
7235           break;
7236         case GTU:
7237           branch = "bgu";
7238           break;
7239         case LEU:
7240           branch = "bleu";
7241           break;
7242         case LTU:
7243           branch = "blu";
7244           break;
7245
7246         default:
7247           gcc_unreachable ();
7248         }
7249       strcpy (string, branch);
7250     }
7251   spaces -= strlen (branch);
7252   p = strchr (string, '\0');
7253
7254   /* Now add the annulling, the label, and a possible noop.  */
7255   if (annul && ! far)
7256     {
7257       strcpy (p, ",a");
7258       p += 2;
7259       spaces -= 2;
7260     }
7261
7262   if (TARGET_V9)
7263     {
7264       rtx note;
7265       int v8 = 0;
7266
7267       if (! far && insn && INSN_ADDRESSES_SET_P ())
7268         {
7269           int delta = (INSN_ADDRESSES (INSN_UID (dest))
7270                        - INSN_ADDRESSES (INSN_UID (insn)));
7271           /* Leave some instructions for "slop".  */
7272           if (delta < -260000 || delta >= 260000)
7273             v8 = 1;
7274         }
7275
7276       if (mode == CCFPmode || mode == CCFPEmode)
7277         {
7278           static char v9_fcc_labelno[] = "%%fccX, ";
7279           /* Set the char indicating the number of the fcc reg to use.  */
7280           v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
7281           labelno = v9_fcc_labelno;
7282           if (v8)
7283             {
7284               gcc_assert (REGNO (cc_reg) == SPARC_FCC_REG);
7285               labelno = "";
7286             }
7287         }
7288       else if (mode == CCXmode || mode == CCX_NOOVmode)
7289         {
7290           labelno = "%%xcc, ";
7291           gcc_assert (! v8);
7292         }
7293       else
7294         {
7295           labelno = "%%icc, ";
7296           if (v8)
7297             labelno = "";
7298         }
7299
7300       if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7301         {
7302           strcpy (p,
7303                   ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7304                   ? ",pt" : ",pn");
7305           p += 3;
7306           spaces -= 3;
7307         }
7308     }
7309   else
7310     labelno = "";
7311
7312   if (spaces > 0)
7313     *p++ = '\t';
7314   else
7315     *p++ = ' ';
7316   strcpy (p, labelno);
7317   p = strchr (p, '\0');
7318   if (far)
7319     {
7320       strcpy (p, ".+12\n\t nop\n\tb\t");
7321       /* Skip the next insn if requested or
7322          if we know that it will be a nop.  */
7323       if (annul || ! final_sequence)
7324         p[3] = '6';
7325       p += 14;
7326     }
7327   *p++ = '%';
7328   *p++ = 'l';
7329   *p++ = label + '0';
7330   *p++ = '%';
7331   *p++ = '#';
7332   *p = '\0';
7333
7334   return string;
7335 }
7336
7337 /* Emit a library call comparison between floating point X and Y.
7338    COMPARISON is the operator to compare with (EQ, NE, GT, etc).
7339    Return the new operator to be used in the comparison sequence.
7340
7341    TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
7342    values as arguments instead of the TFmode registers themselves,
7343    that's why we cannot call emit_float_lib_cmp.  */
7344
7345 rtx
7346 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
7347 {
7348   const char *qpfunc;
7349   rtx slot0, slot1, result, tem, tem2, libfunc;
7350   enum machine_mode mode;
7351   enum rtx_code new_comparison;
7352
7353   switch (comparison)
7354     {
7355     case EQ:
7356       qpfunc = (TARGET_ARCH64 ? "_Qp_feq" : "_Q_feq");
7357       break;
7358
7359     case NE:
7360       qpfunc = (TARGET_ARCH64 ? "_Qp_fne" : "_Q_fne");
7361       break;
7362
7363     case GT:
7364       qpfunc = (TARGET_ARCH64 ? "_Qp_fgt" : "_Q_fgt");
7365       break;
7366
7367     case GE:
7368       qpfunc = (TARGET_ARCH64 ? "_Qp_fge" : "_Q_fge");
7369       break;
7370
7371     case LT:
7372       qpfunc = (TARGET_ARCH64 ? "_Qp_flt" : "_Q_flt");
7373       break;
7374
7375     case LE:
7376       qpfunc = (TARGET_ARCH64 ? "_Qp_fle" : "_Q_fle");
7377       break;
7378
7379     case ORDERED:
7380     case UNORDERED:
7381     case UNGT:
7382     case UNLT:
7383     case UNEQ:
7384     case UNGE:
7385     case UNLE:
7386     case LTGT:
7387       qpfunc = (TARGET_ARCH64 ? "_Qp_cmp" : "_Q_cmp");
7388       break;
7389
7390     default:
7391       gcc_unreachable ();
7392     }
7393
7394   if (TARGET_ARCH64)
7395     {
7396       if (MEM_P (x))
7397         {
7398           tree expr = MEM_EXPR (x);
7399           if (expr)
7400             mark_addressable (expr);
7401           slot0 = x;
7402         }
7403       else
7404         {
7405           slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7406           emit_move_insn (slot0, x);
7407         }
7408
7409       if (MEM_P (y))
7410         {
7411           tree expr = MEM_EXPR (y);
7412           if (expr)
7413             mark_addressable (expr);
7414           slot1 = y;
7415         }
7416       else
7417         {
7418           slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
7419           emit_move_insn (slot1, y);
7420         }
7421
7422       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7423       emit_library_call (libfunc, LCT_NORMAL,
7424                          DImode, 2,
7425                          XEXP (slot0, 0), Pmode,
7426                          XEXP (slot1, 0), Pmode);
7427       mode = DImode;
7428     }
7429   else
7430     {
7431       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
7432       emit_library_call (libfunc, LCT_NORMAL,
7433                          SImode, 2,
7434                          x, TFmode, y, TFmode);
7435       mode = SImode;
7436     }
7437
7438
7439   /* Immediately move the result of the libcall into a pseudo
7440      register so reload doesn't clobber the value if it needs
7441      the return register for a spill reg.  */
7442   result = gen_reg_rtx (mode);
7443   emit_move_insn (result, hard_libcall_value (mode, libfunc));
7444
7445   switch (comparison)
7446     {
7447     default:
7448       return gen_rtx_NE (VOIDmode, result, const0_rtx);
7449     case ORDERED:
7450     case UNORDERED:
7451       new_comparison = (comparison == UNORDERED ? EQ : NE);
7452       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, GEN_INT(3));
7453     case UNGT:
7454     case UNGE:
7455       new_comparison = (comparison == UNGT ? GT : NE);
7456       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, const1_rtx);
7457     case UNLE:
7458       return gen_rtx_NE (VOIDmode, result, const2_rtx);
7459     case UNLT:
7460       tem = gen_reg_rtx (mode);
7461       if (TARGET_ARCH32)
7462         emit_insn (gen_andsi3 (tem, result, const1_rtx));
7463       else
7464         emit_insn (gen_anddi3 (tem, result, const1_rtx));
7465       return gen_rtx_NE (VOIDmode, tem, const0_rtx);
7466     case UNEQ:
7467     case LTGT:
7468       tem = gen_reg_rtx (mode);
7469       if (TARGET_ARCH32)
7470         emit_insn (gen_addsi3 (tem, result, const1_rtx));
7471       else
7472         emit_insn (gen_adddi3 (tem, result, const1_rtx));
7473       tem2 = gen_reg_rtx (mode);
7474       if (TARGET_ARCH32)
7475         emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
7476       else
7477         emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
7478       new_comparison = (comparison == UNEQ ? EQ : NE);
7479       return gen_rtx_fmt_ee (new_comparison, VOIDmode, tem2, const0_rtx);
7480     }
7481
7482   gcc_unreachable ();
7483 }
7484
7485 /* Generate an unsigned DImode to FP conversion.  This is the same code
7486    optabs would emit if we didn't have TFmode patterns.  */
7487
7488 void
7489 sparc_emit_floatunsdi (rtx *operands, enum machine_mode mode)
7490 {
7491   rtx neglab, donelab, i0, i1, f0, in, out;
7492
7493   out = operands[0];
7494   in = force_reg (DImode, operands[1]);
7495   neglab = gen_label_rtx ();
7496   donelab = gen_label_rtx ();
7497   i0 = gen_reg_rtx (DImode);
7498   i1 = gen_reg_rtx (DImode);
7499   f0 = gen_reg_rtx (mode);
7500
7501   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
7502
7503   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
7504   emit_jump_insn (gen_jump (donelab));
7505   emit_barrier ();
7506
7507   emit_label (neglab);
7508
7509   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
7510   emit_insn (gen_anddi3 (i1, in, const1_rtx));
7511   emit_insn (gen_iordi3 (i0, i0, i1));
7512   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
7513   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
7514
7515   emit_label (donelab);
7516 }
7517
7518 /* Generate an FP to unsigned DImode conversion.  This is the same code
7519    optabs would emit if we didn't have TFmode patterns.  */
7520
7521 void
7522 sparc_emit_fixunsdi (rtx *operands, enum machine_mode mode)
7523 {
7524   rtx neglab, donelab, i0, i1, f0, in, out, limit;
7525
7526   out = operands[0];
7527   in = force_reg (mode, operands[1]);
7528   neglab = gen_label_rtx ();
7529   donelab = gen_label_rtx ();
7530   i0 = gen_reg_rtx (DImode);
7531   i1 = gen_reg_rtx (DImode);
7532   limit = gen_reg_rtx (mode);
7533   f0 = gen_reg_rtx (mode);
7534
7535   emit_move_insn (limit,
7536                   CONST_DOUBLE_FROM_REAL_VALUE (
7537                     REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
7538   emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
7539
7540   emit_insn (gen_rtx_SET (VOIDmode,
7541                           out,
7542                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
7543   emit_jump_insn (gen_jump (donelab));
7544   emit_barrier ();
7545
7546   emit_label (neglab);
7547
7548   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
7549   emit_insn (gen_rtx_SET (VOIDmode,
7550                           i0,
7551                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
7552   emit_insn (gen_movdi (i1, const1_rtx));
7553   emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
7554   emit_insn (gen_xordi3 (out, i0, i1));
7555
7556   emit_label (donelab);
7557 }
7558
7559 /* Return the string to output a conditional branch to LABEL, testing
7560    register REG.  LABEL is the operand number of the label; REG is the
7561    operand number of the reg.  OP is the conditional expression.  The mode
7562    of REG says what kind of comparison we made.
7563
7564    DEST is the destination insn (i.e. the label), INSN is the source.
7565
7566    REVERSED is nonzero if we should reverse the sense of the comparison.
7567
7568    ANNUL is nonzero if we should generate an annulling branch.  */
7569
7570 const char *
7571 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
7572                  int annul, rtx insn)
7573 {
7574   static char string[64];
7575   enum rtx_code code = GET_CODE (op);
7576   enum machine_mode mode = GET_MODE (XEXP (op, 0));
7577   rtx note;
7578   int far;
7579   char *p;
7580
7581   /* branch on register are limited to +-128KB.  If it is too far away,
7582      change
7583
7584      brnz,pt %g1, .LC30
7585
7586      to
7587
7588      brz,pn %g1, .+12
7589       nop
7590      ba,pt %xcc, .LC30
7591
7592      and
7593
7594      brgez,a,pn %o1, .LC29
7595
7596      to
7597
7598      brlz,pt %o1, .+16
7599       nop
7600      ba,pt %xcc, .LC29  */
7601
7602   far = get_attr_length (insn) >= 3;
7603
7604   /* If not floating-point or if EQ or NE, we can just reverse the code.  */
7605   if (reversed ^ far)
7606     code = reverse_condition (code);
7607
7608   /* Only 64 bit versions of these instructions exist.  */
7609   gcc_assert (mode == DImode);
7610
7611   /* Start by writing the branch condition.  */
7612
7613   switch (code)
7614     {
7615     case NE:
7616       strcpy (string, "brnz");
7617       break;
7618
7619     case EQ:
7620       strcpy (string, "brz");
7621       break;
7622
7623     case GE:
7624       strcpy (string, "brgez");
7625       break;
7626
7627     case LT:
7628       strcpy (string, "brlz");
7629       break;
7630
7631     case LE:
7632       strcpy (string, "brlez");
7633       break;
7634
7635     case GT:
7636       strcpy (string, "brgz");
7637       break;
7638
7639     default:
7640       gcc_unreachable ();
7641     }
7642
7643   p = strchr (string, '\0');
7644
7645   /* Now add the annulling, reg, label, and nop.  */
7646   if (annul && ! far)
7647     {
7648       strcpy (p, ",a");
7649       p += 2;
7650     }
7651
7652   if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
7653     {
7654       strcpy (p,
7655               ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
7656               ? ",pt" : ",pn");
7657       p += 3;
7658     }
7659
7660   *p = p < string + 8 ? '\t' : ' ';
7661   p++;
7662   *p++ = '%';
7663   *p++ = '0' + reg;
7664   *p++ = ',';
7665   *p++ = ' ';
7666   if (far)
7667     {
7668       int veryfar = 1, delta;
7669
7670       if (INSN_ADDRESSES_SET_P ())
7671         {
7672           delta = (INSN_ADDRESSES (INSN_UID (dest))
7673                    - INSN_ADDRESSES (INSN_UID (insn)));
7674           /* Leave some instructions for "slop".  */
7675           if (delta >= -260000 && delta < 260000)
7676             veryfar = 0;
7677         }
7678
7679       strcpy (p, ".+12\n\t nop\n\t");
7680       /* Skip the next insn if requested or
7681          if we know that it will be a nop.  */
7682       if (annul || ! final_sequence)
7683         p[3] = '6';
7684       p += 12;
7685       if (veryfar)
7686         {
7687           strcpy (p, "b\t");
7688           p += 2;
7689         }
7690       else
7691         {
7692           strcpy (p, "ba,pt\t%%xcc, ");
7693           p += 13;
7694         }
7695     }
7696   *p++ = '%';
7697   *p++ = 'l';
7698   *p++ = '0' + label;
7699   *p++ = '%';
7700   *p++ = '#';
7701   *p = '\0';
7702
7703   return string;
7704 }
7705
7706 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
7707    Such instructions cannot be used in the delay slot of return insn on v9.
7708    If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
7709  */
7710
7711 static int
7712 epilogue_renumber (register rtx *where, int test)
7713 {
7714   register const char *fmt;
7715   register int i;
7716   register enum rtx_code code;
7717
7718   if (*where == 0)
7719     return 0;
7720
7721   code = GET_CODE (*where);
7722
7723   switch (code)
7724     {
7725     case REG:
7726       if (REGNO (*where) >= 8 && REGNO (*where) < 24)      /* oX or lX */
7727         return 1;
7728       if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
7729         *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
7730     case SCRATCH:
7731     case CC0:
7732     case PC:
7733     case CONST_INT:
7734     case CONST_DOUBLE:
7735       return 0;
7736
7737       /* Do not replace the frame pointer with the stack pointer because
7738          it can cause the delayed instruction to load below the stack.
7739          This occurs when instructions like:
7740
7741          (set (reg/i:SI 24 %i0)
7742              (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
7743                        (const_int -20 [0xffffffec])) 0))
7744
7745          are in the return delayed slot.  */
7746     case PLUS:
7747       if (GET_CODE (XEXP (*where, 0)) == REG
7748           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
7749           && (GET_CODE (XEXP (*where, 1)) != CONST_INT
7750               || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
7751         return 1;
7752       break;
7753
7754     case MEM:
7755       if (SPARC_STACK_BIAS
7756           && GET_CODE (XEXP (*where, 0)) == REG
7757           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
7758         return 1;
7759       break;
7760
7761     default:
7762       break;
7763     }
7764
7765   fmt = GET_RTX_FORMAT (code);
7766
7767   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7768     {
7769       if (fmt[i] == 'E')
7770         {
7771           register int j;
7772           for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
7773             if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
7774               return 1;
7775         }
7776       else if (fmt[i] == 'e'
7777                && epilogue_renumber (&(XEXP (*where, i)), test))
7778         return 1;
7779     }
7780   return 0;
7781 }
7782 \f
7783 /* Leaf functions and non-leaf functions have different needs.  */
7784
7785 static const int
7786 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
7787
7788 static const int
7789 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
7790
7791 static const int *const reg_alloc_orders[] = {
7792   reg_leaf_alloc_order,
7793   reg_nonleaf_alloc_order};
7794
7795 void
7796 order_regs_for_local_alloc (void)
7797 {
7798   static int last_order_nonleaf = 1;
7799
7800   if (df_regs_ever_live_p (15) != last_order_nonleaf)
7801     {
7802       last_order_nonleaf = !last_order_nonleaf;
7803       memcpy ((char *) reg_alloc_order,
7804               (const char *) reg_alloc_orders[last_order_nonleaf],
7805               FIRST_PSEUDO_REGISTER * sizeof (int));
7806     }
7807 }
7808 \f
7809 /* Return 1 if REG and MEM are legitimate enough to allow the various
7810    mem<-->reg splits to be run.  */
7811
7812 int
7813 sparc_splitdi_legitimate (rtx reg, rtx mem)
7814 {
7815   /* Punt if we are here by mistake.  */
7816   gcc_assert (reload_completed);
7817
7818   /* We must have an offsettable memory reference.  */
7819   if (! offsettable_memref_p (mem))
7820     return 0;
7821
7822   /* If we have legitimate args for ldd/std, we do not want
7823      the split to happen.  */
7824   if ((REGNO (reg) % 2) == 0
7825       && mem_min_alignment (mem, 8))
7826     return 0;
7827
7828   /* Success.  */
7829   return 1;
7830 }
7831
7832 /* Like sparc_splitdi_legitimate but for REG <--> REG moves.  */
7833
7834 int
7835 sparc_split_regreg_legitimate (rtx reg1, rtx reg2)
7836 {
7837   int regno1, regno2;
7838
7839   if (GET_CODE (reg1) == SUBREG)
7840     reg1 = SUBREG_REG (reg1);
7841   if (GET_CODE (reg1) != REG)
7842     return 0;
7843   regno1 = REGNO (reg1);
7844
7845   if (GET_CODE (reg2) == SUBREG)
7846     reg2 = SUBREG_REG (reg2);
7847   if (GET_CODE (reg2) != REG)
7848     return 0;
7849   regno2 = REGNO (reg2);
7850
7851   if (SPARC_INT_REG_P (regno1) && SPARC_INT_REG_P (regno2))
7852     return 1;
7853
7854   if (TARGET_VIS3)
7855     {
7856       if ((SPARC_INT_REG_P (regno1) && SPARC_FP_REG_P (regno2))
7857           || (SPARC_FP_REG_P (regno1) && SPARC_INT_REG_P (regno2)))
7858         return 1;
7859     }
7860
7861   return 0;
7862 }
7863
7864 /* Return 1 if x and y are some kind of REG and they refer to
7865    different hard registers.  This test is guaranteed to be
7866    run after reload.  */
7867
7868 int
7869 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
7870 {
7871   if (GET_CODE (x) != REG)
7872     return 0;
7873   if (GET_CODE (y) != REG)
7874     return 0;
7875   if (REGNO (x) == REGNO (y))
7876     return 0;
7877   return 1;
7878 }
7879
7880 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
7881    This makes them candidates for using ldd and std insns.
7882
7883    Note reg1 and reg2 *must* be hard registers.  */
7884
7885 int
7886 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
7887 {
7888   /* We might have been passed a SUBREG.  */
7889   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
7890     return 0;
7891
7892   if (REGNO (reg1) % 2 != 0)
7893     return 0;
7894
7895   /* Integer ldd is deprecated in SPARC V9 */
7896   if (TARGET_V9 && SPARC_INT_REG_P (REGNO (reg1)))
7897     return 0;
7898
7899   return (REGNO (reg1) == REGNO (reg2) - 1);
7900 }
7901
7902 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
7903    an ldd or std insn.
7904
7905    This can only happen when addr1 and addr2, the addresses in mem1
7906    and mem2, are consecutive memory locations (addr1 + 4 == addr2).
7907    addr1 must also be aligned on a 64-bit boundary.
7908
7909    Also iff dependent_reg_rtx is not null it should not be used to
7910    compute the address for mem1, i.e. we cannot optimize a sequence
7911    like:
7912         ld [%o0], %o0
7913         ld [%o0 + 4], %o1
7914    to
7915         ldd [%o0], %o0
7916    nor:
7917         ld [%g3 + 4], %g3
7918         ld [%g3], %g2
7919    to
7920         ldd [%g3], %g2
7921
7922    But, note that the transformation from:
7923         ld [%g2 + 4], %g3
7924         ld [%g2], %g2
7925    to
7926         ldd [%g2], %g2
7927    is perfectly fine.  Thus, the peephole2 patterns always pass us
7928    the destination register of the first load, never the second one.
7929
7930    For stores we don't have a similar problem, so dependent_reg_rtx is
7931    NULL_RTX.  */
7932
7933 int
7934 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
7935 {
7936   rtx addr1, addr2;
7937   unsigned int reg1;
7938   HOST_WIDE_INT offset1;
7939
7940   /* The mems cannot be volatile.  */
7941   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
7942     return 0;
7943
7944   /* MEM1 should be aligned on a 64-bit boundary.  */
7945   if (MEM_ALIGN (mem1) < 64)
7946     return 0;
7947
7948   addr1 = XEXP (mem1, 0);
7949   addr2 = XEXP (mem2, 0);
7950
7951   /* Extract a register number and offset (if used) from the first addr.  */
7952   if (GET_CODE (addr1) == PLUS)
7953     {
7954       /* If not a REG, return zero.  */
7955       if (GET_CODE (XEXP (addr1, 0)) != REG)
7956         return 0;
7957       else
7958         {
7959           reg1 = REGNO (XEXP (addr1, 0));
7960           /* The offset must be constant!  */
7961           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
7962             return 0;
7963           offset1 = INTVAL (XEXP (addr1, 1));
7964         }
7965     }
7966   else if (GET_CODE (addr1) != REG)
7967     return 0;
7968   else
7969     {
7970       reg1 = REGNO (addr1);
7971       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
7972       offset1 = 0;
7973     }
7974
7975   /* Make sure the second address is a (mem (plus (reg) (const_int).  */
7976   if (GET_CODE (addr2) != PLUS)
7977     return 0;
7978
7979   if (GET_CODE (XEXP (addr2, 0)) != REG
7980       || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
7981     return 0;
7982
7983   if (reg1 != REGNO (XEXP (addr2, 0)))
7984     return 0;
7985
7986   if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
7987     return 0;
7988
7989   /* The first offset must be evenly divisible by 8 to ensure the
7990      address is 64 bit aligned.  */
7991   if (offset1 % 8 != 0)
7992     return 0;
7993
7994   /* The offset for the second addr must be 4 more than the first addr.  */
7995   if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
7996     return 0;
7997
7998   /* All the tests passed.  addr1 and addr2 are valid for ldd and std
7999      instructions.  */
8000   return 1;
8001 }
8002
8003 /* Return 1 if reg is a pseudo, or is the first register in
8004    a hard register pair.  This makes it suitable for use in
8005    ldd and std insns.  */
8006
8007 int
8008 register_ok_for_ldd (rtx reg)
8009 {
8010   /* We might have been passed a SUBREG.  */
8011   if (!REG_P (reg))
8012     return 0;
8013
8014   if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
8015     return (REGNO (reg) % 2 == 0);
8016
8017   return 1;
8018 }
8019
8020 /* Return 1 if OP is a memory whose address is known to be
8021    aligned to 8-byte boundary, or a pseudo during reload.
8022    This makes it suitable for use in ldd and std insns.  */
8023
8024 int
8025 memory_ok_for_ldd (rtx op)
8026 {
8027   if (MEM_P (op))
8028     {
8029       /* In 64-bit mode, we assume that the address is word-aligned.  */
8030       if (TARGET_ARCH32 && !mem_min_alignment (op, 8))
8031         return 0;
8032
8033       if (! can_create_pseudo_p ()
8034           && !strict_memory_address_p (Pmode, XEXP (op, 0)))
8035         return 0;
8036     }
8037   else if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
8038     {
8039       if (!(reload_in_progress && reg_renumber [REGNO (op)] < 0))
8040         return 0;
8041     }
8042   else
8043     return 0;
8044
8045   return 1;
8046 }
8047 \f
8048 /* Implement TARGET_PRINT_OPERAND_PUNCT_VALID_P.  */
8049
8050 static bool
8051 sparc_print_operand_punct_valid_p (unsigned char code)
8052 {
8053   if (code == '#'
8054       || code == '*'
8055       || code == '('
8056       || code == ')'
8057       || code == '_'
8058       || code == '&')
8059     return true;
8060
8061   return false;
8062 }
8063
8064 /* Implement TARGET_PRINT_OPERAND.
8065    Print operand X (an rtx) in assembler syntax to file FILE.
8066    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
8067    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
8068
8069 static void
8070 sparc_print_operand (FILE *file, rtx x, int code)
8071 {
8072   switch (code)
8073     {
8074     case '#':
8075       /* Output an insn in a delay slot.  */
8076       if (final_sequence)
8077         sparc_indent_opcode = 1;
8078       else
8079         fputs ("\n\t nop", file);
8080       return;
8081     case '*':
8082       /* Output an annul flag if there's nothing for the delay slot and we
8083          are optimizing.  This is always used with '(' below.
8084          Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
8085          this is a dbx bug.  So, we only do this when optimizing.
8086          On UltraSPARC, a branch in a delay slot causes a pipeline flush.
8087          Always emit a nop in case the next instruction is a branch.  */
8088       if (! final_sequence && (optimize && (int)sparc_cpu < PROCESSOR_V9))
8089         fputs (",a", file);
8090       return;
8091     case '(':
8092       /* Output a 'nop' if there's nothing for the delay slot and we are
8093          not optimizing.  This is always used with '*' above.  */
8094       if (! final_sequence && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
8095         fputs ("\n\t nop", file);
8096       else if (final_sequence)
8097         sparc_indent_opcode = 1;
8098       return;
8099     case ')':
8100       /* Output the right displacement from the saved PC on function return.
8101          The caller may have placed an "unimp" insn immediately after the call
8102          so we have to account for it.  This insn is used in the 32-bit ABI
8103          when calling a function that returns a non zero-sized structure.  The
8104          64-bit ABI doesn't have it.  Be careful to have this test be the same
8105          as that for the call.  The exception is when sparc_std_struct_return
8106          is enabled, the psABI is followed exactly and the adjustment is made
8107          by the code in sparc_struct_value_rtx.  The call emitted is the same
8108          when sparc_std_struct_return is enabled. */
8109      if (!TARGET_ARCH64
8110          && cfun->returns_struct
8111          && !sparc_std_struct_return
8112          && DECL_SIZE (DECL_RESULT (current_function_decl))
8113          && TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))
8114              == INTEGER_CST
8115          && !integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl))))
8116         fputs ("12", file);
8117       else
8118         fputc ('8', file);
8119       return;
8120     case '_':
8121       /* Output the Embedded Medium/Anywhere code model base register.  */
8122       fputs (EMBMEDANY_BASE_REG, file);
8123       return;
8124     case '&':
8125       /* Print some local dynamic TLS name.  */
8126       assemble_name (file, get_some_local_dynamic_name ());
8127       return;
8128
8129     case 'Y':
8130       /* Adjust the operand to take into account a RESTORE operation.  */
8131       if (GET_CODE (x) == CONST_INT)
8132         break;
8133       else if (GET_CODE (x) != REG)
8134         output_operand_lossage ("invalid %%Y operand");
8135       else if (REGNO (x) < 8)
8136         fputs (reg_names[REGNO (x)], file);
8137       else if (REGNO (x) >= 24 && REGNO (x) < 32)
8138         fputs (reg_names[REGNO (x)-16], file);
8139       else
8140         output_operand_lossage ("invalid %%Y operand");
8141       return;
8142     case 'L':
8143       /* Print out the low order register name of a register pair.  */
8144       if (WORDS_BIG_ENDIAN)
8145         fputs (reg_names[REGNO (x)+1], file);
8146       else
8147         fputs (reg_names[REGNO (x)], file);
8148       return;
8149     case 'H':
8150       /* Print out the high order register name of a register pair.  */
8151       if (WORDS_BIG_ENDIAN)
8152         fputs (reg_names[REGNO (x)], file);
8153       else
8154         fputs (reg_names[REGNO (x)+1], file);
8155       return;
8156     case 'R':
8157       /* Print out the second register name of a register pair or quad.
8158          I.e., R (%o0) => %o1.  */
8159       fputs (reg_names[REGNO (x)+1], file);
8160       return;
8161     case 'S':
8162       /* Print out the third register name of a register quad.
8163          I.e., S (%o0) => %o2.  */
8164       fputs (reg_names[REGNO (x)+2], file);
8165       return;
8166     case 'T':
8167       /* Print out the fourth register name of a register quad.
8168          I.e., T (%o0) => %o3.  */
8169       fputs (reg_names[REGNO (x)+3], file);
8170       return;
8171     case 'x':
8172       /* Print a condition code register.  */
8173       if (REGNO (x) == SPARC_ICC_REG)
8174         {
8175           /* We don't handle CC[X]_NOOVmode because they're not supposed
8176              to occur here.  */
8177           if (GET_MODE (x) == CCmode)
8178             fputs ("%icc", file);
8179           else if (GET_MODE (x) == CCXmode)
8180             fputs ("%xcc", file);
8181           else
8182             gcc_unreachable ();
8183         }
8184       else
8185         /* %fccN register */
8186         fputs (reg_names[REGNO (x)], file);
8187       return;
8188     case 'm':
8189       /* Print the operand's address only.  */
8190       output_address (XEXP (x, 0));
8191       return;
8192     case 'r':
8193       /* In this case we need a register.  Use %g0 if the
8194          operand is const0_rtx.  */
8195       if (x == const0_rtx
8196           || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
8197         {
8198           fputs ("%g0", file);
8199           return;
8200         }
8201       else
8202         break;
8203
8204     case 'A':
8205       switch (GET_CODE (x))
8206         {
8207         case IOR: fputs ("or", file); break;
8208         case AND: fputs ("and", file); break;
8209         case XOR: fputs ("xor", file); break;
8210         default: output_operand_lossage ("invalid %%A operand");
8211         }
8212       return;
8213
8214     case 'B':
8215       switch (GET_CODE (x))
8216         {
8217         case IOR: fputs ("orn", file); break;
8218         case AND: fputs ("andn", file); break;
8219         case XOR: fputs ("xnor", file); break;
8220         default: output_operand_lossage ("invalid %%B operand");
8221         }
8222       return;
8223
8224       /* This is used by the conditional move instructions.  */
8225     case 'C':
8226       {
8227         enum rtx_code rc = GET_CODE (x);
8228
8229         switch (rc)
8230           {
8231           case NE: fputs ("ne", file); break;
8232           case EQ: fputs ("e", file); break;
8233           case GE: fputs ("ge", file); break;
8234           case GT: fputs ("g", file); break;
8235           case LE: fputs ("le", file); break;
8236           case LT: fputs ("l", file); break;
8237           case GEU: fputs ("geu", file); break;
8238           case GTU: fputs ("gu", file); break;
8239           case LEU: fputs ("leu", file); break;
8240           case LTU: fputs ("lu", file); break;
8241           case LTGT: fputs ("lg", file); break;
8242           case UNORDERED: fputs ("u", file); break;
8243           case ORDERED: fputs ("o", file); break;
8244           case UNLT: fputs ("ul", file); break;
8245           case UNLE: fputs ("ule", file); break;
8246           case UNGT: fputs ("ug", file); break;
8247           case UNGE: fputs ("uge", file); break;
8248           case UNEQ: fputs ("ue", file); break;
8249           default: output_operand_lossage ("invalid %%C operand");
8250           }
8251         return;
8252       }
8253
8254       /* This are used by the movr instruction pattern.  */
8255     case 'D':
8256       {
8257         enum rtx_code rc = GET_CODE (x);
8258         switch (rc)
8259           {
8260           case NE: fputs ("ne", file); break;
8261           case EQ: fputs ("e", file); break;
8262           case GE: fputs ("gez", file); break;
8263           case LT: fputs ("lz", file); break;
8264           case LE: fputs ("lez", file); break;
8265           case GT: fputs ("gz", file); break;
8266           default: output_operand_lossage ("invalid %%D operand");
8267           }
8268         return;
8269       }
8270
8271     case 'b':
8272       {
8273         /* Print a sign-extended character.  */
8274         int i = trunc_int_for_mode (INTVAL (x), QImode);
8275         fprintf (file, "%d", i);
8276         return;
8277       }
8278
8279     case 'f':
8280       /* Operand must be a MEM; write its address.  */
8281       if (GET_CODE (x) != MEM)
8282         output_operand_lossage ("invalid %%f operand");
8283       output_address (XEXP (x, 0));
8284       return;
8285
8286     case 's':
8287       {
8288         /* Print a sign-extended 32-bit value.  */
8289         HOST_WIDE_INT i;
8290         if (GET_CODE(x) == CONST_INT)
8291           i = INTVAL (x);
8292         else if (GET_CODE(x) == CONST_DOUBLE)
8293           i = CONST_DOUBLE_LOW (x);
8294         else
8295           {
8296             output_operand_lossage ("invalid %%s operand");
8297             return;
8298           }
8299         i = trunc_int_for_mode (i, SImode);
8300         fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
8301         return;
8302       }
8303
8304     case 0:
8305       /* Do nothing special.  */
8306       break;
8307
8308     default:
8309       /* Undocumented flag.  */
8310       output_operand_lossage ("invalid operand output code");
8311     }
8312
8313   if (GET_CODE (x) == REG)
8314     fputs (reg_names[REGNO (x)], file);
8315   else if (GET_CODE (x) == MEM)
8316     {
8317       fputc ('[', file);
8318         /* Poor Sun assembler doesn't understand absolute addressing.  */
8319       if (CONSTANT_P (XEXP (x, 0)))
8320         fputs ("%g0+", file);
8321       output_address (XEXP (x, 0));
8322       fputc (']', file);
8323     }
8324   else if (GET_CODE (x) == HIGH)
8325     {
8326       fputs ("%hi(", file);
8327       output_addr_const (file, XEXP (x, 0));
8328       fputc (')', file);
8329     }
8330   else if (GET_CODE (x) == LO_SUM)
8331     {
8332       sparc_print_operand (file, XEXP (x, 0), 0);
8333       if (TARGET_CM_MEDMID)
8334         fputs ("+%l44(", file);
8335       else
8336         fputs ("+%lo(", file);
8337       output_addr_const (file, XEXP (x, 1));
8338       fputc (')', file);
8339     }
8340   else if (GET_CODE (x) == CONST_DOUBLE
8341            && (GET_MODE (x) == VOIDmode
8342                || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
8343     {
8344       if (CONST_DOUBLE_HIGH (x) == 0)
8345         fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
8346       else if (CONST_DOUBLE_HIGH (x) == -1
8347                && CONST_DOUBLE_LOW (x) < 0)
8348         fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
8349       else
8350         output_operand_lossage ("long long constant not a valid immediate operand");
8351     }
8352   else if (GET_CODE (x) == CONST_DOUBLE)
8353     output_operand_lossage ("floating point constant not a valid immediate operand");
8354   else { output_addr_const (file, x); }
8355 }
8356
8357 /* Implement TARGET_PRINT_OPERAND_ADDRESS.  */
8358
8359 static void
8360 sparc_print_operand_address (FILE *file, rtx x)
8361 {
8362   register rtx base, index = 0;
8363   int offset = 0;
8364   register rtx addr = x;
8365
8366   if (REG_P (addr))
8367     fputs (reg_names[REGNO (addr)], file);
8368   else if (GET_CODE (addr) == PLUS)
8369     {
8370       if (CONST_INT_P (XEXP (addr, 0)))
8371         offset = INTVAL (XEXP (addr, 0)), base = XEXP (addr, 1);
8372       else if (CONST_INT_P (XEXP (addr, 1)))
8373         offset = INTVAL (XEXP (addr, 1)), base = XEXP (addr, 0);
8374       else
8375         base = XEXP (addr, 0), index = XEXP (addr, 1);
8376       if (GET_CODE (base) == LO_SUM)
8377         {
8378           gcc_assert (USE_AS_OFFSETABLE_LO10
8379                       && TARGET_ARCH64
8380                       && ! TARGET_CM_MEDMID);
8381           output_operand (XEXP (base, 0), 0);
8382           fputs ("+%lo(", file);
8383           output_address (XEXP (base, 1));
8384           fprintf (file, ")+%d", offset);
8385         }
8386       else
8387         {
8388           fputs (reg_names[REGNO (base)], file);
8389           if (index == 0)
8390             fprintf (file, "%+d", offset);
8391           else if (REG_P (index))
8392             fprintf (file, "+%s", reg_names[REGNO (index)]);
8393           else if (GET_CODE (index) == SYMBOL_REF
8394                    || GET_CODE (index) == LABEL_REF
8395                    || GET_CODE (index) == CONST)
8396             fputc ('+', file), output_addr_const (file, index);
8397           else gcc_unreachable ();
8398         }
8399     }
8400   else if (GET_CODE (addr) == MINUS
8401            && GET_CODE (XEXP (addr, 1)) == LABEL_REF)
8402     {
8403       output_addr_const (file, XEXP (addr, 0));
8404       fputs ("-(", file);
8405       output_addr_const (file, XEXP (addr, 1));
8406       fputs ("-.)", file);
8407     }
8408   else if (GET_CODE (addr) == LO_SUM)
8409     {
8410       output_operand (XEXP (addr, 0), 0);
8411       if (TARGET_CM_MEDMID)
8412         fputs ("+%l44(", file);
8413       else
8414         fputs ("+%lo(", file);
8415       output_address (XEXP (addr, 1));
8416       fputc (')', file);
8417     }
8418   else if (flag_pic
8419            && GET_CODE (addr) == CONST
8420            && GET_CODE (XEXP (addr, 0)) == MINUS
8421            && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST
8422            && GET_CODE (XEXP (XEXP (XEXP (addr, 0), 1), 0)) == MINUS
8423            && XEXP (XEXP (XEXP (XEXP (addr, 0), 1), 0), 1) == pc_rtx)
8424     {
8425       addr = XEXP (addr, 0);
8426       output_addr_const (file, XEXP (addr, 0));
8427       /* Group the args of the second CONST in parenthesis.  */
8428       fputs ("-(", file);
8429       /* Skip past the second CONST--it does nothing for us.  */
8430       output_addr_const (file, XEXP (XEXP (addr, 1), 0));
8431       /* Close the parenthesis.  */
8432       fputc (')', file);
8433     }
8434   else
8435     {
8436       output_addr_const (file, addr);
8437     }
8438 }
8439 \f
8440 /* Target hook for assembling integer objects.  The sparc version has
8441    special handling for aligned DI-mode objects.  */
8442
8443 static bool
8444 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
8445 {
8446   /* ??? We only output .xword's for symbols and only then in environments
8447      where the assembler can handle them.  */
8448   if (aligned_p && size == 8
8449       && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
8450     {
8451       if (TARGET_V9)
8452         {
8453           assemble_integer_with_op ("\t.xword\t", x);
8454           return true;
8455         }
8456       else
8457         {
8458           assemble_aligned_integer (4, const0_rtx);
8459           assemble_aligned_integer (4, x);
8460           return true;
8461         }
8462     }
8463   return default_assemble_integer (x, size, aligned_p);
8464 }
8465 \f
8466 /* Return the value of a code used in the .proc pseudo-op that says
8467    what kind of result this function returns.  For non-C types, we pick
8468    the closest C type.  */
8469
8470 #ifndef SHORT_TYPE_SIZE
8471 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
8472 #endif
8473
8474 #ifndef INT_TYPE_SIZE
8475 #define INT_TYPE_SIZE BITS_PER_WORD
8476 #endif
8477
8478 #ifndef LONG_TYPE_SIZE
8479 #define LONG_TYPE_SIZE BITS_PER_WORD
8480 #endif
8481
8482 #ifndef LONG_LONG_TYPE_SIZE
8483 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
8484 #endif
8485
8486 #ifndef FLOAT_TYPE_SIZE
8487 #define FLOAT_TYPE_SIZE BITS_PER_WORD
8488 #endif
8489
8490 #ifndef DOUBLE_TYPE_SIZE
8491 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8492 #endif
8493
8494 #ifndef LONG_DOUBLE_TYPE_SIZE
8495 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
8496 #endif
8497
8498 unsigned long
8499 sparc_type_code (register tree type)
8500 {
8501   register unsigned long qualifiers = 0;
8502   register unsigned shift;
8503
8504   /* Only the first 30 bits of the qualifier are valid.  We must refrain from
8505      setting more, since some assemblers will give an error for this.  Also,
8506      we must be careful to avoid shifts of 32 bits or more to avoid getting
8507      unpredictable results.  */
8508
8509   for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
8510     {
8511       switch (TREE_CODE (type))
8512         {
8513         case ERROR_MARK:
8514           return qualifiers;
8515
8516         case ARRAY_TYPE:
8517           qualifiers |= (3 << shift);
8518           break;
8519
8520         case FUNCTION_TYPE:
8521         case METHOD_TYPE:
8522           qualifiers |= (2 << shift);
8523           break;
8524
8525         case POINTER_TYPE:
8526         case REFERENCE_TYPE:
8527         case OFFSET_TYPE:
8528           qualifiers |= (1 << shift);
8529           break;
8530
8531         case RECORD_TYPE:
8532           return (qualifiers | 8);
8533
8534         case UNION_TYPE:
8535         case QUAL_UNION_TYPE:
8536           return (qualifiers | 9);
8537
8538         case ENUMERAL_TYPE:
8539           return (qualifiers | 10);
8540
8541         case VOID_TYPE:
8542           return (qualifiers | 16);
8543
8544         case INTEGER_TYPE:
8545           /* If this is a range type, consider it to be the underlying
8546              type.  */
8547           if (TREE_TYPE (type) != 0)
8548             break;
8549
8550           /* Carefully distinguish all the standard types of C,
8551              without messing up if the language is not C.  We do this by
8552              testing TYPE_PRECISION and TYPE_UNSIGNED.  The old code used to
8553              look at both the names and the above fields, but that's redundant.
8554              Any type whose size is between two C types will be considered
8555              to be the wider of the two types.  Also, we do not have a
8556              special code to use for "long long", so anything wider than
8557              long is treated the same.  Note that we can't distinguish
8558              between "int" and "long" in this code if they are the same
8559              size, but that's fine, since neither can the assembler.  */
8560
8561           if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
8562             return (qualifiers | (TYPE_UNSIGNED (type) ? 12 : 2));
8563
8564           else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
8565             return (qualifiers | (TYPE_UNSIGNED (type) ? 13 : 3));
8566
8567           else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
8568             return (qualifiers | (TYPE_UNSIGNED (type) ? 14 : 4));
8569
8570           else
8571             return (qualifiers | (TYPE_UNSIGNED (type) ? 15 : 5));
8572
8573         case REAL_TYPE:
8574           /* If this is a range type, consider it to be the underlying
8575              type.  */
8576           if (TREE_TYPE (type) != 0)
8577             break;
8578
8579           /* Carefully distinguish all the standard types of C,
8580              without messing up if the language is not C.  */
8581
8582           if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
8583             return (qualifiers | 6);
8584
8585           else
8586             return (qualifiers | 7);
8587
8588         case COMPLEX_TYPE:      /* GNU Fortran COMPLEX type.  */
8589           /* ??? We need to distinguish between double and float complex types,
8590              but I don't know how yet because I can't reach this code from
8591              existing front-ends.  */
8592           return (qualifiers | 7);      /* Who knows? */
8593
8594         case VECTOR_TYPE:
8595         case BOOLEAN_TYPE:      /* Boolean truth value type.  */
8596         case LANG_TYPE:
8597         case NULLPTR_TYPE:
8598           return qualifiers;
8599
8600         default:
8601           gcc_unreachable ();           /* Not a type! */
8602         }
8603     }
8604
8605   return qualifiers;
8606 }
8607 \f
8608 /* Nested function support.  */
8609
8610 /* Emit RTL insns to initialize the variable parts of a trampoline.
8611    FNADDR is an RTX for the address of the function's pure code.
8612    CXT is an RTX for the static chain value for the function.
8613
8614    This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
8615    (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
8616    (to store insns).  This is a bit excessive.  Perhaps a different
8617    mechanism would be better here.
8618
8619    Emit enough FLUSH insns to synchronize the data and instruction caches.  */
8620
8621 static void
8622 sparc32_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8623 {
8624   /* SPARC 32-bit trampoline:
8625
8626         sethi   %hi(fn), %g1
8627         sethi   %hi(static), %g2
8628         jmp     %g1+%lo(fn)
8629         or      %g2, %lo(static), %g2
8630
8631     SETHI i,r  = 00rr rrr1 00ii iiii iiii iiii iiii iiii
8632     JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
8633    */
8634
8635   emit_move_insn
8636     (adjust_address (m_tramp, SImode, 0),
8637      expand_binop (SImode, ior_optab,
8638                    expand_shift (RSHIFT_EXPR, SImode, fnaddr, 10, 0, 1),
8639                    GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
8640                    NULL_RTX, 1, OPTAB_DIRECT));
8641
8642   emit_move_insn
8643     (adjust_address (m_tramp, SImode, 4),
8644      expand_binop (SImode, ior_optab,
8645                    expand_shift (RSHIFT_EXPR, SImode, cxt, 10, 0, 1),
8646                    GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
8647                    NULL_RTX, 1, OPTAB_DIRECT));
8648
8649   emit_move_insn
8650     (adjust_address (m_tramp, SImode, 8),
8651      expand_binop (SImode, ior_optab,
8652                    expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
8653                    GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
8654                    NULL_RTX, 1, OPTAB_DIRECT));
8655
8656   emit_move_insn
8657     (adjust_address (m_tramp, SImode, 12),
8658      expand_binop (SImode, ior_optab,
8659                    expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
8660                    GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
8661                    NULL_RTX, 1, OPTAB_DIRECT));
8662
8663   /* On UltraSPARC a flush flushes an entire cache line.  The trampoline is
8664      aligned on a 16 byte boundary so one flush clears it all.  */
8665   emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 0))));
8666   if (sparc_cpu != PROCESSOR_ULTRASPARC
8667       && sparc_cpu != PROCESSOR_ULTRASPARC3
8668       && sparc_cpu != PROCESSOR_NIAGARA
8669       && sparc_cpu != PROCESSOR_NIAGARA2
8670       && sparc_cpu != PROCESSOR_NIAGARA3
8671       && sparc_cpu != PROCESSOR_NIAGARA4)
8672     emit_insn (gen_flush (validize_mem (adjust_address (m_tramp, SImode, 8))));
8673
8674   /* Call __enable_execute_stack after writing onto the stack to make sure
8675      the stack address is accessible.  */
8676 #ifdef HAVE_ENABLE_EXECUTE_STACK
8677   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8678                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8679 #endif
8680
8681 }
8682
8683 /* The 64-bit version is simpler because it makes more sense to load the
8684    values as "immediate" data out of the trampoline.  It's also easier since
8685    we can read the PC without clobbering a register.  */
8686
8687 static void
8688 sparc64_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
8689 {
8690   /* SPARC 64-bit trampoline:
8691
8692         rd      %pc, %g1
8693         ldx     [%g1+24], %g5
8694         jmp     %g5
8695         ldx     [%g1+16], %g5
8696         +16 bytes data
8697    */
8698
8699   emit_move_insn (adjust_address (m_tramp, SImode, 0),
8700                   GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
8701   emit_move_insn (adjust_address (m_tramp, SImode, 4),
8702                   GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
8703   emit_move_insn (adjust_address (m_tramp, SImode, 8),
8704                   GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
8705   emit_move_insn (adjust_address (m_tramp, SImode, 12),
8706                   GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
8707   emit_move_insn (adjust_address (m_tramp, DImode, 16), cxt);
8708   emit_move_insn (adjust_address (m_tramp, DImode, 24), fnaddr);
8709   emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 0))));
8710
8711   if (sparc_cpu != PROCESSOR_ULTRASPARC
8712       && sparc_cpu != PROCESSOR_ULTRASPARC3
8713       && sparc_cpu != PROCESSOR_NIAGARA
8714       && sparc_cpu != PROCESSOR_NIAGARA2
8715       && sparc_cpu != PROCESSOR_NIAGARA3
8716       && sparc_cpu != PROCESSOR_NIAGARA4)
8717     emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 8))));
8718
8719   /* Call __enable_execute_stack after writing onto the stack to make sure
8720      the stack address is accessible.  */
8721 #ifdef HAVE_ENABLE_EXECUTE_STACK
8722   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
8723                      LCT_NORMAL, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
8724 #endif
8725 }
8726
8727 /* Worker for TARGET_TRAMPOLINE_INIT.  */
8728
8729 static void
8730 sparc_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
8731 {
8732   rtx fnaddr = force_reg (Pmode, XEXP (DECL_RTL (fndecl), 0));
8733   cxt = force_reg (Pmode, cxt);
8734   if (TARGET_ARCH64)
8735     sparc64_initialize_trampoline (m_tramp, fnaddr, cxt);
8736   else
8737     sparc32_initialize_trampoline (m_tramp, fnaddr, cxt);
8738 }
8739 \f
8740 /* Adjust the cost of a scheduling dependency.  Return the new cost of
8741    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
8742
8743 static int
8744 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8745 {
8746   enum attr_type insn_type;
8747
8748   if (! recog_memoized (insn))
8749     return 0;
8750
8751   insn_type = get_attr_type (insn);
8752
8753   if (REG_NOTE_KIND (link) == 0)
8754     {
8755       /* Data dependency; DEP_INSN writes a register that INSN reads some
8756          cycles later.  */
8757
8758       /* if a load, then the dependence must be on the memory address;
8759          add an extra "cycle".  Note that the cost could be two cycles
8760          if the reg was written late in an instruction group; we ca not tell
8761          here.  */
8762       if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
8763         return cost + 3;
8764
8765       /* Get the delay only if the address of the store is the dependence.  */
8766       if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
8767         {
8768           rtx pat = PATTERN(insn);
8769           rtx dep_pat = PATTERN (dep_insn);
8770
8771           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8772             return cost;  /* This should not happen!  */
8773
8774           /* The dependency between the two instructions was on the data that
8775              is being stored.  Assume that this implies that the address of the
8776              store is not dependent.  */
8777           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8778             return cost;
8779
8780           return cost + 3;  /* An approximation.  */
8781         }
8782
8783       /* A shift instruction cannot receive its data from an instruction
8784          in the same cycle; add a one cycle penalty.  */
8785       if (insn_type == TYPE_SHIFT)
8786         return cost + 3;   /* Split before cascade into shift.  */
8787     }
8788   else
8789     {
8790       /* Anti- or output- dependency; DEP_INSN reads/writes a register that
8791          INSN writes some cycles later.  */
8792
8793       /* These are only significant for the fpu unit; writing a fp reg before
8794          the fpu has finished with it stalls the processor.  */
8795
8796       /* Reusing an integer register causes no problems.  */
8797       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8798         return 0;
8799     }
8800
8801   return cost;
8802 }
8803
8804 static int
8805 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8806 {
8807   enum attr_type insn_type, dep_type;
8808   rtx pat = PATTERN(insn);
8809   rtx dep_pat = PATTERN (dep_insn);
8810
8811   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
8812     return cost;
8813
8814   insn_type = get_attr_type (insn);
8815   dep_type = get_attr_type (dep_insn);
8816
8817   switch (REG_NOTE_KIND (link))
8818     {
8819     case 0:
8820       /* Data dependency; DEP_INSN writes a register that INSN reads some
8821          cycles later.  */
8822
8823       switch (insn_type)
8824         {
8825         case TYPE_STORE:
8826         case TYPE_FPSTORE:
8827           /* Get the delay iff the address of the store is the dependence.  */
8828           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8829             return cost;
8830
8831           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8832             return cost;
8833           return cost + 3;
8834
8835         case TYPE_LOAD:
8836         case TYPE_SLOAD:
8837         case TYPE_FPLOAD:
8838           /* If a load, then the dependence must be on the memory address.  If
8839              the addresses aren't equal, then it might be a false dependency */
8840           if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
8841             {
8842               if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
8843                   || GET_CODE (SET_DEST (dep_pat)) != MEM
8844                   || GET_CODE (SET_SRC (pat)) != MEM
8845                   || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
8846                                     XEXP (SET_SRC (pat), 0)))
8847                 return cost + 2;
8848
8849               return cost + 8;
8850             }
8851           break;
8852
8853         case TYPE_BRANCH:
8854           /* Compare to branch latency is 0.  There is no benefit from
8855              separating compare and branch.  */
8856           if (dep_type == TYPE_COMPARE)
8857             return 0;
8858           /* Floating point compare to branch latency is less than
8859              compare to conditional move.  */
8860           if (dep_type == TYPE_FPCMP)
8861             return cost - 1;
8862           break;
8863         default:
8864           break;
8865         }
8866         break;
8867
8868     case REG_DEP_ANTI:
8869       /* Anti-dependencies only penalize the fpu unit.  */
8870       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8871         return 0;
8872       break;
8873
8874     default:
8875       break;
8876     }
8877
8878   return cost;
8879 }
8880
8881 static int
8882 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
8883 {
8884   switch (sparc_cpu)
8885     {
8886     case PROCESSOR_SUPERSPARC:
8887       cost = supersparc_adjust_cost (insn, link, dep, cost);
8888       break;
8889     case PROCESSOR_HYPERSPARC:
8890     case PROCESSOR_SPARCLITE86X:
8891       cost = hypersparc_adjust_cost (insn, link, dep, cost);
8892       break;
8893     default:
8894       break;
8895     }
8896   return cost;
8897 }
8898
8899 static void
8900 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
8901                   int sched_verbose ATTRIBUTE_UNUSED,
8902                   int max_ready ATTRIBUTE_UNUSED)
8903 {}
8904
8905 static int
8906 sparc_use_sched_lookahead (void)
8907 {
8908   if (sparc_cpu == PROCESSOR_NIAGARA
8909       || sparc_cpu == PROCESSOR_NIAGARA2
8910       || sparc_cpu == PROCESSOR_NIAGARA3
8911       || sparc_cpu == PROCESSOR_NIAGARA4)
8912     return 0;
8913   if (sparc_cpu == PROCESSOR_ULTRASPARC
8914       || sparc_cpu == PROCESSOR_ULTRASPARC3)
8915     return 4;
8916   if ((1 << sparc_cpu) &
8917       ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
8918        (1 << PROCESSOR_SPARCLITE86X)))
8919     return 3;
8920   return 0;
8921 }
8922
8923 static int
8924 sparc_issue_rate (void)
8925 {
8926   switch (sparc_cpu)
8927     {
8928     case PROCESSOR_NIAGARA:
8929     case PROCESSOR_NIAGARA2:
8930     case PROCESSOR_NIAGARA3:
8931     case PROCESSOR_NIAGARA4:
8932     default:
8933       return 1;
8934     case PROCESSOR_V9:
8935       /* Assume V9 processors are capable of at least dual-issue.  */
8936       return 2;
8937     case PROCESSOR_SUPERSPARC:
8938       return 3;
8939     case PROCESSOR_HYPERSPARC:
8940     case PROCESSOR_SPARCLITE86X:
8941       return 2;
8942     case PROCESSOR_ULTRASPARC:
8943     case PROCESSOR_ULTRASPARC3:
8944       return 4;
8945     }
8946 }
8947
8948 static int
8949 set_extends (rtx insn)
8950 {
8951   register rtx pat = PATTERN (insn);
8952
8953   switch (GET_CODE (SET_SRC (pat)))
8954     {
8955       /* Load and some shift instructions zero extend.  */
8956     case MEM:
8957     case ZERO_EXTEND:
8958       /* sethi clears the high bits */
8959     case HIGH:
8960       /* LO_SUM is used with sethi.  sethi cleared the high
8961          bits and the values used with lo_sum are positive */
8962     case LO_SUM:
8963       /* Store flag stores 0 or 1 */
8964     case LT: case LTU:
8965     case GT: case GTU:
8966     case LE: case LEU:
8967     case GE: case GEU:
8968     case EQ:
8969     case NE:
8970       return 1;
8971     case AND:
8972       {
8973         rtx op0 = XEXP (SET_SRC (pat), 0);
8974         rtx op1 = XEXP (SET_SRC (pat), 1);
8975         if (GET_CODE (op1) == CONST_INT)
8976           return INTVAL (op1) >= 0;
8977         if (GET_CODE (op0) != REG)
8978           return 0;
8979         if (sparc_check_64 (op0, insn) == 1)
8980           return 1;
8981         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8982       }
8983     case IOR:
8984     case XOR:
8985       {
8986         rtx op0 = XEXP (SET_SRC (pat), 0);
8987         rtx op1 = XEXP (SET_SRC (pat), 1);
8988         if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
8989           return 0;
8990         if (GET_CODE (op1) == CONST_INT)
8991           return INTVAL (op1) >= 0;
8992         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8993       }
8994     case LSHIFTRT:
8995       return GET_MODE (SET_SRC (pat)) == SImode;
8996       /* Positive integers leave the high bits zero.  */
8997     case CONST_DOUBLE:
8998       return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
8999     case CONST_INT:
9000       return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
9001     case ASHIFTRT:
9002     case SIGN_EXTEND:
9003       return - (GET_MODE (SET_SRC (pat)) == SImode);
9004     case REG:
9005       return sparc_check_64 (SET_SRC (pat), insn);
9006     default:
9007       return 0;
9008     }
9009 }
9010
9011 /* We _ought_ to have only one kind per function, but...  */
9012 static GTY(()) rtx sparc_addr_diff_list;
9013 static GTY(()) rtx sparc_addr_list;
9014
9015 void
9016 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
9017 {
9018   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
9019   if (diff)
9020     sparc_addr_diff_list
9021       = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
9022   else
9023     sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
9024 }
9025
9026 static void
9027 sparc_output_addr_vec (rtx vec)
9028 {
9029   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
9030   int idx, vlen = XVECLEN (body, 0);
9031
9032 #ifdef ASM_OUTPUT_ADDR_VEC_START
9033   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
9034 #endif
9035
9036 #ifdef ASM_OUTPUT_CASE_LABEL
9037   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
9038                          NEXT_INSN (lab));
9039 #else
9040   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
9041 #endif
9042
9043   for (idx = 0; idx < vlen; idx++)
9044     {
9045       ASM_OUTPUT_ADDR_VEC_ELT
9046         (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
9047     }
9048
9049 #ifdef ASM_OUTPUT_ADDR_VEC_END
9050   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
9051 #endif
9052 }
9053
9054 static void
9055 sparc_output_addr_diff_vec (rtx vec)
9056 {
9057   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
9058   rtx base = XEXP (XEXP (body, 0), 0);
9059   int idx, vlen = XVECLEN (body, 1);
9060
9061 #ifdef ASM_OUTPUT_ADDR_VEC_START
9062   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
9063 #endif
9064
9065 #ifdef ASM_OUTPUT_CASE_LABEL
9066   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
9067                          NEXT_INSN (lab));
9068 #else
9069   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
9070 #endif
9071
9072   for (idx = 0; idx < vlen; idx++)
9073     {
9074       ASM_OUTPUT_ADDR_DIFF_ELT
9075         (asm_out_file,
9076          body,
9077          CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
9078          CODE_LABEL_NUMBER (base));
9079     }
9080
9081 #ifdef ASM_OUTPUT_ADDR_VEC_END
9082   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
9083 #endif
9084 }
9085
9086 static void
9087 sparc_output_deferred_case_vectors (void)
9088 {
9089   rtx t;
9090   int align;
9091
9092   if (sparc_addr_list == NULL_RTX
9093       && sparc_addr_diff_list == NULL_RTX)
9094     return;
9095
9096   /* Align to cache line in the function's code section.  */
9097   switch_to_section (current_function_section ());
9098
9099   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
9100   if (align > 0)
9101     ASM_OUTPUT_ALIGN (asm_out_file, align);
9102
9103   for (t = sparc_addr_list; t ; t = XEXP (t, 1))
9104     sparc_output_addr_vec (XEXP (t, 0));
9105   for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
9106     sparc_output_addr_diff_vec (XEXP (t, 0));
9107
9108   sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
9109 }
9110
9111 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
9112    unknown.  Return 1 if the high bits are zero, -1 if the register is
9113    sign extended.  */
9114 int
9115 sparc_check_64 (rtx x, rtx insn)
9116 {
9117   /* If a register is set only once it is safe to ignore insns this
9118      code does not know how to handle.  The loop will either recognize
9119      the single set and return the correct value or fail to recognize
9120      it and return 0.  */
9121   int set_once = 0;
9122   rtx y = x;
9123
9124   gcc_assert (GET_CODE (x) == REG);
9125
9126   if (GET_MODE (x) == DImode)
9127     y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
9128
9129   if (flag_expensive_optimizations
9130       && df && DF_REG_DEF_COUNT (REGNO (y)) == 1)
9131     set_once = 1;
9132
9133   if (insn == 0)
9134     {
9135       if (set_once)
9136         insn = get_last_insn_anywhere ();
9137       else
9138         return 0;
9139     }
9140
9141   while ((insn = PREV_INSN (insn)))
9142     {
9143       switch (GET_CODE (insn))
9144         {
9145         case JUMP_INSN:
9146         case NOTE:
9147           break;
9148         case CODE_LABEL:
9149         case CALL_INSN:
9150         default:
9151           if (! set_once)
9152             return 0;
9153           break;
9154         case INSN:
9155           {
9156             rtx pat = PATTERN (insn);
9157             if (GET_CODE (pat) != SET)
9158               return 0;
9159             if (rtx_equal_p (x, SET_DEST (pat)))
9160               return set_extends (insn);
9161             if (y && rtx_equal_p (y, SET_DEST (pat)))
9162               return set_extends (insn);
9163             if (reg_overlap_mentioned_p (SET_DEST (pat), y))
9164               return 0;
9165           }
9166         }
9167     }
9168   return 0;
9169 }
9170
9171 /* Output a wide shift instruction in V8+ mode.  INSN is the instruction,
9172    OPERANDS are its operands and OPCODE is the mnemonic to be used.  */
9173
9174 const char *
9175 output_v8plus_shift (rtx insn, rtx *operands, const char *opcode)
9176 {
9177   static char asm_code[60];
9178
9179   /* The scratch register is only required when the destination
9180      register is not a 64-bit global or out register.  */
9181   if (which_alternative != 2)
9182     operands[3] = operands[0];
9183
9184   /* We can only shift by constants <= 63. */
9185   if (GET_CODE (operands[2]) == CONST_INT)
9186     operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
9187
9188   if (GET_CODE (operands[1]) == CONST_INT)
9189     {
9190       output_asm_insn ("mov\t%1, %3", operands);
9191     }
9192   else
9193     {
9194       output_asm_insn ("sllx\t%H1, 32, %3", operands);
9195       if (sparc_check_64 (operands[1], insn) <= 0)
9196         output_asm_insn ("srl\t%L1, 0, %L1", operands);
9197       output_asm_insn ("or\t%L1, %3, %3", operands);
9198     }
9199
9200   strcpy (asm_code, opcode);
9201
9202   if (which_alternative != 2)
9203     return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
9204   else
9205     return
9206       strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
9207 }
9208 \f
9209 /* Output rtl to increment the profiler label LABELNO
9210    for profiling a function entry.  */
9211
9212 void
9213 sparc_profile_hook (int labelno)
9214 {
9215   char buf[32];
9216   rtx lab, fun;
9217
9218   fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
9219   if (NO_PROFILE_COUNTERS)
9220     {
9221       emit_library_call (fun, LCT_NORMAL, VOIDmode, 0);
9222     }
9223   else
9224     {
9225       ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
9226       lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
9227       emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
9228     }
9229 }
9230 \f
9231 #ifdef TARGET_SOLARIS
9232 /* Solaris implementation of TARGET_ASM_NAMED_SECTION.  */
9233
9234 static void
9235 sparc_solaris_elf_asm_named_section (const char *name, unsigned int flags,
9236                                      tree decl ATTRIBUTE_UNUSED)
9237 {
9238   if (HAVE_COMDAT_GROUP && flags & SECTION_LINKONCE)
9239     {
9240       solaris_elf_asm_comdat_section (name, flags, decl);
9241       return;
9242     }
9243
9244   fprintf (asm_out_file, "\t.section\t\"%s\"", name);
9245
9246   if (!(flags & SECTION_DEBUG))
9247     fputs (",#alloc", asm_out_file);
9248   if (flags & SECTION_WRITE)
9249     fputs (",#write", asm_out_file);
9250   if (flags & SECTION_TLS)
9251     fputs (",#tls", asm_out_file);
9252   if (flags & SECTION_CODE)
9253     fputs (",#execinstr", asm_out_file);
9254
9255   /* ??? Handle SECTION_BSS.  */
9256
9257   fputc ('\n', asm_out_file);
9258 }
9259 #endif /* TARGET_SOLARIS */
9260
9261 /* We do not allow indirect calls to be optimized into sibling calls.
9262
9263    We cannot use sibling calls when delayed branches are disabled
9264    because they will likely require the call delay slot to be filled.
9265
9266    Also, on SPARC 32-bit we cannot emit a sibling call when the
9267    current function returns a structure.  This is because the "unimp
9268    after call" convention would cause the callee to return to the
9269    wrong place.  The generic code already disallows cases where the
9270    function being called returns a structure.
9271
9272    It may seem strange how this last case could occur.  Usually there
9273    is code after the call which jumps to epilogue code which dumps the
9274    return value into the struct return area.  That ought to invalidate
9275    the sibling call right?  Well, in the C++ case we can end up passing
9276    the pointer to the struct return area to a constructor (which returns
9277    void) and then nothing else happens.  Such a sibling call would look
9278    valid without the added check here.
9279
9280    VxWorks PIC PLT entries require the global pointer to be initialized
9281    on entry.  We therefore can't emit sibling calls to them.  */
9282 static bool
9283 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
9284 {
9285   return (decl
9286           && flag_delayed_branch
9287           && (TARGET_ARCH64 || ! cfun->returns_struct)
9288           && !(TARGET_VXWORKS_RTP
9289                && flag_pic
9290                && !targetm.binds_local_p (decl)));
9291 }
9292 \f
9293 /* libfunc renaming.  */
9294
9295 static void
9296 sparc_init_libfuncs (void)
9297 {
9298   if (TARGET_ARCH32)
9299     {
9300       /* Use the subroutines that Sun's library provides for integer
9301          multiply and divide.  The `*' prevents an underscore from
9302          being prepended by the compiler. .umul is a little faster
9303          than .mul.  */
9304       set_optab_libfunc (smul_optab, SImode, "*.umul");
9305       set_optab_libfunc (sdiv_optab, SImode, "*.div");
9306       set_optab_libfunc (udiv_optab, SImode, "*.udiv");
9307       set_optab_libfunc (smod_optab, SImode, "*.rem");
9308       set_optab_libfunc (umod_optab, SImode, "*.urem");
9309
9310       /* TFmode arithmetic.  These names are part of the SPARC 32bit ABI.  */
9311       set_optab_libfunc (add_optab, TFmode, "_Q_add");
9312       set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
9313       set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
9314       set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
9315       set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
9316
9317       /* We can define the TFmode sqrt optab only if TARGET_FPU.  This
9318          is because with soft-float, the SFmode and DFmode sqrt
9319          instructions will be absent, and the compiler will notice and
9320          try to use the TFmode sqrt instruction for calls to the
9321          builtin function sqrt, but this fails.  */
9322       if (TARGET_FPU)
9323         set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
9324
9325       set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
9326       set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
9327       set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
9328       set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
9329       set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
9330       set_optab_libfunc (le_optab, TFmode, "_Q_fle");
9331
9332       set_conv_libfunc (sext_optab,   TFmode, SFmode, "_Q_stoq");
9333       set_conv_libfunc (sext_optab,   TFmode, DFmode, "_Q_dtoq");
9334       set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_Q_qtos");
9335       set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_Q_qtod");
9336
9337       set_conv_libfunc (sfix_optab,   SImode, TFmode, "_Q_qtoi");
9338       set_conv_libfunc (ufix_optab,   SImode, TFmode, "_Q_qtou");
9339       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
9340       set_conv_libfunc (ufloat_optab, TFmode, SImode, "_Q_utoq");
9341
9342       if (DITF_CONVERSION_LIBFUNCS)
9343         {
9344           set_conv_libfunc (sfix_optab,   DImode, TFmode, "_Q_qtoll");
9345           set_conv_libfunc (ufix_optab,   DImode, TFmode, "_Q_qtoull");
9346           set_conv_libfunc (sfloat_optab, TFmode, DImode, "_Q_lltoq");
9347           set_conv_libfunc (ufloat_optab, TFmode, DImode, "_Q_ulltoq");
9348         }
9349
9350       if (SUN_CONVERSION_LIBFUNCS)
9351         {
9352           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
9353           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
9354           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
9355           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
9356         }
9357     }
9358   if (TARGET_ARCH64)
9359     {
9360       /* In the SPARC 64bit ABI, SImode multiply and divide functions
9361          do not exist in the library.  Make sure the compiler does not
9362          emit calls to them by accident.  (It should always use the
9363          hardware instructions.)  */
9364       set_optab_libfunc (smul_optab, SImode, 0);
9365       set_optab_libfunc (sdiv_optab, SImode, 0);
9366       set_optab_libfunc (udiv_optab, SImode, 0);
9367       set_optab_libfunc (smod_optab, SImode, 0);
9368       set_optab_libfunc (umod_optab, SImode, 0);
9369
9370       if (SUN_INTEGER_MULTIPLY_64)
9371         {
9372           set_optab_libfunc (smul_optab, DImode, "__mul64");
9373           set_optab_libfunc (sdiv_optab, DImode, "__div64");
9374           set_optab_libfunc (udiv_optab, DImode, "__udiv64");
9375           set_optab_libfunc (smod_optab, DImode, "__rem64");
9376           set_optab_libfunc (umod_optab, DImode, "__urem64");
9377         }
9378
9379       if (SUN_CONVERSION_LIBFUNCS)
9380         {
9381           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
9382           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
9383           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
9384           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
9385         }
9386     }
9387 }
9388 \f
9389 static tree def_builtin(const char *name, int code, tree type)
9390 {
9391   return add_builtin_function(name, type, code, BUILT_IN_MD, NULL,
9392                               NULL_TREE);
9393 }
9394
9395 static tree def_builtin_const(const char *name, int code, tree type)
9396 {
9397   tree t = def_builtin(name, code, type);
9398
9399   if (t)
9400     TREE_READONLY (t) = 1;
9401
9402   return t;
9403 }
9404
9405 /* Implement the TARGET_INIT_BUILTINS target hook.
9406    Create builtin functions for special SPARC instructions.  */
9407
9408 static void
9409 sparc_init_builtins (void)
9410 {
9411   if (TARGET_VIS)
9412     sparc_vis_init_builtins ();
9413 }
9414
9415 /* Create builtin functions for VIS 1.0 instructions.  */
9416
9417 static void
9418 sparc_vis_init_builtins (void)
9419 {
9420   tree v4qi = build_vector_type (unsigned_intQI_type_node, 4);
9421   tree v8qi = build_vector_type (unsigned_intQI_type_node, 8);
9422   tree v4hi = build_vector_type (intHI_type_node, 4);
9423   tree v2hi = build_vector_type (intHI_type_node, 2);
9424   tree v2si = build_vector_type (intSI_type_node, 2);
9425   tree v1si = build_vector_type (intSI_type_node, 1);
9426
9427   tree v4qi_ftype_v4hi = build_function_type_list (v4qi, v4hi, 0);
9428   tree v8qi_ftype_v2si_v8qi = build_function_type_list (v8qi, v2si, v8qi, 0);
9429   tree v2hi_ftype_v2si = build_function_type_list (v2hi, v2si, 0);
9430   tree v4hi_ftype_v4qi = build_function_type_list (v4hi, v4qi, 0);
9431   tree v8qi_ftype_v4qi_v4qi = build_function_type_list (v8qi, v4qi, v4qi, 0);
9432   tree v4hi_ftype_v4qi_v4hi = build_function_type_list (v4hi, v4qi, v4hi, 0);
9433   tree v4hi_ftype_v4qi_v2hi = build_function_type_list (v4hi, v4qi, v2hi, 0);
9434   tree v2si_ftype_v4qi_v2hi = build_function_type_list (v2si, v4qi, v2hi, 0);
9435   tree v4hi_ftype_v8qi_v4hi = build_function_type_list (v4hi, v8qi, v4hi, 0);
9436   tree v4hi_ftype_v4hi_v4hi = build_function_type_list (v4hi, v4hi, v4hi, 0);
9437   tree v2si_ftype_v2si_v2si = build_function_type_list (v2si, v2si, v2si, 0);
9438   tree v8qi_ftype_v8qi_v8qi = build_function_type_list (v8qi, v8qi, v8qi, 0);
9439   tree v2hi_ftype_v2hi_v2hi = build_function_type_list (v2hi, v2hi, v2hi, 0);
9440   tree v1si_ftype_v1si_v1si = build_function_type_list (v1si, v1si, v1si, 0);
9441   tree di_ftype_v8qi_v8qi_di = build_function_type_list (intDI_type_node,
9442                                                          v8qi, v8qi,
9443                                                          intDI_type_node, 0);
9444   tree di_ftype_v8qi_v8qi = build_function_type_list (intDI_type_node,
9445                                                       v8qi, v8qi, 0);
9446   tree si_ftype_v8qi_v8qi = build_function_type_list (intSI_type_node,
9447                                                       v8qi, v8qi, 0);
9448   tree di_ftype_di_di = build_function_type_list (intDI_type_node,
9449                                                   intDI_type_node,
9450                                                   intDI_type_node, 0);
9451   tree si_ftype_si_si = build_function_type_list (intSI_type_node,
9452                                                   intSI_type_node,
9453                                                   intSI_type_node, 0);
9454   tree ptr_ftype_ptr_si = build_function_type_list (ptr_type_node,
9455                                                     ptr_type_node,
9456                                                     intSI_type_node, 0);
9457   tree ptr_ftype_ptr_di = build_function_type_list (ptr_type_node,
9458                                                     ptr_type_node,
9459                                                     intDI_type_node, 0);
9460   tree si_ftype_ptr_ptr = build_function_type_list (intSI_type_node,
9461                                                     ptr_type_node,
9462                                                     ptr_type_node, 0);
9463   tree di_ftype_ptr_ptr = build_function_type_list (intDI_type_node,
9464                                                     ptr_type_node,
9465                                                     ptr_type_node, 0);
9466   tree si_ftype_v4hi_v4hi = build_function_type_list (intSI_type_node,
9467                                                       v4hi, v4hi, 0);
9468   tree si_ftype_v2si_v2si = build_function_type_list (intSI_type_node,
9469                                                       v2si, v2si, 0);
9470   tree di_ftype_v4hi_v4hi = build_function_type_list (intDI_type_node,
9471                                                       v4hi, v4hi, 0);
9472   tree di_ftype_v2si_v2si = build_function_type_list (intDI_type_node,
9473                                                       v2si, v2si, 0);
9474   tree void_ftype_di = build_function_type_list (void_type_node,
9475                                                  intDI_type_node, 0);
9476   tree di_ftype_void = build_function_type_list (intDI_type_node,
9477                                                  void_type_node, 0);
9478   tree void_ftype_si = build_function_type_list (void_type_node,
9479                                                  intSI_type_node, 0);
9480   tree sf_ftype_sf_sf = build_function_type_list (float_type_node,
9481                                                   float_type_node,
9482                                                   float_type_node, 0);
9483   tree df_ftype_df_df = build_function_type_list (double_type_node,
9484                                                   double_type_node,
9485                                                   double_type_node, 0);
9486
9487   /* Packing and expanding vectors.  */
9488   def_builtin ("__builtin_vis_fpack16", CODE_FOR_fpack16_vis,
9489                v4qi_ftype_v4hi);
9490   def_builtin ("__builtin_vis_fpack32", CODE_FOR_fpack32_vis,
9491                v8qi_ftype_v2si_v8qi);
9492   def_builtin ("__builtin_vis_fpackfix", CODE_FOR_fpackfix_vis,
9493                v2hi_ftype_v2si);
9494   def_builtin_const ("__builtin_vis_fexpand", CODE_FOR_fexpand_vis,
9495                      v4hi_ftype_v4qi);
9496   def_builtin_const ("__builtin_vis_fpmerge", CODE_FOR_fpmerge_vis,
9497                      v8qi_ftype_v4qi_v4qi);
9498
9499   /* Multiplications.  */
9500   def_builtin_const ("__builtin_vis_fmul8x16", CODE_FOR_fmul8x16_vis,
9501                      v4hi_ftype_v4qi_v4hi);
9502   def_builtin_const ("__builtin_vis_fmul8x16au", CODE_FOR_fmul8x16au_vis,
9503                      v4hi_ftype_v4qi_v2hi);
9504   def_builtin_const ("__builtin_vis_fmul8x16al", CODE_FOR_fmul8x16al_vis,
9505                      v4hi_ftype_v4qi_v2hi);
9506   def_builtin_const ("__builtin_vis_fmul8sux16", CODE_FOR_fmul8sux16_vis,
9507                      v4hi_ftype_v8qi_v4hi);
9508   def_builtin_const ("__builtin_vis_fmul8ulx16", CODE_FOR_fmul8ulx16_vis,
9509                      v4hi_ftype_v8qi_v4hi);
9510   def_builtin_const ("__builtin_vis_fmuld8sux16", CODE_FOR_fmuld8sux16_vis,
9511                      v2si_ftype_v4qi_v2hi);
9512   def_builtin_const ("__builtin_vis_fmuld8ulx16", CODE_FOR_fmuld8ulx16_vis,
9513                      v2si_ftype_v4qi_v2hi);
9514
9515   /* Data aligning.  */
9516   def_builtin ("__builtin_vis_faligndatav4hi", CODE_FOR_faligndatav4hi_vis,
9517                v4hi_ftype_v4hi_v4hi);
9518   def_builtin ("__builtin_vis_faligndatav8qi", CODE_FOR_faligndatav8qi_vis,
9519                v8qi_ftype_v8qi_v8qi);
9520   def_builtin ("__builtin_vis_faligndatav2si", CODE_FOR_faligndatav2si_vis,
9521                v2si_ftype_v2si_v2si);
9522   def_builtin ("__builtin_vis_faligndatadi", CODE_FOR_faligndatav1di_vis,
9523                di_ftype_di_di);
9524
9525   def_builtin ("__builtin_vis_write_gsr", CODE_FOR_wrgsr_vis,
9526                void_ftype_di);
9527   def_builtin ("__builtin_vis_read_gsr", CODE_FOR_rdgsr_vis,
9528                di_ftype_void);
9529
9530   if (TARGET_ARCH64)
9531     {
9532       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrdi_vis,
9533                    ptr_ftype_ptr_di);
9534       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrldi_vis,
9535                    ptr_ftype_ptr_di);
9536     }
9537   else
9538     {
9539       def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrsi_vis,
9540                    ptr_ftype_ptr_si);
9541       def_builtin ("__builtin_vis_alignaddrl", CODE_FOR_alignaddrlsi_vis,
9542                    ptr_ftype_ptr_si);
9543     }
9544
9545   /* Pixel distance.  */
9546   def_builtin_const ("__builtin_vis_pdist", CODE_FOR_pdist_vis,
9547                      di_ftype_v8qi_v8qi_di);
9548
9549   /* Edge handling.  */
9550   if (TARGET_ARCH64)
9551     {
9552       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8di_vis,
9553                          di_ftype_ptr_ptr);
9554       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8ldi_vis,
9555                          di_ftype_ptr_ptr);
9556       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16di_vis,
9557                          di_ftype_ptr_ptr);
9558       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16ldi_vis,
9559                          di_ftype_ptr_ptr);
9560       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32di_vis,
9561                          di_ftype_ptr_ptr);
9562       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32ldi_vis,
9563                          di_ftype_ptr_ptr);
9564       if (TARGET_VIS2)
9565         {
9566           def_builtin_const ("__builtin_vis_edge8n", CODE_FOR_edge8ndi_vis,
9567                              di_ftype_ptr_ptr);
9568           def_builtin_const ("__builtin_vis_edge8ln", CODE_FOR_edge8lndi_vis,
9569                              di_ftype_ptr_ptr);
9570           def_builtin_const ("__builtin_vis_edge16n", CODE_FOR_edge16ndi_vis,
9571                              di_ftype_ptr_ptr);
9572           def_builtin_const ("__builtin_vis_edge16ln", CODE_FOR_edge16lndi_vis,
9573                              di_ftype_ptr_ptr);
9574           def_builtin_const ("__builtin_vis_edge32n", CODE_FOR_edge32ndi_vis,
9575                              di_ftype_ptr_ptr);
9576           def_builtin_const ("__builtin_vis_edge32ln", CODE_FOR_edge32lndi_vis,
9577                              di_ftype_ptr_ptr);
9578         }
9579     }
9580   else
9581     {
9582       def_builtin_const ("__builtin_vis_edge8", CODE_FOR_edge8si_vis,
9583                          si_ftype_ptr_ptr);
9584       def_builtin_const ("__builtin_vis_edge8l", CODE_FOR_edge8lsi_vis,
9585                          si_ftype_ptr_ptr);
9586       def_builtin_const ("__builtin_vis_edge16", CODE_FOR_edge16si_vis,
9587                          si_ftype_ptr_ptr);
9588       def_builtin_const ("__builtin_vis_edge16l", CODE_FOR_edge16lsi_vis,
9589                          si_ftype_ptr_ptr);
9590       def_builtin_const ("__builtin_vis_edge32", CODE_FOR_edge32si_vis,
9591                          si_ftype_ptr_ptr);
9592       def_builtin_const ("__builtin_vis_edge32l", CODE_FOR_edge32lsi_vis,
9593                          si_ftype_ptr_ptr);
9594       if (TARGET_VIS2)
9595         {
9596           def_builtin_const ("__builtin_vis_edge8n", CODE_FOR_edge8nsi_vis,
9597                              si_ftype_ptr_ptr);
9598           def_builtin_const ("__builtin_vis_edge8ln", CODE_FOR_edge8lnsi_vis,
9599                              si_ftype_ptr_ptr);
9600           def_builtin_const ("__builtin_vis_edge16n", CODE_FOR_edge16nsi_vis,
9601                              si_ftype_ptr_ptr);
9602           def_builtin_const ("__builtin_vis_edge16ln", CODE_FOR_edge16lnsi_vis,
9603                              si_ftype_ptr_ptr);
9604           def_builtin_const ("__builtin_vis_edge32n", CODE_FOR_edge32nsi_vis,
9605                              si_ftype_ptr_ptr);
9606           def_builtin_const ("__builtin_vis_edge32ln", CODE_FOR_edge32lnsi_vis,
9607                              si_ftype_ptr_ptr);
9608         }
9609     }
9610
9611   /* Pixel compare.  */
9612   if (TARGET_ARCH64)
9613     {
9614       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16di_vis,
9615                          di_ftype_v4hi_v4hi);
9616       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32di_vis,
9617                          di_ftype_v2si_v2si);
9618       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16di_vis,
9619                          di_ftype_v4hi_v4hi);
9620       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32di_vis,
9621                          di_ftype_v2si_v2si);
9622       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16di_vis,
9623                          di_ftype_v4hi_v4hi);
9624       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32di_vis,
9625                          di_ftype_v2si_v2si);
9626       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16di_vis,
9627                          di_ftype_v4hi_v4hi);
9628       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32di_vis,
9629                          di_ftype_v2si_v2si);
9630     }
9631   else
9632     {
9633       def_builtin_const ("__builtin_vis_fcmple16", CODE_FOR_fcmple16si_vis,
9634                          si_ftype_v4hi_v4hi);
9635       def_builtin_const ("__builtin_vis_fcmple32", CODE_FOR_fcmple32si_vis,
9636                          si_ftype_v2si_v2si);
9637       def_builtin_const ("__builtin_vis_fcmpne16", CODE_FOR_fcmpne16si_vis,
9638                          si_ftype_v4hi_v4hi);
9639       def_builtin_const ("__builtin_vis_fcmpne32", CODE_FOR_fcmpne32si_vis,
9640                          si_ftype_v2si_v2si);
9641       def_builtin_const ("__builtin_vis_fcmpgt16", CODE_FOR_fcmpgt16si_vis,
9642                          si_ftype_v4hi_v4hi);
9643       def_builtin_const ("__builtin_vis_fcmpgt32", CODE_FOR_fcmpgt32si_vis,
9644                          si_ftype_v2si_v2si);
9645       def_builtin_const ("__builtin_vis_fcmpeq16", CODE_FOR_fcmpeq16si_vis,
9646                          si_ftype_v4hi_v4hi);
9647       def_builtin_const ("__builtin_vis_fcmpeq32", CODE_FOR_fcmpeq32si_vis,
9648                          si_ftype_v2si_v2si);
9649     }
9650
9651   /* Addition and subtraction.  */
9652   def_builtin_const ("__builtin_vis_fpadd16", CODE_FOR_addv4hi3,
9653                      v4hi_ftype_v4hi_v4hi);
9654   def_builtin_const ("__builtin_vis_fpadd16s", CODE_FOR_addv2hi3,
9655                      v2hi_ftype_v2hi_v2hi);
9656   def_builtin_const ("__builtin_vis_fpadd32", CODE_FOR_addv2si3,
9657                      v2si_ftype_v2si_v2si);
9658   def_builtin_const ("__builtin_vis_fpadd32s", CODE_FOR_addv1si3,
9659                      v1si_ftype_v1si_v1si);
9660   def_builtin_const ("__builtin_vis_fpsub16", CODE_FOR_subv4hi3,
9661                      v4hi_ftype_v4hi_v4hi);
9662   def_builtin_const ("__builtin_vis_fpsub16s", CODE_FOR_subv2hi3,
9663                      v2hi_ftype_v2hi_v2hi);
9664   def_builtin_const ("__builtin_vis_fpsub32", CODE_FOR_subv2si3,
9665                      v2si_ftype_v2si_v2si);
9666   def_builtin_const ("__builtin_vis_fpsub32s", CODE_FOR_subv1si3,
9667                      v1si_ftype_v1si_v1si);
9668
9669   /* Three-dimensional array addressing.  */
9670   if (TARGET_ARCH64)
9671     {
9672       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8di_vis,
9673                          di_ftype_di_di);
9674       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16di_vis,
9675                          di_ftype_di_di);
9676       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32di_vis,
9677                          di_ftype_di_di);
9678     }
9679   else
9680     {
9681       def_builtin_const ("__builtin_vis_array8", CODE_FOR_array8si_vis,
9682                          si_ftype_si_si);
9683       def_builtin_const ("__builtin_vis_array16", CODE_FOR_array16si_vis,
9684                          si_ftype_si_si);
9685       def_builtin_const ("__builtin_vis_array32", CODE_FOR_array32si_vis,
9686                          si_ftype_si_si);
9687   }
9688
9689   if (TARGET_VIS2)
9690     {
9691       /* Byte mask and shuffle */
9692       if (TARGET_ARCH64)
9693         def_builtin ("__builtin_vis_bmask", CODE_FOR_bmaskdi_vis,
9694                      di_ftype_di_di);
9695       else
9696         def_builtin ("__builtin_vis_bmask", CODE_FOR_bmasksi_vis,
9697                      si_ftype_si_si);
9698       def_builtin ("__builtin_vis_bshufflev4hi", CODE_FOR_bshufflev4hi_vis,
9699                    v4hi_ftype_v4hi_v4hi);
9700       def_builtin ("__builtin_vis_bshufflev8qi", CODE_FOR_bshufflev8qi_vis,
9701                    v8qi_ftype_v8qi_v8qi);
9702       def_builtin ("__builtin_vis_bshufflev2si", CODE_FOR_bshufflev2si_vis,
9703                    v2si_ftype_v2si_v2si);
9704       def_builtin ("__builtin_vis_bshuffledi", CODE_FOR_bshufflev1di_vis,
9705                    di_ftype_di_di);
9706     }
9707
9708   if (TARGET_VIS3)
9709     {
9710       if (TARGET_ARCH64)
9711         {
9712           def_builtin ("__builtin_vis_cmask8", CODE_FOR_cmask8di_vis,
9713                        void_ftype_di);
9714           def_builtin ("__builtin_vis_cmask16", CODE_FOR_cmask16di_vis,
9715                        void_ftype_di);
9716           def_builtin ("__builtin_vis_cmask32", CODE_FOR_cmask32di_vis,
9717                        void_ftype_di);
9718         }
9719       else
9720         {
9721           def_builtin ("__builtin_vis_cmask8", CODE_FOR_cmask8si_vis,
9722                        void_ftype_si);
9723           def_builtin ("__builtin_vis_cmask16", CODE_FOR_cmask16si_vis,
9724                        void_ftype_si);
9725           def_builtin ("__builtin_vis_cmask32", CODE_FOR_cmask32si_vis,
9726                        void_ftype_si);
9727         }
9728
9729       def_builtin_const ("__builtin_vis_fchksm16", CODE_FOR_fchksm16_vis,
9730                          v4hi_ftype_v4hi_v4hi);
9731
9732       def_builtin_const ("__builtin_vis_fsll16", CODE_FOR_vashlv4hi3,
9733                          v4hi_ftype_v4hi_v4hi);
9734       def_builtin_const ("__builtin_vis_fslas16", CODE_FOR_vssashlv4hi3,
9735                          v4hi_ftype_v4hi_v4hi);
9736       def_builtin_const ("__builtin_vis_fsrl16", CODE_FOR_vlshrv4hi3,
9737                          v4hi_ftype_v4hi_v4hi);
9738       def_builtin_const ("__builtin_vis_fsra16", CODE_FOR_vashrv4hi3,
9739                          v4hi_ftype_v4hi_v4hi);
9740       def_builtin_const ("__builtin_vis_fsll32", CODE_FOR_vashlv2si3,
9741                          v2si_ftype_v2si_v2si);
9742       def_builtin_const ("__builtin_vis_fslas32", CODE_FOR_vssashlv2si3,
9743                          v2si_ftype_v2si_v2si);
9744       def_builtin_const ("__builtin_vis_fsrl32", CODE_FOR_vlshrv2si3,
9745                          v2si_ftype_v2si_v2si);
9746       def_builtin_const ("__builtin_vis_fsra32", CODE_FOR_vashrv2si3,
9747                          v2si_ftype_v2si_v2si);
9748
9749       if (TARGET_ARCH64)
9750         def_builtin_const ("__builtin_vis_pdistn", CODE_FOR_pdistndi_vis,
9751                            di_ftype_v8qi_v8qi);
9752       else
9753         def_builtin_const ("__builtin_vis_pdistn", CODE_FOR_pdistnsi_vis,
9754                            si_ftype_v8qi_v8qi);
9755
9756       def_builtin_const ("__builtin_vis_fmean16", CODE_FOR_fmean16_vis,
9757                          v4hi_ftype_v4hi_v4hi);
9758       def_builtin_const ("__builtin_vis_fpadd64", CODE_FOR_fpadd64_vis,
9759                          di_ftype_di_di);
9760       def_builtin_const ("__builtin_vis_fpsub64", CODE_FOR_fpsub64_vis,
9761                          di_ftype_di_di);
9762
9763       def_builtin_const ("__builtin_vis_fpadds16", CODE_FOR_ssaddv4hi3,
9764                          v4hi_ftype_v4hi_v4hi);
9765       def_builtin_const ("__builtin_vis_fpadds16s", CODE_FOR_ssaddv2hi3,
9766                          v2hi_ftype_v2hi_v2hi);
9767       def_builtin_const ("__builtin_vis_fpsubs16", CODE_FOR_sssubv4hi3,
9768                          v4hi_ftype_v4hi_v4hi);
9769       def_builtin_const ("__builtin_vis_fpsubs16s", CODE_FOR_sssubv2hi3,
9770                          v2hi_ftype_v2hi_v2hi);
9771       def_builtin_const ("__builtin_vis_fpadds32", CODE_FOR_ssaddv2si3,
9772                          v2si_ftype_v2si_v2si);
9773       def_builtin_const ("__builtin_vis_fpadds32s", CODE_FOR_ssaddv1si3,
9774                          v1si_ftype_v1si_v1si);
9775       def_builtin_const ("__builtin_vis_fpsubs32", CODE_FOR_sssubv2si3,
9776                          v2si_ftype_v2si_v2si);
9777       def_builtin_const ("__builtin_vis_fpsubs32s", CODE_FOR_sssubv1si3,
9778                          v1si_ftype_v1si_v1si);
9779
9780       if (TARGET_ARCH64)
9781         {
9782           def_builtin_const ("__builtin_vis_fucmple8", CODE_FOR_fucmple8di_vis,
9783                              di_ftype_v8qi_v8qi);
9784           def_builtin_const ("__builtin_vis_fucmpne8", CODE_FOR_fucmpne8di_vis,
9785                              di_ftype_v8qi_v8qi);
9786           def_builtin_const ("__builtin_vis_fucmpgt8", CODE_FOR_fucmpgt8di_vis,
9787                              di_ftype_v8qi_v8qi);
9788           def_builtin_const ("__builtin_vis_fucmpeq8", CODE_FOR_fucmpeq8di_vis,
9789                              di_ftype_v8qi_v8qi);
9790         }
9791       else
9792         {
9793           def_builtin_const ("__builtin_vis_fucmple8", CODE_FOR_fucmple8si_vis,
9794                              si_ftype_v8qi_v8qi);
9795           def_builtin_const ("__builtin_vis_fucmpne8", CODE_FOR_fucmpne8si_vis,
9796                              si_ftype_v8qi_v8qi);
9797           def_builtin_const ("__builtin_vis_fucmpgt8", CODE_FOR_fucmpgt8si_vis,
9798                              si_ftype_v8qi_v8qi);
9799           def_builtin_const ("__builtin_vis_fucmpeq8", CODE_FOR_fucmpeq8si_vis,
9800                              si_ftype_v8qi_v8qi);
9801         }
9802
9803       def_builtin_const ("__builtin_vis_fhadds", CODE_FOR_fhaddsf_vis,
9804                          sf_ftype_sf_sf);
9805       def_builtin_const ("__builtin_vis_fhaddd", CODE_FOR_fhadddf_vis,
9806                          df_ftype_df_df);
9807       def_builtin_const ("__builtin_vis_fhsubs", CODE_FOR_fhsubsf_vis,
9808                          sf_ftype_sf_sf);
9809       def_builtin_const ("__builtin_vis_fhsubd", CODE_FOR_fhsubdf_vis,
9810                          df_ftype_df_df);
9811       def_builtin_const ("__builtin_vis_fnhadds", CODE_FOR_fnhaddsf_vis,
9812                          sf_ftype_sf_sf);
9813       def_builtin_const ("__builtin_vis_fnhaddd", CODE_FOR_fnhadddf_vis,
9814                          df_ftype_df_df);
9815
9816       def_builtin_const ("__builtin_vis_umulxhi", CODE_FOR_umulxhi_vis,
9817                          di_ftype_di_di);
9818       def_builtin_const ("__builtin_vis_xmulx", CODE_FOR_xmulx_vis,
9819                          di_ftype_di_di);
9820       def_builtin_const ("__builtin_vis_xmulxhi", CODE_FOR_xmulxhi_vis,
9821                          di_ftype_di_di);
9822     }
9823 }
9824
9825 /* Handle TARGET_EXPAND_BUILTIN target hook.
9826    Expand builtin functions for sparc intrinsics.  */
9827
9828 static rtx
9829 sparc_expand_builtin (tree exp, rtx target,
9830                       rtx subtarget ATTRIBUTE_UNUSED,
9831                       enum machine_mode tmode ATTRIBUTE_UNUSED,
9832                       int ignore ATTRIBUTE_UNUSED)
9833 {
9834   tree arg;
9835   call_expr_arg_iterator iter;
9836   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
9837   unsigned int icode = DECL_FUNCTION_CODE (fndecl);
9838   rtx pat, op[4];
9839   int arg_count = 0;
9840   bool nonvoid;
9841
9842   nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
9843
9844   if (nonvoid)
9845     {
9846       enum machine_mode tmode = insn_data[icode].operand[0].mode;
9847       if (!target
9848           || GET_MODE (target) != tmode
9849           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
9850         op[0] = gen_reg_rtx (tmode);
9851       else
9852         op[0] = target;
9853     }
9854   FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
9855     {
9856       const struct insn_operand_data *insn_op;
9857       int idx;
9858
9859       if (arg == error_mark_node)
9860         return NULL_RTX;
9861
9862       arg_count++;
9863       idx = arg_count - !nonvoid;
9864       insn_op = &insn_data[icode].operand[idx];
9865       op[arg_count] = expand_normal (arg);
9866
9867       if (insn_op->mode == V1DImode
9868           && GET_MODE (op[arg_count]) == DImode)
9869         op[arg_count] = gen_lowpart (V1DImode, op[arg_count]);
9870       else if (insn_op->mode == V1SImode
9871           && GET_MODE (op[arg_count]) == SImode)
9872         op[arg_count] = gen_lowpart (V1SImode, op[arg_count]);
9873
9874       if (! (*insn_data[icode].operand[idx].predicate) (op[arg_count],
9875                                                         insn_op->mode))
9876         op[arg_count] = copy_to_mode_reg (insn_op->mode, op[arg_count]);
9877     }
9878
9879   switch (arg_count)
9880     {
9881     case 0:
9882       pat = GEN_FCN (icode) (op[0]);
9883       break;
9884     case 1:
9885       if (nonvoid)
9886         pat = GEN_FCN (icode) (op[0], op[1]);
9887       else
9888         pat = GEN_FCN (icode) (op[1]);
9889       break;
9890     case 2:
9891       pat = GEN_FCN (icode) (op[0], op[1], op[2]);
9892       break;
9893     case 3:
9894       pat = GEN_FCN (icode) (op[0], op[1], op[2], op[3]);
9895       break;
9896     default:
9897       gcc_unreachable ();
9898     }
9899
9900   if (!pat)
9901     return NULL_RTX;
9902
9903   emit_insn (pat);
9904
9905   if (nonvoid)
9906     return op[0];
9907   else
9908     return const0_rtx;
9909 }
9910
9911 static int
9912 sparc_vis_mul8x16 (int e8, int e16)
9913 {
9914   return (e8 * e16 + 128) / 256;
9915 }
9916
9917 /* Multiply the vector elements in ELTS0 to the elements in ELTS1 as specified
9918    by FNCODE.  All of the elements in ELTS0 and ELTS1 lists must be integer
9919    constants.  A tree list with the results of the multiplications is returned,
9920    and each element in the list is of INNER_TYPE.  */
9921
9922 static tree
9923 sparc_handle_vis_mul8x16 (int fncode, tree inner_type, tree elts0, tree elts1)
9924 {
9925   tree n_elts = NULL_TREE;
9926   int scale;
9927
9928   switch (fncode)
9929     {
9930     case CODE_FOR_fmul8x16_vis:
9931       for (; elts0 && elts1;
9932            elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
9933         {
9934           int val
9935             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9936                                  TREE_INT_CST_LOW (TREE_VALUE (elts1)));
9937           n_elts = tree_cons (NULL_TREE,
9938                               build_int_cst (inner_type, val),
9939                               n_elts);
9940         }
9941       break;
9942
9943     case CODE_FOR_fmul8x16au_vis:
9944       scale = TREE_INT_CST_LOW (TREE_VALUE (elts1));
9945
9946       for (; elts0; elts0 = TREE_CHAIN (elts0))
9947         {
9948           int val
9949             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9950                                  scale);
9951           n_elts = tree_cons (NULL_TREE,
9952                               build_int_cst (inner_type, val),
9953                               n_elts);
9954         }
9955       break;
9956
9957     case CODE_FOR_fmul8x16al_vis:
9958       scale = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (elts1)));
9959
9960       for (; elts0; elts0 = TREE_CHAIN (elts0))
9961         {
9962           int val
9963             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
9964                                  scale);
9965           n_elts = tree_cons (NULL_TREE,
9966                               build_int_cst (inner_type, val),
9967                               n_elts);
9968         }
9969       break;
9970
9971     default:
9972       gcc_unreachable ();
9973     }
9974
9975   return nreverse (n_elts);
9976
9977 }
9978 /* Handle TARGET_FOLD_BUILTIN target hook.
9979    Fold builtin functions for SPARC intrinsics.  If IGNORE is true the
9980    result of the function call is ignored.  NULL_TREE is returned if the
9981    function could not be folded.  */
9982
9983 static tree
9984 sparc_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED,
9985                     tree *args, bool ignore)
9986 {
9987   tree arg0, arg1, arg2;
9988   tree rtype = TREE_TYPE (TREE_TYPE (fndecl));
9989   enum insn_code icode = (enum insn_code) DECL_FUNCTION_CODE (fndecl);
9990
9991   if (ignore)
9992     {
9993       /* Note that a switch statement instead of the sequence of tests would
9994          be incorrect as many of the CODE_FOR values could be CODE_FOR_nothing
9995          and that would yield multiple alternatives with identical values.  */
9996       if (icode == CODE_FOR_alignaddrsi_vis
9997           || icode == CODE_FOR_alignaddrdi_vis
9998           || icode == CODE_FOR_wrgsr_vis
9999           || icode == CODE_FOR_bmasksi_vis
10000           || icode == CODE_FOR_bmaskdi_vis
10001           || icode == CODE_FOR_cmask8si_vis
10002           || icode == CODE_FOR_cmask8di_vis
10003           || icode == CODE_FOR_cmask16si_vis
10004           || icode == CODE_FOR_cmask16di_vis
10005           || icode == CODE_FOR_cmask32si_vis
10006           || icode == CODE_FOR_cmask32di_vis)
10007         ;
10008       else
10009         return build_zero_cst (rtype);
10010     }
10011
10012   switch (icode)
10013     {
10014     case CODE_FOR_fexpand_vis:
10015       arg0 = args[0];
10016       STRIP_NOPS (arg0);
10017
10018       if (TREE_CODE (arg0) == VECTOR_CST)
10019         {
10020           tree inner_type = TREE_TYPE (rtype);
10021           tree elts = TREE_VECTOR_CST_ELTS (arg0);
10022           tree n_elts = NULL_TREE;
10023
10024           for (; elts; elts = TREE_CHAIN (elts))
10025             {
10026               unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (elts)) << 4;
10027               n_elts = tree_cons (NULL_TREE,
10028                                   build_int_cst (inner_type, val),
10029                                   n_elts);
10030             }
10031           return build_vector (rtype, nreverse (n_elts));
10032         }
10033       break;
10034
10035     case CODE_FOR_fmul8x16_vis:
10036     case CODE_FOR_fmul8x16au_vis:
10037     case CODE_FOR_fmul8x16al_vis:
10038       arg0 = args[0];
10039       arg1 = args[1];
10040       STRIP_NOPS (arg0);
10041       STRIP_NOPS (arg1);
10042
10043       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
10044         {
10045           tree inner_type = TREE_TYPE (rtype);
10046           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
10047           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
10048           tree n_elts = sparc_handle_vis_mul8x16 (icode, inner_type, elts0,
10049                                                   elts1);
10050
10051           return build_vector (rtype, n_elts);
10052         }
10053       break;
10054
10055     case CODE_FOR_fpmerge_vis:
10056       arg0 = args[0];
10057       arg1 = args[1];
10058       STRIP_NOPS (arg0);
10059       STRIP_NOPS (arg1);
10060
10061       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
10062         {
10063           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
10064           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
10065           tree n_elts = NULL_TREE;
10066
10067           for (; elts0 && elts1;
10068                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
10069             {
10070               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts0), n_elts);
10071               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts1), n_elts);
10072             }
10073
10074           return build_vector (rtype, nreverse (n_elts));
10075         }
10076       break;
10077
10078     case CODE_FOR_pdist_vis:
10079       arg0 = args[0];
10080       arg1 = args[1];
10081       arg2 = args[2];
10082       STRIP_NOPS (arg0);
10083       STRIP_NOPS (arg1);
10084       STRIP_NOPS (arg2);
10085
10086       if (TREE_CODE (arg0) == VECTOR_CST
10087           && TREE_CODE (arg1) == VECTOR_CST
10088           && TREE_CODE (arg2) == INTEGER_CST)
10089         {
10090           int overflow = 0;
10091           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg2);
10092           HOST_WIDE_INT high = TREE_INT_CST_HIGH (arg2);
10093           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
10094           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
10095
10096           for (; elts0 && elts1;
10097                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
10098             {
10099               unsigned HOST_WIDE_INT
10100                 low0 = TREE_INT_CST_LOW (TREE_VALUE (elts0)),
10101                 low1 = TREE_INT_CST_LOW (TREE_VALUE (elts1));
10102               HOST_WIDE_INT high0 = TREE_INT_CST_HIGH (TREE_VALUE (elts0));
10103               HOST_WIDE_INT high1 = TREE_INT_CST_HIGH (TREE_VALUE (elts1));
10104
10105               unsigned HOST_WIDE_INT l;
10106               HOST_WIDE_INT h;
10107
10108               overflow |= neg_double (low1, high1, &l, &h);
10109               overflow |= add_double (low0, high0, l, h, &l, &h);
10110               if (h < 0)
10111                 overflow |= neg_double (l, h, &l, &h);
10112
10113               overflow |= add_double (low, high, l, h, &low, &high);
10114             }
10115
10116           gcc_assert (overflow == 0);
10117
10118           return build_int_cst_wide (rtype, low, high);
10119         }
10120
10121     default:
10122       break;
10123     }
10124
10125   return NULL_TREE;
10126 }
10127 \f
10128 /* ??? This duplicates information provided to the compiler by the
10129    ??? scheduler description.  Some day, teach genautomata to output
10130    ??? the latencies and then CSE will just use that.  */
10131
10132 static bool
10133 sparc_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
10134                  int *total, bool speed ATTRIBUTE_UNUSED)
10135 {
10136   enum machine_mode mode = GET_MODE (x);
10137   bool float_mode_p = FLOAT_MODE_P (mode);
10138
10139   switch (code)
10140     {
10141     case CONST_INT:
10142       if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
10143         {
10144           *total = 0;
10145           return true;
10146         }
10147       /* FALLTHRU */
10148
10149     case HIGH:
10150       *total = 2;
10151       return true;
10152
10153     case CONST:
10154     case LABEL_REF:
10155     case SYMBOL_REF:
10156       *total = 4;
10157       return true;
10158
10159     case CONST_DOUBLE:
10160       if (GET_MODE (x) == VOIDmode
10161           && ((CONST_DOUBLE_HIGH (x) == 0
10162                && CONST_DOUBLE_LOW (x) < 0x1000)
10163               || (CONST_DOUBLE_HIGH (x) == -1
10164                   && CONST_DOUBLE_LOW (x) < 0
10165                   && CONST_DOUBLE_LOW (x) >= -0x1000)))
10166         *total = 0;
10167       else
10168         *total = 8;
10169       return true;
10170
10171     case MEM:
10172       /* If outer-code was a sign or zero extension, a cost
10173          of COSTS_N_INSNS (1) was already added in.  This is
10174          why we are subtracting it back out.  */
10175       if (outer_code == ZERO_EXTEND)
10176         {
10177           *total = sparc_costs->int_zload - COSTS_N_INSNS (1);
10178         }
10179       else if (outer_code == SIGN_EXTEND)
10180         {
10181           *total = sparc_costs->int_sload - COSTS_N_INSNS (1);
10182         }
10183       else if (float_mode_p)
10184         {
10185           *total = sparc_costs->float_load;
10186         }
10187       else
10188         {
10189           *total = sparc_costs->int_load;
10190         }
10191
10192       return true;
10193
10194     case PLUS:
10195     case MINUS:
10196       if (float_mode_p)
10197         *total = sparc_costs->float_plusminus;
10198       else
10199         *total = COSTS_N_INSNS (1);
10200       return false;
10201
10202     case FMA:
10203       {
10204         rtx sub;
10205
10206         gcc_assert (float_mode_p);
10207         *total = sparc_costs->float_mul;
10208
10209         sub = XEXP (x, 0);
10210         if (GET_CODE (sub) == NEG)
10211           sub = XEXP (sub, 0);
10212         *total += rtx_cost (sub, FMA, 0, speed);
10213
10214         sub = XEXP (x, 2);
10215         if (GET_CODE (sub) == NEG)
10216           sub = XEXP (sub, 0);
10217         *total += rtx_cost (sub, FMA, 2, speed);
10218         return true;
10219       }
10220
10221     case MULT:
10222       if (float_mode_p)
10223         *total = sparc_costs->float_mul;
10224       else if (! TARGET_HARD_MUL)
10225         *total = COSTS_N_INSNS (25);
10226       else
10227         {
10228           int bit_cost;
10229
10230           bit_cost = 0;
10231           if (sparc_costs->int_mul_bit_factor)
10232             {
10233               int nbits;
10234
10235               if (GET_CODE (XEXP (x, 1)) == CONST_INT)
10236                 {
10237                   unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
10238                   for (nbits = 0; value != 0; value &= value - 1)
10239                     nbits++;
10240                 }
10241               else if (GET_CODE (XEXP (x, 1)) == CONST_DOUBLE
10242                        && GET_MODE (XEXP (x, 1)) == VOIDmode)
10243                 {
10244                   rtx x1 = XEXP (x, 1);
10245                   unsigned HOST_WIDE_INT value1 = CONST_DOUBLE_LOW (x1);
10246                   unsigned HOST_WIDE_INT value2 = CONST_DOUBLE_HIGH (x1);
10247
10248                   for (nbits = 0; value1 != 0; value1 &= value1 - 1)
10249                     nbits++;
10250                   for (; value2 != 0; value2 &= value2 - 1)
10251                     nbits++;
10252                 }
10253               else
10254                 nbits = 7;
10255
10256               if (nbits < 3)
10257                 nbits = 3;
10258               bit_cost = (nbits - 3) / sparc_costs->int_mul_bit_factor;
10259               bit_cost = COSTS_N_INSNS (bit_cost);
10260             }
10261
10262           if (mode == DImode)
10263             *total = sparc_costs->int_mulX + bit_cost;
10264           else
10265             *total = sparc_costs->int_mul + bit_cost;
10266         }
10267       return false;
10268
10269     case ASHIFT:
10270     case ASHIFTRT:
10271     case LSHIFTRT:
10272       *total = COSTS_N_INSNS (1) + sparc_costs->shift_penalty;
10273       return false;
10274
10275     case DIV:
10276     case UDIV:
10277     case MOD:
10278     case UMOD:
10279       if (float_mode_p)
10280         {
10281           if (mode == DFmode)
10282             *total = sparc_costs->float_div_df;
10283           else
10284             *total = sparc_costs->float_div_sf;
10285         }
10286       else
10287         {
10288           if (mode == DImode)
10289             *total = sparc_costs->int_divX;
10290           else
10291             *total = sparc_costs->int_div;
10292         }
10293       return false;
10294
10295     case NEG:
10296       if (! float_mode_p)
10297         {
10298           *total = COSTS_N_INSNS (1);
10299           return false;
10300         }
10301       /* FALLTHRU */
10302
10303     case ABS:
10304     case FLOAT:
10305     case UNSIGNED_FLOAT:
10306     case FIX:
10307     case UNSIGNED_FIX:
10308     case FLOAT_EXTEND:
10309     case FLOAT_TRUNCATE:
10310       *total = sparc_costs->float_move;
10311       return false;
10312
10313     case SQRT:
10314       if (mode == DFmode)
10315         *total = sparc_costs->float_sqrt_df;
10316       else
10317         *total = sparc_costs->float_sqrt_sf;
10318       return false;
10319
10320     case COMPARE:
10321       if (float_mode_p)
10322         *total = sparc_costs->float_cmp;
10323       else
10324         *total = COSTS_N_INSNS (1);
10325       return false;
10326
10327     case IF_THEN_ELSE:
10328       if (float_mode_p)
10329         *total = sparc_costs->float_cmove;
10330       else
10331         *total = sparc_costs->int_cmove;
10332       return false;
10333
10334     case IOR:
10335       /* Handle the NAND vector patterns.  */
10336       if (sparc_vector_mode_supported_p (GET_MODE (x))
10337           && GET_CODE (XEXP (x, 0)) == NOT
10338           && GET_CODE (XEXP (x, 1)) == NOT)
10339         {
10340           *total = COSTS_N_INSNS (1);
10341           return true;
10342         }
10343       else
10344         return false;
10345
10346     default:
10347       return false;
10348     }
10349 }
10350
10351 /* Return true if CLASS is either GENERAL_REGS or I64_REGS.  */
10352
10353 static inline bool
10354 general_or_i64_p (reg_class_t rclass)
10355 {
10356   return (rclass == GENERAL_REGS || rclass == I64_REGS);
10357 }
10358
10359 /* Implement TARGET_REGISTER_MOVE_COST.  */
10360
10361 static int
10362 sparc_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
10363                           reg_class_t from, reg_class_t to)
10364 {
10365   bool need_memory = false;
10366
10367   if (from == FPCC_REGS || to == FPCC_REGS)
10368     need_memory = true;
10369   else if ((FP_REG_CLASS_P (from) && general_or_i64_p (to))
10370            || (general_or_i64_p (from) && FP_REG_CLASS_P (to)))
10371     {
10372       if (TARGET_VIS3)
10373         {
10374           int size = GET_MODE_SIZE (mode);
10375           if (size == 8 || size == 4)
10376             {
10377               if (! TARGET_ARCH32 || size == 4)
10378                 return 4;
10379               else
10380                 return 6;
10381             }
10382         }
10383       need_memory = true;
10384     }
10385
10386   if (need_memory)
10387     {
10388       if (sparc_cpu == PROCESSOR_ULTRASPARC
10389           || sparc_cpu == PROCESSOR_ULTRASPARC3
10390           || sparc_cpu == PROCESSOR_NIAGARA
10391           || sparc_cpu == PROCESSOR_NIAGARA2
10392           || sparc_cpu == PROCESSOR_NIAGARA3
10393           || sparc_cpu == PROCESSOR_NIAGARA4)
10394         return 12;
10395
10396       return 6;
10397     }
10398
10399   return 2;
10400 }
10401
10402 /* Emit the sequence of insns SEQ while preserving the registers REG and REG2.
10403    This is achieved by means of a manual dynamic stack space allocation in
10404    the current frame.  We make the assumption that SEQ doesn't contain any
10405    function calls, with the possible exception of calls to the GOT helper.  */
10406
10407 static void
10408 emit_and_preserve (rtx seq, rtx reg, rtx reg2)
10409 {
10410   /* We must preserve the lowest 16 words for the register save area.  */
10411   HOST_WIDE_INT offset = 16*UNITS_PER_WORD;
10412   /* We really need only 2 words of fresh stack space.  */
10413   HOST_WIDE_INT size = SPARC_STACK_ALIGN (offset + 2*UNITS_PER_WORD);
10414
10415   rtx slot
10416     = gen_rtx_MEM (word_mode, plus_constant (stack_pointer_rtx,
10417                                              SPARC_STACK_BIAS + offset));
10418
10419   emit_insn (gen_stack_pointer_dec (GEN_INT (size)));
10420   emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
10421   if (reg2)
10422     emit_insn (gen_rtx_SET (VOIDmode,
10423                             adjust_address (slot, word_mode, UNITS_PER_WORD),
10424                             reg2));
10425   emit_insn (seq);
10426   if (reg2)
10427     emit_insn (gen_rtx_SET (VOIDmode,
10428                             reg2,
10429                             adjust_address (slot, word_mode, UNITS_PER_WORD)));
10430   emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
10431   emit_insn (gen_stack_pointer_inc (GEN_INT (size)));
10432 }
10433
10434 /* Output the assembler code for a thunk function.  THUNK_DECL is the
10435    declaration for the thunk function itself, FUNCTION is the decl for
10436    the target function.  DELTA is an immediate constant offset to be
10437    added to THIS.  If VCALL_OFFSET is nonzero, the word at address
10438    (*THIS + VCALL_OFFSET) should be additionally added to THIS.  */
10439
10440 static void
10441 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
10442                        HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
10443                        tree function)
10444 {
10445   rtx this_rtx, insn, funexp;
10446   unsigned int int_arg_first;
10447
10448   reload_completed = 1;
10449   epilogue_completed = 1;
10450
10451   emit_note (NOTE_INSN_PROLOGUE_END);
10452
10453   if (TARGET_FLAT)
10454     {
10455       sparc_leaf_function_p = 1;
10456
10457       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
10458     }
10459   else if (flag_delayed_branch)
10460     {
10461       /* We will emit a regular sibcall below, so we need to instruct
10462          output_sibcall that we are in a leaf function.  */
10463       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 1;
10464
10465       /* This will cause final.c to invoke leaf_renumber_regs so we
10466          must behave as if we were in a not-yet-leafified function.  */
10467       int_arg_first = SPARC_INCOMING_INT_ARG_FIRST;
10468     }
10469   else
10470     {
10471       /* We will emit the sibcall manually below, so we will need to
10472          manually spill non-leaf registers.  */
10473       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 0;
10474
10475       /* We really are in a leaf function.  */
10476       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
10477     }
10478
10479   /* Find the "this" pointer.  Normally in %o0, but in ARCH64 if the function
10480      returns a structure, the structure return pointer is there instead.  */
10481   if (TARGET_ARCH64
10482       && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
10483     this_rtx = gen_rtx_REG (Pmode, int_arg_first + 1);
10484   else
10485     this_rtx = gen_rtx_REG (Pmode, int_arg_first);
10486
10487   /* Add DELTA.  When possible use a plain add, otherwise load it into
10488      a register first.  */
10489   if (delta)
10490     {
10491       rtx delta_rtx = GEN_INT (delta);
10492
10493       if (! SPARC_SIMM13_P (delta))
10494         {
10495           rtx scratch = gen_rtx_REG (Pmode, 1);
10496           emit_move_insn (scratch, delta_rtx);
10497           delta_rtx = scratch;
10498         }
10499
10500       /* THIS_RTX += DELTA.  */
10501       emit_insn (gen_add2_insn (this_rtx, delta_rtx));
10502     }
10503
10504   /* Add the word at address (*THIS_RTX + VCALL_OFFSET).  */
10505   if (vcall_offset)
10506     {
10507       rtx vcall_offset_rtx = GEN_INT (vcall_offset);
10508       rtx scratch = gen_rtx_REG (Pmode, 1);
10509
10510       gcc_assert (vcall_offset < 0);
10511
10512       /* SCRATCH = *THIS_RTX.  */
10513       emit_move_insn (scratch, gen_rtx_MEM (Pmode, this_rtx));
10514
10515       /* Prepare for adding VCALL_OFFSET.  The difficulty is that we
10516          may not have any available scratch register at this point.  */
10517       if (SPARC_SIMM13_P (vcall_offset))
10518         ;
10519       /* This is the case if ARCH64 (unless -ffixed-g5 is passed).  */
10520       else if (! fixed_regs[5]
10521                /* The below sequence is made up of at least 2 insns,
10522                   while the default method may need only one.  */
10523                && vcall_offset < -8192)
10524         {
10525           rtx scratch2 = gen_rtx_REG (Pmode, 5);
10526           emit_move_insn (scratch2, vcall_offset_rtx);
10527           vcall_offset_rtx = scratch2;
10528         }
10529       else
10530         {
10531           rtx increment = GEN_INT (-4096);
10532
10533           /* VCALL_OFFSET is a negative number whose typical range can be
10534              estimated as -32768..0 in 32-bit mode.  In almost all cases
10535              it is therefore cheaper to emit multiple add insns than
10536              spilling and loading the constant into a register (at least
10537              6 insns).  */
10538           while (! SPARC_SIMM13_P (vcall_offset))
10539             {
10540               emit_insn (gen_add2_insn (scratch, increment));
10541               vcall_offset += 4096;
10542             }
10543           vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */
10544         }
10545
10546       /* SCRATCH = *(*THIS_RTX + VCALL_OFFSET).  */
10547       emit_move_insn (scratch, gen_rtx_MEM (Pmode,
10548                                             gen_rtx_PLUS (Pmode,
10549                                                           scratch,
10550                                                           vcall_offset_rtx)));
10551
10552       /* THIS_RTX += *(*THIS_RTX + VCALL_OFFSET).  */
10553       emit_insn (gen_add2_insn (this_rtx, scratch));
10554     }
10555
10556   /* Generate a tail call to the target function.  */
10557   if (! TREE_USED (function))
10558     {
10559       assemble_external (function);
10560       TREE_USED (function) = 1;
10561     }
10562   funexp = XEXP (DECL_RTL (function), 0);
10563
10564   if (flag_delayed_branch)
10565     {
10566       funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
10567       insn = emit_call_insn (gen_sibcall (funexp));
10568       SIBLING_CALL_P (insn) = 1;
10569     }
10570   else
10571     {
10572       /* The hoops we have to jump through in order to generate a sibcall
10573          without using delay slots...  */
10574       rtx spill_reg, seq, scratch = gen_rtx_REG (Pmode, 1);
10575
10576       if (flag_pic)
10577         {
10578           spill_reg = gen_rtx_REG (word_mode, 15);  /* %o7 */
10579           start_sequence ();
10580           load_got_register ();  /* clobbers %o7 */
10581           scratch = sparc_legitimize_pic_address (funexp, scratch);
10582           seq = get_insns ();
10583           end_sequence ();
10584           emit_and_preserve (seq, spill_reg, pic_offset_table_rtx);
10585         }
10586       else if (TARGET_ARCH32)
10587         {
10588           emit_insn (gen_rtx_SET (VOIDmode,
10589                                   scratch,
10590                                   gen_rtx_HIGH (SImode, funexp)));
10591           emit_insn (gen_rtx_SET (VOIDmode,
10592                                   scratch,
10593                                   gen_rtx_LO_SUM (SImode, scratch, funexp)));
10594         }
10595       else  /* TARGET_ARCH64 */
10596         {
10597           switch (sparc_cmodel)
10598             {
10599             case CM_MEDLOW:
10600             case CM_MEDMID:
10601               /* The destination can serve as a temporary.  */
10602               sparc_emit_set_symbolic_const64 (scratch, funexp, scratch);
10603               break;
10604
10605             case CM_MEDANY:
10606             case CM_EMBMEDANY:
10607               /* The destination cannot serve as a temporary.  */
10608               spill_reg = gen_rtx_REG (DImode, 15);  /* %o7 */
10609               start_sequence ();
10610               sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
10611               seq = get_insns ();
10612               end_sequence ();
10613               emit_and_preserve (seq, spill_reg, 0);
10614               break;
10615
10616             default:
10617               gcc_unreachable ();
10618             }
10619         }
10620
10621       emit_jump_insn (gen_indirect_jump (scratch));
10622     }
10623
10624   emit_barrier ();
10625
10626   /* Run just enough of rest_of_compilation to get the insns emitted.
10627      There's not really enough bulk here to make other passes such as
10628      instruction scheduling worth while.  Note that use_thunk calls
10629      assemble_start_function and assemble_end_function.  */
10630   insn = get_insns ();
10631   insn_locators_alloc ();
10632   shorten_branches (insn);
10633   final_start_function (insn, file, 1);
10634   final (insn, file, 1);
10635   final_end_function ();
10636
10637   reload_completed = 0;
10638   epilogue_completed = 0;
10639 }
10640
10641 /* Return true if sparc_output_mi_thunk would be able to output the
10642    assembler code for the thunk function specified by the arguments
10643    it is passed, and false otherwise.  */
10644 static bool
10645 sparc_can_output_mi_thunk (const_tree thunk_fndecl ATTRIBUTE_UNUSED,
10646                            HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
10647                            HOST_WIDE_INT vcall_offset,
10648                            const_tree function ATTRIBUTE_UNUSED)
10649 {
10650   /* Bound the loop used in the default method above.  */
10651   return (vcall_offset >= -32768 || ! fixed_regs[5]);
10652 }
10653
10654 /* We use the machine specific reorg pass to enable workarounds for errata.  */
10655
10656 static void
10657 sparc_reorg (void)
10658 {
10659   rtx insn, next;
10660
10661   /* The only erratum we handle for now is that of the AT697F processor.  */
10662   if (!sparc_fix_at697f)
10663     return;
10664
10665   /* We need to have the (essentially) final form of the insn stream in order
10666      to properly detect the various hazards.  Run delay slot scheduling.  */
10667   if (optimize > 0 && flag_delayed_branch)
10668     dbr_schedule (get_insns ());
10669
10670   /* Now look for specific patterns in the insn stream.  */
10671   for (insn = get_insns (); insn; insn = next)
10672     {
10673       bool insert_nop = false;
10674       rtx set;
10675
10676       /* Look for a single-word load into an odd-numbered FP register.  */
10677       if (NONJUMP_INSN_P (insn)
10678           && (set = single_set (insn)) != NULL_RTX
10679           && GET_MODE_SIZE (GET_MODE (SET_SRC (set))) == 4
10680           && MEM_P (SET_SRC (set))
10681           && REG_P (SET_DEST (set))
10682           && REGNO (SET_DEST (set)) > 31
10683           && REGNO (SET_DEST (set)) % 2 != 0)
10684         {
10685           /* The wrong dependency is on the enclosing double register.  */
10686           unsigned int x = REGNO (SET_DEST (set)) - 1;
10687           unsigned int src1, src2, dest;
10688           int code;
10689
10690           /* If the insn has a delay slot, then it cannot be problematic.  */
10691           next = next_active_insn (insn);
10692           if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
10693             code = -1;
10694           else
10695             {
10696               extract_insn (next);
10697               code = INSN_CODE (next);
10698             }
10699
10700           switch (code)
10701             {
10702             case CODE_FOR_adddf3:
10703             case CODE_FOR_subdf3:
10704             case CODE_FOR_muldf3:
10705             case CODE_FOR_divdf3:
10706               dest = REGNO (recog_data.operand[0]);
10707               src1 = REGNO (recog_data.operand[1]);
10708               src2 = REGNO (recog_data.operand[2]);
10709               if (src1 != src2)
10710                 {
10711                   /* Case [1-4]:
10712                                  ld [address], %fx+1
10713                                  FPOPd %f{x,y}, %f{y,x}, %f{x,y}  */
10714                   if ((src1 == x || src2 == x)
10715                       && (dest == src1 || dest == src2))
10716                     insert_nop = true;
10717                 }
10718               else
10719                 {
10720                   /* Case 5:
10721                              ld [address], %fx+1
10722                              FPOPd %fx, %fx, %fx  */
10723                   if (src1 == x
10724                       && dest == src1
10725                       && (code == CODE_FOR_adddf3 || code == CODE_FOR_muldf3))
10726                     insert_nop = true;
10727                 }
10728               break;
10729
10730             case CODE_FOR_sqrtdf2:
10731               dest = REGNO (recog_data.operand[0]);
10732               src1 = REGNO (recog_data.operand[1]);
10733               /* Case 6:
10734                          ld [address], %fx+1
10735                          fsqrtd %fx, %fx  */
10736               if (src1 == x && dest == src1)
10737                 insert_nop = true;
10738               break;
10739
10740             default:
10741               break;
10742             }
10743         }
10744       else
10745         next = NEXT_INSN (insn);
10746
10747       if (insert_nop)
10748         emit_insn_after (gen_nop (), insn);
10749     }
10750 }
10751
10752 /* How to allocate a 'struct machine_function'.  */
10753
10754 static struct machine_function *
10755 sparc_init_machine_status (void)
10756 {
10757   return ggc_alloc_cleared_machine_function ();
10758 }
10759
10760 /* Locate some local-dynamic symbol still in use by this function
10761    so that we can print its name in local-dynamic base patterns.  */
10762
10763 static const char *
10764 get_some_local_dynamic_name (void)
10765 {
10766   rtx insn;
10767
10768   if (cfun->machine->some_ld_name)
10769     return cfun->machine->some_ld_name;
10770
10771   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
10772     if (INSN_P (insn)
10773         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
10774       return cfun->machine->some_ld_name;
10775
10776   gcc_unreachable ();
10777 }
10778
10779 static int
10780 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
10781 {
10782   rtx x = *px;
10783
10784   if (x
10785       && GET_CODE (x) == SYMBOL_REF
10786       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
10787     {
10788       cfun->machine->some_ld_name = XSTR (x, 0);
10789       return 1;
10790     }
10791
10792   return 0;
10793 }
10794
10795 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
10796    We need to emit DTP-relative relocations.  */
10797
10798 static void
10799 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
10800 {
10801   switch (size)
10802     {
10803     case 4:
10804       fputs ("\t.word\t%r_tls_dtpoff32(", file);
10805       break;
10806     case 8:
10807       fputs ("\t.xword\t%r_tls_dtpoff64(", file);
10808       break;
10809     default:
10810       gcc_unreachable ();
10811     }
10812   output_addr_const (file, x);
10813   fputs (")", file);
10814 }
10815
10816 /* Do whatever processing is required at the end of a file.  */
10817
10818 static void
10819 sparc_file_end (void)
10820 {
10821   /* If we need to emit the special GOT helper function, do so now.  */
10822   if (got_helper_rtx)
10823     {
10824       const char *name = XSTR (got_helper_rtx, 0);
10825       const char *reg_name = reg_names[GLOBAL_OFFSET_TABLE_REGNUM];
10826 #ifdef DWARF2_UNWIND_INFO
10827       bool do_cfi;
10828 #endif
10829
10830       if (USE_HIDDEN_LINKONCE)
10831         {
10832           tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
10833                                   get_identifier (name),
10834                                   build_function_type_list (void_type_node,
10835                                                             NULL_TREE));
10836           DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
10837                                            NULL_TREE, void_type_node);
10838           TREE_PUBLIC (decl) = 1;
10839           TREE_STATIC (decl) = 1;
10840           make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));
10841           DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
10842           DECL_VISIBILITY_SPECIFIED (decl) = 1;
10843           resolve_unique_section (decl, 0, flag_function_sections);
10844           allocate_struct_function (decl, true);
10845           cfun->is_thunk = 1;
10846           current_function_decl = decl;
10847           init_varasm_status ();
10848           assemble_start_function (decl, name);
10849         }
10850       else
10851         {
10852           const int align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
10853           switch_to_section (text_section);
10854           if (align > 0)
10855             ASM_OUTPUT_ALIGN (asm_out_file, align);
10856           ASM_OUTPUT_LABEL (asm_out_file, name);
10857         }
10858
10859 #ifdef DWARF2_UNWIND_INFO
10860       do_cfi = dwarf2out_do_cfi_asm ();
10861       if (do_cfi)
10862         fprintf (asm_out_file, "\t.cfi_startproc\n");
10863 #endif
10864       if (flag_delayed_branch)
10865         fprintf (asm_out_file, "\tjmp\t%%o7+8\n\t add\t%%o7, %s, %s\n",
10866                  reg_name, reg_name);
10867       else
10868         fprintf (asm_out_file, "\tadd\t%%o7, %s, %s\n\tjmp\t%%o7+8\n\t nop\n",
10869                  reg_name, reg_name);
10870 #ifdef DWARF2_UNWIND_INFO
10871       if (do_cfi)
10872         fprintf (asm_out_file, "\t.cfi_endproc\n");
10873 #endif
10874     }
10875
10876   if (NEED_INDICATE_EXEC_STACK)
10877     file_end_indicate_exec_stack ();
10878
10879 #ifdef TARGET_SOLARIS
10880   solaris_file_end ();
10881 #endif
10882 }
10883
10884 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
10885 /* Implement TARGET_MANGLE_TYPE.  */
10886
10887 static const char *
10888 sparc_mangle_type (const_tree type)
10889 {
10890   if (!TARGET_64BIT
10891       && TYPE_MAIN_VARIANT (type) == long_double_type_node
10892       && TARGET_LONG_DOUBLE_128)
10893     return "g";
10894
10895   /* For all other types, use normal C++ mangling.  */
10896   return NULL;
10897 }
10898 #endif
10899
10900 /* Expand a membar instruction for various use cases.  Both the LOAD_STORE
10901    and BEFORE_AFTER arguments of the form X_Y.  They are two-bit masks where
10902    bit 0 indicates that X is true, and bit 1 indicates Y is true.  */
10903
10904 void
10905 sparc_emit_membar_for_model (enum memmodel model,
10906                              int load_store, int before_after)
10907 {
10908   /* Bits for the MEMBAR mmask field.  */
10909   const int LoadLoad = 1;
10910   const int StoreLoad = 2;
10911   const int LoadStore = 4;
10912   const int StoreStore = 8;
10913
10914   int mm = 0, implied = 0;
10915
10916   switch (sparc_memory_model)
10917     {
10918     case SMM_SC:
10919       /* Sequential Consistency.  All memory transactions are immediately
10920          visible in sequential execution order.  No barriers needed.  */
10921       implied = LoadLoad | StoreLoad | LoadStore | StoreStore;
10922       break;
10923
10924     case SMM_TSO:
10925       /* Total Store Ordering: all memory transactions with store semantics
10926          are followed by an implied StoreStore.  */
10927       implied |= StoreStore;
10928       /* FALLTHRU */
10929
10930     case SMM_PSO:
10931       /* Partial Store Ordering: all memory transactions with load semantics
10932          are followed by an implied LoadLoad | LoadStore.  */
10933       implied |= LoadLoad | LoadStore;
10934
10935       /* If we're not looking for a raw barrer (before+after), then atomic
10936          operations get the benefit of being both load and store.  */
10937       if (load_store == 3 && before_after == 2)
10938         implied |= StoreLoad | StoreStore;
10939       /* FALLTHRU */
10940
10941     case SMM_RMO:
10942       /* Relaxed Memory Ordering: no implicit bits.  */
10943       break;
10944
10945     default:
10946       gcc_unreachable ();
10947     }
10948
10949   if (before_after & 1)
10950     {
10951       if (model == MEMMODEL_ACQUIRE
10952           || model == MEMMODEL_ACQ_REL
10953           || model == MEMMODEL_SEQ_CST)
10954         {
10955           if (load_store & 1)
10956             mm |= LoadLoad | LoadStore;
10957           if (load_store & 2)
10958             mm |= StoreLoad | StoreStore;
10959         }
10960     }
10961   if (before_after & 2)
10962     {
10963       if (model == MEMMODEL_RELEASE
10964           || model == MEMMODEL_ACQ_REL
10965           || model == MEMMODEL_SEQ_CST)
10966         {
10967           if (load_store & 1)
10968             mm |= LoadLoad | StoreLoad;
10969           if (load_store & 2)
10970             mm |= LoadStore | StoreStore;
10971         }
10972     }
10973
10974   /* Remove the bits implied by the system memory model.  */
10975   mm &= ~implied;
10976
10977   /* For raw barriers (before+after), always emit a barrier.
10978      This will become a compile-time barrier if needed.  */
10979   if (mm || before_after == 3)
10980     emit_insn (gen_membar (GEN_INT (mm)));
10981 }
10982
10983 /* Expand code to perform a 8 or 16-bit compare and swap by doing 32-bit
10984    compare and swap on the word containing the byte or half-word.  */
10985
10986 static void
10987 sparc_expand_compare_and_swap_12 (rtx bool_result, rtx result, rtx mem,
10988                                   rtx oldval, rtx newval)
10989 {
10990   rtx addr1 = force_reg (Pmode, XEXP (mem, 0));
10991   rtx addr = gen_reg_rtx (Pmode);
10992   rtx off = gen_reg_rtx (SImode);
10993   rtx oldv = gen_reg_rtx (SImode);
10994   rtx newv = gen_reg_rtx (SImode);
10995   rtx oldvalue = gen_reg_rtx (SImode);
10996   rtx newvalue = gen_reg_rtx (SImode);
10997   rtx res = gen_reg_rtx (SImode);
10998   rtx resv = gen_reg_rtx (SImode);
10999   rtx memsi, val, mask, end_label, loop_label, cc;
11000
11001   emit_insn (gen_rtx_SET (VOIDmode, addr,
11002                           gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
11003
11004   if (Pmode != SImode)
11005     addr1 = gen_lowpart (SImode, addr1);
11006   emit_insn (gen_rtx_SET (VOIDmode, off,
11007                           gen_rtx_AND (SImode, addr1, GEN_INT (3))));
11008
11009   memsi = gen_rtx_MEM (SImode, addr);
11010   set_mem_alias_set (memsi, ALIAS_SET_MEMORY_BARRIER);
11011   MEM_VOLATILE_P (memsi) = MEM_VOLATILE_P (mem);
11012
11013   val = copy_to_reg (memsi);
11014
11015   emit_insn (gen_rtx_SET (VOIDmode, off,
11016                           gen_rtx_XOR (SImode, off,
11017                                        GEN_INT (GET_MODE (mem) == QImode
11018                                                 ? 3 : 2))));
11019
11020   emit_insn (gen_rtx_SET (VOIDmode, off,
11021                           gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
11022
11023   if (GET_MODE (mem) == QImode)
11024     mask = force_reg (SImode, GEN_INT (0xff));
11025   else
11026     mask = force_reg (SImode, GEN_INT (0xffff));
11027
11028   emit_insn (gen_rtx_SET (VOIDmode, mask,
11029                           gen_rtx_ASHIFT (SImode, mask, off)));
11030
11031   emit_insn (gen_rtx_SET (VOIDmode, val,
11032                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
11033                                        val)));
11034
11035   oldval = gen_lowpart (SImode, oldval);
11036   emit_insn (gen_rtx_SET (VOIDmode, oldv,
11037                           gen_rtx_ASHIFT (SImode, oldval, off)));
11038
11039   newval = gen_lowpart_common (SImode, newval);
11040   emit_insn (gen_rtx_SET (VOIDmode, newv,
11041                           gen_rtx_ASHIFT (SImode, newval, off)));
11042
11043   emit_insn (gen_rtx_SET (VOIDmode, oldv,
11044                           gen_rtx_AND (SImode, oldv, mask)));
11045
11046   emit_insn (gen_rtx_SET (VOIDmode, newv,
11047                           gen_rtx_AND (SImode, newv, mask)));
11048
11049   end_label = gen_label_rtx ();
11050   loop_label = gen_label_rtx ();
11051   emit_label (loop_label);
11052
11053   emit_insn (gen_rtx_SET (VOIDmode, oldvalue,
11054                           gen_rtx_IOR (SImode, oldv, val)));
11055
11056   emit_insn (gen_rtx_SET (VOIDmode, newvalue,
11057                           gen_rtx_IOR (SImode, newv, val)));
11058
11059   emit_move_insn (bool_result, const1_rtx);
11060
11061   emit_insn (gen_atomic_compare_and_swapsi_1 (res, memsi, oldvalue, newvalue));
11062
11063   emit_cmp_and_jump_insns (res, oldvalue, EQ, NULL, SImode, 0, end_label);
11064
11065   emit_insn (gen_rtx_SET (VOIDmode, resv,
11066                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
11067                                        res)));
11068
11069   emit_move_insn (bool_result, const0_rtx);
11070
11071   cc = gen_compare_reg_1 (NE, resv, val);
11072   emit_insn (gen_rtx_SET (VOIDmode, val, resv));
11073
11074   /* Use cbranchcc4 to separate the compare and branch!  */
11075   emit_jump_insn (gen_cbranchcc4 (gen_rtx_NE (VOIDmode, cc, const0_rtx),
11076                                   cc, const0_rtx, loop_label));
11077
11078   emit_label (end_label);
11079
11080   emit_insn (gen_rtx_SET (VOIDmode, res,
11081                           gen_rtx_AND (SImode, res, mask)));
11082
11083   emit_insn (gen_rtx_SET (VOIDmode, res,
11084                           gen_rtx_LSHIFTRT (SImode, res, off)));
11085
11086   emit_move_insn (result, gen_lowpart (GET_MODE (result), res));
11087 }
11088
11089 /* Expand code to perform a compare-and-swap.  */
11090
11091 void
11092 sparc_expand_compare_and_swap (rtx operands[])
11093 {
11094   rtx bval, retval, mem, oldval, newval;
11095   enum machine_mode mode;
11096   enum memmodel model;
11097
11098   bval = operands[0];
11099   retval = operands[1];
11100   mem = operands[2];
11101   oldval = operands[3];
11102   newval = operands[4];
11103   model = (enum memmodel) INTVAL (operands[6]);
11104   mode = GET_MODE (mem);
11105
11106   sparc_emit_membar_for_model (model, 3, 1);
11107
11108   if (reg_overlap_mentioned_p (retval, oldval))
11109     oldval = copy_to_reg (oldval);
11110
11111   if (mode == QImode || mode == HImode)
11112     sparc_expand_compare_and_swap_12 (bval, retval, mem, oldval, newval);
11113   else
11114     {
11115       rtx (*gen) (rtx, rtx, rtx, rtx);
11116       rtx x;
11117
11118       if (mode == SImode)
11119         gen = gen_atomic_compare_and_swapsi_1;
11120       else
11121         gen = gen_atomic_compare_and_swapdi_1;
11122       emit_insn (gen (retval, mem, oldval, newval));
11123
11124       x = emit_store_flag (bval, EQ, retval, oldval, mode, 1, 1);
11125       if (x != bval)
11126         convert_move (bval, x, 1);
11127     }
11128
11129   sparc_emit_membar_for_model (model, 3, 2);
11130 }
11131
11132 void
11133 sparc_expand_vec_perm_bmask (enum machine_mode vmode, rtx sel)
11134 {
11135   rtx t_1, t_2, t_3;
11136
11137   sel = gen_lowpart (DImode, sel);
11138   switch (vmode)
11139     {
11140     case V2SImode:
11141       /* inp = xxxxxxxAxxxxxxxB */
11142       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11143                                  NULL_RTX, 1, OPTAB_DIRECT);
11144       /* t_1 = ....xxxxxxxAxxx. */
11145       sel = expand_simple_binop (SImode, AND, gen_lowpart (SImode, sel),
11146                                  GEN_INT (3), NULL_RTX, 1, OPTAB_DIRECT);
11147       t_1 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_1),
11148                                  GEN_INT (0x30000), NULL_RTX, 1, OPTAB_DIRECT);
11149       /* sel = .......B */
11150       /* t_1 = ...A.... */
11151       sel = expand_simple_binop (SImode, IOR, sel, t_1, sel, 1, OPTAB_DIRECT);
11152       /* sel = ...A...B */
11153       sel = expand_mult (SImode, sel, GEN_INT (0x4444), sel, 1);
11154       /* sel = AAAABBBB * 4 */
11155       t_1 = force_reg (SImode, GEN_INT (0x01230123));
11156       /* sel = { A*4, A*4+1, A*4+2, ... } */
11157       break;
11158
11159     case V4HImode:
11160       /* inp = xxxAxxxBxxxCxxxD */
11161       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (8),
11162                                  NULL_RTX, 1, OPTAB_DIRECT);
11163       t_2 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11164                                  NULL_RTX, 1, OPTAB_DIRECT);
11165       t_3 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (24),
11166                                  NULL_RTX, 1, OPTAB_DIRECT);
11167       /* t_1 = ..xxxAxxxBxxxCxx */
11168       /* t_2 = ....xxxAxxxBxxxC */
11169       /* t_3 = ......xxxAxxxBxx */
11170       sel = expand_simple_binop (SImode, AND, gen_lowpart (SImode, sel),
11171                                  GEN_INT (0x07),
11172                                  NULL_RTX, 1, OPTAB_DIRECT);
11173       t_1 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_1),
11174                                  GEN_INT (0x0700),
11175                                  NULL_RTX, 1, OPTAB_DIRECT);
11176       t_2 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_2),
11177                                  GEN_INT (0x070000),
11178                                  NULL_RTX, 1, OPTAB_DIRECT);
11179       t_3 = expand_simple_binop (SImode, AND, gen_lowpart (SImode, t_3),
11180                                  GEN_INT (0x07000000),
11181                                  NULL_RTX, 1, OPTAB_DIRECT);
11182       /* sel = .......D */
11183       /* t_1 = .....C.. */
11184       /* t_2 = ...B.... */
11185       /* t_3 = .A...... */
11186       sel = expand_simple_binop (SImode, IOR, sel, t_1, sel, 1, OPTAB_DIRECT);
11187       t_2 = expand_simple_binop (SImode, IOR, t_2, t_3, t_2, 1, OPTAB_DIRECT);
11188       sel = expand_simple_binop (SImode, IOR, sel, t_2, sel, 1, OPTAB_DIRECT);
11189       /* sel = .A.B.C.D */
11190       sel = expand_mult (SImode, sel, GEN_INT (0x22), sel, 1);
11191       /* sel = AABBCCDD * 2 */
11192       t_1 = force_reg (SImode, GEN_INT (0x01010101));
11193       /* sel = { A*2, A*2+1, B*2, B*2+1, ... } */
11194       break;
11195
11196     case V8QImode:
11197       /* input = xAxBxCxDxExFxGxH */
11198       sel = expand_simple_binop (DImode, AND, sel,
11199                                  GEN_INT ((HOST_WIDE_INT)0x0f0f0f0f << 32
11200                                           | 0x0f0f0f0f),
11201                                  NULL_RTX, 1, OPTAB_DIRECT);
11202       /* sel = .A.B.C.D.E.F.G.H */
11203       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (4),
11204                                  NULL_RTX, 1, OPTAB_DIRECT);
11205       /* t_1 = ..A.B.C.D.E.F.G. */
11206       sel = expand_simple_binop (DImode, IOR, sel, t_1,
11207                                  NULL_RTX, 1, OPTAB_DIRECT);
11208       /* sel = .AABBCCDDEEFFGGH */
11209       sel = expand_simple_binop (DImode, AND, sel,
11210                                  GEN_INT ((HOST_WIDE_INT)0xff00ff << 32
11211                                           | 0xff00ff),
11212                                  NULL_RTX, 1, OPTAB_DIRECT);
11213       /* sel = ..AB..CD..EF..GH */
11214       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (8),
11215                                  NULL_RTX, 1, OPTAB_DIRECT);
11216       /* t_1 = ....AB..CD..EF.. */
11217       sel = expand_simple_binop (DImode, IOR, sel, t_1,
11218                                  NULL_RTX, 1, OPTAB_DIRECT);
11219       /* sel = ..ABABCDCDEFEFGH */
11220       sel = expand_simple_binop (DImode, AND, sel,
11221                                  GEN_INT ((HOST_WIDE_INT)0xffff << 32 | 0xffff),
11222                                  NULL_RTX, 1, OPTAB_DIRECT);
11223       /* sel = ....ABCD....EFGH */
11224       t_1 = expand_simple_binop (DImode, LSHIFTRT, sel, GEN_INT (16),
11225                                  NULL_RTX, 1, OPTAB_DIRECT);
11226       /* t_1 = ........ABCD.... */
11227       sel = gen_lowpart (SImode, sel);
11228       t_1 = gen_lowpart (SImode, t_1);
11229       break;
11230
11231     default:
11232       gcc_unreachable ();
11233     }
11234
11235   /* Always perform the final addition/merge within the bmask insn.  */
11236   emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), sel, t_1));
11237 }
11238
11239 /* Implement TARGET_FRAME_POINTER_REQUIRED.  */
11240
11241 static bool
11242 sparc_frame_pointer_required (void)
11243 {
11244   /* If the stack pointer is dynamically modified in the function, it cannot
11245      serve as the frame pointer.  */
11246   if (cfun->calls_alloca)
11247     return true;
11248
11249   /* If the function receives nonlocal gotos, it needs to save the frame
11250      pointer in the nonlocal_goto_save_area object.  */
11251   if (cfun->has_nonlocal_label)
11252     return true;
11253
11254   /* In flat mode, that's it.  */
11255   if (TARGET_FLAT)
11256     return false;
11257
11258   /* Otherwise, the frame pointer is required if the function isn't leaf.  */
11259   return !(current_function_is_leaf && only_leaf_regs_used ());
11260 }
11261
11262 /* The way this is structured, we can't eliminate SFP in favor of SP
11263    if the frame pointer is required: we want to use the SFP->HFP elimination
11264    in that case.  But the test in update_eliminables doesn't know we are
11265    assuming below that we only do the former elimination.  */
11266
11267 static bool
11268 sparc_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
11269 {
11270   return to == HARD_FRAME_POINTER_REGNUM || !sparc_frame_pointer_required ();
11271 }
11272
11273 /* Return the hard frame pointer directly to bypass the stack bias.  */
11274
11275 static rtx
11276 sparc_builtin_setjmp_frame_value (void)
11277 {
11278   return hard_frame_pointer_rtx;
11279 }
11280
11281 /* If !TARGET_FPU, then make the fp registers and fp cc regs fixed so that
11282    they won't be allocated.  */
11283
11284 static void
11285 sparc_conditional_register_usage (void)
11286 {
11287   if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
11288     {
11289       fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
11290       call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
11291     }
11292   /* If the user has passed -f{fixed,call-{used,saved}}-g5 */
11293   /* then honor it.  */
11294   if (TARGET_ARCH32 && fixed_regs[5])
11295     fixed_regs[5] = 1;
11296   else if (TARGET_ARCH64 && fixed_regs[5] == 2)
11297     fixed_regs[5] = 0;
11298   if (! TARGET_V9)
11299     {
11300       int regno;
11301       for (regno = SPARC_FIRST_V9_FP_REG;
11302            regno <= SPARC_LAST_V9_FP_REG;
11303            regno++)
11304         fixed_regs[regno] = 1;
11305       /* %fcc0 is used by v8 and v9.  */
11306       for (regno = SPARC_FIRST_V9_FCC_REG + 1;
11307            regno <= SPARC_LAST_V9_FCC_REG;
11308            regno++)
11309         fixed_regs[regno] = 1;
11310     }
11311   if (! TARGET_FPU)
11312     {
11313       int regno;
11314       for (regno = 32; regno < SPARC_LAST_V9_FCC_REG; regno++)
11315         fixed_regs[regno] = 1;
11316     }
11317   /* If the user has passed -f{fixed,call-{used,saved}}-g2 */
11318   /* then honor it.  Likewise with g3 and g4.  */
11319   if (fixed_regs[2] == 2)
11320     fixed_regs[2] = ! TARGET_APP_REGS;
11321   if (fixed_regs[3] == 2)
11322     fixed_regs[3] = ! TARGET_APP_REGS;
11323   if (TARGET_ARCH32 && fixed_regs[4] == 2)
11324     fixed_regs[4] = ! TARGET_APP_REGS;
11325   else if (TARGET_CM_EMBMEDANY)
11326     fixed_regs[4] = 1;
11327   else if (fixed_regs[4] == 2)
11328     fixed_regs[4] = 0;
11329   if (TARGET_FLAT)
11330     {
11331       int regno;
11332       /* Disable leaf functions.  */
11333       memset (sparc_leaf_regs, 0, FIRST_PSEUDO_REGISTER);
11334       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
11335         leaf_reg_remap [regno] = regno;
11336     }
11337   if (TARGET_VIS)
11338     global_regs[SPARC_GSR_REG] = 1;
11339 }
11340
11341 /* Implement TARGET_PREFERRED_RELOAD_CLASS:
11342
11343    - We can't load constants into FP registers.
11344    - We can't load FP constants into integer registers when soft-float,
11345      because there is no soft-float pattern with a r/F constraint.
11346    - We can't load FP constants into integer registers for TFmode unless
11347      it is 0.0L, because there is no movtf pattern with a r/F constraint.
11348    - Try and reload integer constants (symbolic or otherwise) back into
11349      registers directly, rather than having them dumped to memory.  */
11350
11351 static reg_class_t
11352 sparc_preferred_reload_class (rtx x, reg_class_t rclass)
11353 {
11354   enum machine_mode mode = GET_MODE (x);
11355   if (CONSTANT_P (x))
11356     {
11357       if (FP_REG_CLASS_P (rclass)
11358           || rclass == GENERAL_OR_FP_REGS
11359           || rclass == GENERAL_OR_EXTRA_FP_REGS
11360           || (GET_MODE_CLASS (mode) == MODE_FLOAT && ! TARGET_FPU)
11361           || (mode == TFmode && ! const_zero_operand (x, mode)))
11362         return NO_REGS;
11363
11364       if (GET_MODE_CLASS (mode) == MODE_INT)
11365         return GENERAL_REGS;
11366
11367       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
11368         {
11369           if (! FP_REG_CLASS_P (rclass)
11370               || !(const_zero_operand (x, mode)
11371                    || const_all_ones_operand (x, mode)))
11372             return NO_REGS;
11373         }
11374     }
11375
11376   if (TARGET_VIS3
11377       && ! TARGET_ARCH64
11378       && (rclass == EXTRA_FP_REGS
11379           || rclass == GENERAL_OR_EXTRA_FP_REGS))
11380     {
11381       int regno = true_regnum (x);
11382
11383       if (SPARC_INT_REG_P (regno))
11384         return (rclass == EXTRA_FP_REGS
11385                 ? FP_REGS : GENERAL_OR_FP_REGS);
11386     }
11387
11388   return rclass;
11389 }
11390
11391 /* Output a wide multiply instruction in V8+ mode.  INSN is the instruction,
11392    OPERANDS are its operands and OPCODE is the mnemonic to be used.  */
11393
11394 const char *
11395 output_v8plus_mult (rtx insn, rtx *operands, const char *opcode)
11396 {
11397   char mulstr[32];
11398
11399   gcc_assert (! TARGET_ARCH64);
11400
11401   if (sparc_check_64 (operands[1], insn) <= 0)
11402     output_asm_insn ("srl\t%L1, 0, %L1", operands);
11403   if (which_alternative == 1)
11404     output_asm_insn ("sllx\t%H1, 32, %H1", operands);
11405   if (GET_CODE (operands[2]) == CONST_INT)
11406     {
11407       if (which_alternative == 1)
11408         {
11409           output_asm_insn ("or\t%L1, %H1, %H1", operands);
11410           sprintf (mulstr, "%s\t%%H1, %%2, %%L0", opcode);
11411           output_asm_insn (mulstr, operands);
11412           return "srlx\t%L0, 32, %H0";
11413         }
11414       else
11415         {
11416           output_asm_insn ("sllx\t%H1, 32, %3", operands);
11417           output_asm_insn ("or\t%L1, %3, %3", operands);
11418           sprintf (mulstr, "%s\t%%3, %%2, %%3", opcode);
11419           output_asm_insn (mulstr, operands);
11420           output_asm_insn ("srlx\t%3, 32, %H0", operands);
11421           return "mov\t%3, %L0";
11422         }
11423     }
11424   else if (rtx_equal_p (operands[1], operands[2]))
11425     {
11426       if (which_alternative == 1)
11427         {
11428           output_asm_insn ("or\t%L1, %H1, %H1", operands);
11429           sprintf (mulstr, "%s\t%%H1, %%H1, %%L0", opcode);
11430           output_asm_insn (mulstr, operands);
11431           return "srlx\t%L0, 32, %H0";
11432         }
11433       else
11434         {
11435           output_asm_insn ("sllx\t%H1, 32, %3", operands);
11436           output_asm_insn ("or\t%L1, %3, %3", operands);
11437           sprintf (mulstr, "%s\t%%3, %%3, %%3", opcode);
11438           output_asm_insn (mulstr, operands);
11439           output_asm_insn ("srlx\t%3, 32, %H0", operands);
11440           return "mov\t%3, %L0";
11441         }
11442     }
11443   if (sparc_check_64 (operands[2], insn) <= 0)
11444     output_asm_insn ("srl\t%L2, 0, %L2", operands);
11445   if (which_alternative == 1)
11446     {
11447       output_asm_insn ("or\t%L1, %H1, %H1", operands);
11448       output_asm_insn ("sllx\t%H2, 32, %L1", operands);
11449       output_asm_insn ("or\t%L2, %L1, %L1", operands);
11450       sprintf (mulstr, "%s\t%%H1, %%L1, %%L0", opcode);
11451       output_asm_insn (mulstr, operands);
11452       return "srlx\t%L0, 32, %H0";
11453     }
11454   else
11455     {
11456       output_asm_insn ("sllx\t%H1, 32, %3", operands);
11457       output_asm_insn ("sllx\t%H2, 32, %4", operands);
11458       output_asm_insn ("or\t%L1, %3, %3", operands);
11459       output_asm_insn ("or\t%L2, %4, %4", operands);
11460       sprintf (mulstr, "%s\t%%3, %%4, %%3", opcode);
11461       output_asm_insn (mulstr, operands);
11462       output_asm_insn ("srlx\t%3, 32, %H0", operands);
11463       return "mov\t%3, %L0";
11464     }
11465 }
11466
11467 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11468    all fields of TARGET to ELT by means of VIS2 BSHUFFLE insn.  MODE
11469    and INNER_MODE are the modes describing TARGET.  */
11470
11471 static void
11472 vector_init_bshuffle (rtx target, rtx elt, enum machine_mode mode,
11473                       enum machine_mode inner_mode)
11474 {
11475   rtx t1, final_insn;
11476   int bmask;
11477
11478   t1 = gen_reg_rtx (mode);
11479
11480   elt = convert_modes (SImode, inner_mode, elt, true);
11481   emit_move_insn (gen_lowpart(SImode, t1), elt);
11482
11483   switch (mode)
11484     {
11485     case V2SImode:
11486       final_insn = gen_bshufflev2si_vis (target, t1, t1);
11487       bmask = 0x45674567;
11488       break;
11489     case V4HImode:
11490       final_insn = gen_bshufflev4hi_vis (target, t1, t1);
11491       bmask = 0x67676767;
11492       break;
11493     case V8QImode:
11494       final_insn = gen_bshufflev8qi_vis (target, t1, t1);
11495       bmask = 0x77777777;
11496       break;
11497     default:
11498       gcc_unreachable ();
11499     }
11500
11501   emit_insn (gen_bmasksi_vis (gen_reg_rtx (SImode), CONST0_RTX (SImode),
11502                               force_reg (SImode, GEN_INT (bmask))));
11503   emit_insn (final_insn);
11504 }
11505
11506 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11507    all fields of TARGET to ELT in V8QI by means of VIS FPMERGE insn.  */
11508
11509 static void
11510 vector_init_fpmerge (rtx target, rtx elt)
11511 {
11512   rtx t1, t2, t2_low, t3, t3_low;
11513
11514   t1 = gen_reg_rtx (V4QImode);
11515   elt = convert_modes (SImode, QImode, elt, true);
11516   emit_move_insn (gen_lowpart (SImode, t1), elt);
11517
11518   t2 = gen_reg_rtx (V8QImode);
11519   t2_low = gen_lowpart (V4QImode, t2);
11520   emit_insn (gen_fpmerge_vis (t2, t1, t1));
11521
11522   t3 = gen_reg_rtx (V8QImode);
11523   t3_low = gen_lowpart (V4QImode, t3);
11524   emit_insn (gen_fpmerge_vis (t3, t2_low, t2_low));
11525
11526   emit_insn (gen_fpmerge_vis (target, t3_low, t3_low));
11527 }
11528
11529 /* Subroutine of sparc_expand_vector_init.  Emit code to initialize
11530    all fields of TARGET to ELT in V4HI by means of VIS FALIGNDATA insn.  */
11531
11532 static void
11533 vector_init_faligndata (rtx target, rtx elt)
11534 {
11535   rtx t1 = gen_reg_rtx (V4HImode);
11536   int i;
11537
11538   elt = convert_modes (SImode, HImode, elt, true);
11539   emit_move_insn (gen_lowpart (SImode, t1), elt);
11540
11541   emit_insn (gen_alignaddrsi_vis (gen_reg_rtx (SImode),
11542                                   force_reg (SImode, GEN_INT (6)),
11543                                   const0_rtx));
11544
11545   for (i = 0; i < 4; i++)
11546     emit_insn (gen_faligndatav4hi_vis (target, t1, target));
11547 }
11548
11549 /* Emit code to initialize TARGET to values for individual fields VALS.  */
11550
11551 void
11552 sparc_expand_vector_init (rtx target, rtx vals)
11553 {
11554   const enum machine_mode mode = GET_MODE (target);
11555   const enum machine_mode inner_mode = GET_MODE_INNER (mode);
11556   const int n_elts = GET_MODE_NUNITS (mode);
11557   int i, n_var = 0;
11558   bool all_same;
11559   rtx mem;
11560
11561   all_same = true;
11562   for (i = 0; i < n_elts; i++)
11563     {
11564       rtx x = XVECEXP (vals, 0, i);
11565       if (!CONSTANT_P (x))
11566         n_var++;
11567
11568       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
11569         all_same = false;
11570     }
11571
11572   if (n_var == 0)
11573     {
11574       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
11575       return;
11576     }
11577
11578   if (GET_MODE_SIZE (inner_mode) == GET_MODE_SIZE (mode))
11579     {
11580       if (GET_MODE_SIZE (inner_mode) == 4)
11581         {
11582           emit_move_insn (gen_lowpart (SImode, target),
11583                           gen_lowpart (SImode, XVECEXP (vals, 0, 0)));
11584           return;
11585         }
11586       else if (GET_MODE_SIZE (inner_mode) == 8)
11587         {
11588           emit_move_insn (gen_lowpart (DImode, target),
11589                           gen_lowpart (DImode, XVECEXP (vals, 0, 0)));
11590           return;
11591         }
11592     }
11593   else if (GET_MODE_SIZE (inner_mode) == GET_MODE_SIZE (word_mode)
11594            && GET_MODE_SIZE (mode) == 2 * GET_MODE_SIZE (word_mode))
11595     {
11596       emit_move_insn (gen_highpart (word_mode, target),
11597                       gen_lowpart (word_mode, XVECEXP (vals, 0, 0)));
11598       emit_move_insn (gen_lowpart (word_mode, target),
11599                       gen_lowpart (word_mode, XVECEXP (vals, 0, 1)));
11600       return;
11601     }
11602
11603   if (all_same && GET_MODE_SIZE (mode) == 8)
11604     {
11605       if (TARGET_VIS2)
11606         {
11607           vector_init_bshuffle (target, XVECEXP (vals, 0, 0), mode, inner_mode);
11608           return;
11609         }
11610       if (mode == V8QImode)
11611         {
11612           vector_init_fpmerge (target, XVECEXP (vals, 0, 0));
11613           return;
11614         }
11615       if (mode == V4HImode)
11616         {
11617           vector_init_faligndata (target, XVECEXP (vals, 0, 0));
11618           return;
11619         }
11620     }
11621
11622   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
11623   for (i = 0; i < n_elts; i++)
11624     emit_move_insn (adjust_address_nv (mem, inner_mode,
11625                                        i * GET_MODE_SIZE (inner_mode)),
11626                     XVECEXP (vals, 0, i));
11627   emit_move_insn (target, mem);
11628 }
11629
11630 /* Implement TARGET_SECONDARY_RELOAD.  */
11631
11632 static reg_class_t
11633 sparc_secondary_reload (bool in_p, rtx x, reg_class_t rclass_i,
11634                         enum machine_mode mode, secondary_reload_info *sri)
11635 {
11636   enum reg_class rclass = (enum reg_class) rclass_i;
11637
11638   sri->icode = CODE_FOR_nothing;
11639   sri->extra_cost = 0;
11640
11641   /* We need a temporary when loading/storing a HImode/QImode value
11642      between memory and the FPU registers.  This can happen when combine puts
11643      a paradoxical subreg in a float/fix conversion insn.  */
11644   if (FP_REG_CLASS_P (rclass)
11645       && (mode == HImode || mode == QImode)
11646       && (GET_CODE (x) == MEM
11647           || ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
11648               && true_regnum (x) == -1)))
11649     return GENERAL_REGS;
11650
11651   /* On 32-bit we need a temporary when loading/storing a DFmode value
11652      between unaligned memory and the upper FPU registers.  */
11653   if (TARGET_ARCH32
11654       && rclass == EXTRA_FP_REGS
11655       && mode == DFmode
11656       && GET_CODE (x) == MEM
11657       && ! mem_min_alignment (x, 8))
11658     return FP_REGS;
11659
11660   if (((TARGET_CM_MEDANY
11661         && symbolic_operand (x, mode))
11662        || (TARGET_CM_EMBMEDANY
11663            && text_segment_operand (x, mode)))
11664       && ! flag_pic)
11665     {
11666       if (in_p)
11667         sri->icode = direct_optab_handler (reload_in_optab, mode);
11668       else
11669         sri->icode = direct_optab_handler (reload_out_optab, mode);
11670       return NO_REGS;
11671     }
11672
11673   if (TARGET_VIS3 && TARGET_ARCH32)
11674     {
11675       int regno = true_regnum (x);
11676
11677       /* When using VIS3 fp<-->int register moves, on 32-bit we have
11678          to move 8-byte values in 4-byte pieces.  This only works via
11679          FP_REGS, and not via EXTRA_FP_REGS.  Therefore if we try to
11680          move between EXTRA_FP_REGS and GENERAL_REGS, we will need
11681          an FP_REGS intermediate move.  */
11682       if ((rclass == EXTRA_FP_REGS && SPARC_INT_REG_P (regno))
11683           || ((general_or_i64_p (rclass)
11684                || rclass == GENERAL_OR_FP_REGS)
11685               && SPARC_FP_REG_P (regno)))
11686         {
11687           sri->extra_cost = 2;
11688           return FP_REGS;
11689         }
11690     }
11691
11692   return NO_REGS;
11693 }
11694
11695 /* Emit code to conditionally move either OPERANDS[2] or OPERANDS[3] into
11696    OPERANDS[0] in MODE.  OPERANDS[1] is the operator of the condition.  */
11697
11698 bool
11699 sparc_expand_conditional_move (enum machine_mode mode, rtx *operands)
11700 {
11701   enum rtx_code rc = GET_CODE (operands[1]);
11702   enum machine_mode cmp_mode;
11703   rtx cc_reg, dst, cmp;
11704
11705   cmp = operands[1];
11706   if (GET_MODE (XEXP (cmp, 0)) == DImode && !TARGET_ARCH64)
11707     return false;
11708
11709   if (GET_MODE (XEXP (cmp, 0)) == TFmode && !TARGET_HARD_QUAD)
11710     cmp = sparc_emit_float_lib_cmp (XEXP (cmp, 0), XEXP (cmp, 1), rc);
11711
11712   cmp_mode = GET_MODE (XEXP (cmp, 0));
11713   rc = GET_CODE (cmp);
11714
11715   dst = operands[0];
11716   if (! rtx_equal_p (operands[2], dst)
11717       && ! rtx_equal_p (operands[3], dst))
11718     {
11719       if (reg_overlap_mentioned_p (dst, cmp))
11720         dst = gen_reg_rtx (mode);
11721
11722       emit_move_insn (dst, operands[3]);
11723     }
11724   else if (operands[2] == dst)
11725     {
11726       operands[2] = operands[3];
11727
11728       if (GET_MODE_CLASS (cmp_mode) == MODE_FLOAT)
11729         rc = reverse_condition_maybe_unordered (rc);
11730       else
11731         rc = reverse_condition (rc);
11732     }
11733
11734   if (XEXP (cmp, 1) == const0_rtx
11735       && GET_CODE (XEXP (cmp, 0)) == REG
11736       && cmp_mode == DImode
11737       && v9_regcmp_p (rc))
11738     cc_reg = XEXP (cmp, 0);
11739   else
11740     cc_reg = gen_compare_reg_1 (rc, XEXP (cmp, 0), XEXP (cmp, 1));
11741
11742   cmp = gen_rtx_fmt_ee (rc, GET_MODE (cc_reg), cc_reg, const0_rtx);
11743
11744   emit_insn (gen_rtx_SET (VOIDmode, dst,
11745                           gen_rtx_IF_THEN_ELSE (mode, cmp, operands[2], dst)));
11746
11747   if (dst != operands[0])
11748     emit_move_insn (operands[0], dst);
11749
11750   return true;
11751 }
11752
11753 /* Emit code to conditionally move a combination of OPERANDS[1] and OPERANDS[2]
11754    into OPERANDS[0] in MODE, depending on the outcome of the comparison of
11755    OPERANDS[4] and OPERANDS[5].  OPERANDS[3] is the operator of the condition.
11756    FCODE is the machine code to be used for OPERANDS[3] and CCODE the machine
11757    code to be used for the condition mask.  */
11758
11759 void
11760 sparc_expand_vcond (enum machine_mode mode, rtx *operands, int ccode, int fcode)
11761 {
11762   rtx mask, cop0, cop1, fcmp, cmask, bshuf, gsr;
11763   enum rtx_code code = GET_CODE (operands[3]);
11764
11765   mask = gen_reg_rtx (Pmode);
11766   cop0 = operands[4];
11767   cop1 = operands[5];
11768   if (code == LT || code == GE)
11769     {
11770       rtx t;
11771
11772       code = swap_condition (code);
11773       t = cop0; cop0 = cop1; cop1 = t;
11774     }
11775
11776   gsr = gen_rtx_REG (DImode, SPARC_GSR_REG);
11777
11778   fcmp = gen_rtx_UNSPEC (Pmode,
11779                          gen_rtvec (1, gen_rtx_fmt_ee (code, mode, cop0, cop1)),
11780                          fcode);
11781
11782   cmask = gen_rtx_UNSPEC (DImode,
11783                           gen_rtvec (2, mask, gsr),
11784                           ccode);
11785
11786   bshuf = gen_rtx_UNSPEC (mode,
11787                           gen_rtvec (3, operands[1], operands[2], gsr),
11788                           UNSPEC_BSHUFFLE);
11789
11790   emit_insn (gen_rtx_SET (VOIDmode, mask, fcmp));
11791   emit_insn (gen_rtx_SET (VOIDmode, gsr, cmask));
11792
11793   emit_insn (gen_rtx_SET (VOIDmode, operands[0], bshuf));
11794 }
11795
11796 /* On sparc, any mode which naturally allocates into the float
11797    registers should return 4 here.  */
11798
11799 unsigned int
11800 sparc_regmode_natural_size (enum machine_mode mode)
11801 {
11802   int size = UNITS_PER_WORD;
11803
11804   if (TARGET_ARCH64)
11805     {
11806       enum mode_class mclass = GET_MODE_CLASS (mode);
11807
11808       if (mclass == MODE_FLOAT || mclass == MODE_VECTOR_INT)
11809         size = 4;
11810     }
11811
11812   return size;
11813 }
11814
11815 /* Return TRUE if it is a good idea to tie two pseudo registers
11816    when one has mode MODE1 and one has mode MODE2.
11817    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
11818    for any hard reg, then this must be FALSE for correct output.
11819
11820    For V9 we have to deal with the fact that only the lower 32 floating
11821    point registers are 32-bit addressable.  */
11822
11823 bool
11824 sparc_modes_tieable_p (enum machine_mode mode1, enum machine_mode mode2)
11825 {
11826   enum mode_class mclass1, mclass2;
11827   unsigned short size1, size2;
11828
11829   if (mode1 == mode2)
11830     return true;
11831
11832   mclass1 = GET_MODE_CLASS (mode1);
11833   mclass2 = GET_MODE_CLASS (mode2);
11834   if (mclass1 != mclass2)
11835     return false;
11836
11837   if (! TARGET_V9)
11838     return true;
11839
11840   /* Classes are the same and we are V9 so we have to deal with upper
11841      vs. lower floating point registers.  If one of the modes is a
11842      4-byte mode, and the other is not, we have to mark them as not
11843      tieable because only the lower 32 floating point register are
11844      addressable 32-bits at a time.
11845
11846      We can't just test explicitly for SFmode, otherwise we won't
11847      cover the vector mode cases properly.  */
11848
11849   if (mclass1 != MODE_FLOAT && mclass1 != MODE_VECTOR_INT)
11850     return true;
11851
11852   size1 = GET_MODE_SIZE (mode1);
11853   size2 = GET_MODE_SIZE (mode2);
11854   if ((size1 > 4 && size2 == 4)
11855       || (size2 > 4 && size1 == 4))
11856     return false;
11857
11858   return true;
11859 }
11860
11861 #include "gt-sparc.h"