gcc/config/sparc/sparc.c

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