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
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6    64-bit SPARC-V9 support by Michael Tiemann, Jim Wilson, and Doug Evans,
   7    at Cygnus Support.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 3, or (at your option)
  14 any later version.
  15
  16 GCC is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "config.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "tree.h"
  30 #include "rtl.h"
  31 #include "regs.h"
  32 #include "hard-reg-set.h"
  33 #include "real.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 "expr.h"
  42 #include "optabs.h"
  43 #include "recog.h"
  44 #include "toplev.h"
  45 #include "ggc.h"
  46 #include "tm_p.h"
  47 #include "debug.h"
  48 #include "target.h"
  49 #include "target-def.h"
  50 #include "cfglayout.h"
  51 #include "gimple.h"
  52 #include "langhooks.h"
  53 #include "params.h"
  54 #include "df.h"
  55
  56 /* Processor costs */
  57 static const
  58 struct processor_costs cypress_costs = {
  59   COSTS_N_INSNS (2), /* int load */
  60   COSTS_N_INSNS (2), /* int signed load */
  61   COSTS_N_INSNS (2), /* int zeroed load */
  62   COSTS_N_INSNS (2), /* float load */
  63   COSTS_N_INSNS (5), /* fmov, fneg, fabs */
  64   COSTS_N_INSNS (5), /* fadd, fsub */
  65   COSTS_N_INSNS (1), /* fcmp */
  66   COSTS_N_INSNS (1), /* fmov, fmovr */
  67   COSTS_N_INSNS (7), /* fmul */
  68   COSTS_N_INSNS (37), /* fdivs */
  69   COSTS_N_INSNS (37), /* fdivd */
  70   COSTS_N_INSNS (63), /* fsqrts */
  71   COSTS_N_INSNS (63), /* fsqrtd */
  72   COSTS_N_INSNS (1), /* imul */
  73   COSTS_N_INSNS (1), /* imulX */
  74   0, /* imul bit factor */
  75   COSTS_N_INSNS (1), /* idiv */
  76   COSTS_N_INSNS (1), /* idivX */
  77   COSTS_N_INSNS (1), /* movcc/movr */
  78   0, /* shift penalty */
  79 };
  80
  81 static const
  82 struct processor_costs supersparc_costs = {
  83   COSTS_N_INSNS (1), /* int load */
  84   COSTS_N_INSNS (1), /* int signed load */
  85   COSTS_N_INSNS (1), /* int zeroed load */
  86   COSTS_N_INSNS (0), /* float load */
  87   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
  88   COSTS_N_INSNS (3), /* fadd, fsub */
  89   COSTS_N_INSNS (3), /* fcmp */
  90   COSTS_N_INSNS (1), /* fmov, fmovr */
  91   COSTS_N_INSNS (3), /* fmul */
  92   COSTS_N_INSNS (6), /* fdivs */
  93   COSTS_N_INSNS (9), /* fdivd */
  94   COSTS_N_INSNS (12), /* fsqrts */
  95   COSTS_N_INSNS (12), /* fsqrtd */
  96   COSTS_N_INSNS (4), /* imul */
  97   COSTS_N_INSNS (4), /* imulX */
  98   0, /* imul bit factor */
  99   COSTS_N_INSNS (4), /* idiv */
 100   COSTS_N_INSNS (4), /* idivX */
 101   COSTS_N_INSNS (1), /* movcc/movr */
 102   1, /* shift penalty */
 103 };
 104
 105 static const
 106 struct processor_costs hypersparc_costs = {
 107   COSTS_N_INSNS (1), /* int load */
 108   COSTS_N_INSNS (1), /* int signed load */
 109   COSTS_N_INSNS (1), /* int zeroed load */
 110   COSTS_N_INSNS (1), /* float load */
 111   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 112   COSTS_N_INSNS (1), /* fadd, fsub */
 113   COSTS_N_INSNS (1), /* fcmp */
 114   COSTS_N_INSNS (1), /* fmov, fmovr */
 115   COSTS_N_INSNS (1), /* fmul */
 116   COSTS_N_INSNS (8), /* fdivs */
 117   COSTS_N_INSNS (12), /* fdivd */
 118   COSTS_N_INSNS (17), /* fsqrts */
 119   COSTS_N_INSNS (17), /* fsqrtd */
 120   COSTS_N_INSNS (17), /* imul */
 121   COSTS_N_INSNS (17), /* imulX */
 122   0, /* imul bit factor */
 123   COSTS_N_INSNS (17), /* idiv */
 124   COSTS_N_INSNS (17), /* idivX */
 125   COSTS_N_INSNS (1), /* movcc/movr */
 126   0, /* shift penalty */
 127 };
 128
 129 static const
 130 struct processor_costs sparclet_costs = {
 131   COSTS_N_INSNS (3), /* int load */
 132   COSTS_N_INSNS (3), /* int signed load */
 133   COSTS_N_INSNS (1), /* int zeroed load */
 134   COSTS_N_INSNS (1), /* float load */
 135   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 136   COSTS_N_INSNS (1), /* fadd, fsub */
 137   COSTS_N_INSNS (1), /* fcmp */
 138   COSTS_N_INSNS (1), /* fmov, fmovr */
 139   COSTS_N_INSNS (1), /* fmul */
 140   COSTS_N_INSNS (1), /* fdivs */
 141   COSTS_N_INSNS (1), /* fdivd */
 142   COSTS_N_INSNS (1), /* fsqrts */
 143   COSTS_N_INSNS (1), /* fsqrtd */
 144   COSTS_N_INSNS (5), /* imul */
 145   COSTS_N_INSNS (5), /* imulX */
 146   0, /* imul bit factor */
 147   COSTS_N_INSNS (5), /* idiv */
 148   COSTS_N_INSNS (5), /* idivX */
 149   COSTS_N_INSNS (1), /* movcc/movr */
 150   0, /* shift penalty */
 151 };
 152
 153 static const
 154 struct processor_costs ultrasparc_costs = {
 155   COSTS_N_INSNS (2), /* int load */
 156   COSTS_N_INSNS (3), /* int signed load */
 157   COSTS_N_INSNS (2), /* int zeroed load */
 158   COSTS_N_INSNS (2), /* float load */
 159   COSTS_N_INSNS (1), /* fmov, fneg, fabs */
 160   COSTS_N_INSNS (4), /* fadd, fsub */
 161   COSTS_N_INSNS (1), /* fcmp */
 162   COSTS_N_INSNS (2), /* fmov, fmovr */
 163   COSTS_N_INSNS (4), /* fmul */
 164   COSTS_N_INSNS (13), /* fdivs */
 165   COSTS_N_INSNS (23), /* fdivd */
 166   COSTS_N_INSNS (13), /* fsqrts */
 167   COSTS_N_INSNS (23), /* fsqrtd */
 168   COSTS_N_INSNS (4), /* imul */
 169   COSTS_N_INSNS (4), /* imulX */
 170   2, /* imul bit factor */
 171   COSTS_N_INSNS (37), /* idiv */
 172   COSTS_N_INSNS (68), /* idivX */
 173   COSTS_N_INSNS (2), /* movcc/movr */
 174   2, /* shift penalty */
 175 };
 176
 177 static const
 178 struct processor_costs ultrasparc3_costs = {
 179   COSTS_N_INSNS (2), /* int load */
 180   COSTS_N_INSNS (3), /* int signed load */
 181   COSTS_N_INSNS (3), /* int zeroed load */
 182   COSTS_N_INSNS (2), /* float load */
 183   COSTS_N_INSNS (3), /* fmov, fneg, fabs */
 184   COSTS_N_INSNS (4), /* fadd, fsub */
 185   COSTS_N_INSNS (5), /* fcmp */
 186   COSTS_N_INSNS (3), /* fmov, fmovr */
 187   COSTS_N_INSNS (4), /* fmul */
 188   COSTS_N_INSNS (17), /* fdivs */
 189   COSTS_N_INSNS (20), /* fdivd */
 190   COSTS_N_INSNS (20), /* fsqrts */
 191   COSTS_N_INSNS (29), /* fsqrtd */
 192   COSTS_N_INSNS (6), /* imul */
 193   COSTS_N_INSNS (6), /* imulX */
 194   0, /* imul bit factor */
 195   COSTS_N_INSNS (40), /* idiv */
 196   COSTS_N_INSNS (71), /* idivX */
 197   COSTS_N_INSNS (2), /* movcc/movr */
 198   0, /* shift penalty */
 199 };
 200
 201 static const
 202 struct processor_costs niagara_costs = {
 203   COSTS_N_INSNS (3), /* int load */
 204   COSTS_N_INSNS (3), /* int signed load */
 205   COSTS_N_INSNS (3), /* int zeroed load */
 206   COSTS_N_INSNS (9), /* float load */
 207   COSTS_N_INSNS (8), /* fmov, fneg, fabs */
 208   COSTS_N_INSNS (8), /* fadd, fsub */
 209   COSTS_N_INSNS (26), /* fcmp */
 210   COSTS_N_INSNS (8), /* fmov, fmovr */
 211   COSTS_N_INSNS (29), /* fmul */
 212   COSTS_N_INSNS (54), /* fdivs */
 213   COSTS_N_INSNS (83), /* fdivd */
 214   COSTS_N_INSNS (100), /* fsqrts - not implemented in hardware */
 215   COSTS_N_INSNS (100), /* fsqrtd - not implemented in hardware */
 216   COSTS_N_INSNS (11), /* imul */
 217   COSTS_N_INSNS (11), /* imulX */
 218   0, /* imul bit factor */
 219   COSTS_N_INSNS (72), /* idiv */
 220   COSTS_N_INSNS (72), /* idivX */
 221   COSTS_N_INSNS (1), /* movcc/movr */
 222   0, /* shift penalty */
 223 };
 224
 225 static const
 226 struct processor_costs niagara2_costs = {
 227   COSTS_N_INSNS (3), /* int load */
 228   COSTS_N_INSNS (3), /* int signed load */
 229   COSTS_N_INSNS (3), /* int zeroed load */
 230   COSTS_N_INSNS (3), /* float load */
 231   COSTS_N_INSNS (6), /* fmov, fneg, fabs */
 232   COSTS_N_INSNS (6), /* fadd, fsub */
 233   COSTS_N_INSNS (6), /* fcmp */
 234   COSTS_N_INSNS (6), /* fmov, fmovr */
 235   COSTS_N_INSNS (6), /* fmul */
 236   COSTS_N_INSNS (19), /* fdivs */
 237   COSTS_N_INSNS (33), /* fdivd */
 238   COSTS_N_INSNS (19), /* fsqrts */
 239   COSTS_N_INSNS (33), /* fsqrtd */
 240   COSTS_N_INSNS (5), /* imul */
 241   COSTS_N_INSNS (5), /* imulX */
 242   0, /* imul bit factor */
 243   COSTS_N_INSNS (31), /* idiv, average of 12 - 41 cycle range */
 244   COSTS_N_INSNS (31), /* idivX, average of 12 - 41 cycle range */
 245   COSTS_N_INSNS (1), /* movcc/movr */
 246   0, /* shift penalty */
 247 };
 248
 249 const struct processor_costs *sparc_costs = &cypress_costs;
 250
 251 #ifdef HAVE_AS_RELAX_OPTION
 252 /* If 'as' and 'ld' are relaxing tail call insns into branch always, use
 253    "or %o7,%g0,X; call Y; or X,%g0,%o7" always, so that it can be optimized.
 254    With sethi/jmp, neither 'as' nor 'ld' has an easy way how to find out if
 255    somebody does not branch between the sethi and jmp.  */
 256 #define LEAF_SIBCALL_SLOT_RESERVED_P 1
 257 #else
 258 #define LEAF_SIBCALL_SLOT_RESERVED_P \
 259   ((TARGET_ARCH64 && !TARGET_CM_MEDLOW) || flag_pic)
 260 #endif
 261
 262 /* Global variables for machine-dependent things.  */
 263
 264 /* Size of frame.  Need to know this to emit return insns from leaf procedures.
 265    ACTUAL_FSIZE is set by sparc_compute_frame_size() which is called during the
 266    reload pass.  This is important as the value is later used for scheduling
 267    (to see what can go in a delay slot).
 268    APPARENT_FSIZE is the size of the stack less the register save area and less
 269    the outgoing argument area.  It is used when saving call preserved regs.  */
 270 static HOST_WIDE_INT apparent_fsize;
 271 static HOST_WIDE_INT actual_fsize;
 272
 273 /* Number of live general or floating point registers needed to be
 274    saved (as 4-byte quantities).  */
 275 static int num_gfregs;
 276
 277 /* The alias set for prologue/epilogue register save/restore.  */
 278 static GTY(()) alias_set_type sparc_sr_alias_set;
 279
 280 /* The alias set for the structure return value.  */
 281 static GTY(()) alias_set_type struct_value_alias_set;
 282
 283 /* Vector to say how input registers are mapped to output registers.
 284    HARD_FRAME_POINTER_REGNUM cannot be remapped by this function to
 285    eliminate it.  You must use -fomit-frame-pointer to get that.  */
 286 char leaf_reg_remap[] =
 287 { 0, 1, 2, 3, 4, 5, 6, 7,
 288   -1, -1, -1, -1, -1, -1, 14, -1,
 289   -1, -1, -1, -1, -1, -1, -1, -1,
 290   8, 9, 10, 11, 12, 13, -1, 15,
 291
 292   32, 33, 34, 35, 36, 37, 38, 39,
 293   40, 41, 42, 43, 44, 45, 46, 47,
 294   48, 49, 50, 51, 52, 53, 54, 55,
 295   56, 57, 58, 59, 60, 61, 62, 63,
 296   64, 65, 66, 67, 68, 69, 70, 71,
 297   72, 73, 74, 75, 76, 77, 78, 79,
 298   80, 81, 82, 83, 84, 85, 86, 87,
 299   88, 89, 90, 91, 92, 93, 94, 95,
 300   96, 97, 98, 99, 100};
 301
 302 /* Vector, indexed by hard register number, which contains 1
 303    for a register that is allowable in a candidate for leaf
 304    function treatment.  */
 305 char sparc_leaf_regs[] =
 306 { 1, 1, 1, 1, 1, 1, 1, 1,
 307   0, 0, 0, 0, 0, 0, 1, 0,
 308   0, 0, 0, 0, 0, 0, 0, 0,
 309   1, 1, 1, 1, 1, 1, 0, 1,
 310   1, 1, 1, 1, 1, 1, 1, 1,
 311   1, 1, 1, 1, 1, 1, 1, 1,
 312   1, 1, 1, 1, 1, 1, 1, 1,
 313   1, 1, 1, 1, 1, 1, 1, 1,
 314   1, 1, 1, 1, 1, 1, 1, 1,
 315   1, 1, 1, 1, 1, 1, 1, 1,
 316   1, 1, 1, 1, 1, 1, 1, 1,
 317   1, 1, 1, 1, 1, 1, 1, 1,
 318   1, 1, 1, 1, 1};
 319
 320 struct GTY(()) machine_function
 321 {
 322   /* Some local-dynamic TLS symbol name.  */
 323   const char *some_ld_name;
 324
 325   /* True if the current function is leaf and uses only leaf regs,
 326      so that the SPARC leaf function optimization can be applied.
 327      Private version of current_function_uses_only_leaf_regs, see
 328      sparc_expand_prologue for the rationale.  */
 329   int leaf_function_p;
 330
 331   /* True if the data calculated by sparc_expand_prologue are valid.  */
 332   bool prologue_data_valid_p;
 333 };
 334
 335 #define sparc_leaf_function_p  cfun->machine->leaf_function_p
 336 #define sparc_prologue_data_valid_p  cfun->machine->prologue_data_valid_p
 337
 338 /* Register we pretend to think the frame pointer is allocated to.
 339    Normally, this is %fp, but if we are in a leaf procedure, this
 340    is %sp+"something".  We record "something" separately as it may
 341    be too big for reg+constant addressing.  */
 342 static rtx frame_base_reg;
 343 static HOST_WIDE_INT frame_base_offset;
 344
 345 /* 1 if the next opcode is to be specially indented.  */
 346 int sparc_indent_opcode = 0;
 347
 348 static bool sparc_handle_option (size_t, const char *, int);
 349 static void sparc_init_modes (void);
 350 static void scan_record_type (tree, int *, int *, int *);
 351 static int function_arg_slotno (const CUMULATIVE_ARGS *, enum machine_mode,
 352                                 tree, int, int, int *, int *);
 353
 354 static int supersparc_adjust_cost (rtx, rtx, rtx, int);
 355 static int hypersparc_adjust_cost (rtx, rtx, rtx, int);
 356
 357 static void sparc_output_addr_vec (rtx);
 358 static void sparc_output_addr_diff_vec (rtx);
 359 static void sparc_output_deferred_case_vectors (void);
 360 static bool sparc_legitimate_address_p (enum machine_mode, rtx, bool);
 361 static rtx sparc_builtin_saveregs (void);
 362 static int epilogue_renumber (rtx *, int);
 363 static bool sparc_assemble_integer (rtx, unsigned int, int);
 364 static int set_extends (rtx);
 365 static void emit_pic_helper (void);
 366 static void load_pic_register (bool);
 367 static int save_or_restore_regs (int, int, rtx, int, int);
 368 static void emit_save_or_restore_regs (int);
 369 static void sparc_asm_function_prologue (FILE *, HOST_WIDE_INT);
 370 static void sparc_asm_function_epilogue (FILE *, HOST_WIDE_INT);
 371 #ifdef OBJECT_FORMAT_ELF
 372 static void sparc_elf_asm_named_section (const char *, unsigned int, tree);
 373 #endif
 374
 375 static int sparc_adjust_cost (rtx, rtx, rtx, int);
 376 static int sparc_issue_rate (void);
 377 static void sparc_sched_init (FILE *, int, int);
 378 static int sparc_use_sched_lookahead (void);
 379
 380 static void emit_soft_tfmode_libcall (const char *, int, rtx *);
 381 static void emit_soft_tfmode_binop (enum rtx_code, rtx *);
 382 static void emit_soft_tfmode_unop (enum rtx_code, rtx *);
 383 static void emit_soft_tfmode_cvt (enum rtx_code, rtx *);
 384 static void emit_hard_tfmode_operation (enum rtx_code, rtx *);
 385
 386 static bool sparc_function_ok_for_sibcall (tree, tree);
 387 static void sparc_init_libfuncs (void);
 388 static void sparc_init_builtins (void);
 389 static void sparc_vis_init_builtins (void);
 390 static rtx sparc_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 391 static tree sparc_fold_builtin (tree, tree, bool);
 392 static int sparc_vis_mul8x16 (int, int);
 393 static tree sparc_handle_vis_mul8x16 (int, tree, tree, tree);
 394 static void sparc_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 395                                    HOST_WIDE_INT, tree);
 396 static bool sparc_can_output_mi_thunk (const_tree, HOST_WIDE_INT,
 397                                        HOST_WIDE_INT, const_tree);
 398 static struct machine_function * sparc_init_machine_status (void);
 399 static bool sparc_cannot_force_const_mem (rtx);
 400 static rtx sparc_tls_get_addr (void);
 401 static rtx sparc_tls_got (void);
 402 static const char *get_some_local_dynamic_name (void);
 403 static int get_some_local_dynamic_name_1 (rtx *, void *);
 404 static bool sparc_rtx_costs (rtx, int, int, int *, bool);
 405 static bool sparc_promote_prototypes (const_tree);
 406 static rtx sparc_struct_value_rtx (tree, int);
 407 static enum machine_mode sparc_promote_function_mode (const_tree, enum machine_mode,
 408                                                       int *, const_tree, int);
 409 static bool sparc_return_in_memory (const_tree, const_tree);
 410 static bool sparc_strict_argument_naming (CUMULATIVE_ARGS *);
 411 static void sparc_va_start (tree, rtx);
 412 static tree sparc_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
 413 static bool sparc_vector_mode_supported_p (enum machine_mode);
 414 static rtx sparc_legitimize_address (rtx, rtx, enum machine_mode);
 415 static bool sparc_pass_by_reference (CUMULATIVE_ARGS *,
 416                                      enum machine_mode, const_tree, bool);
 417 static int sparc_arg_partial_bytes (CUMULATIVE_ARGS *,
 418                                     enum machine_mode, tree, bool);
 419 static void sparc_dwarf_handle_frame_unspec (const char *, rtx, int);
 420 static void sparc_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
 421 static void sparc_file_end (void);
 422 static bool sparc_frame_pointer_required (void);
 423 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
 424 static const char *sparc_mangle_type (const_tree);
 425 #endif
 426 \f
 427 #ifdef SUBTARGET_ATTRIBUTE_TABLE
 428 /* Table of valid machine attributes.  */
 429 static const struct attribute_spec sparc_attribute_table[] =
 430 {
 431   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
 432   SUBTARGET_ATTRIBUTE_TABLE,
 433   { NULL,        0, 0, false, false, false, NULL }
 434 };
 435 #endif
 436 \f
 437 /* Option handling.  */
 438
 439 /* Parsed value.  */
 440 enum cmodel sparc_cmodel;
 441
 442 char sparc_hard_reg_printed[8];
 443
 444 struct sparc_cpu_select sparc_select[] =
 445 {
 446   /* switch     name,           tune    arch */
 447   { (char *)0,  "default",      1,      1 },
 448   { (char *)0,  "-mcpu=",       1,      1 },
 449   { (char *)0,  "-mtune=",      1,      0 },
 450   { 0, 0, 0, 0 }
 451 };
 452
 453 /* CPU type.  This is set from TARGET_CPU_DEFAULT and -m{cpu,tune}=xxx.  */
 454 enum processor_type sparc_cpu;
 455
 456 /* Whether\fan FPU option was specified.  */
 457 static bool fpu_option_set = false;
 458
 459 /* Initialize the GCC target structure.  */
 460
 461 /* The sparc default is to use .half rather than .short for aligned
 462    HI objects.  Use .word instead of .long on non-ELF systems.  */
 463 #undef TARGET_ASM_ALIGNED_HI_OP
 464 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
 465 #ifndef OBJECT_FORMAT_ELF
 466 #undef TARGET_ASM_ALIGNED_SI_OP
 467 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
 468 #endif
 469
 470 #undef TARGET_ASM_UNALIGNED_HI_OP
 471 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uahalf\t"
 472 #undef TARGET_ASM_UNALIGNED_SI_OP
 473 #define TARGET_ASM_UNALIGNED_SI_OP "\t.uaword\t"
 474 #undef TARGET_ASM_UNALIGNED_DI_OP
 475 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaxword\t"
 476
 477 /* The target hook has to handle DI-mode values.  */
 478 #undef TARGET_ASM_INTEGER
 479 #define TARGET_ASM_INTEGER sparc_assemble_integer
 480
 481 #undef TARGET_ASM_FUNCTION_PROLOGUE
 482 #define TARGET_ASM_FUNCTION_PROLOGUE sparc_asm_function_prologue
 483 #undef TARGET_ASM_FUNCTION_EPILOGUE
 484 #define TARGET_ASM_FUNCTION_EPILOGUE sparc_asm_function_epilogue
 485
 486 #undef TARGET_SCHED_ADJUST_COST
 487 #define TARGET_SCHED_ADJUST_COST sparc_adjust_cost
 488 #undef TARGET_SCHED_ISSUE_RATE
 489 #define TARGET_SCHED_ISSUE_RATE sparc_issue_rate
 490 #undef TARGET_SCHED_INIT
 491 #define TARGET_SCHED_INIT sparc_sched_init
 492 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
 493 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD sparc_use_sched_lookahead
 494
 495 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 496 #define TARGET_FUNCTION_OK_FOR_SIBCALL sparc_function_ok_for_sibcall
 497
 498 #undef TARGET_INIT_LIBFUNCS
 499 #define TARGET_INIT_LIBFUNCS sparc_init_libfuncs
 500 #undef TARGET_INIT_BUILTINS
 501 #define TARGET_INIT_BUILTINS sparc_init_builtins
 502
 503 #undef TARGET_LEGITIMIZE_ADDRESS
 504 #define TARGET_LEGITIMIZE_ADDRESS sparc_legitimize_address
 505
 506 #undef TARGET_EXPAND_BUILTIN
 507 #define TARGET_EXPAND_BUILTIN sparc_expand_builtin
 508 #undef TARGET_FOLD_BUILTIN
 509 #define TARGET_FOLD_BUILTIN sparc_fold_builtin
 510
 511 #if TARGET_TLS
 512 #undef TARGET_HAVE_TLS
 513 #define TARGET_HAVE_TLS true
 514 #endif
 515
 516 #undef TARGET_CANNOT_FORCE_CONST_MEM
 517 #define TARGET_CANNOT_FORCE_CONST_MEM sparc_cannot_force_const_mem
 518
 519 #undef TARGET_ASM_OUTPUT_MI_THUNK
 520 #define TARGET_ASM_OUTPUT_MI_THUNK sparc_output_mi_thunk
 521 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 522 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK sparc_can_output_mi_thunk
 523
 524 #undef TARGET_RTX_COSTS
 525 #define TARGET_RTX_COSTS sparc_rtx_costs
 526 #undef TARGET_ADDRESS_COST
 527 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
 528
 529 #undef TARGET_PROMOTE_FUNCTION_MODE
 530 #define TARGET_PROMOTE_FUNCTION_MODE sparc_promote_function_mode
 531
 532 #undef TARGET_PROMOTE_PROTOTYPES
 533 #define TARGET_PROMOTE_PROTOTYPES sparc_promote_prototypes
 534
 535 #undef TARGET_STRUCT_VALUE_RTX
 536 #define TARGET_STRUCT_VALUE_RTX sparc_struct_value_rtx
 537 #undef TARGET_RETURN_IN_MEMORY
 538 #define TARGET_RETURN_IN_MEMORY sparc_return_in_memory
 539 #undef TARGET_MUST_PASS_IN_STACK
 540 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 541 #undef TARGET_PASS_BY_REFERENCE
 542 #define TARGET_PASS_BY_REFERENCE sparc_pass_by_reference
 543 #undef TARGET_ARG_PARTIAL_BYTES
 544 #define TARGET_ARG_PARTIAL_BYTES sparc_arg_partial_bytes
 545
 546 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 547 #define TARGET_EXPAND_BUILTIN_SAVEREGS sparc_builtin_saveregs
 548 #undef TARGET_STRICT_ARGUMENT_NAMING
 549 #define TARGET_STRICT_ARGUMENT_NAMING sparc_strict_argument_naming
 550
 551 #undef TARGET_EXPAND_BUILTIN_VA_START
 552 #define TARGET_EXPAND_BUILTIN_VA_START sparc_va_start
 553 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 554 #define TARGET_GIMPLIFY_VA_ARG_EXPR sparc_gimplify_va_arg
 555
 556 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 557 #define TARGET_VECTOR_MODE_SUPPORTED_P sparc_vector_mode_supported_p
 558
 559 #undef TARGET_DWARF_HANDLE_FRAME_UNSPEC
 560 #define TARGET_DWARF_HANDLE_FRAME_UNSPEC sparc_dwarf_handle_frame_unspec
 561
 562 #ifdef SUBTARGET_INSERT_ATTRIBUTES
 563 #undef TARGET_INSERT_ATTRIBUTES
 564 #define TARGET_INSERT_ATTRIBUTES SUBTARGET_INSERT_ATTRIBUTES
 565 #endif
 566
 567 #ifdef SUBTARGET_ATTRIBUTE_TABLE
 568 #undef TARGET_ATTRIBUTE_TABLE
 569 #define TARGET_ATTRIBUTE_TABLE sparc_attribute_table
 570 #endif
 571
 572 #undef TARGET_RELAXED_ORDERING
 573 #define TARGET_RELAXED_ORDERING SPARC_RELAXED_ORDERING
 574
 575 #undef TARGET_DEFAULT_TARGET_FLAGS
 576 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 577 #undef TARGET_HANDLE_OPTION
 578 #define TARGET_HANDLE_OPTION sparc_handle_option
 579
 580 #if TARGET_GNU_TLS && defined(HAVE_AS_SPARC_UA_PCREL)
 581 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
 582 #define TARGET_ASM_OUTPUT_DWARF_DTPREL sparc_output_dwarf_dtprel
 583 #endif
 584
 585 #undef TARGET_ASM_FILE_END
 586 #define TARGET_ASM_FILE_END sparc_file_end
 587
 588 #undef TARGET_FRAME_POINTER_REQUIRED
 589 #define TARGET_FRAME_POINTER_REQUIRED sparc_frame_pointer_required
 590
 591 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
 592 #undef TARGET_MANGLE_TYPE
 593 #define TARGET_MANGLE_TYPE sparc_mangle_type
 594 #endif
 595
 596 #undef TARGET_LEGITIMATE_ADDRESS_P
 597 #define TARGET_LEGITIMATE_ADDRESS_P sparc_legitimate_address_p
 598
 599 struct gcc_target targetm = TARGET_INITIALIZER;
 600
 601 /* Implement TARGET_HANDLE_OPTION.  */
 602
 603 static bool
 604 sparc_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
 605 {
 606   switch (code)
 607     {
 608     case OPT_mfpu:
 609     case OPT_mhard_float:
 610     case OPT_msoft_float:
 611       fpu_option_set = true;
 612       break;
 613
 614     case OPT_mcpu_:
 615       sparc_select[1].string = arg;
 616       break;
 617
 618     case OPT_mtune_:
 619       sparc_select[2].string = arg;
 620       break;
 621     }
 622
 623   return true;
 624 }
 625
 626 /* Validate and override various options, and do some machine dependent
 627    initialization.  */
 628
 629 void
 630 sparc_override_options (void)
 631 {
 632   static struct code_model {
 633     const char *const name;
 634     const enum cmodel value;
 635   } const cmodels[] = {
 636     { "32", CM_32 },
 637     { "medlow", CM_MEDLOW },
 638     { "medmid", CM_MEDMID },
 639     { "medany", CM_MEDANY },
 640     { "embmedany", CM_EMBMEDANY },
 641     { NULL, (enum cmodel) 0 }
 642   };
 643   const struct code_model *cmodel;
 644   /* Map TARGET_CPU_DEFAULT to value for -m{arch,tune}=.  */
 645   static struct cpu_default {
 646     const int cpu;
 647     const char *const name;
 648   } const cpu_default[] = {
 649     /* There must be one entry here for each TARGET_CPU value.  */
 650     { TARGET_CPU_sparc, "cypress" },
 651     { TARGET_CPU_sparclet, "tsc701" },
 652     { TARGET_CPU_sparclite, "f930" },
 653     { TARGET_CPU_v8, "v8" },
 654     { TARGET_CPU_hypersparc, "hypersparc" },
 655     { TARGET_CPU_sparclite86x, "sparclite86x" },
 656     { TARGET_CPU_supersparc, "supersparc" },
 657     { TARGET_CPU_v9, "v9" },
 658     { TARGET_CPU_ultrasparc, "ultrasparc" },
 659     { TARGET_CPU_ultrasparc3, "ultrasparc3" },
 660     { TARGET_CPU_niagara, "niagara" },
 661     { TARGET_CPU_niagara2, "niagara2" },
 662     { 0, 0 }
 663   };
 664   const struct cpu_default *def;
 665   /* Table of values for -m{cpu,tune}=.  */
 666   static struct cpu_table {
 667     const char *const name;
 668     const enum processor_type processor;
 669     const int disable;
 670     const int enable;
 671   } const cpu_table[] = {
 672     { "v7",         PROCESSOR_V7, MASK_ISA, 0 },
 673     { "cypress",    PROCESSOR_CYPRESS, MASK_ISA, 0 },
 674     { "v8",         PROCESSOR_V8, MASK_ISA, MASK_V8 },
 675     /* TI TMS390Z55 supersparc */
 676     { "supersparc", PROCESSOR_SUPERSPARC, MASK_ISA, MASK_V8 },
 677     { "sparclite",  PROCESSOR_SPARCLITE, MASK_ISA, MASK_SPARCLITE },
 678     /* The Fujitsu MB86930 is the original sparclite chip, with no fpu.
 679        The Fujitsu MB86934 is the recent sparclite chip, with an fpu.  */
 680     { "f930",       PROCESSOR_F930, MASK_ISA|MASK_FPU, MASK_SPARCLITE },
 681     { "f934",       PROCESSOR_F934, MASK_ISA, MASK_SPARCLITE|MASK_FPU },
 682     { "hypersparc", PROCESSOR_HYPERSPARC, MASK_ISA, MASK_V8|MASK_FPU },
 683     { "sparclite86x",  PROCESSOR_SPARCLITE86X, MASK_ISA|MASK_FPU,
 684       MASK_SPARCLITE },
 685     { "sparclet",   PROCESSOR_SPARCLET, MASK_ISA, MASK_SPARCLET },
 686     /* TEMIC sparclet */
 687     { "tsc701",     PROCESSOR_TSC701, MASK_ISA, MASK_SPARCLET },
 688     { "v9",         PROCESSOR_V9, MASK_ISA, MASK_V9 },
 689     /* TI ultrasparc I, II, IIi */
 690     { "ultrasparc", PROCESSOR_ULTRASPARC, MASK_ISA, MASK_V9
 691     /* Although insns using %y are deprecated, it is a clear win on current
 692        ultrasparcs.  */
 693                                                     |MASK_DEPRECATED_V8_INSNS},
 694     /* TI ultrasparc III */
 695     /* ??? Check if %y issue still holds true in ultra3.  */
 696     { "ultrasparc3", PROCESSOR_ULTRASPARC3, MASK_ISA, MASK_V9|MASK_DEPRECATED_V8_INSNS},
 697     /* UltraSPARC T1 */
 698     { "niagara", PROCESSOR_NIAGARA, MASK_ISA, MASK_V9|MASK_DEPRECATED_V8_INSNS},
 699     { "niagara2", PROCESSOR_NIAGARA, MASK_ISA, MASK_V9},
 700     { 0, (enum processor_type) 0, 0, 0 }
 701   };
 702   const struct cpu_table *cpu;
 703   const struct sparc_cpu_select *sel;
 704   int fpu;
 705
 706 #ifndef SPARC_BI_ARCH
 707   /* Check for unsupported architecture size.  */
 708   if (! TARGET_64BIT != DEFAULT_ARCH32_P)
 709     error ("%s is not supported by this configuration",
 710            DEFAULT_ARCH32_P ? "-m64" : "-m32");
 711 #endif
 712
 713   /* We force all 64bit archs to use 128 bit long double */
 714   if (TARGET_64BIT && ! TARGET_LONG_DOUBLE_128)
 715     {
 716       error ("-mlong-double-64 not allowed with -m64");
 717       target_flags |= MASK_LONG_DOUBLE_128;
 718     }
 719
 720   /* Code model selection.  */
 721   sparc_cmodel = SPARC_DEFAULT_CMODEL;
 722
 723 #ifdef SPARC_BI_ARCH
 724   if (TARGET_ARCH32)
 725     sparc_cmodel = CM_32;
 726 #endif
 727
 728   if (sparc_cmodel_string != NULL)
 729     {
 730       if (TARGET_ARCH64)
 731         {
 732           for (cmodel = &cmodels[0]; cmodel->name; cmodel++)
 733             if (strcmp (sparc_cmodel_string, cmodel->name) == 0)
 734               break;
 735           if (cmodel->name == NULL)
 736             error ("bad value (%s) for -mcmodel= switch", sparc_cmodel_string);
 737           else
 738             sparc_cmodel = cmodel->value;
 739         }
 740       else
 741         error ("-mcmodel= is not supported on 32 bit systems");
 742     }
 743
 744   fpu = target_flags & MASK_FPU; /* save current -mfpu status */
 745
 746   /* Set the default CPU.  */
 747   for (def = &cpu_default[0]; def->name; ++def)
 748     if (def->cpu == TARGET_CPU_DEFAULT)
 749       break;
 750   gcc_assert (def->name);
 751   sparc_select[0].string = def->name;
 752
 753   for (sel = &sparc_select[0]; sel->name; ++sel)
 754     {
 755       if (sel->string)
 756         {
 757           for (cpu = &cpu_table[0]; cpu->name; ++cpu)
 758             if (! strcmp (sel->string, cpu->name))
 759               {
 760                 if (sel->set_tune_p)
 761                   sparc_cpu = cpu->processor;
 762
 763                 if (sel->set_arch_p)
 764                   {
 765                     target_flags &= ~cpu->disable;
 766                     target_flags |= cpu->enable;
 767                   }
 768                 break;
 769               }
 770
 771           if (! cpu->name)
 772             error ("bad value (%s) for %s switch", sel->string, sel->name);
 773         }
 774     }
 775
 776   /* If -mfpu or -mno-fpu was explicitly used, don't override with
 777      the processor default.  */
 778   if (fpu_option_set)
 779     target_flags = (target_flags & ~MASK_FPU) | fpu;
 780
 781   /* Don't allow -mvis if FPU is disabled.  */
 782   if (! TARGET_FPU)
 783     target_flags &= ~MASK_VIS;
 784
 785   /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
 786      are available.
 787      -m64 also implies v9.  */
 788   if (TARGET_VIS || TARGET_ARCH64)
 789     {
 790       target_flags |= MASK_V9;
 791       target_flags &= ~(MASK_V8 | MASK_SPARCLET | MASK_SPARCLITE);
 792     }
 793
 794   /* Use the deprecated v8 insns for sparc64 in 32 bit mode.  */
 795   if (TARGET_V9 && TARGET_ARCH32)
 796     target_flags |= MASK_DEPRECATED_V8_INSNS;
 797
 798   /* V8PLUS requires V9, makes no sense in 64 bit mode.  */
 799   if (! TARGET_V9 || TARGET_ARCH64)
 800     target_flags &= ~MASK_V8PLUS;
 801
 802   /* Don't use stack biasing in 32 bit mode.  */
 803   if (TARGET_ARCH32)
 804     target_flags &= ~MASK_STACK_BIAS;
 805
 806   /* Supply a default value for align_functions.  */
 807   if (align_functions == 0
 808       && (sparc_cpu == PROCESSOR_ULTRASPARC
 809           || sparc_cpu == PROCESSOR_ULTRASPARC3
 810           || sparc_cpu == PROCESSOR_NIAGARA
 811           || sparc_cpu == PROCESSOR_NIAGARA2))
 812     align_functions = 32;
 813
 814   /* Validate PCC_STRUCT_RETURN.  */
 815   if (flag_pcc_struct_return == DEFAULT_PCC_STRUCT_RETURN)
 816     flag_pcc_struct_return = (TARGET_ARCH64 ? 0 : 1);
 817
 818   /* Only use .uaxword when compiling for a 64-bit target.  */
 819   if (!TARGET_ARCH64)
 820     targetm.asm_out.unaligned_op.di = NULL;
 821
 822   /* Do various machine dependent initializations.  */
 823   sparc_init_modes ();
 824
 825   /* Acquire unique alias sets for our private stuff.  */
 826   sparc_sr_alias_set = new_alias_set ();
 827   struct_value_alias_set = new_alias_set ();
 828
 829   /* Set up function hooks.  */
 830   init_machine_status = sparc_init_machine_status;
 831
 832   switch (sparc_cpu)
 833     {
 834     case PROCESSOR_V7:
 835     case PROCESSOR_CYPRESS:
 836       sparc_costs = &cypress_costs;
 837       break;
 838     case PROCESSOR_V8:
 839     case PROCESSOR_SPARCLITE:
 840     case PROCESSOR_SUPERSPARC:
 841       sparc_costs = &supersparc_costs;
 842       break;
 843     case PROCESSOR_F930:
 844     case PROCESSOR_F934:
 845     case PROCESSOR_HYPERSPARC:
 846     case PROCESSOR_SPARCLITE86X:
 847       sparc_costs = &hypersparc_costs;
 848       break;
 849     case PROCESSOR_SPARCLET:
 850     case PROCESSOR_TSC701:
 851       sparc_costs = &sparclet_costs;
 852       break;
 853     case PROCESSOR_V9:
 854     case PROCESSOR_ULTRASPARC:
 855       sparc_costs = &ultrasparc_costs;
 856       break;
 857     case PROCESSOR_ULTRASPARC3:
 858       sparc_costs = &ultrasparc3_costs;
 859       break;
 860     case PROCESSOR_NIAGARA:
 861       sparc_costs = &niagara_costs;
 862       break;
 863     case PROCESSOR_NIAGARA2:
 864       sparc_costs = &niagara2_costs;
 865       break;
 866     };
 867
 868 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
 869   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
 870     target_flags |= MASK_LONG_DOUBLE_128;
 871 #endif
 872
 873   if (!PARAM_SET_P (PARAM_SIMULTANEOUS_PREFETCHES))
 874     set_param_value ("simultaneous-prefetches",
 875                      ((sparc_cpu == PROCESSOR_ULTRASPARC
 876                        || sparc_cpu == PROCESSOR_NIAGARA
 877                        || sparc_cpu == PROCESSOR_NIAGARA2)
 878                       ? 2
 879                       : (sparc_cpu == PROCESSOR_ULTRASPARC3
 880                          ? 8 : 3)));
 881   if (!PARAM_SET_P (PARAM_L1_CACHE_LINE_SIZE))
 882     set_param_value ("l1-cache-line-size",
 883                      ((sparc_cpu == PROCESSOR_ULTRASPARC
 884                        || sparc_cpu == PROCESSOR_ULTRASPARC3
 885                        || sparc_cpu == PROCESSOR_NIAGARA
 886                        || sparc_cpu == PROCESSOR_NIAGARA2)
 887                       ? 64 : 32));
 888 }
 889 \f
 890 /* Miscellaneous utilities.  */
 891
 892 /* Nonzero if CODE, a comparison, is suitable for use in v9 conditional move
 893    or branch on register contents instructions.  */
 894
 895 int
 896 v9_regcmp_p (enum rtx_code code)
 897 {
 898   return (code == EQ || code == NE || code == GE || code == LT
 899           || code == LE || code == GT);
 900 }
 901
 902 /* Nonzero if OP is a floating point constant which can
 903    be loaded into an integer register using a single
 904    sethi instruction.  */
 905
 906 int
 907 fp_sethi_p (rtx op)
 908 {
 909   if (GET_CODE (op) == CONST_DOUBLE)
 910     {
 911       REAL_VALUE_TYPE r;
 912       long i;
 913
 914       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
 915       REAL_VALUE_TO_TARGET_SINGLE (r, i);
 916       return !SPARC_SIMM13_P (i) && SPARC_SETHI_P (i);
 917     }
 918
 919   return 0;
 920 }
 921
 922 /* Nonzero if OP is a floating point constant which can
 923    be loaded into an integer register using a single
 924    mov instruction.  */
 925
 926 int
 927 fp_mov_p (rtx op)
 928 {
 929   if (GET_CODE (op) == CONST_DOUBLE)
 930     {
 931       REAL_VALUE_TYPE r;
 932       long i;
 933
 934       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
 935       REAL_VALUE_TO_TARGET_SINGLE (r, i);
 936       return SPARC_SIMM13_P (i);
 937     }
 938
 939   return 0;
 940 }
 941
 942 /* Nonzero if OP is a floating point constant which can
 943    be loaded into an integer register using a high/losum
 944    instruction sequence.  */
 945
 946 int
 947 fp_high_losum_p (rtx op)
 948 {
 949   /* The constraints calling this should only be in
 950      SFmode move insns, so any constant which cannot
 951      be moved using a single insn will do.  */
 952   if (GET_CODE (op) == CONST_DOUBLE)
 953     {
 954       REAL_VALUE_TYPE r;
 955       long i;
 956
 957       REAL_VALUE_FROM_CONST_DOUBLE (r, op);
 958       REAL_VALUE_TO_TARGET_SINGLE (r, i);
 959       return !SPARC_SIMM13_P (i) && !SPARC_SETHI_P (i);
 960     }
 961
 962   return 0;
 963 }
 964
 965 /* Expand a move instruction.  Return true if all work is done.  */
 966
 967 bool
 968 sparc_expand_move (enum machine_mode mode, rtx *operands)
 969 {
 970   /* Handle sets of MEM first.  */
 971   if (GET_CODE (operands[0]) == MEM)
 972     {
 973       /* 0 is a register (or a pair of registers) on SPARC.  */
 974       if (register_or_zero_operand (operands[1], mode))
 975         return false;
 976
 977       if (!reload_in_progress)
 978         {
 979           operands[0] = validize_mem (operands[0]);
 980           operands[1] = force_reg (mode, operands[1]);
 981         }
 982     }
 983
 984   /* Fixup TLS cases.  */
 985   if (TARGET_HAVE_TLS
 986       && CONSTANT_P (operands[1])
 987       && GET_CODE (operands[1]) != HIGH
 988       && sparc_tls_referenced_p (operands [1]))
 989     {
 990       rtx sym = operands[1];
 991       rtx addend = NULL;
 992
 993       if (GET_CODE (sym) == CONST && GET_CODE (XEXP (sym, 0)) == PLUS)
 994         {
 995           addend = XEXP (XEXP (sym, 0), 1);
 996           sym = XEXP (XEXP (sym, 0), 0);
 997         }
 998
 999       gcc_assert (SPARC_SYMBOL_REF_TLS_P (sym));
1000
1001       sym = legitimize_tls_address (sym);
1002       if (addend)
1003         {
1004           sym = gen_rtx_PLUS (mode, sym, addend);
1005           sym = force_operand (sym, operands[0]);
1006         }
1007       operands[1] = sym;
1008     }
1009
1010   /* Fixup PIC cases.  */
1011   if (flag_pic && CONSTANT_P (operands[1]))
1012     {
1013       if (pic_address_needs_scratch (operands[1]))
1014         operands[1] = legitimize_pic_address (operands[1], mode, 0);
1015
1016       /* VxWorks does not impose a fixed gap between segments; the run-time
1017          gap can be different from the object-file gap.  We therefore can't
1018          assume X - _GLOBAL_OFFSET_TABLE_ is a link-time constant unless we
1019          are absolutely sure that X is in the same segment as the GOT.
1020          Unfortunately, the flexibility of linker scripts means that we
1021          can't be sure of that in general, so assume that _G_O_T_-relative
1022          accesses are never valid on VxWorks.  */
1023       if (GET_CODE (operands[1]) == LABEL_REF && !TARGET_VXWORKS_RTP)
1024         {
1025           if (mode == SImode)
1026             {
1027               emit_insn (gen_movsi_pic_label_ref (operands[0], operands[1]));
1028               return true;
1029             }
1030
1031           if (mode == DImode)
1032             {
1033               gcc_assert (TARGET_ARCH64);
1034               emit_insn (gen_movdi_pic_label_ref (operands[0], operands[1]));
1035               return true;
1036             }
1037         }
1038
1039       if (symbolic_operand (operands[1], mode))
1040         {
1041           operands[1] = legitimize_pic_address (operands[1],
1042                                                 mode,
1043                                                 (reload_in_progress ?
1044                                                  operands[0] :
1045                                                  NULL_RTX));
1046           return false;
1047         }
1048     }
1049
1050   /* If we are trying to toss an integer constant into FP registers,
1051      or loading a FP or vector constant, force it into memory.  */
1052   if (CONSTANT_P (operands[1])
1053       && REG_P (operands[0])
1054       && (SPARC_FP_REG_P (REGNO (operands[0]))
1055           || SCALAR_FLOAT_MODE_P (mode)
1056           || VECTOR_MODE_P (mode)))
1057     {
1058       /* emit_group_store will send such bogosity to us when it is
1059          not storing directly into memory.  So fix this up to avoid
1060          crashes in output_constant_pool.  */
1061       if (operands [1] == const0_rtx)
1062         operands[1] = CONST0_RTX (mode);
1063
1064       /* We can clear FP registers if TARGET_VIS, and always other regs.  */
1065       if ((TARGET_VIS || REGNO (operands[0]) < SPARC_FIRST_FP_REG)
1066           && const_zero_operand (operands[1], mode))
1067         return false;
1068
1069       if (REGNO (operands[0]) < SPARC_FIRST_FP_REG
1070           /* We are able to build any SF constant in integer registers
1071              with at most 2 instructions.  */
1072           && (mode == SFmode
1073               /* And any DF constant in integer registers.  */
1074               || (mode == DFmode
1075                   && (reload_completed || reload_in_progress))))
1076         return false;
1077
1078       operands[1] = force_const_mem (mode, operands[1]);
1079       if (!reload_in_progress)
1080         operands[1] = validize_mem (operands[1]);
1081       return false;
1082     }
1083
1084   /* Accept non-constants and valid constants unmodified.  */
1085   if (!CONSTANT_P (operands[1])
1086       || GET_CODE (operands[1]) == HIGH
1087       || input_operand (operands[1], mode))
1088     return false;
1089
1090   switch (mode)
1091     {
1092     case QImode:
1093       /* All QImode constants require only one insn, so proceed.  */
1094       break;
1095
1096     case HImode:
1097     case SImode:
1098       sparc_emit_set_const32 (operands[0], operands[1]);
1099       return true;
1100
1101     case DImode:
1102       /* input_operand should have filtered out 32-bit mode.  */
1103       sparc_emit_set_const64 (operands[0], operands[1]);
1104       return true;
1105
1106     default:
1107       gcc_unreachable ();
1108     }
1109
1110   return false;
1111 }
1112
1113 /* Load OP1, a 32-bit constant, into OP0, a register.
1114    We know it can't be done in one insn when we get
1115    here, the move expander guarantees this.  */
1116
1117 void
1118 sparc_emit_set_const32 (rtx op0, rtx op1)
1119 {
1120   enum machine_mode mode = GET_MODE (op0);
1121   rtx temp;
1122
1123   if (reload_in_progress || reload_completed)
1124     temp = op0;
1125   else
1126     temp = gen_reg_rtx (mode);
1127
1128   if (GET_CODE (op1) == CONST_INT)
1129     {
1130       gcc_assert (!small_int_operand (op1, mode)
1131                   && !const_high_operand (op1, mode));
1132
1133       /* Emit them as real moves instead of a HIGH/LO_SUM,
1134          this way CSE can see everything and reuse intermediate
1135          values if it wants.  */
1136       emit_insn (gen_rtx_SET (VOIDmode, temp,
1137                               GEN_INT (INTVAL (op1)
1138                                 & ~(HOST_WIDE_INT)0x3ff)));
1139
1140       emit_insn (gen_rtx_SET (VOIDmode,
1141                               op0,
1142                               gen_rtx_IOR (mode, temp,
1143                                            GEN_INT (INTVAL (op1) & 0x3ff))));
1144     }
1145   else
1146     {
1147       /* A symbol, emit in the traditional way.  */
1148       emit_insn (gen_rtx_SET (VOIDmode, temp,
1149                               gen_rtx_HIGH (mode, op1)));
1150       emit_insn (gen_rtx_SET (VOIDmode,
1151                               op0, gen_rtx_LO_SUM (mode, temp, op1)));
1152     }
1153 }
1154
1155 /* Load OP1, a symbolic 64-bit constant, into OP0, a DImode register.
1156    If TEMP is nonzero, we are forbidden to use any other scratch
1157    registers.  Otherwise, we are allowed to generate them as needed.
1158
1159    Note that TEMP may have TImode if the code model is TARGET_CM_MEDANY
1160    or TARGET_CM_EMBMEDANY (see the reload_indi and reload_outdi patterns).  */
1161
1162 void
1163 sparc_emit_set_symbolic_const64 (rtx op0, rtx op1, rtx temp)
1164 {
1165   rtx temp1, temp2, temp3, temp4, temp5;
1166   rtx ti_temp = 0;
1167
1168   if (temp && GET_MODE (temp) == TImode)
1169     {
1170       ti_temp = temp;
1171       temp = gen_rtx_REG (DImode, REGNO (temp));
1172     }
1173
1174   /* SPARC-V9 code-model support.  */
1175   switch (sparc_cmodel)
1176     {
1177     case CM_MEDLOW:
1178       /* The range spanned by all instructions in the object is less
1179          than 2^31 bytes (2GB) and the distance from any instruction
1180          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1181          than 2^31 bytes (2GB).
1182
1183          The executable must be in the low 4TB of the virtual address
1184          space.
1185
1186          sethi  %hi(symbol), %temp1
1187          or     %temp1, %lo(symbol), %reg  */
1188       if (temp)
1189         temp1 = temp;  /* op0 is allowed.  */
1190       else
1191         temp1 = gen_reg_rtx (DImode);
1192
1193       emit_insn (gen_rtx_SET (VOIDmode, temp1, gen_rtx_HIGH (DImode, op1)));
1194       emit_insn (gen_rtx_SET (VOIDmode, op0, gen_rtx_LO_SUM (DImode, temp1, op1)));
1195       break;
1196
1197     case CM_MEDMID:
1198       /* The range spanned by all instructions in the object is less
1199          than 2^31 bytes (2GB) and the distance from any instruction
1200          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1201          than 2^31 bytes (2GB).
1202
1203          The executable must be in the low 16TB of the virtual address
1204          space.
1205
1206          sethi  %h44(symbol), %temp1
1207          or     %temp1, %m44(symbol), %temp2
1208          sllx   %temp2, 12, %temp3
1209          or     %temp3, %l44(symbol), %reg  */
1210       if (temp)
1211         {
1212           temp1 = op0;
1213           temp2 = op0;
1214           temp3 = temp;  /* op0 is allowed.  */
1215         }
1216       else
1217         {
1218           temp1 = gen_reg_rtx (DImode);
1219           temp2 = gen_reg_rtx (DImode);
1220           temp3 = gen_reg_rtx (DImode);
1221         }
1222
1223       emit_insn (gen_seth44 (temp1, op1));
1224       emit_insn (gen_setm44 (temp2, temp1, op1));
1225       emit_insn (gen_rtx_SET (VOIDmode, temp3,
1226                               gen_rtx_ASHIFT (DImode, temp2, GEN_INT (12))));
1227       emit_insn (gen_setl44 (op0, temp3, op1));
1228       break;
1229
1230     case CM_MEDANY:
1231       /* The range spanned by all instructions in the object is less
1232          than 2^31 bytes (2GB) and the distance from any instruction
1233          to the location of the label _GLOBAL_OFFSET_TABLE_ is less
1234          than 2^31 bytes (2GB).
1235
1236          The executable can be placed anywhere in the virtual address
1237          space.
1238
1239          sethi  %hh(symbol), %temp1
1240          sethi  %lm(symbol), %temp2
1241          or     %temp1, %hm(symbol), %temp3
1242          sllx   %temp3, 32, %temp4
1243          or     %temp4, %temp2, %temp5
1244          or     %temp5, %lo(symbol), %reg  */
1245       if (temp)
1246         {
1247           /* It is possible that one of the registers we got for operands[2]
1248              might coincide with that of operands[0] (which is why we made
1249              it TImode).  Pick the other one to use as our scratch.  */
1250           if (rtx_equal_p (temp, op0))
1251             {
1252               gcc_assert (ti_temp);
1253               temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1254             }
1255           temp1 = op0;
1256           temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1257           temp3 = op0;
1258           temp4 = op0;
1259           temp5 = op0;
1260         }
1261       else
1262         {
1263           temp1 = gen_reg_rtx (DImode);
1264           temp2 = gen_reg_rtx (DImode);
1265           temp3 = gen_reg_rtx (DImode);
1266           temp4 = gen_reg_rtx (DImode);
1267           temp5 = gen_reg_rtx (DImode);
1268         }
1269
1270       emit_insn (gen_sethh (temp1, op1));
1271       emit_insn (gen_setlm (temp2, op1));
1272       emit_insn (gen_sethm (temp3, temp1, op1));
1273       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1274                               gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1275       emit_insn (gen_rtx_SET (VOIDmode, temp5,
1276                               gen_rtx_PLUS (DImode, temp4, temp2)));
1277       emit_insn (gen_setlo (op0, temp5, op1));
1278       break;
1279
1280     case CM_EMBMEDANY:
1281       /* Old old old backwards compatibility kruft here.
1282          Essentially it is MEDLOW with a fixed 64-bit
1283          virtual base added to all data segment addresses.
1284          Text-segment stuff is computed like MEDANY, we can't
1285          reuse the code above because the relocation knobs
1286          look different.
1287
1288          Data segment:  sethi   %hi(symbol), %temp1
1289                         add     %temp1, EMBMEDANY_BASE_REG, %temp2
1290                         or      %temp2, %lo(symbol), %reg  */
1291       if (data_segment_operand (op1, GET_MODE (op1)))
1292         {
1293           if (temp)
1294             {
1295               temp1 = temp;  /* op0 is allowed.  */
1296               temp2 = op0;
1297             }
1298           else
1299             {
1300               temp1 = gen_reg_rtx (DImode);
1301               temp2 = gen_reg_rtx (DImode);
1302             }
1303
1304           emit_insn (gen_embmedany_sethi (temp1, op1));
1305           emit_insn (gen_embmedany_brsum (temp2, temp1));
1306           emit_insn (gen_embmedany_losum (op0, temp2, op1));
1307         }
1308
1309       /* Text segment:  sethi   %uhi(symbol), %temp1
1310                         sethi   %hi(symbol), %temp2
1311                         or      %temp1, %ulo(symbol), %temp3
1312                         sllx    %temp3, 32, %temp4
1313                         or      %temp4, %temp2, %temp5
1314                         or      %temp5, %lo(symbol), %reg  */
1315       else
1316         {
1317           if (temp)
1318             {
1319               /* It is possible that one of the registers we got for operands[2]
1320                  might coincide with that of operands[0] (which is why we made
1321                  it TImode).  Pick the other one to use as our scratch.  */
1322               if (rtx_equal_p (temp, op0))
1323                 {
1324                   gcc_assert (ti_temp);
1325                   temp = gen_rtx_REG (DImode, REGNO (temp) + 1);
1326                 }
1327               temp1 = op0;
1328               temp2 = temp;  /* op0 is _not_ allowed, see above.  */
1329               temp3 = op0;
1330               temp4 = op0;
1331               temp5 = op0;
1332             }
1333           else
1334             {
1335               temp1 = gen_reg_rtx (DImode);
1336               temp2 = gen_reg_rtx (DImode);
1337               temp3 = gen_reg_rtx (DImode);
1338               temp4 = gen_reg_rtx (DImode);
1339               temp5 = gen_reg_rtx (DImode);
1340             }
1341
1342           emit_insn (gen_embmedany_textuhi (temp1, op1));
1343           emit_insn (gen_embmedany_texthi  (temp2, op1));
1344           emit_insn (gen_embmedany_textulo (temp3, temp1, op1));
1345           emit_insn (gen_rtx_SET (VOIDmode, temp4,
1346                                   gen_rtx_ASHIFT (DImode, temp3, GEN_INT (32))));
1347           emit_insn (gen_rtx_SET (VOIDmode, temp5,
1348                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1349           emit_insn (gen_embmedany_textlo  (op0, temp5, op1));
1350         }
1351       break;
1352
1353     default:
1354       gcc_unreachable ();
1355     }
1356 }
1357
1358 #if HOST_BITS_PER_WIDE_INT == 32
1359 void
1360 sparc_emit_set_const64 (rtx op0 ATTRIBUTE_UNUSED, rtx op1 ATTRIBUTE_UNUSED)
1361 {
1362   gcc_unreachable ();
1363 }
1364 #else
1365 /* These avoid problems when cross compiling.  If we do not
1366    go through all this hair then the optimizer will see
1367    invalid REG_EQUAL notes or in some cases none at all.  */
1368 static rtx gen_safe_HIGH64 (rtx, HOST_WIDE_INT);
1369 static rtx gen_safe_SET64 (rtx, HOST_WIDE_INT);
1370 static rtx gen_safe_OR64 (rtx, HOST_WIDE_INT);
1371 static rtx gen_safe_XOR64 (rtx, HOST_WIDE_INT);
1372
1373 /* The optimizer is not to assume anything about exactly
1374    which bits are set for a HIGH, they are unspecified.
1375    Unfortunately this leads to many missed optimizations
1376    during CSE.  We mask out the non-HIGH bits, and matches
1377    a plain movdi, to alleviate this problem.  */
1378 static rtx
1379 gen_safe_HIGH64 (rtx dest, HOST_WIDE_INT val)
1380 {
1381   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val & ~(HOST_WIDE_INT)0x3ff));
1382 }
1383
1384 static rtx
1385 gen_safe_SET64 (rtx dest, HOST_WIDE_INT val)
1386 {
1387   return gen_rtx_SET (VOIDmode, dest, GEN_INT (val));
1388 }
1389
1390 static rtx
1391 gen_safe_OR64 (rtx src, HOST_WIDE_INT val)
1392 {
1393   return gen_rtx_IOR (DImode, src, GEN_INT (val));
1394 }
1395
1396 static rtx
1397 gen_safe_XOR64 (rtx src, HOST_WIDE_INT val)
1398 {
1399   return gen_rtx_XOR (DImode, src, GEN_INT (val));
1400 }
1401
1402 /* Worker routines for 64-bit constant formation on arch64.
1403    One of the key things to be doing in these emissions is
1404    to create as many temp REGs as possible.  This makes it
1405    possible for half-built constants to be used later when
1406    such values are similar to something required later on.
1407    Without doing this, the optimizer cannot see such
1408    opportunities.  */
1409
1410 static void sparc_emit_set_const64_quick1 (rtx, rtx,
1411                                            unsigned HOST_WIDE_INT, int);
1412
1413 static void
1414 sparc_emit_set_const64_quick1 (rtx op0, rtx temp,
1415                                unsigned HOST_WIDE_INT low_bits, int is_neg)
1416 {
1417   unsigned HOST_WIDE_INT high_bits;
1418
1419   if (is_neg)
1420     high_bits = (~low_bits) & 0xffffffff;
1421   else
1422     high_bits = low_bits;
1423
1424   emit_insn (gen_safe_HIGH64 (temp, high_bits));
1425   if (!is_neg)
1426     {
1427       emit_insn (gen_rtx_SET (VOIDmode, op0,
1428                               gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1429     }
1430   else
1431     {
1432       /* If we are XOR'ing with -1, then we should emit a one's complement
1433          instead.  This way the combiner will notice logical operations
1434          such as ANDN later on and substitute.  */
1435       if ((low_bits & 0x3ff) == 0x3ff)
1436         {
1437           emit_insn (gen_rtx_SET (VOIDmode, op0,
1438                                   gen_rtx_NOT (DImode, temp)));
1439         }
1440       else
1441         {
1442           emit_insn (gen_rtx_SET (VOIDmode, op0,
1443                                   gen_safe_XOR64 (temp,
1444                                                   (-(HOST_WIDE_INT)0x400
1445                                                    | (low_bits & 0x3ff)))));
1446         }
1447     }
1448 }
1449
1450 static void sparc_emit_set_const64_quick2 (rtx, rtx, unsigned HOST_WIDE_INT,
1451                                            unsigned HOST_WIDE_INT, int);
1452
1453 static void
1454 sparc_emit_set_const64_quick2 (rtx op0, rtx temp,
1455                                unsigned HOST_WIDE_INT high_bits,
1456                                unsigned HOST_WIDE_INT low_immediate,
1457                                int shift_count)
1458 {
1459   rtx temp2 = op0;
1460
1461   if ((high_bits & 0xfffffc00) != 0)
1462     {
1463       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1464       if ((high_bits & ~0xfffffc00) != 0)
1465         emit_insn (gen_rtx_SET (VOIDmode, op0,
1466                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1467       else
1468         temp2 = temp;
1469     }
1470   else
1471     {
1472       emit_insn (gen_safe_SET64 (temp, high_bits));
1473       temp2 = temp;
1474     }
1475
1476   /* Now shift it up into place.  */
1477   emit_insn (gen_rtx_SET (VOIDmode, op0,
1478                           gen_rtx_ASHIFT (DImode, temp2,
1479                                           GEN_INT (shift_count))));
1480
1481   /* If there is a low immediate part piece, finish up by
1482      putting that in as well.  */
1483   if (low_immediate != 0)
1484     emit_insn (gen_rtx_SET (VOIDmode, op0,
1485                             gen_safe_OR64 (op0, low_immediate)));
1486 }
1487
1488 static void sparc_emit_set_const64_longway (rtx, rtx, unsigned HOST_WIDE_INT,
1489                                             unsigned HOST_WIDE_INT);
1490
1491 /* Full 64-bit constant decomposition.  Even though this is the
1492    'worst' case, we still optimize a few things away.  */
1493 static void
1494 sparc_emit_set_const64_longway (rtx op0, rtx temp,
1495                                 unsigned HOST_WIDE_INT high_bits,
1496                                 unsigned HOST_WIDE_INT low_bits)
1497 {
1498   rtx sub_temp;
1499
1500   if (reload_in_progress || reload_completed)
1501     sub_temp = op0;
1502   else
1503     sub_temp = gen_reg_rtx (DImode);
1504
1505   if ((high_bits & 0xfffffc00) != 0)
1506     {
1507       emit_insn (gen_safe_HIGH64 (temp, high_bits));
1508       if ((high_bits & ~0xfffffc00) != 0)
1509         emit_insn (gen_rtx_SET (VOIDmode,
1510                                 sub_temp,
1511                                 gen_safe_OR64 (temp, (high_bits & 0x3ff))));
1512       else
1513         sub_temp = temp;
1514     }
1515   else
1516     {
1517       emit_insn (gen_safe_SET64 (temp, high_bits));
1518       sub_temp = temp;
1519     }
1520
1521   if (!reload_in_progress && !reload_completed)
1522     {
1523       rtx temp2 = gen_reg_rtx (DImode);
1524       rtx temp3 = gen_reg_rtx (DImode);
1525       rtx temp4 = gen_reg_rtx (DImode);
1526
1527       emit_insn (gen_rtx_SET (VOIDmode, temp4,
1528                               gen_rtx_ASHIFT (DImode, sub_temp,
1529                                               GEN_INT (32))));
1530
1531       emit_insn (gen_safe_HIGH64 (temp2, low_bits));
1532       if ((low_bits & ~0xfffffc00) != 0)
1533         {
1534           emit_insn (gen_rtx_SET (VOIDmode, temp3,
1535                                   gen_safe_OR64 (temp2, (low_bits & 0x3ff))));
1536           emit_insn (gen_rtx_SET (VOIDmode, op0,
1537                                   gen_rtx_PLUS (DImode, temp4, temp3)));
1538         }
1539       else
1540         {
1541           emit_insn (gen_rtx_SET (VOIDmode, op0,
1542                                   gen_rtx_PLUS (DImode, temp4, temp2)));
1543         }
1544     }
1545   else
1546     {
1547       rtx low1 = GEN_INT ((low_bits >> (32 - 12))          & 0xfff);
1548       rtx low2 = GEN_INT ((low_bits >> (32 - 12 - 12))     & 0xfff);
1549       rtx low3 = GEN_INT ((low_bits >> (32 - 12 - 12 - 8)) & 0x0ff);
1550       int to_shift = 12;
1551
1552       /* We are in the middle of reload, so this is really
1553          painful.  However we do still make an attempt to
1554          avoid emitting truly stupid code.  */
1555       if (low1 != const0_rtx)
1556         {
1557           emit_insn (gen_rtx_SET (VOIDmode, op0,
1558                                   gen_rtx_ASHIFT (DImode, sub_temp,
1559                                                   GEN_INT (to_shift))));
1560           emit_insn (gen_rtx_SET (VOIDmode, op0,
1561                                   gen_rtx_IOR (DImode, op0, low1)));
1562           sub_temp = op0;
1563           to_shift = 12;
1564         }
1565       else
1566         {
1567           to_shift += 12;
1568         }
1569       if (low2 != const0_rtx)
1570         {
1571           emit_insn (gen_rtx_SET (VOIDmode, op0,
1572                                   gen_rtx_ASHIFT (DImode, sub_temp,
1573                                                   GEN_INT (to_shift))));
1574           emit_insn (gen_rtx_SET (VOIDmode, op0,
1575                                   gen_rtx_IOR (DImode, op0, low2)));
1576           sub_temp = op0;
1577           to_shift = 8;
1578         }
1579       else
1580         {
1581           to_shift += 8;
1582         }
1583       emit_insn (gen_rtx_SET (VOIDmode, op0,
1584                               gen_rtx_ASHIFT (DImode, sub_temp,
1585                                               GEN_INT (to_shift))));
1586       if (low3 != const0_rtx)
1587         emit_insn (gen_rtx_SET (VOIDmode, op0,
1588                                 gen_rtx_IOR (DImode, op0, low3)));
1589       /* phew...  */
1590     }
1591 }
1592
1593 /* Analyze a 64-bit constant for certain properties.  */
1594 static void analyze_64bit_constant (unsigned HOST_WIDE_INT,
1595                                     unsigned HOST_WIDE_INT,
1596                                     int *, int *, int *);
1597
1598 static void
1599 analyze_64bit_constant (unsigned HOST_WIDE_INT high_bits,
1600                         unsigned HOST_WIDE_INT low_bits,
1601                         int *hbsp, int *lbsp, int *abbasp)
1602 {
1603   int lowest_bit_set, highest_bit_set, all_bits_between_are_set;
1604   int i;
1605
1606   lowest_bit_set = highest_bit_set = -1;
1607   i = 0;
1608   do
1609     {
1610       if ((lowest_bit_set == -1)
1611           && ((low_bits >> i) & 1))
1612         lowest_bit_set = i;
1613       if ((highest_bit_set == -1)
1614           && ((high_bits >> (32 - i - 1)) & 1))
1615         highest_bit_set = (64 - i - 1);
1616     }
1617   while (++i < 32
1618          && ((highest_bit_set == -1)
1619              || (lowest_bit_set == -1)));
1620   if (i == 32)
1621     {
1622       i = 0;
1623       do
1624         {
1625           if ((lowest_bit_set == -1)
1626               && ((high_bits >> i) & 1))
1627             lowest_bit_set = i + 32;
1628           if ((highest_bit_set == -1)
1629               && ((low_bits >> (32 - i - 1)) & 1))
1630             highest_bit_set = 32 - i - 1;
1631         }
1632       while (++i < 32
1633              && ((highest_bit_set == -1)
1634                  || (lowest_bit_set == -1)));
1635     }
1636   /* If there are no bits set this should have gone out
1637      as one instruction!  */
1638   gcc_assert (lowest_bit_set != -1 && highest_bit_set != -1);
1639   all_bits_between_are_set = 1;
1640   for (i = lowest_bit_set; i <= highest_bit_set; i++)
1641     {
1642       if (i < 32)
1643         {
1644           if ((low_bits & (1 << i)) != 0)
1645             continue;
1646         }
1647       else
1648         {
1649           if ((high_bits & (1 << (i - 32))) != 0)
1650             continue;
1651         }
1652       all_bits_between_are_set = 0;
1653       break;
1654     }
1655   *hbsp = highest_bit_set;
1656   *lbsp = lowest_bit_set;
1657   *abbasp = all_bits_between_are_set;
1658 }
1659
1660 static int const64_is_2insns (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
1661
1662 static int
1663 const64_is_2insns (unsigned HOST_WIDE_INT high_bits,
1664                    unsigned HOST_WIDE_INT low_bits)
1665 {
1666   int highest_bit_set, lowest_bit_set, all_bits_between_are_set;
1667
1668   if (high_bits == 0
1669       || high_bits == 0xffffffff)
1670     return 1;
1671
1672   analyze_64bit_constant (high_bits, low_bits,
1673                           &highest_bit_set, &lowest_bit_set,
1674                           &all_bits_between_are_set);
1675
1676   if ((highest_bit_set == 63
1677        || lowest_bit_set == 0)
1678       && all_bits_between_are_set != 0)
1679     return 1;
1680
1681   if ((highest_bit_set - lowest_bit_set) < 21)
1682     return 1;
1683
1684   return 0;
1685 }
1686
1687 static unsigned HOST_WIDE_INT create_simple_focus_bits (unsigned HOST_WIDE_INT,
1688                                                         unsigned HOST_WIDE_INT,
1689                                                         int, int);
1690
1691 static unsigned HOST_WIDE_INT
1692 create_simple_focus_bits (unsigned HOST_WIDE_INT high_bits,
1693                           unsigned HOST_WIDE_INT low_bits,
1694                           int lowest_bit_set, int shift)
1695 {
1696   HOST_WIDE_INT hi, lo;
1697
1698   if (lowest_bit_set < 32)
1699     {
1700       lo = (low_bits >> lowest_bit_set) << shift;
1701       hi = ((high_bits << (32 - lowest_bit_set)) << shift);
1702     }
1703   else
1704     {
1705       lo = 0;
1706       hi = ((high_bits >> (lowest_bit_set - 32)) << shift);
1707     }
1708   gcc_assert (! (hi & lo));
1709   return (hi | lo);
1710 }
1711
1712 /* Here we are sure to be arch64 and this is an integer constant
1713    being loaded into a register.  Emit the most efficient
1714    insn sequence possible.  Detection of all the 1-insn cases
1715    has been done already.  */
1716 void
1717 sparc_emit_set_const64 (rtx op0, rtx op1)
1718 {
1719   unsigned HOST_WIDE_INT high_bits, low_bits;
1720   int lowest_bit_set, highest_bit_set;
1721   int all_bits_between_are_set;
1722   rtx temp = 0;
1723
1724   /* Sanity check that we know what we are working with.  */
1725   gcc_assert (TARGET_ARCH64
1726               && (GET_CODE (op0) == SUBREG
1727                   || (REG_P (op0) && ! SPARC_FP_REG_P (REGNO (op0)))));
1728
1729   if (reload_in_progress || reload_completed)
1730     temp = op0;
1731
1732   if (GET_CODE (op1) != CONST_INT)
1733     {
1734       sparc_emit_set_symbolic_const64 (op0, op1, temp);
1735       return;
1736     }
1737
1738   if (! temp)
1739     temp = gen_reg_rtx (DImode);
1740
1741   high_bits = ((INTVAL (op1) >> 32) & 0xffffffff);
1742   low_bits = (INTVAL (op1) & 0xffffffff);
1743
1744   /* low_bits   bits 0  --> 31
1745      high_bits  bits 32 --> 63  */
1746
1747   analyze_64bit_constant (high_bits, low_bits,
1748                           &highest_bit_set, &lowest_bit_set,
1749                           &all_bits_between_are_set);
1750
1751   /* First try for a 2-insn sequence.  */
1752
1753   /* These situations are preferred because the optimizer can
1754    * do more things with them:
1755    * 1) mov     -1, %reg
1756    *    sllx    %reg, shift, %reg
1757    * 2) mov     -1, %reg
1758    *    srlx    %reg, shift, %reg
1759    * 3) mov     some_small_const, %reg
1760    *    sllx    %reg, shift, %reg
1761    */
1762   if (((highest_bit_set == 63
1763         || lowest_bit_set == 0)
1764        && all_bits_between_are_set != 0)
1765       || ((highest_bit_set - lowest_bit_set) < 12))
1766     {
1767       HOST_WIDE_INT the_const = -1;
1768       int shift = lowest_bit_set;
1769
1770       if ((highest_bit_set != 63
1771            && lowest_bit_set != 0)
1772           || all_bits_between_are_set == 0)
1773         {
1774           the_const =
1775             create_simple_focus_bits (high_bits, low_bits,
1776                                       lowest_bit_set, 0);
1777         }
1778       else if (lowest_bit_set == 0)
1779         shift = -(63 - highest_bit_set);
1780
1781       gcc_assert (SPARC_SIMM13_P (the_const));
1782       gcc_assert (shift != 0);
1783
1784       emit_insn (gen_safe_SET64 (temp, the_const));
1785       if (shift > 0)
1786         emit_insn (gen_rtx_SET (VOIDmode,
1787                                 op0,
1788                                 gen_rtx_ASHIFT (DImode,
1789                                                 temp,
1790                                                 GEN_INT (shift))));
1791       else if (shift < 0)
1792         emit_insn (gen_rtx_SET (VOIDmode,
1793                                 op0,
1794                                 gen_rtx_LSHIFTRT (DImode,
1795                                                   temp,
1796                                                   GEN_INT (-shift))));
1797       return;
1798     }
1799
1800   /* Now a range of 22 or less bits set somewhere.
1801    * 1) sethi   %hi(focus_bits), %reg
1802    *    sllx    %reg, shift, %reg
1803    * 2) sethi   %hi(focus_bits), %reg
1804    *    srlx    %reg, shift, %reg
1805    */
1806   if ((highest_bit_set - lowest_bit_set) < 21)
1807     {
1808       unsigned HOST_WIDE_INT focus_bits =
1809         create_simple_focus_bits (high_bits, low_bits,
1810                                   lowest_bit_set, 10);
1811
1812       gcc_assert (SPARC_SETHI_P (focus_bits));
1813       gcc_assert (lowest_bit_set != 10);
1814
1815       emit_insn (gen_safe_HIGH64 (temp, focus_bits));
1816
1817       /* If lowest_bit_set == 10 then a sethi alone could have done it.  */
1818       if (lowest_bit_set < 10)
1819         emit_insn (gen_rtx_SET (VOIDmode,
1820                                 op0,
1821                                 gen_rtx_LSHIFTRT (DImode, temp,
1822                                                   GEN_INT (10 - lowest_bit_set))));
1823       else if (lowest_bit_set > 10)
1824         emit_insn (gen_rtx_SET (VOIDmode,
1825                                 op0,
1826                                 gen_rtx_ASHIFT (DImode, temp,
1827                                                 GEN_INT (lowest_bit_set - 10))));
1828       return;
1829     }
1830
1831   /* 1) sethi   %hi(low_bits), %reg
1832    *    or      %reg, %lo(low_bits), %reg
1833    * 2) sethi   %hi(~low_bits), %reg
1834    *    xor     %reg, %lo(-0x400 | (low_bits & 0x3ff)), %reg
1835    */
1836   if (high_bits == 0
1837       || high_bits == 0xffffffff)
1838     {
1839       sparc_emit_set_const64_quick1 (op0, temp, low_bits,
1840                                      (high_bits == 0xffffffff));
1841       return;
1842     }
1843
1844   /* Now, try 3-insn sequences.  */
1845
1846   /* 1) sethi   %hi(high_bits), %reg
1847    *    or      %reg, %lo(high_bits), %reg
1848    *    sllx    %reg, 32, %reg
1849    */
1850   if (low_bits == 0)
1851     {
1852       sparc_emit_set_const64_quick2 (op0, temp, high_bits, 0, 32);
1853       return;
1854     }
1855
1856   /* We may be able to do something quick
1857      when the constant is negated, so try that.  */
1858   if (const64_is_2insns ((~high_bits) & 0xffffffff,
1859                          (~low_bits) & 0xfffffc00))
1860     {
1861       /* NOTE: The trailing bits get XOR'd so we need the
1862          non-negated bits, not the negated ones.  */
1863       unsigned HOST_WIDE_INT trailing_bits = low_bits & 0x3ff;
1864
1865       if ((((~high_bits) & 0xffffffff) == 0
1866            && ((~low_bits) & 0x80000000) == 0)
1867           || (((~high_bits) & 0xffffffff) == 0xffffffff
1868               && ((~low_bits) & 0x80000000) != 0))
1869         {
1870           unsigned HOST_WIDE_INT fast_int = (~low_bits & 0xffffffff);
1871
1872           if ((SPARC_SETHI_P (fast_int)
1873                && (~high_bits & 0xffffffff) == 0)
1874               || SPARC_SIMM13_P (fast_int))
1875             emit_insn (gen_safe_SET64 (temp, fast_int));
1876           else
1877             sparc_emit_set_const64 (temp, GEN_INT (fast_int));
1878         }
1879       else
1880         {
1881           rtx negated_const;
1882           negated_const = GEN_INT (((~low_bits) & 0xfffffc00) |
1883                                    (((HOST_WIDE_INT)((~high_bits) & 0xffffffff))<<32));
1884           sparc_emit_set_const64 (temp, negated_const);
1885         }
1886
1887       /* If we are XOR'ing with -1, then we should emit a one's complement
1888          instead.  This way the combiner will notice logical operations
1889          such as ANDN later on and substitute.  */
1890       if (trailing_bits == 0x3ff)
1891         {
1892           emit_insn (gen_rtx_SET (VOIDmode, op0,
1893                                   gen_rtx_NOT (DImode, temp)));
1894         }
1895       else
1896         {
1897           emit_insn (gen_rtx_SET (VOIDmode,
1898                                   op0,
1899                                   gen_safe_XOR64 (temp,
1900                                                   (-0x400 | trailing_bits))));
1901         }
1902       return;
1903     }
1904
1905   /* 1) sethi   %hi(xxx), %reg
1906    *    or      %reg, %lo(xxx), %reg
1907    *    sllx    %reg, yyy, %reg
1908    *
1909    * ??? This is just a generalized version of the low_bits==0
1910    * thing above, FIXME...
1911    */
1912   if ((highest_bit_set - lowest_bit_set) < 32)
1913     {
1914       unsigned HOST_WIDE_INT focus_bits =
1915         create_simple_focus_bits (high_bits, low_bits,
1916                                   lowest_bit_set, 0);
1917
1918       /* We can't get here in this state.  */
1919       gcc_assert (highest_bit_set >= 32 && lowest_bit_set < 32);
1920
1921       /* So what we know is that the set bits straddle the
1922          middle of the 64-bit word.  */
1923       sparc_emit_set_const64_quick2 (op0, temp,
1924                                      focus_bits, 0,
1925                                      lowest_bit_set);
1926       return;
1927     }
1928
1929   /* 1) sethi   %hi(high_bits), %reg
1930    *    or      %reg, %lo(high_bits), %reg
1931    *    sllx    %reg, 32, %reg
1932    *    or      %reg, low_bits, %reg
1933    */
1934   if (SPARC_SIMM13_P(low_bits)
1935       && ((int)low_bits > 0))
1936     {
1937       sparc_emit_set_const64_quick2 (op0, temp, high_bits, low_bits, 32);
1938       return;
1939     }
1940
1941   /* The easiest way when all else fails, is full decomposition.  */
1942 #if 0
1943   printf ("sparc_emit_set_const64: Hard constant [%08lx%08lx] neg[%08lx%08lx]\n",
1944           high_bits, low_bits, ~high_bits, ~low_bits);
1945 #endif
1946   sparc_emit_set_const64_longway (op0, temp, high_bits, low_bits);
1947 }
1948 #endif /* HOST_BITS_PER_WIDE_INT == 32 */
1949
1950 /* Given a comparison code (EQ, NE, etc.) and the first operand of a COMPARE,
1951    return the mode to be used for the comparison.  For floating-point,
1952    CCFP[E]mode is used.  CC_NOOVmode should be used when the first operand
1953    is a PLUS, MINUS, NEG, or ASHIFT.  CCmode should be used when no special
1954    processing is needed.  */
1955
1956 enum machine_mode
1957 select_cc_mode (enum rtx_code op, rtx x, rtx y ATTRIBUTE_UNUSED)
1958 {
1959   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1960     {
1961       switch (op)
1962         {
1963         case EQ:
1964         case NE:
1965         case UNORDERED:
1966         case ORDERED:
1967         case UNLT:
1968         case UNLE:
1969         case UNGT:
1970         case UNGE:
1971         case UNEQ:
1972         case LTGT:
1973           return CCFPmode;
1974
1975         case LT:
1976         case LE:
1977         case GT:
1978         case GE:
1979           return CCFPEmode;
1980
1981         default:
1982           gcc_unreachable ();
1983         }
1984     }
1985   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
1986            || GET_CODE (x) == NEG || GET_CODE (x) == ASHIFT)
1987     {
1988       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
1989         return CCX_NOOVmode;
1990       else
1991         return CC_NOOVmode;
1992     }
1993   else
1994     {
1995       if (TARGET_ARCH64 && GET_MODE (x) == DImode)
1996         return CCXmode;
1997       else
1998         return CCmode;
1999     }
2000 }
2001
2002 /* Emit the compare insn and return the CC reg for a CODE comparison
2003    with operands X and Y.  */
2004
2005 static rtx
2006 gen_compare_reg_1 (enum rtx_code code, rtx x, rtx y)
2007 {
2008   enum machine_mode mode;
2009   rtx cc_reg;
2010
2011   if (GET_MODE_CLASS (GET_MODE (x)) == MODE_CC)
2012     return x;
2013
2014   mode = SELECT_CC_MODE (code, x, y);
2015
2016   /* ??? We don't have movcc patterns so we cannot generate pseudo regs for the
2017      fcc regs (cse can't tell they're really call clobbered regs and will
2018      remove a duplicate comparison even if there is an intervening function
2019      call - it will then try to reload the cc reg via an int reg which is why
2020      we need the movcc patterns).  It is possible to provide the movcc
2021      patterns by using the ldxfsr/stxfsr v9 insns.  I tried it: you need two
2022      registers (say %g1,%g5) and it takes about 6 insns.  A better fix would be
2023      to tell cse that CCFPE mode registers (even pseudos) are call
2024      clobbered.  */
2025
2026   /* ??? This is an experiment.  Rather than making changes to cse which may
2027      or may not be easy/clean, we do our own cse.  This is possible because
2028      we will generate hard registers.  Cse knows they're call clobbered (it
2029      doesn't know the same thing about pseudos). If we guess wrong, no big
2030      deal, but if we win, great!  */
2031
2032   if (TARGET_V9 && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2033 #if 1 /* experiment */
2034     {
2035       int reg;
2036       /* We cycle through the registers to ensure they're all exercised.  */
2037       static int next_fcc_reg = 0;
2038       /* Previous x,y for each fcc reg.  */
2039       static rtx prev_args[4][2];
2040
2041       /* Scan prev_args for x,y.  */
2042       for (reg = 0; reg < 4; reg++)
2043         if (prev_args[reg][0] == x && prev_args[reg][1] == y)
2044           break;
2045       if (reg == 4)
2046         {
2047           reg = next_fcc_reg;
2048           prev_args[reg][0] = x;
2049           prev_args[reg][1] = y;
2050           next_fcc_reg = (next_fcc_reg + 1) & 3;
2051         }
2052       cc_reg = gen_rtx_REG (mode, reg + SPARC_FIRST_V9_FCC_REG);
2053     }
2054 #else
2055     cc_reg = gen_reg_rtx (mode);
2056 #endif /* ! experiment */
2057   else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
2058     cc_reg = gen_rtx_REG (mode, SPARC_FCC_REG);
2059   else
2060     cc_reg = gen_rtx_REG (mode, SPARC_ICC_REG);
2061
2062   /* We shouldn't get there for TFmode if !TARGET_HARD_QUAD.  If we do, this
2063      will only result in an unrecognizable insn so no point in asserting.  */
2064   emit_insn (gen_rtx_SET (VOIDmode, cc_reg, gen_rtx_COMPARE (mode, x, y)));
2065
2066   return cc_reg;
2067 }
2068
2069
2070 /* Emit the compare insn and return the CC reg for the comparison in CMP.  */
2071
2072 rtx
2073 gen_compare_reg (rtx cmp)
2074 {
2075   return gen_compare_reg_1 (GET_CODE (cmp), XEXP (cmp, 0), XEXP (cmp, 1));
2076 }
2077
2078 /* This function is used for v9 only.
2079    DEST is the target of the Scc insn.
2080    CODE is the code for an Scc's comparison.
2081    X and Y are the values we compare.
2082
2083    This function is needed to turn
2084
2085            (set (reg:SI 110)
2086                (gt (reg:CCX 100 %icc)
2087                    (const_int 0)))
2088    into
2089            (set (reg:SI 110)
2090                (gt:DI (reg:CCX 100 %icc)
2091                    (const_int 0)))
2092
2093    IE: The instruction recognizer needs to see the mode of the comparison to
2094    find the right instruction. We could use "gt:DI" right in the
2095    define_expand, but leaving it out allows us to handle DI, SI, etc.  */
2096
2097 static int
2098 gen_v9_scc (rtx dest, enum rtx_code compare_code, rtx x, rtx y)
2099 {
2100   if (! TARGET_ARCH64
2101       && (GET_MODE (x) == DImode
2102           || GET_MODE (dest) == DImode))
2103     return 0;
2104
2105   /* Try to use the movrCC insns.  */
2106   if (TARGET_ARCH64
2107       && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT
2108       && y == const0_rtx
2109       && v9_regcmp_p (compare_code))
2110     {
2111       rtx op0 = x;
2112       rtx temp;
2113
2114       /* Special case for op0 != 0.  This can be done with one instruction if
2115          dest == x.  */
2116
2117       if (compare_code == NE
2118           && GET_MODE (dest) == DImode
2119           && rtx_equal_p (op0, dest))
2120         {
2121           emit_insn (gen_rtx_SET (VOIDmode, dest,
2122                               gen_rtx_IF_THEN_ELSE (DImode,
2123                                        gen_rtx_fmt_ee (compare_code, DImode,
2124                                                        op0, const0_rtx),
2125                                        const1_rtx,
2126                                        dest)));
2127           return 1;
2128         }
2129
2130       if (reg_overlap_mentioned_p (dest, op0))
2131         {
2132           /* Handle the case where dest == x.
2133              We "early clobber" the result.  */
2134           op0 = gen_reg_rtx (GET_MODE (x));
2135           emit_move_insn (op0, x);
2136         }
2137
2138       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2139       if (GET_MODE (op0) != DImode)
2140         {
2141           temp = gen_reg_rtx (DImode);
2142           convert_move (temp, op0, 0);
2143         }
2144       else
2145         temp = op0;
2146       emit_insn (gen_rtx_SET (VOIDmode, dest,
2147                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2148                                    gen_rtx_fmt_ee (compare_code, DImode,
2149                                                    temp, const0_rtx),
2150                                    const1_rtx,
2151                                    dest)));
2152       return 1;
2153     }
2154   else
2155     {
2156       x = gen_compare_reg_1 (compare_code, x, y);
2157       y = const0_rtx;
2158
2159       gcc_assert (GET_MODE (x) != CC_NOOVmode
2160                   && GET_MODE (x) != CCX_NOOVmode);
2161
2162       emit_insn (gen_rtx_SET (VOIDmode, dest, const0_rtx));
2163       emit_insn (gen_rtx_SET (VOIDmode, dest,
2164                           gen_rtx_IF_THEN_ELSE (GET_MODE (dest),
2165                                    gen_rtx_fmt_ee (compare_code,
2166                                                    GET_MODE (x), x, y),
2167                                     const1_rtx, dest)));
2168       return 1;
2169     }
2170 }
2171
2172
2173 /* Emit an scc insn.  For seq, sne, sgeu, and sltu, we can do this
2174    without jumps using the addx/subx instructions.  */
2175
2176 bool
2177 emit_scc_insn (rtx operands[])
2178 {
2179   rtx tem;
2180   rtx x;
2181   rtx y;
2182   enum rtx_code code;
2183
2184   /* The quad-word fp compare library routines all return nonzero to indicate
2185      true, which is different from the equivalent libgcc routines, so we must
2186      handle them specially here.  */
2187   if (GET_MODE (operands[2]) == TFmode && ! TARGET_HARD_QUAD)
2188     {
2189       operands[1] = sparc_emit_float_lib_cmp (operands[2], operands[3],
2190                                               GET_CODE (operands[1]));
2191       operands[2] = XEXP (operands[1], 0);
2192       operands[3] = XEXP (operands[1], 1);
2193     }
2194
2195   code = GET_CODE (operands[1]);
2196   x = operands[2];
2197   y = operands[3];
2198
2199   /* For seq/sne on v9 we use the same code as v8 (the addx/subx method has
2200      more applications).  The exception to this is "reg != 0" which can
2201      be done in one instruction on v9 (so we do it).  */
2202   if (code == EQ)
2203     {
2204       if (GET_MODE (x) == SImode)
2205         {
2206           rtx pat = gen_seqsi_special (operands[0], x, y);
2207           emit_insn (pat);
2208           return true;
2209         }
2210       else if (GET_MODE (x) == DImode)
2211         {
2212           rtx pat = gen_seqdi_special (operands[0], x, y);
2213           emit_insn (pat);
2214           return true;
2215         }
2216     }
2217
2218   if (code == NE)
2219     {
2220       if (GET_MODE (x) == SImode)
2221         {
2222           rtx pat = gen_snesi_special (operands[0], x, y);
2223           emit_insn (pat);
2224           return true;
2225         }
2226       else if (GET_MODE (x) == DImode)
2227         {
2228           rtx pat = gen_snedi_special (operands[0], x, y);
2229           emit_insn (pat);
2230           return true;
2231         }
2232     }
2233
2234   /* For the rest, on v9 we can use conditional moves.  */
2235
2236   if (TARGET_V9)
2237     {
2238       if (gen_v9_scc (operands[0], code, x, y))
2239         return true;
2240     }
2241
2242   /* We can do LTU and GEU using the addx/subx instructions too.  And
2243      for GTU/LEU, if both operands are registers swap them and fall
2244      back to the easy case.  */
2245   if (code == GTU || code == LEU)
2246     {
2247       if ((GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2248           && (GET_CODE (y) == REG || GET_CODE (y) == SUBREG))
2249         {
2250           tem = x;
2251           x = y;
2252           y = tem;
2253           code = swap_condition (code);
2254         }
2255     }
2256
2257   if (code == LTU || code == GEU)
2258     {
2259       emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2260                               gen_rtx_fmt_ee (code, SImode,
2261                                               gen_compare_reg_1 (code, x, y),
2262                                               const0_rtx)));
2263       return true;
2264     }
2265
2266   /* Nope, do branches.  */
2267   return false;
2268 }
2269
2270 /* Emit a conditional jump insn for the v9 architecture using comparison code
2271    CODE and jump target LABEL.
2272    This function exists to take advantage of the v9 brxx insns.  */
2273
2274 static void
2275 emit_v9_brxx_insn (enum rtx_code code, rtx op0, rtx label)
2276 {
2277   emit_jump_insn (gen_rtx_SET (VOIDmode,
2278                            pc_rtx,
2279                            gen_rtx_IF_THEN_ELSE (VOIDmode,
2280                                     gen_rtx_fmt_ee (code, GET_MODE (op0),
2281                                                     op0, const0_rtx),
2282                                     gen_rtx_LABEL_REF (VOIDmode, label),
2283                                     pc_rtx)));
2284 }
2285
2286 void
2287 emit_conditional_branch_insn (rtx operands[])
2288 {
2289   /* The quad-word fp compare library routines all return nonzero to indicate
2290      true, which is different from the equivalent libgcc routines, so we must
2291      handle them specially here.  */
2292   if (GET_MODE (operands[1]) == TFmode && ! TARGET_HARD_QUAD)
2293     {
2294       operands[0] = sparc_emit_float_lib_cmp (operands[1], operands[2],
2295                                               GET_CODE (operands[0]));
2296       operands[1] = XEXP (operands[0], 0);
2297       operands[2] = XEXP (operands[0], 1);
2298     }
2299
2300   if (TARGET_ARCH64 && operands[2] == const0_rtx
2301       && GET_CODE (operands[1]) == REG
2302       && GET_MODE (operands[1]) == DImode)
2303     {
2304       emit_v9_brxx_insn (GET_CODE (operands[0]), operands[1], operands[3]);
2305       return;
2306     }
2307
2308   operands[1] = gen_compare_reg (operands[0]);
2309   operands[2] = const0_rtx;
2310   operands[0] = gen_rtx_fmt_ee (GET_CODE (operands[0]), VOIDmode,
2311                                 operands[1], operands[2]);
2312   emit_jump_insn (gen_cbranchcc4 (operands[0], operands[1], operands[2],
2313                                   operands[3]));
2314 }
2315
2316
2317 /* Generate a DFmode part of a hard TFmode register.
2318    REG is the TFmode hard register, LOW is 1 for the
2319    low 64bit of the register and 0 otherwise.
2320  */
2321 rtx
2322 gen_df_reg (rtx reg, int low)
2323 {
2324   int regno = REGNO (reg);
2325
2326   if ((WORDS_BIG_ENDIAN == 0) ^ (low != 0))
2327     regno += (TARGET_ARCH64 && regno < 32) ? 1 : 2;
2328   return gen_rtx_REG (DFmode, regno);
2329 }
2330 \f
2331 /* Generate a call to FUNC with OPERANDS.  Operand 0 is the return value.
2332    Unlike normal calls, TFmode operands are passed by reference.  It is
2333    assumed that no more than 3 operands are required.  */
2334
2335 static void
2336 emit_soft_tfmode_libcall (const char *func_name, int nargs, rtx *operands)
2337 {
2338   rtx ret_slot = NULL, arg[3], func_sym;
2339   int i;
2340
2341   /* We only expect to be called for conversions, unary, and binary ops.  */
2342   gcc_assert (nargs == 2 || nargs == 3);
2343
2344   for (i = 0; i < nargs; ++i)
2345     {
2346       rtx this_arg = operands[i];
2347       rtx this_slot;
2348
2349       /* TFmode arguments and return values are passed by reference.  */
2350       if (GET_MODE (this_arg) == TFmode)
2351         {
2352           int force_stack_temp;
2353
2354           force_stack_temp = 0;
2355           if (TARGET_BUGGY_QP_LIB && i == 0)
2356             force_stack_temp = 1;
2357
2358           if (GET_CODE (this_arg) == MEM
2359               && ! force_stack_temp)
2360             this_arg = XEXP (this_arg, 0);
2361           else if (CONSTANT_P (this_arg)
2362                    && ! force_stack_temp)
2363             {
2364               this_slot = force_const_mem (TFmode, this_arg);
2365               this_arg = XEXP (this_slot, 0);
2366             }
2367           else
2368             {
2369               this_slot = assign_stack_temp (TFmode, GET_MODE_SIZE (TFmode), 0);
2370
2371               /* Operand 0 is the return value.  We'll copy it out later.  */
2372               if (i > 0)
2373                 emit_move_insn (this_slot, this_arg);
2374               else
2375                 ret_slot = this_slot;
2376
2377               this_arg = XEXP (this_slot, 0);
2378             }
2379         }
2380
2381       arg[i] = this_arg;
2382     }
2383
2384   func_sym = gen_rtx_SYMBOL_REF (Pmode, func_name);
2385
2386   if (GET_MODE (operands[0]) == TFmode)
2387     {
2388       if (nargs == 2)
2389         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 2,
2390                            arg[0], GET_MODE (arg[0]),
2391                            arg[1], GET_MODE (arg[1]));
2392       else
2393         emit_library_call (func_sym, LCT_NORMAL, VOIDmode, 3,
2394                            arg[0], GET_MODE (arg[0]),
2395                            arg[1], GET_MODE (arg[1]),
2396                            arg[2], GET_MODE (arg[2]));
2397
2398       if (ret_slot)
2399         emit_move_insn (operands[0], ret_slot);
2400     }
2401   else
2402     {
2403       rtx ret;
2404
2405       gcc_assert (nargs == 2);
2406
2407       ret = emit_library_call_value (func_sym, operands[0], LCT_NORMAL,
2408                                      GET_MODE (operands[0]), 1,
2409                                      arg[1], GET_MODE (arg[1]));
2410
2411       if (ret != operands[0])
2412         emit_move_insn (operands[0], ret);
2413     }
2414 }
2415
2416 /* Expand soft-float TFmode calls to sparc abi routines.  */
2417
2418 static void
2419 emit_soft_tfmode_binop (enum rtx_code code, rtx *operands)
2420 {
2421   const char *func;
2422
2423   switch (code)
2424     {
2425     case PLUS:
2426       func = "_Qp_add";
2427       break;
2428     case MINUS:
2429       func = "_Qp_sub";
2430       break;
2431     case MULT:
2432       func = "_Qp_mul";
2433       break;
2434     case DIV:
2435       func = "_Qp_div";
2436       break;
2437     default:
2438       gcc_unreachable ();
2439     }
2440
2441   emit_soft_tfmode_libcall (func, 3, operands);
2442 }
2443
2444 static void
2445 emit_soft_tfmode_unop (enum rtx_code code, rtx *operands)
2446 {
2447   const char *func;
2448
2449   gcc_assert (code == SQRT);
2450   func = "_Qp_sqrt";
2451
2452   emit_soft_tfmode_libcall (func, 2, operands);
2453 }
2454
2455 static void
2456 emit_soft_tfmode_cvt (enum rtx_code code, rtx *operands)
2457 {
2458   const char *func;
2459
2460   switch (code)
2461     {
2462     case FLOAT_EXTEND:
2463       switch (GET_MODE (operands[1]))
2464         {
2465         case SFmode:
2466           func = "_Qp_stoq";
2467           break;
2468         case DFmode:
2469           func = "_Qp_dtoq";
2470           break;
2471         default:
2472           gcc_unreachable ();
2473         }
2474       break;
2475
2476     case FLOAT_TRUNCATE:
2477       switch (GET_MODE (operands[0]))
2478         {
2479         case SFmode:
2480           func = "_Qp_qtos";
2481           break;
2482         case DFmode:
2483           func = "_Qp_qtod";
2484           break;
2485         default:
2486           gcc_unreachable ();
2487         }
2488       break;
2489
2490     case FLOAT:
2491       switch (GET_MODE (operands[1]))
2492         {
2493         case SImode:
2494           func = "_Qp_itoq";
2495           if (TARGET_ARCH64)
2496             operands[1] = gen_rtx_SIGN_EXTEND (DImode, operands[1]);
2497           break;
2498         case DImode:
2499           func = "_Qp_xtoq";
2500           break;
2501         default:
2502           gcc_unreachable ();
2503         }
2504       break;
2505
2506     case UNSIGNED_FLOAT:
2507       switch (GET_MODE (operands[1]))
2508         {
2509         case SImode:
2510           func = "_Qp_uitoq";
2511           if (TARGET_ARCH64)
2512             operands[1] = gen_rtx_ZERO_EXTEND (DImode, operands[1]);
2513           break;
2514         case DImode:
2515           func = "_Qp_uxtoq";
2516           break;
2517         default:
2518           gcc_unreachable ();
2519         }
2520       break;
2521
2522     case FIX:
2523       switch (GET_MODE (operands[0]))
2524         {
2525         case SImode:
2526           func = "_Qp_qtoi";
2527           break;
2528         case DImode:
2529           func = "_Qp_qtox";
2530           break;
2531         default:
2532           gcc_unreachable ();
2533         }
2534       break;
2535
2536     case UNSIGNED_FIX:
2537       switch (GET_MODE (operands[0]))
2538         {
2539         case SImode:
2540           func = "_Qp_qtoui";
2541           break;
2542         case DImode:
2543           func = "_Qp_qtoux";
2544           break;
2545         default:
2546           gcc_unreachable ();
2547         }
2548       break;
2549
2550     default:
2551       gcc_unreachable ();
2552     }
2553
2554   emit_soft_tfmode_libcall (func, 2, operands);
2555 }
2556
2557 /* Expand a hard-float tfmode operation.  All arguments must be in
2558    registers.  */
2559
2560 static void
2561 emit_hard_tfmode_operation (enum rtx_code code, rtx *operands)
2562 {
2563   rtx op, dest;
2564
2565   if (GET_RTX_CLASS (code) == RTX_UNARY)
2566     {
2567       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2568       op = gen_rtx_fmt_e (code, GET_MODE (operands[0]), operands[1]);
2569     }
2570   else
2571     {
2572       operands[1] = force_reg (GET_MODE (operands[1]), operands[1]);
2573       operands[2] = force_reg (GET_MODE (operands[2]), operands[2]);
2574       op = gen_rtx_fmt_ee (code, GET_MODE (operands[0]),
2575                            operands[1], operands[2]);
2576     }
2577
2578   if (register_operand (operands[0], VOIDmode))
2579     dest = operands[0];
2580   else
2581     dest = gen_reg_rtx (GET_MODE (operands[0]));
2582
2583   emit_insn (gen_rtx_SET (VOIDmode, dest, op));
2584
2585   if (dest != operands[0])
2586     emit_move_insn (operands[0], dest);
2587 }
2588
2589 void
2590 emit_tfmode_binop (enum rtx_code code, rtx *operands)
2591 {
2592   if (TARGET_HARD_QUAD)
2593     emit_hard_tfmode_operation (code, operands);
2594   else
2595     emit_soft_tfmode_binop (code, operands);
2596 }
2597
2598 void
2599 emit_tfmode_unop (enum rtx_code code, rtx *operands)
2600 {
2601   if (TARGET_HARD_QUAD)
2602     emit_hard_tfmode_operation (code, operands);
2603   else
2604     emit_soft_tfmode_unop (code, operands);
2605 }
2606
2607 void
2608 emit_tfmode_cvt (enum rtx_code code, rtx *operands)
2609 {
2610   if (TARGET_HARD_QUAD)
2611     emit_hard_tfmode_operation (code, operands);
2612   else
2613     emit_soft_tfmode_cvt (code, operands);
2614 }
2615 \f
2616 /* Return nonzero if a branch/jump/call instruction will be emitting
2617    nop into its delay slot.  */
2618
2619 int
2620 empty_delay_slot (rtx insn)
2621 {
2622   rtx seq;
2623
2624   /* If no previous instruction (should not happen), return true.  */
2625   if (PREV_INSN (insn) == NULL)
2626     return 1;
2627
2628   seq = NEXT_INSN (PREV_INSN (insn));
2629   if (GET_CODE (PATTERN (seq)) == SEQUENCE)
2630     return 0;
2631
2632   return 1;
2633 }
2634
2635 /* Return nonzero if TRIAL can go into the call delay slot.  */
2636
2637 int
2638 tls_call_delay (rtx trial)
2639 {
2640   rtx pat;
2641
2642   /* Binutils allows
2643        call __tls_get_addr, %tgd_call (foo)
2644         add %l7, %o0, %o0, %tgd_add (foo)
2645      while Sun as/ld does not.  */
2646   if (TARGET_GNU_TLS || !TARGET_TLS)
2647     return 1;
2648
2649   pat = PATTERN (trial);
2650
2651   /* We must reject tgd_add{32|64}, i.e.
2652        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSGD)))
2653      and tldm_add{32|64}, i.e.
2654        (set (reg) (plus (reg) (unspec [(reg) (symbol_ref)] UNSPEC_TLSLDM)))
2655      for Sun as/ld.  */
2656   if (GET_CODE (pat) == SET
2657       && GET_CODE (SET_SRC (pat)) == PLUS)
2658     {
2659       rtx unspec = XEXP (SET_SRC (pat), 1);
2660
2661       if (GET_CODE (unspec) == UNSPEC
2662           && (XINT (unspec, 1) == UNSPEC_TLSGD
2663               || XINT (unspec, 1) == UNSPEC_TLSLDM))
2664         return 0;
2665     }
2666
2667   return 1;
2668 }
2669
2670 /* Return nonzero if TRIAL, an insn, can be combined with a 'restore'
2671    instruction.  RETURN_P is true if the v9 variant 'return' is to be
2672    considered in the test too.
2673
2674    TRIAL must be a SET whose destination is a REG appropriate for the
2675    'restore' instruction or, if RETURN_P is true, for the 'return'
2676    instruction.  */
2677
2678 static int
2679 eligible_for_restore_insn (rtx trial, bool return_p)
2680 {
2681   rtx pat = PATTERN (trial);
2682   rtx src = SET_SRC (pat);
2683
2684   /* The 'restore src,%g0,dest' pattern for word mode and below.  */
2685   if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
2686       && arith_operand (src, GET_MODE (src)))
2687     {
2688       if (TARGET_ARCH64)
2689         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
2690       else
2691         return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (SImode);
2692     }
2693
2694   /* The 'restore src,%g0,dest' pattern for double-word mode.  */
2695   else if (GET_MODE_CLASS (GET_MODE (src)) != MODE_FLOAT
2696            && arith_double_operand (src, GET_MODE (src)))
2697     return GET_MODE_SIZE (GET_MODE (src)) <= GET_MODE_SIZE (DImode);
2698
2699   /* The 'restore src,%g0,dest' pattern for float if no FPU.  */
2700   else if (! TARGET_FPU && register_operand (src, SFmode))
2701     return 1;
2702
2703   /* The 'restore src,%g0,dest' pattern for double if no FPU.  */
2704   else if (! TARGET_FPU && TARGET_ARCH64 && register_operand (src, DFmode))
2705     return 1;
2706
2707   /* If we have the 'return' instruction, anything that does not use
2708      local or output registers and can go into a delay slot wins.  */
2709   else if (return_p && TARGET_V9 && ! epilogue_renumber (&pat, 1)
2710            && (get_attr_in_uncond_branch_delay (trial)
2711                == IN_UNCOND_BRANCH_DELAY_TRUE))
2712     return 1;
2713
2714   /* The 'restore src1,src2,dest' pattern for SImode.  */
2715   else if (GET_CODE (src) == PLUS
2716            && register_operand (XEXP (src, 0), SImode)
2717            && arith_operand (XEXP (src, 1), SImode))
2718     return 1;
2719
2720   /* The 'restore src1,src2,dest' pattern for DImode.  */
2721   else if (GET_CODE (src) == PLUS
2722            && register_operand (XEXP (src, 0), DImode)
2723            && arith_double_operand (XEXP (src, 1), DImode))
2724     return 1;
2725
2726   /* The 'restore src1,%lo(src2),dest' pattern.  */
2727   else if (GET_CODE (src) == LO_SUM
2728            && ! TARGET_CM_MEDMID
2729            && ((register_operand (XEXP (src, 0), SImode)
2730                 && immediate_operand (XEXP (src, 1), SImode))
2731                || (TARGET_ARCH64
2732                    && register_operand (XEXP (src, 0), DImode)
2733                    && immediate_operand (XEXP (src, 1), DImode))))
2734     return 1;
2735
2736   /* The 'restore src,src,dest' pattern.  */
2737   else if (GET_CODE (src) == ASHIFT
2738            && (register_operand (XEXP (src, 0), SImode)
2739                || register_operand (XEXP (src, 0), DImode))
2740            && XEXP (src, 1) == const1_rtx)
2741     return 1;
2742
2743   return 0;
2744 }
2745
2746 /* Return nonzero if TRIAL can go into the function return's
2747    delay slot.  */
2748
2749 int
2750 eligible_for_return_delay (rtx trial)
2751 {
2752   rtx pat;
2753
2754   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
2755     return 0;
2756
2757   if (get_attr_length (trial) != 1)
2758     return 0;
2759
2760   /* If there are any call-saved registers, we should scan TRIAL if it
2761      does not reference them.  For now just make it easy.  */
2762   if (num_gfregs)
2763     return 0;
2764
2765   /* If the function uses __builtin_eh_return, the eh_return machinery
2766      occupies the delay slot.  */
2767   if (crtl->calls_eh_return)
2768     return 0;
2769
2770   /* In the case of a true leaf function, anything can go into the slot.  */
2771   if (sparc_leaf_function_p)
2772     return get_attr_in_uncond_branch_delay (trial)
2773            == IN_UNCOND_BRANCH_DELAY_TRUE;
2774
2775   pat = PATTERN (trial);
2776
2777   /* Otherwise, only operations which can be done in tandem with
2778      a `restore' or `return' insn can go into the delay slot.  */
2779   if (GET_CODE (SET_DEST (pat)) != REG
2780       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24))
2781     return 0;
2782
2783   /* If this instruction sets up floating point register and we have a return
2784      instruction, it can probably go in.  But restore will not work
2785      with FP_REGS.  */
2786   if (REGNO (SET_DEST (pat)) >= 32)
2787     return (TARGET_V9
2788             && ! epilogue_renumber (&pat, 1)
2789             && (get_attr_in_uncond_branch_delay (trial)
2790                 == IN_UNCOND_BRANCH_DELAY_TRUE));
2791
2792   return eligible_for_restore_insn (trial, true);
2793 }
2794
2795 /* Return nonzero if TRIAL can go into the sibling call's
2796    delay slot.  */
2797
2798 int
2799 eligible_for_sibcall_delay (rtx trial)
2800 {
2801   rtx pat;
2802
2803   if (GET_CODE (trial) != INSN || GET_CODE (PATTERN (trial)) != SET)
2804     return 0;
2805
2806   if (get_attr_length (trial) != 1)
2807     return 0;
2808
2809   pat = PATTERN (trial);
2810
2811   if (sparc_leaf_function_p)
2812     {
2813       /* If the tail call is done using the call instruction,
2814          we have to restore %o7 in the delay slot.  */
2815       if (LEAF_SIBCALL_SLOT_RESERVED_P)
2816         return 0;
2817
2818       /* %g1 is used to build the function address */
2819       if (reg_mentioned_p (gen_rtx_REG (Pmode, 1), pat))
2820         return 0;
2821
2822       return 1;
2823     }
2824
2825   /* Otherwise, only operations which can be done in tandem with
2826      a `restore' insn can go into the delay slot.  */
2827   if (GET_CODE (SET_DEST (pat)) != REG
2828       || (REGNO (SET_DEST (pat)) >= 8 && REGNO (SET_DEST (pat)) < 24)
2829       || REGNO (SET_DEST (pat)) >= 32)
2830     return 0;
2831
2832   /* If it mentions %o7, it can't go in, because sibcall will clobber it
2833      in most cases.  */
2834   if (reg_mentioned_p (gen_rtx_REG (Pmode, 15), pat))
2835     return 0;
2836
2837   return eligible_for_restore_insn (trial, false);
2838 }
2839
2840 int
2841 short_branch (int uid1, int uid2)
2842 {
2843   int delta = INSN_ADDRESSES (uid1) - INSN_ADDRESSES (uid2);
2844
2845   /* Leave a few words of "slop".  */
2846   if (delta >= -1023 && delta <= 1022)
2847     return 1;
2848
2849   return 0;
2850 }
2851
2852 /* Return nonzero if REG is not used after INSN.
2853    We assume REG is a reload reg, and therefore does
2854    not live past labels or calls or jumps.  */
2855 int
2856 reg_unused_after (rtx reg, rtx insn)
2857 {
2858   enum rtx_code code, prev_code = UNKNOWN;
2859
2860   while ((insn = NEXT_INSN (insn)))
2861     {
2862       if (prev_code == CALL_INSN && call_used_regs[REGNO (reg)])
2863         return 1;
2864
2865       code = GET_CODE (insn);
2866       if (GET_CODE (insn) == CODE_LABEL)
2867         return 1;
2868
2869       if (INSN_P (insn))
2870         {
2871           rtx set = single_set (insn);
2872           int in_src = set && reg_overlap_mentioned_p (reg, SET_SRC (set));
2873           if (set && in_src)
2874             return 0;
2875           if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
2876             return 1;
2877           if (set == 0 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
2878             return 0;
2879         }
2880       prev_code = code;
2881     }
2882   return 1;
2883 }
2884 \f
2885 /* Determine if it's legal to put X into the constant pool.  This
2886    is not possible if X contains the address of a symbol that is
2887    not constant (TLS) or not known at final link time (PIC).  */
2888
2889 static bool
2890 sparc_cannot_force_const_mem (rtx x)
2891 {
2892   switch (GET_CODE (x))
2893     {
2894     case CONST_INT:
2895     case CONST_DOUBLE:
2896     case CONST_VECTOR:
2897       /* Accept all non-symbolic constants.  */
2898       return false;
2899
2900     case LABEL_REF:
2901       /* Labels are OK iff we are non-PIC.  */
2902       return flag_pic != 0;
2903
2904     case SYMBOL_REF:
2905       /* 'Naked' TLS symbol references are never OK,
2906          non-TLS symbols are OK iff we are non-PIC.  */
2907       if (SYMBOL_REF_TLS_MODEL (x))
2908         return true;
2909       else
2910         return flag_pic != 0;
2911
2912     case CONST:
2913       return sparc_cannot_force_const_mem (XEXP (x, 0));
2914     case PLUS:
2915     case MINUS:
2916       return sparc_cannot_force_const_mem (XEXP (x, 0))
2917          || sparc_cannot_force_const_mem (XEXP (x, 1));
2918     case UNSPEC:
2919       return true;
2920     default:
2921       gcc_unreachable ();
2922     }
2923 }
2924 \f
2925 /* PIC support.  */
2926 static GTY(()) char pic_helper_symbol_name[256];
2927 static GTY(()) rtx pic_helper_symbol;
2928 static GTY(()) bool pic_helper_emitted_p = false;
2929 static GTY(()) rtx global_offset_table;
2930
2931 /* Ensure that we are not using patterns that are not OK with PIC.  */
2932
2933 int
2934 check_pic (int i)
2935 {
2936   switch (flag_pic)
2937     {
2938     case 1:
2939       gcc_assert (GET_CODE (recog_data.operand[i]) != SYMBOL_REF
2940                   && (GET_CODE (recog_data.operand[i]) != CONST
2941                   || (GET_CODE (XEXP (recog_data.operand[i], 0)) == MINUS
2942                       && (XEXP (XEXP (recog_data.operand[i], 0), 0)
2943                           == global_offset_table)
2944                       && (GET_CODE (XEXP (XEXP (recog_data.operand[i], 0), 1))
2945                           == CONST))));
2946     case 2:
2947     default:
2948       return 1;
2949     }
2950 }
2951
2952 /* Return true if X is an address which needs a temporary register when
2953    reloaded while generating PIC code.  */
2954
2955 int
2956 pic_address_needs_scratch (rtx x)
2957 {
2958   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
2959   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
2960       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2961       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2962       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
2963     return 1;
2964
2965   return 0;
2966 }
2967
2968 /* Determine if a given RTX is a valid constant.  We already know this
2969    satisfies CONSTANT_P.  */
2970
2971 bool
2972 legitimate_constant_p (rtx x)
2973 {
2974   rtx inner;
2975
2976   switch (GET_CODE (x))
2977     {
2978     case SYMBOL_REF:
2979       /* TLS symbols are not constant.  */
2980       if (SYMBOL_REF_TLS_MODEL (x))
2981         return false;
2982       break;
2983
2984     case CONST:
2985       inner = XEXP (x, 0);
2986
2987       /* Offsets of TLS symbols are never valid.
2988          Discourage CSE from creating them.  */
2989       if (GET_CODE (inner) == PLUS
2990           && SPARC_SYMBOL_REF_TLS_P (XEXP (inner, 0)))
2991         return false;
2992       break;
2993
2994     case CONST_DOUBLE:
2995       if (GET_MODE (x) == VOIDmode)
2996         return true;
2997
2998       /* Floating point constants are generally not ok.
2999          The only exception is 0.0 in VIS.  */
3000       if (TARGET_VIS
3001           && SCALAR_FLOAT_MODE_P (GET_MODE (x))
3002           && const_zero_operand (x, GET_MODE (x)))
3003         return true;
3004
3005       return false;
3006
3007     case CONST_VECTOR:
3008       /* Vector constants are generally not ok.
3009          The only exception is 0 in VIS.  */
3010       if (TARGET_VIS
3011           && const_zero_operand (x, GET_MODE (x)))
3012         return true;
3013
3014       return false;
3015
3016     default:
3017       break;
3018     }
3019
3020   return true;
3021 }
3022
3023 /* Determine if a given RTX is a valid constant address.  */
3024
3025 bool
3026 constant_address_p (rtx x)
3027 {
3028   switch (GET_CODE (x))
3029     {
3030     case LABEL_REF:
3031     case CONST_INT:
3032     case HIGH:
3033       return true;
3034
3035     case CONST:
3036       if (flag_pic && pic_address_needs_scratch (x))
3037         return false;
3038       return legitimate_constant_p (x);
3039
3040     case SYMBOL_REF:
3041       return !flag_pic && legitimate_constant_p (x);
3042
3043     default:
3044       return false;
3045     }
3046 }
3047
3048 /* Nonzero if the constant value X is a legitimate general operand
3049    when generating PIC code.  It is given that flag_pic is on and
3050    that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
3051
3052 bool
3053 legitimate_pic_operand_p (rtx x)
3054 {
3055   if (pic_address_needs_scratch (x))
3056     return false;
3057   if (SPARC_SYMBOL_REF_TLS_P (x)
3058       || (GET_CODE (x) == CONST
3059           && GET_CODE (XEXP (x, 0)) == PLUS
3060           && SPARC_SYMBOL_REF_TLS_P (XEXP (XEXP (x, 0), 0))))
3061     return false;
3062   return true;
3063 }
3064
3065 /* Return nonzero if ADDR is a valid memory address.
3066    STRICT specifies whether strict register checking applies.  */
3067
3068 static bool
3069 sparc_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
3070 {
3071   rtx rs1 = NULL, rs2 = NULL, imm1 = NULL;
3072
3073   if (REG_P (addr) || GET_CODE (addr) == SUBREG)
3074     rs1 = addr;
3075   else if (GET_CODE (addr) == PLUS)
3076     {
3077       rs1 = XEXP (addr, 0);
3078       rs2 = XEXP (addr, 1);
3079
3080       /* Canonicalize.  REG comes first, if there are no regs,
3081          LO_SUM comes first.  */
3082       if (!REG_P (rs1)
3083           && GET_CODE (rs1) != SUBREG
3084           && (REG_P (rs2)
3085               || GET_CODE (rs2) == SUBREG
3086               || (GET_CODE (rs2) == LO_SUM && GET_CODE (rs1) != LO_SUM)))
3087         {
3088           rs1 = XEXP (addr, 1);
3089           rs2 = XEXP (addr, 0);
3090         }
3091
3092       if ((flag_pic == 1
3093            && rs1 == pic_offset_table_rtx
3094            && !REG_P (rs2)
3095            && GET_CODE (rs2) != SUBREG
3096            && GET_CODE (rs2) != LO_SUM
3097            && GET_CODE (rs2) != MEM
3098            && ! SPARC_SYMBOL_REF_TLS_P (rs2)
3099            && (! symbolic_operand (rs2, VOIDmode) || mode == Pmode)
3100            && (GET_CODE (rs2) != CONST_INT || SMALL_INT (rs2)))
3101           || ((REG_P (rs1)
3102                || GET_CODE (rs1) == SUBREG)
3103               && RTX_OK_FOR_OFFSET_P (rs2)))
3104         {
3105           imm1 = rs2;
3106           rs2 = NULL;
3107         }
3108       else if ((REG_P (rs1) || GET_CODE (rs1) == SUBREG)
3109                && (REG_P (rs2) || GET_CODE (rs2) == SUBREG))
3110         {
3111           /* We prohibit REG + REG for TFmode when there are no quad move insns
3112              and we consequently need to split.  We do this because REG+REG
3113              is not an offsettable address.  If we get the situation in reload
3114              where source and destination of a movtf pattern are both MEMs with
3115              REG+REG address, then only one of them gets converted to an
3116              offsettable address.  */
3117           if (mode == TFmode
3118               && ! (TARGET_FPU && TARGET_ARCH64 && TARGET_HARD_QUAD))
3119             return 0;
3120
3121           /* We prohibit REG + REG on ARCH32 if not optimizing for
3122              DFmode/DImode because then mem_min_alignment is likely to be zero
3123              after reload and the  forced split would lack a matching splitter
3124              pattern.  */
3125           if (TARGET_ARCH32 && !optimize
3126               && (mode == DFmode || mode == DImode))
3127             return 0;
3128         }
3129       else if (USE_AS_OFFSETABLE_LO10
3130                && GET_CODE (rs1) == LO_SUM
3131                && TARGET_ARCH64
3132                && ! TARGET_CM_MEDMID
3133                && RTX_OK_FOR_OLO10_P (rs2))
3134         {
3135           rs2 = NULL;
3136           imm1 = XEXP (rs1, 1);
3137           rs1 = XEXP (rs1, 0);
3138           if (! CONSTANT_P (imm1) || SPARC_SYMBOL_REF_TLS_P (rs1))
3139             return 0;
3140         }
3141     }
3142   else if (GET_CODE (addr) == LO_SUM)
3143     {
3144       rs1 = XEXP (addr, 0);
3145       imm1 = XEXP (addr, 1);
3146
3147       if (! CONSTANT_P (imm1) || SPARC_SYMBOL_REF_TLS_P (rs1))
3148         return 0;
3149
3150       /* We can't allow TFmode in 32-bit mode, because an offset greater
3151          than the alignment (8) may cause the LO_SUM to overflow.  */
3152       if (mode == TFmode && TARGET_ARCH32)
3153         return 0;
3154     }
3155   else if (GET_CODE (addr) == CONST_INT && SMALL_INT (addr))
3156     return 1;
3157   else
3158     return 0;
3159
3160   if (GET_CODE (rs1) == SUBREG)
3161     rs1 = SUBREG_REG (rs1);
3162   if (!REG_P (rs1))
3163     return 0;
3164
3165   if (rs2)
3166     {
3167       if (GET_CODE (rs2) == SUBREG)
3168         rs2 = SUBREG_REG (rs2);
3169       if (!REG_P (rs2))
3170         return 0;
3171     }
3172
3173   if (strict)
3174     {
3175       if (!REGNO_OK_FOR_BASE_P (REGNO (rs1))
3176           || (rs2 && !REGNO_OK_FOR_BASE_P (REGNO (rs2))))
3177         return 0;
3178     }
3179   else
3180     {
3181       if ((REGNO (rs1) >= 32
3182            && REGNO (rs1) != FRAME_POINTER_REGNUM
3183            && REGNO (rs1) < FIRST_PSEUDO_REGISTER)
3184           || (rs2
3185               && (REGNO (rs2) >= 32
3186                   && REGNO (rs2) != FRAME_POINTER_REGNUM
3187                   && REGNO (rs2) < FIRST_PSEUDO_REGISTER)))
3188         return 0;
3189     }
3190   return 1;
3191 }
3192
3193 /* Construct the SYMBOL_REF for the tls_get_offset function.  */
3194
3195 static GTY(()) rtx sparc_tls_symbol;
3196
3197 static rtx
3198 sparc_tls_get_addr (void)
3199 {
3200   if (!sparc_tls_symbol)
3201     sparc_tls_symbol = gen_rtx_SYMBOL_REF (Pmode, "__tls_get_addr");
3202
3203   return sparc_tls_symbol;
3204 }
3205
3206 static rtx
3207 sparc_tls_got (void)
3208 {
3209   rtx temp;
3210   if (flag_pic)
3211     {
3212       crtl->uses_pic_offset_table = 1;
3213       return pic_offset_table_rtx;
3214     }
3215
3216   if (!global_offset_table)
3217     global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3218   temp = gen_reg_rtx (Pmode);
3219   emit_move_insn (temp, global_offset_table);
3220   return temp;
3221 }
3222
3223 /* Return 1 if *X is a thread-local symbol.  */
3224
3225 static int
3226 sparc_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
3227 {
3228   return SPARC_SYMBOL_REF_TLS_P (*x);
3229 }
3230
3231 /* Return 1 if X contains a thread-local symbol.  */
3232
3233 bool
3234 sparc_tls_referenced_p (rtx x)
3235 {
3236   if (!TARGET_HAVE_TLS)
3237     return false;
3238
3239   return for_each_rtx (&x, &sparc_tls_symbol_ref_1, 0);
3240 }
3241
3242 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
3243    this (thread-local) address.  */
3244
3245 rtx
3246 legitimize_tls_address (rtx addr)
3247 {
3248   rtx temp1, temp2, temp3, ret, o0, got, insn;
3249
3250   gcc_assert (can_create_pseudo_p ());
3251
3252   if (GET_CODE (addr) == SYMBOL_REF)
3253     switch (SYMBOL_REF_TLS_MODEL (addr))
3254       {
3255       case TLS_MODEL_GLOBAL_DYNAMIC:
3256         start_sequence ();
3257         temp1 = gen_reg_rtx (SImode);
3258         temp2 = gen_reg_rtx (SImode);
3259         ret = gen_reg_rtx (Pmode);
3260         o0 = gen_rtx_REG (Pmode, 8);
3261         got = sparc_tls_got ();
3262         emit_insn (gen_tgd_hi22 (temp1, addr));
3263         emit_insn (gen_tgd_lo10 (temp2, temp1, addr));
3264         if (TARGET_ARCH32)
3265           {
3266             emit_insn (gen_tgd_add32 (o0, got, temp2, addr));
3267             insn = emit_call_insn (gen_tgd_call32 (o0, sparc_tls_get_addr (),
3268                                                    addr, const1_rtx));
3269           }
3270         else
3271           {
3272             emit_insn (gen_tgd_add64 (o0, got, temp2, addr));
3273             insn = emit_call_insn (gen_tgd_call64 (o0, sparc_tls_get_addr (),
3274                                                    addr, const1_rtx));
3275           }
3276         CALL_INSN_FUNCTION_USAGE (insn)
3277           = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_USE (VOIDmode, o0),
3278                                CALL_INSN_FUNCTION_USAGE (insn));
3279         insn = get_insns ();
3280         end_sequence ();
3281         emit_libcall_block (insn, ret, o0, addr);
3282         break;
3283
3284       case TLS_MODEL_LOCAL_DYNAMIC:
3285         start_sequence ();
3286         temp1 = gen_reg_rtx (SImode);
3287         temp2 = gen_reg_rtx (SImode);
3288         temp3 = gen_reg_rtx (Pmode);
3289         ret = gen_reg_rtx (Pmode);
3290         o0 = gen_rtx_REG (Pmode, 8);
3291         got = sparc_tls_got ();
3292         emit_insn (gen_tldm_hi22 (temp1));
3293         emit_insn (gen_tldm_lo10 (temp2, temp1));
3294         if (TARGET_ARCH32)
3295           {
3296             emit_insn (gen_tldm_add32 (o0, got, temp2));
3297             insn = emit_call_insn (gen_tldm_call32 (o0, sparc_tls_get_addr (),
3298                                                     const1_rtx));
3299           }
3300         else
3301           {
3302             emit_insn (gen_tldm_add64 (o0, got, temp2));
3303             insn = emit_call_insn (gen_tldm_call64 (o0, sparc_tls_get_addr (),
3304                                                     const1_rtx));
3305           }
3306         CALL_INSN_FUNCTION_USAGE (insn)
3307           = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_USE (VOIDmode, o0),
3308                                CALL_INSN_FUNCTION_USAGE (insn));
3309         insn = get_insns ();
3310         end_sequence ();
3311         emit_libcall_block (insn, temp3, o0,
3312                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3313                                             UNSPEC_TLSLD_BASE));
3314         temp1 = gen_reg_rtx (SImode);
3315         temp2 = gen_reg_rtx (SImode);
3316         emit_insn (gen_tldo_hix22 (temp1, addr));
3317         emit_insn (gen_tldo_lox10 (temp2, temp1, addr));
3318         if (TARGET_ARCH32)
3319           emit_insn (gen_tldo_add32 (ret, temp3, temp2, addr));
3320         else
3321           emit_insn (gen_tldo_add64 (ret, temp3, temp2, addr));
3322         break;
3323
3324       case TLS_MODEL_INITIAL_EXEC:
3325         temp1 = gen_reg_rtx (SImode);
3326         temp2 = gen_reg_rtx (SImode);
3327         temp3 = gen_reg_rtx (Pmode);
3328         got = sparc_tls_got ();
3329         emit_insn (gen_tie_hi22 (temp1, addr));
3330         emit_insn (gen_tie_lo10 (temp2, temp1, addr));
3331         if (TARGET_ARCH32)
3332           emit_insn (gen_tie_ld32 (temp3, got, temp2, addr));
3333         else
3334           emit_insn (gen_tie_ld64 (temp3, got, temp2, addr));
3335         if (TARGET_SUN_TLS)
3336           {
3337             ret = gen_reg_rtx (Pmode);
3338             if (TARGET_ARCH32)
3339               emit_insn (gen_tie_add32 (ret, gen_rtx_REG (Pmode, 7),
3340                                         temp3, addr));
3341             else
3342               emit_insn (gen_tie_add64 (ret, gen_rtx_REG (Pmode, 7),
3343                                         temp3, addr));
3344           }
3345         else
3346           ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp3);
3347         break;
3348
3349       case TLS_MODEL_LOCAL_EXEC:
3350         temp1 = gen_reg_rtx (Pmode);
3351         temp2 = gen_reg_rtx (Pmode);
3352         if (TARGET_ARCH32)
3353           {
3354             emit_insn (gen_tle_hix22_sp32 (temp1, addr));
3355             emit_insn (gen_tle_lox10_sp32 (temp2, temp1, addr));
3356           }
3357         else
3358           {
3359             emit_insn (gen_tle_hix22_sp64 (temp1, addr));
3360             emit_insn (gen_tle_lox10_sp64 (temp2, temp1, addr));
3361           }
3362         ret = gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode, 7), temp2);
3363         break;
3364
3365       default:
3366         gcc_unreachable ();
3367       }
3368
3369   else
3370     gcc_unreachable ();  /* for now ... */
3371
3372   return ret;
3373 }
3374
3375
3376 /* Legitimize PIC addresses.  If the address is already position-independent,
3377    we return ORIG.  Newly generated position-independent addresses go into a
3378    reg.  This is REG if nonzero, otherwise we allocate register(s) as
3379    necessary.  */
3380
3381 rtx
3382 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
3383                         rtx reg)
3384 {
3385   if (GET_CODE (orig) == SYMBOL_REF
3386       /* See the comment in sparc_expand_move.  */
3387       || (TARGET_VXWORKS_RTP && GET_CODE (orig) == LABEL_REF))
3388     {
3389       rtx pic_ref, address;
3390       rtx insn;
3391
3392       if (reg == 0)
3393         {
3394           gcc_assert (! reload_in_progress && ! reload_completed);
3395           reg = gen_reg_rtx (Pmode);
3396         }
3397
3398       if (flag_pic == 2)
3399         {
3400           /* If not during reload, allocate another temp reg here for loading
3401              in the address, so that these instructions can be optimized
3402              properly.  */
3403           rtx temp_reg = ((reload_in_progress || reload_completed)
3404                           ? reg : gen_reg_rtx (Pmode));
3405
3406           /* Must put the SYMBOL_REF inside an UNSPEC here so that cse
3407              won't get confused into thinking that these two instructions
3408              are loading in the true address of the symbol.  If in the
3409              future a PIC rtx exists, that should be used instead.  */
3410           if (TARGET_ARCH64)
3411             {
3412               emit_insn (gen_movdi_high_pic (temp_reg, orig));
3413               emit_insn (gen_movdi_lo_sum_pic (temp_reg, temp_reg, orig));
3414             }
3415           else
3416             {
3417               emit_insn (gen_movsi_high_pic (temp_reg, orig));
3418               emit_insn (gen_movsi_lo_sum_pic (temp_reg, temp_reg, orig));
3419             }
3420           address = temp_reg;
3421         }
3422       else
3423         address = orig;
3424
3425       pic_ref = gen_const_mem (Pmode,
3426                                gen_rtx_PLUS (Pmode,
3427                                              pic_offset_table_rtx, address));
3428       crtl->uses_pic_offset_table = 1;
3429       insn = emit_move_insn (reg, pic_ref);
3430       /* Put a REG_EQUAL note on this insn, so that it can be optimized
3431          by loop.  */
3432       set_unique_reg_note (insn, REG_EQUAL, orig);
3433       return reg;
3434     }
3435   else if (GET_CODE (orig) == CONST)
3436     {
3437       rtx base, offset;
3438
3439       if (GET_CODE (XEXP (orig, 0)) == PLUS
3440           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
3441         return orig;
3442
3443       if (reg == 0)
3444         {
3445           gcc_assert (! reload_in_progress && ! reload_completed);
3446           reg = gen_reg_rtx (Pmode);
3447         }
3448
3449       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
3450       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
3451       offset = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
3452                                        base == reg ? 0 : reg);
3453
3454       if (GET_CODE (offset) == CONST_INT)
3455         {
3456           if (SMALL_INT (offset))
3457             return plus_constant (base, INTVAL (offset));
3458           else if (! reload_in_progress && ! reload_completed)
3459             offset = force_reg (Pmode, offset);
3460           else
3461             /* If we reach here, then something is seriously wrong.  */
3462             gcc_unreachable ();
3463         }
3464       return gen_rtx_PLUS (Pmode, base, offset);
3465     }
3466   else if (GET_CODE (orig) == LABEL_REF)
3467     /* ??? Why do we do this?  */
3468     /* Now movsi_pic_label_ref uses it, but we ought to be checking that
3469        the register is live instead, in case it is eliminated.  */
3470     crtl->uses_pic_offset_table = 1;
3471
3472   return orig;
3473 }
3474
3475 /* Try machine-dependent ways of modifying an illegitimate address X
3476    to be legitimate.  If we find one, return the new, valid address.
3477
3478    OLDX is the address as it was before break_out_memory_refs was called.
3479    In some cases it is useful to look at this to decide what needs to be done.
3480
3481    MODE is the mode of the operand pointed to by X.
3482
3483    On SPARC, change REG+N into REG+REG, and REG+(X*Y) into REG+REG.  */
3484
3485 rtx
3486 sparc_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3487                           enum machine_mode mode)
3488 {
3489   rtx orig_x = x;
3490
3491   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT)
3492     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3493                       force_operand (XEXP (x, 0), NULL_RTX));
3494   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == MULT)
3495     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3496                       force_operand (XEXP (x, 1), NULL_RTX));
3497   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS)
3498     x = gen_rtx_PLUS (Pmode, force_operand (XEXP (x, 0), NULL_RTX),
3499                       XEXP (x, 1));
3500   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == PLUS)
3501     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3502                       force_operand (XEXP (x, 1), NULL_RTX));
3503
3504   if (x != orig_x && sparc_legitimate_address_p (mode, x, FALSE))
3505     return x;
3506
3507   if (SPARC_SYMBOL_REF_TLS_P (x))
3508     x = legitimize_tls_address (x);
3509   else if (flag_pic)
3510     x = legitimize_pic_address (x, mode, 0);
3511   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 1)))
3512     x = gen_rtx_PLUS (Pmode, XEXP (x, 0),
3513                       copy_to_mode_reg (Pmode, XEXP (x, 1)));
3514   else if (GET_CODE (x) == PLUS && CONSTANT_ADDRESS_P (XEXP (x, 0)))
3515     x = gen_rtx_PLUS (Pmode, XEXP (x, 1),
3516                       copy_to_mode_reg (Pmode, XEXP (x, 0)));
3517   else if (GET_CODE (x) == SYMBOL_REF
3518            || GET_CODE (x) == CONST
3519            || GET_CODE (x) == LABEL_REF)
3520     x = copy_to_suggested_reg (x, NULL_RTX, Pmode);
3521   return x;
3522 }
3523
3524 /* Emit the special PIC helper function.  */
3525
3526 static void
3527 emit_pic_helper (void)
3528 {
3529   const char *pic_name = reg_names[REGNO (pic_offset_table_rtx)];
3530   int align;
3531
3532   switch_to_section (text_section);
3533
3534   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
3535   if (align > 0)
3536     ASM_OUTPUT_ALIGN (asm_out_file, align);
3537   ASM_OUTPUT_LABEL (asm_out_file, pic_helper_symbol_name);
3538   if (flag_delayed_branch)
3539     fprintf (asm_out_file, "\tjmp\t%%o7+8\n\t add\t%%o7, %s, %s\n",
3540             pic_name, pic_name);
3541   else
3542     fprintf (asm_out_file, "\tadd\t%%o7, %s, %s\n\tjmp\t%%o7+8\n\t nop\n",
3543             pic_name, pic_name);
3544
3545   pic_helper_emitted_p = true;
3546 }
3547
3548 /* Emit code to load the PIC register.  */
3549
3550 static void
3551 load_pic_register (bool delay_pic_helper)
3552 {
3553   int orig_flag_pic = flag_pic;
3554
3555   if (TARGET_VXWORKS_RTP)
3556     {
3557       emit_insn (gen_vxworks_load_got ());
3558       emit_use (pic_offset_table_rtx);
3559       return;
3560     }
3561
3562   /* If we haven't initialized the special PIC symbols, do so now.  */
3563   if (!pic_helper_symbol_name[0])
3564     {
3565       ASM_GENERATE_INTERNAL_LABEL (pic_helper_symbol_name, "LADDPC", 0);
3566       pic_helper_symbol = gen_rtx_SYMBOL_REF (Pmode, pic_helper_symbol_name);
3567       global_offset_table = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3568     }
3569
3570   /* If we haven't emitted the special PIC helper function, do so now unless
3571      we are requested to delay it.  */
3572   if (!delay_pic_helper && !pic_helper_emitted_p)
3573     emit_pic_helper ();
3574
3575   flag_pic = 0;
3576   if (TARGET_ARCH64)
3577     emit_insn (gen_load_pcrel_symdi (pic_offset_table_rtx, global_offset_table,
3578                                      pic_helper_symbol));
3579   else
3580     emit_insn (gen_load_pcrel_symsi (pic_offset_table_rtx, global_offset_table,
3581                                      pic_helper_symbol));
3582   flag_pic = orig_flag_pic;
3583
3584   /* Need to emit this whether or not we obey regdecls,
3585      since setjmp/longjmp can cause life info to screw up.
3586      ??? In the case where we don't obey regdecls, this is not sufficient
3587      since we may not fall out the bottom.  */
3588   emit_use (pic_offset_table_rtx);
3589 }
3590
3591 /* Emit a call instruction with the pattern given by PAT.  ADDR is the
3592    address of the call target.  */
3593
3594 void
3595 sparc_emit_call_insn (rtx pat, rtx addr)
3596 {
3597   rtx insn;
3598
3599   insn = emit_call_insn (pat);
3600
3601   /* The PIC register is live on entry to VxWorks PIC PLT entries.  */
3602   if (TARGET_VXWORKS_RTP
3603       && flag_pic
3604       && GET_CODE (addr) == SYMBOL_REF
3605       && (SYMBOL_REF_DECL (addr)
3606           ? !targetm.binds_local_p (SYMBOL_REF_DECL (addr))
3607           : !SYMBOL_REF_LOCAL_P (addr)))
3608     {
3609       use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
3610       crtl->uses_pic_offset_table = 1;
3611     }
3612 }
3613 \f
3614 /* Return 1 if RTX is a MEM which is known to be aligned to at
3615    least a DESIRED byte boundary.  */
3616
3617 int
3618 mem_min_alignment (rtx mem, int desired)
3619 {
3620   rtx addr, base, offset;
3621
3622   /* If it's not a MEM we can't accept it.  */
3623   if (GET_CODE (mem) != MEM)
3624     return 0;
3625
3626   /* Obviously...  */
3627   if (!TARGET_UNALIGNED_DOUBLES
3628       && MEM_ALIGN (mem) / BITS_PER_UNIT >= (unsigned)desired)
3629     return 1;
3630
3631   /* ??? The rest of the function predates MEM_ALIGN so
3632      there is probably a bit of redundancy.  */
3633   addr = XEXP (mem, 0);
3634   base = offset = NULL_RTX;
3635   if (GET_CODE (addr) == PLUS)
3636     {
3637       if (GET_CODE (XEXP (addr, 0)) == REG)
3638         {
3639           base = XEXP (addr, 0);
3640
3641           /* What we are saying here is that if the base
3642              REG is aligned properly, the compiler will make
3643              sure any REG based index upon it will be so
3644              as well.  */
3645           if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3646             offset = XEXP (addr, 1);
3647           else
3648             offset = const0_rtx;
3649         }
3650     }
3651   else if (GET_CODE (addr) == REG)
3652     {
3653       base = addr;
3654       offset = const0_rtx;
3655     }
3656
3657   if (base != NULL_RTX)
3658     {
3659       int regno = REGNO (base);
3660
3661       if (regno != HARD_FRAME_POINTER_REGNUM && regno != STACK_POINTER_REGNUM)
3662         {
3663           /* Check if the compiler has recorded some information
3664              about the alignment of the base REG.  If reload has
3665              completed, we already matched with proper alignments.
3666              If not running global_alloc, reload might give us
3667              unaligned pointer to local stack though.  */
3668           if (((cfun != 0
3669                 && REGNO_POINTER_ALIGN (regno) >= desired * BITS_PER_UNIT)
3670                || (optimize && reload_completed))
3671               && (INTVAL (offset) & (desired - 1)) == 0)
3672             return 1;
3673         }
3674       else
3675         {
3676           if (((INTVAL (offset) - SPARC_STACK_BIAS) & (desired - 1)) == 0)
3677             return 1;
3678         }
3679     }
3680   else if (! TARGET_UNALIGNED_DOUBLES
3681            || CONSTANT_P (addr)
3682            || GET_CODE (addr) == LO_SUM)
3683     {
3684       /* Anything else we know is properly aligned unless TARGET_UNALIGNED_DOUBLES
3685          is true, in which case we can only assume that an access is aligned if
3686          it is to a constant address, or the address involves a LO_SUM.  */
3687       return 1;
3688     }
3689
3690   /* An obviously unaligned address.  */
3691   return 0;
3692 }
3693
3694 \f
3695 /* Vectors to keep interesting information about registers where it can easily
3696    be got.  We used to use the actual mode value as the bit number, but there
3697    are more than 32 modes now.  Instead we use two tables: one indexed by
3698    hard register number, and one indexed by mode.  */
3699
3700 /* The purpose of sparc_mode_class is to shrink the range of modes so that
3701    they all fit (as bit numbers) in a 32-bit word (again).  Each real mode is
3702    mapped into one sparc_mode_class mode.  */
3703
3704 enum sparc_mode_class {
3705   S_MODE, D_MODE, T_MODE, O_MODE,
3706   SF_MODE, DF_MODE, TF_MODE, OF_MODE,
3707   CC_MODE, CCFP_MODE
3708 };
3709
3710 /* Modes for single-word and smaller quantities.  */
3711 #define S_MODES ((1 << (int) S_MODE) | (1 << (int) SF_MODE))
3712
3713 /* Modes for double-word and smaller quantities.  */
3714 #define D_MODES (S_MODES | (1 << (int) D_MODE) | (1 << DF_MODE))
3715
3716 /* Modes for quad-word and smaller quantities.  */
3717 #define T_MODES (D_MODES | (1 << (int) T_MODE) | (1 << (int) TF_MODE))
3718
3719 /* Modes for 8-word and smaller quantities.  */
3720 #define O_MODES (T_MODES | (1 << (int) O_MODE) | (1 << (int) OF_MODE))
3721
3722 /* Modes for single-float quantities.  We must allow any single word or
3723    smaller quantity.  This is because the fix/float conversion instructions
3724    take integer inputs/outputs from the float registers.  */
3725 #define SF_MODES (S_MODES)
3726
3727 /* Modes for double-float and smaller quantities.  */
3728 #define DF_MODES (S_MODES | D_MODES)
3729
3730 /* Modes for double-float only quantities.  */
3731 #define DF_MODES_NO_S ((1 << (int) D_MODE) | (1 << (int) DF_MODE))
3732
3733 /* Modes for quad-float only quantities.  */
3734 #define TF_ONLY_MODES (1 << (int) TF_MODE)
3735
3736 /* Modes for quad-float and smaller quantities.  */
3737 #define TF_MODES (DF_MODES | TF_ONLY_MODES)
3738
3739 /* Modes for quad-float and double-float quantities.  */
3740 #define TF_MODES_NO_S (DF_MODES_NO_S | TF_ONLY_MODES)
3741
3742 /* Modes for quad-float pair only quantities.  */
3743 #define OF_ONLY_MODES (1 << (int) OF_MODE)
3744
3745 /* Modes for quad-float pairs and smaller quantities.  */
3746 #define OF_MODES (TF_MODES | OF_ONLY_MODES)
3747
3748 #define OF_MODES_NO_S (TF_MODES_NO_S | OF_ONLY_MODES)
3749
3750 /* Modes for condition codes.  */
3751 #define CC_MODES (1 << (int) CC_MODE)
3752 #define CCFP_MODES (1 << (int) CCFP_MODE)
3753
3754 /* Value is 1 if register/mode pair is acceptable on sparc.
3755    The funny mixture of D and T modes is because integer operations
3756    do not specially operate on tetra quantities, so non-quad-aligned
3757    registers can hold quadword quantities (except %o4 and %i4 because
3758    they cross fixed registers).  */
3759
3760 /* This points to either the 32 bit or the 64 bit version.  */
3761 const int *hard_regno_mode_classes;
3762
3763 static const int hard_32bit_mode_classes[] = {
3764   S_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
3765   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
3766   T_MODES, S_MODES, T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES,
3767   T_MODES, S_MODES, T_MODES, S_MODES, D_MODES, S_MODES, D_MODES, S_MODES,
3768
3769   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3770   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3771   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3772   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
3773
3774   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
3775      and none can hold SFmode/SImode values.  */
3776   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3777   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3778   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3779   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3780
3781   /* %fcc[0123] */
3782   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
3783
3784   /* %icc */
3785   CC_MODES
3786 };
3787
3788 static const int hard_64bit_mode_classes[] = {
3789   D_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
3790   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
3791   T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
3792   O_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES, T_MODES, D_MODES,
3793
3794   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3795   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3796   OF_MODES, SF_MODES, DF_MODES, SF_MODES, OF_MODES, SF_MODES, DF_MODES, SF_MODES,
3797   OF_MODES, SF_MODES, DF_MODES, SF_MODES, TF_MODES, SF_MODES, DF_MODES, SF_MODES,
3798
3799   /* FP regs f32 to f63.  Only the even numbered registers actually exist,
3800      and none can hold SFmode/SImode values.  */
3801   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3802   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3803   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, OF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3804   OF_MODES_NO_S, 0, DF_MODES_NO_S, 0, TF_MODES_NO_S, 0, DF_MODES_NO_S, 0,
3805
3806   /* %fcc[0123] */
3807   CCFP_MODES, CCFP_MODES, CCFP_MODES, CCFP_MODES,
3808
3809   /* %icc */
3810   CC_MODES
3811 };
3812
3813 int sparc_mode_class [NUM_MACHINE_MODES];
3814
3815 enum reg_class sparc_regno_reg_class[FIRST_PSEUDO_REGISTER];
3816
3817 static void
3818 sparc_init_modes (void)
3819 {
3820   int i;
3821
3822   for (i = 0; i < NUM_MACHINE_MODES; i++)
3823     {
3824       switch (GET_MODE_CLASS (i))
3825         {
3826         case MODE_INT:
3827         case MODE_PARTIAL_INT:
3828         case MODE_COMPLEX_INT:
3829           if (GET_MODE_SIZE (i) <= 4)
3830             sparc_mode_class[i] = 1 << (int) S_MODE;
3831           else if (GET_MODE_SIZE (i) == 8)
3832             sparc_mode_class[i] = 1 << (int) D_MODE;
3833           else if (GET_MODE_SIZE (i) == 16)
3834             sparc_mode_class[i] = 1 << (int) T_MODE;
3835           else if (GET_MODE_SIZE (i) == 32)
3836             sparc_mode_class[i] = 1 << (int) O_MODE;
3837           else
3838             sparc_mode_class[i] = 0;
3839           break;
3840         case MODE_VECTOR_INT:
3841           if (GET_MODE_SIZE (i) <= 4)
3842             sparc_mode_class[i] = 1 << (int)SF_MODE;
3843           else if (GET_MODE_SIZE (i) == 8)
3844             sparc_mode_class[i] = 1 << (int)DF_MODE;
3845           break;
3846         case MODE_FLOAT:
3847         case MODE_COMPLEX_FLOAT:
3848           if (GET_MODE_SIZE (i) <= 4)
3849             sparc_mode_class[i] = 1 << (int) SF_MODE;
3850           else if (GET_MODE_SIZE (i) == 8)
3851             sparc_mode_class[i] = 1 << (int) DF_MODE;
3852           else if (GET_MODE_SIZE (i) == 16)
3853             sparc_mode_class[i] = 1 << (int) TF_MODE;
3854           else if (GET_MODE_SIZE (i) == 32)
3855             sparc_mode_class[i] = 1 << (int) OF_MODE;
3856           else
3857             sparc_mode_class[i] = 0;
3858           break;
3859         case MODE_CC:
3860           if (i == (int) CCFPmode || i == (int) CCFPEmode)
3861             sparc_mode_class[i] = 1 << (int) CCFP_MODE;
3862           else
3863             sparc_mode_class[i] = 1 << (int) CC_MODE;
3864           break;
3865         default:
3866           sparc_mode_class[i] = 0;
3867           break;
3868         }
3869     }
3870
3871   if (TARGET_ARCH64)
3872     hard_regno_mode_classes = hard_64bit_mode_classes;
3873   else
3874     hard_regno_mode_classes = hard_32bit_mode_classes;
3875
3876   /* Initialize the array used by REGNO_REG_CLASS.  */
3877   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3878     {
3879       if (i < 16 && TARGET_V8PLUS)
3880         sparc_regno_reg_class[i] = I64_REGS;
3881       else if (i < 32 || i == FRAME_POINTER_REGNUM)
3882         sparc_regno_reg_class[i] = GENERAL_REGS;
3883       else if (i < 64)
3884         sparc_regno_reg_class[i] = FP_REGS;
3885       else if (i < 96)
3886         sparc_regno_reg_class[i] = EXTRA_FP_REGS;
3887       else if (i < 100)
3888         sparc_regno_reg_class[i] = FPCC_REGS;
3889       else
3890         sparc_regno_reg_class[i] = NO_REGS;
3891     }
3892 }
3893 \f
3894 /* Compute the frame size required by the function.  This function is called
3895    during the reload pass and also by sparc_expand_prologue.  */
3896
3897 HOST_WIDE_INT
3898 sparc_compute_frame_size (HOST_WIDE_INT size, int leaf_function_p)
3899 {
3900   int outgoing_args_size = (crtl->outgoing_args_size
3901                             + REG_PARM_STACK_SPACE (current_function_decl));
3902   int n_regs = 0;  /* N_REGS is the number of 4-byte regs saved thus far.  */
3903   int i;
3904
3905   if (TARGET_ARCH64)
3906     {
3907       for (i = 0; i < 8; i++)
3908         if (df_regs_ever_live_p (i) && ! call_used_regs[i])
3909           n_regs += 2;
3910     }
3911   else
3912     {
3913       for (i = 0; i < 8; i += 2)
3914         if ((df_regs_ever_live_p (i) && ! call_used_regs[i])
3915             || (df_regs_ever_live_p (i+1) && ! call_used_regs[i+1]))
3916           n_regs += 2;
3917     }
3918
3919   for (i = 32; i < (TARGET_V9 ? 96 : 64); i += 2)
3920     if ((df_regs_ever_live_p (i) && ! call_used_regs[i])
3921         || (df_regs_ever_live_p (i+1) && ! call_used_regs[i+1]))
3922       n_regs += 2;
3923
3924   /* Set up values for use in prologue and epilogue.  */
3925   num_gfregs = n_regs;
3926
3927   if (leaf_function_p
3928       && n_regs == 0
3929       && size == 0
3930       && crtl->outgoing_args_size == 0)
3931     actual_fsize = apparent_fsize = 0;
3932   else
3933     {
3934       /* We subtract STARTING_FRAME_OFFSET, remember it's negative.  */
3935       apparent_fsize = (size - STARTING_FRAME_OFFSET + 7) & -8;
3936       apparent_fsize += n_regs * 4;
3937       actual_fsize = apparent_fsize + ((outgoing_args_size + 7) & -8);
3938     }
3939
3940   /* Make sure nothing can clobber our register windows.
3941      If a SAVE must be done, or there is a stack-local variable,
3942      the register window area must be allocated.  */
3943   if (! leaf_function_p || size > 0)
3944     actual_fsize += FIRST_PARM_OFFSET (current_function_decl);
3945
3946   return SPARC_STACK_ALIGN (actual_fsize);
3947 }
3948
3949 /* Output any necessary .register pseudo-ops.  */
3950
3951 void
3952 sparc_output_scratch_registers (FILE *file ATTRIBUTE_UNUSED)
3953 {
3954 #ifdef HAVE_AS_REGISTER_PSEUDO_OP
3955   int i;
3956
3957   if (TARGET_ARCH32)
3958     return;
3959
3960   /* Check if %g[2367] were used without
3961      .register being printed for them already.  */
3962   for (i = 2; i < 8; i++)
3963     {
3964       if (df_regs_ever_live_p (i)
3965           && ! sparc_hard_reg_printed [i])
3966         {
3967           sparc_hard_reg_printed [i] = 1;
3968           /* %g7 is used as TLS base register, use #ignore
3969              for it instead of #scratch.  */
3970           fprintf (file, "\t.register\t%%g%d, #%s\n", i,
3971                    i == 7 ? "ignore" : "scratch");
3972         }
3973       if (i == 3) i = 5;
3974     }
3975 #endif
3976 }
3977
3978 /* Save/restore call-saved registers from LOW to HIGH at BASE+OFFSET
3979    as needed.  LOW should be double-word aligned for 32-bit registers.
3980    Return the new OFFSET.  */
3981
3982 #define SORR_SAVE    0
3983 #define SORR_RESTORE 1
3984
3985 static int
3986 save_or_restore_regs (int low, int high, rtx base, int offset, int action)
3987 {
3988   rtx mem, insn;
3989   int i;
3990
3991   if (TARGET_ARCH64 && high <= 32)
3992     {
3993       for (i = low; i < high; i++)
3994         {
3995           if (df_regs_ever_live_p (i) && ! call_used_regs[i])
3996             {
3997               mem = gen_rtx_MEM (DImode, plus_constant (base, offset));
3998               set_mem_alias_set (mem, sparc_sr_alias_set);
3999               if (action == SORR_SAVE)
4000                 {
4001                   insn = emit_move_insn (mem, gen_rtx_REG (DImode, i));
4002                   RTX_FRAME_RELATED_P (insn) = 1;
4003                 }
4004               else  /* action == SORR_RESTORE */
4005                 emit_move_insn (gen_rtx_REG (DImode, i), mem);
4006               offset += 8;
4007             }
4008         }
4009     }
4010   else
4011     {
4012       for (i = low; i < high; i += 2)
4013         {
4014           bool reg0 = df_regs_ever_live_p (i) && ! call_used_regs[i];
4015           bool reg1 = df_regs_ever_live_p (i+1) && ! call_used_regs[i+1];
4016           enum machine_mode mode;
4017           int regno;
4018
4019           if (reg0 && reg1)
4020             {
4021               mode = i < 32 ? DImode : DFmode;
4022               regno = i;
4023             }
4024           else if (reg0)
4025             {
4026               mode = i < 32 ? SImode : SFmode;
4027               regno = i;
4028             }
4029           else if (reg1)
4030             {
4031               mode = i < 32 ? SImode : SFmode;
4032               regno = i + 1;
4033               offset += 4;
4034             }
4035           else
4036             continue;
4037
4038           mem = gen_rtx_MEM (mode, plus_constant (base, offset));
4039           set_mem_alias_set (mem, sparc_sr_alias_set);
4040           if (action == SORR_SAVE)
4041             {
4042               insn = emit_move_insn (mem, gen_rtx_REG (mode, regno));
4043               RTX_FRAME_RELATED_P (insn) = 1;
4044             }
4045           else  /* action == SORR_RESTORE */
4046             emit_move_insn (gen_rtx_REG (mode, regno), mem);
4047
4048           /* Always preserve double-word alignment.  */
4049           offset = (offset + 7) & -8;
4050         }
4051     }
4052
4053   return offset;
4054 }
4055
4056 /* Emit code to save call-saved registers.  */
4057
4058 static void
4059 emit_save_or_restore_regs (int action)
4060 {
4061   HOST_WIDE_INT offset;
4062   rtx base;
4063
4064   offset = frame_base_offset - apparent_fsize;
4065
4066   if (offset < -4096 || offset + num_gfregs * 4 > 4095)
4067     {
4068       /* ??? This might be optimized a little as %g1 might already have a
4069          value close enough that a single add insn will do.  */
4070       /* ??? Although, all of this is probably only a temporary fix
4071          because if %g1 can hold a function result, then
4072          sparc_expand_epilogue will lose (the result will be
4073          clobbered).  */
4074       base = gen_rtx_REG (Pmode, 1);
4075       emit_move_insn (base, GEN_INT (offset));
4076       emit_insn (gen_rtx_SET (VOIDmode,
4077                               base,
4078                               gen_rtx_PLUS (Pmode, frame_base_reg, base)));
4079       offset = 0;
4080     }
4081   else
4082     base = frame_base_reg;
4083
4084   offset = save_or_restore_regs (0, 8, base, offset, action);
4085   save_or_restore_regs (32, TARGET_V9 ? 96 : 64, base, offset, action);
4086 }
4087
4088 /* Generate a save_register_window insn.  */
4089
4090 static rtx
4091 gen_save_register_window (rtx increment)
4092 {
4093   if (TARGET_ARCH64)
4094     return gen_save_register_windowdi (increment);
4095   else
4096     return gen_save_register_windowsi (increment);
4097 }
4098
4099 /* Generate an increment for the stack pointer.  */
4100
4101 static rtx
4102 gen_stack_pointer_inc (rtx increment)
4103 {
4104   return gen_rtx_SET (VOIDmode,
4105                       stack_pointer_rtx,
4106                       gen_rtx_PLUS (Pmode,
4107                                     stack_pointer_rtx,
4108                                     increment));
4109 }
4110
4111 /* Generate a decrement for the stack pointer.  */
4112
4113 static rtx
4114 gen_stack_pointer_dec (rtx decrement)
4115 {
4116   return gen_rtx_SET (VOIDmode,
4117                       stack_pointer_rtx,
4118                       gen_rtx_MINUS (Pmode,
4119                                      stack_pointer_rtx,
4120                                      decrement));
4121 }
4122
4123 /* Expand the function prologue.  The prologue is responsible for reserving
4124    storage for the frame, saving the call-saved registers and loading the
4125    PIC register if needed.  */
4126
4127 void
4128 sparc_expand_prologue (void)
4129 {
4130   rtx insn;
4131   int i;
4132
4133   /* Compute a snapshot of current_function_uses_only_leaf_regs.  Relying
4134      on the final value of the flag means deferring the prologue/epilogue
4135      expansion until just before the second scheduling pass, which is too
4136      late to emit multiple epilogues or return insns.
4137
4138      Of course we are making the assumption that the value of the flag
4139      will not change between now and its final value.  Of the three parts
4140      of the formula, only the last one can reasonably vary.  Let's take a
4141      closer look, after assuming that the first two ones are set to true
4142      (otherwise the last value is effectively silenced).
4143
4144      If only_leaf_regs_used returns false, the global predicate will also
4145      be false so the actual frame size calculated below will be positive.
4146      As a consequence, the save_register_window insn will be emitted in
4147      the instruction stream; now this insn explicitly references %fp
4148      which is not a leaf register so only_leaf_regs_used will always
4149      return false subsequently.
4150
4151      If only_leaf_regs_used returns true, we hope that the subsequent
4152      optimization passes won't cause non-leaf registers to pop up.  For
4153      example, the regrename pass has special provisions to not rename to
4154      non-leaf registers in a leaf function.  */
4155   sparc_leaf_function_p
4156     = optimize > 0 && leaf_function_p () && only_leaf_regs_used ();
4157
4158   /* Need to use actual_fsize, since we are also allocating
4159      space for our callee (and our own register save area).  */
4160   actual_fsize
4161     = sparc_compute_frame_size (get_frame_size(), sparc_leaf_function_p);
4162
4163   /* Advertise that the data calculated just above are now valid.  */
4164   sparc_prologue_data_valid_p = true;
4165
4166   if (sparc_leaf_function_p)
4167     {
4168       frame_base_reg = stack_pointer_rtx;
4169       frame_base_offset = actual_fsize + SPARC_STACK_BIAS;
4170     }
4171   else
4172     {
4173       frame_base_reg = hard_frame_pointer_rtx;
4174       frame_base_offset = SPARC_STACK_BIAS;
4175     }
4176
4177   if (actual_fsize == 0)
4178     /* do nothing.  */ ;
4179   else if (sparc_leaf_function_p)
4180     {
4181       if (actual_fsize <= 4096)
4182         insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-actual_fsize)));
4183       else if (actual_fsize <= 8192)
4184         {
4185           insn = emit_insn (gen_stack_pointer_inc (GEN_INT (-4096)));
4186           /* %sp is still the CFA register.  */
4187           RTX_FRAME_RELATED_P (insn) = 1;
4188           insn
4189             = emit_insn (gen_stack_pointer_inc (GEN_INT (4096-actual_fsize)));
4190         }
4191       else
4192         {
4193           rtx reg = gen_rtx_REG (Pmode, 1);
4194           emit_move_insn (reg, GEN_INT (-actual_fsize));
4195           insn = emit_insn (gen_stack_pointer_inc (reg));
4196           add_reg_note (insn, REG_FRAME_RELATED_EXPR,
4197                         gen_stack_pointer_inc (GEN_INT (-actual_fsize)));
4198         }
4199
4200       RTX_FRAME_RELATED_P (insn) = 1;
4201     }
4202   else
4203     {
4204       if (actual_fsize <= 4096)
4205         insn = emit_insn (gen_save_register_window (GEN_INT (-actual_fsize)));
4206       else if (actual_fsize <= 8192)
4207         {
4208           insn = emit_insn (gen_save_register_window (GEN_INT (-4096)));
4209           /* %sp is not the CFA register anymore.  */
4210           emit_insn (gen_stack_pointer_inc (GEN_INT (4096-actual_fsize)));
4211         }
4212       else
4213         {
4214           rtx reg = gen_rtx_REG (Pmode, 1);
4215           emit_move_insn (reg, GEN_INT (-actual_fsize));
4216           insn = emit_insn (gen_save_register_window (reg));
4217         }
4218
4219       RTX_FRAME_RELATED_P (insn) = 1;
4220       for (i=0; i < XVECLEN (PATTERN (insn), 0); i++)
4221         RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, i)) = 1;
4222     }
4223
4224   if (num_gfregs)
4225     emit_save_or_restore_regs (SORR_SAVE);
4226
4227   /* Load the PIC register if needed.  */
4228   if (flag_pic && crtl->uses_pic_offset_table)
4229     load_pic_register (false);
4230 }
4231
4232 /* This function generates the assembly code for function entry, which boils
4233    down to emitting the necessary .register directives.  */
4234
4235 static void
4236 sparc_asm_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
4237 {
4238   /* Check that the assumption we made in sparc_expand_prologue is valid.  */
4239   gcc_assert (sparc_leaf_function_p == current_function_uses_only_leaf_regs);
4240
4241   sparc_output_scratch_registers (file);
4242 }
4243
4244 /* Expand the function epilogue, either normal or part of a sibcall.
4245    We emit all the instructions except the return or the call.  */
4246
4247 void
4248 sparc_expand_epilogue (void)
4249 {
4250   if (num_gfregs)
4251     emit_save_or_restore_regs (SORR_RESTORE);
4252
4253   if (actual_fsize == 0)
4254     /* do nothing.  */ ;
4255   else if (sparc_leaf_function_p)
4256     {
4257       if (actual_fsize <= 4096)
4258         emit_insn (gen_stack_pointer_dec (GEN_INT (- actual_fsize)));
4259       else if (actual_fsize <= 8192)
4260         {
4261           emit_insn (gen_stack_pointer_dec (GEN_INT (-4096)));
4262           emit_insn (gen_stack_pointer_dec (GEN_INT (4096 - actual_fsize)));
4263         }
4264       else
4265         {
4266           rtx reg = gen_rtx_REG (Pmode, 1);
4267           emit_move_insn (reg, GEN_INT (-actual_fsize));
4268           emit_insn (gen_stack_pointer_dec (reg));
4269         }
4270     }
4271 }
4272
4273 /* Return true if it is appropriate to emit `return' instructions in the
4274    body of a function.  */
4275
4276 bool
4277 sparc_can_use_return_insn_p (void)
4278 {
4279   return sparc_prologue_data_valid_p
4280          && (actual_fsize == 0 || !sparc_leaf_function_p);
4281 }
4282
4283 /* This function generates the assembly code for function exit.  */
4284
4285 static void
4286 sparc_asm_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
4287 {
4288   /* If code does not drop into the epilogue, we have to still output
4289      a dummy nop for the sake of sane backtraces.  Otherwise, if the
4290      last two instructions of a function were "call foo; dslot;" this
4291      can make the return PC of foo (i.e. address of call instruction
4292      plus 8) point to the first instruction in the next function.  */
4293
4294   rtx insn, last_real_insn;
4295
4296   insn = get_last_insn ();
4297
4298   last_real_insn = prev_real_insn (insn);
4299   if (last_real_insn
4300       && GET_CODE (last_real_insn) == INSN
4301       && GET_CODE (PATTERN (last_real_insn)) == SEQUENCE)
4302     last_real_insn = XVECEXP (PATTERN (last_real_insn), 0, 0);
4303
4304   if (last_real_insn && GET_CODE (last_real_insn) == CALL_INSN)
4305     fputs("\tnop\n", file);
4306
4307   sparc_output_deferred_case_vectors ();
4308 }
4309
4310 /* Output a 'restore' instruction.  */
4311
4312 static void
4313 output_restore (rtx pat)
4314 {
4315   rtx operands[3];
4316
4317   if (! pat)
4318     {
4319       fputs ("\t restore\n", asm_out_file);
4320       return;
4321     }
4322
4323   gcc_assert (GET_CODE (pat) == SET);
4324
4325   operands[0] = SET_DEST (pat);
4326   pat = SET_SRC (pat);
4327
4328   switch (GET_CODE (pat))
4329     {
4330       case PLUS:
4331         operands[1] = XEXP (pat, 0);
4332         operands[2] = XEXP (pat, 1);
4333         output_asm_insn (" restore %r1, %2, %Y0", operands);
4334         break;
4335       case LO_SUM:
4336         operands[1] = XEXP (pat, 0);
4337         operands[2] = XEXP (pat, 1);
4338         output_asm_insn (" restore %r1, %%lo(%a2), %Y0", operands);
4339         break;
4340       case ASHIFT:
4341         operands[1] = XEXP (pat, 0);
4342         gcc_assert (XEXP (pat, 1) == const1_rtx);
4343         output_asm_insn (" restore %r1, %r1, %Y0", operands);
4344         break;
4345       default:
4346         operands[1] = pat;
4347         output_asm_insn (" restore %%g0, %1, %Y0", operands);
4348         break;
4349     }
4350 }
4351
4352 /* Output a return.  */
4353
4354 const char *
4355 output_return (rtx insn)
4356 {
4357   if (sparc_leaf_function_p)
4358     {
4359       /* This is a leaf function so we don't have to bother restoring the
4360          register window, which frees us from dealing with the convoluted
4361          semantics of restore/return.  We simply output the jump to the
4362          return address and the insn in the delay slot (if any).  */
4363
4364       gcc_assert (! crtl->calls_eh_return);
4365
4366       return "jmp\t%%o7+%)%#";
4367     }
4368   else
4369     {
4370       /* This is a regular function so we have to restore the register window.
4371          We may have a pending insn for the delay slot, which will be either
4372          combined with the 'restore' instruction or put in the delay slot of
4373          the 'return' instruction.  */
4374
4375       if (crtl->calls_eh_return)
4376         {
4377           /* If the function uses __builtin_eh_return, the eh_return
4378              machinery occupies the delay slot.  */
4379           gcc_assert (! final_sequence);
4380
4381           if (! flag_delayed_branch)
4382             fputs ("\tadd\t%fp, %g1, %fp\n", asm_out_file);
4383
4384           if (TARGET_V9)
4385             fputs ("\treturn\t%i7+8\n", asm_out_file);
4386           else
4387             fputs ("\trestore\n\tjmp\t%o7+8\n", asm_out_file);
4388
4389           if (flag_delayed_branch)
4390             fputs ("\t add\t%sp, %g1, %sp\n", asm_out_file);
4391           else
4392             fputs ("\t nop\n", asm_out_file);
4393         }
4394       else if (final_sequence)
4395         {
4396           rtx delay, pat;
4397
4398           delay = NEXT_INSN (insn);
4399           gcc_assert (delay);
4400
4401           pat = PATTERN (delay);
4402
4403           if (TARGET_V9 && ! epilogue_renumber (&pat, 1))
4404             {
4405               epilogue_renumber (&pat, 0);
4406               return "return\t%%i7+%)%#";
4407             }
4408           else
4409             {
4410               output_asm_insn ("jmp\t%%i7+%)", NULL);
4411               output_restore (pat);
4412               PATTERN (delay) = gen_blockage ();
4413               INSN_CODE (delay) = -1;
4414             }
4415         }
4416       else
4417         {
4418           /* The delay slot is empty.  */
4419           if (TARGET_V9)
4420             return "return\t%%i7+%)\n\t nop";
4421           else if (flag_delayed_branch)
4422             return "jmp\t%%i7+%)\n\t restore";
4423           else
4424             return "restore\n\tjmp\t%%o7+%)\n\t nop";
4425         }
4426     }
4427
4428   return "";
4429 }
4430
4431 /* Output a sibling call.  */
4432
4433 const char *
4434 output_sibcall (rtx insn, rtx call_operand)
4435 {
4436   rtx operands[1];
4437
4438   gcc_assert (flag_delayed_branch);
4439
4440   operands[0] = call_operand;
4441
4442   if (sparc_leaf_function_p)
4443     {
4444       /* This is a leaf function so we don't have to bother restoring the
4445          register window.  We simply output the jump to the function and
4446          the insn in the delay slot (if any).  */
4447
4448       gcc_assert (!(LEAF_SIBCALL_SLOT_RESERVED_P && final_sequence));
4449
4450       if (final_sequence)
4451         output_asm_insn ("sethi\t%%hi(%a0), %%g1\n\tjmp\t%%g1 + %%lo(%a0)%#",
4452                          operands);
4453       else
4454         /* Use or with rs2 %%g0 instead of mov, so that as/ld can optimize
4455            it into branch if possible.  */
4456         output_asm_insn ("or\t%%o7, %%g0, %%g1\n\tcall\t%a0, 0\n\t or\t%%g1, %%g0, %%o7",
4457                          operands);
4458     }
4459   else
4460     {
4461       /* This is a regular function so we have to restore the register window.
4462          We may have a pending insn for the delay slot, which will be combined
4463          with the 'restore' instruction.  */
4464
4465       output_asm_insn ("call\t%a0, 0", operands);
4466
4467       if (final_sequence)
4468         {
4469           rtx delay = NEXT_INSN (insn);
4470           gcc_assert (delay);
4471
4472           output_restore (PATTERN (delay));
4473
4474           PATTERN (delay) = gen_blockage ();
4475           INSN_CODE (delay) = -1;
4476         }
4477       else
4478         output_restore (NULL_RTX);
4479     }
4480
4481   return "";
4482 }
4483 \f
4484 /* Functions for handling argument passing.
4485
4486    For 32-bit, the first 6 args are normally in registers and the rest are
4487    pushed.  Any arg that starts within the first 6 words is at least
4488    partially passed in a register unless its data type forbids.
4489
4490    For 64-bit, the argument registers are laid out as an array of 16 elements
4491    and arguments are added sequentially.  The first 6 int args and up to the
4492    first 16 fp args (depending on size) are passed in regs.
4493
4494    Slot    Stack   Integral   Float   Float in structure   Double   Long Double
4495    ----    -----   --------   -----   ------------------   ------   -----------
4496     15   [SP+248]              %f31       %f30,%f31         %d30
4497     14   [SP+240]              %f29       %f28,%f29         %d28       %q28
4498     13   [SP+232]              %f27       %f26,%f27         %d26
4499     12   [SP+224]              %f25       %f24,%f25         %d24       %q24
4500     11   [SP+216]              %f23       %f22,%f23         %d22
4501     10   [SP+208]              %f21       %f20,%f21         %d20       %q20
4502      9   [SP+200]              %f19       %f18,%f19         %d18
4503      8   [SP+192]              %f17       %f16,%f17         %d16       %q16
4504      7   [SP+184]              %f15       %f14,%f15         %d14
4505      6   [SP+176]              %f13       %f12,%f13         %d12       %q12
4506      5   [SP+168]     %o5      %f11       %f10,%f11         %d10
4507      4   [SP+160]     %o4       %f9        %f8,%f9           %d8        %q8
4508      3   [SP+152]     %o3       %f7        %f6,%f7           %d6
4509      2   [SP+144]     %o2       %f5        %f4,%f5           %d4        %q4
4510      1   [SP+136]     %o1       %f3        %f2,%f3           %d2
4511      0   [SP+128]     %o0       %f1        %f0,%f1           %d0        %q0
4512
4513    Here SP = %sp if -mno-stack-bias or %sp+stack_bias otherwise.
4514
4515    Integral arguments are always passed as 64-bit quantities appropriately
4516    extended.
4517
4518    Passing of floating point values is handled as follows.
4519    If a prototype is in scope:
4520      If the value is in a named argument (i.e. not a stdarg function or a
4521      value not part of the `...') then the value is passed in the appropriate
4522      fp reg.
4523      If the value is part of the `...' and is passed in one of the first 6
4524      slots then the value is passed in the appropriate int reg.
4525      If the value is part of the `...' and is not passed in one of the first 6
4526      slots then the value is passed in memory.
4527    If a prototype is not in scope:
4528      If the value is one of the first 6 arguments the value is passed in the
4529      appropriate integer reg and the appropriate fp reg.
4530      If the value is not one of the first 6 arguments the value is passed in
4531      the appropriate fp reg and in memory.
4532
4533
4534    Summary of the calling conventions implemented by GCC on SPARC:
4535
4536    32-bit ABI:
4537                                 size      argument     return value
4538
4539       small integer              <4       int. reg.      int. reg.
4540       word                        4       int. reg.      int. reg.
4541       double word                 8       int. reg.      int. reg.
4542
4543       _Complex small integer     <8       int. reg.      int. reg.
4544       _Complex word               8       int. reg.      int. reg.
4545       _Complex double word       16        memory        int. reg.
4546
4547       vector integer            <=8       int. reg.       FP reg.
4548       vector integer             >8        memory         memory
4549
4550       float                       4       int. reg.       FP reg.
4551       double                      8       int. reg.       FP reg.
4552       long double                16        memory         memory
4553
4554       _Complex float              8        memory         FP reg.
4555       _Complex double            16        memory         FP reg.
4556       _Complex long double       32        memory         FP reg.
4557
4558       vector float              any        memory         memory
4559
4560       aggregate                 any        memory         memory
4561
4562
4563
4564     64-bit ABI:
4565                                 size      argument     return value
4566
4567       small integer              <8       int. reg.      int. reg.
4568       word                        8       int. reg.      int. reg.
4569       double word                16       int. reg.      int. reg.
4570
4571       _Complex small integer    <16       int. reg.      int. reg.
4572       _Complex word              16       int. reg.      int. reg.
4573       _Complex double word       32        memory        int. reg.
4574
4575       vector integer           <=16        FP reg.        FP reg.
4576       vector integer       16<s<=32        memory         FP reg.
4577       vector integer            >32        memory         memory
4578
4579       float                       4        FP reg.        FP reg.
4580       double                      8        FP reg.        FP reg.
4581       long double                16        FP reg.        FP reg.
4582
4583       _Complex float              8        FP reg.        FP reg.
4584       _Complex double            16        FP reg.        FP reg.
4585       _Complex long double       32        memory         FP reg.
4586
4587       vector float             <=16        FP reg.        FP reg.
4588       vector float         16<s<=32        memory         FP reg.
4589       vector float              >32        memory         memory
4590
4591       aggregate                <=16         reg.           reg.
4592       aggregate            16<s<=32        memory          reg.
4593       aggregate                 >32        memory         memory
4594
4595
4596
4597 Note #1: complex floating-point types follow the extended SPARC ABIs as
4598 implemented by the Sun compiler.
4599
4600 Note #2: integral vector types follow the scalar floating-point types
4601 conventions to match what is implemented by the Sun VIS SDK.
4602
4603 Note #3: floating-point vector types follow the aggregate types
4604 conventions.  */
4605
4606
4607 /* Maximum number of int regs for args.  */
4608 #define SPARC_INT_ARG_MAX 6
4609 /* Maximum number of fp regs for args.  */
4610 #define SPARC_FP_ARG_MAX 16
4611
4612 #define ROUND_ADVANCE(SIZE) (((SIZE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
4613
4614 /* Handle the INIT_CUMULATIVE_ARGS macro.
4615    Initialize a variable CUM of type CUMULATIVE_ARGS
4616    for a call to a function whose data type is FNTYPE.
4617    For a library call, FNTYPE is 0.  */
4618
4619 void
4620 init_cumulative_args (struct sparc_args *cum, tree fntype,
4621                       rtx libname ATTRIBUTE_UNUSED,
4622                       tree fndecl ATTRIBUTE_UNUSED)
4623 {
4624   cum->words = 0;
4625   cum->prototype_p = fntype && TYPE_ARG_TYPES (fntype);
4626   cum->libcall_p = fntype == 0;
4627 }
4628
4629 /* Handle the TARGET_PROMOTE_PROTOTYPES target hook.
4630    When a prototype says `char' or `short', really pass an `int'.  */
4631
4632 static bool
4633 sparc_promote_prototypes (const_tree fntype ATTRIBUTE_UNUSED)
4634 {
4635   return TARGET_ARCH32 ? true : false;
4636 }
4637
4638 /* Handle promotion of pointer and integer arguments.  */
4639
4640 static enum machine_mode
4641 sparc_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
4642                              enum machine_mode mode,
4643                              int *punsignedp ATTRIBUTE_UNUSED,
4644                              const_tree fntype ATTRIBUTE_UNUSED,
4645                              int for_return ATTRIBUTE_UNUSED)
4646 {
4647   if (POINTER_TYPE_P (type))
4648     {
4649       *punsignedp = POINTERS_EXTEND_UNSIGNED;
4650       return Pmode;
4651     }
4652
4653   /* For TARGET_ARCH64 we need this, as we don't have instructions
4654      for arithmetic operations which do zero/sign extension at the same time,
4655      so without this we end up with a srl/sra after every assignment to an
4656      user variable,  which means very very bad code.  */
4657
4658   if (TARGET_ARCH64
4659       && GET_MODE_CLASS (mode) == MODE_INT
4660       && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
4661     return word_mode;
4662
4663   return mode;
4664 }
4665
4666
4667
4668 /* Handle the TARGET_STRICT_ARGUMENT_NAMING target hook.  */
4669
4670 static bool
4671 sparc_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
4672 {
4673   return TARGET_ARCH64 ? true : false;
4674 }
4675
4676 /* Scan the record type TYPE and return the following predicates:
4677     - INTREGS_P: the record contains at least one field or sub-field
4678       that is eligible for promotion in integer registers.
4679     - FP_REGS_P: the record contains at least one field or sub-field
4680       that is eligible for promotion in floating-point registers.
4681     - PACKED_P: the record contains at least one field that is packed.
4682
4683    Sub-fields are not taken into account for the PACKED_P predicate.  */
4684
4685 static void
4686 scan_record_type (tree type, int *intregs_p, int *fpregs_p, int *packed_p)
4687 {
4688   tree field;
4689
4690   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4691     {
4692       if (TREE_CODE (field) == FIELD_DECL)
4693         {
4694           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
4695             scan_record_type (TREE_TYPE (field), intregs_p, fpregs_p, 0);
4696           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
4697                    || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
4698                   && TARGET_FPU)
4699             *fpregs_p = 1;
4700           else
4701             *intregs_p = 1;
4702
4703           if (packed_p && DECL_PACKED (field))
4704             *packed_p = 1;
4705         }
4706     }
4707 }
4708
4709 /* Compute the slot number to pass an argument in.
4710    Return the slot number or -1 if passing on the stack.
4711
4712    CUM is a variable of type CUMULATIVE_ARGS which gives info about
4713     the preceding args and about the function being called.
4714    MODE is the argument's machine mode.
4715    TYPE is the data type of the argument (as a tree).
4716     This is null for libcalls where that information may
4717     not be available.
4718    NAMED is nonzero if this argument is a named parameter
4719     (otherwise it is an extra parameter matching an ellipsis).
4720    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.
4721    *PREGNO records the register number to use if scalar type.
4722    *PPADDING records the amount of padding needed in words.  */
4723
4724 static int
4725 function_arg_slotno (const struct sparc_args *cum, enum machine_mode mode,
4726                      tree type, int named, int incoming_p,
4727                      int *pregno, int *ppadding)
4728 {
4729   int regbase = (incoming_p
4730                  ? SPARC_INCOMING_INT_ARG_FIRST
4731                  : SPARC_OUTGOING_INT_ARG_FIRST);
4732   int slotno = cum->words;
4733   enum mode_class mclass;
4734   int regno;
4735
4736   *ppadding = 0;
4737
4738   if (type && TREE_ADDRESSABLE (type))
4739     return -1;
4740
4741   if (TARGET_ARCH32
4742       && mode == BLKmode
4743       && type
4744       && TYPE_ALIGN (type) % PARM_BOUNDARY != 0)
4745     return -1;
4746
4747   /* For SPARC64, objects requiring 16-byte alignment get it.  */
4748   if (TARGET_ARCH64
4749       && (type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode)) >= 128
4750       && (slotno & 1) != 0)
4751     slotno++, *ppadding = 1;
4752
4753   mclass = GET_MODE_CLASS (mode);
4754   if (type && TREE_CODE (type) == VECTOR_TYPE)
4755     {
4756       /* Vector types deserve special treatment because they are
4757          polymorphic wrt their mode, depending upon whether VIS
4758          instructions are enabled.  */
4759       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
4760         {
4761           /* The SPARC port defines no floating-point vector modes.  */
4762           gcc_assert (mode == BLKmode);
4763         }
4764       else
4765         {
4766           /* Integral vector types should either have a vector
4767              mode or an integral mode, because we are guaranteed
4768              by pass_by_reference that their size is not greater
4769              than 16 bytes and TImode is 16-byte wide.  */
4770           gcc_assert (mode != BLKmode);
4771
4772           /* Vector integers are handled like floats according to
4773              the Sun VIS SDK.  */
4774           mclass = MODE_FLOAT;
4775         }
4776     }
4777
4778   switch (mclass)
4779     {
4780     case MODE_FLOAT:
4781     case MODE_COMPLEX_FLOAT:
4782     case MODE_VECTOR_INT:
4783       if (TARGET_ARCH64 && TARGET_FPU && named)
4784         {
4785           if (slotno >= SPARC_FP_ARG_MAX)
4786             return -1;
4787           regno = SPARC_FP_ARG_FIRST + slotno * 2;
4788           /* Arguments filling only one single FP register are
4789              right-justified in the outer double FP register.  */
4790           if (GET_MODE_SIZE (mode) <= 4)
4791             regno++;
4792           break;
4793         }
4794       /* fallthrough */
4795
4796     case MODE_INT:
4797     case MODE_COMPLEX_INT:
4798       if (slotno >= SPARC_INT_ARG_MAX)
4799         return -1;
4800       regno = regbase + slotno;
4801       break;
4802
4803     case MODE_RANDOM:
4804       if (mode == VOIDmode)
4805         /* MODE is VOIDmode when generating the actual call.  */
4806         return -1;
4807
4808       gcc_assert (mode == BLKmode);
4809
4810       if (TARGET_ARCH32
4811           || !type
4812           || (TREE_CODE (type) != VECTOR_TYPE
4813               && TREE_CODE (type) != RECORD_TYPE))
4814         {
4815           if (slotno >= SPARC_INT_ARG_MAX)
4816             return -1;
4817           regno = regbase + slotno;
4818         }
4819       else  /* TARGET_ARCH64 && type */
4820         {
4821           int intregs_p = 0, fpregs_p = 0, packed_p = 0;
4822
4823           /* First see what kinds of registers we would need.  */
4824           if (TREE_CODE (type) == VECTOR_TYPE)
4825             fpregs_p = 1;
4826           else
4827             scan_record_type (type, &intregs_p, &fpregs_p, &packed_p);
4828
4829           /* The ABI obviously doesn't specify how packed structures
4830              are passed.  These are defined to be passed in int regs
4831              if possible, otherwise memory.  */
4832           if (packed_p || !named)
4833             fpregs_p = 0, intregs_p = 1;
4834
4835           /* If all arg slots are filled, then must pass on stack.  */
4836           if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
4837             return -1;
4838
4839           /* If there are only int args and all int arg slots are filled,
4840              then must pass on stack.  */
4841           if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
4842             return -1;
4843
4844           /* Note that even if all int arg slots are filled, fp members may
4845              still be passed in regs if such regs are available.
4846              *PREGNO isn't set because there may be more than one, it's up
4847              to the caller to compute them.  */
4848           return slotno;
4849         }
4850       break;
4851
4852     default :
4853       gcc_unreachable ();
4854     }
4855
4856   *pregno = regno;
4857   return slotno;
4858 }
4859
4860 /* Handle recursive register counting for structure field layout.  */
4861
4862 struct function_arg_record_value_parms
4863 {
4864   rtx ret;              /* return expression being built.  */
4865   int slotno;           /* slot number of the argument.  */
4866   int named;            /* whether the argument is named.  */
4867   int regbase;          /* regno of the base register.  */
4868   int stack;            /* 1 if part of the argument is on the stack.  */
4869   int intoffset;        /* offset of the first pending integer field.  */
4870   unsigned int nregs;   /* number of words passed in registers.  */
4871 };
4872
4873 static void function_arg_record_value_3
4874  (HOST_WIDE_INT, struct function_arg_record_value_parms *);
4875 static void function_arg_record_value_2
4876  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
4877 static void function_arg_record_value_1
4878  (const_tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
4879 static rtx function_arg_record_value (const_tree, enum machine_mode, int, int, int);
4880 static rtx function_arg_union_value (int, enum machine_mode, int, int);
4881
4882 /* A subroutine of function_arg_record_value.  Traverse the structure
4883    recursively and determine how many registers will be required.  */
4884
4885 static void
4886 function_arg_record_value_1 (const_tree type, HOST_WIDE_INT startbitpos,
4887                              struct function_arg_record_value_parms *parms,
4888                              bool packed_p)
4889 {
4890   tree field;
4891
4892   /* We need to compute how many registers are needed so we can
4893      allocate the PARALLEL but before we can do that we need to know
4894      whether there are any packed fields.  The ABI obviously doesn't
4895      specify how structures are passed in this case, so they are
4896      defined to be passed in int regs if possible, otherwise memory,
4897      regardless of whether there are fp values present.  */
4898
4899   if (! packed_p)
4900     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4901       {
4902         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
4903           {
4904             packed_p = true;
4905             break;
4906           }
4907       }
4908
4909   /* Compute how many registers we need.  */
4910   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4911     {
4912       if (TREE_CODE (field) == FIELD_DECL)
4913         {
4914           HOST_WIDE_INT bitpos = startbitpos;
4915
4916           if (DECL_SIZE (field) != 0)
4917             {
4918               if (integer_zerop (DECL_SIZE (field)))
4919                 continue;
4920
4921               if (host_integerp (bit_position (field), 1))
4922                 bitpos += int_bit_position (field);
4923             }
4924
4925           /* ??? FIXME: else assume zero offset.  */
4926
4927           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
4928             function_arg_record_value_1 (TREE_TYPE (field),
4929                                          bitpos,
4930                                          parms,
4931                                          packed_p);
4932           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
4933                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
4934                    && TARGET_FPU
4935                    && parms->named
4936                    && ! packed_p)
4937             {
4938               if (parms->intoffset != -1)
4939                 {
4940                   unsigned int startbit, endbit;
4941                   int intslots, this_slotno;
4942
4943                   startbit = parms->intoffset & -BITS_PER_WORD;
4944                   endbit   = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
4945
4946                   intslots = (endbit - startbit) / BITS_PER_WORD;
4947                   this_slotno = parms->slotno + parms->intoffset
4948                     / BITS_PER_WORD;
4949
4950                   if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
4951                     {
4952                       intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
4953                       /* We need to pass this field on the stack.  */
4954                       parms->stack = 1;
4955                     }
4956
4957                   parms->nregs += intslots;
4958                   parms->intoffset = -1;
4959                 }
4960
4961               /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
4962                  If it wasn't true we wouldn't be here.  */
4963               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
4964                   && DECL_MODE (field) == BLKmode)
4965                 parms->nregs += TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
4966               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
4967                 parms->nregs += 2;
4968               else
4969                 parms->nregs += 1;
4970             }
4971           else
4972             {
4973               if (parms->intoffset == -1)
4974                 parms->intoffset = bitpos;
4975             }
4976         }
4977     }
4978 }
4979
4980 /* A subroutine of function_arg_record_value.  Assign the bits of the
4981    structure between parms->intoffset and bitpos to integer registers.  */
4982
4983 static void
4984 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
4985                              struct function_arg_record_value_parms *parms)
4986 {
4987   enum machine_mode mode;
4988   unsigned int regno;
4989   unsigned int startbit, endbit;
4990   int this_slotno, intslots, intoffset;
4991   rtx reg;
4992
4993   if (parms->intoffset == -1)
4994     return;
4995
4996   intoffset = parms->intoffset;
4997   parms->intoffset = -1;
4998
4999   startbit = intoffset & -BITS_PER_WORD;
5000   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5001   intslots = (endbit - startbit) / BITS_PER_WORD;
5002   this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
5003
5004   intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
5005   if (intslots <= 0)
5006     return;
5007
5008   /* If this is the trailing part of a word, only load that much into
5009      the register.  Otherwise load the whole register.  Note that in
5010      the latter case we may pick up unwanted bits.  It's not a problem
5011      at the moment but may wish to revisit.  */
5012
5013   if (intoffset % BITS_PER_WORD != 0)
5014     mode = smallest_mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
5015                                    MODE_INT);
5016   else
5017     mode = word_mode;
5018
5019   intoffset /= BITS_PER_UNIT;
5020   do
5021     {
5022       regno = parms->regbase + this_slotno;
5023       reg = gen_rtx_REG (mode, regno);
5024       XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5025         = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
5026
5027       this_slotno += 1;
5028       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
5029       mode = word_mode;
5030       parms->nregs += 1;
5031       intslots -= 1;
5032     }
5033   while (intslots > 0);
5034 }
5035
5036 /* A subroutine of function_arg_record_value.  Traverse the structure
5037    recursively and assign bits to floating point registers.  Track which
5038    bits in between need integer registers; invoke function_arg_record_value_3
5039    to make that happen.  */
5040
5041 static void
5042 function_arg_record_value_2 (const_tree type, HOST_WIDE_INT startbitpos,
5043                              struct function_arg_record_value_parms *parms,
5044                              bool packed_p)
5045 {
5046   tree field;
5047
5048   if (! packed_p)
5049     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5050       {
5051         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5052           {
5053             packed_p = true;
5054             break;
5055           }
5056       }
5057
5058   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5059     {
5060       if (TREE_CODE (field) == FIELD_DECL)
5061         {
5062           HOST_WIDE_INT bitpos = startbitpos;
5063
5064           if (DECL_SIZE (field) != 0)
5065             {
5066               if (integer_zerop (DECL_SIZE (field)))
5067                 continue;
5068
5069               if (host_integerp (bit_position (field), 1))
5070                 bitpos += int_bit_position (field);
5071             }
5072
5073           /* ??? FIXME: else assume zero offset.  */
5074
5075           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5076             function_arg_record_value_2 (TREE_TYPE (field),
5077                                          bitpos,
5078                                          parms,
5079                                          packed_p);
5080           else if ((FLOAT_TYPE_P (TREE_TYPE (field))
5081                     || TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE)
5082                    && TARGET_FPU
5083                    && parms->named
5084                    && ! packed_p)
5085             {
5086               int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
5087               int regno, nregs, pos;
5088               enum machine_mode mode = DECL_MODE (field);
5089               rtx reg;
5090
5091               function_arg_record_value_3 (bitpos, parms);
5092
5093               if (TREE_CODE (TREE_TYPE (field)) == VECTOR_TYPE
5094                   && mode == BLKmode)
5095                 {
5096                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5097                   nregs = TYPE_VECTOR_SUBPARTS (TREE_TYPE (field));
5098                 }
5099               else if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5100                 {
5101                   mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (field)));
5102                   nregs = 2;
5103                 }
5104               else
5105                 nregs = 1;
5106
5107               regno = SPARC_FP_ARG_FIRST + this_slotno * 2;
5108               if (GET_MODE_SIZE (mode) <= 4 && (bitpos & 32) != 0)
5109                 regno++;
5110               reg = gen_rtx_REG (mode, regno);
5111               pos = bitpos / BITS_PER_UNIT;
5112               XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5113                 = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5114               parms->nregs += 1;
5115               while (--nregs > 0)
5116                 {
5117                   regno += GET_MODE_SIZE (mode) / 4;
5118                   reg = gen_rtx_REG (mode, regno);
5119                   pos += GET_MODE_SIZE (mode);
5120                   XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5121                     = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (pos));
5122                   parms->nregs += 1;
5123                 }
5124             }
5125           else
5126             {
5127               if (parms->intoffset == -1)
5128                 parms->intoffset = bitpos;
5129             }
5130         }
5131     }
5132 }
5133
5134 /* Used by function_arg and function_value to implement the complex
5135    conventions of the 64-bit ABI for passing and returning structures.
5136    Return an expression valid as a return value for the two macros
5137    FUNCTION_ARG and FUNCTION_VALUE.
5138
5139    TYPE is the data type of the argument (as a tree).
5140     This is null for libcalls where that information may
5141     not be available.
5142    MODE is the argument's machine mode.
5143    SLOTNO is the index number of the argument's slot in the parameter array.
5144    NAMED is nonzero if this argument is a named parameter
5145     (otherwise it is an extra parameter matching an ellipsis).
5146    REGBASE is the regno of the base register for the parameter array.  */
5147
5148 static rtx
5149 function_arg_record_value (const_tree type, enum machine_mode mode,
5150                            int slotno, int named, int regbase)
5151 {
5152   HOST_WIDE_INT typesize = int_size_in_bytes (type);
5153   struct function_arg_record_value_parms parms;
5154   unsigned int nregs;
5155
5156   parms.ret = NULL_RTX;
5157   parms.slotno = slotno;
5158   parms.named = named;
5159   parms.regbase = regbase;
5160   parms.stack = 0;
5161
5162   /* Compute how many registers we need.  */
5163   parms.nregs = 0;
5164   parms.intoffset = 0;
5165   function_arg_record_value_1 (type, 0, &parms, false);
5166
5167   /* Take into account pending integer fields.  */
5168   if (parms.intoffset != -1)
5169     {
5170       unsigned int startbit, endbit;
5171       int intslots, this_slotno;
5172
5173       startbit = parms.intoffset & -BITS_PER_WORD;
5174       endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5175       intslots = (endbit - startbit) / BITS_PER_WORD;
5176       this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
5177
5178       if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5179         {
5180           intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5181           /* We need to pass this field on the stack.  */
5182           parms.stack = 1;
5183         }
5184
5185       parms.nregs += intslots;
5186     }
5187   nregs = parms.nregs;
5188
5189   /* Allocate the vector and handle some annoying special cases.  */
5190   if (nregs == 0)
5191     {
5192       /* ??? Empty structure has no value?  Duh?  */
5193       if (typesize <= 0)
5194         {
5195           /* Though there's nothing really to store, return a word register
5196              anyway so the rest of gcc doesn't go nuts.  Returning a PARALLEL
5197              leads to breakage due to the fact that there are zero bytes to
5198              load.  */
5199           return gen_rtx_REG (mode, regbase);
5200         }
5201       else
5202         {
5203           /* ??? C++ has structures with no fields, and yet a size.  Give up
5204              for now and pass everything back in integer registers.  */
5205           nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5206         }
5207       if (nregs + slotno > SPARC_INT_ARG_MAX)
5208         nregs = SPARC_INT_ARG_MAX - slotno;
5209     }
5210   gcc_assert (nregs != 0);
5211
5212   parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
5213
5214   /* If at least one field must be passed on the stack, generate
5215      (parallel [(expr_list (nil) ...) ...]) so that all fields will
5216      also be passed on the stack.  We can't do much better because the
5217      semantics of TARGET_ARG_PARTIAL_BYTES doesn't handle the case
5218      of structures for which the fields passed exclusively in registers
5219      are not at the beginning of the structure.  */
5220   if (parms.stack)
5221     XVECEXP (parms.ret, 0, 0)
5222       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5223
5224   /* Fill in the entries.  */
5225   parms.nregs = 0;
5226   parms.intoffset = 0;
5227   function_arg_record_value_2 (type, 0, &parms, false);
5228   function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
5229
5230   gcc_assert (parms.nregs == nregs);
5231
5232   return parms.ret;
5233 }
5234
5235 /* Used by function_arg and function_value to implement the conventions
5236    of the 64-bit ABI for passing and returning unions.
5237    Return an expression valid as a return value for the two macros
5238    FUNCTION_ARG and FUNCTION_VALUE.
5239
5240    SIZE is the size in bytes of the union.
5241    MODE is the argument's machine mode.
5242    REGNO is the hard register the union will be passed in.  */
5243
5244 static rtx
5245 function_arg_union_value (int size, enum machine_mode mode, int slotno,
5246                           int regno)
5247 {
5248   int nwords = ROUND_ADVANCE (size), i;
5249   rtx regs;
5250
5251   /* See comment in previous function for empty structures.  */
5252   if (nwords == 0)
5253     return gen_rtx_REG (mode, regno);
5254
5255   if (slotno == SPARC_INT_ARG_MAX - 1)
5256     nwords = 1;
5257
5258   regs = gen_rtx_PARALLEL (mode, rtvec_alloc (nwords));
5259
5260   for (i = 0; i < nwords; i++)
5261     {
5262       /* Unions are passed left-justified.  */
5263       XVECEXP (regs, 0, i)
5264         = gen_rtx_EXPR_LIST (VOIDmode,
5265                              gen_rtx_REG (word_mode, regno),
5266                              GEN_INT (UNITS_PER_WORD * i));
5267       regno++;
5268     }
5269
5270   return regs;
5271 }
5272
5273 /* Used by function_arg and function_value to implement the conventions
5274    for passing and returning large (BLKmode) vectors.
5275    Return an expression valid as a return value for the two macros
5276    FUNCTION_ARG and FUNCTION_VALUE.
5277
5278    SIZE is the size in bytes of the vector (at least 8 bytes).
5279    REGNO is the FP hard register the vector will be passed in.  */
5280
5281 static rtx
5282 function_arg_vector_value (int size, int regno)
5283 {
5284   int i, nregs = size / 8;
5285   rtx regs;
5286
5287   regs = gen_rtx_PARALLEL (BLKmode, rtvec_alloc (nregs));
5288
5289   for (i = 0; i < nregs; i++)
5290     {
5291       XVECEXP (regs, 0, i)
5292         = gen_rtx_EXPR_LIST (VOIDmode,
5293                              gen_rtx_REG (DImode, regno + 2*i),
5294                              GEN_INT (i*8));
5295     }
5296
5297   return regs;
5298 }
5299
5300 /* Handle the FUNCTION_ARG macro.
5301    Determine where to put an argument to a function.
5302    Value is zero to push the argument on the stack,
5303    or a hard register in which to store the argument.
5304
5305    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5306     the preceding args and about the function being called.
5307    MODE is the argument's machine mode.
5308    TYPE is the data type of the argument (as a tree).
5309     This is null for libcalls where that information may
5310     not be available.
5311    NAMED is nonzero if this argument is a named parameter
5312     (otherwise it is an extra parameter matching an ellipsis).
5313    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.  */
5314
5315 rtx
5316 function_arg (const struct sparc_args *cum, enum machine_mode mode,
5317               tree type, int named, int incoming_p)
5318 {
5319   int regbase = (incoming_p
5320                  ? SPARC_INCOMING_INT_ARG_FIRST
5321                  : SPARC_OUTGOING_INT_ARG_FIRST);
5322   int slotno, regno, padding;
5323   enum mode_class mclass = GET_MODE_CLASS (mode);
5324
5325   slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
5326                                 &regno, &padding);
5327   if (slotno == -1)
5328     return 0;
5329
5330   /* Vector types deserve special treatment because they are polymorphic wrt
5331      their mode, depending upon whether VIS instructions are enabled.  */
5332   if (type && TREE_CODE (type) == VECTOR_TYPE)
5333     {
5334       HOST_WIDE_INT size = int_size_in_bytes (type);
5335       gcc_assert ((TARGET_ARCH32 && size <= 8)
5336                   || (TARGET_ARCH64 && size <= 16));
5337
5338       if (mode == BLKmode)
5339         return function_arg_vector_value (size,
5340                                           SPARC_FP_ARG_FIRST + 2*slotno);
5341       else
5342         mclass = MODE_FLOAT;
5343     }
5344
5345   if (TARGET_ARCH32)
5346     return gen_rtx_REG (mode, regno);
5347
5348   /* Structures up to 16 bytes in size are passed in arg slots on the stack
5349      and are promoted to registers if possible.  */
5350   if (type && TREE_CODE (type) == RECORD_TYPE)
5351     {
5352       HOST_WIDE_INT size = int_size_in_bytes (type);
5353       gcc_assert (size <= 16);
5354
5355       return function_arg_record_value (type, mode, slotno, named, regbase);
5356     }
5357
5358   /* Unions up to 16 bytes in size are passed in integer registers.  */
5359   else if (type && TREE_CODE (type) == UNION_TYPE)
5360     {
5361       HOST_WIDE_INT size = int_size_in_bytes (type);
5362       gcc_assert (size <= 16);
5363
5364       return function_arg_union_value (size, mode, slotno, regno);
5365     }
5366
5367   /* v9 fp args in reg slots beyond the int reg slots get passed in regs
5368      but also have the slot allocated for them.
5369      If no prototype is in scope fp values in register slots get passed
5370      in two places, either fp regs and int regs or fp regs and memory.  */
5371   else if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
5372            && SPARC_FP_REG_P (regno))
5373     {
5374       rtx reg = gen_rtx_REG (mode, regno);
5375       if (cum->prototype_p || cum->libcall_p)
5376         {
5377           /* "* 2" because fp reg numbers are recorded in 4 byte
5378              quantities.  */
5379 #if 0
5380           /* ??? This will cause the value to be passed in the fp reg and
5381              in the stack.  When a prototype exists we want to pass the
5382              value in the reg but reserve space on the stack.  That's an
5383              optimization, and is deferred [for a bit].  */
5384           if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
5385             return gen_rtx_PARALLEL (mode,
5386                             gen_rtvec (2,
5387                                        gen_rtx_EXPR_LIST (VOIDmode,
5388                                                 NULL_RTX, const0_rtx),
5389                                        gen_rtx_EXPR_LIST (VOIDmode,
5390                                                 reg, const0_rtx)));
5391           else
5392 #else
5393           /* ??? It seems that passing back a register even when past
5394              the area declared by REG_PARM_STACK_SPACE will allocate
5395              space appropriately, and will not copy the data onto the
5396              stack, exactly as we desire.
5397
5398              This is due to locate_and_pad_parm being called in
5399              expand_call whenever reg_parm_stack_space > 0, which
5400              while beneficial to our example here, would seem to be
5401              in error from what had been intended.  Ho hum...  -- r~ */
5402 #endif
5403             return reg;
5404         }
5405       else
5406         {
5407           rtx v0, v1;
5408
5409           if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
5410             {
5411               int intreg;
5412
5413               /* On incoming, we don't need to know that the value
5414                  is passed in %f0 and %i0, and it confuses other parts
5415                  causing needless spillage even on the simplest cases.  */
5416               if (incoming_p)
5417                 return reg;
5418
5419               intreg = (SPARC_OUTGOING_INT_ARG_FIRST
5420                         + (regno - SPARC_FP_ARG_FIRST) / 2);
5421
5422               v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5423               v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
5424                                       const0_rtx);
5425               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5426             }
5427           else
5428             {
5429               v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5430               v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5431               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5432             }
5433         }
5434     }
5435
5436   /* All other aggregate types are passed in an integer register in a mode
5437      corresponding to the size of the type.  */
5438   else if (type && AGGREGATE_TYPE_P (type))
5439     {
5440       HOST_WIDE_INT size = int_size_in_bytes (type);
5441       gcc_assert (size <= 16);
5442
5443       mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
5444     }
5445
5446   return gen_rtx_REG (mode, regno);
5447 }
5448
5449 /* For an arg passed partly in registers and partly in memory,
5450    this is the number of bytes of registers used.
5451    For args passed entirely in registers or entirely in memory, zero.
5452
5453    Any arg that starts in the first 6 regs but won't entirely fit in them
5454    needs partial registers on v8.  On v9, structures with integer
5455    values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
5456    values that begin in the last fp reg [where "last fp reg" varies with the
5457    mode] will be split between that reg and memory.  */
5458
5459 static int
5460 sparc_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
5461                          tree type, bool named)
5462 {
5463   int slotno, regno, padding;
5464
5465   /* We pass 0 for incoming_p here, it doesn't matter.  */
5466   slotno = function_arg_slotno (cum, mode, type, named, 0, &regno, &padding);
5467
5468   if (slotno == -1)
5469     return 0;
5470
5471   if (TARGET_ARCH32)
5472     {
5473       if ((slotno + (mode == BLKmode
5474                      ? ROUND_ADVANCE (int_size_in_bytes (type))
5475                      : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
5476           > SPARC_INT_ARG_MAX)
5477         return (SPARC_INT_ARG_MAX - slotno) * UNITS_PER_WORD;
5478     }
5479   else
5480     {
5481       /* We are guaranteed by pass_by_reference that the size of the
5482          argument is not greater than 16 bytes, so we only need to return
5483          one word if the argument is partially passed in registers.  */
5484
5485       if (type && AGGREGATE_TYPE_P (type))
5486         {
5487           int size = int_size_in_bytes (type);
5488
5489           if (size > UNITS_PER_WORD
5490               && slotno == SPARC_INT_ARG_MAX - 1)
5491             return UNITS_PER_WORD;
5492         }
5493       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
5494                || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
5495                    && ! (TARGET_FPU && named)))
5496         {
5497           /* The complex types are passed as packed types.  */
5498           if (GET_MODE_SIZE (mode) > UNITS_PER_WORD
5499               && slotno == SPARC_INT_ARG_MAX - 1)
5500             return UNITS_PER_WORD;
5501         }
5502       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
5503         {
5504           if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
5505               > SPARC_FP_ARG_MAX)
5506             return UNITS_PER_WORD;
5507         }
5508     }
5509
5510   return 0;
5511 }
5512
5513 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
5514    Specify whether to pass the argument by reference.  */
5515
5516 static bool
5517 sparc_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
5518                          enum machine_mode mode, const_tree type,
5519                          bool named ATTRIBUTE_UNUSED)
5520 {
5521   if (TARGET_ARCH32)
5522     /* Original SPARC 32-bit ABI says that structures and unions,
5523        and quad-precision floats are passed by reference.  For Pascal,
5524        also pass arrays by reference.  All other base types are passed
5525        in registers.
5526
5527        Extended ABI (as implemented by the Sun compiler) says that all
5528        complex floats are passed by reference.  Pass complex integers
5529        in registers up to 8 bytes.  More generally, enforce the 2-word
5530        cap for passing arguments in registers.
5531
5532        Vector ABI (as implemented by the Sun VIS SDK) says that vector
5533        integers are passed like floats of the same size, that is in
5534        registers up to 8 bytes.  Pass all vector floats by reference
5535        like structure and unions.  */
5536     return ((type && (AGGREGATE_TYPE_P (type) || VECTOR_FLOAT_TYPE_P (type)))
5537             || mode == SCmode
5538             /* Catch CDImode, TFmode, DCmode and TCmode.  */
5539             || GET_MODE_SIZE (mode) > 8
5540             || (type
5541                 && TREE_CODE (type) == VECTOR_TYPE
5542                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
5543   else
5544     /* Original SPARC 64-bit ABI says that structures and unions
5545        smaller than 16 bytes are passed in registers, as well as
5546        all other base types.
5547
5548        Extended ABI (as implemented by the Sun compiler) says that
5549        complex floats are passed in registers up to 16 bytes.  Pass
5550        all complex integers in registers up to 16 bytes.  More generally,
5551        enforce the 2-word cap for passing arguments in registers.
5552
5553        Vector ABI (as implemented by the Sun VIS SDK) says that vector
5554        integers are passed like floats of the same size, that is in
5555        registers (up to 16 bytes).  Pass all vector floats like structure
5556        and unions.  */
5557     return ((type
5558              && (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == VECTOR_TYPE)
5559              && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16)
5560             /* Catch CTImode and TCmode.  */
5561             || GET_MODE_SIZE (mode) > 16);
5562 }
5563
5564 /* Handle the FUNCTION_ARG_ADVANCE macro.
5565    Update the data in CUM to advance over an argument
5566    of mode MODE and data type TYPE.
5567    TYPE is null for libcalls where that information may not be available.  */
5568
5569 void
5570 function_arg_advance (struct sparc_args *cum, enum machine_mode mode,
5571                       tree type, int named)
5572 {
5573   int slotno, regno, padding;
5574
5575   /* We pass 0 for incoming_p here, it doesn't matter.  */
5576   slotno = function_arg_slotno (cum, mode, type, named, 0, &regno, &padding);
5577
5578   /* If register required leading padding, add it.  */
5579   if (slotno != -1)
5580     cum->words += padding;
5581
5582   if (TARGET_ARCH32)
5583     {
5584       cum->words += (mode != BLKmode
5585                      ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5586                      : ROUND_ADVANCE (int_size_in_bytes (type)));
5587     }
5588   else
5589     {
5590       if (type && AGGREGATE_TYPE_P (type))
5591         {
5592           int size = int_size_in_bytes (type);
5593
5594           if (size <= 8)
5595             ++cum->words;
5596           else if (size <= 16)
5597             cum->words += 2;
5598           else /* passed by reference */
5599             ++cum->words;
5600         }
5601       else
5602         {
5603           cum->words += (mode != BLKmode
5604                          ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5605                          : ROUND_ADVANCE (int_size_in_bytes (type)));
5606         }
5607     }
5608 }
5609
5610 /* Handle the FUNCTION_ARG_PADDING macro.
5611    For the 64 bit ABI structs are always stored left shifted in their
5612    argument slot.  */
5613
5614 enum direction
5615 function_arg_padding (enum machine_mode mode, const_tree type)
5616 {
5617   if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
5618     return upward;
5619
5620   /* Fall back to the default.  */
5621   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
5622 }
5623
5624 /* Handle the TARGET_RETURN_IN_MEMORY target hook.
5625    Specify whether to return the return value in memory.  */
5626
5627 static bool
5628 sparc_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
5629 {
5630   if (TARGET_ARCH32)
5631     /* Original SPARC 32-bit ABI says that structures and unions,
5632        and quad-precision floats are returned in memory.  All other
5633        base types are returned in registers.
5634
5635        Extended ABI (as implemented by the Sun compiler) says that
5636        all complex floats are returned in registers (8 FP registers
5637        at most for '_Complex long double').  Return all complex integers
5638        in registers (4 at most for '_Complex long long').
5639
5640        Vector ABI (as implemented by the Sun VIS SDK) says that vector
5641        integers are returned like floats of the same size, that is in
5642        registers up to 8 bytes and in memory otherwise.  Return all
5643        vector floats in memory like structure and unions; note that
5644        they always have BLKmode like the latter.  */
5645     return (TYPE_MODE (type) == BLKmode
5646             || TYPE_MODE (type) == TFmode
5647             || (TREE_CODE (type) == VECTOR_TYPE
5648                 && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8));
5649   else
5650     /* Original SPARC 64-bit ABI says that structures and unions
5651        smaller than 32 bytes are returned in registers, as well as
5652        all other base types.
5653
5654        Extended ABI (as implemented by the Sun compiler) says that all
5655        complex floats are returned in registers (8 FP registers at most
5656        for '_Complex long double').  Return all complex integers in
5657        registers (4 at most for '_Complex TItype').
5658
5659        Vector ABI (as implemented by the Sun VIS SDK) says that vector
5660        integers are returned like floats of the same size, that is in
5661        registers.  Return all vector floats like structure and unions;
5662        note that they always have BLKmode like the latter.  */
5663     return ((TYPE_MODE (type) == BLKmode
5664              && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 32));
5665 }
5666
5667 /* Handle the TARGET_STRUCT_VALUE target hook.
5668    Return where to find the structure return value address.  */
5669
5670 static rtx
5671 sparc_struct_value_rtx (tree fndecl, int incoming)
5672 {
5673   if (TARGET_ARCH64)
5674     return 0;
5675   else
5676     {
5677       rtx mem;
5678
5679       if (incoming)
5680         mem = gen_rtx_MEM (Pmode, plus_constant (frame_pointer_rtx,
5681                                                  STRUCT_VALUE_OFFSET));
5682       else
5683         mem = gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx,
5684                                                  STRUCT_VALUE_OFFSET));
5685
5686       /* Only follow the SPARC ABI for fixed-size structure returns.
5687          Variable size structure returns are handled per the normal
5688          procedures in GCC. This is enabled by -mstd-struct-return */
5689       if (incoming == 2
5690           && sparc_std_struct_return
5691           && TYPE_SIZE_UNIT (TREE_TYPE (fndecl))
5692           && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (fndecl))) == INTEGER_CST)
5693         {
5694           /* We must check and adjust the return address, as it is
5695              optional as to whether the return object is really
5696              provided.  */
5697           rtx ret_rtx = gen_rtx_REG (Pmode, 31);
5698           rtx scratch = gen_reg_rtx (SImode);
5699           rtx endlab = gen_label_rtx ();
5700
5701           /* Calculate the return object size */
5702           tree size = TYPE_SIZE_UNIT (TREE_TYPE (fndecl));
5703           rtx size_rtx = GEN_INT (TREE_INT_CST_LOW (size) & 0xfff);
5704           /* Construct a temporary return value */
5705           rtx temp_val = assign_stack_local (Pmode, TREE_INT_CST_LOW (size), 0);
5706
5707           /* Implement SPARC 32-bit psABI callee returns struck checking
5708              requirements:
5709
5710               Fetch the instruction where we will return to and see if
5711              it's an unimp instruction (the most significant 10 bits
5712              will be zero).  */
5713           emit_move_insn (scratch, gen_rtx_MEM (SImode,
5714                                                 plus_constant (ret_rtx, 8)));
5715           /* Assume the size is valid and pre-adjust */
5716           emit_insn (gen_add3_insn (ret_rtx, ret_rtx, GEN_INT (4)));
5717           emit_cmp_and_jump_insns (scratch, size_rtx, EQ, const0_rtx, SImode, 0, endlab);
5718           emit_insn (gen_sub3_insn (ret_rtx, ret_rtx, GEN_INT (4)));
5719           /* Assign stack temp:
5720              Write the address of the memory pointed to by temp_val into
5721              the memory pointed to by mem */
5722           emit_move_insn (mem, XEXP (temp_val, 0));
5723           emit_label (endlab);
5724         }
5725
5726       set_mem_alias_set (mem, struct_value_alias_set);
5727       return mem;
5728     }
5729 }
5730
5731 /* Handle FUNCTION_VALUE, FUNCTION_OUTGOING_VALUE, and LIBCALL_VALUE macros.
5732    For v9, function return values are subject to the same rules as arguments,
5733    except that up to 32 bytes may be returned in registers.  */
5734
5735 rtx
5736 function_value (const_tree type, enum machine_mode mode, int incoming_p)
5737 {
5738   /* Beware that the two values are swapped here wrt function_arg.  */
5739   int regbase = (incoming_p
5740                  ? SPARC_OUTGOING_INT_ARG_FIRST
5741                  : SPARC_INCOMING_INT_ARG_FIRST);
5742   enum mode_class mclass = GET_MODE_CLASS (mode);
5743   int regno;
5744
5745   /* Vector types deserve special treatment because they are polymorphic wrt
5746      their mode, depending upon whether VIS instructions are enabled.  */
5747   if (type && TREE_CODE (type) == VECTOR_TYPE)
5748     {
5749       HOST_WIDE_INT size = int_size_in_bytes (type);
5750       gcc_assert ((TARGET_ARCH32 && size <= 8)
5751                   || (TARGET_ARCH64 && size <= 32));
5752
5753       if (mode == BLKmode)
5754         return function_arg_vector_value (size,
5755                                           SPARC_FP_ARG_FIRST);
5756       else
5757         mclass = MODE_FLOAT;
5758     }
5759
5760   if (TARGET_ARCH64 && type)
5761     {
5762       /* Structures up to 32 bytes in size are returned in registers.  */
5763       if (TREE_CODE (type) == RECORD_TYPE)
5764         {
5765           HOST_WIDE_INT size = int_size_in_bytes (type);
5766           gcc_assert (size <= 32);
5767
5768           return function_arg_record_value (type, mode, 0, 1, regbase);
5769         }
5770
5771       /* Unions up to 32 bytes in size are returned in integer registers.  */
5772       else if (TREE_CODE (type) == UNION_TYPE)
5773         {
5774           HOST_WIDE_INT size = int_size_in_bytes (type);
5775           gcc_assert (size <= 32);
5776
5777           return function_arg_union_value (size, mode, 0, regbase);
5778         }
5779
5780       /* Objects that require it are returned in FP registers.  */
5781       else if (mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT)
5782         ;
5783
5784       /* All other aggregate types are returned in an integer register in a
5785          mode corresponding to the size of the type.  */
5786       else if (AGGREGATE_TYPE_P (type))
5787         {
5788           /* All other aggregate types are passed in an integer register
5789              in a mode corresponding to the size of the type.  */
5790           HOST_WIDE_INT size = int_size_in_bytes (type);
5791           gcc_assert (size <= 32);
5792
5793           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
5794
5795           /* ??? We probably should have made the same ABI change in
5796              3.4.0 as the one we made for unions.   The latter was
5797              required by the SCD though, while the former is not
5798              specified, so we favored compatibility and efficiency.
5799
5800              Now we're stuck for aggregates larger than 16 bytes,
5801              because OImode vanished in the meantime.  Let's not
5802              try to be unduly clever, and simply follow the ABI
5803              for unions in that case.  */
5804           if (mode == BLKmode)
5805             return function_arg_union_value (size, mode, 0, regbase);
5806           else
5807             mclass = MODE_INT;
5808         }
5809
5810       /* This must match sparc_promote_function_mode.
5811          ??? Maybe 32-bit pointers should actually remain in Pmode?  */
5812       else if (mclass == MODE_INT && GET_MODE_SIZE (mode) < UNITS_PER_WORD)
5813         mode = word_mode;
5814     }
5815
5816   if ((mclass == MODE_FLOAT || mclass == MODE_COMPLEX_FLOAT) && TARGET_FPU)
5817     regno = SPARC_FP_ARG_FIRST;
5818   else
5819     regno = regbase;
5820
5821   return gen_rtx_REG (mode, regno);
5822 }
5823
5824 /* Do what is necessary for `va_start'.  We look at the current function
5825    to determine if stdarg or varargs is used and return the address of
5826    the first unnamed parameter.  */
5827
5828 static rtx
5829 sparc_builtin_saveregs (void)
5830 {
5831   int first_reg = crtl->args.info.words;
5832   rtx address;
5833   int regno;
5834
5835   for (regno = first_reg; regno < SPARC_INT_ARG_MAX; regno++)
5836     emit_move_insn (gen_rtx_MEM (word_mode,
5837                                  gen_rtx_PLUS (Pmode,
5838                                                frame_pointer_rtx,
5839                                                GEN_INT (FIRST_PARM_OFFSET (0)
5840                                                         + (UNITS_PER_WORD
5841                                                            * regno)))),
5842                     gen_rtx_REG (word_mode,
5843                                  SPARC_INCOMING_INT_ARG_FIRST + regno));
5844
5845   address = gen_rtx_PLUS (Pmode,
5846                           frame_pointer_rtx,
5847                           GEN_INT (FIRST_PARM_OFFSET (0)
5848                                    + UNITS_PER_WORD * first_reg));
5849
5850   return address;
5851 }
5852
5853 /* Implement `va_start' for stdarg.  */
5854
5855 static void
5856 sparc_va_start (tree valist, rtx nextarg)
5857 {
5858   nextarg = expand_builtin_saveregs ();
5859   std_expand_builtin_va_start (valist, nextarg);
5860 }
5861
5862 /* Implement `va_arg' for stdarg.  */
5863
5864 static tree
5865 sparc_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
5866                        gimple_seq *post_p)
5867 {
5868   HOST_WIDE_INT size, rsize, align;
5869   tree addr, incr;
5870   bool indirect;
5871   tree ptrtype = build_pointer_type (type);
5872
5873   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
5874     {
5875       indirect = true;
5876       size = rsize = UNITS_PER_WORD;
5877       align = 0;
5878     }
5879   else
5880     {
5881       indirect = false;
5882       size = int_size_in_bytes (type);
5883       rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
5884       align = 0;
5885
5886       if (TARGET_ARCH64)
5887         {
5888           /* For SPARC64, objects requiring 16-byte alignment get it.  */
5889           if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
5890             align = 2 * UNITS_PER_WORD;
5891
5892           /* SPARC-V9 ABI states that structures up to 16 bytes in size
5893              are left-justified in their slots.  */
5894           if (AGGREGATE_TYPE_P (type))
5895             {
5896               if (size == 0)
5897                 size = rsize = UNITS_PER_WORD;
5898               else
5899                 size = rsize;
5900             }
5901         }
5902     }
5903
5904   incr = valist;
5905   if (align)
5906     {
5907       incr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, incr,
5908                           size_int (align - 1));
5909       incr = fold_convert (sizetype, incr);
5910       incr = fold_build2 (BIT_AND_EXPR, sizetype, incr,
5911                           size_int (-align));
5912       incr = fold_convert (ptr_type_node, incr);
5913     }
5914
5915   gimplify_expr (&incr, pre_p, post_p, is_gimple_val, fb_rvalue);
5916   addr = incr;
5917
5918   if (BYTES_BIG_ENDIAN && size < rsize)
5919     addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, incr,
5920                         size_int (rsize - size));
5921
5922   if (indirect)
5923     {
5924       addr = fold_convert (build_pointer_type (ptrtype), addr);
5925       addr = build_va_arg_indirect_ref (addr);
5926     }
5927
5928   /* If the address isn't aligned properly for the type, we need a temporary.
5929      FIXME: This is inefficient, usually we can do this in registers.  */
5930   else if (align == 0 && TYPE_ALIGN (type) > BITS_PER_WORD)
5931     {
5932       tree tmp = create_tmp_var (type, "va_arg_tmp");
5933       tree dest_addr = build_fold_addr_expr (tmp);
5934       tree copy = build_call_expr (implicit_built_in_decls[BUILT_IN_MEMCPY],
5935                                    3, dest_addr, addr, size_int (rsize));
5936       TREE_ADDRESSABLE (tmp) = 1;
5937       gimplify_and_add (copy, pre_p);
5938       addr = dest_addr;
5939     }
5940
5941   else
5942     addr = fold_convert (ptrtype, addr);
5943
5944   incr
5945     = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, incr, size_int (rsize));
5946   gimplify_assign (valist, incr, post_p);
5947
5948   return build_va_arg_indirect_ref (addr);
5949 }
5950 \f
5951 /* Implement the TARGET_VECTOR_MODE_SUPPORTED_P target hook.
5952    Specify whether the vector mode is supported by the hardware.  */
5953
5954 static bool
5955 sparc_vector_mode_supported_p (enum machine_mode mode)
5956 {
5957   return TARGET_VIS && VECTOR_MODE_P (mode) ? true : false;
5958 }
5959 \f
5960 /* Return the string to output an unconditional branch to LABEL, which is
5961    the operand number of the label.
5962
5963    DEST is the destination insn (i.e. the label), INSN is the source.  */
5964
5965 const char *
5966 output_ubranch (rtx dest, int label, rtx insn)
5967 {
5968   static char string[64];
5969   bool v9_form = false;
5970   char *p;
5971
5972   if (TARGET_V9 && INSN_ADDRESSES_SET_P ())
5973     {
5974       int delta = (INSN_ADDRESSES (INSN_UID (dest))
5975                    - INSN_ADDRESSES (INSN_UID (insn)));
5976       /* Leave some instructions for "slop".  */
5977       if (delta >= -260000 && delta < 260000)
5978         v9_form = true;
5979     }
5980
5981   if (v9_form)
5982     strcpy (string, "ba%*,pt\t%%xcc, ");
5983   else
5984     strcpy (string, "b%*\t");
5985
5986   p = strchr (string, '\0');
5987   *p++ = '%';
5988   *p++ = 'l';
5989   *p++ = '0' + label;
5990   *p++ = '%';
5991   *p++ = '(';
5992   *p = '\0';
5993
5994   return string;
5995 }
5996
5997 /* Return the string to output a conditional branch to LABEL, which is
5998    the operand number of the label.  OP is the conditional expression.
5999    XEXP (OP, 0) is assumed to be a condition code register (integer or
6000    floating point) and its mode specifies what kind of comparison we made.
6001
6002    DEST is the destination insn (i.e. the label), INSN is the source.
6003
6004    REVERSED is nonzero if we should reverse the sense of the comparison.
6005
6006    ANNUL is nonzero if we should generate an annulling branch.  */
6007
6008 const char *
6009 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
6010                 rtx insn)
6011 {
6012   static char string[64];
6013   enum rtx_code code = GET_CODE (op);
6014   rtx cc_reg = XEXP (op, 0);
6015   enum machine_mode mode = GET_MODE (cc_reg);
6016   const char *labelno, *branch;
6017   int spaces = 8, far;
6018   char *p;
6019
6020   /* v9 branches are limited to +-1MB.  If it is too far away,
6021      change
6022
6023      bne,pt %xcc, .LC30
6024
6025      to
6026
6027      be,pn %xcc, .+12
6028       nop
6029      ba .LC30
6030
6031      and
6032
6033      fbne,a,pn %fcc2, .LC29
6034
6035      to
6036
6037      fbe,pt %fcc2, .+16
6038       nop
6039      ba .LC29  */
6040
6041   far = TARGET_V9 && (get_attr_length (insn) >= 3);
6042   if (reversed ^ far)
6043     {
6044       /* Reversal of FP compares takes care -- an ordered compare
6045          becomes an unordered compare and vice versa.  */
6046       if (mode == CCFPmode || mode == CCFPEmode)
6047         code = reverse_condition_maybe_unordered (code);
6048       else
6049         code = reverse_condition (code);
6050     }
6051
6052   /* Start by writing the branch condition.  */
6053   if (mode == CCFPmode || mode == CCFPEmode)
6054     {
6055       switch (code)
6056         {
6057         case NE:
6058           branch = "fbne";
6059           break;
6060         case EQ:
6061           branch = "fbe";
6062           break;
6063         case GE:
6064           branch = "fbge";
6065           break;
6066         case GT:
6067           branch = "fbg";
6068           break;
6069         case LE:
6070           branch = "fble";
6071           break;
6072         case LT:
6073           branch = "fbl";
6074           break;
6075         case UNORDERED:
6076           branch = "fbu";
6077           break;
6078         case ORDERED:
6079           branch = "fbo";
6080           break;
6081         case UNGT:
6082           branch = "fbug";
6083           break;
6084         case UNLT:
6085           branch = "fbul";
6086           break;
6087         case UNEQ:
6088           branch = "fbue";
6089           break;
6090         case UNGE:
6091           branch = "fbuge";
6092           break;
6093         case UNLE:
6094           branch = "fbule";
6095           break;
6096         case LTGT:
6097           branch = "fblg";
6098           break;
6099
6100         default:
6101           gcc_unreachable ();
6102         }
6103
6104       /* ??? !v9: FP branches cannot be preceded by another floating point
6105          insn.  Because there is currently no concept of pre-delay slots,
6106          we can fix this only by always emitting a nop before a floating
6107          point branch.  */
6108
6109       string[0] = '\0';
6110       if (! TARGET_V9)
6111         strcpy (string, "nop\n\t");
6112       strcat (string, branch);
6113     }
6114   else
6115     {
6116       switch (code)
6117         {
6118         case NE:
6119           branch = "bne";
6120           break;
6121         case EQ:
6122           branch = "be";
6123           break;
6124         case GE:
6125           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
6126             branch = "bpos";
6127           else
6128             branch = "bge";
6129           break;
6130         case GT:
6131           branch = "bg";
6132           break;
6133         case LE:
6134           branch = "ble";
6135           break;
6136         case LT:
6137           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
6138             branch = "bneg";
6139           else
6140             branch = "bl";
6141           break;
6142         case GEU:
6143           branch = "bgeu";
6144           break;
6145         case GTU:
6146           branch = "bgu";
6147           break;
6148         case LEU:
6149           branch = "bleu";
6150           break;
6151         case LTU:
6152           branch = "blu";
6153           break;
6154
6155         default:
6156           gcc_unreachable ();
6157         }
6158       strcpy (string, branch);
6159     }
6160   spaces -= strlen (branch);
6161   p = strchr (string, '\0');
6162
6163   /* Now add the annulling, the label, and a possible noop.  */
6164   if (annul && ! far)
6165     {
6166       strcpy (p, ",a");
6167       p += 2;
6168       spaces -= 2;
6169     }
6170
6171   if (TARGET_V9)
6172     {
6173       rtx note;
6174       int v8 = 0;
6175
6176       if (! far && insn && INSN_ADDRESSES_SET_P ())
6177         {
6178           int delta = (INSN_ADDRESSES (INSN_UID (dest))
6179                        - INSN_ADDRESSES (INSN_UID (insn)));
6180           /* Leave some instructions for "slop".  */
6181           if (delta < -260000 || delta >= 260000)
6182             v8 = 1;
6183         }
6184
6185       if (mode == CCFPmode || mode == CCFPEmode)
6186         {
6187           static char v9_fcc_labelno[] = "%%fccX, ";
6188           /* Set the char indicating the number of the fcc reg to use.  */
6189           v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
6190           labelno = v9_fcc_labelno;
6191           if (v8)
6192             {
6193               gcc_assert (REGNO (cc_reg) == SPARC_FCC_REG);
6194               labelno = "";
6195             }
6196         }
6197       else if (mode == CCXmode || mode == CCX_NOOVmode)
6198         {
6199           labelno = "%%xcc, ";
6200           gcc_assert (! v8);
6201         }
6202       else
6203         {
6204           labelno = "%%icc, ";
6205           if (v8)
6206             labelno = "";
6207         }
6208
6209       if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6210         {
6211           strcpy (p,
6212                   ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6213                   ? ",pt" : ",pn");
6214           p += 3;
6215           spaces -= 3;
6216         }
6217     }
6218   else
6219     labelno = "";
6220
6221   if (spaces > 0)
6222     *p++ = '\t';
6223   else
6224     *p++ = ' ';
6225   strcpy (p, labelno);
6226   p = strchr (p, '\0');
6227   if (far)
6228     {
6229       strcpy (p, ".+12\n\t nop\n\tb\t");
6230       /* Skip the next insn if requested or
6231          if we know that it will be a nop.  */
6232       if (annul || ! final_sequence)
6233         p[3] = '6';
6234       p += 14;
6235     }
6236   *p++ = '%';
6237   *p++ = 'l';
6238   *p++ = label + '0';
6239   *p++ = '%';
6240   *p++ = '#';
6241   *p = '\0';
6242
6243   return string;
6244 }
6245
6246 /* Emit a library call comparison between floating point X and Y.
6247    COMPARISON is the operator to compare with (EQ, NE, GT, etc).
6248    Return the new operator to be used in the comparison sequence.
6249
6250    TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
6251    values as arguments instead of the TFmode registers themselves,
6252    that's why we cannot call emit_float_lib_cmp.  */
6253
6254 rtx
6255 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
6256 {
6257   const char *qpfunc;
6258   rtx slot0, slot1, result, tem, tem2, libfunc;
6259   enum machine_mode mode;
6260   enum rtx_code new_comparison;
6261
6262   switch (comparison)
6263     {
6264     case EQ:
6265       qpfunc = (TARGET_ARCH64 ? "_Qp_feq" : "_Q_feq");
6266       break;
6267
6268     case NE:
6269       qpfunc = (TARGET_ARCH64 ? "_Qp_fne" : "_Q_fne");
6270       break;
6271
6272     case GT:
6273       qpfunc = (TARGET_ARCH64 ? "_Qp_fgt" : "_Q_fgt");
6274       break;
6275
6276     case GE:
6277       qpfunc = (TARGET_ARCH64 ? "_Qp_fge" : "_Q_fge");
6278       break;
6279
6280     case LT:
6281       qpfunc = (TARGET_ARCH64 ? "_Qp_flt" : "_Q_flt");
6282       break;
6283
6284     case LE:
6285       qpfunc = (TARGET_ARCH64 ? "_Qp_fle" : "_Q_fle");
6286       break;
6287
6288     case ORDERED:
6289     case UNORDERED:
6290     case UNGT:
6291     case UNLT:
6292     case UNEQ:
6293     case UNGE:
6294     case UNLE:
6295     case LTGT:
6296       qpfunc = (TARGET_ARCH64 ? "_Qp_cmp" : "_Q_cmp");
6297       break;
6298
6299     default:
6300       gcc_unreachable ();
6301     }
6302
6303   if (TARGET_ARCH64)
6304     {
6305       if (MEM_P (x))
6306         slot0 = x;
6307       else
6308         {
6309           slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6310           emit_move_insn (slot0, x);
6311         }
6312
6313       if (MEM_P (y))
6314         slot1 = y;
6315       else
6316         {
6317           slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6318           emit_move_insn (slot1, y);
6319         }
6320
6321       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
6322       emit_library_call (libfunc, LCT_NORMAL,
6323                          DImode, 2,
6324                          XEXP (slot0, 0), Pmode,
6325                          XEXP (slot1, 0), Pmode);
6326       mode = DImode;
6327     }
6328   else
6329     {
6330       libfunc = gen_rtx_SYMBOL_REF (Pmode, qpfunc);
6331       emit_library_call (libfunc, LCT_NORMAL,
6332                          SImode, 2,
6333                          x, TFmode, y, TFmode);
6334       mode = SImode;
6335     }
6336
6337
6338   /* Immediately move the result of the libcall into a pseudo
6339      register so reload doesn't clobber the value if it needs
6340      the return register for a spill reg.  */
6341   result = gen_reg_rtx (mode);
6342   emit_move_insn (result, hard_libcall_value (mode, libfunc));
6343
6344   switch (comparison)
6345     {
6346     default:
6347       return gen_rtx_NE (VOIDmode, result, const0_rtx);
6348     case ORDERED:
6349     case UNORDERED:
6350       new_comparison = (comparison == UNORDERED ? EQ : NE);
6351       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, GEN_INT(3));
6352     case UNGT:
6353     case UNGE:
6354       new_comparison = (comparison == UNGT ? GT : NE);
6355       return gen_rtx_fmt_ee (new_comparison, VOIDmode, result, const1_rtx);
6356     case UNLE:
6357       return gen_rtx_NE (VOIDmode, result, const2_rtx);
6358     case UNLT:
6359       tem = gen_reg_rtx (mode);
6360       if (TARGET_ARCH32)
6361         emit_insn (gen_andsi3 (tem, result, const1_rtx));
6362       else
6363         emit_insn (gen_anddi3 (tem, result, const1_rtx));
6364       return gen_rtx_NE (VOIDmode, tem, const0_rtx);
6365     case UNEQ:
6366     case LTGT:
6367       tem = gen_reg_rtx (mode);
6368       if (TARGET_ARCH32)
6369         emit_insn (gen_addsi3 (tem, result, const1_rtx));
6370       else
6371         emit_insn (gen_adddi3 (tem, result, const1_rtx));
6372       tem2 = gen_reg_rtx (mode);
6373       if (TARGET_ARCH32)
6374         emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
6375       else
6376         emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
6377       new_comparison = (comparison == UNEQ ? EQ : NE);
6378       return gen_rtx_fmt_ee (new_comparison, VOIDmode, tem2, const0_rtx);
6379     }
6380
6381   gcc_unreachable ();
6382 }
6383
6384 /* Generate an unsigned DImode to FP conversion.  This is the same code
6385    optabs would emit if we didn't have TFmode patterns.  */
6386
6387 void
6388 sparc_emit_floatunsdi (rtx *operands, enum machine_mode mode)
6389 {
6390   rtx neglab, donelab, i0, i1, f0, in, out;
6391
6392   out = operands[0];
6393   in = force_reg (DImode, operands[1]);
6394   neglab = gen_label_rtx ();
6395   donelab = gen_label_rtx ();
6396   i0 = gen_reg_rtx (DImode);
6397   i1 = gen_reg_rtx (DImode);
6398   f0 = gen_reg_rtx (mode);
6399
6400   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
6401
6402   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
6403   emit_jump_insn (gen_jump (donelab));
6404   emit_barrier ();
6405
6406   emit_label (neglab);
6407
6408   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
6409   emit_insn (gen_anddi3 (i1, in, const1_rtx));
6410   emit_insn (gen_iordi3 (i0, i0, i1));
6411   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
6412   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
6413
6414   emit_label (donelab);
6415 }
6416
6417 /* Generate an FP to unsigned DImode conversion.  This is the same code
6418    optabs would emit if we didn't have TFmode patterns.  */
6419
6420 void
6421 sparc_emit_fixunsdi (rtx *operands, enum machine_mode mode)
6422 {
6423   rtx neglab, donelab, i0, i1, f0, in, out, limit;
6424
6425   out = operands[0];
6426   in = force_reg (mode, operands[1]);
6427   neglab = gen_label_rtx ();
6428   donelab = gen_label_rtx ();
6429   i0 = gen_reg_rtx (DImode);
6430   i1 = gen_reg_rtx (DImode);
6431   limit = gen_reg_rtx (mode);
6432   f0 = gen_reg_rtx (mode);
6433
6434   emit_move_insn (limit,
6435                   CONST_DOUBLE_FROM_REAL_VALUE (
6436                     REAL_VALUE_ATOF ("9223372036854775808.0", mode), mode));
6437   emit_cmp_and_jump_insns (in, limit, GE, NULL_RTX, mode, 0, neglab);
6438
6439   emit_insn (gen_rtx_SET (VOIDmode,
6440                           out,
6441                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, in))));
6442   emit_jump_insn (gen_jump (donelab));
6443   emit_barrier ();
6444
6445   emit_label (neglab);
6446
6447   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_MINUS (mode, in, limit)));
6448   emit_insn (gen_rtx_SET (VOIDmode,
6449                           i0,
6450                           gen_rtx_FIX (DImode, gen_rtx_FIX (mode, f0))));
6451   emit_insn (gen_movdi (i1, const1_rtx));
6452   emit_insn (gen_ashldi3 (i1, i1, GEN_INT (63)));
6453   emit_insn (gen_xordi3 (out, i0, i1));
6454
6455   emit_label (donelab);
6456 }
6457
6458 /* Return the string to output a conditional branch to LABEL, testing
6459    register REG.  LABEL is the operand number of the label; REG is the
6460    operand number of the reg.  OP is the conditional expression.  The mode
6461    of REG says what kind of comparison we made.
6462
6463    DEST is the destination insn (i.e. the label), INSN is the source.
6464
6465    REVERSED is nonzero if we should reverse the sense of the comparison.
6466
6467    ANNUL is nonzero if we should generate an annulling branch.  */
6468
6469 const char *
6470 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
6471                  int annul, rtx insn)
6472 {
6473   static char string[64];
6474   enum rtx_code code = GET_CODE (op);
6475   enum machine_mode mode = GET_MODE (XEXP (op, 0));
6476   rtx note;
6477   int far;
6478   char *p;
6479
6480   /* branch on register are limited to +-128KB.  If it is too far away,
6481      change
6482
6483      brnz,pt %g1, .LC30
6484
6485      to
6486
6487      brz,pn %g1, .+12
6488       nop
6489      ba,pt %xcc, .LC30
6490
6491      and
6492
6493      brgez,a,pn %o1, .LC29
6494
6495      to
6496
6497      brlz,pt %o1, .+16
6498       nop
6499      ba,pt %xcc, .LC29  */
6500
6501   far = get_attr_length (insn) >= 3;
6502
6503   /* If not floating-point or if EQ or NE, we can just reverse the code.  */
6504   if (reversed ^ far)
6505     code = reverse_condition (code);
6506
6507   /* Only 64 bit versions of these instructions exist.  */
6508   gcc_assert (mode == DImode);
6509
6510   /* Start by writing the branch condition.  */
6511
6512   switch (code)
6513     {
6514     case NE:
6515       strcpy (string, "brnz");
6516       break;
6517
6518     case EQ:
6519       strcpy (string, "brz");
6520       break;
6521
6522     case GE:
6523       strcpy (string, "brgez");
6524       break;
6525
6526     case LT:
6527       strcpy (string, "brlz");
6528       break;
6529
6530     case LE:
6531       strcpy (string, "brlez");
6532       break;
6533
6534     case GT:
6535       strcpy (string, "brgz");
6536       break;
6537
6538     default:
6539       gcc_unreachable ();
6540     }
6541
6542   p = strchr (string, '\0');
6543
6544   /* Now add the annulling, reg, label, and nop.  */
6545   if (annul && ! far)
6546     {
6547       strcpy (p, ",a");
6548       p += 2;
6549     }
6550
6551   if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6552     {
6553       strcpy (p,
6554               ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6555               ? ",pt" : ",pn");
6556       p += 3;
6557     }
6558
6559   *p = p < string + 8 ? '\t' : ' ';
6560   p++;
6561   *p++ = '%';
6562   *p++ = '0' + reg;
6563   *p++ = ',';
6564   *p++ = ' ';
6565   if (far)
6566     {
6567       int veryfar = 1, delta;
6568
6569       if (INSN_ADDRESSES_SET_P ())
6570         {
6571           delta = (INSN_ADDRESSES (INSN_UID (dest))
6572                    - INSN_ADDRESSES (INSN_UID (insn)));
6573           /* Leave some instructions for "slop".  */
6574           if (delta >= -260000 && delta < 260000)
6575             veryfar = 0;
6576         }
6577
6578       strcpy (p, ".+12\n\t nop\n\t");
6579       /* Skip the next insn if requested or
6580          if we know that it will be a nop.  */
6581       if (annul || ! final_sequence)
6582         p[3] = '6';
6583       p += 12;
6584       if (veryfar)
6585         {
6586           strcpy (p, "b\t");
6587           p += 2;
6588         }
6589       else
6590         {
6591           strcpy (p, "ba,pt\t%%xcc, ");
6592           p += 13;
6593         }
6594     }
6595   *p++ = '%';
6596   *p++ = 'l';
6597   *p++ = '0' + label;
6598   *p++ = '%';
6599   *p++ = '#';
6600   *p = '\0';
6601
6602   return string;
6603 }
6604
6605 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
6606    Such instructions cannot be used in the delay slot of return insn on v9.
6607    If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
6608  */
6609
6610 static int
6611 epilogue_renumber (register rtx *where, int test)
6612 {
6613   register const char *fmt;
6614   register int i;
6615   register enum rtx_code code;
6616
6617   if (*where == 0)
6618     return 0;
6619
6620   code = GET_CODE (*where);
6621
6622   switch (code)
6623     {
6624     case REG:
6625       if (REGNO (*where) >= 8 && REGNO (*where) < 24)      /* oX or lX */
6626         return 1;
6627       if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
6628         *where = gen_rtx_REG (GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
6629     case SCRATCH:
6630     case CC0:
6631     case PC:
6632     case CONST_INT:
6633     case CONST_DOUBLE:
6634       return 0;
6635
6636       /* Do not replace the frame pointer with the stack pointer because
6637          it can cause the delayed instruction to load below the stack.
6638          This occurs when instructions like:
6639
6640          (set (reg/i:SI 24 %i0)
6641              (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
6642                        (const_int -20 [0xffffffec])) 0))
6643
6644          are in the return delayed slot.  */
6645     case PLUS:
6646       if (GET_CODE (XEXP (*where, 0)) == REG
6647           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
6648           && (GET_CODE (XEXP (*where, 1)) != CONST_INT
6649               || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
6650         return 1;
6651       break;
6652
6653     case MEM:
6654       if (SPARC_STACK_BIAS
6655           && GET_CODE (XEXP (*where, 0)) == REG
6656           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
6657         return 1;
6658       break;
6659
6660     default:
6661       break;
6662     }
6663
6664   fmt = GET_RTX_FORMAT (code);
6665
6666   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6667     {
6668       if (fmt[i] == 'E')
6669         {
6670           register int j;
6671           for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
6672             if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
6673               return 1;
6674         }
6675       else if (fmt[i] == 'e'
6676                && epilogue_renumber (&(XEXP (*where, i)), test))
6677         return 1;
6678     }
6679   return 0;
6680 }
6681 \f
6682 /* Leaf functions and non-leaf functions have different needs.  */
6683
6684 static const int
6685 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
6686
6687 static const int
6688 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
6689
6690 static const int *const reg_alloc_orders[] = {
6691   reg_leaf_alloc_order,
6692   reg_nonleaf_alloc_order};
6693
6694 void
6695 order_regs_for_local_alloc (void)
6696 {
6697   static int last_order_nonleaf = 1;
6698
6699   if (df_regs_ever_live_p (15) != last_order_nonleaf)
6700     {
6701       last_order_nonleaf = !last_order_nonleaf;
6702       memcpy ((char *) reg_alloc_order,
6703               (const char *) reg_alloc_orders[last_order_nonleaf],
6704               FIRST_PSEUDO_REGISTER * sizeof (int));
6705     }
6706 }
6707 \f
6708 /* Return 1 if REG and MEM are legitimate enough to allow the various
6709    mem<-->reg splits to be run.  */
6710
6711 int
6712 sparc_splitdi_legitimate (rtx reg, rtx mem)
6713 {
6714   /* Punt if we are here by mistake.  */
6715   gcc_assert (reload_completed);
6716
6717   /* We must have an offsettable memory reference.  */
6718   if (! offsettable_memref_p (mem))
6719     return 0;
6720
6721   /* If we have legitimate args for ldd/std, we do not want
6722      the split to happen.  */
6723   if ((REGNO (reg) % 2) == 0
6724       && mem_min_alignment (mem, 8))
6725     return 0;
6726
6727   /* Success.  */
6728   return 1;
6729 }
6730
6731 /* Return 1 if x and y are some kind of REG and they refer to
6732    different hard registers.  This test is guaranteed to be
6733    run after reload.  */
6734
6735 int
6736 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
6737 {
6738   if (GET_CODE (x) != REG)
6739     return 0;
6740   if (GET_CODE (y) != REG)
6741     return 0;
6742   if (REGNO (x) == REGNO (y))
6743     return 0;
6744   return 1;
6745 }
6746
6747 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
6748    This makes them candidates for using ldd and std insns.
6749
6750    Note reg1 and reg2 *must* be hard registers.  */
6751
6752 int
6753 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
6754 {
6755   /* We might have been passed a SUBREG.  */
6756   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
6757     return 0;
6758
6759   if (REGNO (reg1) % 2 != 0)
6760     return 0;
6761
6762   /* Integer ldd is deprecated in SPARC V9 */
6763   if (TARGET_V9 && REGNO (reg1) < 32)
6764     return 0;
6765
6766   return (REGNO (reg1) == REGNO (reg2) - 1);
6767 }
6768
6769 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
6770    an ldd or std insn.
6771
6772    This can only happen when addr1 and addr2, the addresses in mem1
6773    and mem2, are consecutive memory locations (addr1 + 4 == addr2).
6774    addr1 must also be aligned on a 64-bit boundary.
6775
6776    Also iff dependent_reg_rtx is not null it should not be used to
6777    compute the address for mem1, i.e. we cannot optimize a sequence
6778    like:
6779         ld [%o0], %o0
6780         ld [%o0 + 4], %o1
6781    to
6782         ldd [%o0], %o0
6783    nor:
6784         ld [%g3 + 4], %g3
6785         ld [%g3], %g2
6786    to
6787         ldd [%g3], %g2
6788
6789    But, note that the transformation from:
6790         ld [%g2 + 4], %g3
6791         ld [%g2], %g2
6792    to
6793         ldd [%g2], %g2
6794    is perfectly fine.  Thus, the peephole2 patterns always pass us
6795    the destination register of the first load, never the second one.
6796
6797    For stores we don't have a similar problem, so dependent_reg_rtx is
6798    NULL_RTX.  */
6799
6800 int
6801 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
6802 {
6803   rtx addr1, addr2;
6804   unsigned int reg1;
6805   HOST_WIDE_INT offset1;
6806
6807   /* The mems cannot be volatile.  */
6808   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
6809     return 0;
6810
6811   /* MEM1 should be aligned on a 64-bit boundary.  */
6812   if (MEM_ALIGN (mem1) < 64)
6813     return 0;
6814
6815   addr1 = XEXP (mem1, 0);
6816   addr2 = XEXP (mem2, 0);
6817
6818   /* Extract a register number and offset (if used) from the first addr.  */
6819   if (GET_CODE (addr1) == PLUS)
6820     {
6821       /* If not a REG, return zero.  */
6822       if (GET_CODE (XEXP (addr1, 0)) != REG)
6823         return 0;
6824       else
6825         {
6826           reg1 = REGNO (XEXP (addr1, 0));
6827           /* The offset must be constant!  */
6828           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
6829             return 0;
6830           offset1 = INTVAL (XEXP (addr1, 1));
6831         }
6832     }
6833   else if (GET_CODE (addr1) != REG)
6834     return 0;
6835   else
6836     {
6837       reg1 = REGNO (addr1);
6838       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
6839       offset1 = 0;
6840     }
6841
6842   /* Make sure the second address is a (mem (plus (reg) (const_int).  */
6843   if (GET_CODE (addr2) != PLUS)
6844     return 0;
6845
6846   if (GET_CODE (XEXP (addr2, 0)) != REG
6847       || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
6848     return 0;
6849
6850   if (reg1 != REGNO (XEXP (addr2, 0)))
6851     return 0;
6852
6853   if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
6854     return 0;
6855
6856   /* The first offset must be evenly divisible by 8 to ensure the
6857      address is 64 bit aligned.  */
6858   if (offset1 % 8 != 0)
6859     return 0;
6860
6861   /* The offset for the second addr must be 4 more than the first addr.  */
6862   if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
6863     return 0;
6864
6865   /* All the tests passed.  addr1 and addr2 are valid for ldd and std
6866      instructions.  */
6867   return 1;
6868 }
6869
6870 /* Return 1 if reg is a pseudo, or is the first register in
6871    a hard register pair.  This makes it suitable for use in
6872    ldd and std insns.  */
6873
6874 int
6875 register_ok_for_ldd (rtx reg)
6876 {
6877   /* We might have been passed a SUBREG.  */
6878   if (!REG_P (reg))
6879     return 0;
6880
6881   if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
6882     return (REGNO (reg) % 2 == 0);
6883
6884   return 1;
6885 }
6886
6887 /* Return 1 if OP is a memory whose address is known to be
6888    aligned to 8-byte boundary, or a pseudo during reload.
6889    This makes it suitable for use in ldd and std insns.  */
6890
6891 int
6892 memory_ok_for_ldd (rtx op)
6893 {
6894   if (MEM_P (op))
6895     {
6896       /* In 64-bit mode, we assume that the address is word-aligned.  */
6897       if (TARGET_ARCH32 && !mem_min_alignment (op, 8))
6898         return 0;
6899
6900       if ((reload_in_progress || reload_completed)
6901           && !strict_memory_address_p (Pmode, XEXP (op, 0)))
6902         return 0;
6903     }
6904   else if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
6905     {
6906       if (!(reload_in_progress && reg_renumber [REGNO (op)] < 0))
6907         return 0;
6908     }
6909   else
6910     return 0;
6911
6912   return 1;
6913 }
6914 \f
6915 /* Print operand X (an rtx) in assembler syntax to file FILE.
6916    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
6917    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
6918
6919 void
6920 print_operand (FILE *file, rtx x, int code)
6921 {
6922   switch (code)
6923     {
6924     case '#':
6925       /* Output an insn in a delay slot.  */
6926       if (final_sequence)
6927         sparc_indent_opcode = 1;
6928       else
6929         fputs ("\n\t nop", file);
6930       return;
6931     case '*':
6932       /* Output an annul flag if there's nothing for the delay slot and we
6933          are optimizing.  This is always used with '(' below.
6934          Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
6935          this is a dbx bug.  So, we only do this when optimizing.
6936          On UltraSPARC, a branch in a delay slot causes a pipeline flush.
6937          Always emit a nop in case the next instruction is a branch.  */
6938       if (! final_sequence && (optimize && (int)sparc_cpu < PROCESSOR_V9))
6939         fputs (",a", file);
6940       return;
6941     case '(':
6942       /* Output a 'nop' if there's nothing for the delay slot and we are
6943          not optimizing.  This is always used with '*' above.  */
6944       if (! final_sequence && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
6945         fputs ("\n\t nop", file);
6946       else if (final_sequence)
6947         sparc_indent_opcode = 1;
6948       return;
6949     case ')':
6950       /* Output the right displacement from the saved PC on function return.
6951          The caller may have placed an "unimp" insn immediately after the call
6952          so we have to account for it.  This insn is used in the 32-bit ABI
6953          when calling a function that returns a non zero-sized structure. The
6954          64-bit ABI doesn't have it.  Be careful to have this test be the same
6955          as that used on the call. The exception here is that when
6956          sparc_std_struct_return is enabled, the psABI is followed exactly
6957          and the adjustment is made by the code in sparc_struct_value_rtx.
6958          The call emitted is the same when sparc_std_struct_return is
6959          present. */
6960      if (! TARGET_ARCH64
6961          && cfun->returns_struct
6962          && ! sparc_std_struct_return
6963          && (TREE_CODE (DECL_SIZE (DECL_RESULT (current_function_decl)))
6964              == INTEGER_CST)
6965          && ! integer_zerop (DECL_SIZE (DECL_RESULT (current_function_decl))))
6966         fputs ("12", file);
6967       else
6968         fputc ('8', file);
6969       return;
6970     case '_':
6971       /* Output the Embedded Medium/Anywhere code model base register.  */
6972       fputs (EMBMEDANY_BASE_REG, file);
6973       return;
6974     case '&':
6975       /* Print some local dynamic TLS name.  */
6976       assemble_name (file, get_some_local_dynamic_name ());
6977       return;
6978
6979     case 'Y':
6980       /* Adjust the operand to take into account a RESTORE operation.  */
6981       if (GET_CODE (x) == CONST_INT)
6982         break;
6983       else if (GET_CODE (x) != REG)
6984         output_operand_lossage ("invalid %%Y operand");
6985       else if (REGNO (x) < 8)
6986         fputs (reg_names[REGNO (x)], file);
6987       else if (REGNO (x) >= 24 && REGNO (x) < 32)
6988         fputs (reg_names[REGNO (x)-16], file);
6989       else
6990         output_operand_lossage ("invalid %%Y operand");
6991       return;
6992     case 'L':
6993       /* Print out the low order register name of a register pair.  */
6994       if (WORDS_BIG_ENDIAN)
6995         fputs (reg_names[REGNO (x)+1], file);
6996       else
6997         fputs (reg_names[REGNO (x)], file);
6998       return;
6999     case 'H':
7000       /* Print out the high order register name of a register pair.  */
7001       if (WORDS_BIG_ENDIAN)
7002         fputs (reg_names[REGNO (x)], file);
7003       else
7004         fputs (reg_names[REGNO (x)+1], file);
7005       return;
7006     case 'R':
7007       /* Print out the second register name of a register pair or quad.
7008          I.e., R (%o0) => %o1.  */
7009       fputs (reg_names[REGNO (x)+1], file);
7010       return;
7011     case 'S':
7012       /* Print out the third register name of a register quad.
7013          I.e., S (%o0) => %o2.  */
7014       fputs (reg_names[REGNO (x)+2], file);
7015       return;
7016     case 'T':
7017       /* Print out the fourth register name of a register quad.
7018          I.e., T (%o0) => %o3.  */
7019       fputs (reg_names[REGNO (x)+3], file);
7020       return;
7021     case 'x':
7022       /* Print a condition code register.  */
7023       if (REGNO (x) == SPARC_ICC_REG)
7024         {
7025           /* We don't handle CC[X]_NOOVmode because they're not supposed
7026              to occur here.  */
7027           if (GET_MODE (x) == CCmode)
7028             fputs ("%icc", file);
7029           else if (GET_MODE (x) == CCXmode)
7030             fputs ("%xcc", file);
7031           else
7032             gcc_unreachable ();
7033         }
7034       else
7035         /* %fccN register */
7036         fputs (reg_names[REGNO (x)], file);
7037       return;
7038     case 'm':
7039       /* Print the operand's address only.  */
7040       output_address (XEXP (x, 0));
7041       return;
7042     case 'r':
7043       /* In this case we need a register.  Use %g0 if the
7044          operand is const0_rtx.  */
7045       if (x == const0_rtx
7046           || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
7047         {
7048           fputs ("%g0", file);
7049           return;
7050         }
7051       else
7052         break;
7053
7054     case 'A':
7055       switch (GET_CODE (x))
7056         {
7057         case IOR: fputs ("or", file); break;
7058         case AND: fputs ("and", file); break;
7059         case XOR: fputs ("xor", file); break;
7060         default: output_operand_lossage ("invalid %%A operand");
7061         }
7062       return;
7063
7064     case 'B':
7065       switch (GET_CODE (x))
7066         {
7067         case IOR: fputs ("orn", file); break;
7068         case AND: fputs ("andn", file); break;
7069         case XOR: fputs ("xnor", file); break;
7070         default: output_operand_lossage ("invalid %%B operand");
7071         }
7072       return;
7073
7074       /* These are used by the conditional move instructions.  */
7075     case 'c' :
7076     case 'C':
7077       {
7078         enum rtx_code rc = GET_CODE (x);
7079
7080         if (code == 'c')
7081           {
7082             enum machine_mode mode = GET_MODE (XEXP (x, 0));
7083             if (mode == CCFPmode || mode == CCFPEmode)
7084               rc = reverse_condition_maybe_unordered (GET_CODE (x));
7085             else
7086               rc = reverse_condition (GET_CODE (x));
7087           }
7088         switch (rc)
7089           {
7090           case NE: fputs ("ne", file); break;
7091           case EQ: fputs ("e", file); break;
7092           case GE: fputs ("ge", file); break;
7093           case GT: fputs ("g", file); break;
7094           case LE: fputs ("le", file); break;
7095           case LT: fputs ("l", file); break;
7096           case GEU: fputs ("geu", file); break;
7097           case GTU: fputs ("gu", file); break;
7098           case LEU: fputs ("leu", file); break;
7099           case LTU: fputs ("lu", file); break;
7100           case LTGT: fputs ("lg", file); break;
7101           case UNORDERED: fputs ("u", file); break;
7102           case ORDERED: fputs ("o", file); break;
7103           case UNLT: fputs ("ul", file); break;
7104           case UNLE: fputs ("ule", file); break;
7105           case UNGT: fputs ("ug", file); break;
7106           case UNGE: fputs ("uge", file); break;
7107           case UNEQ: fputs ("ue", file); break;
7108           default: output_operand_lossage (code == 'c'
7109                                            ? "invalid %%c operand"
7110                                            : "invalid %%C operand");
7111           }
7112         return;
7113       }
7114
7115       /* These are used by the movr instruction pattern.  */
7116     case 'd':
7117     case 'D':
7118       {
7119         enum rtx_code rc = (code == 'd'
7120                             ? reverse_condition (GET_CODE (x))
7121                             : GET_CODE (x));
7122         switch (rc)
7123           {
7124           case NE: fputs ("ne", file); break;
7125           case EQ: fputs ("e", file); break;
7126           case GE: fputs ("gez", file); break;
7127           case LT: fputs ("lz", file); break;
7128           case LE: fputs ("lez", file); break;
7129           case GT: fputs ("gz", file); break;
7130           default: output_operand_lossage (code == 'd'
7131                                            ? "invalid %%d operand"
7132                                            : "invalid %%D operand");
7133           }
7134         return;
7135       }
7136
7137     case 'b':
7138       {
7139         /* Print a sign-extended character.  */
7140         int i = trunc_int_for_mode (INTVAL (x), QImode);
7141         fprintf (file, "%d", i);
7142         return;
7143       }
7144
7145     case 'f':
7146       /* Operand must be a MEM; write its address.  */
7147       if (GET_CODE (x) != MEM)
7148         output_operand_lossage ("invalid %%f operand");
7149       output_address (XEXP (x, 0));
7150       return;
7151
7152     case 's':
7153       {
7154         /* Print a sign-extended 32-bit value.  */
7155         HOST_WIDE_INT i;
7156         if (GET_CODE(x) == CONST_INT)
7157           i = INTVAL (x);
7158         else if (GET_CODE(x) == CONST_DOUBLE)
7159           i = CONST_DOUBLE_LOW (x);
7160         else
7161           {
7162             output_operand_lossage ("invalid %%s operand");
7163             return;
7164           }
7165         i = trunc_int_for_mode (i, SImode);
7166         fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
7167         return;
7168       }
7169
7170     case 0:
7171       /* Do nothing special.  */
7172       break;
7173
7174     default:
7175       /* Undocumented flag.  */
7176       output_operand_lossage ("invalid operand output code");
7177     }
7178
7179   if (GET_CODE (x) == REG)
7180     fputs (reg_names[REGNO (x)], file);
7181   else if (GET_CODE (x) == MEM)
7182     {
7183       fputc ('[', file);
7184         /* Poor Sun assembler doesn't understand absolute addressing.  */
7185       if (CONSTANT_P (XEXP (x, 0)))
7186         fputs ("%g0+", file);
7187       output_address (XEXP (x, 0));
7188       fputc (']', file);
7189     }
7190   else if (GET_CODE (x) == HIGH)
7191     {
7192       fputs ("%hi(", file);
7193       output_addr_const (file, XEXP (x, 0));
7194       fputc (')', file);
7195     }
7196   else if (GET_CODE (x) == LO_SUM)
7197     {
7198       print_operand (file, XEXP (x, 0), 0);
7199       if (TARGET_CM_MEDMID)
7200         fputs ("+%l44(", file);
7201       else
7202         fputs ("+%lo(", file);
7203       output_addr_const (file, XEXP (x, 1));
7204       fputc (')', file);
7205     }
7206   else if (GET_CODE (x) == CONST_DOUBLE
7207            && (GET_MODE (x) == VOIDmode
7208                || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
7209     {
7210       if (CONST_DOUBLE_HIGH (x) == 0)
7211         fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
7212       else if (CONST_DOUBLE_HIGH (x) == -1
7213                && CONST_DOUBLE_LOW (x) < 0)
7214         fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
7215       else
7216         output_operand_lossage ("long long constant not a valid immediate operand");
7217     }
7218   else if (GET_CODE (x) == CONST_DOUBLE)
7219     output_operand_lossage ("floating point constant not a valid immediate operand");
7220   else { output_addr_const (file, x); }
7221 }
7222 \f
7223 /* Target hook for assembling integer objects.  The sparc version has
7224    special handling for aligned DI-mode objects.  */
7225
7226 static bool
7227 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
7228 {
7229   /* ??? We only output .xword's for symbols and only then in environments
7230      where the assembler can handle them.  */
7231   if (aligned_p && size == 8
7232       && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
7233     {
7234       if (TARGET_V9)
7235         {
7236           assemble_integer_with_op ("\t.xword\t", x);
7237           return true;
7238         }
7239       else
7240         {
7241           assemble_aligned_integer (4, const0_rtx);
7242           assemble_aligned_integer (4, x);
7243           return true;
7244         }
7245     }
7246   return default_assemble_integer (x, size, aligned_p);
7247 }
7248 \f
7249 /* Return the value of a code used in the .proc pseudo-op that says
7250    what kind of result this function returns.  For non-C types, we pick
7251    the closest C type.  */
7252
7253 #ifndef SHORT_TYPE_SIZE
7254 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
7255 #endif
7256
7257 #ifndef INT_TYPE_SIZE
7258 #define INT_TYPE_SIZE BITS_PER_WORD
7259 #endif
7260
7261 #ifndef LONG_TYPE_SIZE
7262 #define LONG_TYPE_SIZE BITS_PER_WORD
7263 #endif
7264
7265 #ifndef LONG_LONG_TYPE_SIZE
7266 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
7267 #endif
7268
7269 #ifndef FLOAT_TYPE_SIZE
7270 #define FLOAT_TYPE_SIZE BITS_PER_WORD
7271 #endif
7272
7273 #ifndef DOUBLE_TYPE_SIZE
7274 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7275 #endif
7276
7277 #ifndef LONG_DOUBLE_TYPE_SIZE
7278 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7279 #endif
7280
7281 unsigned long
7282 sparc_type_code (register tree type)
7283 {
7284   register unsigned long qualifiers = 0;
7285   register unsigned shift;
7286
7287   /* Only the first 30 bits of the qualifier are valid.  We must refrain from
7288      setting more, since some assemblers will give an error for this.  Also,
7289      we must be careful to avoid shifts of 32 bits or more to avoid getting
7290      unpredictable results.  */
7291
7292   for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
7293     {
7294       switch (TREE_CODE (type))
7295         {
7296         case ERROR_MARK:
7297           return qualifiers;
7298
7299         case ARRAY_TYPE:
7300           qualifiers |= (3 << shift);
7301           break;
7302
7303         case FUNCTION_TYPE:
7304         case METHOD_TYPE:
7305           qualifiers |= (2 << shift);
7306           break;
7307
7308         case POINTER_TYPE:
7309         case REFERENCE_TYPE:
7310         case OFFSET_TYPE:
7311           qualifiers |= (1 << shift);
7312           break;
7313
7314         case RECORD_TYPE:
7315           return (qualifiers | 8);
7316
7317         case UNION_TYPE:
7318         case QUAL_UNION_TYPE:
7319           return (qualifiers | 9);
7320
7321         case ENUMERAL_TYPE:
7322           return (qualifiers | 10);
7323
7324         case VOID_TYPE:
7325           return (qualifiers | 16);
7326
7327         case INTEGER_TYPE:
7328           /* If this is a range type, consider it to be the underlying
7329              type.  */
7330           if (TREE_TYPE (type) != 0)
7331             break;
7332
7333           /* Carefully distinguish all the standard types of C,
7334              without messing up if the language is not C.  We do this by
7335              testing TYPE_PRECISION and TYPE_UNSIGNED.  The old code used to
7336              look at both the names and the above fields, but that's redundant.
7337              Any type whose size is between two C types will be considered
7338              to be the wider of the two types.  Also, we do not have a
7339              special code to use for "long long", so anything wider than
7340              long is treated the same.  Note that we can't distinguish
7341              between "int" and "long" in this code if they are the same
7342              size, but that's fine, since neither can the assembler.  */
7343
7344           if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
7345             return (qualifiers | (TYPE_UNSIGNED (type) ? 12 : 2));
7346
7347           else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
7348             return (qualifiers | (TYPE_UNSIGNED (type) ? 13 : 3));
7349
7350           else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
7351             return (qualifiers | (TYPE_UNSIGNED (type) ? 14 : 4));
7352
7353           else
7354             return (qualifiers | (TYPE_UNSIGNED (type) ? 15 : 5));
7355
7356         case REAL_TYPE:
7357           /* If this is a range type, consider it to be the underlying
7358              type.  */
7359           if (TREE_TYPE (type) != 0)
7360             break;
7361
7362           /* Carefully distinguish all the standard types of C,
7363              without messing up if the language is not C.  */
7364
7365           if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
7366             return (qualifiers | 6);
7367
7368           else
7369             return (qualifiers | 7);
7370
7371         case COMPLEX_TYPE:      /* GNU Fortran COMPLEX type.  */
7372           /* ??? We need to distinguish between double and float complex types,
7373              but I don't know how yet because I can't reach this code from
7374              existing front-ends.  */
7375           return (qualifiers | 7);      /* Who knows? */
7376
7377         case VECTOR_TYPE:
7378         case BOOLEAN_TYPE:      /* Boolean truth value type.  */
7379         case LANG_TYPE:         /* ? */
7380           return qualifiers;
7381
7382         default:
7383           gcc_unreachable ();           /* Not a type! */
7384         }
7385     }
7386
7387   return qualifiers;
7388 }
7389 \f
7390 /* Nested function support.  */
7391
7392 /* Emit RTL insns to initialize the variable parts of a trampoline.
7393    FNADDR is an RTX for the address of the function's pure code.
7394    CXT is an RTX for the static chain value for the function.
7395
7396    This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
7397    (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
7398    (to store insns).  This is a bit excessive.  Perhaps a different
7399    mechanism would be better here.
7400
7401    Emit enough FLUSH insns to synchronize the data and instruction caches.  */
7402
7403 void
7404 sparc_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7405 {
7406   /* SPARC 32-bit trampoline:
7407
7408         sethi   %hi(fn), %g1
7409         sethi   %hi(static), %g2
7410         jmp     %g1+%lo(fn)
7411         or      %g2, %lo(static), %g2
7412
7413     SETHI i,r  = 00rr rrr1 00ii iiii iiii iiii iiii iiii
7414     JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
7415    */
7416
7417   emit_move_insn
7418     (gen_rtx_MEM (SImode, plus_constant (tramp, 0)),
7419      expand_binop (SImode, ior_optab,
7420                    expand_shift (RSHIFT_EXPR, SImode, fnaddr,
7421                                  size_int (10), 0, 1),
7422                    GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
7423                    NULL_RTX, 1, OPTAB_DIRECT));
7424
7425   emit_move_insn
7426     (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7427      expand_binop (SImode, ior_optab,
7428                    expand_shift (RSHIFT_EXPR, SImode, cxt,
7429                                  size_int (10), 0, 1),
7430                    GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
7431                    NULL_RTX, 1, OPTAB_DIRECT));
7432
7433   emit_move_insn
7434     (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7435      expand_binop (SImode, ior_optab,
7436                    expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
7437                    GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
7438                    NULL_RTX, 1, OPTAB_DIRECT));
7439
7440   emit_move_insn
7441     (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7442      expand_binop (SImode, ior_optab,
7443                    expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
7444                    GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
7445                    NULL_RTX, 1, OPTAB_DIRECT));
7446
7447   /* On UltraSPARC a flush flushes an entire cache line.  The trampoline is
7448      aligned on a 16 byte boundary so one flush clears it all.  */
7449   emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode, tramp))));
7450   if (sparc_cpu != PROCESSOR_ULTRASPARC
7451       && sparc_cpu != PROCESSOR_ULTRASPARC3
7452       && sparc_cpu != PROCESSOR_NIAGARA
7453       && sparc_cpu != PROCESSOR_NIAGARA2)
7454     emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode,
7455                                                      plus_constant (tramp, 8)))));
7456
7457   /* Call __enable_execute_stack after writing onto the stack to make sure
7458      the stack address is accessible.  */
7459 #ifdef ENABLE_EXECUTE_STACK
7460   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
7461                      LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7462 #endif
7463
7464 }
7465
7466 /* The 64-bit version is simpler because it makes more sense to load the
7467    values as "immediate" data out of the trampoline.  It's also easier since
7468    we can read the PC without clobbering a register.  */
7469
7470 void
7471 sparc64_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7472 {
7473   /* SPARC 64-bit trampoline:
7474
7475         rd      %pc, %g1
7476         ldx     [%g1+24], %g5
7477         jmp     %g5
7478         ldx     [%g1+16], %g5
7479         +16 bytes data
7480    */
7481
7482   emit_move_insn (gen_rtx_MEM (SImode, tramp),
7483                   GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
7484   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7485                   GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
7486   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7487                   GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
7488   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7489                   GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
7490   emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 16)), cxt);
7491   emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 24)), fnaddr);
7492   emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, tramp))));
7493
7494   if (sparc_cpu != PROCESSOR_ULTRASPARC
7495       && sparc_cpu != PROCESSOR_ULTRASPARC3
7496       && sparc_cpu != PROCESSOR_NIAGARA
7497       && sparc_cpu != PROCESSOR_NIAGARA2)
7498     emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, plus_constant (tramp, 8)))));
7499
7500   /* Call __enable_execute_stack after writing onto the stack to make sure
7501      the stack address is accessible.  */
7502 #ifdef ENABLE_EXECUTE_STACK
7503   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
7504                      LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7505 #endif
7506 }
7507 \f
7508 /* Adjust the cost of a scheduling dependency.  Return the new cost of
7509    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
7510
7511 static int
7512 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
7513 {
7514   enum attr_type insn_type;
7515
7516   if (! recog_memoized (insn))
7517     return 0;
7518
7519   insn_type = get_attr_type (insn);
7520
7521   if (REG_NOTE_KIND (link) == 0)
7522     {
7523       /* Data dependency; DEP_INSN writes a register that INSN reads some
7524          cycles later.  */
7525
7526       /* if a load, then the dependence must be on the memory address;
7527          add an extra "cycle".  Note that the cost could be two cycles
7528          if the reg was written late in an instruction group; we ca not tell
7529          here.  */
7530       if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
7531         return cost + 3;
7532
7533       /* Get the delay only if the address of the store is the dependence.  */
7534       if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
7535         {
7536           rtx pat = PATTERN(insn);
7537           rtx dep_pat = PATTERN (dep_insn);
7538
7539           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
7540             return cost;  /* This should not happen!  */
7541
7542           /* The dependency between the two instructions was on the data that
7543              is being stored.  Assume that this implies that the address of the
7544              store is not dependent.  */
7545           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
7546             return cost;
7547
7548           return cost + 3;  /* An approximation.  */
7549         }
7550
7551       /* A shift instruction cannot receive its data from an instruction
7552          in the same cycle; add a one cycle penalty.  */
7553       if (insn_type == TYPE_SHIFT)
7554         return cost + 3;   /* Split before cascade into shift.  */
7555     }
7556   else
7557     {
7558       /* Anti- or output- dependency; DEP_INSN reads/writes a register that
7559          INSN writes some cycles later.  */
7560
7561       /* These are only significant for the fpu unit; writing a fp reg before
7562          the fpu has finished with it stalls the processor.  */
7563
7564       /* Reusing an integer register causes no problems.  */
7565       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
7566         return 0;
7567     }
7568
7569   return cost;
7570 }
7571
7572 static int
7573 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
7574 {
7575   enum attr_type insn_type, dep_type;
7576   rtx pat = PATTERN(insn);
7577   rtx dep_pat = PATTERN (dep_insn);
7578
7579   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
7580     return cost;
7581
7582   insn_type = get_attr_type (insn);
7583   dep_type = get_attr_type (dep_insn);
7584
7585   switch (REG_NOTE_KIND (link))
7586     {
7587     case 0:
7588       /* Data dependency; DEP_INSN writes a register that INSN reads some
7589          cycles later.  */
7590
7591       switch (insn_type)
7592         {
7593         case TYPE_STORE:
7594         case TYPE_FPSTORE:
7595           /* Get the delay iff the address of the store is the dependence.  */
7596           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
7597             return cost;
7598
7599           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
7600             return cost;
7601           return cost + 3;
7602
7603         case TYPE_LOAD:
7604         case TYPE_SLOAD:
7605         case TYPE_FPLOAD:
7606           /* If a load, then the dependence must be on the memory address.  If
7607              the addresses aren't equal, then it might be a false dependency */
7608           if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
7609             {
7610               if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
7611                   || GET_CODE (SET_DEST (dep_pat)) != MEM
7612                   || GET_CODE (SET_SRC (pat)) != MEM
7613                   || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
7614                                     XEXP (SET_SRC (pat), 0)))
7615                 return cost + 2;
7616
7617               return cost + 8;
7618             }
7619           break;
7620
7621         case TYPE_BRANCH:
7622           /* Compare to branch latency is 0.  There is no benefit from
7623              separating compare and branch.  */
7624           if (dep_type == TYPE_COMPARE)
7625             return 0;
7626           /* Floating point compare to branch latency is less than
7627              compare to conditional move.  */
7628           if (dep_type == TYPE_FPCMP)
7629             return cost - 1;
7630           break;
7631         default:
7632           break;
7633         }
7634         break;
7635
7636     case REG_DEP_ANTI:
7637       /* Anti-dependencies only penalize the fpu unit.  */
7638       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
7639         return 0;
7640       break;
7641
7642     default:
7643       break;
7644     }
7645
7646   return cost;
7647 }
7648
7649 static int
7650 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
7651 {
7652   switch (sparc_cpu)
7653     {
7654     case PROCESSOR_SUPERSPARC:
7655       cost = supersparc_adjust_cost (insn, link, dep, cost);
7656       break;
7657     case PROCESSOR_HYPERSPARC:
7658     case PROCESSOR_SPARCLITE86X:
7659       cost = hypersparc_adjust_cost (insn, link, dep, cost);
7660       break;
7661     default:
7662       break;
7663     }
7664   return cost;
7665 }
7666
7667 static void
7668 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
7669                   int sched_verbose ATTRIBUTE_UNUSED,
7670                   int max_ready ATTRIBUTE_UNUSED)
7671 {
7672 }
7673
7674 static int
7675 sparc_use_sched_lookahead (void)
7676 {
7677   if (sparc_cpu == PROCESSOR_NIAGARA
7678       || sparc_cpu == PROCESSOR_NIAGARA2)
7679     return 0;
7680   if (sparc_cpu == PROCESSOR_ULTRASPARC
7681       || sparc_cpu == PROCESSOR_ULTRASPARC3)
7682     return 4;
7683   if ((1 << sparc_cpu) &
7684       ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
7685        (1 << PROCESSOR_SPARCLITE86X)))
7686     return 3;
7687   return 0;
7688 }
7689
7690 static int
7691 sparc_issue_rate (void)
7692 {
7693   switch (sparc_cpu)
7694     {
7695     case PROCESSOR_NIAGARA:
7696     case PROCESSOR_NIAGARA2:
7697     default:
7698       return 1;
7699     case PROCESSOR_V9:
7700       /* Assume V9 processors are capable of at least dual-issue.  */
7701       return 2;
7702     case PROCESSOR_SUPERSPARC:
7703       return 3;
7704     case PROCESSOR_HYPERSPARC:
7705     case PROCESSOR_SPARCLITE86X:
7706       return 2;
7707     case PROCESSOR_ULTRASPARC:
7708     case PROCESSOR_ULTRASPARC3:
7709       return 4;
7710     }
7711 }
7712
7713 static int
7714 set_extends (rtx insn)
7715 {
7716   register rtx pat = PATTERN (insn);
7717
7718   switch (GET_CODE (SET_SRC (pat)))
7719     {
7720       /* Load and some shift instructions zero extend.  */
7721     case MEM:
7722     case ZERO_EXTEND:
7723       /* sethi clears the high bits */
7724     case HIGH:
7725       /* LO_SUM is used with sethi.  sethi cleared the high
7726          bits and the values used with lo_sum are positive */
7727     case LO_SUM:
7728       /* Store flag stores 0 or 1 */
7729     case LT: case LTU:
7730     case GT: case GTU:
7731     case LE: case LEU:
7732     case GE: case GEU:
7733     case EQ:
7734     case NE:
7735       return 1;
7736     case AND:
7737       {
7738         rtx op0 = XEXP (SET_SRC (pat), 0);
7739         rtx op1 = XEXP (SET_SRC (pat), 1);
7740         if (GET_CODE (op1) == CONST_INT)
7741           return INTVAL (op1) >= 0;
7742         if (GET_CODE (op0) != REG)
7743           return 0;
7744         if (sparc_check_64 (op0, insn) == 1)
7745           return 1;
7746         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
7747       }
7748     case IOR:
7749     case XOR:
7750       {
7751         rtx op0 = XEXP (SET_SRC (pat), 0);
7752         rtx op1 = XEXP (SET_SRC (pat), 1);
7753         if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
7754           return 0;
7755         if (GET_CODE (op1) == CONST_INT)
7756           return INTVAL (op1) >= 0;
7757         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
7758       }
7759     case LSHIFTRT:
7760       return GET_MODE (SET_SRC (pat)) == SImode;
7761       /* Positive integers leave the high bits zero.  */
7762     case CONST_DOUBLE:
7763       return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
7764     case CONST_INT:
7765       return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
7766     case ASHIFTRT:
7767     case SIGN_EXTEND:
7768       return - (GET_MODE (SET_SRC (pat)) == SImode);
7769     case REG:
7770       return sparc_check_64 (SET_SRC (pat), insn);
7771     default:
7772       return 0;
7773     }
7774 }
7775
7776 /* We _ought_ to have only one kind per function, but...  */
7777 static GTY(()) rtx sparc_addr_diff_list;
7778 static GTY(()) rtx sparc_addr_list;
7779
7780 void
7781 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
7782 {
7783   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
7784   if (diff)
7785     sparc_addr_diff_list
7786       = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
7787   else
7788     sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
7789 }
7790
7791 static void
7792 sparc_output_addr_vec (rtx vec)
7793 {
7794   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
7795   int idx, vlen = XVECLEN (body, 0);
7796
7797 #ifdef ASM_OUTPUT_ADDR_VEC_START
7798   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
7799 #endif
7800
7801 #ifdef ASM_OUTPUT_CASE_LABEL
7802   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
7803                          NEXT_INSN (lab));
7804 #else
7805   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
7806 #endif
7807
7808   for (idx = 0; idx < vlen; idx++)
7809     {
7810       ASM_OUTPUT_ADDR_VEC_ELT
7811         (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
7812     }
7813
7814 #ifdef ASM_OUTPUT_ADDR_VEC_END
7815   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
7816 #endif
7817 }
7818
7819 static void
7820 sparc_output_addr_diff_vec (rtx vec)
7821 {
7822   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
7823   rtx base = XEXP (XEXP (body, 0), 0);
7824   int idx, vlen = XVECLEN (body, 1);
7825
7826 #ifdef ASM_OUTPUT_ADDR_VEC_START
7827   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
7828 #endif
7829
7830 #ifdef ASM_OUTPUT_CASE_LABEL
7831   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
7832                          NEXT_INSN (lab));
7833 #else
7834   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
7835 #endif
7836
7837   for (idx = 0; idx < vlen; idx++)
7838     {
7839       ASM_OUTPUT_ADDR_DIFF_ELT
7840         (asm_out_file,
7841          body,
7842          CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
7843          CODE_LABEL_NUMBER (base));
7844     }
7845
7846 #ifdef ASM_OUTPUT_ADDR_VEC_END
7847   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
7848 #endif
7849 }
7850
7851 static void
7852 sparc_output_deferred_case_vectors (void)
7853 {
7854   rtx t;
7855   int align;
7856
7857   if (sparc_addr_list == NULL_RTX
7858       && sparc_addr_diff_list == NULL_RTX)
7859     return;
7860
7861   /* Align to cache line in the function's code section.  */
7862   switch_to_section (current_function_section ());
7863
7864   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
7865   if (align > 0)
7866     ASM_OUTPUT_ALIGN (asm_out_file, align);
7867
7868   for (t = sparc_addr_list; t ; t = XEXP (t, 1))
7869     sparc_output_addr_vec (XEXP (t, 0));
7870   for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
7871     sparc_output_addr_diff_vec (XEXP (t, 0));
7872
7873   sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
7874 }
7875
7876 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
7877    unknown.  Return 1 if the high bits are zero, -1 if the register is
7878    sign extended.  */
7879 int
7880 sparc_check_64 (rtx x, rtx insn)
7881 {
7882   /* If a register is set only once it is safe to ignore insns this
7883      code does not know how to handle.  The loop will either recognize
7884      the single set and return the correct value or fail to recognize
7885      it and return 0.  */
7886   int set_once = 0;
7887   rtx y = x;
7888
7889   gcc_assert (GET_CODE (x) == REG);
7890
7891   if (GET_MODE (x) == DImode)
7892     y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
7893
7894   if (flag_expensive_optimizations
7895       && df && DF_REG_DEF_COUNT (REGNO (y)) == 1)
7896     set_once = 1;
7897
7898   if (insn == 0)
7899     {
7900       if (set_once)
7901         insn = get_last_insn_anywhere ();
7902       else
7903         return 0;
7904     }
7905
7906   while ((insn = PREV_INSN (insn)))
7907     {
7908       switch (GET_CODE (insn))
7909         {
7910         case JUMP_INSN:
7911         case NOTE:
7912           break;
7913         case CODE_LABEL:
7914         case CALL_INSN:
7915         default:
7916           if (! set_once)
7917             return 0;
7918           break;
7919         case INSN:
7920           {
7921             rtx pat = PATTERN (insn);
7922             if (GET_CODE (pat) != SET)
7923               return 0;
7924             if (rtx_equal_p (x, SET_DEST (pat)))
7925               return set_extends (insn);
7926             if (y && rtx_equal_p (y, SET_DEST (pat)))
7927               return set_extends (insn);
7928             if (reg_overlap_mentioned_p (SET_DEST (pat), y))
7929               return 0;
7930           }
7931         }
7932     }
7933   return 0;
7934 }
7935
7936 /* Returns assembly code to perform a DImode shift using
7937    a 64-bit global or out register on SPARC-V8+.  */
7938 const char *
7939 output_v8plus_shift (rtx *operands, rtx insn, const char *opcode)
7940 {
7941   static char asm_code[60];
7942
7943   /* The scratch register is only required when the destination
7944      register is not a 64-bit global or out register.  */
7945   if (which_alternative != 2)
7946     operands[3] = operands[0];
7947
7948   /* We can only shift by constants <= 63. */
7949   if (GET_CODE (operands[2]) == CONST_INT)
7950     operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
7951
7952   if (GET_CODE (operands[1]) == CONST_INT)
7953     {
7954       output_asm_insn ("mov\t%1, %3", operands);
7955     }
7956   else
7957     {
7958       output_asm_insn ("sllx\t%H1, 32, %3", operands);
7959       if (sparc_check_64 (operands[1], insn) <= 0)
7960         output_asm_insn ("srl\t%L1, 0, %L1", operands);
7961       output_asm_insn ("or\t%L1, %3, %3", operands);
7962     }
7963
7964   strcpy(asm_code, opcode);
7965
7966   if (which_alternative != 2)
7967     return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
7968   else
7969     return strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
7970 }
7971 \f
7972 /* Output rtl to increment the profiler label LABELNO
7973    for profiling a function entry.  */
7974
7975 void
7976 sparc_profile_hook (int labelno)
7977 {
7978   char buf[32];
7979   rtx lab, fun;
7980
7981   fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
7982   if (NO_PROFILE_COUNTERS)
7983     {
7984       emit_library_call (fun, LCT_NORMAL, VOIDmode, 0);
7985     }
7986   else
7987     {
7988       ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
7989       lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
7990       emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
7991     }
7992 }
7993 \f
7994 #ifdef OBJECT_FORMAT_ELF
7995 static void
7996 sparc_elf_asm_named_section (const char *name, unsigned int flags,
7997                              tree decl)
7998 {
7999   if (flags & SECTION_MERGE)
8000     {
8001       /* entsize cannot be expressed in this section attributes
8002          encoding style.  */
8003       default_elf_asm_named_section (name, flags, decl);
8004       return;
8005     }
8006
8007   fprintf (asm_out_file, "\t.section\t\"%s\"", name);
8008
8009   if (!(flags & SECTION_DEBUG))
8010     fputs (",#alloc", asm_out_file);
8011   if (flags & SECTION_WRITE)
8012     fputs (",#write", asm_out_file);
8013   if (flags & SECTION_TLS)
8014     fputs (",#tls", asm_out_file);
8015   if (flags & SECTION_CODE)
8016     fputs (",#execinstr", asm_out_file);
8017
8018   /* ??? Handle SECTION_BSS.  */
8019
8020   fputc ('\n', asm_out_file);
8021 }
8022 #endif /* OBJECT_FORMAT_ELF */
8023
8024 /* We do not allow indirect calls to be optimized into sibling calls.
8025
8026    We cannot use sibling calls when delayed branches are disabled
8027    because they will likely require the call delay slot to be filled.
8028
8029    Also, on SPARC 32-bit we cannot emit a sibling call when the
8030    current function returns a structure.  This is because the "unimp
8031    after call" convention would cause the callee to return to the
8032    wrong place.  The generic code already disallows cases where the
8033    function being called returns a structure.
8034
8035    It may seem strange how this last case could occur.  Usually there
8036    is code after the call which jumps to epilogue code which dumps the
8037    return value into the struct return area.  That ought to invalidate
8038    the sibling call right?  Well, in the C++ case we can end up passing
8039    the pointer to the struct return area to a constructor (which returns
8040    void) and then nothing else happens.  Such a sibling call would look
8041    valid without the added check here.
8042
8043    VxWorks PIC PLT entries require the global pointer to be initialized
8044    on entry.  We therefore can't emit sibling calls to them.  */
8045 static bool
8046 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
8047 {
8048   return (decl
8049           && flag_delayed_branch
8050           && (TARGET_ARCH64 || ! cfun->returns_struct)
8051           && !(TARGET_VXWORKS_RTP
8052                && flag_pic
8053                && !targetm.binds_local_p (decl)));
8054 }
8055 \f
8056 /* libfunc renaming.  */
8057 #include "config/gofast.h"
8058
8059 static void
8060 sparc_init_libfuncs (void)
8061 {
8062   if (TARGET_ARCH32)
8063     {
8064       /* Use the subroutines that Sun's library provides for integer
8065          multiply and divide.  The `*' prevents an underscore from
8066          being prepended by the compiler. .umul is a little faster
8067          than .mul.  */
8068       set_optab_libfunc (smul_optab, SImode, "*.umul");
8069       set_optab_libfunc (sdiv_optab, SImode, "*.div");
8070       set_optab_libfunc (udiv_optab, SImode, "*.udiv");
8071       set_optab_libfunc (smod_optab, SImode, "*.rem");
8072       set_optab_libfunc (umod_optab, SImode, "*.urem");
8073
8074       /* TFmode arithmetic.  These names are part of the SPARC 32bit ABI.  */
8075       set_optab_libfunc (add_optab, TFmode, "_Q_add");
8076       set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
8077       set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
8078       set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
8079       set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
8080
8081       /* We can define the TFmode sqrt optab only if TARGET_FPU.  This
8082          is because with soft-float, the SFmode and DFmode sqrt
8083          instructions will be absent, and the compiler will notice and
8084          try to use the TFmode sqrt instruction for calls to the
8085          builtin function sqrt, but this fails.  */
8086       if (TARGET_FPU)
8087         set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
8088
8089       set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
8090       set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
8091       set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
8092       set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
8093       set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
8094       set_optab_libfunc (le_optab, TFmode, "_Q_fle");
8095
8096       set_conv_libfunc (sext_optab,   TFmode, SFmode, "_Q_stoq");
8097       set_conv_libfunc (sext_optab,   TFmode, DFmode, "_Q_dtoq");
8098       set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_Q_qtos");
8099       set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_Q_qtod");
8100
8101       set_conv_libfunc (sfix_optab,   SImode, TFmode, "_Q_qtoi");
8102       set_conv_libfunc (ufix_optab,   SImode, TFmode, "_Q_qtou");
8103       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
8104       set_conv_libfunc (ufloat_optab, TFmode, SImode, "_Q_utoq");
8105
8106       if (DITF_CONVERSION_LIBFUNCS)
8107         {
8108           set_conv_libfunc (sfix_optab,   DImode, TFmode, "_Q_qtoll");
8109           set_conv_libfunc (ufix_optab,   DImode, TFmode, "_Q_qtoull");
8110           set_conv_libfunc (sfloat_optab, TFmode, DImode, "_Q_lltoq");
8111           set_conv_libfunc (ufloat_optab, TFmode, DImode, "_Q_ulltoq");
8112         }
8113
8114       if (SUN_CONVERSION_LIBFUNCS)
8115         {
8116           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
8117           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
8118           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
8119           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
8120         }
8121     }
8122   if (TARGET_ARCH64)
8123     {
8124       /* In the SPARC 64bit ABI, SImode multiply and divide functions
8125          do not exist in the library.  Make sure the compiler does not
8126          emit calls to them by accident.  (It should always use the
8127          hardware instructions.)  */
8128       set_optab_libfunc (smul_optab, SImode, 0);
8129       set_optab_libfunc (sdiv_optab, SImode, 0);
8130       set_optab_libfunc (udiv_optab, SImode, 0);
8131       set_optab_libfunc (smod_optab, SImode, 0);
8132       set_optab_libfunc (umod_optab, SImode, 0);
8133
8134       if (SUN_INTEGER_MULTIPLY_64)
8135         {
8136           set_optab_libfunc (smul_optab, DImode, "__mul64");
8137           set_optab_libfunc (sdiv_optab, DImode, "__div64");
8138           set_optab_libfunc (udiv_optab, DImode, "__udiv64");
8139           set_optab_libfunc (smod_optab, DImode, "__rem64");
8140           set_optab_libfunc (umod_optab, DImode, "__urem64");
8141         }
8142
8143       if (SUN_CONVERSION_LIBFUNCS)
8144         {
8145           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
8146           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
8147           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
8148           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
8149         }
8150     }
8151
8152   gofast_maybe_init_libfuncs ();
8153 }
8154 \f
8155 #define def_builtin(NAME, CODE, TYPE) \
8156   add_builtin_function((NAME), (TYPE), (CODE), BUILT_IN_MD, NULL, \
8157                        NULL_TREE)
8158
8159 /* Implement the TARGET_INIT_BUILTINS target hook.
8160    Create builtin functions for special SPARC instructions.  */
8161
8162 static void
8163 sparc_init_builtins (void)
8164 {
8165   if (TARGET_VIS)
8166     sparc_vis_init_builtins ();
8167 }
8168
8169 /* Create builtin functions for VIS 1.0 instructions.  */
8170
8171 static void
8172 sparc_vis_init_builtins (void)
8173 {
8174   tree v4qi = build_vector_type (unsigned_intQI_type_node, 4);
8175   tree v8qi = build_vector_type (unsigned_intQI_type_node, 8);
8176   tree v4hi = build_vector_type (intHI_type_node, 4);
8177   tree v2hi = build_vector_type (intHI_type_node, 2);
8178   tree v2si = build_vector_type (intSI_type_node, 2);
8179
8180   tree v4qi_ftype_v4hi = build_function_type_list (v4qi, v4hi, 0);
8181   tree v8qi_ftype_v2si_v8qi = build_function_type_list (v8qi, v2si, v8qi, 0);
8182   tree v2hi_ftype_v2si = build_function_type_list (v2hi, v2si, 0);
8183   tree v4hi_ftype_v4qi = build_function_type_list (v4hi, v4qi, 0);
8184   tree v8qi_ftype_v4qi_v4qi = build_function_type_list (v8qi, v4qi, v4qi, 0);
8185   tree v4hi_ftype_v4qi_v4hi = build_function_type_list (v4hi, v4qi, v4hi, 0);
8186   tree v4hi_ftype_v4qi_v2hi = build_function_type_list (v4hi, v4qi, v2hi, 0);
8187   tree v2si_ftype_v4qi_v2hi = build_function_type_list (v2si, v4qi, v2hi, 0);
8188   tree v4hi_ftype_v8qi_v4hi = build_function_type_list (v4hi, v8qi, v4hi, 0);
8189   tree v4hi_ftype_v4hi_v4hi = build_function_type_list (v4hi, v4hi, v4hi, 0);
8190   tree v2si_ftype_v2si_v2si = build_function_type_list (v2si, v2si, v2si, 0);
8191   tree v8qi_ftype_v8qi_v8qi = build_function_type_list (v8qi, v8qi, v8qi, 0);
8192   tree di_ftype_v8qi_v8qi_di = build_function_type_list (intDI_type_node,
8193                                                          v8qi, v8qi,
8194                                                          intDI_type_node, 0);
8195   tree di_ftype_di_di = build_function_type_list (intDI_type_node,
8196                                                   intDI_type_node,
8197                                                   intDI_type_node, 0);
8198   tree ptr_ftype_ptr_si = build_function_type_list (ptr_type_node,
8199                                                     ptr_type_node,
8200                                                     intSI_type_node, 0);
8201   tree ptr_ftype_ptr_di = build_function_type_list (ptr_type_node,
8202                                                     ptr_type_node,
8203                                                     intDI_type_node, 0);
8204
8205   /* Packing and expanding vectors.  */
8206   def_builtin ("__builtin_vis_fpack16", CODE_FOR_fpack16_vis, v4qi_ftype_v4hi);
8207   def_builtin ("__builtin_vis_fpack32", CODE_FOR_fpack32_vis,
8208                v8qi_ftype_v2si_v8qi);
8209   def_builtin ("__builtin_vis_fpackfix", CODE_FOR_fpackfix_vis,
8210                v2hi_ftype_v2si);
8211   def_builtin ("__builtin_vis_fexpand", CODE_FOR_fexpand_vis, v4hi_ftype_v4qi);
8212   def_builtin ("__builtin_vis_fpmerge", CODE_FOR_fpmerge_vis,
8213                v8qi_ftype_v4qi_v4qi);
8214
8215   /* Multiplications.  */
8216   def_builtin ("__builtin_vis_fmul8x16", CODE_FOR_fmul8x16_vis,
8217                v4hi_ftype_v4qi_v4hi);
8218   def_builtin ("__builtin_vis_fmul8x16au", CODE_FOR_fmul8x16au_vis,
8219                v4hi_ftype_v4qi_v2hi);
8220   def_builtin ("__builtin_vis_fmul8x16al", CODE_FOR_fmul8x16al_vis,
8221                v4hi_ftype_v4qi_v2hi);
8222   def_builtin ("__builtin_vis_fmul8sux16", CODE_FOR_fmul8sux16_vis,
8223                v4hi_ftype_v8qi_v4hi);
8224   def_builtin ("__builtin_vis_fmul8ulx16", CODE_FOR_fmul8ulx16_vis,
8225                v4hi_ftype_v8qi_v4hi);
8226   def_builtin ("__builtin_vis_fmuld8sux16", CODE_FOR_fmuld8sux16_vis,
8227                v2si_ftype_v4qi_v2hi);
8228   def_builtin ("__builtin_vis_fmuld8ulx16", CODE_FOR_fmuld8ulx16_vis,
8229                v2si_ftype_v4qi_v2hi);
8230
8231   /* Data aligning.  */
8232   def_builtin ("__builtin_vis_faligndatav4hi", CODE_FOR_faligndatav4hi_vis,
8233                v4hi_ftype_v4hi_v4hi);
8234   def_builtin ("__builtin_vis_faligndatav8qi", CODE_FOR_faligndatav8qi_vis,
8235                v8qi_ftype_v8qi_v8qi);
8236   def_builtin ("__builtin_vis_faligndatav2si", CODE_FOR_faligndatav2si_vis,
8237                v2si_ftype_v2si_v2si);
8238   def_builtin ("__builtin_vis_faligndatadi", CODE_FOR_faligndatadi_vis,
8239                di_ftype_di_di);
8240   if (TARGET_ARCH64)
8241     def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrdi_vis,
8242                  ptr_ftype_ptr_di);
8243   else
8244     def_builtin ("__builtin_vis_alignaddr", CODE_FOR_alignaddrsi_vis,
8245                  ptr_ftype_ptr_si);
8246
8247   /* Pixel distance.  */
8248   def_builtin ("__builtin_vis_pdist", CODE_FOR_pdist_vis,
8249                di_ftype_v8qi_v8qi_di);
8250 }
8251
8252 /* Handle TARGET_EXPAND_BUILTIN target hook.
8253    Expand builtin functions for sparc intrinsics.  */
8254
8255 static rtx
8256 sparc_expand_builtin (tree exp, rtx target,
8257                       rtx subtarget ATTRIBUTE_UNUSED,
8258                       enum machine_mode tmode ATTRIBUTE_UNUSED,
8259                       int ignore ATTRIBUTE_UNUSED)
8260 {
8261   tree arg;
8262   call_expr_arg_iterator iter;
8263   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
8264   unsigned int icode = DECL_FUNCTION_CODE (fndecl);
8265   rtx pat, op[4];
8266   enum machine_mode mode[4];
8267   int arg_count = 0;
8268
8269   mode[0] = insn_data[icode].operand[0].mode;
8270   if (!target
8271       || GET_MODE (target) != mode[0]
8272       || ! (*insn_data[icode].operand[0].predicate) (target, mode[0]))
8273     op[0] = gen_reg_rtx (mode[0]);
8274   else
8275     op[0] = target;
8276
8277   FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
8278     {
8279       arg_count++;
8280       mode[arg_count] = insn_data[icode].operand[arg_count].mode;
8281       op[arg_count] = expand_normal (arg);
8282
8283       if (! (*insn_data[icode].operand[arg_count].predicate) (op[arg_count],
8284                                                               mode[arg_count]))
8285         op[arg_count] = copy_to_mode_reg (mode[arg_count], op[arg_count]);
8286     }
8287
8288   switch (arg_count)
8289     {
8290     case 1:
8291       pat = GEN_FCN (icode) (op[0], op[1]);
8292       break;
8293     case 2:
8294       pat = GEN_FCN (icode) (op[0], op[1], op[2]);
8295       break;
8296     case 3:
8297       pat = GEN_FCN (icode) (op[0], op[1], op[2], op[3]);
8298       break;
8299     default:
8300       gcc_unreachable ();
8301     }
8302
8303   if (!pat)
8304     return NULL_RTX;
8305
8306   emit_insn (pat);
8307
8308   return op[0];
8309 }
8310
8311 static int
8312 sparc_vis_mul8x16 (int e8, int e16)
8313 {
8314   return (e8 * e16 + 128) / 256;
8315 }
8316
8317 /* Multiply the vector elements in ELTS0 to the elements in ELTS1 as specified
8318    by FNCODE.  All of the elements in ELTS0 and ELTS1 lists must be integer
8319    constants.  A tree list with the results of the multiplications is returned,
8320    and each element in the list is of INNER_TYPE.  */
8321
8322 static tree
8323 sparc_handle_vis_mul8x16 (int fncode, tree inner_type, tree elts0, tree elts1)
8324 {
8325   tree n_elts = NULL_TREE;
8326   int scale;
8327
8328   switch (fncode)
8329     {
8330     case CODE_FOR_fmul8x16_vis:
8331       for (; elts0 && elts1;
8332            elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
8333         {
8334           int val
8335             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
8336                                  TREE_INT_CST_LOW (TREE_VALUE (elts1)));
8337           n_elts = tree_cons (NULL_TREE,
8338                               build_int_cst (inner_type, val),
8339                               n_elts);
8340         }
8341       break;
8342
8343     case CODE_FOR_fmul8x16au_vis:
8344       scale = TREE_INT_CST_LOW (TREE_VALUE (elts1));
8345
8346       for (; elts0; elts0 = TREE_CHAIN (elts0))
8347         {
8348           int val
8349             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
8350                                  scale);
8351           n_elts = tree_cons (NULL_TREE,
8352                               build_int_cst (inner_type, val),
8353                               n_elts);
8354         }
8355       break;
8356
8357     case CODE_FOR_fmul8x16al_vis:
8358       scale = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (elts1)));
8359
8360       for (; elts0; elts0 = TREE_CHAIN (elts0))
8361         {
8362           int val
8363             = sparc_vis_mul8x16 (TREE_INT_CST_LOW (TREE_VALUE (elts0)),
8364                                  scale);
8365           n_elts = tree_cons (NULL_TREE,
8366                               build_int_cst (inner_type, val),
8367                               n_elts);
8368         }
8369       break;
8370
8371     default:
8372       gcc_unreachable ();
8373     }
8374
8375   return nreverse (n_elts);
8376
8377 }
8378 /* Handle TARGET_FOLD_BUILTIN target hook.
8379    Fold builtin functions for SPARC intrinsics.  If IGNORE is true the
8380    result of the function call is ignored.  NULL_TREE is returned if the
8381    function could not be folded.  */
8382
8383 static tree
8384 sparc_fold_builtin (tree fndecl, tree arglist, bool ignore)
8385 {
8386   tree arg0, arg1, arg2;
8387   tree rtype = TREE_TYPE (TREE_TYPE (fndecl));
8388   enum insn_code icode = (enum insn_code) DECL_FUNCTION_CODE (fndecl);
8389
8390   if (ignore
8391       && icode != CODE_FOR_alignaddrsi_vis
8392       && icode != CODE_FOR_alignaddrdi_vis)
8393     return fold_convert (rtype, integer_zero_node);
8394
8395   switch (icode)
8396     {
8397     case CODE_FOR_fexpand_vis:
8398       arg0 = TREE_VALUE (arglist);
8399       STRIP_NOPS (arg0);
8400
8401       if (TREE_CODE (arg0) == VECTOR_CST)
8402         {
8403           tree inner_type = TREE_TYPE (rtype);
8404           tree elts = TREE_VECTOR_CST_ELTS (arg0);
8405           tree n_elts = NULL_TREE;
8406
8407           for (; elts; elts = TREE_CHAIN (elts))
8408             {
8409               unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (elts)) << 4;
8410               n_elts = tree_cons (NULL_TREE,
8411                                   build_int_cst (inner_type, val),
8412                                   n_elts);
8413             }
8414           return build_vector (rtype, nreverse (n_elts));
8415         }
8416       break;
8417
8418     case CODE_FOR_fmul8x16_vis:
8419     case CODE_FOR_fmul8x16au_vis:
8420     case CODE_FOR_fmul8x16al_vis:
8421       arg0 = TREE_VALUE (arglist);
8422       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
8423       STRIP_NOPS (arg0);
8424       STRIP_NOPS (arg1);
8425
8426       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
8427         {
8428           tree inner_type = TREE_TYPE (rtype);
8429           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
8430           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
8431           tree n_elts = sparc_handle_vis_mul8x16 (icode, inner_type, elts0,
8432                                                   elts1);
8433
8434           return build_vector (rtype, n_elts);
8435         }
8436       break;
8437
8438     case CODE_FOR_fpmerge_vis:
8439       arg0 = TREE_VALUE (arglist);
8440       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
8441       STRIP_NOPS (arg0);
8442       STRIP_NOPS (arg1);
8443
8444       if (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
8445         {
8446           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
8447           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
8448           tree n_elts = NULL_TREE;
8449
8450           for (; elts0 && elts1;
8451                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
8452             {
8453               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts0), n_elts);
8454               n_elts = tree_cons (NULL_TREE, TREE_VALUE (elts1), n_elts);
8455             }
8456
8457           return build_vector (rtype, nreverse (n_elts));
8458         }
8459       break;
8460
8461     case CODE_FOR_pdist_vis:
8462       arg0 = TREE_VALUE (arglist);
8463       arg1 = TREE_VALUE (TREE_CHAIN (arglist));
8464       arg2 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
8465       STRIP_NOPS (arg0);
8466       STRIP_NOPS (arg1);
8467       STRIP_NOPS (arg2);
8468
8469       if (TREE_CODE (arg0) == VECTOR_CST
8470           && TREE_CODE (arg1) == VECTOR_CST
8471           && TREE_CODE (arg2) == INTEGER_CST)
8472         {
8473           int overflow = 0;
8474           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg2);
8475           HOST_WIDE_INT high = TREE_INT_CST_HIGH (arg2);
8476           tree elts0 = TREE_VECTOR_CST_ELTS (arg0);
8477           tree elts1 = TREE_VECTOR_CST_ELTS (arg1);
8478
8479           for (; elts0 && elts1;
8480                elts0 = TREE_CHAIN (elts0), elts1 = TREE_CHAIN (elts1))
8481             {
8482               unsigned HOST_WIDE_INT
8483                 low0 = TREE_INT_CST_LOW (TREE_VALUE (elts0)),
8484                 low1 = TREE_INT_CST_LOW (TREE_VALUE (elts1));
8485               HOST_WIDE_INT high0 = TREE_INT_CST_HIGH (TREE_VALUE (elts0));
8486               HOST_WIDE_INT high1 = TREE_INT_CST_HIGH (TREE_VALUE (elts1));
8487
8488               unsigned HOST_WIDE_INT l;
8489               HOST_WIDE_INT h;
8490
8491               overflow |= neg_double (low1, high1, &l, &h);
8492               overflow |= add_double (low0, high0, l, h, &l, &h);
8493               if (h < 0)
8494                 overflow |= neg_double (l, h, &l, &h);
8495
8496               overflow |= add_double (low, high, l, h, &low, &high);
8497             }
8498
8499           gcc_assert (overflow == 0);
8500
8501           return build_int_cst_wide (rtype, low, high);
8502         }
8503
8504     default:
8505       break;
8506     }
8507
8508   return NULL_TREE;
8509 }
8510 \f
8511 /* ??? This duplicates information provided to the compiler by the
8512    ??? scheduler description.  Some day, teach genautomata to output
8513    ??? the latencies and then CSE will just use that.  */
8514
8515 static bool
8516 sparc_rtx_costs (rtx x, int code, int outer_code, int *total,
8517                  bool speed ATTRIBUTE_UNUSED)
8518 {
8519   enum machine_mode mode = GET_MODE (x);
8520   bool float_mode_p = FLOAT_MODE_P (mode);
8521
8522   switch (code)
8523     {
8524     case CONST_INT:
8525       if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
8526         {
8527           *total = 0;
8528           return true;
8529         }
8530       /* FALLTHRU */
8531
8532     case HIGH:
8533       *total = 2;
8534       return true;
8535
8536     case CONST:
8537     case LABEL_REF:
8538     case SYMBOL_REF:
8539       *total = 4;
8540       return true;
8541
8542     case CONST_DOUBLE:
8543       if (GET_MODE (x) == VOIDmode
8544           && ((CONST_DOUBLE_HIGH (x) == 0
8545                && CONST_DOUBLE_LOW (x) < 0x1000)
8546               || (CONST_DOUBLE_HIGH (x) == -1
8547                   && CONST_DOUBLE_LOW (x) < 0
8548                   && CONST_DOUBLE_LOW (x) >= -0x1000)))
8549         *total = 0;
8550       else
8551         *total = 8;
8552       return true;
8553
8554     case MEM:
8555       /* If outer-code was a sign or zero extension, a cost
8556          of COSTS_N_INSNS (1) was already added in.  This is
8557          why we are subtracting it back out.  */
8558       if (outer_code == ZERO_EXTEND)
8559         {
8560           *total = sparc_costs->int_zload - COSTS_N_INSNS (1);
8561         }
8562       else if (outer_code == SIGN_EXTEND)
8563         {
8564           *total = sparc_costs->int_sload - COSTS_N_INSNS (1);
8565         }
8566       else if (float_mode_p)
8567         {
8568           *total = sparc_costs->float_load;
8569         }
8570       else
8571         {
8572           *total = sparc_costs->int_load;
8573         }
8574
8575       return true;
8576
8577     case PLUS:
8578     case MINUS:
8579       if (float_mode_p)
8580         *total = sparc_costs->float_plusminus;
8581       else
8582         *total = COSTS_N_INSNS (1);
8583       return false;
8584
8585     case MULT:
8586       if (float_mode_p)
8587         *total = sparc_costs->float_mul;
8588       else if (! TARGET_HARD_MUL)
8589         *total = COSTS_N_INSNS (25);
8590       else
8591         {
8592           int bit_cost;
8593
8594           bit_cost = 0;
8595           if (sparc_costs->int_mul_bit_factor)
8596             {
8597               int nbits;
8598
8599               if (GET_CODE (XEXP (x, 1)) == CONST_INT)
8600                 {
8601                   unsigned HOST_WIDE_INT value = INTVAL (XEXP (x, 1));
8602                   for (nbits = 0; value != 0; value &= value - 1)
8603                     nbits++;
8604                 }
8605               else if (GET_CODE (XEXP (x, 1)) == CONST_DOUBLE
8606                        && GET_MODE (XEXP (x, 1)) == VOIDmode)
8607                 {
8608                   rtx x1 = XEXP (x, 1);
8609                   unsigned HOST_WIDE_INT value1 = CONST_DOUBLE_LOW (x1);
8610                   unsigned HOST_WIDE_INT value2 = CONST_DOUBLE_HIGH (x1);
8611
8612                   for (nbits = 0; value1 != 0; value1 &= value1 - 1)
8613                     nbits++;
8614                   for (; value2 != 0; value2 &= value2 - 1)
8615                     nbits++;
8616                 }
8617               else
8618                 nbits = 7;
8619
8620               if (nbits < 3)
8621                 nbits = 3;
8622               bit_cost = (nbits - 3) / sparc_costs->int_mul_bit_factor;
8623               bit_cost = COSTS_N_INSNS (bit_cost);
8624             }
8625
8626           if (mode == DImode)
8627             *total = sparc_costs->int_mulX + bit_cost;
8628           else
8629             *total = sparc_costs->int_mul + bit_cost;
8630         }
8631       return false;
8632
8633     case ASHIFT:
8634     case ASHIFTRT:
8635     case LSHIFTRT:
8636       *total = COSTS_N_INSNS (1) + sparc_costs->shift_penalty;
8637       return false;
8638
8639     case DIV:
8640     case UDIV:
8641     case MOD:
8642     case UMOD:
8643       if (float_mode_p)
8644         {
8645           if (mode == DFmode)
8646             *total = sparc_costs->float_div_df;
8647           else
8648             *total = sparc_costs->float_div_sf;
8649         }
8650       else
8651         {
8652           if (mode == DImode)
8653             *total = sparc_costs->int_divX;
8654           else
8655             *total = sparc_costs->int_div;
8656         }
8657       return false;
8658
8659     case NEG:
8660       if (! float_mode_p)
8661         {
8662           *total = COSTS_N_INSNS (1);
8663           return false;
8664         }
8665       /* FALLTHRU */
8666
8667     case ABS:
8668     case FLOAT:
8669     case UNSIGNED_FLOAT:
8670     case FIX:
8671     case UNSIGNED_FIX:
8672     case FLOAT_EXTEND:
8673     case FLOAT_TRUNCATE:
8674       *total = sparc_costs->float_move;
8675       return false;
8676
8677     case SQRT:
8678       if (mode == DFmode)
8679         *total = sparc_costs->float_sqrt_df;
8680       else
8681         *total = sparc_costs->float_sqrt_sf;
8682       return false;
8683
8684     case COMPARE:
8685       if (float_mode_p)
8686         *total = sparc_costs->float_cmp;
8687       else
8688         *total = COSTS_N_INSNS (1);
8689       return false;
8690
8691     case IF_THEN_ELSE:
8692       if (float_mode_p)
8693         *total = sparc_costs->float_cmove;
8694       else
8695         *total = sparc_costs->int_cmove;
8696       return false;
8697
8698     case IOR:
8699       /* Handle the NAND vector patterns.  */
8700       if (sparc_vector_mode_supported_p (GET_MODE (x))
8701           && GET_CODE (XEXP (x, 0)) == NOT
8702           && GET_CODE (XEXP (x, 1)) == NOT)
8703         {
8704           *total = COSTS_N_INSNS (1);
8705           return true;
8706         }
8707       else
8708         return false;
8709
8710     default:
8711       return false;
8712     }
8713 }
8714
8715 /* Emit the sequence of insns SEQ while preserving the registers REG and REG2.
8716    This is achieved by means of a manual dynamic stack space allocation in
8717    the current frame.  We make the assumption that SEQ doesn't contain any
8718    function calls, with the possible exception of calls to the PIC helper.  */
8719
8720 static void
8721 emit_and_preserve (rtx seq, rtx reg, rtx reg2)
8722 {
8723   /* We must preserve the lowest 16 words for the register save area.  */
8724   HOST_WIDE_INT offset = 16*UNITS_PER_WORD;
8725   /* We really need only 2 words of fresh stack space.  */
8726   HOST_WIDE_INT size = SPARC_STACK_ALIGN (offset + 2*UNITS_PER_WORD);
8727
8728   rtx slot
8729     = gen_rtx_MEM (word_mode, plus_constant (stack_pointer_rtx,
8730                                              SPARC_STACK_BIAS + offset));
8731
8732   emit_insn (gen_stack_pointer_dec (GEN_INT (size)));
8733   emit_insn (gen_rtx_SET (VOIDmode, slot, reg));
8734   if (reg2)
8735     emit_insn (gen_rtx_SET (VOIDmode,
8736                             adjust_address (slot, word_mode, UNITS_PER_WORD),
8737                             reg2));
8738   emit_insn (seq);
8739   if (reg2)
8740     emit_insn (gen_rtx_SET (VOIDmode,
8741                             reg2,
8742                             adjust_address (slot, word_mode, UNITS_PER_WORD)));
8743   emit_insn (gen_rtx_SET (VOIDmode, reg, slot));
8744   emit_insn (gen_stack_pointer_inc (GEN_INT (size)));
8745 }
8746
8747 /* Output the assembler code for a thunk function.  THUNK_DECL is the
8748    declaration for the thunk function itself, FUNCTION is the decl for
8749    the target function.  DELTA is an immediate constant offset to be
8750    added to THIS.  If VCALL_OFFSET is nonzero, the word at address
8751    (*THIS + VCALL_OFFSET) should be additionally added to THIS.  */
8752
8753 static void
8754 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
8755                        HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
8756                        tree function)
8757 {
8758   rtx this_rtx, insn, funexp;
8759   unsigned int int_arg_first;
8760
8761   reload_completed = 1;
8762   epilogue_completed = 1;
8763
8764   emit_note (NOTE_INSN_PROLOGUE_END);
8765
8766   if (flag_delayed_branch)
8767     {
8768       /* We will emit a regular sibcall below, so we need to instruct
8769          output_sibcall that we are in a leaf function.  */
8770       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 1;
8771
8772       /* This will cause final.c to invoke leaf_renumber_regs so we
8773          must behave as if we were in a not-yet-leafified function.  */
8774       int_arg_first = SPARC_INCOMING_INT_ARG_FIRST;
8775     }
8776   else
8777     {
8778       /* We will emit the sibcall manually below, so we will need to
8779          manually spill non-leaf registers.  */
8780       sparc_leaf_function_p = current_function_uses_only_leaf_regs = 0;
8781
8782       /* We really are in a leaf function.  */
8783       int_arg_first = SPARC_OUTGOING_INT_ARG_FIRST;
8784     }
8785
8786   /* Find the "this" pointer.  Normally in %o0, but in ARCH64 if the function
8787      returns a structure, the structure return pointer is there instead.  */
8788   if (TARGET_ARCH64 && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
8789     this_rtx = gen_rtx_REG (Pmode, int_arg_first + 1);
8790   else
8791     this_rtx = gen_rtx_REG (Pmode, int_arg_first);
8792
8793   /* Add DELTA.  When possible use a plain add, otherwise load it into
8794      a register first.  */
8795   if (delta)
8796     {
8797       rtx delta_rtx = GEN_INT (delta);
8798
8799       if (! SPARC_SIMM13_P (delta))
8800         {
8801           rtx scratch = gen_rtx_REG (Pmode, 1);
8802           emit_move_insn (scratch, delta_rtx);
8803           delta_rtx = scratch;
8804         }
8805
8806       /* THIS_RTX += DELTA.  */
8807       emit_insn (gen_add2_insn (this_rtx, delta_rtx));
8808     }
8809
8810   /* Add the word at address (*THIS_RTX + VCALL_OFFSET).  */
8811   if (vcall_offset)
8812     {
8813       rtx vcall_offset_rtx = GEN_INT (vcall_offset);
8814       rtx scratch = gen_rtx_REG (Pmode, 1);
8815
8816       gcc_assert (vcall_offset < 0);
8817
8818       /* SCRATCH = *THIS_RTX.  */
8819       emit_move_insn (scratch, gen_rtx_MEM (Pmode, this_rtx));
8820
8821       /* Prepare for adding VCALL_OFFSET.  The difficulty is that we
8822          may not have any available scratch register at this point.  */
8823       if (SPARC_SIMM13_P (vcall_offset))
8824         ;
8825       /* This is the case if ARCH64 (unless -ffixed-g5 is passed).  */
8826       else if (! fixed_regs[5]
8827                /* The below sequence is made up of at least 2 insns,
8828                   while the default method may need only one.  */
8829                && vcall_offset < -8192)
8830         {
8831           rtx scratch2 = gen_rtx_REG (Pmode, 5);
8832           emit_move_insn (scratch2, vcall_offset_rtx);
8833           vcall_offset_rtx = scratch2;
8834         }
8835       else
8836         {
8837           rtx increment = GEN_INT (-4096);
8838
8839           /* VCALL_OFFSET is a negative number whose typical range can be
8840              estimated as -32768..0 in 32-bit mode.  In almost all cases
8841              it is therefore cheaper to emit multiple add insns than
8842              spilling and loading the constant into a register (at least
8843              6 insns).  */
8844           while (! SPARC_SIMM13_P (vcall_offset))
8845             {
8846               emit_insn (gen_add2_insn (scratch, increment));
8847               vcall_offset += 4096;
8848             }
8849           vcall_offset_rtx = GEN_INT (vcall_offset); /* cannot be 0 */
8850         }
8851
8852       /* SCRATCH = *(*THIS_RTX + VCALL_OFFSET).  */
8853       emit_move_insn (scratch, gen_rtx_MEM (Pmode,
8854                                             gen_rtx_PLUS (Pmode,
8855                                                           scratch,
8856                                                           vcall_offset_rtx)));
8857
8858       /* THIS_RTX += *(*THIS_RTX + VCALL_OFFSET).  */
8859       emit_insn (gen_add2_insn (this_rtx, scratch));
8860     }
8861
8862   /* Generate a tail call to the target function.  */
8863   if (! TREE_USED (function))
8864     {
8865       assemble_external (function);
8866       TREE_USED (function) = 1;
8867     }
8868   funexp = XEXP (DECL_RTL (function), 0);
8869
8870   if (flag_delayed_branch)
8871     {
8872       funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
8873       insn = emit_call_insn (gen_sibcall (funexp));
8874       SIBLING_CALL_P (insn) = 1;
8875     }
8876   else
8877     {
8878       /* The hoops we have to jump through in order to generate a sibcall
8879          without using delay slots...  */
8880       rtx spill_reg, spill_reg2, seq, scratch = gen_rtx_REG (Pmode, 1);
8881
8882       if (flag_pic)
8883         {
8884           spill_reg = gen_rtx_REG (word_mode, 15);  /* %o7 */
8885           spill_reg2 = gen_rtx_REG (word_mode, PIC_OFFSET_TABLE_REGNUM);
8886           start_sequence ();
8887           /* Delay emitting the PIC helper function because it needs to
8888              change the section and we are emitting assembly code.  */
8889           load_pic_register (true);  /* clobbers %o7 */
8890           scratch = legitimize_pic_address (funexp, Pmode, scratch);
8891           seq = get_insns ();
8892           end_sequence ();
8893           emit_and_preserve (seq, spill_reg, spill_reg2);
8894         }
8895       else if (TARGET_ARCH32)
8896         {
8897           emit_insn (gen_rtx_SET (VOIDmode,
8898                                   scratch,
8899                                   gen_rtx_HIGH (SImode, funexp)));
8900           emit_insn (gen_rtx_SET (VOIDmode,
8901                                   scratch,
8902                                   gen_rtx_LO_SUM (SImode, scratch, funexp)));
8903         }
8904       else  /* TARGET_ARCH64 */
8905         {
8906           switch (sparc_cmodel)
8907             {
8908             case CM_MEDLOW:
8909             case CM_MEDMID:
8910               /* The destination can serve as a temporary.  */
8911               sparc_emit_set_symbolic_const64 (scratch, funexp, scratch);
8912               break;
8913
8914             case CM_MEDANY:
8915             case CM_EMBMEDANY:
8916               /* The destination cannot serve as a temporary.  */
8917               spill_reg = gen_rtx_REG (DImode, 15);  /* %o7 */
8918               start_sequence ();
8919               sparc_emit_set_symbolic_const64 (scratch, funexp, spill_reg);
8920               seq = get_insns ();
8921               end_sequence ();
8922               emit_and_preserve (seq, spill_reg, 0);
8923               break;
8924
8925             default:
8926               gcc_unreachable ();
8927             }
8928         }
8929
8930       emit_jump_insn (gen_indirect_jump (scratch));
8931     }
8932
8933   emit_barrier ();
8934
8935   /* Run just enough of rest_of_compilation to get the insns emitted.
8936      There's not really enough bulk here to make other passes such as
8937      instruction scheduling worth while.  Note that use_thunk calls
8938      assemble_start_function and assemble_end_function.  */
8939   insn = get_insns ();
8940   insn_locators_alloc ();
8941   shorten_branches (insn);
8942   final_start_function (insn, file, 1);
8943   final (insn, file, 1);
8944   final_end_function ();
8945   free_after_compilation (cfun);
8946
8947   reload_completed = 0;
8948   epilogue_completed = 0;
8949 }
8950
8951 /* Return true if sparc_output_mi_thunk would be able to output the
8952    assembler code for the thunk function specified by the arguments
8953    it is passed, and false otherwise.  */
8954 static bool
8955 sparc_can_output_mi_thunk (const_tree thunk_fndecl ATTRIBUTE_UNUSED,
8956                            HOST_WIDE_INT delta ATTRIBUTE_UNUSED,
8957                            HOST_WIDE_INT vcall_offset,
8958                            const_tree function ATTRIBUTE_UNUSED)
8959 {
8960   /* Bound the loop used in the default method above.  */
8961   return (vcall_offset >= -32768 || ! fixed_regs[5]);
8962 }
8963
8964 /* How to allocate a 'struct machine_function'.  */
8965
8966 static struct machine_function *
8967 sparc_init_machine_status (void)
8968 {
8969   return GGC_CNEW (struct machine_function);
8970 }
8971
8972 /* Locate some local-dynamic symbol still in use by this function
8973    so that we can print its name in local-dynamic base patterns.  */
8974
8975 static const char *
8976 get_some_local_dynamic_name (void)
8977 {
8978   rtx insn;
8979
8980   if (cfun->machine->some_ld_name)
8981     return cfun->machine->some_ld_name;
8982
8983   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
8984     if (INSN_P (insn)
8985         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
8986       return cfun->machine->some_ld_name;
8987
8988   gcc_unreachable ();
8989 }
8990
8991 static int
8992 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
8993 {
8994   rtx x = *px;
8995
8996   if (x
8997       && GET_CODE (x) == SYMBOL_REF
8998       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
8999     {
9000       cfun->machine->some_ld_name = XSTR (x, 0);
9001       return 1;
9002     }
9003
9004   return 0;
9005 }
9006
9007 /* Handle the TARGET_DWARF_HANDLE_FRAME_UNSPEC hook.
9008    This is called from dwarf2out.c to emit call frame instructions
9009    for frame-related insns containing UNSPECs and UNSPEC_VOLATILEs. */
9010 static void
9011 sparc_dwarf_handle_frame_unspec (const char *label,
9012                                  rtx pattern ATTRIBUTE_UNUSED,
9013                                  int index ATTRIBUTE_UNUSED)
9014 {
9015   gcc_assert (index == UNSPECV_SAVEW);
9016   dwarf2out_window_save (label);
9017 }
9018
9019 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
9020    We need to emit DTP-relative relocations.  */
9021
9022 static void
9023 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
9024 {
9025   switch (size)
9026     {
9027     case 4:
9028       fputs ("\t.word\t%r_tls_dtpoff32(", file);
9029       break;
9030     case 8:
9031       fputs ("\t.xword\t%r_tls_dtpoff64(", file);
9032       break;
9033     default:
9034       gcc_unreachable ();
9035     }
9036   output_addr_const (file, x);
9037   fputs (")", file);
9038 }
9039
9040 /* Do whatever processing is required at the end of a file.  */
9041
9042 static void
9043 sparc_file_end (void)
9044 {
9045   /* If we haven't emitted the special PIC helper function, do so now.  */
9046   if (pic_helper_symbol_name[0] && !pic_helper_emitted_p)
9047     emit_pic_helper ();
9048
9049   if (NEED_INDICATE_EXEC_STACK)
9050     file_end_indicate_exec_stack ();
9051 }
9052
9053 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
9054 /* Implement TARGET_MANGLE_TYPE.  */
9055
9056 static const char *
9057 sparc_mangle_type (const_tree type)
9058 {
9059   if (!TARGET_64BIT
9060       && TYPE_MAIN_VARIANT (type) == long_double_type_node
9061       && TARGET_LONG_DOUBLE_128)
9062     return "g";
9063
9064   /* For all other types, use normal C++ mangling.  */
9065   return NULL;
9066 }
9067 #endif
9068
9069 /* Expand code to perform a 8 or 16-bit compare and swap by doing 32-bit
9070    compare and swap on the word containing the byte or half-word.  */
9071
9072 void
9073 sparc_expand_compare_and_swap_12 (rtx result, rtx mem, rtx oldval, rtx newval)
9074 {
9075   rtx addr1 = force_reg (Pmode, XEXP (mem, 0));
9076   rtx addr = gen_reg_rtx (Pmode);
9077   rtx off = gen_reg_rtx (SImode);
9078   rtx oldv = gen_reg_rtx (SImode);
9079   rtx newv = gen_reg_rtx (SImode);
9080   rtx oldvalue = gen_reg_rtx (SImode);
9081   rtx newvalue = gen_reg_rtx (SImode);
9082   rtx res = gen_reg_rtx (SImode);
9083   rtx resv = gen_reg_rtx (SImode);
9084   rtx memsi, val, mask, end_label, loop_label, cc;
9085
9086   emit_insn (gen_rtx_SET (VOIDmode, addr,
9087                           gen_rtx_AND (Pmode, addr1, GEN_INT (-4))));
9088
9089   if (Pmode != SImode)
9090     addr1 = gen_lowpart (SImode, addr1);
9091   emit_insn (gen_rtx_SET (VOIDmode, off,
9092                           gen_rtx_AND (SImode, addr1, GEN_INT (3))));
9093
9094   memsi = gen_rtx_MEM (SImode, addr);
9095   set_mem_alias_set (memsi, ALIAS_SET_MEMORY_BARRIER);
9096   MEM_VOLATILE_P (memsi) = MEM_VOLATILE_P (mem);
9097
9098   val = force_reg (SImode, memsi);
9099
9100   emit_insn (gen_rtx_SET (VOIDmode, off,
9101                           gen_rtx_XOR (SImode, off,
9102                                        GEN_INT (GET_MODE (mem) == QImode
9103                                                 ? 3 : 2))));
9104
9105   emit_insn (gen_rtx_SET (VOIDmode, off,
9106                           gen_rtx_ASHIFT (SImode, off, GEN_INT (3))));
9107
9108   if (GET_MODE (mem) == QImode)
9109     mask = force_reg (SImode, GEN_INT (0xff));
9110   else
9111     mask = force_reg (SImode, GEN_INT (0xffff));
9112
9113   emit_insn (gen_rtx_SET (VOIDmode, mask,
9114                           gen_rtx_ASHIFT (SImode, mask, off)));
9115
9116   emit_insn (gen_rtx_SET (VOIDmode, val,
9117                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
9118                                        val)));
9119
9120   oldval = gen_lowpart (SImode, oldval);
9121   emit_insn (gen_rtx_SET (VOIDmode, oldv,
9122                           gen_rtx_ASHIFT (SImode, oldval, off)));
9123
9124   newval = gen_lowpart_common (SImode, newval);
9125   emit_insn (gen_rtx_SET (VOIDmode, newv,
9126                           gen_rtx_ASHIFT (SImode, newval, off)));
9127
9128   emit_insn (gen_rtx_SET (VOIDmode, oldv,
9129                           gen_rtx_AND (SImode, oldv, mask)));
9130
9131   emit_insn (gen_rtx_SET (VOIDmode, newv,
9132                           gen_rtx_AND (SImode, newv, mask)));
9133
9134   end_label = gen_label_rtx ();
9135   loop_label = gen_label_rtx ();
9136   emit_label (loop_label);
9137
9138   emit_insn (gen_rtx_SET (VOIDmode, oldvalue,
9139                           gen_rtx_IOR (SImode, oldv, val)));
9140
9141   emit_insn (gen_rtx_SET (VOIDmode, newvalue,
9142                           gen_rtx_IOR (SImode, newv, val)));
9143
9144   emit_insn (gen_sync_compare_and_swapsi (res, memsi, oldvalue, newvalue));
9145
9146   emit_cmp_and_jump_insns (res, oldvalue, EQ, NULL, SImode, 0, end_label);
9147
9148   emit_insn (gen_rtx_SET (VOIDmode, resv,
9149                           gen_rtx_AND (SImode, gen_rtx_NOT (SImode, mask),
9150                                        res)));
9151
9152   cc = gen_compare_reg_1 (NE, resv, val);
9153   emit_insn (gen_rtx_SET (VOIDmode, val, resv));
9154
9155   /* Use cbranchcc4 to separate the compare and branch!  */
9156   emit_jump_insn (gen_cbranchcc4 (gen_rtx_NE (VOIDmode, cc, const0_rtx),
9157                                   cc, const0_rtx, loop_label));
9158
9159   emit_label (end_label);
9160
9161   emit_insn (gen_rtx_SET (VOIDmode, res,
9162                           gen_rtx_AND (SImode, res, mask)));
9163
9164   emit_insn (gen_rtx_SET (VOIDmode, res,
9165                           gen_rtx_LSHIFTRT (SImode, res, off)));
9166
9167   emit_move_insn (result, gen_lowpart (GET_MODE (result), res));
9168 }
9169
9170 /* Implement TARGET_FRAME_POINTER_REQUIRED.  */
9171
9172 bool
9173 sparc_frame_pointer_required (void)
9174 {
9175   return !(leaf_function_p () && only_leaf_regs_used ());
9176 }
9177
9178 /* The way this is structured, we can't eliminate SFP in favor of SP
9179    if the frame pointer is required: we want to use the SFP->HFP elimination
9180    in that case.  But the test in update_eliminables doesn't know we are
9181    assuming below that we only do the former elimination.  */
9182
9183 bool
9184 sparc_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
9185 {
9186   return (to == HARD_FRAME_POINTER_REGNUM
9187           || !targetm.frame_pointer_required ());
9188 }
9189
9190 #include "gt-sparc.h"