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 (FLOAT_TYPE_P (TREE_TYPE (field)) && TARGET_FPU)
4932                     fpregs_p = 1;
4933                   else
4934                     intregs_p = 1;
4935                   if (DECL_PACKED (field))
4936                     packed_p = 1;
4937                 }
4938             }
4939           if (packed_p || !named)
4940             fpregs_p = 0, intregs_p = 1;
4941
4942           /* If all arg slots are filled, then must pass on stack.  */
4943           if (fpregs_p && slotno >= SPARC_FP_ARG_MAX)
4944             return -1;
4945           /* If there are only int args and all int arg slots are filled,
4946              then must pass on stack.  */
4947           if (!fpregs_p && intregs_p && slotno >= SPARC_INT_ARG_MAX)
4948             return -1;
4949           /* Note that even if all int arg slots are filled, fp members may
4950              still be passed in regs if such regs are available.
4951              *PREGNO isn't set because there may be more than one, it's up
4952              to the caller to compute them.  */
4953           return slotno;
4954         }
4955       break;
4956
4957     default :
4958       abort ();
4959     }
4960
4961   *pregno = regno;
4962   return slotno;
4963 }
4964
4965 /* Handle recursive register counting for structure field layout.  */
4966
4967 struct function_arg_record_value_parms
4968 {
4969   rtx ret;              /* return expression being built.  */
4970   int slotno;           /* slot number of the argument.  */
4971   int named;            /* whether the argument is named.  */
4972   int regbase;          /* regno of the base register.  */
4973   int stack;            /* 1 if part of the argument is on the stack.  */
4974   int intoffset;        /* offset of the first pending integer field.  */
4975   unsigned int nregs;   /* number of words passed in registers.  */
4976 };
4977
4978 static void function_arg_record_value_3
4979  (HOST_WIDE_INT, struct function_arg_record_value_parms *);
4980 static void function_arg_record_value_2
4981  (tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
4982 static void function_arg_record_value_1
4983  (tree, HOST_WIDE_INT, struct function_arg_record_value_parms *, bool);
4984 static rtx function_arg_record_value (tree, enum machine_mode, int, int, int);
4985
4986 /* A subroutine of function_arg_record_value.  Traverse the structure
4987    recursively and determine how many registers will be required.  */
4988
4989 static void
4990 function_arg_record_value_1 (tree type, HOST_WIDE_INT startbitpos,
4991                              struct function_arg_record_value_parms *parms,
4992                              bool packed_p)
4993 {
4994   tree field;
4995
4996   /* We need to compute how many registers are needed so we can
4997      allocate the PARALLEL but before we can do that we need to know
4998      whether there are any packed fields.  The ABI obviously doesn't
4999      specify how structures are passed in this case, so they are
5000      defined to be passed in int regs if possible, otherwise memory,
5001      regardless of whether there are fp values present.  */
5002
5003   if (! packed_p)
5004     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5005       {
5006         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5007           {
5008             packed_p = true;
5009             break;
5010           }
5011       }
5012
5013   /* Compute how many registers we need.  */
5014   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5015     {
5016       if (TREE_CODE (field) == FIELD_DECL)
5017         {
5018           HOST_WIDE_INT bitpos = startbitpos;
5019
5020           if (DECL_SIZE (field) != 0
5021               && host_integerp (bit_position (field), 1))
5022             bitpos += int_bit_position (field);
5023
5024           /* ??? FIXME: else assume zero offset.  */
5025
5026           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5027             function_arg_record_value_1 (TREE_TYPE (field),
5028                                          bitpos,
5029                                          parms,
5030                                          packed_p);
5031           else if (FLOAT_TYPE_P (TREE_TYPE (field))
5032                    && TARGET_FPU
5033                    && parms->named
5034                    && ! packed_p)
5035             {
5036               if (parms->intoffset != -1)
5037                 {
5038                   unsigned int startbit, endbit;
5039                   int intslots, this_slotno;
5040
5041                   startbit = parms->intoffset & -BITS_PER_WORD;
5042                   endbit   = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5043
5044                   intslots = (endbit - startbit) / BITS_PER_WORD;
5045                   this_slotno = parms->slotno + parms->intoffset
5046                     / BITS_PER_WORD;
5047
5048                   if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5049                     {
5050                       intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5051                       /* We need to pass this field on the stack.  */
5052                       parms->stack = 1;
5053                     }
5054
5055                   parms->nregs += intslots;
5056                   parms->intoffset = -1;
5057                 }
5058
5059               /* There's no need to check this_slotno < SPARC_FP_ARG MAX.
5060                  If it wasn't true we wouldn't be here.  */
5061               parms->nregs += 1;
5062               if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5063                 parms->nregs += 1;
5064             }
5065           else
5066             {
5067               if (parms->intoffset == -1)
5068                 parms->intoffset = bitpos;
5069             }
5070         }
5071     }
5072 }
5073
5074 /* A subroutine of function_arg_record_value.  Assign the bits of the
5075    structure between parms->intoffset and bitpos to integer registers.  */
5076
5077 static void
5078 function_arg_record_value_3 (HOST_WIDE_INT bitpos,
5079                              struct function_arg_record_value_parms *parms)
5080 {
5081   enum machine_mode mode;
5082   unsigned int regno;
5083   unsigned int startbit, endbit;
5084   int this_slotno, intslots, intoffset;
5085   rtx reg;
5086
5087   if (parms->intoffset == -1)
5088     return;
5089
5090   intoffset = parms->intoffset;
5091   parms->intoffset = -1;
5092
5093   startbit = intoffset & -BITS_PER_WORD;
5094   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5095   intslots = (endbit - startbit) / BITS_PER_WORD;
5096   this_slotno = parms->slotno + intoffset / BITS_PER_WORD;
5097
5098   intslots = MIN (intslots, SPARC_INT_ARG_MAX - this_slotno);
5099   if (intslots <= 0)
5100     return;
5101
5102   /* If this is the trailing part of a word, only load that much into
5103      the register.  Otherwise load the whole register.  Note that in
5104      the latter case we may pick up unwanted bits.  It's not a problem
5105      at the moment but may wish to revisit.  */
5106
5107   if (intoffset % BITS_PER_WORD != 0)
5108     mode = mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
5109                           MODE_INT, 0);
5110   else
5111     mode = word_mode;
5112
5113   intoffset /= BITS_PER_UNIT;
5114   do
5115     {
5116       regno = parms->regbase + this_slotno;
5117       reg = gen_rtx_REG (mode, regno);
5118       XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5119         = gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
5120
5121       this_slotno += 1;
5122       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
5123       mode = word_mode;
5124       parms->nregs += 1;
5125       intslots -= 1;
5126     }
5127   while (intslots > 0);
5128 }
5129
5130 /* A subroutine of function_arg_record_value.  Traverse the structure
5131    recursively and assign bits to floating point registers.  Track which
5132    bits in between need integer registers; invoke function_arg_record_value_3
5133    to make that happen.  */
5134
5135 static void
5136 function_arg_record_value_2 (tree type, HOST_WIDE_INT startbitpos,
5137                              struct function_arg_record_value_parms *parms,
5138                              bool packed_p)
5139 {
5140   tree field;
5141
5142   if (! packed_p)
5143     for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5144       {
5145         if (TREE_CODE (field) == FIELD_DECL && DECL_PACKED (field))
5146           {
5147             packed_p = true;
5148             break;
5149           }
5150       }
5151
5152   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5153     {
5154       if (TREE_CODE (field) == FIELD_DECL)
5155         {
5156           HOST_WIDE_INT bitpos = startbitpos;
5157
5158           if (DECL_SIZE (field) != 0
5159               && host_integerp (bit_position (field), 1))
5160             bitpos += int_bit_position (field);
5161
5162           /* ??? FIXME: else assume zero offset.  */
5163
5164           if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
5165             function_arg_record_value_2 (TREE_TYPE (field),
5166                                          bitpos,
5167                                          parms,
5168                                          packed_p);
5169           else if (FLOAT_TYPE_P (TREE_TYPE (field))
5170                    && TARGET_FPU
5171                    && parms->named
5172                    && ! packed_p)
5173             {
5174               int this_slotno = parms->slotno + bitpos / BITS_PER_WORD;
5175               int regno;
5176               enum machine_mode mode = DECL_MODE (field);
5177               rtx reg;
5178
5179               function_arg_record_value_3 (bitpos, parms);
5180               regno = SPARC_FP_ARG_FIRST + this_slotno * 2
5181                       + ((mode == SFmode || mode == SCmode)
5182                          && (bitpos & 32) != 0);
5183               switch (mode)
5184                 {
5185                 case SCmode: mode = SFmode; break;
5186                 case DCmode: mode = DFmode; break;
5187                 case TCmode: mode = TFmode; break;
5188                 default: break;
5189                 }
5190               reg = gen_rtx_REG (mode, regno);
5191               XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5192                 = gen_rtx_EXPR_LIST (VOIDmode, reg,
5193                            GEN_INT (bitpos / BITS_PER_UNIT));
5194               parms->nregs += 1;
5195               if (TREE_CODE (TREE_TYPE (field)) == COMPLEX_TYPE)
5196                 {
5197                   regno += GET_MODE_SIZE (mode) / 4;
5198                   reg = gen_rtx_REG (mode, regno);
5199                   XVECEXP (parms->ret, 0, parms->stack + parms->nregs)
5200                     = gen_rtx_EXPR_LIST (VOIDmode, reg,
5201                         GEN_INT ((bitpos + GET_MODE_BITSIZE (mode))
5202                                  / BITS_PER_UNIT));
5203                   parms->nregs += 1;
5204                 }
5205             }
5206           else
5207             {
5208               if (parms->intoffset == -1)
5209                 parms->intoffset = bitpos;
5210             }
5211         }
5212     }
5213 }
5214
5215 /* Used by function_arg and function_value to implement the complex
5216    conventions of the 64-bit ABI for passing and returning structures.
5217    Return an expression valid as a return value for the two macros
5218    FUNCTION_ARG and FUNCTION_VALUE.
5219
5220    TYPE is the data type of the argument (as a tree).
5221     This is null for libcalls where that information may
5222     not be available.
5223    MODE is the argument's machine mode.
5224    SLOTNO is the index number of the argument's slot in the parameter array.
5225    NAMED is nonzero if this argument is a named parameter
5226     (otherwise it is an extra parameter matching an ellipsis).
5227    REGBASE is the regno of the base register for the parameter array.  */
5228
5229 static rtx
5230 function_arg_record_value (tree type, enum machine_mode mode,
5231                            int slotno, int named, int regbase)
5232 {
5233   HOST_WIDE_INT typesize = int_size_in_bytes (type);
5234   struct function_arg_record_value_parms parms;
5235   unsigned int nregs;
5236
5237   parms.ret = NULL_RTX;
5238   parms.slotno = slotno;
5239   parms.named = named;
5240   parms.regbase = regbase;
5241   parms.stack = 0;
5242
5243   /* Compute how many registers we need.  */
5244   parms.nregs = 0;
5245   parms.intoffset = 0;
5246   function_arg_record_value_1 (type, 0, &parms, false);
5247
5248   /* Take into account pending integer fields.  */
5249   if (parms.intoffset != -1)
5250     {
5251       unsigned int startbit, endbit;
5252       int intslots, this_slotno;
5253
5254       startbit = parms.intoffset & -BITS_PER_WORD;
5255       endbit = (typesize*BITS_PER_UNIT + BITS_PER_WORD - 1) & -BITS_PER_WORD;
5256       intslots = (endbit - startbit) / BITS_PER_WORD;
5257       this_slotno = slotno + parms.intoffset / BITS_PER_WORD;
5258
5259       if (intslots > 0 && intslots > SPARC_INT_ARG_MAX - this_slotno)
5260         {
5261           intslots = MAX (0, SPARC_INT_ARG_MAX - this_slotno);
5262           /* We need to pass this field on the stack.  */
5263           parms.stack = 1;
5264         }
5265
5266       parms.nregs += intslots;
5267     }
5268   nregs = parms.nregs;
5269
5270   /* Allocate the vector and handle some annoying special cases.  */
5271   if (nregs == 0)
5272     {
5273       /* ??? Empty structure has no value?  Duh?  */
5274       if (typesize <= 0)
5275         {
5276           /* Though there's nothing really to store, return a word register
5277              anyway so the rest of gcc doesn't go nuts.  Returning a PARALLEL
5278              leads to breakage due to the fact that there are zero bytes to
5279              load.  */
5280           return gen_rtx_REG (mode, regbase);
5281         }
5282       else
5283         {
5284           /* ??? C++ has structures with no fields, and yet a size.  Give up
5285              for now and pass everything back in integer registers.  */
5286           nregs = (typesize + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
5287         }
5288       if (nregs + slotno > SPARC_INT_ARG_MAX)
5289         nregs = SPARC_INT_ARG_MAX - slotno;
5290     }
5291   if (nregs == 0)
5292     abort ();
5293
5294   parms.ret = gen_rtx_PARALLEL (mode, rtvec_alloc (parms.stack + nregs));
5295
5296   /* If at least one field must be passed on the stack, generate
5297      (parallel [(expr_list (nil) ...) ...]) so that all fields will
5298      also be passed on the stack.  We can't do much better because the
5299      semantics of FUNCTION_ARG_PARTIAL_NREGS doesn't handle the case
5300      of structures for which the fields passed exclusively in registers
5301      are not at the beginning of the structure.  */
5302   if (parms.stack)
5303     XVECEXP (parms.ret, 0, 0)
5304       = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5305
5306   /* Fill in the entries.  */
5307   parms.nregs = 0;
5308   parms.intoffset = 0;
5309   function_arg_record_value_2 (type, 0, &parms, false);
5310   function_arg_record_value_3 (typesize * BITS_PER_UNIT, &parms);
5311
5312   if (parms.nregs != nregs)
5313     abort ();
5314
5315   return parms.ret;
5316 }
5317
5318 /* Handle the FUNCTION_ARG macro.
5319    Determine where to put an argument to a function.
5320    Value is zero to push the argument on the stack,
5321    or a hard register in which to store the argument.
5322
5323    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5324     the preceding args and about the function being called.
5325    MODE is the argument's machine mode.
5326    TYPE is the data type of the argument (as a tree).
5327     This is null for libcalls where that information may
5328     not be available.
5329    NAMED is nonzero if this argument is a named parameter
5330     (otherwise it is an extra parameter matching an ellipsis).
5331    INCOMING_P is zero for FUNCTION_ARG, nonzero for FUNCTION_INCOMING_ARG.  */
5332
5333 rtx
5334 function_arg (const struct sparc_args *cum, enum machine_mode mode,
5335               tree type, int named, int incoming_p)
5336 {
5337   int regbase = (incoming_p
5338                  ? SPARC_INCOMING_INT_ARG_FIRST
5339                  : SPARC_OUTGOING_INT_ARG_FIRST);
5340   int slotno, regno, padding;
5341   rtx reg;
5342
5343   slotno = function_arg_slotno (cum, mode, type, named, incoming_p,
5344                                 &regno, &padding);
5345
5346   if (slotno == -1)
5347     return 0;
5348
5349   if (TARGET_ARCH32)
5350     {
5351       reg = gen_rtx_REG (mode, regno);
5352       return reg;
5353     }
5354
5355   if (type && TREE_CODE (type) == RECORD_TYPE)
5356     {
5357       /* Structures up to 16 bytes in size are passed in arg slots on the
5358          stack and are promoted to registers where possible.  */
5359
5360       if (int_size_in_bytes (type) > 16)
5361         abort (); /* shouldn't get here */
5362
5363       return function_arg_record_value (type, mode, slotno, named, regbase);
5364     }
5365   else if (type && TREE_CODE (type) == UNION_TYPE)
5366     {
5367       enum machine_mode mode;
5368       int bytes = int_size_in_bytes (type);
5369
5370       if (bytes > 16)
5371         abort ();
5372
5373       mode = mode_for_size (bytes * BITS_PER_UNIT, MODE_INT, 0);
5374       reg = gen_rtx_REG (mode, regno);
5375     }
5376   /* v9 fp args in reg slots beyond the int reg slots get passed in regs
5377      but also have the slot allocated for them.
5378      If no prototype is in scope fp values in register slots get passed
5379      in two places, either fp regs and int regs or fp regs and memory.  */
5380   else if ((GET_MODE_CLASS (mode) == MODE_FLOAT
5381             || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
5382       && SPARC_FP_REG_P (regno))
5383     {
5384       reg = gen_rtx_REG (mode, regno);
5385       if (cum->prototype_p || cum->libcall_p)
5386         {
5387           /* "* 2" because fp reg numbers are recorded in 4 byte
5388              quantities.  */
5389 #if 0
5390           /* ??? This will cause the value to be passed in the fp reg and
5391              in the stack.  When a prototype exists we want to pass the
5392              value in the reg but reserve space on the stack.  That's an
5393              optimization, and is deferred [for a bit].  */
5394           if ((regno - SPARC_FP_ARG_FIRST) >= SPARC_INT_ARG_MAX * 2)
5395             return gen_rtx_PARALLEL (mode,
5396                             gen_rtvec (2,
5397                                        gen_rtx_EXPR_LIST (VOIDmode,
5398                                                 NULL_RTX, const0_rtx),
5399                                        gen_rtx_EXPR_LIST (VOIDmode,
5400                                                 reg, const0_rtx)));
5401           else
5402 #else
5403           /* ??? It seems that passing back a register even when past
5404              the area declared by REG_PARM_STACK_SPACE will allocate
5405              space appropriately, and will not copy the data onto the
5406              stack, exactly as we desire.
5407
5408              This is due to locate_and_pad_parm being called in
5409              expand_call whenever reg_parm_stack_space > 0, which
5410              while beneficial to our example here, would seem to be
5411              in error from what had been intended.  Ho hum...  -- r~ */
5412 #endif
5413             return reg;
5414         }
5415       else
5416         {
5417           rtx v0, v1;
5418
5419           if ((regno - SPARC_FP_ARG_FIRST) < SPARC_INT_ARG_MAX * 2)
5420             {
5421               int intreg;
5422
5423               /* On incoming, we don't need to know that the value
5424                  is passed in %f0 and %i0, and it confuses other parts
5425                  causing needless spillage even on the simplest cases.  */
5426               if (incoming_p)
5427                 return reg;
5428
5429               intreg = (SPARC_OUTGOING_INT_ARG_FIRST
5430                         + (regno - SPARC_FP_ARG_FIRST) / 2);
5431
5432               v0 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5433               v1 = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (mode, intreg),
5434                                       const0_rtx);
5435               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5436             }
5437           else
5438             {
5439               v0 = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
5440               v1 = gen_rtx_EXPR_LIST (VOIDmode, reg, const0_rtx);
5441               return gen_rtx_PARALLEL (mode, gen_rtvec (2, v0, v1));
5442             }
5443         }
5444     }
5445   else
5446     {
5447       /* Scalar or complex int.  */
5448       reg = gen_rtx_REG (mode, regno);
5449     }
5450
5451   return reg;
5452 }
5453
5454 /* Handle the FUNCTION_ARG_PARTIAL_NREGS macro.
5455    For an arg passed partly in registers and partly in memory,
5456    this is the number of registers used.
5457    For args passed entirely in registers or entirely in memory, zero.
5458
5459    Any arg that starts in the first 6 regs but won't entirely fit in them
5460    needs partial registers on v8.  On v9, structures with integer
5461    values in arg slots 5,6 will be passed in %o5 and SP+176, and complex fp
5462    values that begin in the last fp reg [where "last fp reg" varies with the
5463    mode] will be split between that reg and memory.  */
5464
5465 int
5466 function_arg_partial_nregs (const struct sparc_args *cum,
5467                             enum machine_mode mode, tree type, int named)
5468 {
5469   int slotno, regno, padding;
5470
5471   /* We pass 0 for incoming_p here, it doesn't matter.  */
5472   slotno = function_arg_slotno (cum, mode, type, named, 0, &regno, &padding);
5473
5474   if (slotno == -1)
5475     return 0;
5476
5477   if (TARGET_ARCH32)
5478     {
5479       if ((slotno + (mode == BLKmode
5480                      ? ROUND_ADVANCE (int_size_in_bytes (type))
5481                      : ROUND_ADVANCE (GET_MODE_SIZE (mode))))
5482           > NPARM_REGS (SImode))
5483         return NPARM_REGS (SImode) - slotno;
5484       return 0;
5485     }
5486   else
5487     {
5488       if (type && AGGREGATE_TYPE_P (type))
5489         {
5490           int size = int_size_in_bytes (type);
5491           int align = TYPE_ALIGN (type);
5492
5493           if (align == 16)
5494             slotno += slotno & 1;
5495           if (size > 8 && size <= 16
5496               && slotno == SPARC_INT_ARG_MAX - 1)
5497             return 1;
5498         }
5499       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
5500                || (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
5501                    && ! (TARGET_FPU && named)))
5502         {
5503           /* The complex types are passed as packed types.  */
5504           if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
5505             return 0;
5506
5507           if (GET_MODE_ALIGNMENT (mode) == 128)
5508             {
5509               slotno += slotno & 1;
5510
5511               /* ??? The mode needs 3 slots?  */
5512               if (slotno == SPARC_INT_ARG_MAX - 2)
5513                 return 1;
5514             }
5515           else
5516             {
5517               if (slotno == SPARC_INT_ARG_MAX - 1)
5518                 return 1;
5519             }
5520         }
5521       else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
5522         {
5523           if (GET_MODE_ALIGNMENT (mode) == 128)
5524             slotno += slotno & 1;
5525           if ((slotno + GET_MODE_SIZE (mode) / UNITS_PER_WORD)
5526               > SPARC_FP_ARG_MAX)
5527             return 1;
5528         }
5529       return 0;
5530     }
5531 }
5532
5533 /* Handle the FUNCTION_ARG_PASS_BY_REFERENCE macro.
5534    !v9: The SPARC ABI stipulates passing struct arguments (of any size) and
5535    quad-precision floats by invisible reference.
5536    v9: Aggregates greater than 16 bytes are passed by reference.
5537    For Pascal, also pass arrays by reference.  */
5538
5539 int
5540 function_arg_pass_by_reference (const struct sparc_args *cum ATTRIBUTE_UNUSED,
5541                                 enum machine_mode mode, tree type,
5542                                 int named ATTRIBUTE_UNUSED)
5543 {
5544   if (TARGET_ARCH32)
5545     {
5546       return ((type && AGGREGATE_TYPE_P (type))
5547               || mode == TFmode || mode == TCmode);
5548     }
5549   else
5550     {
5551       return ((type && TREE_CODE (type) == ARRAY_TYPE)
5552               /* Consider complex values as aggregates, so care
5553                  for CTImode and TCmode.  */
5554               || GET_MODE_SIZE (mode) > 16
5555               || (type
5556                   && AGGREGATE_TYPE_P (type)
5557                   && (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 16));
5558     }
5559 }
5560
5561 /* Handle the FUNCTION_ARG_ADVANCE macro.
5562    Update the data in CUM to advance over an argument
5563    of mode MODE and data type TYPE.
5564    TYPE is null for libcalls where that information may not be available.  */
5565
5566 void
5567 function_arg_advance (struct sparc_args *cum, enum machine_mode mode,
5568                       tree type, int named)
5569 {
5570   int slotno, regno, padding;
5571
5572   /* We pass 0 for incoming_p here, it doesn't matter.  */
5573   slotno = function_arg_slotno (cum, mode, type, named, 0, &regno, &padding);
5574
5575   /* If register required leading padding, add it.  */
5576   if (slotno != -1)
5577     cum->words += padding;
5578
5579   if (TARGET_ARCH32)
5580     {
5581       cum->words += (mode != BLKmode
5582                      ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5583                      : ROUND_ADVANCE (int_size_in_bytes (type)));
5584     }
5585   else
5586     {
5587       if (type && AGGREGATE_TYPE_P (type))
5588         {
5589           int size = int_size_in_bytes (type);
5590
5591           if (size <= 8)
5592             ++cum->words;
5593           else if (size <= 16)
5594             cum->words += 2;
5595           else /* passed by reference */
5596             ++cum->words;
5597         }
5598       else
5599         {
5600           cum->words += (mode != BLKmode
5601                          ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
5602                          : ROUND_ADVANCE (int_size_in_bytes (type)));
5603         }
5604     }
5605 }
5606
5607 /* Handle the FUNCTION_ARG_PADDING macro.
5608    For the 64 bit ABI structs are always stored left shifted in their
5609    argument slot.  */
5610
5611 enum direction
5612 function_arg_padding (enum machine_mode mode, tree type)
5613 {
5614   if (TARGET_ARCH64 && type != 0 && AGGREGATE_TYPE_P (type))
5615     return upward;
5616
5617   /* Fall back to the default.  */
5618   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
5619 }
5620
5621 /* Handle FUNCTION_VALUE, FUNCTION_OUTGOING_VALUE, and LIBCALL_VALUE macros.
5622    For v9, function return values are subject to the same rules as arguments,
5623    except that up to 32-bytes may be returned in registers.  */
5624
5625 rtx
5626 function_value (tree type, enum machine_mode mode, int incoming_p)
5627 {
5628   int regno;
5629   int regbase = (incoming_p
5630                  ? SPARC_OUTGOING_INT_ARG_FIRST
5631                  : SPARC_INCOMING_INT_ARG_FIRST);
5632
5633   if (TARGET_ARCH64 && type)
5634     {
5635       if (TREE_CODE (type) == RECORD_TYPE)
5636         {
5637           /* Structures up to 32 bytes in size are passed in registers,
5638              promoted to fp registers where possible.  */
5639
5640           if (int_size_in_bytes (type) > 32)
5641             abort (); /* shouldn't get here */
5642
5643           return function_arg_record_value (type, mode, 0, 1, regbase);
5644         }
5645       else if (AGGREGATE_TYPE_P (type))
5646         {
5647           /* All other aggregate types are passed in an integer register
5648              in a mode corresponding to the size of the type.  */
5649           HOST_WIDE_INT bytes = int_size_in_bytes (type);
5650
5651           if (bytes > 32)
5652             abort ();
5653
5654           mode = mode_for_size (bytes * BITS_PER_UNIT, MODE_INT, 0);
5655         }
5656     }
5657
5658   if (TARGET_ARCH64
5659       && GET_MODE_CLASS (mode) == MODE_INT
5660       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
5661       && type && ! AGGREGATE_TYPE_P (type))
5662     mode = DImode;
5663
5664   if (incoming_p)
5665     regno = BASE_RETURN_VALUE_REG (mode);
5666   else
5667     regno = BASE_OUTGOING_VALUE_REG (mode);
5668
5669   return gen_rtx_REG (mode, regno);
5670 }
5671
5672 /* Do what is necessary for `va_start'.  We look at the current function
5673    to determine if stdarg or varargs is used and return the address of
5674    the first unnamed parameter.  */
5675
5676 rtx
5677 sparc_builtin_saveregs (void)
5678 {
5679   int first_reg = current_function_args_info.words;
5680   rtx address;
5681   int regno;
5682
5683   for (regno = first_reg; regno < NPARM_REGS (word_mode); regno++)
5684     emit_move_insn (gen_rtx_MEM (word_mode,
5685                                  gen_rtx_PLUS (Pmode,
5686                                                frame_pointer_rtx,
5687                                                GEN_INT (FIRST_PARM_OFFSET (0)
5688                                                         + (UNITS_PER_WORD
5689                                                            * regno)))),
5690                     gen_rtx_REG (word_mode,
5691                                  BASE_INCOMING_ARG_REG (word_mode) + regno));
5692
5693   address = gen_rtx_PLUS (Pmode,
5694                           frame_pointer_rtx,
5695                           GEN_INT (FIRST_PARM_OFFSET (0)
5696                                    + UNITS_PER_WORD * first_reg));
5697
5698   return address;
5699 }
5700
5701 /* Implement `va_start' for varargs and stdarg.  */
5702
5703 void
5704 sparc_va_start (tree valist, rtx nextarg)
5705 {
5706   nextarg = expand_builtin_saveregs ();
5707   std_expand_builtin_va_start (valist, nextarg);
5708 }
5709
5710 /* Implement `va_arg'.  */
5711
5712 rtx
5713 sparc_va_arg (tree valist, tree type)
5714 {
5715   HOST_WIDE_INT size, rsize, align;
5716   tree addr, incr;
5717   rtx addr_rtx;
5718   int indirect = 0;
5719
5720   /* Round up sizeof(type) to a word.  */
5721   size = int_size_in_bytes (type);
5722   rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
5723   align = 0;
5724
5725   if (TARGET_ARCH64)
5726     {
5727       if (TYPE_ALIGN (type) >= 2 * (unsigned) BITS_PER_WORD)
5728         align = 2 * UNITS_PER_WORD;
5729
5730       /* Consider complex values as aggregates, so care
5731          for CTImode and TCmode.  */
5732       if ((unsigned HOST_WIDE_INT) size > 16)
5733         {
5734           indirect = 1;
5735           size = rsize = UNITS_PER_WORD;
5736           align = 0;
5737         }
5738       else if (AGGREGATE_TYPE_P (type))
5739         {
5740           /* SPARC-V9 ABI states that structures up to 16 bytes in size
5741              are given whole slots as needed.  */
5742           if (size == 0)
5743             size = rsize = UNITS_PER_WORD;
5744           else
5745             size = rsize;
5746         }
5747     }
5748   else
5749     {
5750       if (AGGREGATE_TYPE_P (type)
5751           || TYPE_MODE (type) == TFmode
5752           || TYPE_MODE (type) == TCmode)
5753         {
5754           indirect = 1;
5755           size = rsize = UNITS_PER_WORD;
5756         }
5757     }
5758
5759   incr = valist;
5760   if (align)
5761     {
5762       incr = fold (build (PLUS_EXPR, ptr_type_node, incr,
5763                          build_int_2 (align - 1, 0)));
5764       incr = fold (build (BIT_AND_EXPR, ptr_type_node, incr,
5765                           build_int_2 (-align, -1)));
5766     }
5767
5768   addr = incr = save_expr (incr);
5769   if (BYTES_BIG_ENDIAN && size < rsize)
5770     {
5771       addr = fold (build (PLUS_EXPR, ptr_type_node, incr,
5772                           build_int_2 (rsize - size, 0)));
5773     }
5774   incr = fold (build (PLUS_EXPR, ptr_type_node, incr,
5775                       build_int_2 (rsize, 0)));
5776
5777   incr = build (MODIFY_EXPR, ptr_type_node, valist, incr);
5778   TREE_SIDE_EFFECTS (incr) = 1;
5779   expand_expr (incr, const0_rtx, VOIDmode, EXPAND_NORMAL);
5780
5781   addr_rtx = expand_expr (addr, NULL, Pmode, EXPAND_NORMAL);
5782
5783   /* If the address isn't aligned properly for the type,
5784      we may need to copy to a temporary.
5785      FIXME: This is inefficient.  Usually we can do this
5786      in registers.  */
5787   if (align == 0
5788       && TYPE_ALIGN (type) > BITS_PER_WORD
5789       && !indirect)
5790     {
5791       /* FIXME: We really need to specify that the temporary is live
5792          for the whole function because expand_builtin_va_arg wants
5793          the alias set to be get_varargs_alias_set (), but in this
5794          case the alias set is that for TYPE and if the memory gets
5795          reused it will be reused with alias set TYPE.  */
5796       rtx tmp = assign_temp (type, 0, 1, 0);
5797       rtx dest_addr;
5798
5799       addr_rtx = force_reg (Pmode, addr_rtx);
5800       addr_rtx = gen_rtx_MEM (BLKmode, addr_rtx);
5801       set_mem_alias_set (addr_rtx, get_varargs_alias_set ());
5802       set_mem_align (addr_rtx, BITS_PER_WORD);
5803       tmp = shallow_copy_rtx (tmp);
5804       PUT_MODE (tmp, BLKmode);
5805       set_mem_alias_set (tmp, 0);
5806
5807       dest_addr = emit_block_move (tmp, addr_rtx, GEN_INT (rsize),
5808                                    BLOCK_OP_NORMAL);
5809       if (dest_addr != NULL_RTX)
5810         addr_rtx = dest_addr;
5811       else
5812         addr_rtx = XCEXP (tmp, 0, MEM);
5813     }
5814
5815   if (indirect)
5816     {
5817       addr_rtx = force_reg (Pmode, addr_rtx);
5818       addr_rtx = gen_rtx_MEM (Pmode, addr_rtx);
5819       set_mem_alias_set (addr_rtx, get_varargs_alias_set ());
5820     }
5821
5822   return addr_rtx;
5823 }
5824 \f
5825 /* Return the string to output a conditional branch to LABEL, which is
5826    the operand number of the label.  OP is the conditional expression.
5827    XEXP (OP, 0) is assumed to be a condition code register (integer or
5828    floating point) and its mode specifies what kind of comparison we made.
5829
5830    REVERSED is nonzero if we should reverse the sense of the comparison.
5831
5832    ANNUL is nonzero if we should generate an annulling branch.
5833
5834    NOOP is nonzero if we have to follow this branch by a noop.
5835
5836    INSN, if set, is the insn.  */
5837
5838 char *
5839 output_cbranch (rtx op, rtx dest, int label, int reversed, int annul,
5840                 int noop, rtx insn)
5841 {
5842   static char string[50];
5843   enum rtx_code code = GET_CODE (op);
5844   rtx cc_reg = XEXP (op, 0);
5845   enum machine_mode mode = GET_MODE (cc_reg);
5846   const char *labelno, *branch;
5847   int spaces = 8, far;
5848   char *p;
5849
5850   /* v9 branches are limited to +-1MB.  If it is too far away,
5851      change
5852
5853      bne,pt %xcc, .LC30
5854
5855      to
5856
5857      be,pn %xcc, .+12
5858      nop
5859      ba .LC30
5860
5861      and
5862
5863      fbne,a,pn %fcc2, .LC29
5864
5865      to
5866
5867      fbe,pt %fcc2, .+16
5868      nop
5869      ba .LC29  */
5870
5871   far = get_attr_length (insn) >= 3;
5872   if (reversed ^ far)
5873     {
5874       /* Reversal of FP compares takes care -- an ordered compare
5875          becomes an unordered compare and vice versa.  */
5876       if (mode == CCFPmode || mode == CCFPEmode)
5877         code = reverse_condition_maybe_unordered (code);
5878       else
5879         code = reverse_condition (code);
5880     }
5881
5882   /* Start by writing the branch condition.  */
5883   if (mode == CCFPmode || mode == CCFPEmode)
5884     {
5885       switch (code)
5886         {
5887         case NE:
5888           branch = "fbne";
5889           break;
5890         case EQ:
5891           branch = "fbe";
5892           break;
5893         case GE:
5894           branch = "fbge";
5895           break;
5896         case GT:
5897           branch = "fbg";
5898           break;
5899         case LE:
5900           branch = "fble";
5901           break;
5902         case LT:
5903           branch = "fbl";
5904           break;
5905         case UNORDERED:
5906           branch = "fbu";
5907           break;
5908         case ORDERED:
5909           branch = "fbo";
5910           break;
5911         case UNGT:
5912           branch = "fbug";
5913           break;
5914         case UNLT:
5915           branch = "fbul";
5916           break;
5917         case UNEQ:
5918           branch = "fbue";
5919           break;
5920         case UNGE:
5921           branch = "fbuge";
5922           break;
5923         case UNLE:
5924           branch = "fbule";
5925           break;
5926         case LTGT:
5927           branch = "fblg";
5928           break;
5929
5930         default:
5931           abort ();
5932         }
5933
5934       /* ??? !v9: FP branches cannot be preceded by another floating point
5935          insn.  Because there is currently no concept of pre-delay slots,
5936          we can fix this only by always emitting a nop before a floating
5937          point branch.  */
5938
5939       string[0] = '\0';
5940       if (! TARGET_V9)
5941         strcpy (string, "nop\n\t");
5942       strcat (string, branch);
5943     }
5944   else
5945     {
5946       switch (code)
5947         {
5948         case NE:
5949           branch = "bne";
5950           break;
5951         case EQ:
5952           branch = "be";
5953           break;
5954         case GE:
5955           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
5956             branch = "bpos";
5957           else
5958             branch = "bge";
5959           break;
5960         case GT:
5961           branch = "bg";
5962           break;
5963         case LE:
5964           branch = "ble";
5965           break;
5966         case LT:
5967           if (mode == CC_NOOVmode || mode == CCX_NOOVmode)
5968             branch = "bneg";
5969           else
5970             branch = "bl";
5971           break;
5972         case GEU:
5973           branch = "bgeu";
5974           break;
5975         case GTU:
5976           branch = "bgu";
5977           break;
5978         case LEU:
5979           branch = "bleu";
5980           break;
5981         case LTU:
5982           branch = "blu";
5983           break;
5984
5985         default:
5986           abort ();
5987         }
5988       strcpy (string, branch);
5989     }
5990   spaces -= strlen (branch);
5991   p = strchr (string, '\0');
5992
5993   /* Now add the annulling, the label, and a possible noop.  */
5994   if (annul && ! far)
5995     {
5996       strcpy (p, ",a");
5997       p += 2;
5998       spaces -= 2;
5999     }
6000
6001   if (! TARGET_V9)
6002     labelno = "";
6003   else
6004     {
6005       rtx note;
6006       int v8 = 0;
6007
6008       if (! far && insn && INSN_ADDRESSES_SET_P ())
6009         {
6010           int delta = (INSN_ADDRESSES (INSN_UID (dest))
6011                        - INSN_ADDRESSES (INSN_UID (insn)));
6012           /* Leave some instructions for "slop".  */
6013           if (delta < -260000 || delta >= 260000)
6014             v8 = 1;
6015         }
6016
6017       if (mode == CCFPmode || mode == CCFPEmode)
6018         {
6019           static char v9_fcc_labelno[] = "%%fccX, ";
6020           /* Set the char indicating the number of the fcc reg to use.  */
6021           v9_fcc_labelno[5] = REGNO (cc_reg) - SPARC_FIRST_V9_FCC_REG + '0';
6022           labelno = v9_fcc_labelno;
6023           if (v8)
6024             {
6025               if (REGNO (cc_reg) == SPARC_FCC_REG)
6026                 labelno = "";
6027               else
6028                 abort ();
6029             }
6030         }
6031       else if (mode == CCXmode || mode == CCX_NOOVmode)
6032         {
6033           labelno = "%%xcc, ";
6034           if (v8)
6035             abort ();
6036         }
6037       else
6038         {
6039           labelno = "%%icc, ";
6040           if (v8)
6041             labelno = "";
6042         }
6043
6044       if (*labelno && insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6045         {
6046           strcpy (p,
6047                   ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6048                   ? ",pt" : ",pn");
6049           p += 3;
6050           spaces -= 3;
6051         }
6052     }
6053   if (spaces > 0)
6054     *p++ = '\t';
6055   else
6056     *p++ = ' ';
6057   strcpy (p, labelno);
6058   p = strchr (p, '\0');
6059   if (far)
6060     {
6061       strcpy (p, ".+12\n\tnop\n\tb\t");
6062       if (annul || noop)
6063         p[3] = '6';
6064       p += 13;
6065     }
6066   *p++ = '%';
6067   *p++ = 'l';
6068   /* Set the char indicating the number of the operand containing the
6069      label_ref.  */
6070   *p++ = label + '0';
6071   *p = '\0';
6072   if (noop)
6073     strcpy (p, "\n\tnop");
6074
6075   return string;
6076 }
6077
6078 /* Emit a library call comparison between floating point X and Y.
6079    COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).
6080    TARGET_ARCH64 uses _Qp_* functions, which use pointers to TFmode
6081    values as arguments instead of the TFmode registers themselves,
6082    that's why we cannot call emit_float_lib_cmp.  */
6083 void
6084 sparc_emit_float_lib_cmp (rtx x, rtx y, enum rtx_code comparison)
6085 {
6086   const char *qpfunc;
6087   rtx slot0, slot1, result, tem, tem2;
6088   enum machine_mode mode;
6089
6090   switch (comparison)
6091     {
6092     case EQ:
6093       qpfunc = (TARGET_ARCH64) ? "_Qp_feq" : "_Q_feq";
6094       break;
6095
6096     case NE:
6097       qpfunc = (TARGET_ARCH64) ? "_Qp_fne" : "_Q_fne";
6098       break;
6099
6100     case GT:
6101       qpfunc = (TARGET_ARCH64) ? "_Qp_fgt" : "_Q_fgt";
6102       break;
6103
6104     case GE:
6105       qpfunc = (TARGET_ARCH64) ? "_Qp_fge" : "_Q_fge";
6106       break;
6107
6108     case LT:
6109       qpfunc = (TARGET_ARCH64) ? "_Qp_flt" : "_Q_flt";
6110       break;
6111
6112     case LE:
6113       qpfunc = (TARGET_ARCH64) ? "_Qp_fle" : "_Q_fle";
6114       break;
6115
6116     case ORDERED:
6117     case UNORDERED:
6118     case UNGT:
6119     case UNLT:
6120     case UNEQ:
6121     case UNGE:
6122     case UNLE:
6123     case LTGT:
6124       qpfunc = (TARGET_ARCH64) ? "_Qp_cmp" : "_Q_cmp";
6125       break;
6126
6127     default:
6128       abort();
6129       break;
6130     }
6131
6132   if (TARGET_ARCH64)
6133     {
6134       if (GET_CODE (x) != MEM)
6135         {
6136           slot0 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6137           emit_insn (gen_rtx_SET (VOIDmode, slot0, x));
6138         }
6139       else
6140         slot0 = x;
6141
6142       if (GET_CODE (y) != MEM)
6143         {
6144           slot1 = assign_stack_temp (TFmode, GET_MODE_SIZE(TFmode), 0);
6145           emit_insn (gen_rtx_SET (VOIDmode, slot1, y));
6146         }
6147       else
6148         slot1 = y;
6149
6150       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, qpfunc), LCT_NORMAL,
6151                          DImode, 2,
6152                          XEXP (slot0, 0), Pmode,
6153                          XEXP (slot1, 0), Pmode);
6154
6155       mode = DImode;
6156     }
6157   else
6158     {
6159       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, qpfunc), LCT_NORMAL,
6160                          SImode, 2,
6161                          x, TFmode, y, TFmode);
6162
6163       mode = SImode;
6164     }
6165
6166
6167   /* Immediately move the result of the libcall into a pseudo
6168      register so reload doesn't clobber the value if it needs
6169      the return register for a spill reg.  */
6170   result = gen_reg_rtx (mode);
6171   emit_move_insn (result, hard_libcall_value (mode));
6172
6173   switch (comparison)
6174     {
6175     default:
6176       emit_cmp_insn (result, const0_rtx, NE, NULL_RTX, mode, 0);
6177       break;
6178     case ORDERED:
6179     case UNORDERED:
6180       emit_cmp_insn (result, GEN_INT(3), comparison == UNORDERED ? EQ : NE,
6181                      NULL_RTX, mode, 0);
6182       break;
6183     case UNGT:
6184     case UNGE:
6185       emit_cmp_insn (result, const1_rtx,
6186                      comparison == UNGT ? GT : NE, NULL_RTX, mode, 0);
6187       break;
6188     case UNLE:
6189       emit_cmp_insn (result, const2_rtx, NE, NULL_RTX, mode, 0);
6190       break;
6191     case UNLT:
6192       tem = gen_reg_rtx (mode);
6193       if (TARGET_ARCH32)
6194         emit_insn (gen_andsi3 (tem, result, const1_rtx));
6195       else
6196         emit_insn (gen_anddi3 (tem, result, const1_rtx));
6197       emit_cmp_insn (tem, const0_rtx, NE, NULL_RTX, mode, 0);
6198       break;
6199     case UNEQ:
6200     case LTGT:
6201       tem = gen_reg_rtx (mode);
6202       if (TARGET_ARCH32)
6203         emit_insn (gen_addsi3 (tem, result, const1_rtx));
6204       else
6205         emit_insn (gen_adddi3 (tem, result, const1_rtx));
6206       tem2 = gen_reg_rtx (mode);
6207       if (TARGET_ARCH32)
6208         emit_insn (gen_andsi3 (tem2, tem, const2_rtx));
6209       else
6210         emit_insn (gen_anddi3 (tem2, tem, const2_rtx));
6211       emit_cmp_insn (tem2, const0_rtx, comparison == UNEQ ? EQ : NE,
6212                      NULL_RTX, mode, 0);
6213       break;
6214     }
6215 }
6216
6217 /* Generate an unsigned DImode to FP conversion.  This is the same code
6218    optabs would emit if we didn't have TFmode patterns.  */
6219
6220 void
6221 sparc_emit_floatunsdi (rtx *operands)
6222 {
6223   rtx neglab, donelab, i0, i1, f0, in, out;
6224   enum machine_mode mode;
6225
6226   out = operands[0];
6227   in = force_reg (DImode, operands[1]);
6228   mode = GET_MODE (out);
6229   neglab = gen_label_rtx ();
6230   donelab = gen_label_rtx ();
6231   i0 = gen_reg_rtx (DImode);
6232   i1 = gen_reg_rtx (DImode);
6233   f0 = gen_reg_rtx (mode);
6234
6235   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
6236
6237   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
6238   emit_jump_insn (gen_jump (donelab));
6239   emit_barrier ();
6240
6241   emit_label (neglab);
6242
6243   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
6244   emit_insn (gen_anddi3 (i1, in, const1_rtx));
6245   emit_insn (gen_iordi3 (i0, i0, i1));
6246   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
6247   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
6248
6249   emit_label (donelab);
6250 }
6251
6252 /* Return the string to output a conditional branch to LABEL, testing
6253    register REG.  LABEL is the operand number of the label; REG is the
6254    operand number of the reg.  OP is the conditional expression.  The mode
6255    of REG says what kind of comparison we made.
6256
6257    REVERSED is nonzero if we should reverse the sense of the comparison.
6258
6259    ANNUL is nonzero if we should generate an annulling branch.
6260
6261    NOOP is nonzero if we have to follow this branch by a noop.  */
6262
6263 char *
6264 output_v9branch (rtx op, rtx dest, int reg, int label, int reversed,
6265                  int annul, int noop, rtx insn)
6266 {
6267   static char string[50];
6268   enum rtx_code code = GET_CODE (op);
6269   enum machine_mode mode = GET_MODE (XEXP (op, 0));
6270   rtx note;
6271   int far;
6272   char *p;
6273
6274   /* branch on register are limited to +-128KB.  If it is too far away,
6275      change
6276
6277      brnz,pt %g1, .LC30
6278
6279      to
6280
6281      brz,pn %g1, .+12
6282      nop
6283      ba,pt %xcc, .LC30
6284
6285      and
6286
6287      brgez,a,pn %o1, .LC29
6288
6289      to
6290
6291      brlz,pt %o1, .+16
6292      nop
6293      ba,pt %xcc, .LC29  */
6294
6295   far = get_attr_length (insn) >= 3;
6296
6297   /* If not floating-point or if EQ or NE, we can just reverse the code.  */
6298   if (reversed ^ far)
6299     code = reverse_condition (code);
6300
6301   /* Only 64 bit versions of these instructions exist.  */
6302   if (mode != DImode)
6303     abort ();
6304
6305   /* Start by writing the branch condition.  */
6306
6307   switch (code)
6308     {
6309     case NE:
6310       strcpy (string, "brnz");
6311       break;
6312
6313     case EQ:
6314       strcpy (string, "brz");
6315       break;
6316
6317     case GE:
6318       strcpy (string, "brgez");
6319       break;
6320
6321     case LT:
6322       strcpy (string, "brlz");
6323       break;
6324
6325     case LE:
6326       strcpy (string, "brlez");
6327       break;
6328
6329     case GT:
6330       strcpy (string, "brgz");
6331       break;
6332
6333     default:
6334       abort ();
6335     }
6336
6337   p = strchr (string, '\0');
6338
6339   /* Now add the annulling, reg, label, and nop.  */
6340   if (annul && ! far)
6341     {
6342       strcpy (p, ",a");
6343       p += 2;
6344     }
6345
6346   if (insn && (note = find_reg_note (insn, REG_BR_PROB, NULL_RTX)))
6347     {
6348       strcpy (p,
6349               ((INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2) ^ far)
6350               ? ",pt" : ",pn");
6351       p += 3;
6352     }
6353
6354   *p = p < string + 8 ? '\t' : ' ';
6355   p++;
6356   *p++ = '%';
6357   *p++ = '0' + reg;
6358   *p++ = ',';
6359   *p++ = ' ';
6360   if (far)
6361     {
6362       int veryfar = 1, delta;
6363
6364       if (INSN_ADDRESSES_SET_P ())
6365         {
6366           delta = (INSN_ADDRESSES (INSN_UID (dest))
6367                    - INSN_ADDRESSES (INSN_UID (insn)));
6368           /* Leave some instructions for "slop".  */
6369           if (delta >= -260000 && delta < 260000)
6370             veryfar = 0;
6371         }
6372
6373       strcpy (p, ".+12\n\tnop\n\t");
6374       if (annul || noop)
6375         p[3] = '6';
6376       p += 11;
6377       if (veryfar)
6378         {
6379           strcpy (p, "b\t");
6380           p += 2;
6381         }
6382       else
6383         {
6384           strcpy (p, "ba,pt\t%%xcc, ");
6385           p += 13;
6386         }
6387     }
6388   *p++ = '%';
6389   *p++ = 'l';
6390   *p++ = '0' + label;
6391   *p = '\0';
6392
6393   if (noop)
6394     strcpy (p, "\n\tnop");
6395
6396   return string;
6397 }
6398
6399 /* Return 1, if any of the registers of the instruction are %l[0-7] or %o[0-7].
6400    Such instructions cannot be used in the delay slot of return insn on v9.
6401    If TEST is 0, also rename all %i[0-7] registers to their %o[0-7] counterparts.
6402  */
6403
6404 static int
6405 epilogue_renumber (register rtx *where, int test)
6406 {
6407   register const char *fmt;
6408   register int i;
6409   register enum rtx_code code;
6410
6411   if (*where == 0)
6412     return 0;
6413
6414   code = GET_CODE (*where);
6415
6416   switch (code)
6417     {
6418     case REG:
6419       if (REGNO (*where) >= 8 && REGNO (*where) < 24)      /* oX or lX */
6420         return 1;
6421       if (! test && REGNO (*where) >= 24 && REGNO (*where) < 32)
6422         *where = gen_rtx (REG, GET_MODE (*where), OUTGOING_REGNO (REGNO(*where)));
6423     case SCRATCH:
6424     case CC0:
6425     case PC:
6426     case CONST_INT:
6427     case CONST_DOUBLE:
6428       return 0;
6429
6430       /* Do not replace the frame pointer with the stack pointer because
6431          it can cause the delayed instruction to load below the stack.
6432          This occurs when instructions like:
6433
6434          (set (reg/i:SI 24 %i0)
6435              (mem/f:SI (plus:SI (reg/f:SI 30 %fp)
6436                        (const_int -20 [0xffffffec])) 0))
6437
6438          are in the return delayed slot.  */
6439     case PLUS:
6440       if (GET_CODE (XEXP (*where, 0)) == REG
6441           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM
6442           && (GET_CODE (XEXP (*where, 1)) != CONST_INT
6443               || INTVAL (XEXP (*where, 1)) < SPARC_STACK_BIAS))
6444         return 1;
6445       break;
6446
6447     case MEM:
6448       if (SPARC_STACK_BIAS
6449           && GET_CODE (XEXP (*where, 0)) == REG
6450           && REGNO (XEXP (*where, 0)) == HARD_FRAME_POINTER_REGNUM)
6451         return 1;
6452       break;
6453
6454     default:
6455       break;
6456     }
6457
6458   fmt = GET_RTX_FORMAT (code);
6459
6460   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6461     {
6462       if (fmt[i] == 'E')
6463         {
6464           register int j;
6465           for (j = XVECLEN (*where, i) - 1; j >= 0; j--)
6466             if (epilogue_renumber (&(XVECEXP (*where, i, j)), test))
6467               return 1;
6468         }
6469       else if (fmt[i] == 'e'
6470                && epilogue_renumber (&(XEXP (*where, i)), test))
6471         return 1;
6472     }
6473   return 0;
6474 }
6475 \f
6476 /* Leaf functions and non-leaf functions have different needs.  */
6477
6478 static const int
6479 reg_leaf_alloc_order[] = REG_LEAF_ALLOC_ORDER;
6480
6481 static const int
6482 reg_nonleaf_alloc_order[] = REG_ALLOC_ORDER;
6483
6484 static const int *const reg_alloc_orders[] = {
6485   reg_leaf_alloc_order,
6486   reg_nonleaf_alloc_order};
6487
6488 void
6489 order_regs_for_local_alloc (void)
6490 {
6491   static int last_order_nonleaf = 1;
6492
6493   if (regs_ever_live[15] != last_order_nonleaf)
6494     {
6495       last_order_nonleaf = !last_order_nonleaf;
6496       memcpy ((char *) reg_alloc_order,
6497               (const char *) reg_alloc_orders[last_order_nonleaf],
6498               FIRST_PSEUDO_REGISTER * sizeof (int));
6499     }
6500 }
6501 \f
6502 /* Return 1 if REG and MEM are legitimate enough to allow the various
6503    mem<-->reg splits to be run.  */
6504
6505 int
6506 sparc_splitdi_legitimate (rtx reg, rtx mem)
6507 {
6508   /* Punt if we are here by mistake.  */
6509   if (! reload_completed)
6510     abort ();
6511
6512   /* We must have an offsettable memory reference.  */
6513   if (! offsettable_memref_p (mem))
6514     return 0;
6515
6516   /* If we have legitimate args for ldd/std, we do not want
6517      the split to happen.  */
6518   if ((REGNO (reg) % 2) == 0
6519       && mem_min_alignment (mem, 8))
6520     return 0;
6521
6522   /* Success.  */
6523   return 1;
6524 }
6525
6526 /* Return 1 if x and y are some kind of REG and they refer to
6527    different hard registers.  This test is guaranteed to be
6528    run after reload.  */
6529
6530 int
6531 sparc_absnegfloat_split_legitimate (rtx x, rtx y)
6532 {
6533   if (GET_CODE (x) != REG)
6534     return 0;
6535   if (GET_CODE (y) != REG)
6536     return 0;
6537   if (REGNO (x) == REGNO (y))
6538     return 0;
6539   return 1;
6540 }
6541
6542 /* Return 1 if REGNO (reg1) is even and REGNO (reg1) == REGNO (reg2) - 1.
6543    This makes them candidates for using ldd and std insns.
6544
6545    Note reg1 and reg2 *must* be hard registers.  */
6546
6547 int
6548 registers_ok_for_ldd_peep (rtx reg1, rtx reg2)
6549 {
6550   /* We might have been passed a SUBREG.  */
6551   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
6552     return 0;
6553
6554   if (REGNO (reg1) % 2 != 0)
6555     return 0;
6556
6557   /* Integer ldd is deprecated in SPARC V9 */
6558   if (TARGET_V9 && REGNO (reg1) < 32)
6559     return 0;
6560
6561   return (REGNO (reg1) == REGNO (reg2) - 1);
6562 }
6563
6564 /* Return 1 if the addresses in mem1 and mem2 are suitable for use in
6565    an ldd or std insn.
6566
6567    This can only happen when addr1 and addr2, the addresses in mem1
6568    and mem2, are consecutive memory locations (addr1 + 4 == addr2).
6569    addr1 must also be aligned on a 64-bit boundary.
6570
6571    Also iff dependent_reg_rtx is not null it should not be used to
6572    compute the address for mem1, i.e. we cannot optimize a sequence
6573    like:
6574         ld [%o0], %o0
6575         ld [%o0 + 4], %o1
6576    to
6577         ldd [%o0], %o0
6578    nor:
6579         ld [%g3 + 4], %g3
6580         ld [%g3], %g2
6581    to
6582         ldd [%g3], %g2
6583
6584    But, note that the transformation from:
6585         ld [%g2 + 4], %g3
6586         ld [%g2], %g2
6587    to
6588         ldd [%g2], %g2
6589    is perfectly fine.  Thus, the peephole2 patterns always pass us
6590    the destination register of the first load, never the second one.
6591
6592    For stores we don't have a similar problem, so dependent_reg_rtx is
6593    NULL_RTX.  */
6594
6595 int
6596 mems_ok_for_ldd_peep (rtx mem1, rtx mem2, rtx dependent_reg_rtx)
6597 {
6598   rtx addr1, addr2;
6599   unsigned int reg1;
6600   HOST_WIDE_INT offset1;
6601
6602   /* The mems cannot be volatile.  */
6603   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
6604     return 0;
6605
6606   /* MEM1 should be aligned on a 64-bit boundary.  */
6607   if (MEM_ALIGN (mem1) < 64)
6608     return 0;
6609
6610   addr1 = XEXP (mem1, 0);
6611   addr2 = XEXP (mem2, 0);
6612
6613   /* Extract a register number and offset (if used) from the first addr.  */
6614   if (GET_CODE (addr1) == PLUS)
6615     {
6616       /* If not a REG, return zero.  */
6617       if (GET_CODE (XEXP (addr1, 0)) != REG)
6618         return 0;
6619       else
6620         {
6621           reg1 = REGNO (XEXP (addr1, 0));
6622           /* The offset must be constant!  */
6623           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
6624             return 0;
6625           offset1 = INTVAL (XEXP (addr1, 1));
6626         }
6627     }
6628   else if (GET_CODE (addr1) != REG)
6629     return 0;
6630   else
6631     {
6632       reg1 = REGNO (addr1);
6633       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
6634       offset1 = 0;
6635     }
6636
6637   /* Make sure the second address is a (mem (plus (reg) (const_int).  */
6638   if (GET_CODE (addr2) != PLUS)
6639     return 0;
6640
6641   if (GET_CODE (XEXP (addr2, 0)) != REG
6642       || GET_CODE (XEXP (addr2, 1)) != CONST_INT)
6643     return 0;
6644
6645   if (reg1 != REGNO (XEXP (addr2, 0)))
6646     return 0;
6647
6648   if (dependent_reg_rtx != NULL_RTX && reg1 == REGNO (dependent_reg_rtx))
6649     return 0;
6650
6651   /* The first offset must be evenly divisible by 8 to ensure the
6652      address is 64 bit aligned.  */
6653   if (offset1 % 8 != 0)
6654     return 0;
6655
6656   /* The offset for the second addr must be 4 more than the first addr.  */
6657   if (INTVAL (XEXP (addr2, 1)) != offset1 + 4)
6658     return 0;
6659
6660   /* All the tests passed.  addr1 and addr2 are valid for ldd and std
6661      instructions.  */
6662   return 1;
6663 }
6664
6665 /* Return 1 if reg is a pseudo, or is the first register in
6666    a hard register pair.  This makes it a candidate for use in
6667    ldd and std insns.  */
6668
6669 int
6670 register_ok_for_ldd (rtx reg)
6671 {
6672   /* We might have been passed a SUBREG.  */
6673   if (GET_CODE (reg) != REG)
6674     return 0;
6675
6676   if (REGNO (reg) < FIRST_PSEUDO_REGISTER)
6677     return (REGNO (reg) % 2 == 0);
6678   else
6679     return 1;
6680 }
6681 \f
6682 /* Print operand X (an rtx) in assembler syntax to file FILE.
6683    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
6684    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
6685
6686 void
6687 print_operand (FILE *file, rtx x, int code)
6688 {
6689   switch (code)
6690     {
6691     case '#':
6692       /* Output a 'nop' if there's nothing for the delay slot.  */
6693       if (dbr_sequence_length () == 0)
6694         fputs ("\n\t nop", file);
6695       return;
6696     case '*':
6697       /* Output an annul flag if there's nothing for the delay slot and we
6698          are optimizing.  This is always used with '(' below.  */
6699       /* Sun OS 4.1.1 dbx can't handle an annulled unconditional branch;
6700          this is a dbx bug.  So, we only do this when optimizing.  */
6701       /* On UltraSPARC, a branch in a delay slot causes a pipeline flush.
6702          Always emit a nop in case the next instruction is a branch.  */
6703       if (dbr_sequence_length () == 0
6704           && (optimize && (int)sparc_cpu < PROCESSOR_V9))
6705         fputs (",a", file);
6706       return;
6707     case '(':
6708       /* Output a 'nop' if there's nothing for the delay slot and we are
6709          not optimizing.  This is always used with '*' above.  */
6710       if (dbr_sequence_length () == 0
6711           && ! (optimize && (int)sparc_cpu < PROCESSOR_V9))
6712         fputs ("\n\t nop", file);
6713       return;
6714     case '_':
6715       /* Output the Embedded Medium/Anywhere code model base register.  */
6716       fputs (EMBMEDANY_BASE_REG, file);
6717       return;
6718     case '@':
6719       /* Print out what we are using as the frame pointer.  This might
6720          be %fp, or might be %sp+offset.  */
6721       /* ??? What if offset is too big? Perhaps the caller knows it isn't? */
6722       fprintf (file, "%s+"HOST_WIDE_INT_PRINT_DEC, frame_base_name, frame_base_offset);
6723       return;
6724     case '&':
6725       /* Print some local dynamic TLS name.  */
6726       assemble_name (file, get_some_local_dynamic_name ());
6727       return;
6728     case 'Y':
6729       /* Adjust the operand to take into account a RESTORE operation.  */
6730       if (GET_CODE (x) == CONST_INT)
6731         break;
6732       else if (GET_CODE (x) != REG)
6733         output_operand_lossage ("invalid %%Y operand");
6734       else if (REGNO (x) < 8)
6735         fputs (reg_names[REGNO (x)], file);
6736       else if (REGNO (x) >= 24 && REGNO (x) < 32)
6737         fputs (reg_names[REGNO (x)-16], file);
6738       else
6739         output_operand_lossage ("invalid %%Y operand");
6740       return;
6741     case 'L':
6742       /* Print out the low order register name of a register pair.  */
6743       if (WORDS_BIG_ENDIAN)
6744         fputs (reg_names[REGNO (x)+1], file);
6745       else
6746         fputs (reg_names[REGNO (x)], file);
6747       return;
6748     case 'H':
6749       /* Print out the high order register name of a register pair.  */
6750       if (WORDS_BIG_ENDIAN)
6751         fputs (reg_names[REGNO (x)], file);
6752       else
6753         fputs (reg_names[REGNO (x)+1], file);
6754       return;
6755     case 'R':
6756       /* Print out the second register name of a register pair or quad.
6757          I.e., R (%o0) => %o1.  */
6758       fputs (reg_names[REGNO (x)+1], file);
6759       return;
6760     case 'S':
6761       /* Print out the third register name of a register quad.
6762          I.e., S (%o0) => %o2.  */
6763       fputs (reg_names[REGNO (x)+2], file);
6764       return;
6765     case 'T':
6766       /* Print out the fourth register name of a register quad.
6767          I.e., T (%o0) => %o3.  */
6768       fputs (reg_names[REGNO (x)+3], file);
6769       return;
6770     case 'x':
6771       /* Print a condition code register.  */
6772       if (REGNO (x) == SPARC_ICC_REG)
6773         {
6774           /* We don't handle CC[X]_NOOVmode because they're not supposed
6775              to occur here.  */
6776           if (GET_MODE (x) == CCmode)
6777             fputs ("%icc", file);
6778           else if (GET_MODE (x) == CCXmode)
6779             fputs ("%xcc", file);
6780           else
6781             abort ();
6782         }
6783       else
6784         /* %fccN register */
6785         fputs (reg_names[REGNO (x)], file);
6786       return;
6787     case 'm':
6788       /* Print the operand's address only.  */
6789       output_address (XEXP (x, 0));
6790       return;
6791     case 'r':
6792       /* In this case we need a register.  Use %g0 if the
6793          operand is const0_rtx.  */
6794       if (x == const0_rtx
6795           || (GET_MODE (x) != VOIDmode && x == CONST0_RTX (GET_MODE (x))))
6796         {
6797           fputs ("%g0", file);
6798           return;
6799         }
6800       else
6801         break;
6802
6803     case 'A':
6804       switch (GET_CODE (x))
6805         {
6806         case IOR: fputs ("or", file); break;
6807         case AND: fputs ("and", file); break;
6808         case XOR: fputs ("xor", file); break;
6809         default: output_operand_lossage ("invalid %%A operand");
6810         }
6811       return;
6812
6813     case 'B':
6814       switch (GET_CODE (x))
6815         {
6816         case IOR: fputs ("orn", file); break;
6817         case AND: fputs ("andn", file); break;
6818         case XOR: fputs ("xnor", file); break;
6819         default: output_operand_lossage ("invalid %%B operand");
6820         }
6821       return;
6822
6823       /* These are used by the conditional move instructions.  */
6824     case 'c' :
6825     case 'C':
6826       {
6827         enum rtx_code rc = GET_CODE (x);
6828
6829         if (code == 'c')
6830           {
6831             enum machine_mode mode = GET_MODE (XEXP (x, 0));
6832             if (mode == CCFPmode || mode == CCFPEmode)
6833               rc = reverse_condition_maybe_unordered (GET_CODE (x));
6834             else
6835               rc = reverse_condition (GET_CODE (x));
6836           }
6837         switch (rc)
6838           {
6839           case NE: fputs ("ne", file); break;
6840           case EQ: fputs ("e", file); break;
6841           case GE: fputs ("ge", file); break;
6842           case GT: fputs ("g", file); break;
6843           case LE: fputs ("le", file); break;
6844           case LT: fputs ("l", file); break;
6845           case GEU: fputs ("geu", file); break;
6846           case GTU: fputs ("gu", file); break;
6847           case LEU: fputs ("leu", file); break;
6848           case LTU: fputs ("lu", file); break;
6849           case LTGT: fputs ("lg", file); break;
6850           case UNORDERED: fputs ("u", file); break;
6851           case ORDERED: fputs ("o", file); break;
6852           case UNLT: fputs ("ul", file); break;
6853           case UNLE: fputs ("ule", file); break;
6854           case UNGT: fputs ("ug", file); break;
6855           case UNGE: fputs ("uge", file); break;
6856           case UNEQ: fputs ("ue", file); break;
6857           default: output_operand_lossage (code == 'c'
6858                                            ? "invalid %%c operand"
6859                                            : "invalid %%C operand");
6860           }
6861         return;
6862       }
6863
6864       /* These are used by the movr instruction pattern.  */
6865     case 'd':
6866     case 'D':
6867       {
6868         enum rtx_code rc = (code == 'd'
6869                             ? reverse_condition (GET_CODE (x))
6870                             : GET_CODE (x));
6871         switch (rc)
6872           {
6873           case NE: fputs ("ne", file); break;
6874           case EQ: fputs ("e", file); break;
6875           case GE: fputs ("gez", file); break;
6876           case LT: fputs ("lz", file); break;
6877           case LE: fputs ("lez", file); break;
6878           case GT: fputs ("gz", file); break;
6879           default: output_operand_lossage (code == 'd'
6880                                            ? "invalid %%d operand"
6881                                            : "invalid %%D operand");
6882           }
6883         return;
6884       }
6885
6886     case 'b':
6887       {
6888         /* Print a sign-extended character.  */
6889         int i = trunc_int_for_mode (INTVAL (x), QImode);
6890         fprintf (file, "%d", i);
6891         return;
6892       }
6893
6894     case 'f':
6895       /* Operand must be a MEM; write its address.  */
6896       if (GET_CODE (x) != MEM)
6897         output_operand_lossage ("invalid %%f operand");
6898       output_address (XEXP (x, 0));
6899       return;
6900
6901     case 's':
6902       {
6903         /* Print a sign-extended 32-bit value.  */
6904         HOST_WIDE_INT i;
6905         if (GET_CODE(x) == CONST_INT)
6906           i = INTVAL (x);
6907         else if (GET_CODE(x) == CONST_DOUBLE)
6908           i = CONST_DOUBLE_LOW (x);
6909         else
6910           {
6911             output_operand_lossage ("invalid %%s operand");
6912             return;
6913           }
6914         i = trunc_int_for_mode (i, SImode);
6915         fprintf (file, HOST_WIDE_INT_PRINT_DEC, i);
6916         return;
6917       }
6918
6919     case 0:
6920       /* Do nothing special.  */
6921       break;
6922
6923     default:
6924       /* Undocumented flag.  */
6925       output_operand_lossage ("invalid operand output code");
6926     }
6927
6928   if (GET_CODE (x) == REG)
6929     fputs (reg_names[REGNO (x)], file);
6930   else if (GET_CODE (x) == MEM)
6931     {
6932       fputc ('[', file);
6933         /* Poor Sun assembler doesn't understand absolute addressing.  */
6934       if (CONSTANT_P (XEXP (x, 0)))
6935         fputs ("%g0+", file);
6936       output_address (XEXP (x, 0));
6937       fputc (']', file);
6938     }
6939   else if (GET_CODE (x) == HIGH)
6940     {
6941       fputs ("%hi(", file);
6942       output_addr_const (file, XEXP (x, 0));
6943       fputc (')', file);
6944     }
6945   else if (GET_CODE (x) == LO_SUM)
6946     {
6947       print_operand (file, XEXP (x, 0), 0);
6948       if (TARGET_CM_MEDMID)
6949         fputs ("+%l44(", file);
6950       else
6951         fputs ("+%lo(", file);
6952       output_addr_const (file, XEXP (x, 1));
6953       fputc (')', file);
6954     }
6955   else if (GET_CODE (x) == CONST_DOUBLE
6956            && (GET_MODE (x) == VOIDmode
6957                || GET_MODE_CLASS (GET_MODE (x)) == MODE_INT))
6958     {
6959       if (CONST_DOUBLE_HIGH (x) == 0)
6960         fprintf (file, "%u", (unsigned int) CONST_DOUBLE_LOW (x));
6961       else if (CONST_DOUBLE_HIGH (x) == -1
6962                && CONST_DOUBLE_LOW (x) < 0)
6963         fprintf (file, "%d", (int) CONST_DOUBLE_LOW (x));
6964       else
6965         output_operand_lossage ("long long constant not a valid immediate operand");
6966     }
6967   else if (GET_CODE (x) == CONST_DOUBLE)
6968     output_operand_lossage ("floating point constant not a valid immediate operand");
6969   else { output_addr_const (file, x); }
6970 }
6971 \f
6972 /* Target hook for assembling integer objects.  The sparc version has
6973    special handling for aligned DI-mode objects.  */
6974
6975 static bool
6976 sparc_assemble_integer (rtx x, unsigned int size, int aligned_p)
6977 {
6978   /* ??? We only output .xword's for symbols and only then in environments
6979      where the assembler can handle them.  */
6980   if (aligned_p && size == 8
6981       && (GET_CODE (x) != CONST_INT && GET_CODE (x) != CONST_DOUBLE))
6982     {
6983       if (TARGET_V9)
6984         {
6985           assemble_integer_with_op ("\t.xword\t", x);
6986           return true;
6987         }
6988       else
6989         {
6990           assemble_aligned_integer (4, const0_rtx);
6991           assemble_aligned_integer (4, x);
6992           return true;
6993         }
6994     }
6995   return default_assemble_integer (x, size, aligned_p);
6996 }
6997 \f
6998 /* Return the value of a code used in the .proc pseudo-op that says
6999    what kind of result this function returns.  For non-C types, we pick
7000    the closest C type.  */
7001
7002 #ifndef SHORT_TYPE_SIZE
7003 #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
7004 #endif
7005
7006 #ifndef INT_TYPE_SIZE
7007 #define INT_TYPE_SIZE BITS_PER_WORD
7008 #endif
7009
7010 #ifndef LONG_TYPE_SIZE
7011 #define LONG_TYPE_SIZE BITS_PER_WORD
7012 #endif
7013
7014 #ifndef LONG_LONG_TYPE_SIZE
7015 #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
7016 #endif
7017
7018 #ifndef FLOAT_TYPE_SIZE
7019 #define FLOAT_TYPE_SIZE BITS_PER_WORD
7020 #endif
7021
7022 #ifndef DOUBLE_TYPE_SIZE
7023 #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7024 #endif
7025
7026 #ifndef LONG_DOUBLE_TYPE_SIZE
7027 #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
7028 #endif
7029
7030 unsigned long
7031 sparc_type_code (register tree type)
7032 {
7033   register unsigned long qualifiers = 0;
7034   register unsigned shift;
7035
7036   /* Only the first 30 bits of the qualifier are valid.  We must refrain from
7037      setting more, since some assemblers will give an error for this.  Also,
7038      we must be careful to avoid shifts of 32 bits or more to avoid getting
7039      unpredictable results.  */
7040
7041   for (shift = 6; shift < 30; shift += 2, type = TREE_TYPE (type))
7042     {
7043       switch (TREE_CODE (type))
7044         {
7045         case ERROR_MARK:
7046           return qualifiers;
7047
7048         case ARRAY_TYPE:
7049           qualifiers |= (3 << shift);
7050           break;
7051
7052         case FUNCTION_TYPE:
7053         case METHOD_TYPE:
7054           qualifiers |= (2 << shift);
7055           break;
7056
7057         case POINTER_TYPE:
7058         case REFERENCE_TYPE:
7059         case OFFSET_TYPE:
7060           qualifiers |= (1 << shift);
7061           break;
7062
7063         case RECORD_TYPE:
7064           return (qualifiers | 8);
7065
7066         case UNION_TYPE:
7067         case QUAL_UNION_TYPE:
7068           return (qualifiers | 9);
7069
7070         case ENUMERAL_TYPE:
7071           return (qualifiers | 10);
7072
7073         case VOID_TYPE:
7074           return (qualifiers | 16);
7075
7076         case INTEGER_TYPE:
7077           /* If this is a range type, consider it to be the underlying
7078              type.  */
7079           if (TREE_TYPE (type) != 0)
7080             break;
7081
7082           /* Carefully distinguish all the standard types of C,
7083              without messing up if the language is not C.  We do this by
7084              testing TYPE_PRECISION and TREE_UNSIGNED.  The old code used to
7085              look at both the names and the above fields, but that's redundant.
7086              Any type whose size is between two C types will be considered
7087              to be the wider of the two types.  Also, we do not have a
7088              special code to use for "long long", so anything wider than
7089              long is treated the same.  Note that we can't distinguish
7090              between "int" and "long" in this code if they are the same
7091              size, but that's fine, since neither can the assembler.  */
7092
7093           if (TYPE_PRECISION (type) <= CHAR_TYPE_SIZE)
7094             return (qualifiers | (TREE_UNSIGNED (type) ? 12 : 2));
7095
7096           else if (TYPE_PRECISION (type) <= SHORT_TYPE_SIZE)
7097             return (qualifiers | (TREE_UNSIGNED (type) ? 13 : 3));
7098
7099           else if (TYPE_PRECISION (type) <= INT_TYPE_SIZE)
7100             return (qualifiers | (TREE_UNSIGNED (type) ? 14 : 4));
7101
7102           else
7103             return (qualifiers | (TREE_UNSIGNED (type) ? 15 : 5));
7104
7105         case REAL_TYPE:
7106           /* If this is a range type, consider it to be the underlying
7107              type.  */
7108           if (TREE_TYPE (type) != 0)
7109             break;
7110
7111           /* Carefully distinguish all the standard types of C,
7112              without messing up if the language is not C.  */
7113
7114           if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
7115             return (qualifiers | 6);
7116
7117           else
7118             return (qualifiers | 7);
7119
7120         case COMPLEX_TYPE:      /* GNU Fortran COMPLEX type.  */
7121           /* ??? We need to distinguish between double and float complex types,
7122              but I don't know how yet because I can't reach this code from
7123              existing front-ends.  */
7124           return (qualifiers | 7);      /* Who knows? */
7125
7126         case CHAR_TYPE:         /* GNU Pascal CHAR type.  Not used in C.  */
7127         case BOOLEAN_TYPE:      /* GNU Fortran BOOLEAN type.  */
7128         case FILE_TYPE:         /* GNU Pascal FILE type.  */
7129         case SET_TYPE:          /* GNU Pascal SET type.  */
7130         case LANG_TYPE:         /* ? */
7131           return qualifiers;
7132
7133         default:
7134           abort ();             /* Not a type! */
7135         }
7136     }
7137
7138   return qualifiers;
7139 }
7140 \f
7141 /* Nested function support.  */
7142
7143 /* Emit RTL insns to initialize the variable parts of a trampoline.
7144    FNADDR is an RTX for the address of the function's pure code.
7145    CXT is an RTX for the static chain value for the function.
7146
7147    This takes 16 insns: 2 shifts & 2 ands (to split up addresses), 4 sethi
7148    (to load in opcodes), 4 iors (to merge address and opcodes), and 4 writes
7149    (to store insns).  This is a bit excessive.  Perhaps a different
7150    mechanism would be better here.
7151
7152    Emit enough FLUSH insns to synchronize the data and instruction caches.  */
7153
7154 void
7155 sparc_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7156 {
7157   /* SPARC 32-bit trampoline:
7158
7159         sethi   %hi(fn), %g1
7160         sethi   %hi(static), %g2
7161         jmp     %g1+%lo(fn)
7162         or      %g2, %lo(static), %g2
7163
7164     SETHI i,r  = 00rr rrr1 00ii iiii iiii iiii iiii iiii
7165     JMPL r+i,d = 10dd ddd1 1100 0rrr rr1i iiii iiii iiii
7166    */
7167
7168   emit_move_insn
7169     (gen_rtx_MEM (SImode, plus_constant (tramp, 0)),
7170      expand_binop (SImode, ior_optab,
7171                    expand_shift (RSHIFT_EXPR, SImode, fnaddr,
7172                                  size_int (10), 0, 1),
7173                    GEN_INT (trunc_int_for_mode (0x03000000, SImode)),
7174                    NULL_RTX, 1, OPTAB_DIRECT));
7175
7176   emit_move_insn
7177     (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7178      expand_binop (SImode, ior_optab,
7179                    expand_shift (RSHIFT_EXPR, SImode, cxt,
7180                                  size_int (10), 0, 1),
7181                    GEN_INT (trunc_int_for_mode (0x05000000, SImode)),
7182                    NULL_RTX, 1, OPTAB_DIRECT));
7183
7184   emit_move_insn
7185     (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7186      expand_binop (SImode, ior_optab,
7187                    expand_and (SImode, fnaddr, GEN_INT (0x3ff), NULL_RTX),
7188                    GEN_INT (trunc_int_for_mode (0x81c06000, SImode)),
7189                    NULL_RTX, 1, OPTAB_DIRECT));
7190
7191   emit_move_insn
7192     (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7193      expand_binop (SImode, ior_optab,
7194                    expand_and (SImode, cxt, GEN_INT (0x3ff), NULL_RTX),
7195                    GEN_INT (trunc_int_for_mode (0x8410a000, SImode)),
7196                    NULL_RTX, 1, OPTAB_DIRECT));
7197
7198   /* On UltraSPARC a flush flushes an entire cache line.  The trampoline is
7199      aligned on a 16 byte boundary so one flush clears it all.  */
7200   emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode, tramp))));
7201   if (sparc_cpu != PROCESSOR_ULTRASPARC
7202       && sparc_cpu != PROCESSOR_ULTRASPARC3)
7203     emit_insn (gen_flush (validize_mem (gen_rtx_MEM (SImode,
7204                                                      plus_constant (tramp, 8)))));
7205
7206   /* Call __enable_execute_stack after writing onto the stack to make sure
7207      the stack address is accessible.  */
7208 #ifdef TRANSFER_FROM_TRAMPOLINE
7209   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__enable_execute_stack"),
7210                      LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7211 #endif
7212
7213 }
7214
7215 /* The 64-bit version is simpler because it makes more sense to load the
7216    values as "immediate" data out of the trampoline.  It's also easier since
7217    we can read the PC without clobbering a register.  */
7218
7219 void
7220 sparc64_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
7221 {
7222   /* SPARC 64-bit trampoline:
7223
7224         rd      %pc, %g1
7225         ldx     [%g1+24], %g5
7226         jmp     %g5
7227         ldx     [%g1+16], %g5
7228         +16 bytes data
7229    */
7230
7231   emit_move_insn (gen_rtx_MEM (SImode, tramp),
7232                   GEN_INT (trunc_int_for_mode (0x83414000, SImode)));
7233   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 4)),
7234                   GEN_INT (trunc_int_for_mode (0xca586018, SImode)));
7235   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 8)),
7236                   GEN_INT (trunc_int_for_mode (0x81c14000, SImode)));
7237   emit_move_insn (gen_rtx_MEM (SImode, plus_constant (tramp, 12)),
7238                   GEN_INT (trunc_int_for_mode (0xca586010, SImode)));
7239   emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 16)), cxt);
7240   emit_move_insn (gen_rtx_MEM (DImode, plus_constant (tramp, 24)), fnaddr);
7241   emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, tramp))));
7242
7243   if (sparc_cpu != PROCESSOR_ULTRASPARC
7244       && sparc_cpu != PROCESSOR_ULTRASPARC3)
7245     emit_insn (gen_flushdi (validize_mem (gen_rtx_MEM (DImode, plus_constant (tramp, 8)))));
7246
7247   /* Call __enable_execute_stack after writing onto the stack to make sure
7248      the stack address is accessible.  */
7249 #ifdef TRANSFER_FROM_TRAMPOLINE
7250   emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__enable_execute_stack"),
7251                      LCT_NORMAL, VOIDmode, 1, tramp, Pmode);
7252 #endif
7253 }
7254 \f
7255 /* Subroutines to support a flat (single) register window calling
7256    convention.  */
7257
7258 /* Single-register window sparc stack frames look like:
7259
7260              Before call                        After call
7261         +-----------------------+       +-----------------------+
7262    high |                       |       |                       |
7263    mem  |  caller's temps.      |       |  caller's temps.      |
7264         |                       |       |                       |
7265         +-----------------------+       +-----------------------+
7266         |                       |       |                       |
7267         |  arguments on stack.  |       |  arguments on stack.  |
7268         |                       |       |                       |
7269         +-----------------------+FP+92->+-----------------------+
7270         |  6 words to save      |       |  6 words to save      |
7271         |  arguments passed     |       |  arguments passed     |
7272         |  in registers, even   |       |  in registers, even   |
7273         |  if not passed.       |       |  if not passed.       |
7274  SP+68->+-----------------------+FP+68->+-----------------------+
7275         | 1 word struct addr    |       | 1 word struct addr    |
7276         +-----------------------+FP+64->+-----------------------+
7277         |                       |       |                       |
7278         | 16 word reg save area |       | 16 word reg save area |
7279         |                       |       |                       |
7280     SP->+-----------------------+   FP->+-----------------------+
7281                                         | 4 word area for       |
7282                                         | fp/alu reg moves      |
7283                                  FP-16->+-----------------------+
7284                                         |                       |
7285                                         |  local variables      |
7286                                         |                       |
7287                                         +-----------------------+
7288                                         |                       |
7289                                         |  fp register save     |
7290                                         |                       |
7291                                         +-----------------------+
7292                                         |                       |
7293                                         |  gp register save     |
7294                                         |                       |
7295                                         +-----------------------+
7296                                         |                       |
7297                                         |  alloca allocations   |
7298                                         |                       |
7299                                         +-----------------------+
7300                                         |                       |
7301                                         |  arguments on stack   |
7302                                         |                       |
7303                                  SP+92->+-----------------------+
7304                                         |  6 words to save      |
7305                                         |  arguments passed     |
7306                                         |  in registers, even   |
7307    low                                  |  if not passed.       |
7308    memory                        SP+68->+-----------------------+
7309                                         | 1 word struct addr    |
7310                                  SP+64->+-----------------------+
7311                                         |                       |
7312                                         I 16 word reg save area |
7313                                         |                       |
7314                                     SP->+-----------------------+  */
7315
7316 /* Structure to be filled in by sparc_flat_compute_frame_size with register
7317    save masks, and offsets for the current function.  */
7318
7319 struct sparc_frame_info
7320 {
7321   HOST_WIDE_INT total_size;     /* # bytes that the entire frame takes up.  */
7322   HOST_WIDE_INT var_size;       /* # bytes that variables take up.  */
7323   int           args_size;      /* # bytes that outgoing arguments take up.  */
7324   int           extra_size;     /* # bytes of extra gunk.  */
7325   int           gp_reg_size;    /* # bytes needed to store gp regs.  */
7326   int           fp_reg_size;    /* # bytes needed to store fp regs.  */
7327   unsigned long gmask;          /* Mask of saved gp registers.  */
7328   unsigned long fmask;          /* Mask of saved fp registers.  */
7329   int           reg_offset;     /* Offset from new sp to store regs.  */
7330   int           initialized;    /* Nonzero if frame size already calculated.  */
7331 };
7332
7333 /* Current frame information calculated by sparc_flat_compute_frame_size.  */
7334 struct sparc_frame_info current_frame_info;
7335
7336 /* Zero structure to initialize current_frame_info.  */
7337 struct sparc_frame_info zero_frame_info;
7338
7339 #define RETURN_ADDR_REGNUM 15
7340 #define HARD_FRAME_POINTER_MASK (1 << (HARD_FRAME_POINTER_REGNUM))
7341 #define RETURN_ADDR_MASK (1 << (RETURN_ADDR_REGNUM))
7342 \f
7343 /* Tell prologue and epilogue if register REGNO should be saved / restored.  */
7344
7345 static bool
7346 sparc_flat_must_save_register_p (int regno)
7347 {
7348   /* General case: call-saved registers live at some point.  */
7349   if (!call_used_regs[regno] && regs_ever_live[regno])
7350     return true;
7351
7352   /* Frame pointer register (%i7) if needed.  */
7353   if (regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
7354     return true;
7355
7356   /* PIC register (%l7) if needed.  */
7357   if (regno == (int) PIC_OFFSET_TABLE_REGNUM
7358       && flag_pic && current_function_uses_pic_offset_table)
7359     return true;
7360
7361   /* Return address register (%o7) if needed.  */
7362   if (regno == RETURN_ADDR_REGNUM
7363       && (regs_ever_live[RETURN_ADDR_REGNUM]
7364           /* When the PIC offset table is used, the PIC register
7365              is set by using a bare call that clobbers %o7.  */
7366           || (flag_pic && current_function_uses_pic_offset_table)))
7367     return true;
7368
7369   return false;
7370 }
7371 \f
7372 /* Return the bytes needed to compute the frame pointer from the current
7373    stack pointer.  */
7374
7375 HOST_WIDE_INT
7376 sparc_flat_compute_frame_size (HOST_WIDE_INT size)
7377                                 /* # of var. bytes allocated.  */
7378 {
7379   int regno;
7380   HOST_WIDE_INT total_size;     /* # bytes that the entire frame takes up.  */
7381   HOST_WIDE_INT var_size;       /* # bytes that variables take up.  */
7382   int           args_size;      /* # bytes that outgoing arguments take up.  */
7383   int           extra_size;     /* # extra bytes.  */
7384   int           gp_reg_size;    /* # bytes needed to store gp regs.  */
7385   int           fp_reg_size;    /* # bytes needed to store fp regs.  */
7386   unsigned long gmask;          /* Mask of saved gp registers.  */
7387   unsigned long fmask;          /* Mask of saved fp registers.  */
7388   int           reg_offset;     /* Offset to register save area.  */
7389   int           need_aligned_p; /* 1 if need the save area 8 byte aligned.  */
7390
7391   /* This is the size of the 16 word reg save area, 1 word struct addr
7392      area, and 4 word fp/alu register copy area.  */
7393   extra_size = -STARTING_FRAME_OFFSET + FIRST_PARM_OFFSET(0);
7394   var_size = size;
7395   gp_reg_size = 0;
7396   fp_reg_size = 0;
7397   gmask = 0;
7398   fmask = 0;
7399   reg_offset = 0;
7400   need_aligned_p = 0;
7401
7402   args_size = 0;
7403   if (!leaf_function_p ())
7404     {
7405       /* Also include the size needed for the 6 parameter registers.  */
7406       args_size = current_function_outgoing_args_size + 24;
7407     }
7408   total_size = var_size + args_size;
7409
7410   /* Calculate space needed for gp registers.  */
7411   for (regno = 1; regno <= 31; regno++)
7412     {
7413       if (sparc_flat_must_save_register_p (regno))
7414         {
7415           /* If we need to save two regs in a row, ensure there's room to bump
7416              up the address to align it to a doubleword boundary.  */
7417           if ((regno & 0x1) == 0 && sparc_flat_must_save_register_p (regno+1))
7418             {
7419               if (gp_reg_size % 8 != 0)
7420                 gp_reg_size += 4;
7421               gp_reg_size += 2 * UNITS_PER_WORD;
7422               gmask |= 3 << regno;
7423               regno++;
7424               need_aligned_p = 1;
7425             }
7426           else
7427             {
7428               gp_reg_size += UNITS_PER_WORD;
7429               gmask |= 1 << regno;
7430             }
7431         }
7432     }
7433
7434   /* Calculate space needed for fp registers.  */
7435   for (regno = 32; regno <= 63; regno++)
7436     {
7437       if (regs_ever_live[regno] && !call_used_regs[regno])
7438         {
7439           fp_reg_size += UNITS_PER_WORD;
7440           fmask |= 1 << (regno - 32);
7441         }
7442     }
7443
7444   if (gmask || fmask)
7445     {
7446       int n;
7447       reg_offset = FIRST_PARM_OFFSET(0) + args_size;
7448       /* Ensure save area is 8 byte aligned if we need it.  */
7449       n = reg_offset % 8;
7450       if (need_aligned_p && n != 0)
7451         {
7452           total_size += 8 - n;
7453           reg_offset += 8 - n;
7454         }
7455       total_size += gp_reg_size + fp_reg_size;
7456     }
7457
7458   /* If we must allocate a stack frame at all, we must also allocate
7459      room for register window spillage, so as to be binary compatible
7460      with libraries and operating systems that do not use -mflat.  */
7461   if (total_size > 0)
7462     total_size += extra_size;
7463   else
7464     extra_size = 0;
7465
7466   total_size = SPARC_STACK_ALIGN (total_size);
7467
7468   /* Save other computed information.  */
7469   current_frame_info.total_size  = total_size;
7470   current_frame_info.var_size    = var_size;
7471   current_frame_info.args_size   = args_size;
7472   current_frame_info.extra_size  = extra_size;
7473   current_frame_info.gp_reg_size = gp_reg_size;
7474   current_frame_info.fp_reg_size = fp_reg_size;
7475   current_frame_info.gmask       = gmask;
7476   current_frame_info.fmask       = fmask;
7477   current_frame_info.reg_offset  = reg_offset;
7478   current_frame_info.initialized = reload_completed;
7479
7480   /* Ok, we're done.  */
7481   return total_size;
7482 }
7483 \f
7484 /* Save/restore registers in GMASK and FMASK at register BASE_REG plus offset
7485    OFFSET.
7486
7487    BASE_REG must be 8 byte aligned.  This allows us to test OFFSET for
7488    appropriate alignment and use DOUBLEWORD_OP when we can.  We assume
7489    [BASE_REG+OFFSET] will always be a valid address.
7490
7491    WORD_OP is either "st" for save, "ld" for restore.
7492    DOUBLEWORD_OP is either "std" for save, "ldd" for restore.  */
7493
7494 static void
7495 sparc_flat_save_restore (FILE *file, const char *base_reg, int offset,
7496                          unsigned long gmask, unsigned long fmask,
7497                          const char *word_op, const char *doubleword_op,
7498                          HOST_WIDE_INT base_offset)
7499 {
7500   int regno;
7501
7502   if (gmask == 0 && fmask == 0)
7503     return;
7504
7505   /* Save registers starting from high to low.  We've already saved the
7506      previous frame pointer and previous return address for the debugger's
7507      sake.  The debugger allows us to not need a nop in the epilog if at least
7508      one register is reloaded in addition to return address.  */
7509
7510   if (gmask)
7511     {
7512       for (regno = 1; regno <= 31; regno++)
7513         {
7514           if ((gmask & (1L << regno)) != 0)
7515             {
7516               if ((regno & 0x1) == 0 && ((gmask & (1L << (regno+1))) != 0))
7517                 {
7518                   /* We can save two registers in a row.  If we're not at a
7519                      double word boundary, move to one.
7520                      sparc_flat_compute_frame_size ensures there's room to do
7521                      this.  */
7522                   if (offset % 8 != 0)
7523                     offset += UNITS_PER_WORD;
7524
7525                   if (word_op[0] == 's')
7526                     {
7527                       fprintf (file, "\t%s\t%s, [%s+%d]\n",
7528                                doubleword_op, reg_names[regno],
7529                                base_reg, offset);
7530                       if (dwarf2out_do_frame ())
7531                         {
7532                           char *l = dwarf2out_cfi_label ();
7533                           dwarf2out_reg_save (l, regno, offset + base_offset);
7534                           dwarf2out_reg_save
7535                             (l, regno+1, offset+base_offset + UNITS_PER_WORD);
7536                         }
7537                     }
7538                   else
7539                     fprintf (file, "\t%s\t[%s+%d], %s\n",
7540                              doubleword_op, base_reg, offset,
7541                              reg_names[regno]);
7542
7543                   offset += 2 * UNITS_PER_WORD;
7544                   regno++;
7545                 }
7546               else
7547                 {
7548                   if (word_op[0] == 's')
7549                     {
7550                       fprintf (file, "\t%s\t%s, [%s+%d]\n",
7551                                word_op, reg_names[regno],
7552                                base_reg, offset);
7553                       if (dwarf2out_do_frame ())
7554                         dwarf2out_reg_save ("", regno, offset + base_offset);
7555                     }
7556                   else
7557                     fprintf (file, "\t%s\t[%s+%d], %s\n",
7558                              word_op, base_reg, offset, reg_names[regno]);
7559
7560                   offset += UNITS_PER_WORD;
7561                 }
7562             }
7563         }
7564     }
7565
7566   if (fmask)
7567     {
7568       for (regno = 32; regno <= 63; regno++)
7569         {
7570           if ((fmask & (1L << (regno - 32))) != 0)
7571             {
7572               if (word_op[0] == 's')
7573                 {
7574                   fprintf (file, "\t%s\t%s, [%s+%d]\n",
7575                            word_op, reg_names[regno],
7576                            base_reg, offset);
7577                   if (dwarf2out_do_frame ())
7578                     dwarf2out_reg_save ("", regno, offset + base_offset);
7579                 }
7580               else
7581                 fprintf (file, "\t%s\t[%s+%d], %s\n",
7582                          word_op, base_reg, offset, reg_names[regno]);
7583
7584               offset += UNITS_PER_WORD;
7585             }
7586         }
7587     }
7588 }
7589 \f
7590 /* Set up the stack and frame (if desired) for the function.  */
7591
7592 static void
7593 sparc_flat_function_prologue (FILE *file, HOST_WIDE_INT size)
7594 {
7595   const char *sp_str = reg_names[STACK_POINTER_REGNUM];
7596   unsigned long gmask = current_frame_info.gmask;
7597
7598   sparc_output_scratch_registers (file);
7599
7600   /* This is only for the human reader.  */
7601   fprintf (file, "\t%s#PROLOGUE# 0\n", ASM_COMMENT_START);
7602   fprintf (file, "\t%s# vars= "HOST_WIDE_INT_PRINT_DEC", "
7603                  "regs= %d/%d, args= %d, extra= %d\n",
7604            ASM_COMMENT_START,
7605            current_frame_info.var_size,
7606            current_frame_info.gp_reg_size / 4,
7607            current_frame_info.fp_reg_size / 4,
7608            current_function_outgoing_args_size,
7609            current_frame_info.extra_size);
7610
7611   size = SPARC_STACK_ALIGN (size);
7612   size = (! current_frame_info.initialized
7613           ? sparc_flat_compute_frame_size (size)
7614           : current_frame_info.total_size);
7615
7616   /* These cases shouldn't happen.  Catch them now.  */
7617   if (size == 0 && (gmask || current_frame_info.fmask))
7618     abort ();
7619
7620   /* Allocate our stack frame by decrementing %sp.
7621      At present, the only algorithm gdb can use to determine if this is a
7622      flat frame is if we always set %i7 if we set %sp.  This can be optimized
7623      in the future by putting in some sort of debugging information that says
7624      this is a `flat' function.  However, there is still the case of debugging
7625      code without such debugging information (including cases where most fns
7626      have such info, but there is one that doesn't).  So, always do this now
7627      so we don't get a lot of code out there that gdb can't handle.
7628      If the frame pointer isn't needn't then that's ok - gdb won't be able to
7629      distinguish us from a non-flat function but there won't (and shouldn't)
7630      be any differences anyway.  The return pc is saved (if necessary) right
7631      after %i7 so gdb won't have to look too far to find it.  */
7632   if (size > 0)
7633     {
7634       int reg_offset = current_frame_info.reg_offset;
7635       const char *const fp_str = reg_names[HARD_FRAME_POINTER_REGNUM];
7636       static const char *const t1_str = "%g1";
7637
7638       /* Things get a little tricky if local variables take up more than ~4096
7639          bytes and outgoing arguments take up more than ~4096 bytes.  When that
7640          happens, the register save area can't be accessed from either end of
7641          the frame.  Handle this by decrementing %sp to the start of the gp
7642          register save area, save the regs, update %i7, and then set %sp to its
7643          final value.  Given that we only have one scratch register to play
7644          with it is the cheapest solution, and it helps gdb out as it won't
7645          slow down recognition of flat functions.
7646          Don't change the order of insns emitted here without checking with
7647          the gdb folk first.  */
7648
7649       /* Is the entire register save area offsettable from %sp?  */
7650       if (reg_offset < 4096 - 64 * UNITS_PER_WORD)
7651         {
7652           if (size <= 4096)
7653             {
7654               fprintf (file, "\tadd\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s\n",
7655                        sp_str, size, sp_str);
7656               if (gmask & HARD_FRAME_POINTER_MASK)
7657                 {
7658                   fprintf (file, "\tst\t%s, [%s+%d]\n",
7659                            fp_str, sp_str, reg_offset);
7660                   fprintf (file, "\tsub\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s"
7661                                  "\t%s# set up frame pointer\n",
7662                            sp_str, size, fp_str, ASM_COMMENT_START);
7663                   reg_offset += 4;
7664                 }
7665             }
7666           else
7667             {
7668               build_big_number (file, size, t1_str);
7669               fprintf (file, "\tsub\t%s, %s, %s\n", sp_str, t1_str, sp_str);
7670               if (gmask & HARD_FRAME_POINTER_MASK)
7671                 {
7672                   fprintf (file, "\tst\t%s, [%s+%d]\n",
7673                            fp_str, sp_str, reg_offset);
7674                   fprintf (file, "\tadd\t%s, %s, %s\t%s# set up frame pointer\n",
7675                            sp_str, t1_str, fp_str, ASM_COMMENT_START);
7676                   reg_offset += 4;
7677                 }
7678             }
7679           if (dwarf2out_do_frame ())
7680             {
7681               char *l = dwarf2out_cfi_label ();
7682               if (gmask & HARD_FRAME_POINTER_MASK)
7683                 {
7684                   dwarf2out_reg_save (l, HARD_FRAME_POINTER_REGNUM,
7685                                       reg_offset - 4 - size);
7686                   dwarf2out_def_cfa (l, HARD_FRAME_POINTER_REGNUM, 0);
7687                 }
7688               else
7689                 dwarf2out_def_cfa (l, STACK_POINTER_REGNUM, size);
7690             }
7691           if (gmask & RETURN_ADDR_MASK)
7692             {
7693               fprintf (file, "\tst\t%s, [%s+%d]\n",
7694                        reg_names[RETURN_ADDR_REGNUM], sp_str, reg_offset);
7695               if (dwarf2out_do_frame ())
7696                 dwarf2out_return_save ("", reg_offset - size);
7697               reg_offset += 4;
7698             }
7699           sparc_flat_save_restore (file, sp_str, reg_offset,
7700                                    gmask & ~(HARD_FRAME_POINTER_MASK | RETURN_ADDR_MASK),
7701                                    current_frame_info.fmask,
7702                                    "st", "std", -size);
7703         }
7704       else
7705         {
7706           /* Subtract %sp in two steps, but make sure there is always a
7707              64-byte register save area, and %sp is properly aligned.  */
7708
7709           /* Amount to decrement %sp by, the first time.  */
7710           HOST_WIDE_INT size1 = ((size - reg_offset + 64) + 15) & -16;
7711
7712           /* Amount to decrement %sp by, the second time.  */
7713           HOST_WIDE_INT size2 = size - size1;
7714
7715           /* Offset to register save area from %sp after first decrement.  */
7716           int offset = (int)(size1 - (size - reg_offset));
7717
7718           if (size1 <= 4096)
7719             {
7720               fprintf (file, "\tadd\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s\n",
7721                        sp_str, size1, sp_str);
7722               if (gmask & HARD_FRAME_POINTER_MASK)
7723                 {
7724                   fprintf (file, "\tst\t%s, [%s+%d]\n"
7725                                  "\tsub\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s"
7726                                  "\t%s# set up frame pointer\n",
7727                            fp_str, sp_str, offset, sp_str, size1,
7728                            fp_str, ASM_COMMENT_START);
7729                   offset += 4;
7730                 }
7731             }
7732           else
7733             {
7734               build_big_number (file, size1, t1_str);
7735               fprintf (file, "\tsub\t%s, %s, %s\n", sp_str, t1_str, sp_str);
7736               if (gmask & HARD_FRAME_POINTER_MASK)
7737                 {
7738                   fprintf (file, "\tst\t%s, [%s+%d]\n"
7739                                  "\tadd\t%s, %s, %s\t%s# set up frame pointer\n",
7740                            fp_str, sp_str, offset, sp_str, t1_str,
7741                            fp_str, ASM_COMMENT_START);
7742                   offset += 4;
7743                 }
7744             }
7745           if (dwarf2out_do_frame ())
7746             {
7747               char *l = dwarf2out_cfi_label ();
7748               if (gmask & HARD_FRAME_POINTER_MASK)
7749                 {
7750                   dwarf2out_reg_save (l, HARD_FRAME_POINTER_REGNUM,
7751                                       offset - 4 - size1);
7752                   dwarf2out_def_cfa (l, HARD_FRAME_POINTER_REGNUM, 0);
7753                 }
7754               else
7755                 dwarf2out_def_cfa (l, STACK_POINTER_REGNUM, size1);
7756             }
7757           if (gmask & RETURN_ADDR_MASK)
7758             {
7759               fprintf (file, "\tst\t%s, [%s+%d]\n",
7760                        reg_names[RETURN_ADDR_REGNUM], sp_str, offset);
7761               if (dwarf2out_do_frame ())
7762                 /* offset - size1 == reg_offset - size
7763                    if reg_offset were updated above like offset.  */
7764                 dwarf2out_return_save ("", offset - size1);
7765               offset += 4;
7766             }
7767           sparc_flat_save_restore (file, sp_str, offset,
7768                                    gmask & ~(HARD_FRAME_POINTER_MASK | RETURN_ADDR_MASK),
7769                                    current_frame_info.fmask,
7770                                    "st", "std", -size1);
7771           if (size2 <= 4096)
7772             fprintf (file, "\tadd\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s\n",
7773                      sp_str, size2, sp_str);
7774           else
7775             {
7776               build_big_number (file, size2, t1_str);
7777               fprintf (file, "\tsub\t%s, %s, %s\n", sp_str, t1_str, sp_str);
7778             }
7779           if (dwarf2out_do_frame ())
7780             if (! (gmask & HARD_FRAME_POINTER_MASK))
7781               dwarf2out_def_cfa ("", STACK_POINTER_REGNUM, size);
7782         }
7783     }
7784
7785   fprintf (file, "\t%s#PROLOGUE# 1\n", ASM_COMMENT_START);
7786 }
7787 \f
7788 /* Do any necessary cleanup after a function to restore stack, frame,
7789    and regs.  */
7790
7791 static void
7792 sparc_flat_function_epilogue (FILE *file, HOST_WIDE_INT size)
7793 {
7794   rtx epilogue_delay = current_function_epilogue_delay_list;
7795   int noepilogue = FALSE;
7796
7797   /* This is only for the human reader.  */
7798   fprintf (file, "\t%s#EPILOGUE#\n", ASM_COMMENT_START);
7799
7800   /* The epilogue does not depend on any registers, but the stack
7801      registers, so we assume that if we have 1 pending nop, it can be
7802      ignored, and 2 it must be filled (2 nops occur for integer
7803      multiply and divide).  */
7804
7805   size = SPARC_STACK_ALIGN (size);
7806   size = (!current_frame_info.initialized
7807            ? sparc_flat_compute_frame_size (size)
7808            : current_frame_info.total_size);
7809
7810   if (size == 0 && epilogue_delay == 0)
7811     {
7812       rtx insn = get_last_insn ();
7813
7814       /* If the last insn was a BARRIER, we don't have to write any code
7815          because a jump (aka return) was put there.  */
7816       if (GET_CODE (insn) == NOTE)
7817         insn = prev_nonnote_insn (insn);
7818       if (insn && GET_CODE (insn) == BARRIER)
7819         noepilogue = TRUE;
7820     }
7821
7822   if (!noepilogue)
7823     {
7824       int reg_offset = current_frame_info.reg_offset;
7825       int reg_offset1;
7826       const char *const sp_str = reg_names[STACK_POINTER_REGNUM];
7827       const char *const fp_str = reg_names[HARD_FRAME_POINTER_REGNUM];
7828       static const char *const t1_str = "%g1";
7829
7830       /* In the reload sequence, we don't need to fill the load delay
7831          slots for most of the loads, also see if we can fill the final
7832          delay slot if not otherwise filled by the reload sequence.  */
7833
7834       if (size > 4096)
7835         build_big_number (file, size, t1_str);
7836
7837       if (frame_pointer_needed)
7838         {
7839           if (size > 4096)
7840             fprintf (file,"\tsub\t%s, %s, %s\t\t%s# sp not trusted here\n",
7841                      fp_str, t1_str, sp_str, ASM_COMMENT_START);
7842           else
7843             fprintf (file,"\tadd\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s"
7844                           "\t\t%s# sp not trusted here\n",
7845                      fp_str, size, sp_str, ASM_COMMENT_START);
7846         }
7847
7848       /* Is the entire register save area offsettable from %sp?  */
7849       if (reg_offset < 4096 - 64 * UNITS_PER_WORD)
7850         {
7851           reg_offset1 = 0;
7852         }
7853       else
7854         {
7855           /* Restore %sp in two steps, but make sure there is always a
7856              64-byte register save area, and %sp is properly aligned.  */
7857
7858           /* Amount to increment %sp by, the first time.  */
7859           reg_offset1 = ((reg_offset - 64 - 16) + 15) & -16;
7860
7861           /* Offset to register save area from %sp.  */
7862           reg_offset = reg_offset1 - reg_offset;
7863
7864           if (reg_offset1 > 4096)
7865             {
7866               build_big_number (file, reg_offset1, t1_str);
7867               fprintf (file, "\tadd\t%s, %s, %s\n", sp_str, t1_str, sp_str);
7868             }
7869           else
7870             fprintf (file, "\tsub\t%s, -%d, %s\n", sp_str, reg_offset1, sp_str);
7871         }
7872
7873       /* We must restore the frame pointer and return address reg first
7874          because they are treated specially by the prologue output code.  */
7875       if (current_frame_info.gmask & HARD_FRAME_POINTER_MASK)
7876         {
7877           fprintf (file, "\tld\t[%s+%d], %s\n",
7878                    sp_str, reg_offset, fp_str);
7879           reg_offset += 4;
7880         }
7881       if (current_frame_info.gmask & RETURN_ADDR_MASK)
7882         {
7883           fprintf (file, "\tld\t[%s+%d], %s\n",
7884                    sp_str, reg_offset, reg_names[RETURN_ADDR_REGNUM]);
7885           reg_offset += 4;
7886         }
7887
7888       /* Restore any remaining saved registers.  */
7889       sparc_flat_save_restore (file, sp_str, reg_offset,
7890                                current_frame_info.gmask & ~(HARD_FRAME_POINTER_MASK | RETURN_ADDR_MASK),
7891                                current_frame_info.fmask,
7892                                "ld", "ldd", 0);
7893
7894       /* If we had to increment %sp in two steps, record it so the second
7895          restoration in the epilogue finishes up.  */
7896       if (reg_offset1 > 0)
7897         {
7898           size -= reg_offset1;
7899           if (size > 4096)
7900             build_big_number (file, size, t1_str);
7901         }
7902
7903       if (current_function_returns_struct)
7904         fprintf (file, "\tjmp\t%%o7+12\n");
7905       else
7906         fprintf (file, "\tretl\n");
7907
7908       /* If the only register saved is the return address, we need a
7909          nop, unless we have an instruction to put into it.  Otherwise
7910          we don't since reloading multiple registers doesn't reference
7911          the register being loaded.  */
7912
7913       if (epilogue_delay)
7914         {
7915           if (size)
7916             abort ();
7917           final_scan_insn (XEXP (epilogue_delay, 0), file, 1, -2, 1, NULL);
7918         }
7919
7920       else if (size > 4096)
7921         fprintf (file, "\tadd\t%s, %s, %s\n", sp_str, t1_str, sp_str);
7922
7923       else if (size > 0)
7924         fprintf (file, "\tsub\t%s, -"HOST_WIDE_INT_PRINT_DEC", %s\n",
7925                  sp_str, size, sp_str);
7926
7927       else
7928         fprintf (file, "\tnop\n");
7929     }
7930
7931   /* Reset state info for each function.  */
7932   current_frame_info = zero_frame_info;
7933
7934   sparc_output_deferred_case_vectors ();
7935 }
7936 \f
7937 /* Define the number of delay slots needed for the function epilogue.
7938
7939    On the sparc, we need a slot if either no stack has been allocated,
7940    or the only register saved is the return register.  */
7941
7942 int
7943 sparc_flat_epilogue_delay_slots (void)
7944 {
7945   if (!current_frame_info.initialized)
7946     (void) sparc_flat_compute_frame_size (get_frame_size ());
7947
7948   if (current_frame_info.total_size == 0)
7949     return 1;
7950
7951   return 0;
7952 }
7953
7954 /* Return true if TRIAL is a valid insn for the epilogue delay slot.
7955    Any single length instruction which doesn't reference the stack or frame
7956    pointer is OK.  */
7957
7958 int
7959 sparc_flat_eligible_for_epilogue_delay (rtx trial, int slot ATTRIBUTE_UNUSED)
7960 {
7961   rtx pat = PATTERN (trial);
7962
7963   if (get_attr_length (trial) != 1)
7964     return 0;
7965
7966   if (! reg_mentioned_p (stack_pointer_rtx, pat)
7967       && ! reg_mentioned_p (frame_pointer_rtx, pat))
7968     return 1;
7969
7970   return 0;
7971 }
7972 \f
7973 /* Adjust the cost of a scheduling dependency.  Return the new cost of
7974    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
7975
7976 static int
7977 supersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
7978 {
7979   enum attr_type insn_type;
7980
7981   if (! recog_memoized (insn))
7982     return 0;
7983
7984   insn_type = get_attr_type (insn);
7985
7986   if (REG_NOTE_KIND (link) == 0)
7987     {
7988       /* Data dependency; DEP_INSN writes a register that INSN reads some
7989          cycles later.  */
7990
7991       /* if a load, then the dependence must be on the memory address;
7992          add an extra "cycle".  Note that the cost could be two cycles
7993          if the reg was written late in an instruction group; we ca not tell
7994          here.  */
7995       if (insn_type == TYPE_LOAD || insn_type == TYPE_FPLOAD)
7996         return cost + 3;
7997
7998       /* Get the delay only if the address of the store is the dependence.  */
7999       if (insn_type == TYPE_STORE || insn_type == TYPE_FPSTORE)
8000         {
8001           rtx pat = PATTERN(insn);
8002           rtx dep_pat = PATTERN (dep_insn);
8003
8004           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8005             return cost;  /* This should not happen!  */
8006
8007           /* The dependency between the two instructions was on the data that
8008              is being stored.  Assume that this implies that the address of the
8009              store is not dependent.  */
8010           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8011             return cost;
8012
8013           return cost + 3;  /* An approximation.  */
8014         }
8015
8016       /* A shift instruction cannot receive its data from an instruction
8017          in the same cycle; add a one cycle penalty.  */
8018       if (insn_type == TYPE_SHIFT)
8019         return cost + 3;   /* Split before cascade into shift.  */
8020     }
8021   else
8022     {
8023       /* Anti- or output- dependency; DEP_INSN reads/writes a register that
8024          INSN writes some cycles later.  */
8025
8026       /* These are only significant for the fpu unit; writing a fp reg before
8027          the fpu has finished with it stalls the processor.  */
8028
8029       /* Reusing an integer register causes no problems.  */
8030       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8031         return 0;
8032     }
8033
8034   return cost;
8035 }
8036
8037 static int
8038 hypersparc_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
8039 {
8040   enum attr_type insn_type, dep_type;
8041   rtx pat = PATTERN(insn);
8042   rtx dep_pat = PATTERN (dep_insn);
8043
8044   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
8045     return cost;
8046
8047   insn_type = get_attr_type (insn);
8048   dep_type = get_attr_type (dep_insn);
8049
8050   switch (REG_NOTE_KIND (link))
8051     {
8052     case 0:
8053       /* Data dependency; DEP_INSN writes a register that INSN reads some
8054          cycles later.  */
8055
8056       switch (insn_type)
8057         {
8058         case TYPE_STORE:
8059         case TYPE_FPSTORE:
8060           /* Get the delay iff the address of the store is the dependence.  */
8061           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
8062             return cost;
8063
8064           if (rtx_equal_p (SET_DEST (dep_pat), SET_SRC (pat)))
8065             return cost;
8066           return cost + 3;
8067
8068         case TYPE_LOAD:
8069         case TYPE_SLOAD:
8070         case TYPE_FPLOAD:
8071           /* If a load, then the dependence must be on the memory address.  If
8072              the addresses aren't equal, then it might be a false dependency */
8073           if (dep_type == TYPE_STORE || dep_type == TYPE_FPSTORE)
8074             {
8075               if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET
8076                   || GET_CODE (SET_DEST (dep_pat)) != MEM
8077                   || GET_CODE (SET_SRC (pat)) != MEM
8078                   || ! rtx_equal_p (XEXP (SET_DEST (dep_pat), 0),
8079                                     XEXP (SET_SRC (pat), 0)))
8080                 return cost + 2;
8081
8082               return cost + 8;
8083             }
8084           break;
8085
8086         case TYPE_BRANCH:
8087           /* Compare to branch latency is 0.  There is no benefit from
8088              separating compare and branch.  */
8089           if (dep_type == TYPE_COMPARE)
8090             return 0;
8091           /* Floating point compare to branch latency is less than
8092              compare to conditional move.  */
8093           if (dep_type == TYPE_FPCMP)
8094             return cost - 1;
8095           break;
8096         default:
8097           break;
8098         }
8099         break;
8100
8101     case REG_DEP_ANTI:
8102       /* Anti-dependencies only penalize the fpu unit.  */
8103       if (insn_type == TYPE_IALU || insn_type == TYPE_SHIFT)
8104         return 0;
8105       break;
8106
8107     default:
8108       break;
8109     }
8110
8111   return cost;
8112 }
8113
8114 static int
8115 sparc_adjust_cost(rtx insn, rtx link, rtx dep, int cost)
8116 {
8117   switch (sparc_cpu)
8118     {
8119     case PROCESSOR_SUPERSPARC:
8120       cost = supersparc_adjust_cost (insn, link, dep, cost);
8121       break;
8122     case PROCESSOR_HYPERSPARC:
8123     case PROCESSOR_SPARCLITE86X:
8124       cost = hypersparc_adjust_cost (insn, link, dep, cost);
8125       break;
8126     default:
8127       break;
8128     }
8129   return cost;
8130 }
8131
8132 static void
8133 sparc_sched_init (FILE *dump ATTRIBUTE_UNUSED,
8134                   int sched_verbose ATTRIBUTE_UNUSED,
8135                   int max_ready ATTRIBUTE_UNUSED)
8136 {
8137 }
8138
8139 static int
8140 sparc_use_dfa_pipeline_interface (void)
8141 {
8142   if ((1 << sparc_cpu) &
8143       ((1 << PROCESSOR_ULTRASPARC) | (1 << PROCESSOR_CYPRESS) |
8144        (1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
8145        (1 << PROCESSOR_SPARCLITE86X) | (1 << PROCESSOR_TSC701) |
8146        (1 << PROCESSOR_ULTRASPARC3)))
8147     return 1;
8148   return 0;
8149 }
8150
8151 static int
8152 sparc_use_sched_lookahead (void)
8153 {
8154   if (sparc_cpu == PROCESSOR_ULTRASPARC
8155       || sparc_cpu == PROCESSOR_ULTRASPARC3)
8156     return 4;
8157   if ((1 << sparc_cpu) &
8158       ((1 << PROCESSOR_SUPERSPARC) | (1 << PROCESSOR_HYPERSPARC) |
8159        (1 << PROCESSOR_SPARCLITE86X)))
8160     return 3;
8161   return 0;
8162 }
8163
8164 static int
8165 sparc_issue_rate (void)
8166 {
8167   switch (sparc_cpu)
8168     {
8169     default:
8170       return 1;
8171     case PROCESSOR_V9:
8172       /* Assume V9 processors are capable of at least dual-issue.  */
8173       return 2;
8174     case PROCESSOR_SUPERSPARC:
8175       return 3;
8176     case PROCESSOR_HYPERSPARC:
8177     case PROCESSOR_SPARCLITE86X:
8178       return 2;
8179     case PROCESSOR_ULTRASPARC:
8180     case PROCESSOR_ULTRASPARC3:
8181       return 4;
8182     }
8183 }
8184
8185 static int
8186 set_extends (rtx insn)
8187 {
8188   register rtx pat = PATTERN (insn);
8189
8190   switch (GET_CODE (SET_SRC (pat)))
8191     {
8192       /* Load and some shift instructions zero extend.  */
8193     case MEM:
8194     case ZERO_EXTEND:
8195       /* sethi clears the high bits */
8196     case HIGH:
8197       /* LO_SUM is used with sethi.  sethi cleared the high
8198          bits and the values used with lo_sum are positive */
8199     case LO_SUM:
8200       /* Store flag stores 0 or 1 */
8201     case LT: case LTU:
8202     case GT: case GTU:
8203     case LE: case LEU:
8204     case GE: case GEU:
8205     case EQ:
8206     case NE:
8207       return 1;
8208     case AND:
8209       {
8210         rtx op0 = XEXP (SET_SRC (pat), 0);
8211         rtx op1 = XEXP (SET_SRC (pat), 1);
8212         if (GET_CODE (op1) == CONST_INT)
8213           return INTVAL (op1) >= 0;
8214         if (GET_CODE (op0) != REG)
8215           return 0;
8216         if (sparc_check_64 (op0, insn) == 1)
8217           return 1;
8218         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8219       }
8220     case IOR:
8221     case XOR:
8222       {
8223         rtx op0 = XEXP (SET_SRC (pat), 0);
8224         rtx op1 = XEXP (SET_SRC (pat), 1);
8225         if (GET_CODE (op0) != REG || sparc_check_64 (op0, insn) <= 0)
8226           return 0;
8227         if (GET_CODE (op1) == CONST_INT)
8228           return INTVAL (op1) >= 0;
8229         return (GET_CODE (op1) == REG && sparc_check_64 (op1, insn) == 1);
8230       }
8231     case LSHIFTRT:
8232       return GET_MODE (SET_SRC (pat)) == SImode;
8233       /* Positive integers leave the high bits zero.  */
8234     case CONST_DOUBLE:
8235       return ! (CONST_DOUBLE_LOW (SET_SRC (pat)) & 0x80000000);
8236     case CONST_INT:
8237       return ! (INTVAL (SET_SRC (pat)) & 0x80000000);
8238     case ASHIFTRT:
8239     case SIGN_EXTEND:
8240       return - (GET_MODE (SET_SRC (pat)) == SImode);
8241     case REG:
8242       return sparc_check_64 (SET_SRC (pat), insn);
8243     default:
8244       return 0;
8245     }
8246 }
8247
8248 /* We _ought_ to have only one kind per function, but...  */
8249 static GTY(()) rtx sparc_addr_diff_list;
8250 static GTY(()) rtx sparc_addr_list;
8251
8252 void
8253 sparc_defer_case_vector (rtx lab, rtx vec, int diff)
8254 {
8255   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
8256   if (diff)
8257     sparc_addr_diff_list
8258       = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_diff_list);
8259   else
8260     sparc_addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec, sparc_addr_list);
8261 }
8262
8263 static void
8264 sparc_output_addr_vec (rtx vec)
8265 {
8266   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8267   int idx, vlen = XVECLEN (body, 0);
8268
8269 #ifdef ASM_OUTPUT_ADDR_VEC_START
8270   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8271 #endif
8272
8273 #ifdef ASM_OUTPUT_CASE_LABEL
8274   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8275                          NEXT_INSN (lab));
8276 #else
8277   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8278 #endif
8279
8280   for (idx = 0; idx < vlen; idx++)
8281     {
8282       ASM_OUTPUT_ADDR_VEC_ELT
8283         (asm_out_file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
8284     }
8285
8286 #ifdef ASM_OUTPUT_ADDR_VEC_END
8287   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8288 #endif
8289 }
8290
8291 static void
8292 sparc_output_addr_diff_vec (rtx vec)
8293 {
8294   rtx lab = XEXP (vec, 0), body = XEXP (vec, 1);
8295   rtx base = XEXP (XEXP (body, 0), 0);
8296   int idx, vlen = XVECLEN (body, 1);
8297
8298 #ifdef ASM_OUTPUT_ADDR_VEC_START
8299   ASM_OUTPUT_ADDR_VEC_START (asm_out_file);
8300 #endif
8301
8302 #ifdef ASM_OUTPUT_CASE_LABEL
8303   ASM_OUTPUT_CASE_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (lab),
8304                          NEXT_INSN (lab));
8305 #else
8306   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (lab));
8307 #endif
8308
8309   for (idx = 0; idx < vlen; idx++)
8310     {
8311       ASM_OUTPUT_ADDR_DIFF_ELT
8312         (asm_out_file,
8313          body,
8314          CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
8315          CODE_LABEL_NUMBER (base));
8316     }
8317
8318 #ifdef ASM_OUTPUT_ADDR_VEC_END
8319   ASM_OUTPUT_ADDR_VEC_END (asm_out_file);
8320 #endif
8321 }
8322
8323 static void
8324 sparc_output_deferred_case_vectors (void)
8325 {
8326   rtx t;
8327   int align;
8328
8329   if (sparc_addr_list == NULL_RTX
8330       && sparc_addr_diff_list == NULL_RTX)
8331     return;
8332
8333   /* Align to cache line in the function's code section.  */
8334   function_section (current_function_decl);
8335
8336   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
8337   if (align > 0)
8338     ASM_OUTPUT_ALIGN (asm_out_file, align);
8339
8340   for (t = sparc_addr_list; t ; t = XEXP (t, 1))
8341     sparc_output_addr_vec (XEXP (t, 0));
8342   for (t = sparc_addr_diff_list; t ; t = XEXP (t, 1))
8343     sparc_output_addr_diff_vec (XEXP (t, 0));
8344
8345   sparc_addr_list = sparc_addr_diff_list = NULL_RTX;
8346 }
8347
8348 /* Return 0 if the high 32 bits of X (the low word of X, if DImode) are
8349    unknown.  Return 1 if the high bits are zero, -1 if the register is
8350    sign extended.  */
8351 int
8352 sparc_check_64 (rtx x, rtx insn)
8353 {
8354   /* If a register is set only once it is safe to ignore insns this
8355      code does not know how to handle.  The loop will either recognize
8356      the single set and return the correct value or fail to recognize
8357      it and return 0.  */
8358   int set_once = 0;
8359   rtx y = x;
8360
8361   if (GET_CODE (x) != REG)
8362     abort ();
8363
8364   if (GET_MODE (x) == DImode)
8365     y = gen_rtx_REG (SImode, REGNO (x) + WORDS_BIG_ENDIAN);
8366
8367   if (flag_expensive_optimizations
8368       && REG_N_SETS (REGNO (y)) == 1)
8369     set_once = 1;
8370
8371   if (insn == 0)
8372     {
8373       if (set_once)
8374         insn = get_last_insn_anywhere ();
8375       else
8376         return 0;
8377     }
8378
8379   while ((insn = PREV_INSN (insn)))
8380     {
8381       switch (GET_CODE (insn))
8382         {
8383         case JUMP_INSN:
8384         case NOTE:
8385           break;
8386         case CODE_LABEL:
8387         case CALL_INSN:
8388         default:
8389           if (! set_once)
8390             return 0;
8391           break;
8392         case INSN:
8393           {
8394             rtx pat = PATTERN (insn);
8395             if (GET_CODE (pat) != SET)
8396               return 0;
8397             if (rtx_equal_p (x, SET_DEST (pat)))
8398               return set_extends (insn);
8399             if (y && rtx_equal_p (y, SET_DEST (pat)))
8400               return set_extends (insn);
8401             if (reg_overlap_mentioned_p (SET_DEST (pat), y))
8402               return 0;
8403           }
8404         }
8405     }
8406   return 0;
8407 }
8408
8409 /* Returns assembly code to perform a DImode shift using
8410    a 64-bit global or out register on SPARC-V8+.  */
8411 char *
8412 sparc_v8plus_shift (rtx *operands, rtx insn, const char *opcode)
8413 {
8414   static char asm_code[60];
8415
8416   /* The scratch register is only required when the destination
8417      register is not a 64-bit global or out register.  */
8418   if (which_alternative != 2)
8419     operands[3] = operands[0];
8420
8421   /* We can only shift by constants <= 63. */
8422   if (GET_CODE (operands[2]) == CONST_INT)
8423     operands[2] = GEN_INT (INTVAL (operands[2]) & 0x3f);
8424
8425   if (GET_CODE (operands[1]) == CONST_INT)
8426     {
8427       output_asm_insn ("mov\t%1, %3", operands);
8428     }
8429   else
8430     {
8431       output_asm_insn ("sllx\t%H1, 32, %3", operands);
8432       if (sparc_check_64 (operands[1], insn) <= 0)
8433         output_asm_insn ("srl\t%L1, 0, %L1", operands);
8434       output_asm_insn ("or\t%L1, %3, %3", operands);
8435     }
8436
8437   strcpy(asm_code, opcode);
8438
8439   if (which_alternative != 2)
8440     return strcat (asm_code, "\t%0, %2, %L0\n\tsrlx\t%L0, 32, %H0");
8441   else
8442     return strcat (asm_code, "\t%3, %2, %3\n\tsrlx\t%3, 32, %H0\n\tmov\t%3, %L0");
8443 }
8444 \f
8445 /* Output rtl to increment the profiler label LABELNO
8446    for profiling a function entry.  */
8447
8448 void
8449 sparc_profile_hook (int labelno)
8450 {
8451   char buf[32];
8452   rtx lab, fun;
8453
8454   ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
8455   lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
8456   fun = gen_rtx_SYMBOL_REF (Pmode, MCOUNT_FUNCTION);
8457
8458   emit_library_call (fun, LCT_NORMAL, VOIDmode, 1, lab, Pmode);
8459 }
8460 \f
8461 #ifdef OBJECT_FORMAT_ELF
8462 static void
8463 sparc_elf_asm_named_section (const char *name, unsigned int flags)
8464 {
8465   if (flags & SECTION_MERGE)
8466     {
8467       /* entsize cannot be expressed in this section attributes
8468          encoding style.  */
8469       default_elf_asm_named_section (name, flags);
8470       return;
8471     }
8472
8473   fprintf (asm_out_file, "\t.section\t\"%s\"", name);
8474
8475   if (!(flags & SECTION_DEBUG))
8476     fputs (",#alloc", asm_out_file);
8477   if (flags & SECTION_WRITE)
8478     fputs (",#write", asm_out_file);
8479   if (flags & SECTION_TLS)
8480     fputs (",#tls", asm_out_file);
8481   if (flags & SECTION_CODE)
8482     fputs (",#execinstr", asm_out_file);
8483
8484   /* ??? Handle SECTION_BSS.  */
8485
8486   fputc ('\n', asm_out_file);
8487 }
8488 #endif /* OBJECT_FORMAT_ELF */
8489
8490 /* We do not allow sibling calls if -mflat, nor
8491    we do not allow indirect calls to be optimized into sibling calls.
8492
8493    Also, on sparc 32-bit we cannot emit a sibling call when the
8494    current function returns a structure.  This is because the "unimp
8495    after call" convention would cause the callee to return to the
8496    wrong place.  The generic code already disallows cases where the
8497    function being called returns a structure.
8498
8499    It may seem strange how this last case could occur.  Usually there
8500    is code after the call which jumps to epilogue code which dumps the
8501    return value into the struct return area.  That ought to invalidate
8502    the sibling call right?  Well, in the c++ case we can end up passing
8503    the pointer to the struct return area to a constructor (which returns
8504    void) and then nothing else happens.  Such a sibling call would look
8505    valid without the added check here.  */
8506 static bool
8507 sparc_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
8508 {
8509   return (decl
8510           && ! TARGET_FLAT
8511           && (TARGET_ARCH64 || ! current_function_returns_struct));
8512 }
8513 \f
8514 /* libfunc renaming.  */
8515 #include "config/gofast.h"
8516
8517 static void
8518 sparc_init_libfuncs (void)
8519 {
8520   if (TARGET_ARCH32)
8521     {
8522       /* Use the subroutines that Sun's library provides for integer
8523          multiply and divide.  The `*' prevents an underscore from
8524          being prepended by the compiler. .umul is a little faster
8525          than .mul. */
8526       set_optab_libfunc (smul_optab, SImode, "*.umul");
8527       set_optab_libfunc (sdiv_optab, SImode, "*.div");
8528       set_optab_libfunc (udiv_optab, SImode, "*.udiv");
8529       set_optab_libfunc (smod_optab, SImode, "*.rem");
8530       set_optab_libfunc (umod_optab, SImode, "*.urem");
8531
8532       /* TFmode arithmetic.  These names are part of the SPARC 32bit ABI.  */
8533       set_optab_libfunc (add_optab, TFmode, "_Q_add");
8534       set_optab_libfunc (sub_optab, TFmode, "_Q_sub");
8535       set_optab_libfunc (neg_optab, TFmode, "_Q_neg");
8536       set_optab_libfunc (smul_optab, TFmode, "_Q_mul");
8537       set_optab_libfunc (sdiv_optab, TFmode, "_Q_div");
8538
8539       /* We can define the TFmode sqrt optab only if TARGET_FPU.  This
8540          is because with soft-float, the SFmode and DFmode sqrt
8541          instructions will be absent, and the compiler will notice and
8542          try to use the TFmode sqrt instruction for calls to the
8543          builtin function sqrt, but this fails.  */
8544       if (TARGET_FPU)
8545         set_optab_libfunc (sqrt_optab, TFmode, "_Q_sqrt");
8546
8547       set_optab_libfunc (eq_optab, TFmode, "_Q_feq");
8548       set_optab_libfunc (ne_optab, TFmode, "_Q_fne");
8549       set_optab_libfunc (gt_optab, TFmode, "_Q_fgt");
8550       set_optab_libfunc (ge_optab, TFmode, "_Q_fge");
8551       set_optab_libfunc (lt_optab, TFmode, "_Q_flt");
8552       set_optab_libfunc (le_optab, TFmode, "_Q_fle");
8553
8554       set_conv_libfunc (sext_optab,   TFmode, SFmode, "_Q_stoq");
8555       set_conv_libfunc (sext_optab,   TFmode, DFmode, "_Q_dtoq");
8556       set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_Q_qtos");
8557       set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_Q_qtod");
8558
8559       set_conv_libfunc (sfix_optab,   SImode, TFmode, "_Q_qtoi");
8560       set_conv_libfunc (ufix_optab,   SImode, TFmode, "_Q_qtou");
8561       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_Q_itoq");
8562
8563       if (SUN_CONVERSION_LIBFUNCS)
8564         {
8565           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftoll");
8566           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoull");
8567           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtoll");
8568           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoull");
8569         }
8570     }
8571   if (TARGET_ARCH64)
8572     {
8573       /* In the SPARC 64bit ABI, SImode multiply and divide functions
8574          do not exist in the library.  Make sure the compiler does not
8575          emit calls to them by accident.  (It should always use the
8576          hardware instructions.)  */
8577       set_optab_libfunc (smul_optab, SImode, 0);
8578       set_optab_libfunc (sdiv_optab, SImode, 0);
8579       set_optab_libfunc (udiv_optab, SImode, 0);
8580       set_optab_libfunc (smod_optab, SImode, 0);
8581       set_optab_libfunc (umod_optab, SImode, 0);
8582
8583       if (SUN_INTEGER_MULTIPLY_64)
8584         {
8585           set_optab_libfunc (smul_optab, DImode, "__mul64");
8586           set_optab_libfunc (sdiv_optab, DImode, "__div64");
8587           set_optab_libfunc (udiv_optab, DImode, "__udiv64");
8588           set_optab_libfunc (smod_optab, DImode, "__rem64");
8589           set_optab_libfunc (umod_optab, DImode, "__urem64");
8590         }
8591
8592       if (SUN_CONVERSION_LIBFUNCS)
8593         {
8594           set_conv_libfunc (sfix_optab, DImode, SFmode, "__ftol");
8595           set_conv_libfunc (ufix_optab, DImode, SFmode, "__ftoul");
8596           set_conv_libfunc (sfix_optab, DImode, DFmode, "__dtol");
8597           set_conv_libfunc (ufix_optab, DImode, DFmode, "__dtoul");
8598         }
8599     }
8600
8601   gofast_maybe_init_libfuncs ();
8602 }
8603 \f
8604 /* ??? Similar to the standard section selection, but force reloc-y-ness
8605    if SUNOS4_SHARED_LIBRARIES.  Unclear why this helps (as opposed to
8606    pretending PIC always on), but that's what the old code did.  */
8607
8608 static void
8609 sparc_aout_select_section (tree t, int reloc, unsigned HOST_WIDE_INT align)
8610 {
8611   default_select_section (t, reloc | SUNOS4_SHARED_LIBRARIES, align);
8612 }
8613
8614 /* Use text section for a constant unless we need more alignment than
8615    that offers.  */
8616
8617 static void
8618 sparc_aout_select_rtx_section (enum machine_mode mode, rtx x,
8619                                unsigned HOST_WIDE_INT align)
8620 {
8621   if (align <= MAX_TEXT_ALIGN
8622       && ! (flag_pic && (symbolic_operand (x, mode)
8623                          || SUNOS4_SHARED_LIBRARIES)))
8624     readonly_data_section ();
8625   else
8626     data_section ();
8627 }
8628
8629 int
8630 sparc_extra_constraint_check (rtx op, int c, int strict)
8631 {
8632   int reload_ok_mem;
8633
8634   if (TARGET_ARCH64
8635       && (c == 'T' || c == 'U'))
8636     return 0;
8637
8638   switch (c)
8639     {
8640     case 'Q':
8641       return fp_sethi_p (op);
8642
8643     case 'R':
8644       return fp_mov_p (op);
8645
8646     case 'S':
8647       return fp_high_losum_p (op);
8648
8649     case 'U':
8650       if (! strict
8651           || (GET_CODE (op) == REG
8652               && (REGNO (op) < FIRST_PSEUDO_REGISTER
8653                   || reg_renumber[REGNO (op)] >= 0)))
8654         return register_ok_for_ldd (op);
8655
8656       return 0;
8657
8658     case 'W':
8659     case 'T':
8660       break;
8661
8662     default:
8663       return 0;
8664     }
8665
8666   /* Our memory extra constraints have to emulate the
8667      behavior of 'm' and 'o' in order for reload to work
8668      correctly.  */
8669   if (GET_CODE (op) == MEM)
8670     {
8671       reload_ok_mem = 0;
8672       if ((TARGET_ARCH64 || mem_min_alignment (op, 8))
8673           && (! strict
8674               || strict_memory_address_p (Pmode, XEXP (op, 0))))
8675         reload_ok_mem = 1;
8676     }
8677   else
8678     {
8679       reload_ok_mem = (reload_in_progress
8680                        && GET_CODE (op) == REG
8681                        && REGNO (op) >= FIRST_PSEUDO_REGISTER
8682                        && reg_renumber [REGNO (op)] < 0);
8683     }
8684
8685   return reload_ok_mem;
8686 }
8687
8688 /* ??? This duplicates information provided to the compiler by the
8689    ??? scheduler description.  Some day, teach genautomata to output
8690    ??? the latencies and then CSE will just use that.  */
8691
8692 static bool
8693 sparc_rtx_costs (rtx x, int code, int outer_code, int *total)
8694 {
8695   switch (code)
8696     {
8697     case PLUS: case MINUS: case ABS: case NEG:
8698     case FLOAT: case UNSIGNED_FLOAT:
8699     case FIX: case UNSIGNED_FIX:
8700     case FLOAT_EXTEND: case FLOAT_TRUNCATE:
8701       if (FLOAT_MODE_P (GET_MODE (x)))
8702         {
8703           switch (sparc_cpu)
8704             {
8705             case PROCESSOR_ULTRASPARC:
8706             case PROCESSOR_ULTRASPARC3:
8707               *total = COSTS_N_INSNS (4);
8708               return true;
8709
8710             case PROCESSOR_SUPERSPARC:
8711               *total = COSTS_N_INSNS (3);
8712               return true;
8713
8714             case PROCESSOR_CYPRESS:
8715               *total = COSTS_N_INSNS (5);
8716               return true;
8717
8718             case PROCESSOR_HYPERSPARC:
8719             case PROCESSOR_SPARCLITE86X:
8720             default:
8721               *total = COSTS_N_INSNS (1);
8722               return true;
8723             }
8724         }
8725
8726       *total = COSTS_N_INSNS (1);
8727       return true;
8728
8729     case SQRT:
8730       switch (sparc_cpu)
8731         {
8732         case PROCESSOR_ULTRASPARC:
8733           if (GET_MODE (x) == SFmode)
8734             *total = COSTS_N_INSNS (13);
8735           else
8736             *total = COSTS_N_INSNS (23);
8737           return true;
8738
8739         case PROCESSOR_ULTRASPARC3:
8740           if (GET_MODE (x) == SFmode)
8741             *total = COSTS_N_INSNS (20);
8742           else
8743             *total = COSTS_N_INSNS (29);
8744           return true;
8745
8746         case PROCESSOR_SUPERSPARC:
8747           *total = COSTS_N_INSNS (12);
8748           return true;
8749
8750         case PROCESSOR_CYPRESS:
8751           *total = COSTS_N_INSNS (63);
8752           return true;
8753
8754         case PROCESSOR_HYPERSPARC:
8755         case PROCESSOR_SPARCLITE86X:
8756           *total = COSTS_N_INSNS (17);
8757           return true;
8758
8759         default:
8760           *total = COSTS_N_INSNS (30);
8761           return true;
8762         }
8763
8764     case COMPARE:
8765       if (FLOAT_MODE_P (GET_MODE (x)))
8766         {
8767           switch (sparc_cpu)
8768             {
8769             case PROCESSOR_ULTRASPARC:
8770             case PROCESSOR_ULTRASPARC3:
8771               *total = COSTS_N_INSNS (1);
8772               return true;
8773
8774             case PROCESSOR_SUPERSPARC:
8775               *total = COSTS_N_INSNS (3);
8776               return true;
8777
8778             case PROCESSOR_CYPRESS:
8779               *total = COSTS_N_INSNS (5);
8780               return true;
8781
8782             case PROCESSOR_HYPERSPARC:
8783             case PROCESSOR_SPARCLITE86X:
8784             default:
8785               *total = COSTS_N_INSNS (1);
8786               return true;
8787             }
8788         }
8789
8790       /* ??? Maybe mark integer compares as zero cost on
8791          ??? all UltraSPARC processors because the result
8792          ??? can be bypassed to a branch in the same group.  */
8793
8794       *total = COSTS_N_INSNS (1);
8795       return true;
8796
8797     case MULT:
8798       if (FLOAT_MODE_P (GET_MODE (x)))
8799         {
8800           switch (sparc_cpu)
8801             {
8802             case PROCESSOR_ULTRASPARC:
8803             case PROCESSOR_ULTRASPARC3:
8804               *total = COSTS_N_INSNS (4);
8805               return true;
8806
8807             case PROCESSOR_SUPERSPARC:
8808               *total = COSTS_N_INSNS (3);
8809               return true;
8810
8811             case PROCESSOR_CYPRESS:
8812               *total = COSTS_N_INSNS (7);
8813               return true;
8814
8815             case PROCESSOR_HYPERSPARC:
8816             case PROCESSOR_SPARCLITE86X:
8817               *total = COSTS_N_INSNS (1);
8818               return true;
8819
8820             default:
8821               *total = COSTS_N_INSNS (5);
8822               return true;
8823             }
8824         }
8825
8826       /* The latency is actually variable for Ultra-I/II
8827          And if one of the inputs have a known constant
8828          value, we could calculate this precisely.
8829
8830          However, for that to be useful we would need to
8831          add some machine description changes which would
8832          make sure small constants ended up in rs1 of the
8833          multiply instruction.  This is because the multiply
8834          latency is determined by the number of clear (or
8835          set if the value is negative) bits starting from
8836          the most significant bit of the first input.
8837
8838          The algorithm for computing num_cycles of a multiply
8839          on Ultra-I/II is:
8840
8841                 if (rs1 < 0)
8842                         highest_bit = highest_clear_bit(rs1);
8843                 else
8844                         highest_bit = highest_set_bit(rs1);
8845                 if (num_bits < 3)
8846                         highest_bit = 3;
8847                 num_cycles = 4 + ((highest_bit - 3) / 2);
8848
8849          If we did that we would have to also consider register
8850          allocation issues that would result from forcing such
8851          a value into a register.
8852
8853          There are other similar tricks we could play if we
8854          knew, for example, that one input was an array index.
8855
8856          Since we do not play any such tricks currently the
8857          safest thing to do is report the worst case latency.  */
8858       if (sparc_cpu == PROCESSOR_ULTRASPARC)
8859         {
8860           *total = (GET_MODE (x) == DImode
8861                     ? COSTS_N_INSNS (34) : COSTS_N_INSNS (19));
8862           return true;
8863         }
8864
8865       /* Multiply latency on Ultra-III, fortunately, is constant.  */
8866       if (sparc_cpu == PROCESSOR_ULTRASPARC3)
8867         {
8868           *total = COSTS_N_INSNS (6);
8869           return true;
8870         }
8871
8872       if (sparc_cpu == PROCESSOR_HYPERSPARC
8873           || sparc_cpu == PROCESSOR_SPARCLITE86X)
8874         {
8875           *total = COSTS_N_INSNS (17);
8876           return true;
8877         }
8878
8879       *total = (TARGET_HARD_MUL ? COSTS_N_INSNS (5) : COSTS_N_INSNS (25));
8880       return true;
8881
8882     case DIV:
8883     case UDIV:
8884     case MOD:
8885     case UMOD:
8886       if (FLOAT_MODE_P (GET_MODE (x)))
8887         {
8888           switch (sparc_cpu)
8889             {
8890             case PROCESSOR_ULTRASPARC:
8891               if (GET_MODE (x) == SFmode)
8892                 *total = COSTS_N_INSNS (13);
8893               else
8894                 *total = COSTS_N_INSNS (23);
8895               return true;
8896
8897             case PROCESSOR_ULTRASPARC3:
8898               if (GET_MODE (x) == SFmode)
8899                 *total = COSTS_N_INSNS (17);
8900               else
8901                 *total = COSTS_N_INSNS (20);
8902               return true;
8903
8904             case PROCESSOR_SUPERSPARC:
8905               if (GET_MODE (x) == SFmode)
8906                 *total = COSTS_N_INSNS (6);
8907               else
8908                 *total = COSTS_N_INSNS (9);
8909               return true;
8910
8911             case PROCESSOR_HYPERSPARC:
8912             case PROCESSOR_SPARCLITE86X:
8913               if (GET_MODE (x) == SFmode)
8914                 *total = COSTS_N_INSNS (8);
8915               else
8916                 *total = COSTS_N_INSNS (12);
8917               return true;
8918
8919             default:
8920               *total = COSTS_N_INSNS (7);
8921               return true;
8922             }
8923         }
8924
8925       if (sparc_cpu == PROCESSOR_ULTRASPARC)
8926         *total = (GET_MODE (x) == DImode
8927                   ? COSTS_N_INSNS (68) : COSTS_N_INSNS (37));
8928       else if (sparc_cpu == PROCESSOR_ULTRASPARC3)
8929         *total = (GET_MODE (x) == DImode
8930                   ? COSTS_N_INSNS (71) : COSTS_N_INSNS (40));
8931       else
8932         *total = COSTS_N_INSNS (25);
8933       return true;
8934
8935     case IF_THEN_ELSE:
8936       /* Conditional moves. */
8937       switch (sparc_cpu)
8938         {
8939         case PROCESSOR_ULTRASPARC:
8940           *total = COSTS_N_INSNS (2);
8941           return true;
8942
8943         case PROCESSOR_ULTRASPARC3:
8944           if (FLOAT_MODE_P (GET_MODE (x)))
8945             *total = COSTS_N_INSNS (3);
8946           else
8947             *total = COSTS_N_INSNS (2);
8948           return true;
8949
8950         default:
8951           *total = COSTS_N_INSNS (1);
8952           return true;
8953         }
8954
8955     case MEM:
8956       /* If outer-code is SIGN/ZERO extension we have to subtract
8957          out COSTS_N_INSNS (1) from whatever we return in determining
8958          the cost.  */
8959       switch (sparc_cpu)
8960         {
8961         case PROCESSOR_ULTRASPARC:
8962           if (outer_code == ZERO_EXTEND)
8963             *total = COSTS_N_INSNS (1);
8964           else
8965             *total = COSTS_N_INSNS (2);
8966           return true;
8967
8968         case PROCESSOR_ULTRASPARC3:
8969           if (outer_code == ZERO_EXTEND)
8970             {
8971               if (GET_MODE (x) == QImode
8972                   || GET_MODE (x) == HImode
8973                   || outer_code == SIGN_EXTEND)
8974                 *total = COSTS_N_INSNS (2);
8975               else
8976                 *total = COSTS_N_INSNS (1);
8977             }
8978           else
8979             {
8980               /* This handles sign extension (3 cycles)
8981                  and everything else (2 cycles).  */
8982               *total = COSTS_N_INSNS (2);
8983             }
8984           return true;
8985
8986         case PROCESSOR_SUPERSPARC:
8987           if (FLOAT_MODE_P (GET_MODE (x))
8988               || outer_code == ZERO_EXTEND
8989               || outer_code == SIGN_EXTEND)
8990             *total = COSTS_N_INSNS (0);
8991           else
8992             *total = COSTS_N_INSNS (1);
8993           return true;
8994
8995         case PROCESSOR_TSC701:
8996           if (outer_code == ZERO_EXTEND
8997               || outer_code == SIGN_EXTEND)
8998             *total = COSTS_N_INSNS (2);
8999           else
9000             *total = COSTS_N_INSNS (3);
9001           return true;
9002
9003         case PROCESSOR_CYPRESS:
9004           if (outer_code == ZERO_EXTEND
9005               || outer_code == SIGN_EXTEND)
9006             *total = COSTS_N_INSNS (1);
9007           else
9008             *total = COSTS_N_INSNS (2);
9009           return true;
9010
9011         case PROCESSOR_HYPERSPARC:
9012         case PROCESSOR_SPARCLITE86X:
9013         default:
9014           if (outer_code == ZERO_EXTEND
9015               || outer_code == SIGN_EXTEND)
9016             *total = COSTS_N_INSNS (0);
9017           else
9018             *total = COSTS_N_INSNS (1);
9019           return true;
9020         }
9021
9022     case CONST_INT:
9023       if (INTVAL (x) < 0x1000 && INTVAL (x) >= -0x1000)
9024         {
9025           *total = 0;
9026           return true;
9027         }
9028       /* FALLTHRU */
9029
9030     case HIGH:
9031       *total = 2;
9032       return true;
9033
9034     case CONST:
9035     case LABEL_REF:
9036     case SYMBOL_REF:
9037       *total = 4;
9038       return true;
9039
9040     case CONST_DOUBLE:
9041       if (GET_MODE (x) == DImode
9042           && ((XINT (x, 3) == 0
9043                && (unsigned HOST_WIDE_INT) XINT (x, 2) < 0x1000)
9044               || (XINT (x, 3) == -1
9045                   && XINT (x, 2) < 0
9046                   && XINT (x, 2) >= -0x1000)))
9047         *total = 0;
9048       else
9049         *total = 8;
9050       return true;
9051
9052     default:
9053       return false;
9054     }
9055 }
9056
9057 /* Output code to add DELTA to the first argument, and then jump to FUNCTION.
9058    Used for C++ multiple inheritance.  */
9059
9060 static void
9061 sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
9062                        HOST_WIDE_INT delta,
9063                        HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
9064                        tree function)
9065 {
9066   rtx this, insn, funexp, delta_rtx, tmp;
9067
9068   reload_completed = 1;
9069   epilogue_completed = 1;
9070   no_new_pseudos = 1;
9071   current_function_uses_only_leaf_regs = 1;
9072
9073   emit_note (NOTE_INSN_PROLOGUE_END);
9074
9075   /* Find the "this" pointer.  Normally in %o0, but in ARCH64 if the function
9076      returns a structure, the structure return pointer is there instead.  */
9077   if (TARGET_ARCH64 && aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
9078     this = gen_rtx_REG (Pmode, SPARC_INCOMING_INT_ARG_FIRST + 1);
9079   else
9080     this = gen_rtx_REG (Pmode, SPARC_INCOMING_INT_ARG_FIRST);
9081
9082   /* Add DELTA.  When possible use a plain add, otherwise load it into
9083      a register first.  */
9084   delta_rtx = GEN_INT (delta);
9085   if (!SPARC_SIMM13_P (delta))
9086     {
9087       rtx scratch = gen_rtx_REG (Pmode, 1);
9088
9089       if (input_operand (delta_rtx, GET_MODE (scratch)))
9090         emit_insn (gen_rtx_SET (VOIDmode, scratch, delta_rtx));
9091       else
9092         {
9093           if (TARGET_ARCH64)
9094             sparc_emit_set_const64 (scratch, delta_rtx);
9095           else
9096             sparc_emit_set_const32 (scratch, delta_rtx);
9097         }
9098
9099       delta_rtx = scratch;
9100     }
9101
9102   tmp = gen_rtx_PLUS (Pmode, this, delta_rtx);
9103   emit_insn (gen_rtx_SET (VOIDmode, this, tmp));
9104
9105   /* Generate a tail call to the target function.  */
9106   if (! TREE_USED (function))
9107     {
9108       assemble_external (function);
9109       TREE_USED (function) = 1;
9110     }
9111   funexp = XEXP (DECL_RTL (function), 0);
9112   funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
9113   insn = emit_call_insn (gen_sibcall (funexp));
9114   SIBLING_CALL_P (insn) = 1;
9115   emit_barrier ();
9116
9117   /* Run just enough of rest_of_compilation to get the insns emitted.
9118      There's not really enough bulk here to make other passes such as
9119      instruction scheduling worth while.  Note that use_thunk calls
9120      assemble_start_function and assemble_end_function.  */
9121   insn = get_insns ();
9122   insn_locators_initialize ();
9123   shorten_branches (insn);
9124   final_start_function (insn, file, 1);
9125   final (insn, file, 1, 0);
9126   final_end_function ();
9127
9128   reload_completed = 0;
9129   epilogue_completed = 0;
9130   no_new_pseudos = 0;
9131 }
9132
9133 /* How to allocate a 'struct machine_function'.  */
9134
9135 static struct machine_function *
9136 sparc_init_machine_status (void)
9137 {
9138   return ggc_alloc_cleared (sizeof (struct machine_function));
9139 }
9140
9141 /* Locate some local-dynamic symbol still in use by this function
9142    so that we can print its name in local-dynamic base patterns.  */
9143
9144 static const char *
9145 get_some_local_dynamic_name (void)
9146 {
9147   rtx insn;
9148
9149   if (cfun->machine->some_ld_name)
9150     return cfun->machine->some_ld_name;
9151
9152   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
9153     if (INSN_P (insn)
9154         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
9155       return cfun->machine->some_ld_name;
9156
9157   abort ();
9158 }
9159
9160 static int
9161 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
9162 {
9163   rtx x = *px;
9164
9165   if (x
9166       && GET_CODE (x) == SYMBOL_REF
9167       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
9168     {
9169       cfun->machine->some_ld_name = XSTR (x, 0);
9170       return 1;
9171     }
9172
9173   return 0;
9174 }
9175
9176 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
9177    We need to emit DTP-relative relocations.  */
9178
9179 void
9180 sparc_output_dwarf_dtprel (FILE *file, int size, rtx x)
9181 {
9182   switch (size)
9183     {
9184     case 4:
9185       fputs ("\t.word\t%r_tls_dtpoff32(", file);
9186       break;
9187     case 8:
9188       fputs ("\t.xword\t%r_tls_dtpoff64(", file);
9189       break;
9190     default:
9191       abort ();
9192     }
9193   output_addr_const (file, x);
9194   fputs (")", file);
9195 }
9196
9197 #include "gt-sparc.h"