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