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