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