gcc/config/mips/mips.c

   1 /* Subroutines used for MIPS code generation.
   2    Copyright (C) 1989, 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4    Contributed by A. Lichnewsky, lich@inria.inria.fr.
   5    Changes by Michael Meissner, meissner@osf.org.
   6    64 bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
   7    Brendan Eich, brendan@microunity.com.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify
  12 it under the terms of the GNU General Public License as published by
  13 the Free Software Foundation; either version 2, or (at your option)
  14 any later version.
  15
  16 GCC is distributed in the hope that it will be useful,
  17 but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 GNU General Public License for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING.  If not, write to
  23 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  24 Boston, MA 02110-1301, USA.  */
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include <signal.h>
  31 #include "rtl.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "real.h"
  35 #include "insn-config.h"
  36 #include "conditions.h"
  37 #include "insn-attr.h"
  38 #include "recog.h"
  39 #include "toplev.h"
  40 #include "output.h"
  41 #include "tree.h"
  42 #include "function.h"
  43 #include "expr.h"
  44 #include "optabs.h"
  45 #include "flags.h"
  46 #include "reload.h"
  47 #include "tm_p.h"
  48 #include "ggc.h"
  49 #include "gstab.h"
  50 #include "hashtab.h"
  51 #include "debug.h"
  52 #include "target.h"
  53 #include "target-def.h"
  54 #include "integrate.h"
  55 #include "langhooks.h"
  56 #include "cfglayout.h"
  57 #include "sched-int.h"
  58 #include "tree-gimple.h"
  59 #include "bitmap.h"
  60
  61 /* True if X is an unspec wrapper around a SYMBOL_REF or LABEL_REF.  */
  62 #define UNSPEC_ADDRESS_P(X)                                     \
  63   (GET_CODE (X) == UNSPEC                                       \
  64    && XINT (X, 1) >= UNSPEC_ADDRESS_FIRST                       \
  65    && XINT (X, 1) < UNSPEC_ADDRESS_FIRST + NUM_SYMBOL_TYPES)
  66
  67 /* Extract the symbol or label from UNSPEC wrapper X.  */
  68 #define UNSPEC_ADDRESS(X) \
  69   XVECEXP (X, 0, 0)
  70
  71 /* Extract the symbol type from UNSPEC wrapper X.  */
  72 #define UNSPEC_ADDRESS_TYPE(X) \
  73   ((enum mips_symbol_type) (XINT (X, 1) - UNSPEC_ADDRESS_FIRST))
  74
  75 /* The maximum distance between the top of the stack frame and the
  76    value $sp has when we save & restore registers.
  77
  78    Use a maximum gap of 0x100 in the mips16 case.  We can then use
  79    unextended instructions to save and restore registers, and to
  80    allocate and deallocate the top part of the frame.
  81
  82    The value in the !mips16 case must be a SMALL_OPERAND and must
  83    preserve the maximum stack alignment.  */
  84 #define MIPS_MAX_FIRST_STACK_STEP (TARGET_MIPS16 ? 0x100 : 0x7ff0)
  85
  86 /* True if INSN is a mips.md pattern or asm statement.  */
  87 #define USEFUL_INSN_P(INSN)                                             \
  88   (INSN_P (INSN)                                                        \
  89    && GET_CODE (PATTERN (INSN)) != USE                                  \
  90    && GET_CODE (PATTERN (INSN)) != CLOBBER                              \
  91    && GET_CODE (PATTERN (INSN)) != ADDR_VEC                             \
  92    && GET_CODE (PATTERN (INSN)) != ADDR_DIFF_VEC)
  93
  94 /* If INSN is a delayed branch sequence, return the first instruction
  95    in the sequence, otherwise return INSN itself.  */
  96 #define SEQ_BEGIN(INSN)                                                 \
  97   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
  98    ? XVECEXP (PATTERN (INSN), 0, 0)                                     \
  99    : (INSN))
 100
 101 /* Likewise for the last instruction in a delayed branch sequence.  */
 102 #define SEQ_END(INSN)                                                   \
 103   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
 104    ? XVECEXP (PATTERN (INSN), 0, XVECLEN (PATTERN (INSN), 0) - 1)       \
 105    : (INSN))
 106
 107 /* Execute the following loop body with SUBINSN set to each instruction
 108    between SEQ_BEGIN (INSN) and SEQ_END (INSN) inclusive.  */
 109 #define FOR_EACH_SUBINSN(SUBINSN, INSN)                                 \
 110   for ((SUBINSN) = SEQ_BEGIN (INSN);                                    \
 111        (SUBINSN) != NEXT_INSN (SEQ_END (INSN));                         \
 112        (SUBINSN) = NEXT_INSN (SUBINSN))
 113
 114 /* Classifies an address.
 115
 116    ADDRESS_REG
 117        A natural register + offset address.  The register satisfies
 118        mips_valid_base_register_p and the offset is a const_arith_operand.
 119
 120    ADDRESS_LO_SUM
 121        A LO_SUM rtx.  The first operand is a valid base register and
 122        the second operand is a symbolic address.
 123
 124    ADDRESS_CONST_INT
 125        A signed 16-bit constant address.
 126
 127    ADDRESS_SYMBOLIC:
 128        A constant symbolic address (equivalent to CONSTANT_SYMBOLIC).  */
 129 enum mips_address_type {
 130   ADDRESS_REG,
 131   ADDRESS_LO_SUM,
 132   ADDRESS_CONST_INT,
 133   ADDRESS_SYMBOLIC
 134 };
 135
 136 /* Classifies the prototype of a builtin function.  */
 137 enum mips_function_type
 138 {
 139   MIPS_V2SF_FTYPE_V2SF,
 140   MIPS_V2SF_FTYPE_V2SF_V2SF,
 141   MIPS_V2SF_FTYPE_V2SF_V2SF_INT,
 142   MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,
 143   MIPS_V2SF_FTYPE_SF_SF,
 144   MIPS_INT_FTYPE_V2SF_V2SF,
 145   MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,
 146   MIPS_INT_FTYPE_SF_SF,
 147   MIPS_INT_FTYPE_DF_DF,
 148   MIPS_SF_FTYPE_V2SF,
 149   MIPS_SF_FTYPE_SF,
 150   MIPS_SF_FTYPE_SF_SF,
 151   MIPS_DF_FTYPE_DF,
 152   MIPS_DF_FTYPE_DF_DF,
 153
 154   /* For MIPS DSP ASE  */
 155   MIPS_DI_FTYPE_DI_SI,
 156   MIPS_DI_FTYPE_DI_SI_SI,
 157   MIPS_DI_FTYPE_DI_V2HI_V2HI,
 158   MIPS_DI_FTYPE_DI_V4QI_V4QI,
 159   MIPS_SI_FTYPE_DI_SI,
 160   MIPS_SI_FTYPE_PTR_SI,
 161   MIPS_SI_FTYPE_SI,
 162   MIPS_SI_FTYPE_SI_SI,
 163   MIPS_SI_FTYPE_V2HI,
 164   MIPS_SI_FTYPE_V2HI_V2HI,
 165   MIPS_SI_FTYPE_V4QI,
 166   MIPS_SI_FTYPE_V4QI_V4QI,
 167   MIPS_SI_FTYPE_VOID,
 168   MIPS_V2HI_FTYPE_SI,
 169   MIPS_V2HI_FTYPE_SI_SI,
 170   MIPS_V2HI_FTYPE_V2HI,
 171   MIPS_V2HI_FTYPE_V2HI_SI,
 172   MIPS_V2HI_FTYPE_V2HI_V2HI,
 173   MIPS_V2HI_FTYPE_V4QI,
 174   MIPS_V2HI_FTYPE_V4QI_V2HI,
 175   MIPS_V4QI_FTYPE_SI,
 176   MIPS_V4QI_FTYPE_V2HI_V2HI,
 177   MIPS_V4QI_FTYPE_V4QI_SI,
 178   MIPS_V4QI_FTYPE_V4QI_V4QI,
 179   MIPS_VOID_FTYPE_SI_SI,
 180   MIPS_VOID_FTYPE_V2HI_V2HI,
 181   MIPS_VOID_FTYPE_V4QI_V4QI,
 182
 183   /* The last type.  */
 184   MIPS_MAX_FTYPE_MAX
 185 };
 186
 187 /* Specifies how a builtin function should be converted into rtl.  */
 188 enum mips_builtin_type
 189 {
 190   /* The builtin corresponds directly to an .md pattern.  The return
 191      value is mapped to operand 0 and the arguments are mapped to
 192      operands 1 and above.  */
 193   MIPS_BUILTIN_DIRECT,
 194
 195   /* The builtin corresponds directly to an .md pattern.  There is no return
 196      value and the arguments are mapped to operands 0 and above.  */
 197   MIPS_BUILTIN_DIRECT_NO_TARGET,
 198
 199   /* The builtin corresponds to a comparison instruction followed by
 200      a mips_cond_move_tf_ps pattern.  The first two arguments are the
 201      values to compare and the second two arguments are the vector
 202      operands for the movt.ps or movf.ps instruction (in assembly order).  */
 203   MIPS_BUILTIN_MOVF,
 204   MIPS_BUILTIN_MOVT,
 205
 206   /* The builtin corresponds to a V2SF comparison instruction.  Operand 0
 207      of this instruction is the result of the comparison, which has mode
 208      CCV2 or CCV4.  The function arguments are mapped to operands 1 and
 209      above.  The function's return value is an SImode boolean that is
 210      true under the following conditions:
 211
 212      MIPS_BUILTIN_CMP_ANY: one of the registers is true
 213      MIPS_BUILTIN_CMP_ALL: all of the registers are true
 214      MIPS_BUILTIN_CMP_LOWER: the first register is true
 215      MIPS_BUILTIN_CMP_UPPER: the second register is true.  */
 216   MIPS_BUILTIN_CMP_ANY,
 217   MIPS_BUILTIN_CMP_ALL,
 218   MIPS_BUILTIN_CMP_UPPER,
 219   MIPS_BUILTIN_CMP_LOWER,
 220
 221   /* As above, but the instruction only sets a single $fcc register.  */
 222   MIPS_BUILTIN_CMP_SINGLE,
 223
 224   /* For generating bposge32 branch instructions in MIPS32 DSP ASE.  */
 225   MIPS_BUILTIN_BPOSGE32
 226 };
 227
 228 /* Invokes MACRO (COND) for each c.cond.fmt condition.  */
 229 #define MIPS_FP_CONDITIONS(MACRO) \
 230   MACRO (f),    \
 231   MACRO (un),   \
 232   MACRO (eq),   \
 233   MACRO (ueq),  \
 234   MACRO (olt),  \
 235   MACRO (ult),  \
 236   MACRO (ole),  \
 237   MACRO (ule),  \
 238   MACRO (sf),   \
 239   MACRO (ngle), \
 240   MACRO (seq),  \
 241   MACRO (ngl),  \
 242   MACRO (lt),   \
 243   MACRO (nge),  \
 244   MACRO (le),   \
 245   MACRO (ngt)
 246
 247 /* Enumerates the codes above as MIPS_FP_COND_<X>.  */
 248 #define DECLARE_MIPS_COND(X) MIPS_FP_COND_ ## X
 249 enum mips_fp_condition {
 250   MIPS_FP_CONDITIONS (DECLARE_MIPS_COND)
 251 };
 252
 253 /* Index X provides the string representation of MIPS_FP_COND_<X>.  */
 254 #define STRINGIFY(X) #X
 255 static const char *const mips_fp_conditions[] = {
 256   MIPS_FP_CONDITIONS (STRINGIFY)
 257 };
 258
 259 /* A function to save or store a register.  The first argument is the
 260    register and the second is the stack slot.  */
 261 typedef void (*mips_save_restore_fn) (rtx, rtx);
 262
 263 struct mips16_constant;
 264 struct mips_arg_info;
 265 struct mips_address_info;
 266 struct mips_integer_op;
 267 struct mips_sim;
 268
 269 static enum mips_symbol_type mips_classify_symbol (rtx);
 270 static void mips_split_const (rtx, rtx *, HOST_WIDE_INT *);
 271 static bool mips_offset_within_object_p (rtx, HOST_WIDE_INT);
 272 static bool mips_valid_base_register_p (rtx, enum machine_mode, int);
 273 static bool mips_symbolic_address_p (enum mips_symbol_type, enum machine_mode);
 274 static bool mips_classify_address (struct mips_address_info *, rtx,
 275                                    enum machine_mode, int);
 276 static bool mips_cannot_force_const_mem (rtx);
 277 static bool mips_use_blocks_for_constant_p (enum machine_mode, rtx);
 278 static int mips_symbol_insns (enum mips_symbol_type);
 279 static bool mips16_unextended_reference_p (enum machine_mode mode, rtx, rtx);
 280 static rtx mips_force_temporary (rtx, rtx);
 281 static rtx mips_unspec_offset_high (rtx, rtx, rtx, enum mips_symbol_type);
 282 static rtx mips_add_offset (rtx, rtx, HOST_WIDE_INT);
 283 static unsigned int mips_build_shift (struct mips_integer_op *, HOST_WIDE_INT);
 284 static unsigned int mips_build_lower (struct mips_integer_op *,
 285                                       unsigned HOST_WIDE_INT);
 286 static unsigned int mips_build_integer (struct mips_integer_op *,
 287                                         unsigned HOST_WIDE_INT);
 288 static void mips_legitimize_const_move (enum machine_mode, rtx, rtx);
 289 static int m16_check_op (rtx, int, int, int);
 290 static bool mips_rtx_costs (rtx, int, int, int *);
 291 static int mips_address_cost (rtx);
 292 static void mips_emit_compare (enum rtx_code *, rtx *, rtx *, bool);
 293 static void mips_load_call_address (rtx, rtx, int);
 294 static bool mips_function_ok_for_sibcall (tree, tree);
 295 static void mips_block_move_straight (rtx, rtx, HOST_WIDE_INT);
 296 static void mips_adjust_block_mem (rtx, HOST_WIDE_INT, rtx *, rtx *);
 297 static void mips_block_move_loop (rtx, rtx, HOST_WIDE_INT);
 298 static void mips_arg_info (const CUMULATIVE_ARGS *, enum machine_mode,
 299                            tree, int, struct mips_arg_info *);
 300 static bool mips_get_unaligned_mem (rtx *, unsigned int, int, rtx *, rtx *);
 301 static void mips_set_architecture (const struct mips_cpu_info *);
 302 static void mips_set_tune (const struct mips_cpu_info *);
 303 static bool mips_handle_option (size_t, const char *, int);
 304 static struct machine_function *mips_init_machine_status (void);
 305 static void print_operand_reloc (FILE *, rtx, const char **);
 306 static void mips_file_start (void);
 307 static bool mips_rewrite_small_data_p (rtx);
 308 static int mips_small_data_pattern_1 (rtx *, void *);
 309 static int mips_rewrite_small_data_1 (rtx *, void *);
 310 static bool mips_function_has_gp_insn (void);
 311 static unsigned int mips_global_pointer (void);
 312 static bool mips_save_reg_p (unsigned int);
 313 static void mips_save_restore_reg (enum machine_mode, int, HOST_WIDE_INT,
 314                                    mips_save_restore_fn);
 315 static void mips_for_each_saved_reg (HOST_WIDE_INT, mips_save_restore_fn);
 316 static void mips_output_cplocal (void);
 317 static void mips_emit_loadgp (void);
 318 static void mips_output_function_prologue (FILE *, HOST_WIDE_INT);
 319 static void mips_set_frame_expr (rtx);
 320 static rtx mips_frame_set (rtx, rtx);
 321 static void mips_save_reg (rtx, rtx);
 322 static void mips_output_function_epilogue (FILE *, HOST_WIDE_INT);
 323 static void mips_restore_reg (rtx, rtx);
 324 static void mips_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 325                                   HOST_WIDE_INT, tree);
 326 static int symbolic_expression_p (rtx);
 327 static section *mips_select_rtx_section (enum machine_mode, rtx,
 328                                          unsigned HOST_WIDE_INT);
 329 static section *mips_function_rodata_section (tree);
 330 static bool mips_in_small_data_p (tree);
 331 static bool mips_use_anchors_for_symbol_p (rtx);
 332 static int mips_fpr_return_fields (tree, tree *);
 333 static bool mips_return_in_msb (tree);
 334 static rtx mips_return_fpr_pair (enum machine_mode mode,
 335                                  enum machine_mode mode1, HOST_WIDE_INT,
 336                                  enum machine_mode mode2, HOST_WIDE_INT);
 337 static rtx mips16_gp_pseudo_reg (void);
 338 static void mips16_fp_args (FILE *, int, int);
 339 static void build_mips16_function_stub (FILE *);
 340 static rtx dump_constants_1 (enum machine_mode, rtx, rtx);
 341 static void dump_constants (struct mips16_constant *, rtx);
 342 static int mips16_insn_length (rtx);
 343 static int mips16_rewrite_pool_refs (rtx *, void *);
 344 static void mips16_lay_out_constants (void);
 345 static void mips_sim_reset (struct mips_sim *);
 346 static void mips_sim_init (struct mips_sim *, state_t);
 347 static void mips_sim_next_cycle (struct mips_sim *);
 348 static void mips_sim_wait_reg (struct mips_sim *, rtx, rtx);
 349 static int mips_sim_wait_regs_2 (rtx *, void *);
 350 static void mips_sim_wait_regs_1 (rtx *, void *);
 351 static void mips_sim_wait_regs (struct mips_sim *, rtx);
 352 static void mips_sim_wait_units (struct mips_sim *, rtx);
 353 static void mips_sim_wait_insn (struct mips_sim *, rtx);
 354 static void mips_sim_record_set (rtx, rtx, void *);
 355 static void mips_sim_issue_insn (struct mips_sim *, rtx);
 356 static void mips_sim_issue_nop (struct mips_sim *);
 357 static void mips_sim_finish_insn (struct mips_sim *, rtx);
 358 static void vr4130_avoid_branch_rt_conflict (rtx);
 359 static void vr4130_align_insns (void);
 360 static void mips_avoid_hazard (rtx, rtx, int *, rtx *, rtx);
 361 static void mips_avoid_hazards (void);
 362 static void mips_reorg (void);
 363 static bool mips_strict_matching_cpu_name_p (const char *, const char *);
 364 static bool mips_matching_cpu_name_p (const char *, const char *);
 365 static const struct mips_cpu_info *mips_parse_cpu (const char *);
 366 static const struct mips_cpu_info *mips_cpu_info_from_isa (int);
 367 static bool mips_return_in_memory (tree, tree);
 368 static bool mips_strict_argument_naming (CUMULATIVE_ARGS *);
 369 static void mips_macc_chains_record (rtx);
 370 static void mips_macc_chains_reorder (rtx *, int);
 371 static void vr4130_true_reg_dependence_p_1 (rtx, rtx, void *);
 372 static bool vr4130_true_reg_dependence_p (rtx);
 373 static bool vr4130_swap_insns_p (rtx, rtx);
 374 static void vr4130_reorder (rtx *, int);
 375 static void mips_promote_ready (rtx *, int, int);
 376 static int mips_sched_reorder (FILE *, int, rtx *, int *, int);
 377 static int mips_variable_issue (FILE *, int, rtx, int);
 378 static int mips_adjust_cost (rtx, rtx, rtx, int);
 379 static int mips_issue_rate (void);
 380 static int mips_multipass_dfa_lookahead (void);
 381 static void mips_init_libfuncs (void);
 382 static void mips_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
 383                                          tree, int *, int);
 384 static tree mips_build_builtin_va_list (void);
 385 static tree mips_gimplify_va_arg_expr (tree, tree, tree *, tree *);
 386 static bool mips_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode mode,
 387                                     tree, bool);
 388 static bool mips_callee_copies (CUMULATIVE_ARGS *, enum machine_mode mode,
 389                                 tree, bool);
 390 static int mips_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode mode,
 391                                    tree, bool);
 392 static bool mips_valid_pointer_mode (enum machine_mode);
 393 static bool mips_vector_mode_supported_p (enum machine_mode);
 394 static rtx mips_prepare_builtin_arg (enum insn_code, unsigned int, tree *);
 395 static rtx mips_prepare_builtin_target (enum insn_code, unsigned int, rtx);
 396 static rtx mips_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 397 static void mips_init_builtins (void);
 398 static rtx mips_expand_builtin_direct (enum insn_code, rtx, tree, bool);
 399 static rtx mips_expand_builtin_movtf (enum mips_builtin_type,
 400                                       enum insn_code, enum mips_fp_condition,
 401                                       rtx, tree);
 402 static rtx mips_expand_builtin_compare (enum mips_builtin_type,
 403                                         enum insn_code, enum mips_fp_condition,
 404                                         rtx, tree);
 405 static rtx mips_expand_builtin_bposge (enum mips_builtin_type, rtx);
 406 static void mips_encode_section_info (tree, rtx, int);
 407 static void mips_extra_live_on_entry (bitmap);
 408 static int mips_mode_rep_extended (enum machine_mode, enum machine_mode);
 409
 410 /* Structure to be filled in by compute_frame_size with register
 411    save masks, and offsets for the current function.  */
 412
 413 struct mips_frame_info GTY(())
 414 {
 415   HOST_WIDE_INT total_size;     /* # bytes that the entire frame takes up */
 416   HOST_WIDE_INT var_size;       /* # bytes that variables take up */
 417   HOST_WIDE_INT args_size;      /* # bytes that outgoing arguments take up */
 418   HOST_WIDE_INT cprestore_size; /* # bytes that the .cprestore slot takes up */
 419   HOST_WIDE_INT gp_reg_size;    /* # bytes needed to store gp regs */
 420   HOST_WIDE_INT fp_reg_size;    /* # bytes needed to store fp regs */
 421   unsigned int mask;            /* mask of saved gp registers */
 422   unsigned int fmask;           /* mask of saved fp registers */
 423   HOST_WIDE_INT gp_save_offset; /* offset from vfp to store gp registers */
 424   HOST_WIDE_INT fp_save_offset; /* offset from vfp to store fp registers */
 425   HOST_WIDE_INT gp_sp_offset;   /* offset from new sp to store gp registers */
 426   HOST_WIDE_INT fp_sp_offset;   /* offset from new sp to store fp registers */
 427   bool initialized;             /* true if frame size already calculated */
 428   int num_gp;                   /* number of gp registers saved */
 429   int num_fp;                   /* number of fp registers saved */
 430 };
 431
 432 struct machine_function GTY(()) {
 433   /* Pseudo-reg holding the value of $28 in a mips16 function which
 434      refers to GP relative global variables.  */
 435   rtx mips16_gp_pseudo_rtx;
 436
 437   /* The number of extra stack bytes taken up by register varargs.
 438      This area is allocated by the callee at the very top of the frame.  */
 439   int varargs_size;
 440
 441   /* Current frame information, calculated by compute_frame_size.  */
 442   struct mips_frame_info frame;
 443
 444   /* The register to use as the global pointer within this function.  */
 445   unsigned int global_pointer;
 446
 447   /* True if mips_adjust_insn_length should ignore an instruction's
 448      hazard attribute.  */
 449   bool ignore_hazard_length_p;
 450
 451   /* True if the whole function is suitable for .set noreorder and
 452      .set nomacro.  */
 453   bool all_noreorder_p;
 454
 455   /* True if the function is known to have an instruction that needs $gp.  */
 456   bool has_gp_insn_p;
 457 };
 458
 459 /* Information about a single argument.  */
 460 struct mips_arg_info
 461 {
 462   /* True if the argument is passed in a floating-point register, or
 463      would have been if we hadn't run out of registers.  */
 464   bool fpr_p;
 465
 466   /* The number of words passed in registers, rounded up.  */
 467   unsigned int reg_words;
 468
 469   /* For EABI, the offset of the first register from GP_ARG_FIRST or
 470      FP_ARG_FIRST.  For other ABIs, the offset of the first register from
 471      the start of the ABI's argument structure (see the CUMULATIVE_ARGS
 472      comment for details).
 473
 474      The value is MAX_ARGS_IN_REGISTERS if the argument is passed entirely
 475      on the stack.  */
 476   unsigned int reg_offset;
 477
 478   /* The number of words that must be passed on the stack, rounded up.  */
 479   unsigned int stack_words;
 480
 481   /* The offset from the start of the stack overflow area of the argument's
 482      first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
 483   unsigned int stack_offset;
 484 };
 485
 486
 487 /* Information about an address described by mips_address_type.
 488
 489    ADDRESS_CONST_INT
 490        No fields are used.
 491
 492    ADDRESS_REG
 493        REG is the base register and OFFSET is the constant offset.
 494
 495    ADDRESS_LO_SUM
 496        REG is the register that contains the high part of the address,
 497        OFFSET is the symbolic address being referenced and SYMBOL_TYPE
 498        is the type of OFFSET's symbol.
 499
 500    ADDRESS_SYMBOLIC
 501        SYMBOL_TYPE is the type of symbol being referenced.  */
 502
 503 struct mips_address_info
 504 {
 505   enum mips_address_type type;
 506   rtx reg;
 507   rtx offset;
 508   enum mips_symbol_type symbol_type;
 509 };
 510
 511
 512 /* One stage in a constant building sequence.  These sequences have
 513    the form:
 514
 515         A = VALUE[0]
 516         A = A CODE[1] VALUE[1]
 517         A = A CODE[2] VALUE[2]
 518         ...
 519
 520    where A is an accumulator, each CODE[i] is a binary rtl operation
 521    and each VALUE[i] is a constant integer.  */
 522 struct mips_integer_op {
 523   enum rtx_code code;
 524   unsigned HOST_WIDE_INT value;
 525 };
 526
 527
 528 /* The largest number of operations needed to load an integer constant.
 529    The worst accepted case for 64-bit constants is LUI,ORI,SLL,ORI,SLL,ORI.
 530    When the lowest bit is clear, we can try, but reject a sequence with
 531    an extra SLL at the end.  */
 532 #define MIPS_MAX_INTEGER_OPS 7
 533
 534
 535 /* Global variables for machine-dependent things.  */
 536
 537 /* Threshold for data being put into the small data/bss area, instead
 538    of the normal data area.  */
 539 int mips_section_threshold = -1;
 540
 541 /* Count the number of .file directives, so that .loc is up to date.  */
 542 int num_source_filenames = 0;
 543
 544 /* Count the number of sdb related labels are generated (to find block
 545    start and end boundaries).  */
 546 int sdb_label_count = 0;
 547
 548 /* Next label # for each statement for Silicon Graphics IRIS systems.  */
 549 int sym_lineno = 0;
 550
 551 /* Name of the file containing the current function.  */
 552 const char *current_function_file = "";
 553
 554 /* Number of nested .set noreorder, noat, nomacro, and volatile requests.  */
 555 int set_noreorder;
 556 int set_noat;
 557 int set_nomacro;
 558 int set_volatile;
 559
 560 /* The next branch instruction is a branch likely, not branch normal.  */
 561 int mips_branch_likely;
 562
 563 /* The operands passed to the last cmpMM expander.  */
 564 rtx cmp_operands[2];
 565
 566 /* The target cpu for code generation.  */
 567 enum processor_type mips_arch;
 568 const struct mips_cpu_info *mips_arch_info;
 569
 570 /* The target cpu for optimization and scheduling.  */
 571 enum processor_type mips_tune;
 572 const struct mips_cpu_info *mips_tune_info;
 573
 574 /* Which instruction set architecture to use.  */
 575 int mips_isa;
 576
 577 /* Which ABI to use.  */
 578 int mips_abi = MIPS_ABI_DEFAULT;
 579
 580 /* Cost information to use.  */
 581 const struct mips_rtx_cost_data *mips_cost;
 582
 583 /* Whether we are generating mips16 hard float code.  In mips16 mode
 584    we always set TARGET_SOFT_FLOAT; this variable is nonzero if
 585    -msoft-float was not specified by the user, which means that we
 586    should arrange to call mips32 hard floating point code.  */
 587 int mips16_hard_float;
 588
 589 /* The architecture selected by -mipsN.  */
 590 static const struct mips_cpu_info *mips_isa_info;
 591
 592 /* If TRUE, we split addresses into their high and low parts in the RTL.  */
 593 int mips_split_addresses;
 594
 595 /* Mode used for saving/restoring general purpose registers.  */
 596 static enum machine_mode gpr_mode;
 597
 598 /* Array giving truth value on whether or not a given hard register
 599    can support a given mode.  */
 600 char mips_hard_regno_mode_ok[(int)MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
 601
 602 /* List of all MIPS punctuation characters used by print_operand.  */
 603 char mips_print_operand_punct[256];
 604
 605 /* Map GCC register number to debugger register number.  */
 606 int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
 607
 608 /* A copy of the original flag_delayed_branch: see override_options.  */
 609 static int mips_flag_delayed_branch;
 610
 611 static GTY (()) int mips_output_filename_first_time = 1;
 612
 613 /* mips_split_p[X] is true if symbols of type X can be split by
 614    mips_split_symbol().  */
 615 bool mips_split_p[NUM_SYMBOL_TYPES];
 616
 617 /* mips_lo_relocs[X] is the relocation to use when a symbol of type X
 618    appears in a LO_SUM.  It can be null if such LO_SUMs aren't valid or
 619    if they are matched by a special .md file pattern.  */
 620 static const char *mips_lo_relocs[NUM_SYMBOL_TYPES];
 621
 622 /* Likewise for HIGHs.  */
 623 static const char *mips_hi_relocs[NUM_SYMBOL_TYPES];
 624
 625 /* Map hard register number to register class */
 626 const enum reg_class mips_regno_to_class[] =
 627 {
 628   LEA_REGS,     LEA_REGS,       M16_NA_REGS,    V1_REG,
 629   M16_REGS,     M16_REGS,       M16_REGS,       M16_REGS,
 630   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
 631   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
 632   M16_NA_REGS,  M16_NA_REGS,    LEA_REGS,       LEA_REGS,
 633   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
 634   T_REG,        PIC_FN_ADDR_REG, LEA_REGS,      LEA_REGS,
 635   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
 636   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 637   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 638   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 639   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 640   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 641   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 642   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 643   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 644   HI_REG,       LO_REG,         NO_REGS,        ST_REGS,
 645   ST_REGS,      ST_REGS,        ST_REGS,        ST_REGS,
 646   ST_REGS,      ST_REGS,        ST_REGS,        NO_REGS,
 647   NO_REGS,      ALL_REGS,       ALL_REGS,       NO_REGS,
 648   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 649   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 650   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 651   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 652   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 653   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 654   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 655   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
 656   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 657   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 658   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 659   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 660   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 661   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 662   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 663   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
 664   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 665   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 666   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 667   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 668   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 669   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 670   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 671   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
 672   DSP_ACC_REGS, DSP_ACC_REGS,   DSP_ACC_REGS,   DSP_ACC_REGS,
 673   DSP_ACC_REGS, DSP_ACC_REGS,   ALL_REGS,       ALL_REGS,
 674   ALL_REGS,     ALL_REGS,       ALL_REGS,       ALL_REGS
 675 };
 676
 677 /* Table of machine dependent attributes.  */
 678 const struct attribute_spec mips_attribute_table[] =
 679 {
 680   { "long_call",   0, 0, false, true,  true,  NULL },
 681   { NULL,          0, 0, false, false, false, NULL }
 682 };
 683 \f
 684 /* A table describing all the processors gcc knows about.  Names are
 685    matched in the order listed.  The first mention of an ISA level is
 686    taken as the canonical name for that ISA.
 687
 688    To ease comparison, please keep this table in the same order as
 689    gas's mips_cpu_info_table[].  */
 690 const struct mips_cpu_info mips_cpu_info_table[] = {
 691   /* Entries for generic ISAs */
 692   { "mips1", PROCESSOR_R3000, 1 },
 693   { "mips2", PROCESSOR_R6000, 2 },
 694   { "mips3", PROCESSOR_R4000, 3 },
 695   { "mips4", PROCESSOR_R8000, 4 },
 696   { "mips32", PROCESSOR_4KC, 32 },
 697   { "mips32r2", PROCESSOR_M4K, 33 },
 698   { "mips64", PROCESSOR_5KC, 64 },
 699
 700   /* MIPS I */
 701   { "r3000", PROCESSOR_R3000, 1 },
 702   { "r2000", PROCESSOR_R3000, 1 }, /* = r3000 */
 703   { "r3900", PROCESSOR_R3900, 1 },
 704
 705   /* MIPS II */
 706   { "r6000", PROCESSOR_R6000, 2 },
 707
 708   /* MIPS III */
 709   { "r4000", PROCESSOR_R4000, 3 },
 710   { "vr4100", PROCESSOR_R4100, 3 },
 711   { "vr4111", PROCESSOR_R4111, 3 },
 712   { "vr4120", PROCESSOR_R4120, 3 },
 713   { "vr4130", PROCESSOR_R4130, 3 },
 714   { "vr4300", PROCESSOR_R4300, 3 },
 715   { "r4400", PROCESSOR_R4000, 3 }, /* = r4000 */
 716   { "r4600", PROCESSOR_R4600, 3 },
 717   { "orion", PROCESSOR_R4600, 3 }, /* = r4600 */
 718   { "r4650", PROCESSOR_R4650, 3 },
 719
 720   /* MIPS IV */
 721   { "r8000", PROCESSOR_R8000, 4 },
 722   { "vr5000", PROCESSOR_R5000, 4 },
 723   { "vr5400", PROCESSOR_R5400, 4 },
 724   { "vr5500", PROCESSOR_R5500, 4 },
 725   { "rm7000", PROCESSOR_R7000, 4 },
 726   { "rm9000", PROCESSOR_R9000, 4 },
 727
 728   /* MIPS32 */
 729   { "4kc", PROCESSOR_4KC, 32 },
 730   { "4km", PROCESSOR_4KC, 32 }, /* = 4kc */
 731   { "4kp", PROCESSOR_4KP, 32 },
 732
 733   /* MIPS32 Release 2 */
 734   { "m4k", PROCESSOR_M4K, 33 },
 735   { "4kec", PROCESSOR_4KC, 33 },
 736   { "4kem", PROCESSOR_4KC, 33 },
 737   { "4kep", PROCESSOR_4KP, 33 },
 738   { "24kc", PROCESSOR_24KC, 33 },  /* 24K  no FPU */
 739   { "24kf", PROCESSOR_24KF, 33 },  /* 24K 1:2 FPU */
 740   { "24kx", PROCESSOR_24KX, 33 },  /* 24K 1:1 FPU */
 741   { "24kec", PROCESSOR_24KC, 33 }, /* 24K with DSP */
 742   { "24kef", PROCESSOR_24KF, 33 },
 743   { "24kex", PROCESSOR_24KX, 33 },
 744   { "34kc", PROCESSOR_24KC, 33 },  /* 34K with MT/DSP */
 745   { "34kf", PROCESSOR_24KF, 33 },
 746   { "34kx", PROCESSOR_24KX, 33 },
 747
 748   /* MIPS64 */
 749   { "5kc", PROCESSOR_5KC, 64 },
 750   { "5kf", PROCESSOR_5KF, 64 },
 751   { "20kc", PROCESSOR_20KC, 64 },
 752   { "sb1", PROCESSOR_SB1, 64 },
 753   { "sb1a", PROCESSOR_SB1A, 64 },
 754   { "sr71000", PROCESSOR_SR71000, 64 },
 755
 756   /* End marker */
 757   { 0, 0, 0 }
 758 };
 759
 760 /* Default costs. If these are used for a processor we should look
 761    up the actual costs.  */
 762 #define DEFAULT_COSTS COSTS_N_INSNS (6),  /* fp_add */       \
 763                       COSTS_N_INSNS (7),  /* fp_mult_sf */   \
 764                       COSTS_N_INSNS (8),  /* fp_mult_df */   \
 765                       COSTS_N_INSNS (23), /* fp_div_sf */    \
 766                       COSTS_N_INSNS (36), /* fp_div_df */    \
 767                       COSTS_N_INSNS (10), /* int_mult_si */  \
 768                       COSTS_N_INSNS (10), /* int_mult_di */  \
 769                       COSTS_N_INSNS (69), /* int_div_si */   \
 770                       COSTS_N_INSNS (69), /* int_div_di */   \
 771                                        2, /* branch_cost */  \
 772                                        4  /* memory_latency */
 773
 774 /* Need to replace these with the costs of calling the appropriate
 775    libgcc routine.  */
 776 #define SOFT_FP_COSTS COSTS_N_INSNS (256), /* fp_add */       \
 777                       COSTS_N_INSNS (256), /* fp_mult_sf */   \
 778                       COSTS_N_INSNS (256), /* fp_mult_df */   \
 779                       COSTS_N_INSNS (256), /* fp_div_sf */    \
 780                       COSTS_N_INSNS (256)  /* fp_div_df */
 781
 782 static struct mips_rtx_cost_data const mips_rtx_cost_optimize_size =
 783   {
 784       COSTS_N_INSNS (1),            /* fp_add */
 785       COSTS_N_INSNS (1),            /* fp_mult_sf */
 786       COSTS_N_INSNS (1),            /* fp_mult_df */
 787       COSTS_N_INSNS (1),            /* fp_div_sf */
 788       COSTS_N_INSNS (1),            /* fp_div_df */
 789       COSTS_N_INSNS (1),            /* int_mult_si */
 790       COSTS_N_INSNS (1),            /* int_mult_di */
 791       COSTS_N_INSNS (1),            /* int_div_si */
 792       COSTS_N_INSNS (1),            /* int_div_di */
 793                        2,           /* branch_cost */
 794                        4            /* memory_latency */
 795   };
 796
 797 static struct mips_rtx_cost_data const mips_rtx_cost_data[PROCESSOR_MAX] =
 798   {
 799     { /* R3000 */
 800       COSTS_N_INSNS (2),            /* fp_add */
 801       COSTS_N_INSNS (4),            /* fp_mult_sf */
 802       COSTS_N_INSNS (5),            /* fp_mult_df */
 803       COSTS_N_INSNS (12),           /* fp_div_sf */
 804       COSTS_N_INSNS (19),           /* fp_div_df */
 805       COSTS_N_INSNS (12),           /* int_mult_si */
 806       COSTS_N_INSNS (12),           /* int_mult_di */
 807       COSTS_N_INSNS (35),           /* int_div_si */
 808       COSTS_N_INSNS (35),           /* int_div_di */
 809                        1,           /* branch_cost */
 810                        4            /* memory_latency */
 811
 812     },
 813     { /* 4KC */
 814       SOFT_FP_COSTS,
 815       COSTS_N_INSNS (6),            /* int_mult_si */
 816       COSTS_N_INSNS (6),            /* int_mult_di */
 817       COSTS_N_INSNS (36),           /* int_div_si */
 818       COSTS_N_INSNS (36),           /* int_div_di */
 819                        1,           /* branch_cost */
 820                        4            /* memory_latency */
 821     },
 822     { /* 4KP */
 823       SOFT_FP_COSTS,
 824       COSTS_N_INSNS (36),           /* int_mult_si */
 825       COSTS_N_INSNS (36),           /* int_mult_di */
 826       COSTS_N_INSNS (37),           /* int_div_si */
 827       COSTS_N_INSNS (37),           /* int_div_di */
 828                        1,           /* branch_cost */
 829                        4            /* memory_latency */
 830     },
 831     { /* 5KC */
 832       SOFT_FP_COSTS,
 833       COSTS_N_INSNS (4),            /* int_mult_si */
 834       COSTS_N_INSNS (11),           /* int_mult_di */
 835       COSTS_N_INSNS (36),           /* int_div_si */
 836       COSTS_N_INSNS (68),           /* int_div_di */
 837                        1,           /* branch_cost */
 838                        4            /* memory_latency */
 839     },
 840     { /* 5KF */
 841       COSTS_N_INSNS (4),            /* fp_add */
 842       COSTS_N_INSNS (4),            /* fp_mult_sf */
 843       COSTS_N_INSNS (5),            /* fp_mult_df */
 844       COSTS_N_INSNS (17),           /* fp_div_sf */
 845       COSTS_N_INSNS (32),           /* fp_div_df */
 846       COSTS_N_INSNS (4),            /* int_mult_si */
 847       COSTS_N_INSNS (11),           /* int_mult_di */
 848       COSTS_N_INSNS (36),           /* int_div_si */
 849       COSTS_N_INSNS (68),           /* int_div_di */
 850                        1,           /* branch_cost */
 851                        4            /* memory_latency */
 852     },
 853     { /* 20KC */
 854       DEFAULT_COSTS
 855     },
 856     { /* 24KC */
 857       SOFT_FP_COSTS,
 858       COSTS_N_INSNS (5),            /* int_mult_si */
 859       COSTS_N_INSNS (5),            /* int_mult_di */
 860       COSTS_N_INSNS (41),           /* int_div_si */
 861       COSTS_N_INSNS (41),           /* int_div_di */
 862                        1,           /* branch_cost */
 863                        4            /* memory_latency */
 864     },
 865     { /* 24KF */
 866       COSTS_N_INSNS (8),            /* fp_add */
 867       COSTS_N_INSNS (8),            /* fp_mult_sf */
 868       COSTS_N_INSNS (10),           /* fp_mult_df */
 869       COSTS_N_INSNS (34),           /* fp_div_sf */
 870       COSTS_N_INSNS (64),           /* fp_div_df */
 871       COSTS_N_INSNS (5),            /* int_mult_si */
 872       COSTS_N_INSNS (5),            /* int_mult_di */
 873       COSTS_N_INSNS (41),           /* int_div_si */
 874       COSTS_N_INSNS (41),           /* int_div_di */
 875                        1,           /* branch_cost */
 876                        4            /* memory_latency */
 877     },
 878     { /* 24KX */
 879       COSTS_N_INSNS (4),            /* fp_add */
 880       COSTS_N_INSNS (4),            /* fp_mult_sf */
 881       COSTS_N_INSNS (5),            /* fp_mult_df */
 882       COSTS_N_INSNS (17),           /* fp_div_sf */
 883       COSTS_N_INSNS (32),           /* fp_div_df */
 884       COSTS_N_INSNS (5),            /* int_mult_si */
 885       COSTS_N_INSNS (5),            /* int_mult_di */
 886       COSTS_N_INSNS (41),           /* int_div_si */
 887       COSTS_N_INSNS (41),           /* int_div_di */
 888                        1,           /* branch_cost */
 889                        4            /* memory_latency */
 890     },
 891     { /* M4k */
 892       DEFAULT_COSTS
 893     },
 894     { /* R3900 */
 895       COSTS_N_INSNS (2),            /* fp_add */
 896       COSTS_N_INSNS (4),            /* fp_mult_sf */
 897       COSTS_N_INSNS (5),            /* fp_mult_df */
 898       COSTS_N_INSNS (12),           /* fp_div_sf */
 899       COSTS_N_INSNS (19),           /* fp_div_df */
 900       COSTS_N_INSNS (2),            /* int_mult_si */
 901       COSTS_N_INSNS (2),            /* int_mult_di */
 902       COSTS_N_INSNS (35),           /* int_div_si */
 903       COSTS_N_INSNS (35),           /* int_div_di */
 904                        1,           /* branch_cost */
 905                        4            /* memory_latency */
 906     },
 907     { /* R6000 */
 908       COSTS_N_INSNS (3),            /* fp_add */
 909       COSTS_N_INSNS (5),            /* fp_mult_sf */
 910       COSTS_N_INSNS (6),            /* fp_mult_df */
 911       COSTS_N_INSNS (15),           /* fp_div_sf */
 912       COSTS_N_INSNS (16),           /* fp_div_df */
 913       COSTS_N_INSNS (17),           /* int_mult_si */
 914       COSTS_N_INSNS (17),           /* int_mult_di */
 915       COSTS_N_INSNS (38),           /* int_div_si */
 916       COSTS_N_INSNS (38),           /* int_div_di */
 917                        2,           /* branch_cost */
 918                        6            /* memory_latency */
 919     },
 920     { /* R4000 */
 921        COSTS_N_INSNS (6),           /* fp_add */
 922        COSTS_N_INSNS (7),           /* fp_mult_sf */
 923        COSTS_N_INSNS (8),           /* fp_mult_df */
 924        COSTS_N_INSNS (23),          /* fp_div_sf */
 925        COSTS_N_INSNS (36),          /* fp_div_df */
 926        COSTS_N_INSNS (10),          /* int_mult_si */
 927        COSTS_N_INSNS (10),          /* int_mult_di */
 928        COSTS_N_INSNS (69),          /* int_div_si */
 929        COSTS_N_INSNS (69),          /* int_div_di */
 930                         2,          /* branch_cost */
 931                         6           /* memory_latency */
 932     },
 933     { /* R4100 */
 934       DEFAULT_COSTS
 935     },
 936     { /* R4111 */
 937       DEFAULT_COSTS
 938     },
 939     { /* R4120 */
 940       DEFAULT_COSTS
 941     },
 942     { /* R4130 */
 943       /* The only costs that appear to be updated here are
 944          integer multiplication.  */
 945       SOFT_FP_COSTS,
 946       COSTS_N_INSNS (4),            /* int_mult_si */
 947       COSTS_N_INSNS (6),            /* int_mult_di */
 948       COSTS_N_INSNS (69),           /* int_div_si */
 949       COSTS_N_INSNS (69),           /* int_div_di */
 950                        1,           /* branch_cost */
 951                        4            /* memory_latency */
 952     },
 953     { /* R4300 */
 954       DEFAULT_COSTS
 955     },
 956     { /* R4600 */
 957       DEFAULT_COSTS
 958     },
 959     { /* R4650 */
 960       DEFAULT_COSTS
 961     },
 962     { /* R5000 */
 963       COSTS_N_INSNS (6),            /* fp_add */
 964       COSTS_N_INSNS (4),            /* fp_mult_sf */
 965       COSTS_N_INSNS (5),            /* fp_mult_df */
 966       COSTS_N_INSNS (23),           /* fp_div_sf */
 967       COSTS_N_INSNS (36),           /* fp_div_df */
 968       COSTS_N_INSNS (5),            /* int_mult_si */
 969       COSTS_N_INSNS (5),            /* int_mult_di */
 970       COSTS_N_INSNS (36),           /* int_div_si */
 971       COSTS_N_INSNS (36),           /* int_div_di */
 972                        1,           /* branch_cost */
 973                        4            /* memory_latency */
 974     },
 975     { /* R5400 */
 976       COSTS_N_INSNS (6),            /* fp_add */
 977       COSTS_N_INSNS (5),            /* fp_mult_sf */
 978       COSTS_N_INSNS (6),            /* fp_mult_df */
 979       COSTS_N_INSNS (30),           /* fp_div_sf */
 980       COSTS_N_INSNS (59),           /* fp_div_df */
 981       COSTS_N_INSNS (3),            /* int_mult_si */
 982       COSTS_N_INSNS (4),            /* int_mult_di */
 983       COSTS_N_INSNS (42),           /* int_div_si */
 984       COSTS_N_INSNS (74),           /* int_div_di */
 985                        1,           /* branch_cost */
 986                        4            /* memory_latency */
 987     },
 988     { /* R5500 */
 989       COSTS_N_INSNS (6),            /* fp_add */
 990       COSTS_N_INSNS (5),            /* fp_mult_sf */
 991       COSTS_N_INSNS (6),            /* fp_mult_df */
 992       COSTS_N_INSNS (30),           /* fp_div_sf */
 993       COSTS_N_INSNS (59),           /* fp_div_df */
 994       COSTS_N_INSNS (5),            /* int_mult_si */
 995       COSTS_N_INSNS (9),            /* int_mult_di */
 996       COSTS_N_INSNS (42),           /* int_div_si */
 997       COSTS_N_INSNS (74),           /* int_div_di */
 998                        1,           /* branch_cost */
 999                        4            /* memory_latency */
1000     },
1001     { /* R7000 */
1002       /* The only costs that are changed here are
1003          integer multiplication.  */
1004       COSTS_N_INSNS (6),            /* fp_add */
1005       COSTS_N_INSNS (7),            /* fp_mult_sf */
1006       COSTS_N_INSNS (8),            /* fp_mult_df */
1007       COSTS_N_INSNS (23),           /* fp_div_sf */
1008       COSTS_N_INSNS (36),           /* fp_div_df */
1009       COSTS_N_INSNS (5),            /* int_mult_si */
1010       COSTS_N_INSNS (9),            /* int_mult_di */
1011       COSTS_N_INSNS (69),           /* int_div_si */
1012       COSTS_N_INSNS (69),           /* int_div_di */
1013                        1,           /* branch_cost */
1014                        4            /* memory_latency */
1015     },
1016     { /* R8000 */
1017       DEFAULT_COSTS
1018     },
1019     { /* R9000 */
1020       /* The only costs that are changed here are
1021          integer multiplication.  */
1022       COSTS_N_INSNS (6),            /* fp_add */
1023       COSTS_N_INSNS (7),            /* fp_mult_sf */
1024       COSTS_N_INSNS (8),            /* fp_mult_df */
1025       COSTS_N_INSNS (23),           /* fp_div_sf */
1026       COSTS_N_INSNS (36),           /* fp_div_df */
1027       COSTS_N_INSNS (3),            /* int_mult_si */
1028       COSTS_N_INSNS (8),            /* int_mult_di */
1029       COSTS_N_INSNS (69),           /* int_div_si */
1030       COSTS_N_INSNS (69),           /* int_div_di */
1031                        1,           /* branch_cost */
1032                        4            /* memory_latency */
1033     },
1034     { /* SB1 */
1035       /* These costs are the same as the SB-1A below.  */
1036       COSTS_N_INSNS (4),            /* fp_add */
1037       COSTS_N_INSNS (4),            /* fp_mult_sf */
1038       COSTS_N_INSNS (4),            /* fp_mult_df */
1039       COSTS_N_INSNS (24),           /* fp_div_sf */
1040       COSTS_N_INSNS (32),           /* fp_div_df */
1041       COSTS_N_INSNS (3),            /* int_mult_si */
1042       COSTS_N_INSNS (4),            /* int_mult_di */
1043       COSTS_N_INSNS (36),           /* int_div_si */
1044       COSTS_N_INSNS (68),           /* int_div_di */
1045                        1,           /* branch_cost */
1046                        4            /* memory_latency */
1047     },
1048     { /* SB1-A */
1049       /* These costs are the same as the SB-1 above.  */
1050       COSTS_N_INSNS (4),            /* fp_add */
1051       COSTS_N_INSNS (4),            /* fp_mult_sf */
1052       COSTS_N_INSNS (4),            /* fp_mult_df */
1053       COSTS_N_INSNS (24),           /* fp_div_sf */
1054       COSTS_N_INSNS (32),           /* fp_div_df */
1055       COSTS_N_INSNS (3),            /* int_mult_si */
1056       COSTS_N_INSNS (4),            /* int_mult_di */
1057       COSTS_N_INSNS (36),           /* int_div_si */
1058       COSTS_N_INSNS (68),           /* int_div_di */
1059                        1,           /* branch_cost */
1060                        4            /* memory_latency */
1061     },
1062     { /* SR71000 */
1063       DEFAULT_COSTS
1064     },
1065   };
1066
1067 \f
1068 /* Nonzero if -march should decide the default value of MASK_SOFT_FLOAT.  */
1069 #ifndef MIPS_MARCH_CONTROLS_SOFT_FLOAT
1070 #define MIPS_MARCH_CONTROLS_SOFT_FLOAT 0
1071 #endif
1072 \f
1073 /* Initialize the GCC target structure.  */
1074 #undef TARGET_ASM_ALIGNED_HI_OP
1075 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
1076 #undef TARGET_ASM_ALIGNED_SI_OP
1077 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
1078 #undef TARGET_ASM_ALIGNED_DI_OP
1079 #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t"
1080
1081 #undef TARGET_ASM_FUNCTION_PROLOGUE
1082 #define TARGET_ASM_FUNCTION_PROLOGUE mips_output_function_prologue
1083 #undef TARGET_ASM_FUNCTION_EPILOGUE
1084 #define TARGET_ASM_FUNCTION_EPILOGUE mips_output_function_epilogue
1085 #undef TARGET_ASM_SELECT_RTX_SECTION
1086 #define TARGET_ASM_SELECT_RTX_SECTION mips_select_rtx_section
1087 #undef TARGET_ASM_FUNCTION_RODATA_SECTION
1088 #define TARGET_ASM_FUNCTION_RODATA_SECTION mips_function_rodata_section
1089
1090 #undef TARGET_SCHED_REORDER
1091 #define TARGET_SCHED_REORDER mips_sched_reorder
1092 #undef TARGET_SCHED_VARIABLE_ISSUE
1093 #define TARGET_SCHED_VARIABLE_ISSUE mips_variable_issue
1094 #undef TARGET_SCHED_ADJUST_COST
1095 #define TARGET_SCHED_ADJUST_COST mips_adjust_cost
1096 #undef TARGET_SCHED_ISSUE_RATE
1097 #define TARGET_SCHED_ISSUE_RATE mips_issue_rate
1098 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1099 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
1100   mips_multipass_dfa_lookahead
1101
1102 #undef TARGET_DEFAULT_TARGET_FLAGS
1103 #define TARGET_DEFAULT_TARGET_FLAGS             \
1104   (TARGET_DEFAULT                               \
1105    | TARGET_CPU_DEFAULT                         \
1106    | TARGET_ENDIAN_DEFAULT                      \
1107    | TARGET_FP_EXCEPTIONS_DEFAULT               \
1108    | MASK_CHECK_ZERO_DIV                        \
1109    | MASK_FUSED_MADD)
1110 #undef TARGET_HANDLE_OPTION
1111 #define TARGET_HANDLE_OPTION mips_handle_option
1112
1113 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1114 #define TARGET_FUNCTION_OK_FOR_SIBCALL mips_function_ok_for_sibcall
1115
1116 #undef TARGET_VALID_POINTER_MODE
1117 #define TARGET_VALID_POINTER_MODE mips_valid_pointer_mode
1118 #undef TARGET_RTX_COSTS
1119 #define TARGET_RTX_COSTS mips_rtx_costs
1120 #undef TARGET_ADDRESS_COST
1121 #define TARGET_ADDRESS_COST mips_address_cost
1122
1123 #undef TARGET_IN_SMALL_DATA_P
1124 #define TARGET_IN_SMALL_DATA_P mips_in_small_data_p
1125
1126 #undef TARGET_MACHINE_DEPENDENT_REORG
1127 #define TARGET_MACHINE_DEPENDENT_REORG mips_reorg
1128
1129 #undef TARGET_ASM_FILE_START
1130 #define TARGET_ASM_FILE_START mips_file_start
1131 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
1132 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
1133
1134 #undef TARGET_INIT_LIBFUNCS
1135 #define TARGET_INIT_LIBFUNCS mips_init_libfuncs
1136
1137 #undef TARGET_BUILD_BUILTIN_VA_LIST
1138 #define TARGET_BUILD_BUILTIN_VA_LIST mips_build_builtin_va_list
1139 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1140 #define TARGET_GIMPLIFY_VA_ARG_EXPR mips_gimplify_va_arg_expr
1141
1142 #undef TARGET_PROMOTE_FUNCTION_ARGS
1143 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
1144 #undef TARGET_PROMOTE_FUNCTION_RETURN
1145 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
1146 #undef TARGET_PROMOTE_PROTOTYPES
1147 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
1148
1149 #undef TARGET_RETURN_IN_MEMORY
1150 #define TARGET_RETURN_IN_MEMORY mips_return_in_memory
1151 #undef TARGET_RETURN_IN_MSB
1152 #define TARGET_RETURN_IN_MSB mips_return_in_msb
1153
1154 #undef TARGET_ASM_OUTPUT_MI_THUNK
1155 #define TARGET_ASM_OUTPUT_MI_THUNK mips_output_mi_thunk
1156 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1157 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
1158
1159 #undef TARGET_SETUP_INCOMING_VARARGS
1160 #define TARGET_SETUP_INCOMING_VARARGS mips_setup_incoming_varargs
1161 #undef TARGET_STRICT_ARGUMENT_NAMING
1162 #define TARGET_STRICT_ARGUMENT_NAMING mips_strict_argument_naming
1163 #undef TARGET_MUST_PASS_IN_STACK
1164 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
1165 #undef TARGET_PASS_BY_REFERENCE
1166 #define TARGET_PASS_BY_REFERENCE mips_pass_by_reference
1167 #undef TARGET_CALLEE_COPIES
1168 #define TARGET_CALLEE_COPIES mips_callee_copies
1169 #undef TARGET_ARG_PARTIAL_BYTES
1170 #define TARGET_ARG_PARTIAL_BYTES mips_arg_partial_bytes
1171
1172 #undef TARGET_MODE_REP_EXTENDED
1173 #define TARGET_MODE_REP_EXTENDED mips_mode_rep_extended
1174
1175 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1176 #define TARGET_VECTOR_MODE_SUPPORTED_P mips_vector_mode_supported_p
1177
1178 #undef TARGET_INIT_BUILTINS
1179 #define TARGET_INIT_BUILTINS mips_init_builtins
1180 #undef TARGET_EXPAND_BUILTIN
1181 #define TARGET_EXPAND_BUILTIN mips_expand_builtin
1182
1183 #undef TARGET_HAVE_TLS
1184 #define TARGET_HAVE_TLS HAVE_AS_TLS
1185
1186 #undef TARGET_CANNOT_FORCE_CONST_MEM
1187 #define TARGET_CANNOT_FORCE_CONST_MEM mips_cannot_force_const_mem
1188
1189 #undef TARGET_ENCODE_SECTION_INFO
1190 #define TARGET_ENCODE_SECTION_INFO mips_encode_section_info
1191
1192 #undef TARGET_ATTRIBUTE_TABLE
1193 #define TARGET_ATTRIBUTE_TABLE mips_attribute_table
1194
1195 #undef TARGET_EXTRA_LIVE_ON_ENTRY
1196 #define TARGET_EXTRA_LIVE_ON_ENTRY mips_extra_live_on_entry
1197
1198 #undef TARGET_MIN_ANCHOR_OFFSET
1199 #define TARGET_MIN_ANCHOR_OFFSET -32768
1200 #undef TARGET_MAX_ANCHOR_OFFSET
1201 #define TARGET_MAX_ANCHOR_OFFSET 32767
1202 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1203 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P mips_use_blocks_for_constant_p
1204 #undef TARGET_USE_ANCHORS_FOR_SYMBOL_P
1205 #define TARGET_USE_ANCHORS_FOR_SYMBOL_P mips_use_anchors_for_symbol_p
1206
1207 struct gcc_target targetm = TARGET_INITIALIZER;
1208 \f
1209 /* Classify symbol X, which must be a SYMBOL_REF or a LABEL_REF.  */
1210
1211 static enum mips_symbol_type
1212 mips_classify_symbol (rtx x)
1213 {
1214   tree decl;
1215
1216   if (GET_CODE (x) == LABEL_REF)
1217     {
1218       if (TARGET_MIPS16)
1219         return SYMBOL_CONSTANT_POOL;
1220       if (TARGET_ABICALLS && !TARGET_ABSOLUTE_ABICALLS)
1221         return SYMBOL_GOT_LOCAL;
1222       return SYMBOL_GENERAL;
1223     }
1224
1225   gcc_assert (GET_CODE (x) == SYMBOL_REF);
1226
1227   if (SYMBOL_REF_TLS_MODEL (x))
1228     return SYMBOL_TLS;
1229
1230   if (CONSTANT_POOL_ADDRESS_P (x))
1231     {
1232       if (TARGET_MIPS16)
1233         return SYMBOL_CONSTANT_POOL;
1234
1235       if (GET_MODE_SIZE (get_pool_mode (x)) <= mips_section_threshold)
1236         return SYMBOL_SMALL_DATA;
1237     }
1238
1239   /* Do not use small-data accesses for weak symbols; they may end up
1240      being zero.  */
1241   if (SYMBOL_REF_SMALL_P (x)
1242       && !SYMBOL_REF_WEAK (x))
1243     return SYMBOL_SMALL_DATA;
1244
1245   if (TARGET_ABICALLS)
1246     {
1247       decl = SYMBOL_REF_DECL (x);
1248       if (decl == 0)
1249         {
1250           if (!SYMBOL_REF_LOCAL_P (x))
1251             return SYMBOL_GOT_GLOBAL;
1252         }
1253       else
1254         {
1255           /* Don't use GOT accesses for locally-binding symbols if
1256              TARGET_ABSOLUTE_ABICALLS.  Otherwise, there are three
1257              cases to consider:
1258
1259                 - o32 PIC (either with or without explicit relocs)
1260                 - n32/n64 PIC without explicit relocs
1261                 - n32/n64 PIC with explicit relocs
1262
1263              In the first case, both local and global accesses will use an
1264              R_MIPS_GOT16 relocation.  We must correctly predict which of
1265              the two semantics (local or global) the assembler and linker
1266              will apply.  The choice doesn't depend on the symbol's
1267              visibility, so we deliberately ignore decl_visibility and
1268              binds_local_p here.
1269
1270              In the second case, the assembler will not use R_MIPS_GOT16
1271              relocations, but it chooses between local and global accesses
1272              in the same way as for o32 PIC.
1273
1274              In the third case we have more freedom since both forms of
1275              access will work for any kind of symbol.  However, there seems
1276              little point in doing things differently.
1277
1278              Note that weakref symbols are not TREE_PUBLIC, but their
1279              targets are global or weak symbols.  Relocations in the
1280              object file will be against the target symbol, so it's
1281              that symbol's binding that matters here.  */
1282           if (DECL_P (decl)
1283               && (TREE_PUBLIC (decl) || DECL_WEAK (decl))
1284               && !(TARGET_ABSOLUTE_ABICALLS && targetm.binds_local_p (decl)))
1285             return SYMBOL_GOT_GLOBAL;
1286         }
1287
1288       if (!TARGET_ABSOLUTE_ABICALLS)
1289         return SYMBOL_GOT_LOCAL;
1290     }
1291
1292   return SYMBOL_GENERAL;
1293 }
1294
1295
1296 /* Split X into a base and a constant offset, storing them in *BASE
1297    and *OFFSET respectively.  */
1298
1299 static void
1300 mips_split_const (rtx x, rtx *base, HOST_WIDE_INT *offset)
1301 {
1302   *offset = 0;
1303
1304   if (GET_CODE (x) == CONST)
1305     {
1306       x = XEXP (x, 0);
1307       if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
1308         {
1309           *offset += INTVAL (XEXP (x, 1));
1310           x = XEXP (x, 0);
1311         }
1312     }
1313   *base = x;
1314 }
1315
1316
1317 /* Return true if SYMBOL is a SYMBOL_REF and OFFSET + SYMBOL points
1318    to the same object as SYMBOL, or to the same object_block.  */
1319
1320 static bool
1321 mips_offset_within_object_p (rtx symbol, HOST_WIDE_INT offset)
1322 {
1323   if (GET_CODE (symbol) != SYMBOL_REF)
1324     return false;
1325
1326   if (CONSTANT_POOL_ADDRESS_P (symbol)
1327       && offset >= 0
1328       && offset < (int) GET_MODE_SIZE (get_pool_mode (symbol)))
1329     return true;
1330
1331   if (SYMBOL_REF_DECL (symbol) != 0
1332       && offset >= 0
1333       && offset < int_size_in_bytes (TREE_TYPE (SYMBOL_REF_DECL (symbol))))
1334     return true;
1335
1336   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol)
1337       && SYMBOL_REF_BLOCK (symbol)
1338       && SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0
1339       && ((unsigned HOST_WIDE_INT) offset + SYMBOL_REF_BLOCK_OFFSET (symbol)
1340           < (unsigned HOST_WIDE_INT) SYMBOL_REF_BLOCK (symbol)->size))
1341     return true;
1342
1343   return false;
1344 }
1345
1346
1347 /* Return true if X is a symbolic constant that can be calculated in
1348    the same way as a bare symbol.  If it is, store the type of the
1349    symbol in *SYMBOL_TYPE.  */
1350
1351 bool
1352 mips_symbolic_constant_p (rtx x, enum mips_symbol_type *symbol_type)
1353 {
1354   HOST_WIDE_INT offset;
1355
1356   mips_split_const (x, &x, &offset);
1357   if (UNSPEC_ADDRESS_P (x))
1358     *symbol_type = UNSPEC_ADDRESS_TYPE (x);
1359   else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
1360     {
1361       *symbol_type = mips_classify_symbol (x);
1362       if (*symbol_type == SYMBOL_TLS)
1363         return false;
1364     }
1365   else
1366     return false;
1367
1368   if (offset == 0)
1369     return true;
1370
1371   /* Check whether a nonzero offset is valid for the underlying
1372      relocations.  */
1373   switch (*symbol_type)
1374     {
1375     case SYMBOL_GENERAL:
1376     case SYMBOL_64_HIGH:
1377     case SYMBOL_64_MID:
1378     case SYMBOL_64_LOW:
1379       /* If the target has 64-bit pointers and the object file only
1380          supports 32-bit symbols, the values of those symbols will be
1381          sign-extended.  In this case we can't allow an arbitrary offset
1382          in case the 32-bit value X + OFFSET has a different sign from X.  */
1383       if (Pmode == DImode && !ABI_HAS_64BIT_SYMBOLS)
1384         return mips_offset_within_object_p (x, offset);
1385
1386       /* In other cases the relocations can handle any offset.  */
1387       return true;
1388
1389     case SYMBOL_CONSTANT_POOL:
1390       /* Allow constant pool references to be converted to LABEL+CONSTANT.
1391          In this case, we no longer have access to the underlying constant,
1392          but the original symbol-based access was known to be valid.  */
1393       if (GET_CODE (x) == LABEL_REF)
1394         return true;
1395
1396       /* Fall through.  */
1397
1398     case SYMBOL_SMALL_DATA:
1399       /* Make sure that the offset refers to something within the
1400          underlying object.  This should guarantee that the final
1401          PC- or GP-relative offset is within the 16-bit limit.  */
1402       return mips_offset_within_object_p (x, offset);
1403
1404     case SYMBOL_GOT_LOCAL:
1405     case SYMBOL_GOTOFF_PAGE:
1406       /* The linker should provide enough local GOT entries for a
1407          16-bit offset.  Larger offsets may lead to GOT overflow.  */
1408       return SMALL_OPERAND (offset);
1409
1410     case SYMBOL_GOT_GLOBAL:
1411     case SYMBOL_GOTOFF_GLOBAL:
1412     case SYMBOL_GOTOFF_CALL:
1413     case SYMBOL_GOTOFF_LOADGP:
1414     case SYMBOL_TLSGD:
1415     case SYMBOL_TLSLDM:
1416     case SYMBOL_DTPREL:
1417     case SYMBOL_TPREL:
1418     case SYMBOL_GOTTPREL:
1419     case SYMBOL_TLS:
1420       return false;
1421     }
1422   gcc_unreachable ();
1423 }
1424
1425
1426 /* This function is used to implement REG_MODE_OK_FOR_BASE_P.  */
1427
1428 int
1429 mips_regno_mode_ok_for_base_p (int regno, enum machine_mode mode, int strict)
1430 {
1431   if (!HARD_REGISTER_NUM_P (regno))
1432     {
1433       if (!strict)
1434         return true;
1435       regno = reg_renumber[regno];
1436     }
1437
1438   /* These fake registers will be eliminated to either the stack or
1439      hard frame pointer, both of which are usually valid base registers.
1440      Reload deals with the cases where the eliminated form isn't valid.  */
1441   if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
1442     return true;
1443
1444   /* In mips16 mode, the stack pointer can only address word and doubleword
1445      values, nothing smaller.  There are two problems here:
1446
1447        (a) Instantiating virtual registers can introduce new uses of the
1448            stack pointer.  If these virtual registers are valid addresses,
1449            the stack pointer should be too.
1450
1451        (b) Most uses of the stack pointer are not made explicit until
1452            FRAME_POINTER_REGNUM and ARG_POINTER_REGNUM have been eliminated.
1453            We don't know until that stage whether we'll be eliminating to the
1454            stack pointer (which needs the restriction) or the hard frame
1455            pointer (which doesn't).
1456
1457      All in all, it seems more consistent to only enforce this restriction
1458      during and after reload.  */
1459   if (TARGET_MIPS16 && regno == STACK_POINTER_REGNUM)
1460     return !strict || GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8;
1461
1462   return TARGET_MIPS16 ? M16_REG_P (regno) : GP_REG_P (regno);
1463 }
1464
1465
1466 /* Return true if X is a valid base register for the given mode.
1467    Allow only hard registers if STRICT.  */
1468
1469 static bool
1470 mips_valid_base_register_p (rtx x, enum machine_mode mode, int strict)
1471 {
1472   if (!strict && GET_CODE (x) == SUBREG)
1473     x = SUBREG_REG (x);
1474
1475   return (REG_P (x)
1476           && mips_regno_mode_ok_for_base_p (REGNO (x), mode, strict));
1477 }
1478
1479
1480 /* Return true if symbols of type SYMBOL_TYPE can directly address a value
1481    with mode MODE.  This is used for both symbolic and LO_SUM addresses.  */
1482
1483 static bool
1484 mips_symbolic_address_p (enum mips_symbol_type symbol_type,
1485                          enum machine_mode mode)
1486 {
1487   switch (symbol_type)
1488     {
1489     case SYMBOL_GENERAL:
1490       return !TARGET_MIPS16;
1491
1492     case SYMBOL_SMALL_DATA:
1493       return true;
1494
1495     case SYMBOL_CONSTANT_POOL:
1496       /* PC-relative addressing is only available for lw and ld.  */
1497       return GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8;
1498
1499     case SYMBOL_GOT_LOCAL:
1500       return true;
1501
1502     case SYMBOL_GOT_GLOBAL:
1503       /* The address will have to be loaded from the GOT first.  */
1504       return false;
1505
1506     case SYMBOL_GOTOFF_PAGE:
1507     case SYMBOL_GOTOFF_GLOBAL:
1508     case SYMBOL_GOTOFF_CALL:
1509     case SYMBOL_GOTOFF_LOADGP:
1510     case SYMBOL_TLS:
1511     case SYMBOL_TLSGD:
1512     case SYMBOL_TLSLDM:
1513     case SYMBOL_DTPREL:
1514     case SYMBOL_GOTTPREL:
1515     case SYMBOL_TPREL:
1516     case SYMBOL_64_HIGH:
1517     case SYMBOL_64_MID:
1518     case SYMBOL_64_LOW:
1519       return true;
1520     }
1521   gcc_unreachable ();
1522 }
1523
1524
1525 /* Return true if X is a valid address for machine mode MODE.  If it is,
1526    fill in INFO appropriately.  STRICT is true if we should only accept
1527    hard base registers.  */
1528
1529 static bool
1530 mips_classify_address (struct mips_address_info *info, rtx x,
1531                        enum machine_mode mode, int strict)
1532 {
1533   switch (GET_CODE (x))
1534     {
1535     case REG:
1536     case SUBREG:
1537       info->type = ADDRESS_REG;
1538       info->reg = x;
1539       info->offset = const0_rtx;
1540       return mips_valid_base_register_p (info->reg, mode, strict);
1541
1542     case PLUS:
1543       info->type = ADDRESS_REG;
1544       info->reg = XEXP (x, 0);
1545       info->offset = XEXP (x, 1);
1546       return (mips_valid_base_register_p (info->reg, mode, strict)
1547               && const_arith_operand (info->offset, VOIDmode));
1548
1549     case LO_SUM:
1550       info->type = ADDRESS_LO_SUM;
1551       info->reg = XEXP (x, 0);
1552       info->offset = XEXP (x, 1);
1553       return (mips_valid_base_register_p (info->reg, mode, strict)
1554               && mips_symbolic_constant_p (info->offset, &info->symbol_type)
1555               && mips_symbolic_address_p (info->symbol_type, mode)
1556               && mips_lo_relocs[info->symbol_type] != 0);
1557
1558     case CONST_INT:
1559       /* Small-integer addresses don't occur very often, but they
1560          are legitimate if $0 is a valid base register.  */
1561       info->type = ADDRESS_CONST_INT;
1562       return !TARGET_MIPS16 && SMALL_INT (x);
1563
1564     case CONST:
1565     case LABEL_REF:
1566     case SYMBOL_REF:
1567       info->type = ADDRESS_SYMBOLIC;
1568       return (mips_symbolic_constant_p (x, &info->symbol_type)
1569               && mips_symbolic_address_p (info->symbol_type, mode)
1570               && !mips_split_p[info->symbol_type]);
1571
1572     default:
1573       return false;
1574     }
1575 }
1576
1577 /* Return true if X is a thread-local symbol.  */
1578
1579 static bool
1580 mips_tls_operand_p (rtx x)
1581 {
1582   return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
1583 }
1584
1585 /* Return true if X can not be forced into a constant pool.  */
1586
1587 static int
1588 mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1589 {
1590   return mips_tls_operand_p (*x);
1591 }
1592
1593 /* Return true if X can not be forced into a constant pool.  */
1594
1595 static bool
1596 mips_cannot_force_const_mem (rtx x)
1597 {
1598   rtx base;
1599   HOST_WIDE_INT offset;
1600
1601   if (!TARGET_MIPS16)
1602     {
1603       /* As an optimization, reject constants that mips_legitimize_move
1604          can expand inline.
1605
1606          Suppose we have a multi-instruction sequence that loads constant C
1607          into register R.  If R does not get allocated a hard register, and
1608          R is used in an operand that allows both registers and memory
1609          references, reload will consider forcing C into memory and using
1610          one of the instruction's memory alternatives.  Returning false
1611          here will force it to use an input reload instead.  */
1612       if (GET_CODE (x) == CONST_INT)
1613         return true;
1614
1615       mips_split_const (x, &base, &offset);
1616       if (symbolic_operand (base, VOIDmode) && SMALL_OPERAND (offset))
1617         return true;
1618     }
1619
1620   if (TARGET_HAVE_TLS && for_each_rtx (&x, &mips_tls_symbol_ref_1, 0))
1621     return true;
1622
1623   return false;
1624 }
1625
1626 /* Implement TARGET_USE_BLOCKS_FOR_CONSTANT_P.  MIPS16 uses per-function
1627    constant pools, but normal-mode code doesn't need to.  */
1628
1629 static bool
1630 mips_use_blocks_for_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED,
1631                                 rtx x ATTRIBUTE_UNUSED)
1632 {
1633   return !TARGET_MIPS16;
1634 }
1635 \f
1636 /* Return the number of instructions needed to load a symbol of the
1637    given type into a register.  If valid in an address, the same number
1638    of instructions are needed for loads and stores.  Treat extended
1639    mips16 instructions as two instructions.  */
1640
1641 static int
1642 mips_symbol_insns (enum mips_symbol_type type)
1643 {
1644   switch (type)
1645     {
1646     case SYMBOL_GENERAL:
1647       /* In mips16 code, general symbols must be fetched from the
1648          constant pool.  */
1649       if (TARGET_MIPS16)
1650         return 0;
1651
1652       /* When using 64-bit symbols, we need 5 preparatory instructions,
1653          such as:
1654
1655              lui     $at,%highest(symbol)
1656              daddiu  $at,$at,%higher(symbol)
1657              dsll    $at,$at,16
1658              daddiu  $at,$at,%hi(symbol)
1659              dsll    $at,$at,16
1660
1661          The final address is then $at + %lo(symbol).  With 32-bit
1662          symbols we just need a preparatory lui.  */
1663       return (ABI_HAS_64BIT_SYMBOLS ? 6 : 2);
1664
1665     case SYMBOL_SMALL_DATA:
1666       return 1;
1667
1668     case SYMBOL_CONSTANT_POOL:
1669       /* This case is for mips16 only.  Assume we'll need an
1670          extended instruction.  */
1671       return 2;
1672
1673     case SYMBOL_GOT_LOCAL:
1674     case SYMBOL_GOT_GLOBAL:
1675       /* Unless -funit-at-a-time is in effect, we can't be sure whether
1676          the local/global classification is accurate.  See override_options
1677          for details.
1678
1679          The worst cases are:
1680
1681          (1) For local symbols when generating o32 or o64 code.  The assembler
1682              will use:
1683
1684                  lw           $at,%got(symbol)
1685                  nop
1686
1687              ...and the final address will be $at + %lo(symbol).
1688
1689          (2) For global symbols when -mxgot.  The assembler will use:
1690
1691                  lui     $at,%got_hi(symbol)
1692                  (d)addu $at,$at,$gp
1693
1694              ...and the final address will be $at + %got_lo(symbol).  */
1695       return 3;
1696
1697     case SYMBOL_GOTOFF_PAGE:
1698     case SYMBOL_GOTOFF_GLOBAL:
1699     case SYMBOL_GOTOFF_CALL:
1700     case SYMBOL_GOTOFF_LOADGP:
1701     case SYMBOL_64_HIGH:
1702     case SYMBOL_64_MID:
1703     case SYMBOL_64_LOW:
1704     case SYMBOL_TLSGD:
1705     case SYMBOL_TLSLDM:
1706     case SYMBOL_DTPREL:
1707     case SYMBOL_GOTTPREL:
1708     case SYMBOL_TPREL:
1709       /* Check whether the offset is a 16- or 32-bit value.  */
1710       return mips_split_p[type] ? 2 : 1;
1711
1712     case SYMBOL_TLS:
1713       /* We don't treat a bare TLS symbol as a constant.  */
1714       return 0;
1715     }
1716   gcc_unreachable ();
1717 }
1718
1719 /* Return true if X is a legitimate $sp-based address for mode MDOE.  */
1720
1721 bool
1722 mips_stack_address_p (rtx x, enum machine_mode mode)
1723 {
1724   struct mips_address_info addr;
1725
1726   return (mips_classify_address (&addr, x, mode, false)
1727           && addr.type == ADDRESS_REG
1728           && addr.reg == stack_pointer_rtx);
1729 }
1730
1731 /* Return true if a value at OFFSET bytes from BASE can be accessed
1732    using an unextended mips16 instruction.  MODE is the mode of the
1733    value.
1734
1735    Usually the offset in an unextended instruction is a 5-bit field.
1736    The offset is unsigned and shifted left once for HIs, twice
1737    for SIs, and so on.  An exception is SImode accesses off the
1738    stack pointer, which have an 8-bit immediate field.  */
1739
1740 static bool
1741 mips16_unextended_reference_p (enum machine_mode mode, rtx base, rtx offset)
1742 {
1743   if (TARGET_MIPS16
1744       && GET_CODE (offset) == CONST_INT
1745       && INTVAL (offset) >= 0
1746       && (INTVAL (offset) & (GET_MODE_SIZE (mode) - 1)) == 0)
1747     {
1748       if (GET_MODE_SIZE (mode) == 4 && base == stack_pointer_rtx)
1749         return INTVAL (offset) < 256 * GET_MODE_SIZE (mode);
1750       return INTVAL (offset) < 32 * GET_MODE_SIZE (mode);
1751     }
1752   return false;
1753 }
1754
1755
1756 /* Return the number of instructions needed to load or store a value
1757    of mode MODE at X.  Return 0 if X isn't valid for MODE.
1758
1759    For mips16 code, count extended instructions as two instructions.  */
1760
1761 int
1762 mips_address_insns (rtx x, enum machine_mode mode)
1763 {
1764   struct mips_address_info addr;
1765   int factor;
1766
1767   if (mode == BLKmode)
1768     /* BLKmode is used for single unaligned loads and stores.  */
1769     factor = 1;
1770   else
1771     /* Each word of a multi-word value will be accessed individually.  */
1772     factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1773
1774   if (mips_classify_address (&addr, x, mode, false))
1775     switch (addr.type)
1776       {
1777       case ADDRESS_REG:
1778         if (TARGET_MIPS16
1779             && !mips16_unextended_reference_p (mode, addr.reg, addr.offset))
1780           return factor * 2;
1781         return factor;
1782
1783       case ADDRESS_LO_SUM:
1784         return (TARGET_MIPS16 ? factor * 2 : factor);
1785
1786       case ADDRESS_CONST_INT:
1787         return factor;
1788
1789       case ADDRESS_SYMBOLIC:
1790         return factor * mips_symbol_insns (addr.symbol_type);
1791       }
1792   return 0;
1793 }
1794
1795
1796 /* Likewise for constant X.  */
1797
1798 int
1799 mips_const_insns (rtx x)
1800 {
1801   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
1802   enum mips_symbol_type symbol_type;
1803   HOST_WIDE_INT offset;
1804
1805   switch (GET_CODE (x))
1806     {
1807     case HIGH:
1808       if (TARGET_MIPS16
1809           || !mips_symbolic_constant_p (XEXP (x, 0), &symbol_type)
1810           || !mips_split_p[symbol_type])
1811         return 0;
1812
1813       return 1;
1814
1815     case CONST_INT:
1816       if (TARGET_MIPS16)
1817         /* Unsigned 8-bit constants can be loaded using an unextended
1818            LI instruction.  Unsigned 16-bit constants can be loaded
1819            using an extended LI.  Negative constants must be loaded
1820            using LI and then negated.  */
1821         return (INTVAL (x) >= 0 && INTVAL (x) < 256 ? 1
1822                 : SMALL_OPERAND_UNSIGNED (INTVAL (x)) ? 2
1823                 : INTVAL (x) > -256 && INTVAL (x) < 0 ? 2
1824                 : SMALL_OPERAND_UNSIGNED (-INTVAL (x)) ? 3
1825                 : 0);
1826
1827       return mips_build_integer (codes, INTVAL (x));
1828
1829     case CONST_DOUBLE:
1830     case CONST_VECTOR:
1831       return (!TARGET_MIPS16 && x == CONST0_RTX (GET_MODE (x)) ? 1 : 0);
1832
1833     case CONST:
1834       if (CONST_GP_P (x))
1835         return 1;
1836
1837       /* See if we can refer to X directly.  */
1838       if (mips_symbolic_constant_p (x, &symbol_type))
1839         return mips_symbol_insns (symbol_type);
1840
1841       /* Otherwise try splitting the constant into a base and offset.
1842          16-bit offsets can be added using an extra addiu.  Larger offsets
1843          must be calculated separately and then added to the base.  */
1844       mips_split_const (x, &x, &offset);
1845       if (offset != 0)
1846         {
1847           int n = mips_const_insns (x);
1848           if (n != 0)
1849             {
1850               if (SMALL_OPERAND (offset))
1851                 return n + 1;
1852               else
1853                 return n + 1 + mips_build_integer (codes, offset);
1854             }
1855         }
1856       return 0;
1857
1858     case SYMBOL_REF:
1859     case LABEL_REF:
1860       return mips_symbol_insns (mips_classify_symbol (x));
1861
1862     default:
1863       return 0;
1864     }
1865 }
1866
1867
1868 /* Return the number of instructions needed for memory reference X.
1869    Count extended mips16 instructions as two instructions.  */
1870
1871 int
1872 mips_fetch_insns (rtx x)
1873 {
1874   gcc_assert (MEM_P (x));
1875   return mips_address_insns (XEXP (x, 0), GET_MODE (x));
1876 }
1877
1878
1879 /* Return the number of instructions needed for an integer division.  */
1880
1881 int
1882 mips_idiv_insns (void)
1883 {
1884   int count;
1885
1886   count = 1;
1887   if (TARGET_CHECK_ZERO_DIV)
1888     {
1889       if (GENERATE_DIVIDE_TRAPS)
1890         count++;
1891       else
1892         count += 2;
1893     }
1894
1895   if (TARGET_FIX_R4000 || TARGET_FIX_R4400)
1896     count++;
1897   return count;
1898 }
1899 \f
1900 /* This function is used to implement GO_IF_LEGITIMATE_ADDRESS.  It
1901    returns a nonzero value if X is a legitimate address for a memory
1902    operand of the indicated MODE.  STRICT is nonzero if this function
1903    is called during reload.  */
1904
1905 bool
1906 mips_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
1907 {
1908   struct mips_address_info addr;
1909
1910   return mips_classify_address (&addr, x, mode, strict);
1911 }
1912
1913
1914 /* Copy VALUE to a register and return that register.  If new psuedos
1915    are allowed, copy it into a new register, otherwise use DEST.  */
1916
1917 static rtx
1918 mips_force_temporary (rtx dest, rtx value)
1919 {
1920   if (!no_new_pseudos)
1921     return force_reg (Pmode, value);
1922   else
1923     {
1924       emit_move_insn (copy_rtx (dest), value);
1925       return dest;
1926     }
1927 }
1928
1929
1930 /* Return a LO_SUM expression for ADDR.  TEMP is as for mips_force_temporary
1931    and is used to load the high part into a register.  */
1932
1933 rtx
1934 mips_split_symbol (rtx temp, rtx addr)
1935 {
1936   rtx high;
1937
1938   if (TARGET_MIPS16)
1939     high = mips16_gp_pseudo_reg ();
1940   else
1941     high = mips_force_temporary (temp, gen_rtx_HIGH (Pmode, copy_rtx (addr)));
1942   return gen_rtx_LO_SUM (Pmode, high, addr);
1943 }
1944
1945
1946 /* Return an UNSPEC address with underlying address ADDRESS and symbol
1947    type SYMBOL_TYPE.  */
1948
1949 rtx
1950 mips_unspec_address (rtx address, enum mips_symbol_type symbol_type)
1951 {
1952   rtx base;
1953   HOST_WIDE_INT offset;
1954
1955   mips_split_const (address, &base, &offset);
1956   base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base),
1957                          UNSPEC_ADDRESS_FIRST + symbol_type);
1958   return plus_constant (gen_rtx_CONST (Pmode, base), offset);
1959 }
1960
1961
1962 /* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the
1963    high part to BASE and return the result.  Just return BASE otherwise.
1964    TEMP is available as a temporary register if needed.
1965
1966    The returned expression can be used as the first operand to a LO_SUM.  */
1967
1968 static rtx
1969 mips_unspec_offset_high (rtx temp, rtx base, rtx addr,
1970                          enum mips_symbol_type symbol_type)
1971 {
1972   if (mips_split_p[symbol_type])
1973     {
1974       addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type));
1975       addr = mips_force_temporary (temp, addr);
1976       return mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base));
1977     }
1978   return base;
1979 }
1980
1981
1982 /* Return a legitimate address for REG + OFFSET.  TEMP is as for
1983    mips_force_temporary; it is only needed when OFFSET is not a
1984    SMALL_OPERAND.  */
1985
1986 static rtx
1987 mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
1988 {
1989   if (!SMALL_OPERAND (offset))
1990     {
1991       rtx high;
1992       if (TARGET_MIPS16)
1993         {
1994           /* Load the full offset into a register so that we can use
1995              an unextended instruction for the address itself.  */
1996           high = GEN_INT (offset);
1997           offset = 0;
1998         }
1999       else
2000         {
2001           /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.  */
2002           high = GEN_INT (CONST_HIGH_PART (offset));
2003           offset = CONST_LOW_PART (offset);
2004         }
2005       high = mips_force_temporary (temp, high);
2006       reg = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, high, reg));
2007     }
2008   return plus_constant (reg, offset);
2009 }
2010
2011 /* Emit a call to __tls_get_addr.  SYM is the TLS symbol we are
2012    referencing, and TYPE is the symbol type to use (either global
2013    dynamic or local dynamic).  V0 is an RTX for the return value
2014    location.  The entire insn sequence is returned.  */
2015
2016 static GTY(()) rtx mips_tls_symbol;
2017
2018 static rtx
2019 mips_call_tls_get_addr (rtx sym, enum mips_symbol_type type, rtx v0)
2020 {
2021   rtx insn, loc, tga, a0;
2022
2023   a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST);
2024
2025   if (!mips_tls_symbol)
2026     mips_tls_symbol = init_one_libfunc ("__tls_get_addr");
2027
2028   loc = mips_unspec_address (sym, type);
2029
2030   start_sequence ();
2031
2032   emit_insn (gen_rtx_SET (Pmode, a0,
2033                           gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, loc)));
2034   tga = gen_rtx_MEM (Pmode, mips_tls_symbol);
2035   insn = emit_call_insn (gen_call_value (v0, tga, const0_rtx, const0_rtx));
2036   CONST_OR_PURE_CALL_P (insn) = 1;
2037   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), v0);
2038   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
2039   insn = get_insns ();
2040
2041   end_sequence ();
2042
2043   return insn;
2044 }
2045
2046 /* Generate the code to access LOC, a thread local SYMBOL_REF.  The
2047    return value will be a valid address and move_operand (either a REG
2048    or a LO_SUM).  */
2049
2050 static rtx
2051 mips_legitimize_tls_address (rtx loc)
2052 {
2053   rtx dest, insn, v0, v1, tmp1, tmp2, eqv;
2054   enum tls_model model;
2055
2056   v0 = gen_rtx_REG (Pmode, GP_RETURN);
2057   v1 = gen_rtx_REG (Pmode, GP_RETURN + 1);
2058
2059   model = SYMBOL_REF_TLS_MODEL (loc);
2060   /* Only TARGET_ABICALLS code can have more than one module; other
2061      code must be be static and should not use a GOT.  All TLS models
2062      reduce to local exec in this situation.  */
2063   if (!TARGET_ABICALLS)
2064     model = TLS_MODEL_LOCAL_EXEC;
2065
2066   switch (model)
2067     {
2068     case TLS_MODEL_GLOBAL_DYNAMIC:
2069       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSGD, v0);
2070       dest = gen_reg_rtx (Pmode);
2071       emit_libcall_block (insn, dest, v0, loc);
2072       break;
2073
2074     case TLS_MODEL_LOCAL_DYNAMIC:
2075       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSLDM, v0);
2076       tmp1 = gen_reg_rtx (Pmode);
2077
2078       /* Attach a unique REG_EQUIV, to allow the RTL optimizers to
2079          share the LDM result with other LD model accesses.  */
2080       eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
2081                             UNSPEC_TLS_LDM);
2082       emit_libcall_block (insn, tmp1, v0, eqv);
2083
2084       tmp2 = mips_unspec_offset_high (NULL, tmp1, loc, SYMBOL_DTPREL);
2085       dest = gen_rtx_LO_SUM (Pmode, tmp2,
2086                              mips_unspec_address (loc, SYMBOL_DTPREL));
2087       break;
2088
2089     case TLS_MODEL_INITIAL_EXEC:
2090       tmp1 = gen_reg_rtx (Pmode);
2091       tmp2 = mips_unspec_address (loc, SYMBOL_GOTTPREL);
2092       if (Pmode == DImode)
2093         {
2094           emit_insn (gen_tls_get_tp_di (v1));
2095           emit_insn (gen_load_gotdi (tmp1, pic_offset_table_rtx, tmp2));
2096         }
2097       else
2098         {
2099           emit_insn (gen_tls_get_tp_si (v1));
2100           emit_insn (gen_load_gotsi (tmp1, pic_offset_table_rtx, tmp2));
2101         }
2102       dest = gen_reg_rtx (Pmode);
2103       emit_insn (gen_add3_insn (dest, tmp1, v1));
2104       break;
2105
2106     case TLS_MODEL_LOCAL_EXEC:
2107       if (Pmode == DImode)
2108         emit_insn (gen_tls_get_tp_di (v1));
2109       else
2110         emit_insn (gen_tls_get_tp_si (v1));
2111
2112       tmp1 = mips_unspec_offset_high (NULL, v1, loc, SYMBOL_TPREL);
2113       dest = gen_rtx_LO_SUM (Pmode, tmp1,
2114                              mips_unspec_address (loc, SYMBOL_TPREL));
2115       break;
2116
2117     default:
2118       gcc_unreachable ();
2119     }
2120
2121   return dest;
2122 }
2123
2124 /* This function is used to implement LEGITIMIZE_ADDRESS.  If *XLOC can
2125    be legitimized in a way that the generic machinery might not expect,
2126    put the new address in *XLOC and return true.  MODE is the mode of
2127    the memory being accessed.  */
2128
2129 bool
2130 mips_legitimize_address (rtx *xloc, enum machine_mode mode)
2131 {
2132   enum mips_symbol_type symbol_type;
2133
2134   if (mips_tls_operand_p (*xloc))
2135     {
2136       *xloc = mips_legitimize_tls_address (*xloc);
2137       return true;
2138     }
2139
2140   /* See if the address can split into a high part and a LO_SUM.  */
2141   if (mips_symbolic_constant_p (*xloc, &symbol_type)
2142       && mips_symbolic_address_p (symbol_type, mode)
2143       && mips_split_p[symbol_type])
2144     {
2145       *xloc = mips_split_symbol (0, *xloc);
2146       return true;
2147     }
2148
2149   if (GET_CODE (*xloc) == PLUS && GET_CODE (XEXP (*xloc, 1)) == CONST_INT)
2150     {
2151       /* Handle REG + CONSTANT using mips_add_offset.  */
2152       rtx reg;
2153
2154       reg = XEXP (*xloc, 0);
2155       if (!mips_valid_base_register_p (reg, mode, 0))
2156         reg = copy_to_mode_reg (Pmode, reg);
2157       *xloc = mips_add_offset (0, reg, INTVAL (XEXP (*xloc, 1)));
2158       return true;
2159     }
2160
2161   return false;
2162 }
2163
2164
2165 /* Subroutine of mips_build_integer (with the same interface).
2166    Assume that the final action in the sequence should be a left shift.  */
2167
2168 static unsigned int
2169 mips_build_shift (struct mips_integer_op *codes, HOST_WIDE_INT value)
2170 {
2171   unsigned int i, shift;
2172
2173   /* Shift VALUE right until its lowest bit is set.  Shift arithmetically
2174      since signed numbers are easier to load than unsigned ones.  */
2175   shift = 0;
2176   while ((value & 1) == 0)
2177     value /= 2, shift++;
2178
2179   i = mips_build_integer (codes, value);
2180   codes[i].code = ASHIFT;
2181   codes[i].value = shift;
2182   return i + 1;
2183 }
2184
2185
2186 /* As for mips_build_shift, but assume that the final action will be
2187    an IOR or PLUS operation.  */
2188
2189 static unsigned int
2190 mips_build_lower (struct mips_integer_op *codes, unsigned HOST_WIDE_INT value)
2191 {
2192   unsigned HOST_WIDE_INT high;
2193   unsigned int i;
2194
2195   high = value & ~(unsigned HOST_WIDE_INT) 0xffff;
2196   if (!LUI_OPERAND (high) && (value & 0x18000) == 0x18000)
2197     {
2198       /* The constant is too complex to load with a simple lui/ori pair
2199          so our goal is to clear as many trailing zeros as possible.
2200          In this case, we know bit 16 is set and that the low 16 bits
2201          form a negative number.  If we subtract that number from VALUE,
2202          we will clear at least the lowest 17 bits, maybe more.  */
2203       i = mips_build_integer (codes, CONST_HIGH_PART (value));
2204       codes[i].code = PLUS;
2205       codes[i].value = CONST_LOW_PART (value);
2206     }
2207   else
2208     {
2209       i = mips_build_integer (codes, high);
2210       codes[i].code = IOR;
2211       codes[i].value = value & 0xffff;
2212     }
2213   return i + 1;
2214 }
2215
2216
2217 /* Fill CODES with a sequence of rtl operations to load VALUE.
2218    Return the number of operations needed.  */
2219
2220 static unsigned int
2221 mips_build_integer (struct mips_integer_op *codes,
2222                     unsigned HOST_WIDE_INT value)
2223 {
2224   if (SMALL_OPERAND (value)
2225       || SMALL_OPERAND_UNSIGNED (value)
2226       || LUI_OPERAND (value))
2227     {
2228       /* The value can be loaded with a single instruction.  */
2229       codes[0].code = UNKNOWN;
2230       codes[0].value = value;
2231       return 1;
2232     }
2233   else if ((value & 1) != 0 || LUI_OPERAND (CONST_HIGH_PART (value)))
2234     {
2235       /* Either the constant is a simple LUI/ORI combination or its
2236          lowest bit is set.  We don't want to shift in this case.  */
2237       return mips_build_lower (codes, value);
2238     }
2239   else if ((value & 0xffff) == 0)
2240     {
2241       /* The constant will need at least three actions.  The lowest
2242          16 bits are clear, so the final action will be a shift.  */
2243       return mips_build_shift (codes, value);
2244     }
2245   else
2246     {
2247       /* The final action could be a shift, add or inclusive OR.
2248          Rather than use a complex condition to select the best
2249          approach, try both mips_build_shift and mips_build_lower
2250          and pick the one that gives the shortest sequence.
2251          Note that this case is only used once per constant.  */
2252       struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
2253       unsigned int cost, alt_cost;
2254
2255       cost = mips_build_shift (codes, value);
2256       alt_cost = mips_build_lower (alt_codes, value);
2257       if (alt_cost < cost)
2258         {
2259           memcpy (codes, alt_codes, alt_cost * sizeof (codes[0]));
2260           cost = alt_cost;
2261         }
2262       return cost;
2263     }
2264 }
2265
2266
2267 /* Load VALUE into DEST, using TEMP as a temporary register if need be.  */
2268
2269 void
2270 mips_move_integer (rtx dest, rtx temp, unsigned HOST_WIDE_INT value)
2271 {
2272   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2273   enum machine_mode mode;
2274   unsigned int i, cost;
2275   rtx x;
2276
2277   mode = GET_MODE (dest);
2278   cost = mips_build_integer (codes, value);
2279
2280   /* Apply each binary operation to X.  Invariant: X is a legitimate
2281      source operand for a SET pattern.  */
2282   x = GEN_INT (codes[0].value);
2283   for (i = 1; i < cost; i++)
2284     {
2285       if (no_new_pseudos)
2286         {
2287           emit_insn (gen_rtx_SET (VOIDmode, temp, x));
2288           x = temp;
2289         }
2290       else
2291         x = force_reg (mode, x);
2292       x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
2293     }
2294
2295   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
2296 }
2297
2298
2299 /* Subroutine of mips_legitimize_move.  Move constant SRC into register
2300    DEST given that SRC satisfies immediate_operand but doesn't satisfy
2301    move_operand.  */
2302
2303 static void
2304 mips_legitimize_const_move (enum machine_mode mode, rtx dest, rtx src)
2305 {
2306   rtx base;
2307   HOST_WIDE_INT offset;
2308
2309   /* Split moves of big integers into smaller pieces.  */
2310   if (splittable_const_int_operand (src, mode))
2311     {
2312       mips_move_integer (dest, dest, INTVAL (src));
2313       return;
2314     }
2315
2316   /* Split moves of symbolic constants into high/low pairs.  */
2317   if (splittable_symbolic_operand (src, mode))
2318     {
2319       emit_insn (gen_rtx_SET (VOIDmode, dest, mips_split_symbol (dest, src)));
2320       return;
2321     }
2322
2323   if (mips_tls_operand_p (src))
2324     {
2325       emit_move_insn (dest, mips_legitimize_tls_address (src));
2326       return;
2327     }
2328
2329   /* If we have (const (plus symbol offset)), load the symbol first
2330      and then add in the offset.  This is usually better than forcing
2331      the constant into memory, at least in non-mips16 code.  */
2332   mips_split_const (src, &base, &offset);
2333   if (!TARGET_MIPS16
2334       && offset != 0
2335       && (!no_new_pseudos || SMALL_OPERAND (offset)))
2336     {
2337       base = mips_force_temporary (dest, base);
2338       emit_move_insn (dest, mips_add_offset (0, base, offset));
2339       return;
2340     }
2341
2342   src = force_const_mem (mode, src);
2343
2344   /* When using explicit relocs, constant pool references are sometimes
2345      not legitimate addresses.  */
2346   if (!memory_operand (src, VOIDmode))
2347     src = replace_equiv_address (src, mips_split_symbol (dest, XEXP (src, 0)));
2348   emit_move_insn (dest, src);
2349 }
2350
2351
2352 /* If (set DEST SRC) is not a valid instruction, emit an equivalent
2353    sequence that is valid.  */
2354
2355 bool
2356 mips_legitimize_move (enum machine_mode mode, rtx dest, rtx src)
2357 {
2358   if (!register_operand (dest, mode) && !reg_or_0_operand (src, mode))
2359     {
2360       emit_move_insn (dest, force_reg (mode, src));
2361       return true;
2362     }
2363
2364   /* Check for individual, fully-reloaded mflo and mfhi instructions.  */
2365   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
2366       && REG_P (src) && MD_REG_P (REGNO (src))
2367       && REG_P (dest) && GP_REG_P (REGNO (dest)))
2368     {
2369       int other_regno = REGNO (src) == HI_REGNUM ? LO_REGNUM : HI_REGNUM;
2370       if (GET_MODE_SIZE (mode) <= 4)
2371         emit_insn (gen_mfhilo_si (gen_rtx_REG (SImode, REGNO (dest)),
2372                                   gen_rtx_REG (SImode, REGNO (src)),
2373                                   gen_rtx_REG (SImode, other_regno)));
2374       else
2375         emit_insn (gen_mfhilo_di (gen_rtx_REG (DImode, REGNO (dest)),
2376                                   gen_rtx_REG (DImode, REGNO (src)),
2377                                   gen_rtx_REG (DImode, other_regno)));
2378       return true;
2379     }
2380
2381   /* We need to deal with constants that would be legitimate
2382      immediate_operands but not legitimate move_operands.  */
2383   if (CONSTANT_P (src) && !move_operand (src, mode))
2384     {
2385       mips_legitimize_const_move (mode, dest, src);
2386       set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (src));
2387       return true;
2388     }
2389   return false;
2390 }
2391 \f
2392 /* We need a lot of little routines to check constant values on the
2393    mips16.  These are used to figure out how long the instruction will
2394    be.  It would be much better to do this using constraints, but
2395    there aren't nearly enough letters available.  */
2396
2397 static int
2398 m16_check_op (rtx op, int low, int high, int mask)
2399 {
2400   return (GET_CODE (op) == CONST_INT
2401           && INTVAL (op) >= low
2402           && INTVAL (op) <= high
2403           && (INTVAL (op) & mask) == 0);
2404 }
2405
2406 int
2407 m16_uimm3_b (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2408 {
2409   return m16_check_op (op, 0x1, 0x8, 0);
2410 }
2411
2412 int
2413 m16_simm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2414 {
2415   return m16_check_op (op, - 0x8, 0x7, 0);
2416 }
2417
2418 int
2419 m16_nsimm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2420 {
2421   return m16_check_op (op, - 0x7, 0x8, 0);
2422 }
2423
2424 int
2425 m16_simm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2426 {
2427   return m16_check_op (op, - 0x10, 0xf, 0);
2428 }
2429
2430 int
2431 m16_nsimm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2432 {
2433   return m16_check_op (op, - 0xf, 0x10, 0);
2434 }
2435
2436 int
2437 m16_uimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2438 {
2439   return m16_check_op (op, (- 0x10) << 2, 0xf << 2, 3);
2440 }
2441
2442 int
2443 m16_nuimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2444 {
2445   return m16_check_op (op, (- 0xf) << 2, 0x10 << 2, 3);
2446 }
2447
2448 int
2449 m16_simm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2450 {
2451   return m16_check_op (op, - 0x80, 0x7f, 0);
2452 }
2453
2454 int
2455 m16_nsimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2456 {
2457   return m16_check_op (op, - 0x7f, 0x80, 0);
2458 }
2459
2460 int
2461 m16_uimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2462 {
2463   return m16_check_op (op, 0x0, 0xff, 0);
2464 }
2465
2466 int
2467 m16_nuimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2468 {
2469   return m16_check_op (op, - 0xff, 0x0, 0);
2470 }
2471
2472 int
2473 m16_uimm8_m1_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2474 {
2475   return m16_check_op (op, - 0x1, 0xfe, 0);
2476 }
2477
2478 int
2479 m16_uimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2480 {
2481   return m16_check_op (op, 0x0, 0xff << 2, 3);
2482 }
2483
2484 int
2485 m16_nuimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2486 {
2487   return m16_check_op (op, (- 0xff) << 2, 0x0, 3);
2488 }
2489
2490 int
2491 m16_simm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2492 {
2493   return m16_check_op (op, (- 0x80) << 3, 0x7f << 3, 7);
2494 }
2495
2496 int
2497 m16_nsimm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2498 {
2499   return m16_check_op (op, (- 0x7f) << 3, 0x80 << 3, 7);
2500 }
2501 \f
2502 static bool
2503 mips_rtx_costs (rtx x, int code, int outer_code, int *total)
2504 {
2505   enum machine_mode mode = GET_MODE (x);
2506   bool float_mode_p = FLOAT_MODE_P (mode);
2507
2508   switch (code)
2509     {
2510     case CONST_INT:
2511       if (TARGET_MIPS16)
2512         {
2513           /* A number between 1 and 8 inclusive is efficient for a shift.
2514              Otherwise, we will need an extended instruction.  */
2515           if ((outer_code) == ASHIFT || (outer_code) == ASHIFTRT
2516               || (outer_code) == LSHIFTRT)
2517             {
2518               if (INTVAL (x) >= 1 && INTVAL (x) <= 8)
2519                 *total = 0;
2520               else
2521                 *total = COSTS_N_INSNS (1);
2522               return true;
2523             }
2524
2525           /* We can use cmpi for an xor with an unsigned 16 bit value.  */
2526           if ((outer_code) == XOR
2527               && INTVAL (x) >= 0 && INTVAL (x) < 0x10000)
2528             {
2529               *total = 0;
2530               return true;
2531             }
2532
2533           /* We may be able to use slt or sltu for a comparison with a
2534              signed 16 bit value.  (The boundary conditions aren't quite
2535              right, but this is just a heuristic anyhow.)  */
2536           if (((outer_code) == LT || (outer_code) == LE
2537                || (outer_code) == GE || (outer_code) == GT
2538                || (outer_code) == LTU || (outer_code) == LEU
2539                || (outer_code) == GEU || (outer_code) == GTU)
2540               && INTVAL (x) >= -0x8000 && INTVAL (x) < 0x8000)
2541             {
2542               *total = 0;
2543               return true;
2544             }
2545
2546           /* Equality comparisons with 0 are cheap.  */
2547           if (((outer_code) == EQ || (outer_code) == NE)
2548               && INTVAL (x) == 0)
2549             {
2550               *total = 0;
2551               return true;
2552             }
2553
2554           /* Constants in the range 0...255 can be loaded with an unextended
2555              instruction.  They are therefore as cheap as a register move.
2556
2557              Given the choice between "li R1,0...255" and "move R1,R2"
2558              (where R2 is a known constant), it is usually better to use "li",
2559              since we do not want to unnecessarily extend the lifetime
2560              of R2.  */
2561           if (outer_code == SET
2562               && INTVAL (x) >= 0
2563               && INTVAL (x) < 256)
2564             {
2565               *total = 0;
2566               return true;
2567             }
2568         }
2569       else
2570         {
2571           /* These can be used anywhere. */
2572           *total = 0;
2573           return true;
2574         }
2575
2576       /* Otherwise fall through to the handling below because
2577          we'll need to construct the constant.  */
2578
2579     case CONST:
2580     case SYMBOL_REF:
2581     case LABEL_REF:
2582     case CONST_DOUBLE:
2583       if (LEGITIMATE_CONSTANT_P (x))
2584         {
2585           *total = COSTS_N_INSNS (1);
2586           return true;
2587         }
2588       else
2589         {
2590           /* The value will need to be fetched from the constant pool.  */
2591           *total = CONSTANT_POOL_COST;
2592           return true;
2593         }
2594
2595     case MEM:
2596       {
2597         /* If the address is legitimate, return the number of
2598            instructions it needs, otherwise use the default handling.  */
2599         int n = mips_address_insns (XEXP (x, 0), GET_MODE (x));
2600         if (n > 0)
2601           {
2602             *total = COSTS_N_INSNS (n + 1);
2603             return true;
2604           }
2605         return false;
2606       }
2607
2608     case FFS:
2609       *total = COSTS_N_INSNS (6);
2610       return true;
2611
2612     case NOT:
2613       *total = COSTS_N_INSNS ((mode == DImode && !TARGET_64BIT) ? 2 : 1);
2614       return true;
2615
2616     case AND:
2617     case IOR:
2618     case XOR:
2619       if (mode == DImode && !TARGET_64BIT)
2620         {
2621           *total = COSTS_N_INSNS (2);
2622           return true;
2623         }
2624       return false;
2625
2626     case ASHIFT:
2627     case ASHIFTRT:
2628     case LSHIFTRT:
2629       if (mode == DImode && !TARGET_64BIT)
2630         {
2631           *total = COSTS_N_INSNS ((GET_CODE (XEXP (x, 1)) == CONST_INT)
2632                                   ? 4 : 12);
2633           return true;
2634         }
2635       return false;
2636
2637     case ABS:
2638       if (float_mode_p)
2639         *total = COSTS_N_INSNS (1);
2640       else
2641         *total = COSTS_N_INSNS (4);
2642       return true;
2643
2644     case LO_SUM:
2645       *total = COSTS_N_INSNS (1);
2646       return true;
2647
2648     case PLUS:
2649     case MINUS:
2650       if (float_mode_p)
2651         {
2652           *total = mips_cost->fp_add;
2653           return true;
2654         }
2655
2656       else if (mode == DImode && !TARGET_64BIT)
2657         {
2658           *total = COSTS_N_INSNS (4);
2659           return true;
2660         }
2661       return false;
2662
2663     case NEG:
2664       if (mode == DImode && !TARGET_64BIT)
2665         {
2666           *total = COSTS_N_INSNS (4);
2667           return true;
2668         }
2669       return false;
2670
2671     case MULT:
2672       if (mode == SFmode)
2673         *total = mips_cost->fp_mult_sf;
2674
2675       else if (mode == DFmode)
2676         *total = mips_cost->fp_mult_df;
2677
2678       else if (mode == SImode)
2679         *total = mips_cost->int_mult_si;
2680
2681       else
2682         *total = mips_cost->int_mult_di;
2683
2684       return true;
2685
2686     case DIV:
2687     case MOD:
2688       if (float_mode_p)
2689         {
2690           if (mode == SFmode)
2691             *total = mips_cost->fp_div_sf;
2692           else
2693             *total = mips_cost->fp_div_df;
2694
2695           return true;
2696         }
2697       /* Fall through.  */
2698
2699     case UDIV:
2700     case UMOD:
2701       if (mode == DImode)
2702         *total = mips_cost->int_div_di;
2703       else
2704         *total = mips_cost->int_div_si;
2705
2706       return true;
2707
2708     case SIGN_EXTEND:
2709       /* A sign extend from SImode to DImode in 64 bit mode is often
2710          zero instructions, because the result can often be used
2711          directly by another instruction; we'll call it one.  */
2712       if (TARGET_64BIT && mode == DImode
2713           && GET_MODE (XEXP (x, 0)) == SImode)
2714         *total = COSTS_N_INSNS (1);
2715       else
2716         *total = COSTS_N_INSNS (2);
2717       return true;
2718
2719     case ZERO_EXTEND:
2720       if (TARGET_64BIT && mode == DImode
2721           && GET_MODE (XEXP (x, 0)) == SImode)
2722         *total = COSTS_N_INSNS (2);
2723       else
2724         *total = COSTS_N_INSNS (1);
2725       return true;
2726
2727     case FLOAT:
2728     case UNSIGNED_FLOAT:
2729     case FIX:
2730     case FLOAT_EXTEND:
2731     case FLOAT_TRUNCATE:
2732     case SQRT:
2733       *total = mips_cost->fp_add;
2734       return true;
2735
2736     default:
2737       return false;
2738     }
2739 }
2740
2741 /* Provide the costs of an addressing mode that contains ADDR.
2742    If ADDR is not a valid address, its cost is irrelevant.  */
2743
2744 static int
2745 mips_address_cost (rtx addr)
2746 {
2747   return mips_address_insns (addr, SImode);
2748 }
2749 \f
2750 /* Return one word of double-word value OP, taking into account the fixed
2751    endianness of certain registers.  HIGH_P is true to select the high part,
2752    false to select the low part.  */
2753
2754 rtx
2755 mips_subword (rtx op, int high_p)
2756 {
2757   unsigned int byte;
2758   enum machine_mode mode;
2759
2760   mode = GET_MODE (op);
2761   if (mode == VOIDmode)
2762     mode = DImode;
2763
2764   if (TARGET_BIG_ENDIAN ? !high_p : high_p)
2765     byte = UNITS_PER_WORD;
2766   else
2767     byte = 0;
2768
2769   if (REG_P (op))
2770     {
2771       if (FP_REG_P (REGNO (op)))
2772         return gen_rtx_REG (word_mode, high_p ? REGNO (op) + 1 : REGNO (op));
2773       if (ACC_HI_REG_P (REGNO (op)))
2774         return gen_rtx_REG (word_mode, high_p ? REGNO (op) : REGNO (op) + 1);
2775     }
2776
2777   if (MEM_P (op))
2778     return mips_rewrite_small_data (adjust_address (op, word_mode, byte));
2779
2780   return simplify_gen_subreg (word_mode, op, mode, byte);
2781 }
2782
2783
2784 /* Return true if a 64-bit move from SRC to DEST should be split into two.  */
2785
2786 bool
2787 mips_split_64bit_move_p (rtx dest, rtx src)
2788 {
2789   if (TARGET_64BIT)
2790     return false;
2791
2792   /* FP->FP moves can be done in a single instruction.  */
2793   if (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest))
2794     return false;
2795
2796   /* Check for floating-point loads and stores.  They can be done using
2797      ldc1 and sdc1 on MIPS II and above.  */
2798   if (mips_isa > 1)
2799     {
2800       if (FP_REG_RTX_P (dest) && MEM_P (src))
2801         return false;
2802       if (FP_REG_RTX_P (src) && MEM_P (dest))
2803         return false;
2804     }
2805   return true;
2806 }
2807
2808
2809 /* Split a 64-bit move from SRC to DEST assuming that
2810    mips_split_64bit_move_p holds.
2811
2812    Moves into and out of FPRs cause some difficulty here.  Such moves
2813    will always be DFmode, since paired FPRs are not allowed to store
2814    DImode values.  The most natural representation would be two separate
2815    32-bit moves, such as:
2816
2817         (set (reg:SI $f0) (mem:SI ...))
2818         (set (reg:SI $f1) (mem:SI ...))
2819
2820    However, the second insn is invalid because odd-numbered FPRs are
2821    not allowed to store independent values.  Use the patterns load_df_low,
2822    load_df_high and store_df_high instead.  */
2823
2824 void
2825 mips_split_64bit_move (rtx dest, rtx src)
2826 {
2827   if (FP_REG_RTX_P (dest))
2828     {
2829       /* Loading an FPR from memory or from GPRs.  */
2830       if (ISA_HAS_MXHC1)
2831         {
2832           dest = gen_lowpart (DFmode, dest);
2833           emit_insn (gen_load_df_low (dest, mips_subword (src, 0)));
2834           emit_insn (gen_mthc1 (dest, mips_subword (src, 1),
2835                                 copy_rtx (dest)));
2836         }
2837       else
2838         {
2839           emit_insn (gen_load_df_low (copy_rtx (dest),
2840                                       mips_subword (src, 0)));
2841           emit_insn (gen_load_df_high (dest, mips_subword (src, 1),
2842                                        copy_rtx (dest)));
2843         }
2844     }
2845   else if (FP_REG_RTX_P (src))
2846     {
2847       /* Storing an FPR into memory or GPRs.  */
2848       if (ISA_HAS_MXHC1)
2849         {
2850           src = gen_lowpart (DFmode, src);
2851           emit_move_insn (mips_subword (dest, 0), mips_subword (src, 0));
2852           emit_insn (gen_mfhc1 (mips_subword (dest, 1), src));
2853         }
2854       else
2855         {
2856           emit_move_insn (mips_subword (dest, 0), mips_subword (src, 0));
2857           emit_insn (gen_store_df_high (mips_subword (dest, 1), src));
2858         }
2859     }
2860   else
2861     {
2862       /* The operation can be split into two normal moves.  Decide in
2863          which order to do them.  */
2864       rtx low_dest;
2865
2866       low_dest = mips_subword (dest, 0);
2867       if (REG_P (low_dest)
2868           && reg_overlap_mentioned_p (low_dest, src))
2869         {
2870           emit_move_insn (mips_subword (dest, 1), mips_subword (src, 1));
2871           emit_move_insn (low_dest, mips_subword (src, 0));
2872         }
2873       else
2874         {
2875           emit_move_insn (low_dest, mips_subword (src, 0));
2876           emit_move_insn (mips_subword (dest, 1), mips_subword (src, 1));
2877         }
2878     }
2879 }
2880 \f
2881 /* Return the appropriate instructions to move SRC into DEST.  Assume
2882    that SRC is operand 1 and DEST is operand 0.  */
2883
2884 const char *
2885 mips_output_move (rtx dest, rtx src)
2886 {
2887   enum rtx_code dest_code, src_code;
2888   bool dbl_p;
2889
2890   dest_code = GET_CODE (dest);
2891   src_code = GET_CODE (src);
2892   dbl_p = (GET_MODE_SIZE (GET_MODE (dest)) == 8);
2893
2894   if (dbl_p && mips_split_64bit_move_p (dest, src))
2895     return "#";
2896
2897   if ((src_code == REG && GP_REG_P (REGNO (src)))
2898       || (!TARGET_MIPS16 && src == CONST0_RTX (GET_MODE (dest))))
2899     {
2900       if (dest_code == REG)
2901         {
2902           if (GP_REG_P (REGNO (dest)))
2903             return "move\t%0,%z1";
2904
2905           if (MD_REG_P (REGNO (dest)))
2906             return "mt%0\t%z1";
2907
2908           if (DSP_ACC_REG_P (REGNO (dest)))
2909             {
2910               static char retval[] = "mt__\t%z1,%q0";
2911               retval[2] = reg_names[REGNO (dest)][4];
2912               retval[3] = reg_names[REGNO (dest)][5];
2913               return retval;
2914             }
2915
2916           if (FP_REG_P (REGNO (dest)))
2917             return (dbl_p ? "dmtc1\t%z1,%0" : "mtc1\t%z1,%0");
2918
2919           if (ALL_COP_REG_P (REGNO (dest)))
2920             {
2921               static char retval[] = "dmtc_\t%z1,%0";
2922
2923               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
2924               return (dbl_p ? retval : retval + 1);
2925             }
2926         }
2927       if (dest_code == MEM)
2928         return (dbl_p ? "sd\t%z1,%0" : "sw\t%z1,%0");
2929     }
2930   if (dest_code == REG && GP_REG_P (REGNO (dest)))
2931     {
2932       if (src_code == REG)
2933         {
2934           if (DSP_ACC_REG_P (REGNO (src)))
2935             {
2936               static char retval[] = "mf__\t%0,%q1";
2937               retval[2] = reg_names[REGNO (src)][4];
2938               retval[3] = reg_names[REGNO (src)][5];
2939               return retval;
2940             }
2941
2942           if (ST_REG_P (REGNO (src)) && ISA_HAS_8CC)
2943             return "lui\t%0,0x3f80\n\tmovf\t%0,%.,%1";
2944
2945           if (FP_REG_P (REGNO (src)))
2946             return (dbl_p ? "dmfc1\t%0,%1" : "mfc1\t%0,%1");
2947
2948           if (ALL_COP_REG_P (REGNO (src)))
2949             {
2950               static char retval[] = "dmfc_\t%0,%1";
2951
2952               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
2953               return (dbl_p ? retval : retval + 1);
2954             }
2955         }
2956
2957       if (src_code == MEM)
2958         return (dbl_p ? "ld\t%0,%1" : "lw\t%0,%1");
2959
2960       if (src_code == CONST_INT)
2961         {
2962           /* Don't use the X format, because that will give out of
2963              range numbers for 64 bit hosts and 32 bit targets.  */
2964           if (!TARGET_MIPS16)
2965             return "li\t%0,%1\t\t\t# %X1";
2966
2967           if (INTVAL (src) >= 0 && INTVAL (src) <= 0xffff)
2968             return "li\t%0,%1";
2969
2970           if (INTVAL (src) < 0 && INTVAL (src) >= -0xffff)
2971             return "#";
2972         }
2973
2974       if (src_code == HIGH)
2975         return "lui\t%0,%h1";
2976
2977       if (CONST_GP_P (src))
2978         return "move\t%0,%1";
2979
2980       if (symbolic_operand (src, VOIDmode))
2981         return (dbl_p ? "dla\t%0,%1" : "la\t%0,%1");
2982     }
2983   if (src_code == REG && FP_REG_P (REGNO (src)))
2984     {
2985       if (dest_code == REG && FP_REG_P (REGNO (dest)))
2986         {
2987           if (GET_MODE (dest) == V2SFmode)
2988             return "mov.ps\t%0,%1";
2989           else
2990             return (dbl_p ? "mov.d\t%0,%1" : "mov.s\t%0,%1");
2991         }
2992
2993       if (dest_code == MEM)
2994         return (dbl_p ? "sdc1\t%1,%0" : "swc1\t%1,%0");
2995     }
2996   if (dest_code == REG && FP_REG_P (REGNO (dest)))
2997     {
2998       if (src_code == MEM)
2999         return (dbl_p ? "ldc1\t%0,%1" : "lwc1\t%0,%1");
3000     }
3001   if (dest_code == REG && ALL_COP_REG_P (REGNO (dest)) && src_code == MEM)
3002     {
3003       static char retval[] = "l_c_\t%0,%1";
3004
3005       retval[1] = (dbl_p ? 'd' : 'w');
3006       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
3007       return retval;
3008     }
3009   if (dest_code == MEM && src_code == REG && ALL_COP_REG_P (REGNO (src)))
3010     {
3011       static char retval[] = "s_c_\t%1,%0";
3012
3013       retval[1] = (dbl_p ? 'd' : 'w');
3014       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
3015       return retval;
3016     }
3017   gcc_unreachable ();
3018 }
3019 \f
3020 /* Restore $gp from its save slot.  Valid only when using o32 or
3021    o64 abicalls.  */
3022
3023 void
3024 mips_restore_gp (void)
3025 {
3026   rtx address, slot;
3027
3028   gcc_assert (TARGET_ABICALLS && TARGET_OLDABI);
3029
3030   address = mips_add_offset (pic_offset_table_rtx,
3031                              frame_pointer_needed
3032                              ? hard_frame_pointer_rtx
3033                              : stack_pointer_rtx,
3034                              current_function_outgoing_args_size);
3035   slot = gen_rtx_MEM (Pmode, address);
3036
3037   emit_move_insn (pic_offset_table_rtx, slot);
3038   if (!TARGET_EXPLICIT_RELOCS)
3039     emit_insn (gen_blockage ());
3040 }
3041 \f
3042 /* Emit an instruction of the form (set TARGET (CODE OP0 OP1)).  */
3043
3044 static void
3045 mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
3046 {
3047   emit_insn (gen_rtx_SET (VOIDmode, target,
3048                           gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
3049 }
3050
3051 /* Return true if CMP1 is a suitable second operand for relational
3052    operator CODE.  See also the *sCC patterns in mips.md.  */
3053
3054 static bool
3055 mips_relational_operand_ok_p (enum rtx_code code, rtx cmp1)
3056 {
3057   switch (code)
3058     {
3059     case GT:
3060     case GTU:
3061       return reg_or_0_operand (cmp1, VOIDmode);
3062
3063     case GE:
3064     case GEU:
3065       return !TARGET_MIPS16 && cmp1 == const1_rtx;
3066
3067     case LT:
3068     case LTU:
3069       return arith_operand (cmp1, VOIDmode);
3070
3071     case LE:
3072       return sle_operand (cmp1, VOIDmode);
3073
3074     case LEU:
3075       return sleu_operand (cmp1, VOIDmode);
3076
3077     default:
3078       gcc_unreachable ();
3079     }
3080 }
3081
3082 /* Canonicalize LE or LEU comparisons into LT comparisons when
3083    possible to avoid extra instructions or inverting the
3084    comparison.  */
3085
3086 static bool
3087 mips_canonicalize_comparison (enum rtx_code *code, rtx *cmp1,
3088                               enum machine_mode mode)
3089 {
3090   HOST_WIDE_INT original, plus_one;
3091
3092   if (GET_CODE (*cmp1) != CONST_INT)
3093     return false;
3094
3095   original = INTVAL (*cmp1);
3096   plus_one = trunc_int_for_mode ((unsigned HOST_WIDE_INT) original + 1, mode);
3097
3098   switch (*code)
3099     {
3100     case LE:
3101       if (original < plus_one)
3102         {
3103           *code = LT;
3104           *cmp1 = force_reg (mode, GEN_INT (plus_one));
3105           return true;
3106         }
3107       break;
3108
3109     case LEU:
3110       if (plus_one != 0)
3111         {
3112           *code = LTU;
3113           *cmp1 = force_reg (mode, GEN_INT (plus_one));
3114           return true;
3115         }
3116       break;
3117
3118     default:
3119       return false;
3120    }
3121
3122   return false;
3123
3124 }
3125
3126 /* Compare CMP0 and CMP1 using relational operator CODE and store the
3127    result in TARGET.  CMP0 and TARGET are register_operands that have
3128    the same integer mode.  If INVERT_PTR is nonnull, it's OK to set
3129    TARGET to the inverse of the result and flip *INVERT_PTR instead.  */
3130
3131 static void
3132 mips_emit_int_relational (enum rtx_code code, bool *invert_ptr,
3133                           rtx target, rtx cmp0, rtx cmp1)
3134 {
3135   /* First see if there is a MIPS instruction that can do this operation
3136      with CMP1 in its current form. If not, try to canonicalize the
3137      comparison to LT. If that fails, try doing the same for the
3138      inverse operation.  If that also fails, force CMP1 into a register
3139      and try again.  */
3140   if (mips_relational_operand_ok_p (code, cmp1))
3141     mips_emit_binary (code, target, cmp0, cmp1);
3142   else if (mips_canonicalize_comparison (&code, &cmp1, GET_MODE (target)))
3143     mips_emit_binary (code, target, cmp0, cmp1);
3144   else
3145     {
3146       enum rtx_code inv_code = reverse_condition (code);
3147       if (!mips_relational_operand_ok_p (inv_code, cmp1))
3148         {
3149           cmp1 = force_reg (GET_MODE (cmp0), cmp1);
3150           mips_emit_int_relational (code, invert_ptr, target, cmp0, cmp1);
3151         }
3152       else if (invert_ptr == 0)
3153         {
3154           rtx inv_target = gen_reg_rtx (GET_MODE (target));
3155           mips_emit_binary (inv_code, inv_target, cmp0, cmp1);
3156           mips_emit_binary (XOR, target, inv_target, const1_rtx);
3157         }
3158       else
3159         {
3160           *invert_ptr = !*invert_ptr;
3161           mips_emit_binary (inv_code, target, cmp0, cmp1);
3162         }
3163     }
3164 }
3165
3166 /* Return a register that is zero iff CMP0 and CMP1 are equal.
3167    The register will have the same mode as CMP0.  */
3168
3169 static rtx
3170 mips_zero_if_equal (rtx cmp0, rtx cmp1)
3171 {
3172   if (cmp1 == const0_rtx)
3173     return cmp0;
3174
3175   if (uns_arith_operand (cmp1, VOIDmode))
3176     return expand_binop (GET_MODE (cmp0), xor_optab,
3177                          cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3178
3179   return expand_binop (GET_MODE (cmp0), sub_optab,
3180                        cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3181 }
3182
3183 /* Convert *CODE into a code that can be used in a floating-point
3184    scc instruction (c.<cond>.<fmt>).  Return true if the values of
3185    the condition code registers will be inverted, with 0 indicating
3186    that the condition holds.  */
3187
3188 static bool
3189 mips_reverse_fp_cond_p (enum rtx_code *code)
3190 {
3191   switch (*code)
3192     {
3193     case NE:
3194     case LTGT:
3195     case ORDERED:
3196       *code = reverse_condition_maybe_unordered (*code);
3197       return true;
3198
3199     default:
3200       return false;
3201     }
3202 }
3203
3204 /* Convert a comparison into something that can be used in a branch or
3205    conditional move.  cmp_operands[0] and cmp_operands[1] are the values
3206    being compared and *CODE is the code used to compare them.
3207
3208    Update *CODE, *OP0 and *OP1 so that they describe the final comparison.
3209    If NEED_EQ_NE_P, then only EQ/NE comparisons against zero are possible,
3210    otherwise any standard branch condition can be used.  The standard branch
3211    conditions are:
3212
3213       - EQ/NE between two registers.
3214       - any comparison between a register and zero.  */
3215
3216 static void
3217 mips_emit_compare (enum rtx_code *code, rtx *op0, rtx *op1, bool need_eq_ne_p)
3218 {
3219   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) == MODE_INT)
3220     {
3221       if (!need_eq_ne_p && cmp_operands[1] == const0_rtx)
3222         {
3223           *op0 = cmp_operands[0];
3224           *op1 = cmp_operands[1];
3225         }
3226       else if (*code == EQ || *code == NE)
3227         {
3228           if (need_eq_ne_p)
3229             {
3230               *op0 = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3231               *op1 = const0_rtx;
3232             }
3233           else
3234             {
3235               *op0 = cmp_operands[0];
3236               *op1 = force_reg (GET_MODE (*op0), cmp_operands[1]);
3237             }
3238         }
3239       else
3240         {
3241           /* The comparison needs a separate scc instruction.  Store the
3242              result of the scc in *OP0 and compare it against zero.  */
3243           bool invert = false;
3244           *op0 = gen_reg_rtx (GET_MODE (cmp_operands[0]));
3245           *op1 = const0_rtx;
3246           mips_emit_int_relational (*code, &invert, *op0,
3247                                     cmp_operands[0], cmp_operands[1]);
3248           *code = (invert ? EQ : NE);
3249         }
3250     }
3251   else
3252     {
3253       enum rtx_code cmp_code;
3254
3255       /* Floating-point tests use a separate c.cond.fmt comparison to
3256          set a condition code register.  The branch or conditional move
3257          will then compare that register against zero.
3258
3259          Set CMP_CODE to the code of the comparison instruction and
3260          *CODE to the code that the branch or move should use.  */
3261       cmp_code = *code;
3262       *code = mips_reverse_fp_cond_p (&cmp_code) ? EQ : NE;
3263       *op0 = (ISA_HAS_8CC
3264               ? gen_reg_rtx (CCmode)
3265               : gen_rtx_REG (CCmode, FPSW_REGNUM));
3266       *op1 = const0_rtx;
3267       mips_emit_binary (cmp_code, *op0, cmp_operands[0], cmp_operands[1]);
3268     }
3269 }
3270 \f
3271 /* Try comparing cmp_operands[0] and cmp_operands[1] using rtl code CODE.
3272    Store the result in TARGET and return true if successful.
3273
3274    On 64-bit targets, TARGET may be wider than cmp_operands[0].  */
3275
3276 bool
3277 mips_emit_scc (enum rtx_code code, rtx target)
3278 {
3279   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) != MODE_INT)
3280     return false;
3281
3282   target = gen_lowpart (GET_MODE (cmp_operands[0]), target);
3283   if (code == EQ || code == NE)
3284     {
3285       rtx zie = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3286       mips_emit_binary (code, target, zie, const0_rtx);
3287     }
3288   else
3289     mips_emit_int_relational (code, 0, target,
3290                               cmp_operands[0], cmp_operands[1]);
3291   return true;
3292 }
3293
3294 /* Emit the common code for doing conditional branches.
3295    operand[0] is the label to jump to.
3296    The comparison operands are saved away by cmp{si,di,sf,df}.  */
3297
3298 void
3299 gen_conditional_branch (rtx *operands, enum rtx_code code)
3300 {
3301   rtx op0, op1, condition;
3302
3303   mips_emit_compare (&code, &op0, &op1, TARGET_MIPS16);
3304   condition = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
3305   emit_jump_insn (gen_condjump (condition, operands[0]));
3306 }
3307
3308 /* Implement:
3309
3310    (set temp (COND:CCV2 CMP_OP0 CMP_OP1))
3311    (set DEST (unspec [TRUE_SRC FALSE_SRC temp] UNSPEC_MOVE_TF_PS))  */
3312
3313 void
3314 mips_expand_vcondv2sf (rtx dest, rtx true_src, rtx false_src,
3315                        enum rtx_code cond, rtx cmp_op0, rtx cmp_op1)
3316 {
3317   rtx cmp_result;
3318   bool reversed_p;
3319
3320   reversed_p = mips_reverse_fp_cond_p (&cond);
3321   cmp_result = gen_reg_rtx (CCV2mode);
3322   emit_insn (gen_scc_ps (cmp_result,
3323                          gen_rtx_fmt_ee (cond, VOIDmode, cmp_op0, cmp_op1)));
3324   if (reversed_p)
3325     emit_insn (gen_mips_cond_move_tf_ps (dest, false_src, true_src,
3326                                          cmp_result));
3327   else
3328     emit_insn (gen_mips_cond_move_tf_ps (dest, true_src, false_src,
3329                                          cmp_result));
3330 }
3331
3332 /* Emit the common code for conditional moves.  OPERANDS is the array
3333    of operands passed to the conditional move define_expand.  */
3334
3335 void
3336 gen_conditional_move (rtx *operands)
3337 {
3338   enum rtx_code code;
3339   rtx op0, op1;
3340
3341   code = GET_CODE (operands[1]);
3342   mips_emit_compare (&code, &op0, &op1, true);
3343   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3344                           gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]),
3345                                                 gen_rtx_fmt_ee (code,
3346                                                                 GET_MODE (op0),
3347                                                                 op0, op1),
3348                                                 operands[2], operands[3])));
3349 }
3350
3351 /* Emit a conditional trap.  OPERANDS is the array of operands passed to
3352    the conditional_trap expander.  */
3353
3354 void
3355 mips_gen_conditional_trap (rtx *operands)
3356 {
3357   rtx op0, op1;
3358   enum rtx_code cmp_code = GET_CODE (operands[0]);
3359   enum machine_mode mode = GET_MODE (cmp_operands[0]);
3360
3361   /* MIPS conditional trap machine instructions don't have GT or LE
3362      flavors, so we must invert the comparison and convert to LT and
3363      GE, respectively.  */
3364   switch (cmp_code)
3365     {
3366     case GT: cmp_code = LT; break;
3367     case LE: cmp_code = GE; break;
3368     case GTU: cmp_code = LTU; break;
3369     case LEU: cmp_code = GEU; break;
3370     default: break;
3371     }
3372   if (cmp_code == GET_CODE (operands[0]))
3373     {
3374       op0 = cmp_operands[0];
3375       op1 = cmp_operands[1];
3376     }
3377   else
3378     {
3379       op0 = cmp_operands[1];
3380       op1 = cmp_operands[0];
3381     }
3382   op0 = force_reg (mode, op0);
3383   if (!arith_operand (op1, mode))
3384     op1 = force_reg (mode, op1);
3385
3386   emit_insn (gen_rtx_TRAP_IF (VOIDmode,
3387                               gen_rtx_fmt_ee (cmp_code, mode, op0, op1),
3388                               operands[1]));
3389 }
3390 \f
3391 /* Load function address ADDR into register DEST.  SIBCALL_P is true
3392    if the address is needed for a sibling call.  */
3393
3394 static void
3395 mips_load_call_address (rtx dest, rtx addr, int sibcall_p)
3396 {
3397   /* If we're generating PIC, and this call is to a global function,
3398      try to allow its address to be resolved lazily.  This isn't
3399      possible for NewABI sibcalls since the value of $gp on entry
3400      to the stub would be our caller's gp, not ours.  */
3401   if (TARGET_EXPLICIT_RELOCS
3402       && !(sibcall_p && TARGET_NEWABI)
3403       && global_got_operand (addr, VOIDmode))
3404     {
3405       rtx high, lo_sum_symbol;
3406
3407       high = mips_unspec_offset_high (dest, pic_offset_table_rtx,
3408                                       addr, SYMBOL_GOTOFF_CALL);
3409       lo_sum_symbol = mips_unspec_address (addr, SYMBOL_GOTOFF_CALL);
3410       if (Pmode == SImode)
3411         emit_insn (gen_load_callsi (dest, high, lo_sum_symbol));
3412       else
3413         emit_insn (gen_load_calldi (dest, high, lo_sum_symbol));
3414     }
3415   else
3416     emit_move_insn (dest, addr);
3417 }
3418
3419
3420 /* Expand a call or call_value instruction.  RESULT is where the
3421    result will go (null for calls), ADDR is the address of the
3422    function, ARGS_SIZE is the size of the arguments and AUX is
3423    the value passed to us by mips_function_arg.  SIBCALL_P is true
3424    if we are expanding a sibling call, false if we're expanding
3425    a normal call.  */
3426
3427 void
3428 mips_expand_call (rtx result, rtx addr, rtx args_size, rtx aux, int sibcall_p)
3429 {
3430   rtx orig_addr, pattern, insn;
3431
3432   orig_addr = addr;
3433   if (!call_insn_operand (addr, VOIDmode))
3434     {
3435       addr = gen_reg_rtx (Pmode);
3436       mips_load_call_address (addr, orig_addr, sibcall_p);
3437     }
3438
3439   if (TARGET_MIPS16
3440       && mips16_hard_float
3441       && build_mips16_call_stub (result, addr, args_size,
3442                                  aux == 0 ? 0 : (int) GET_MODE (aux)))
3443     return;
3444
3445   if (result == 0)
3446     pattern = (sibcall_p
3447                ? gen_sibcall_internal (addr, args_size)
3448                : gen_call_internal (addr, args_size));
3449   else if (GET_CODE (result) == PARALLEL && XVECLEN (result, 0) == 2)
3450     {
3451       rtx reg1, reg2;
3452
3453       reg1 = XEXP (XVECEXP (result, 0, 0), 0);
3454       reg2 = XEXP (XVECEXP (result, 0, 1), 0);
3455       pattern =
3456         (sibcall_p
3457          ? gen_sibcall_value_multiple_internal (reg1, addr, args_size, reg2)
3458          : gen_call_value_multiple_internal (reg1, addr, args_size, reg2));
3459     }
3460   else
3461     pattern = (sibcall_p
3462                ? gen_sibcall_value_internal (result, addr, args_size)
3463                : gen_call_value_internal (result, addr, args_size));
3464
3465   insn = emit_call_insn (pattern);
3466
3467   /* Lazy-binding stubs require $gp to be valid on entry.  */
3468   if (global_got_operand (orig_addr, VOIDmode))
3469     use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
3470 }
3471
3472
3473 /* We can handle any sibcall when TARGET_SIBCALLS is true.  */
3474
3475 static bool
3476 mips_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED,
3477                               tree exp ATTRIBUTE_UNUSED)
3478 {
3479   return TARGET_SIBCALLS;
3480 }
3481 \f
3482 /* Emit code to move general operand SRC into condition-code
3483    register DEST.  SCRATCH is a scratch TFmode float register.
3484    The sequence is:
3485
3486         FP1 = SRC
3487         FP2 = 0.0f
3488         DEST = FP2 < FP1
3489
3490    where FP1 and FP2 are single-precision float registers
3491    taken from SCRATCH.  */
3492
3493 void
3494 mips_emit_fcc_reload (rtx dest, rtx src, rtx scratch)
3495 {
3496   rtx fp1, fp2;
3497
3498   /* Change the source to SFmode.  */
3499   if (MEM_P (src))
3500     src = adjust_address (src, SFmode, 0);
3501   else if (REG_P (src) || GET_CODE (src) == SUBREG)
3502     src = gen_rtx_REG (SFmode, true_regnum (src));
3503
3504   fp1 = gen_rtx_REG (SFmode, REGNO (scratch));
3505   fp2 = gen_rtx_REG (SFmode, REGNO (scratch) + FP_INC);
3506
3507   emit_move_insn (copy_rtx (fp1), src);
3508   emit_move_insn (copy_rtx (fp2), CONST0_RTX (SFmode));
3509   emit_insn (gen_slt_sf (dest, fp2, fp1));
3510 }
3511 \f
3512 /* Emit code to change the current function's return address to
3513    ADDRESS.  SCRATCH is available as a scratch register, if needed.
3514    ADDRESS and SCRATCH are both word-mode GPRs.  */
3515
3516 void
3517 mips_set_return_address (rtx address, rtx scratch)
3518 {
3519   rtx slot_address;
3520
3521   compute_frame_size (get_frame_size ());
3522   gcc_assert ((cfun->machine->frame.mask >> 31) & 1);
3523   slot_address = mips_add_offset (scratch, stack_pointer_rtx,
3524                                   cfun->machine->frame.gp_sp_offset);
3525
3526   emit_move_insn (gen_rtx_MEM (GET_MODE (address), slot_address), address);
3527 }
3528 \f
3529 /* Emit straight-line code to move LENGTH bytes from SRC to DEST.
3530    Assume that the areas do not overlap.  */
3531
3532 static void
3533 mips_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length)
3534 {
3535   HOST_WIDE_INT offset, delta;
3536   unsigned HOST_WIDE_INT bits;
3537   int i;
3538   enum machine_mode mode;
3539   rtx *regs;
3540
3541   /* Work out how many bits to move at a time.  If both operands have
3542      half-word alignment, it is usually better to move in half words.
3543      For instance, lh/lh/sh/sh is usually better than lwl/lwr/swl/swr
3544      and lw/lw/sw/sw is usually better than ldl/ldr/sdl/sdr.
3545      Otherwise move word-sized chunks.  */
3546   if (MEM_ALIGN (src) == BITS_PER_WORD / 2
3547       && MEM_ALIGN (dest) == BITS_PER_WORD / 2)
3548     bits = BITS_PER_WORD / 2;
3549   else
3550     bits = BITS_PER_WORD;
3551
3552   mode = mode_for_size (bits, MODE_INT, 0);
3553   delta = bits / BITS_PER_UNIT;
3554
3555   /* Allocate a buffer for the temporary registers.  */
3556   regs = alloca (sizeof (rtx) * length / delta);
3557
3558   /* Load as many BITS-sized chunks as possible.  Use a normal load if
3559      the source has enough alignment, otherwise use left/right pairs.  */
3560   for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
3561     {
3562       regs[i] = gen_reg_rtx (mode);
3563       if (MEM_ALIGN (src) >= bits)
3564         emit_move_insn (regs[i], adjust_address (src, mode, offset));
3565       else
3566         {
3567           rtx part = adjust_address (src, BLKmode, offset);
3568           if (!mips_expand_unaligned_load (regs[i], part, bits, 0))
3569             gcc_unreachable ();
3570         }
3571     }
3572
3573   /* Copy the chunks to the destination.  */
3574   for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
3575     if (MEM_ALIGN (dest) >= bits)
3576       emit_move_insn (adjust_address (dest, mode, offset), regs[i]);
3577     else
3578       {
3579         rtx part = adjust_address (dest, BLKmode, offset);
3580         if (!mips_expand_unaligned_store (part, regs[i], bits, 0))
3581           gcc_unreachable ();
3582       }
3583
3584   /* Mop up any left-over bytes.  */
3585   if (offset < length)
3586     {
3587       src = adjust_address (src, BLKmode, offset);
3588       dest = adjust_address (dest, BLKmode, offset);
3589       move_by_pieces (dest, src, length - offset,
3590                       MIN (MEM_ALIGN (src), MEM_ALIGN (dest)), 0);
3591     }
3592 }
3593 \f
3594 #define MAX_MOVE_REGS 4
3595 #define MAX_MOVE_BYTES (MAX_MOVE_REGS * UNITS_PER_WORD)
3596
3597
3598 /* Helper function for doing a loop-based block operation on memory
3599    reference MEM.  Each iteration of the loop will operate on LENGTH
3600    bytes of MEM.
3601
3602    Create a new base register for use within the loop and point it to
3603    the start of MEM.  Create a new memory reference that uses this
3604    register.  Store them in *LOOP_REG and *LOOP_MEM respectively.  */
3605
3606 static void
3607 mips_adjust_block_mem (rtx mem, HOST_WIDE_INT length,
3608                        rtx *loop_reg, rtx *loop_mem)
3609 {
3610   *loop_reg = copy_addr_to_reg (XEXP (mem, 0));
3611
3612   /* Although the new mem does not refer to a known location,
3613      it does keep up to LENGTH bytes of alignment.  */
3614   *loop_mem = change_address (mem, BLKmode, *loop_reg);
3615   set_mem_align (*loop_mem, MIN (MEM_ALIGN (mem), length * BITS_PER_UNIT));
3616 }
3617
3618
3619 /* Move LENGTH bytes from SRC to DEST using a loop that moves MAX_MOVE_BYTES
3620    per iteration.  LENGTH must be at least MAX_MOVE_BYTES.  Assume that the
3621    memory regions do not overlap.  */
3622
3623 static void
3624 mips_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length)
3625 {
3626   rtx label, src_reg, dest_reg, final_src;
3627   HOST_WIDE_INT leftover;
3628
3629   leftover = length % MAX_MOVE_BYTES;
3630   length -= leftover;
3631
3632   /* Create registers and memory references for use within the loop.  */
3633   mips_adjust_block_mem (src, MAX_MOVE_BYTES, &src_reg, &src);
3634   mips_adjust_block_mem (dest, MAX_MOVE_BYTES, &dest_reg, &dest);
3635
3636   /* Calculate the value that SRC_REG should have after the last iteration
3637      of the loop.  */
3638   final_src = expand_simple_binop (Pmode, PLUS, src_reg, GEN_INT (length),
3639                                    0, 0, OPTAB_WIDEN);
3640
3641   /* Emit the start of the loop.  */
3642   label = gen_label_rtx ();
3643   emit_label (label);
3644
3645   /* Emit the loop body.  */
3646   mips_block_move_straight (dest, src, MAX_MOVE_BYTES);
3647
3648   /* Move on to the next block.  */
3649   emit_move_insn (src_reg, plus_constant (src_reg, MAX_MOVE_BYTES));
3650   emit_move_insn (dest_reg, plus_constant (dest_reg, MAX_MOVE_BYTES));
3651
3652   /* Emit the loop condition.  */
3653   if (Pmode == DImode)
3654     emit_insn (gen_cmpdi (src_reg, final_src));
3655   else
3656     emit_insn (gen_cmpsi (src_reg, final_src));
3657   emit_jump_insn (gen_bne (label));
3658
3659   /* Mop up any left-over bytes.  */
3660   if (leftover)
3661     mips_block_move_straight (dest, src, leftover);
3662 }
3663 \f
3664 /* Expand a movmemsi instruction.  */
3665
3666 bool
3667 mips_expand_block_move (rtx dest, rtx src, rtx length)
3668 {
3669   if (GET_CODE (length) == CONST_INT)
3670     {
3671       if (INTVAL (length) <= 2 * MAX_MOVE_BYTES)
3672         {
3673           mips_block_move_straight (dest, src, INTVAL (length));
3674           return true;
3675         }
3676       else if (optimize)
3677         {
3678           mips_block_move_loop (dest, src, INTVAL (length));
3679           return true;
3680         }
3681     }
3682   return false;
3683 }
3684 \f
3685 /* Argument support functions.  */
3686
3687 /* Initialize CUMULATIVE_ARGS for a function.  */
3688
3689 void
3690 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
3691                       rtx libname ATTRIBUTE_UNUSED)
3692 {
3693   static CUMULATIVE_ARGS zero_cum;
3694   tree param, next_param;
3695
3696   *cum = zero_cum;
3697   cum->prototype = (fntype && TYPE_ARG_TYPES (fntype));
3698
3699   /* Determine if this function has variable arguments.  This is
3700      indicated by the last argument being 'void_type_mode' if there
3701      are no variable arguments.  The standard MIPS calling sequence
3702      passes all arguments in the general purpose registers in this case.  */
3703
3704   for (param = fntype ? TYPE_ARG_TYPES (fntype) : 0;
3705        param != 0; param = next_param)
3706     {
3707       next_param = TREE_CHAIN (param);
3708       if (next_param == 0 && TREE_VALUE (param) != void_type_node)
3709         cum->gp_reg_found = 1;
3710     }
3711 }
3712
3713
3714 /* Fill INFO with information about a single argument.  CUM is the
3715    cumulative state for earlier arguments.  MODE is the mode of this
3716    argument and TYPE is its type (if known).  NAMED is true if this
3717    is a named (fixed) argument rather than a variable one.  */
3718
3719 static void
3720 mips_arg_info (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
3721                tree type, int named, struct mips_arg_info *info)
3722 {
3723   bool doubleword_aligned_p;
3724   unsigned int num_bytes, num_words, max_regs;
3725
3726   /* Work out the size of the argument.  */
3727   num_bytes = type ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
3728   num_words = (num_bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3729
3730   /* Decide whether it should go in a floating-point register, assuming
3731      one is free.  Later code checks for availability.
3732
3733      The checks against UNITS_PER_FPVALUE handle the soft-float and
3734      single-float cases.  */
3735   switch (mips_abi)
3736     {
3737     case ABI_EABI:
3738       /* The EABI conventions have traditionally been defined in terms
3739          of TYPE_MODE, regardless of the actual type.  */
3740       info->fpr_p = ((GET_MODE_CLASS (mode) == MODE_FLOAT
3741                       || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
3742                      && GET_MODE_SIZE (mode) <= UNITS_PER_FPVALUE);
3743       break;
3744
3745     case ABI_32:
3746     case ABI_O64:
3747       /* Only leading floating-point scalars are passed in
3748          floating-point registers.  We also handle vector floats the same
3749          say, which is OK because they are not covered by the standard ABI.  */
3750       info->fpr_p = (!cum->gp_reg_found
3751                      && cum->arg_number < 2
3752                      && (type == 0 || SCALAR_FLOAT_TYPE_P (type)
3753                          || VECTOR_FLOAT_TYPE_P (type))
3754                      && (GET_MODE_CLASS (mode) == MODE_FLOAT
3755                          || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
3756                      && GET_MODE_SIZE (mode) <= UNITS_PER_FPVALUE);
3757       break;
3758
3759     case ABI_N32:
3760     case ABI_64:
3761       /* Scalar and complex floating-point types are passed in
3762          floating-point registers.  */
3763       info->fpr_p = (named
3764                      && (type == 0 || FLOAT_TYPE_P (type))
3765                      && (GET_MODE_CLASS (mode) == MODE_FLOAT
3766                          || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
3767                          || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
3768                      && GET_MODE_UNIT_SIZE (mode) <= UNITS_PER_FPVALUE);
3769
3770       /* ??? According to the ABI documentation, the real and imaginary
3771          parts of complex floats should be passed in individual registers.
3772          The real and imaginary parts of stack arguments are supposed
3773          to be contiguous and there should be an extra word of padding
3774          at the end.
3775
3776          This has two problems.  First, it makes it impossible to use a
3777          single "void *" va_list type, since register and stack arguments
3778          are passed differently.  (At the time of writing, MIPSpro cannot
3779          handle complex float varargs correctly.)  Second, it's unclear
3780          what should happen when there is only one register free.
3781
3782          For now, we assume that named complex floats should go into FPRs
3783          if there are two FPRs free, otherwise they should be passed in the
3784          same way as a struct containing two floats.  */
3785       if (info->fpr_p
3786           && GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
3787           && GET_MODE_UNIT_SIZE (mode) < UNITS_PER_FPVALUE)
3788         {
3789           if (cum->num_gprs >= MAX_ARGS_IN_REGISTERS - 1)
3790             info->fpr_p = false;
3791           else
3792             num_words = 2;
3793         }
3794       break;
3795
3796     default:
3797       gcc_unreachable ();
3798     }
3799
3800   /* See whether the argument has doubleword alignment.  */
3801   doubleword_aligned_p = FUNCTION_ARG_BOUNDARY (mode, type) > BITS_PER_WORD;
3802
3803   /* Set REG_OFFSET to the register count we're interested in.
3804      The EABI allocates the floating-point registers separately,
3805      but the other ABIs allocate them like integer registers.  */
3806   info->reg_offset = (mips_abi == ABI_EABI && info->fpr_p
3807                       ? cum->num_fprs
3808                       : cum->num_gprs);
3809
3810   /* Advance to an even register if the argument is doubleword-aligned.  */
3811   if (doubleword_aligned_p)
3812     info->reg_offset += info->reg_offset & 1;
3813
3814   /* Work out the offset of a stack argument.  */
3815   info->stack_offset = cum->stack_words;
3816   if (doubleword_aligned_p)
3817     info->stack_offset += info->stack_offset & 1;
3818
3819   max_regs = MAX_ARGS_IN_REGISTERS - info->reg_offset;
3820
3821   /* Partition the argument between registers and stack.  */
3822   info->reg_words = MIN (num_words, max_regs);
3823   info->stack_words = num_words - info->reg_words;
3824 }
3825
3826
3827 /* Implement FUNCTION_ARG_ADVANCE.  */
3828
3829 void
3830 function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
3831                       tree type, int named)
3832 {
3833   struct mips_arg_info info;
3834
3835   mips_arg_info (cum, mode, type, named, &info);
3836
3837   if (!info.fpr_p)
3838     cum->gp_reg_found = true;
3839
3840   /* See the comment above the cumulative args structure in mips.h
3841      for an explanation of what this code does.  It assumes the O32
3842      ABI, which passes at most 2 arguments in float registers.  */
3843   if (cum->arg_number < 2 && info.fpr_p)
3844     cum->fp_code += (mode == SFmode ? 1 : 2) << ((cum->arg_number - 1) * 2);
3845
3846   if (mips_abi != ABI_EABI || !info.fpr_p)
3847     cum->num_gprs = info.reg_offset + info.reg_words;
3848   else if (info.reg_words > 0)
3849     cum->num_fprs += FP_INC;
3850
3851   if (info.stack_words > 0)
3852     cum->stack_words = info.stack_offset + info.stack_words;
3853
3854   cum->arg_number++;
3855 }
3856
3857 /* Implement FUNCTION_ARG.  */
3858
3859 struct rtx_def *
3860 function_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
3861               tree type, int named)
3862 {
3863   struct mips_arg_info info;
3864
3865   /* We will be called with a mode of VOIDmode after the last argument
3866      has been seen.  Whatever we return will be passed to the call
3867      insn.  If we need a mips16 fp_code, return a REG with the code
3868      stored as the mode.  */
3869   if (mode == VOIDmode)
3870     {
3871       if (TARGET_MIPS16 && cum->fp_code != 0)
3872         return gen_rtx_REG ((enum machine_mode) cum->fp_code, 0);
3873
3874       else
3875         return 0;
3876     }
3877
3878   mips_arg_info (cum, mode, type, named, &info);
3879
3880   /* Return straight away if the whole argument is passed on the stack.  */
3881   if (info.reg_offset == MAX_ARGS_IN_REGISTERS)
3882     return 0;
3883
3884   if (type != 0
3885       && TREE_CODE (type) == RECORD_TYPE
3886       && TARGET_NEWABI
3887       && TYPE_SIZE_UNIT (type)
3888       && host_integerp (TYPE_SIZE_UNIT (type), 1)
3889       && named)
3890     {
3891       /* The Irix 6 n32/n64 ABIs say that if any 64 bit chunk of the
3892          structure contains a double in its entirety, then that 64 bit
3893          chunk is passed in a floating point register.  */
3894       tree field;
3895
3896       /* First check to see if there is any such field.  */
3897       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3898         if (TREE_CODE (field) == FIELD_DECL
3899             && TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
3900             && TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD
3901             && host_integerp (bit_position (field), 0)
3902             && int_bit_position (field) % BITS_PER_WORD == 0)
3903           break;
3904
3905       if (field != 0)
3906         {
3907           /* Now handle the special case by returning a PARALLEL
3908              indicating where each 64 bit chunk goes.  INFO.REG_WORDS
3909              chunks are passed in registers.  */
3910           unsigned int i;
3911           HOST_WIDE_INT bitpos;
3912           rtx ret;
3913
3914           /* assign_parms checks the mode of ENTRY_PARM, so we must
3915              use the actual mode here.  */
3916           ret = gen_rtx_PARALLEL (mode, rtvec_alloc (info.reg_words));
3917
3918           bitpos = 0;
3919           field = TYPE_FIELDS (type);
3920           for (i = 0; i < info.reg_words; i++)
3921             {
3922               rtx reg;
3923
3924               for (; field; field = TREE_CHAIN (field))
3925                 if (TREE_CODE (field) == FIELD_DECL
3926                     && int_bit_position (field) >= bitpos)
3927                   break;
3928
3929               if (field
3930                   && int_bit_position (field) == bitpos
3931                   && TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
3932                   && !TARGET_SOFT_FLOAT
3933                   && TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD)
3934                 reg = gen_rtx_REG (DFmode, FP_ARG_FIRST + info.reg_offset + i);
3935               else
3936                 reg = gen_rtx_REG (DImode, GP_ARG_FIRST + info.reg_offset + i);
3937
3938               XVECEXP (ret, 0, i)
3939                 = gen_rtx_EXPR_LIST (VOIDmode, reg,
3940                                      GEN_INT (bitpos / BITS_PER_UNIT));
3941
3942               bitpos += BITS_PER_WORD;
3943             }
3944           return ret;
3945         }
3946     }
3947
3948   /* Handle the n32/n64 conventions for passing complex floating-point
3949      arguments in FPR pairs.  The real part goes in the lower register
3950      and the imaginary part goes in the upper register.  */
3951   if (TARGET_NEWABI
3952       && info.fpr_p
3953       && GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
3954     {
3955       rtx real, imag;
3956       enum machine_mode inner;
3957       int reg;
3958
3959       inner = GET_MODE_INNER (mode);
3960       reg = FP_ARG_FIRST + info.reg_offset;
3961       if (info.reg_words * UNITS_PER_WORD == GET_MODE_SIZE (inner))
3962         {
3963           /* Real part in registers, imaginary part on stack.  */
3964           gcc_assert (info.stack_words == info.reg_words);
3965           return gen_rtx_REG (inner, reg);
3966         }
3967       else
3968         {
3969           gcc_assert (info.stack_words == 0);
3970           real = gen_rtx_EXPR_LIST (VOIDmode,
3971                                     gen_rtx_REG (inner, reg),
3972                                     const0_rtx);
3973           imag = gen_rtx_EXPR_LIST (VOIDmode,
3974                                     gen_rtx_REG (inner,
3975                                                  reg + info.reg_words / 2),
3976                                     GEN_INT (GET_MODE_SIZE (inner)));
3977           return gen_rtx_PARALLEL (mode, gen_rtvec (2, real, imag));
3978         }
3979     }
3980
3981   if (!info.fpr_p)
3982     return gen_rtx_REG (mode, GP_ARG_FIRST + info.reg_offset);
3983   else if (info.reg_offset == 1)
3984     /* This code handles the special o32 case in which the second word
3985        of the argument structure is passed in floating-point registers.  */
3986     return gen_rtx_REG (mode, FP_ARG_FIRST + FP_INC);
3987   else
3988     return gen_rtx_REG (mode, FP_ARG_FIRST + info.reg_offset);
3989 }
3990
3991
3992 /* Implement TARGET_ARG_PARTIAL_BYTES.  */
3993
3994 static int
3995 mips_arg_partial_bytes (CUMULATIVE_ARGS *cum,
3996                         enum machine_mode mode, tree type, bool named)
3997 {
3998   struct mips_arg_info info;
3999
4000   mips_arg_info (cum, mode, type, named, &info);
4001   return info.stack_words > 0 ? info.reg_words * UNITS_PER_WORD : 0;
4002 }
4003
4004
4005 /* Implement FUNCTION_ARG_BOUNDARY.  Every parameter gets at least
4006    PARM_BOUNDARY bits of alignment, but will be given anything up
4007    to STACK_BOUNDARY bits if the type requires it.  */
4008
4009 int
4010 function_arg_boundary (enum machine_mode mode, tree type)
4011 {
4012   unsigned int alignment;
4013
4014   alignment = type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode);
4015   if (alignment < PARM_BOUNDARY)
4016     alignment = PARM_BOUNDARY;
4017   if (alignment > STACK_BOUNDARY)
4018     alignment = STACK_BOUNDARY;
4019   return alignment;
4020 }
4021
4022 /* Return true if FUNCTION_ARG_PADDING (MODE, TYPE) should return
4023    upward rather than downward.  In other words, return true if the
4024    first byte of the stack slot has useful data, false if the last
4025    byte does.  */
4026
4027 bool
4028 mips_pad_arg_upward (enum machine_mode mode, tree type)
4029 {
4030   /* On little-endian targets, the first byte of every stack argument
4031      is passed in the first byte of the stack slot.  */
4032   if (!BYTES_BIG_ENDIAN)
4033     return true;
4034
4035   /* Otherwise, integral types are padded downward: the last byte of a
4036      stack argument is passed in the last byte of the stack slot.  */
4037   if (type != 0
4038       ? INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)
4039       : GET_MODE_CLASS (mode) == MODE_INT)
4040     return false;
4041
4042   /* Big-endian o64 pads floating-point arguments downward.  */
4043   if (mips_abi == ABI_O64)
4044     if (type != 0 ? FLOAT_TYPE_P (type) : GET_MODE_CLASS (mode) == MODE_FLOAT)
4045       return false;
4046
4047   /* Other types are padded upward for o32, o64, n32 and n64.  */
4048   if (mips_abi != ABI_EABI)
4049     return true;
4050
4051   /* Arguments smaller than a stack slot are padded downward.  */
4052   if (mode != BLKmode)
4053     return (GET_MODE_BITSIZE (mode) >= PARM_BOUNDARY);
4054   else
4055     return (int_size_in_bytes (type) >= (PARM_BOUNDARY / BITS_PER_UNIT));
4056 }
4057
4058
4059 /* Likewise BLOCK_REG_PADDING (MODE, TYPE, ...).  Return !BYTES_BIG_ENDIAN
4060    if the least significant byte of the register has useful data.  Return
4061    the opposite if the most significant byte does.  */
4062
4063 bool
4064 mips_pad_reg_upward (enum machine_mode mode, tree type)
4065 {
4066   /* No shifting is required for floating-point arguments.  */
4067   if (type != 0 ? FLOAT_TYPE_P (type) : GET_MODE_CLASS (mode) == MODE_FLOAT)
4068     return !BYTES_BIG_ENDIAN;
4069
4070   /* Otherwise, apply the same padding to register arguments as we do
4071      to stack arguments.  */
4072   return mips_pad_arg_upward (mode, type);
4073 }
4074 \f
4075 static void
4076 mips_setup_incoming_varargs (CUMULATIVE_ARGS *cum, enum machine_mode mode,
4077                              tree type, int *pretend_size ATTRIBUTE_UNUSED,
4078                              int no_rtl)
4079 {
4080   CUMULATIVE_ARGS local_cum;
4081   int gp_saved, fp_saved;
4082
4083   /* The caller has advanced CUM up to, but not beyond, the last named
4084      argument.  Advance a local copy of CUM past the last "real" named
4085      argument, to find out how many registers are left over.  */
4086
4087   local_cum = *cum;
4088   FUNCTION_ARG_ADVANCE (local_cum, mode, type, 1);
4089
4090   /* Found out how many registers we need to save.  */
4091   gp_saved = MAX_ARGS_IN_REGISTERS - local_cum.num_gprs;
4092   fp_saved = (EABI_FLOAT_VARARGS_P
4093               ? MAX_ARGS_IN_REGISTERS - local_cum.num_fprs
4094               : 0);
4095
4096   if (!no_rtl)
4097     {
4098       if (gp_saved > 0)
4099         {
4100           rtx ptr, mem;
4101
4102           ptr = plus_constant (virtual_incoming_args_rtx,
4103                                REG_PARM_STACK_SPACE (cfun->decl)
4104                                - gp_saved * UNITS_PER_WORD);
4105           mem = gen_rtx_MEM (BLKmode, ptr);
4106           set_mem_alias_set (mem, get_varargs_alias_set ());
4107
4108           move_block_from_reg (local_cum.num_gprs + GP_ARG_FIRST,
4109                                mem, gp_saved);
4110         }
4111       if (fp_saved > 0)
4112         {
4113           /* We can't use move_block_from_reg, because it will use
4114              the wrong mode.  */
4115           enum machine_mode mode;
4116           int off, i;
4117
4118           /* Set OFF to the offset from virtual_incoming_args_rtx of
4119              the first float register.  The FP save area lies below
4120              the integer one, and is aligned to UNITS_PER_FPVALUE bytes.  */
4121           off = -gp_saved * UNITS_PER_WORD;
4122           off &= ~(UNITS_PER_FPVALUE - 1);
4123           off -= fp_saved * UNITS_PER_FPREG;
4124
4125           mode = TARGET_SINGLE_FLOAT ? SFmode : DFmode;
4126
4127           for (i = local_cum.num_fprs; i < MAX_ARGS_IN_REGISTERS; i += FP_INC)
4128             {
4129               rtx ptr, mem;
4130
4131               ptr = plus_constant (virtual_incoming_args_rtx, off);
4132               mem = gen_rtx_MEM (mode, ptr);
4133               set_mem_alias_set (mem, get_varargs_alias_set ());
4134               emit_move_insn (mem, gen_rtx_REG (mode, FP_ARG_FIRST + i));
4135               off += UNITS_PER_HWFPVALUE;
4136             }
4137         }
4138     }
4139   if (REG_PARM_STACK_SPACE (cfun->decl) == 0)
4140     cfun->machine->varargs_size = (gp_saved * UNITS_PER_WORD
4141                                    + fp_saved * UNITS_PER_FPREG);
4142 }
4143
4144 /* Create the va_list data type.
4145    We keep 3 pointers, and two offsets.
4146    Two pointers are to the overflow area, which starts at the CFA.
4147      One of these is constant, for addressing into the GPR save area below it.
4148      The other is advanced up the stack through the overflow region.
4149    The third pointer is to the GPR save area.  Since the FPR save area
4150      is just below it, we can address FPR slots off this pointer.
4151    We also keep two one-byte offsets, which are to be subtracted from the
4152      constant pointers to yield addresses in the GPR and FPR save areas.
4153      These are downcounted as float or non-float arguments are used,
4154      and when they get to zero, the argument must be obtained from the
4155      overflow region.
4156    If !EABI_FLOAT_VARARGS_P, then no FPR save area exists, and a single
4157      pointer is enough.  It's started at the GPR save area, and is
4158      advanced, period.
4159    Note that the GPR save area is not constant size, due to optimization
4160      in the prologue.  Hence, we can't use a design with two pointers
4161      and two offsets, although we could have designed this with two pointers
4162      and three offsets.  */
4163
4164 static tree
4165 mips_build_builtin_va_list (void)
4166 {
4167   if (EABI_FLOAT_VARARGS_P)
4168     {
4169       tree f_ovfl, f_gtop, f_ftop, f_goff, f_foff, f_res, record;
4170       tree array, index;
4171
4172       record = (*lang_hooks.types.make_type) (RECORD_TYPE);
4173
4174       f_ovfl = build_decl (FIELD_DECL, get_identifier ("__overflow_argptr"),
4175                           ptr_type_node);
4176       f_gtop = build_decl (FIELD_DECL, get_identifier ("__gpr_top"),
4177                           ptr_type_node);
4178       f_ftop = build_decl (FIELD_DECL, get_identifier ("__fpr_top"),
4179                           ptr_type_node);
4180       f_goff = build_decl (FIELD_DECL, get_identifier ("__gpr_offset"),
4181                           unsigned_char_type_node);
4182       f_foff = build_decl (FIELD_DECL, get_identifier ("__fpr_offset"),
4183                           unsigned_char_type_node);
4184       /* Explicitly pad to the size of a pointer, so that -Wpadded won't
4185          warn on every user file.  */
4186       index = build_int_cst (NULL_TREE, GET_MODE_SIZE (ptr_mode) - 2 - 1);
4187       array = build_array_type (unsigned_char_type_node,
4188                                 build_index_type (index));
4189       f_res = build_decl (FIELD_DECL, get_identifier ("__reserved"), array);
4190
4191       DECL_FIELD_CONTEXT (f_ovfl) = record;
4192       DECL_FIELD_CONTEXT (f_gtop) = record;
4193       DECL_FIELD_CONTEXT (f_ftop) = record;
4194       DECL_FIELD_CONTEXT (f_goff) = record;
4195       DECL_FIELD_CONTEXT (f_foff) = record;
4196       DECL_FIELD_CONTEXT (f_res) = record;
4197
4198       TYPE_FIELDS (record) = f_ovfl;
4199       TREE_CHAIN (f_ovfl) = f_gtop;
4200       TREE_CHAIN (f_gtop) = f_ftop;
4201       TREE_CHAIN (f_ftop) = f_goff;
4202       TREE_CHAIN (f_goff) = f_foff;
4203       TREE_CHAIN (f_foff) = f_res;
4204
4205       layout_type (record);
4206       return record;
4207     }
4208   else if (TARGET_IRIX && TARGET_IRIX6)
4209     /* On IRIX 6, this type is 'char *'.  */
4210     return build_pointer_type (char_type_node);
4211   else
4212     /* Otherwise, we use 'void *'.  */
4213     return ptr_type_node;
4214 }
4215
4216 /* Implement va_start.  */
4217
4218 void
4219 mips_va_start (tree valist, rtx nextarg)
4220 {
4221   if (EABI_FLOAT_VARARGS_P)
4222     {
4223       const CUMULATIVE_ARGS *cum;
4224       tree f_ovfl, f_gtop, f_ftop, f_goff, f_foff;
4225       tree ovfl, gtop, ftop, goff, foff;
4226       tree t;
4227       int gpr_save_area_size;
4228       int fpr_save_area_size;
4229       int fpr_offset;
4230
4231       cum = &current_function_args_info;
4232       gpr_save_area_size
4233         = (MAX_ARGS_IN_REGISTERS - cum->num_gprs) * UNITS_PER_WORD;
4234       fpr_save_area_size
4235         = (MAX_ARGS_IN_REGISTERS - cum->num_fprs) * UNITS_PER_FPREG;
4236
4237       f_ovfl = TYPE_FIELDS (va_list_type_node);
4238       f_gtop = TREE_CHAIN (f_ovfl);
4239       f_ftop = TREE_CHAIN (f_gtop);
4240       f_goff = TREE_CHAIN (f_ftop);
4241       f_foff = TREE_CHAIN (f_goff);
4242
4243       ovfl = build3 (COMPONENT_REF, TREE_TYPE (f_ovfl), valist, f_ovfl,
4244                      NULL_TREE);
4245       gtop = build3 (COMPONENT_REF, TREE_TYPE (f_gtop), valist, f_gtop,
4246                      NULL_TREE);
4247       ftop = build3 (COMPONENT_REF, TREE_TYPE (f_ftop), valist, f_ftop,
4248                      NULL_TREE);
4249       goff = build3 (COMPONENT_REF, TREE_TYPE (f_goff), valist, f_goff,
4250                      NULL_TREE);
4251       foff = build3 (COMPONENT_REF, TREE_TYPE (f_foff), valist, f_foff,
4252                      NULL_TREE);
4253
4254       /* Emit code to initialize OVFL, which points to the next varargs
4255          stack argument.  CUM->STACK_WORDS gives the number of stack
4256          words used by named arguments.  */
4257       t = make_tree (TREE_TYPE (ovfl), virtual_incoming_args_rtx);
4258       if (cum->stack_words > 0)
4259         t = build2 (PLUS_EXPR, TREE_TYPE (ovfl), t,
4260                     build_int_cst (NULL_TREE,
4261                                    cum->stack_words * UNITS_PER_WORD));
4262       t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovfl), ovfl, t);
4263       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4264
4265       /* Emit code to initialize GTOP, the top of the GPR save area.  */
4266       t = make_tree (TREE_TYPE (gtop), virtual_incoming_args_rtx);
4267       t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (gtop), gtop, t);
4268       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4269
4270       /* Emit code to initialize FTOP, the top of the FPR save area.
4271          This address is gpr_save_area_bytes below GTOP, rounded
4272          down to the next fp-aligned boundary.  */
4273       t = make_tree (TREE_TYPE (ftop), virtual_incoming_args_rtx);
4274       fpr_offset = gpr_save_area_size + UNITS_PER_FPVALUE - 1;
4275       fpr_offset &= ~(UNITS_PER_FPVALUE - 1);
4276       if (fpr_offset)
4277         t = build2 (PLUS_EXPR, TREE_TYPE (ftop), t,
4278                     build_int_cst (NULL_TREE, -fpr_offset));
4279       t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ftop), ftop, t);
4280       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4281
4282       /* Emit code to initialize GOFF, the offset from GTOP of the
4283          next GPR argument.  */
4284       t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (goff), goff,
4285                   build_int_cst (NULL_TREE, gpr_save_area_size));
4286       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4287
4288       /* Likewise emit code to initialize FOFF, the offset from FTOP
4289          of the next FPR argument.  */
4290       t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (foff), foff,
4291                   build_int_cst (NULL_TREE, fpr_save_area_size));
4292       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4293     }
4294   else
4295     {
4296       nextarg = plus_constant (nextarg, -cfun->machine->varargs_size);
4297       std_expand_builtin_va_start (valist, nextarg);
4298     }
4299 }
4300 \f
4301 /* Implement va_arg.  */
4302
4303 static tree
4304 mips_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
4305 {
4306   HOST_WIDE_INT size, rsize;
4307   tree addr;
4308   bool indirect;
4309
4310   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, 0);
4311
4312   if (indirect)
4313     type = build_pointer_type (type);
4314
4315   size = int_size_in_bytes (type);
4316   rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
4317
4318   if (mips_abi != ABI_EABI || !EABI_FLOAT_VARARGS_P)
4319     addr = std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
4320   else
4321     {
4322       /* Not a simple merged stack.      */
4323
4324       tree f_ovfl, f_gtop, f_ftop, f_goff, f_foff;
4325       tree ovfl, top, off, align;
4326       HOST_WIDE_INT osize;
4327       tree t, u;
4328
4329       f_ovfl = TYPE_FIELDS (va_list_type_node);
4330       f_gtop = TREE_CHAIN (f_ovfl);
4331       f_ftop = TREE_CHAIN (f_gtop);
4332       f_goff = TREE_CHAIN (f_ftop);
4333       f_foff = TREE_CHAIN (f_goff);
4334
4335       /* We maintain separate pointers and offsets for floating-point
4336          and integer arguments, but we need similar code in both cases.
4337          Let:
4338
4339          TOP be the top of the register save area;
4340          OFF be the offset from TOP of the next register;
4341          ADDR_RTX be the address of the argument;
4342          RSIZE be the number of bytes used to store the argument
4343          when it's in the register save area;
4344          OSIZE be the number of bytes used to store it when it's
4345          in the stack overflow area; and
4346          PADDING be (BYTES_BIG_ENDIAN ? OSIZE - RSIZE : 0)
4347
4348          The code we want is:
4349
4350          1: off &= -rsize;        // round down
4351          2: if (off != 0)
4352          3:   {
4353          4:      addr_rtx = top - off;
4354          5:      off -= rsize;
4355          6:   }
4356          7: else
4357          8:   {
4358          9:      ovfl += ((intptr_t) ovfl + osize - 1) & -osize;
4359          10:     addr_rtx = ovfl + PADDING;
4360          11:     ovfl += osize;
4361          14:   }
4362
4363          [1] and [9] can sometimes be optimized away.  */
4364
4365       ovfl = build3 (COMPONENT_REF, TREE_TYPE (f_ovfl), valist, f_ovfl,
4366                      NULL_TREE);
4367
4368       if (GET_MODE_CLASS (TYPE_MODE (type)) == MODE_FLOAT
4369           && GET_MODE_SIZE (TYPE_MODE (type)) <= UNITS_PER_FPVALUE)
4370         {
4371           top = build3 (COMPONENT_REF, TREE_TYPE (f_ftop), valist, f_ftop,
4372                         NULL_TREE);
4373           off = build3 (COMPONENT_REF, TREE_TYPE (f_foff), valist, f_foff,
4374                         NULL_TREE);
4375
4376           /* When floating-point registers are saved to the stack,
4377              each one will take up UNITS_PER_HWFPVALUE bytes, regardless
4378              of the float's precision.  */
4379           rsize = UNITS_PER_HWFPVALUE;
4380
4381           /* Overflow arguments are padded to UNITS_PER_WORD bytes
4382              (= PARM_BOUNDARY bits).  This can be different from RSIZE
4383              in two cases:
4384
4385              (1) On 32-bit targets when TYPE is a structure such as:
4386
4387              struct s { float f; };
4388
4389              Such structures are passed in paired FPRs, so RSIZE
4390              will be 8 bytes.  However, the structure only takes
4391              up 4 bytes of memory, so OSIZE will only be 4.
4392
4393              (2) In combinations such as -mgp64 -msingle-float
4394              -fshort-double.  Doubles passed in registers
4395              will then take up 4 (UNITS_PER_HWFPVALUE) bytes,
4396              but those passed on the stack take up
4397              UNITS_PER_WORD bytes.  */
4398           osize = MAX (GET_MODE_SIZE (TYPE_MODE (type)), UNITS_PER_WORD);
4399         }
4400       else
4401         {
4402           top = build3 (COMPONENT_REF, TREE_TYPE (f_gtop), valist, f_gtop,
4403                         NULL_TREE);
4404           off = build3 (COMPONENT_REF, TREE_TYPE (f_goff), valist, f_goff,
4405                         NULL_TREE);
4406           if (rsize > UNITS_PER_WORD)
4407             {
4408               /* [1] Emit code for: off &= -rsize.      */
4409               t = build2 (BIT_AND_EXPR, TREE_TYPE (off), off,
4410                           build_int_cst (NULL_TREE, -rsize));
4411               t = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (off), off, t);
4412               gimplify_and_add (t, pre_p);
4413             }
4414           osize = rsize;
4415         }
4416
4417       /* [2] Emit code to branch if off == 0.  */
4418       t = build2 (NE_EXPR, boolean_type_node, off,
4419                   build_int_cst (TREE_TYPE (off), 0));
4420       addr = build3 (COND_EXPR, ptr_type_node, t, NULL_TREE, NULL_TREE);
4421
4422       /* [5] Emit code for: off -= rsize.  We do this as a form of
4423          post-increment not available to C.  Also widen for the
4424          coming pointer arithmetic.  */
4425       t = fold_convert (TREE_TYPE (off), build_int_cst (NULL_TREE, rsize));
4426       t = build2 (POSTDECREMENT_EXPR, TREE_TYPE (off), off, t);
4427       t = fold_convert (sizetype, t);
4428       t = fold_convert (TREE_TYPE (top), t);
4429
4430       /* [4] Emit code for: addr_rtx = top - off.  On big endian machines,
4431          the argument has RSIZE - SIZE bytes of leading padding.  */
4432       t = build2 (MINUS_EXPR, TREE_TYPE (top), top, t);
4433       if (BYTES_BIG_ENDIAN && rsize > size)
4434         {
4435           u = fold_convert (TREE_TYPE (t), build_int_cst (NULL_TREE,
4436                                                           rsize - size));
4437           t = build2 (PLUS_EXPR, TREE_TYPE (t), t, u);
4438         }
4439       COND_EXPR_THEN (addr) = t;
4440
4441       if (osize > UNITS_PER_WORD)
4442         {
4443           /* [9] Emit: ovfl += ((intptr_t) ovfl + osize - 1) & -osize.  */
4444           u = fold_convert (TREE_TYPE (ovfl),
4445                             build_int_cst (NULL_TREE, osize - 1));
4446           t = build2 (PLUS_EXPR, TREE_TYPE (ovfl), ovfl, u);
4447           u = fold_convert (TREE_TYPE (ovfl),
4448                             build_int_cst (NULL_TREE, -osize));
4449           t = build2 (BIT_AND_EXPR, TREE_TYPE (ovfl), t, u);
4450           align = build2 (GIMPLE_MODIFY_STMT, TREE_TYPE (ovfl), ovfl, t);
4451         }
4452       else
4453         align = NULL;
4454
4455       /* [10, 11].      Emit code to store ovfl in addr_rtx, then
4456          post-increment ovfl by osize.  On big-endian machines,
4457          the argument has OSIZE - SIZE bytes of leading padding.  */
4458       u = fold_convert (TREE_TYPE (ovfl),
4459                         build_int_cst (NULL_TREE, osize));
4460       t = build2 (POSTINCREMENT_EXPR, TREE_TYPE (ovfl), ovfl, u);
4461       if (BYTES_BIG_ENDIAN && osize > size)
4462         {
4463           u = fold_convert (TREE_TYPE (t),
4464                             build_int_cst (NULL_TREE, osize - size));
4465           t = build2 (PLUS_EXPR, TREE_TYPE (t), t, u);
4466         }
4467
4468       /* String [9] and [10,11] together.  */
4469       if (align)
4470         t = build2 (COMPOUND_EXPR, TREE_TYPE (t), align, t);
4471       COND_EXPR_ELSE (addr) = t;
4472
4473       addr = fold_convert (build_pointer_type (type), addr);
4474       addr = build_va_arg_indirect_ref (addr);
4475     }
4476
4477   if (indirect)
4478     addr = build_va_arg_indirect_ref (addr);
4479
4480   return addr;
4481 }
4482 \f
4483 /* Return true if it is possible to use left/right accesses for a
4484    bitfield of WIDTH bits starting BITPOS bits into *OP.  When
4485    returning true, update *OP, *LEFT and *RIGHT as follows:
4486
4487    *OP is a BLKmode reference to the whole field.
4488
4489    *LEFT is a QImode reference to the first byte if big endian or
4490    the last byte if little endian.  This address can be used in the
4491    left-side instructions (lwl, swl, ldl, sdl).
4492
4493    *RIGHT is a QImode reference to the opposite end of the field and
4494    can be used in the patterning right-side instruction.  */
4495
4496 static bool
4497 mips_get_unaligned_mem (rtx *op, unsigned int width, int bitpos,
4498                         rtx *left, rtx *right)
4499 {
4500   rtx first, last;
4501
4502   /* Check that the operand really is a MEM.  Not all the extv and
4503      extzv predicates are checked.  */
4504   if (!MEM_P (*op))
4505     return false;
4506
4507   /* Check that the size is valid.  */
4508   if (width != 32 && (!TARGET_64BIT || width != 64))
4509     return false;
4510
4511   /* We can only access byte-aligned values.  Since we are always passed
4512      a reference to the first byte of the field, it is not necessary to
4513      do anything with BITPOS after this check.  */
4514   if (bitpos % BITS_PER_UNIT != 0)
4515     return false;
4516
4517   /* Reject aligned bitfields: we want to use a normal load or store
4518      instead of a left/right pair.  */
4519   if (MEM_ALIGN (*op) >= width)
4520     return false;
4521
4522   /* Adjust *OP to refer to the whole field.  This also has the effect
4523      of legitimizing *OP's address for BLKmode, possibly simplifying it.  */
4524   *op = adjust_address (*op, BLKmode, 0);
4525   set_mem_size (*op, GEN_INT (width / BITS_PER_UNIT));
4526
4527   /* Get references to both ends of the field.  We deliberately don't
4528      use the original QImode *OP for FIRST since the new BLKmode one
4529      might have a simpler address.  */
4530   first = adjust_address (*op, QImode, 0);
4531   last = adjust_address (*op, QImode, width / BITS_PER_UNIT - 1);
4532
4533   /* Allocate to LEFT and RIGHT according to endianness.  LEFT should
4534      be the upper word and RIGHT the lower word.  */
4535   if (TARGET_BIG_ENDIAN)
4536     *left = first, *right = last;
4537   else
4538     *left = last, *right = first;
4539
4540   return true;
4541 }
4542
4543
4544 /* Try to emit the equivalent of (set DEST (zero_extract SRC WIDTH BITPOS)).
4545    Return true on success.  We only handle cases where zero_extract is
4546    equivalent to sign_extract.  */
4547
4548 bool
4549 mips_expand_unaligned_load (rtx dest, rtx src, unsigned int width, int bitpos)
4550 {
4551   rtx left, right, temp;
4552
4553   /* If TARGET_64BIT, the destination of a 32-bit load will be a
4554      paradoxical word_mode subreg.  This is the only case in which
4555      we allow the destination to be larger than the source.  */
4556   if (GET_CODE (dest) == SUBREG
4557       && GET_MODE (dest) == DImode
4558       && SUBREG_BYTE (dest) == 0
4559       && GET_MODE (SUBREG_REG (dest)) == SImode)
4560     dest = SUBREG_REG (dest);
4561
4562   /* After the above adjustment, the destination must be the same
4563      width as the source.  */
4564   if (GET_MODE_BITSIZE (GET_MODE (dest)) != width)
4565     return false;
4566
4567   if (!mips_get_unaligned_mem (&src, width, bitpos, &left, &right))
4568     return false;
4569
4570   temp = gen_reg_rtx (GET_MODE (dest));
4571   if (GET_MODE (dest) == DImode)
4572     {
4573       emit_insn (gen_mov_ldl (temp, src, left));
4574       emit_insn (gen_mov_ldr (dest, copy_rtx (src), right, temp));
4575     }
4576   else
4577     {
4578       emit_insn (gen_mov_lwl (temp, src, left));
4579       emit_insn (gen_mov_lwr (dest, copy_rtx (src), right, temp));
4580     }
4581   return true;
4582 }
4583
4584
4585 /* Try to expand (set (zero_extract DEST WIDTH BITPOS) SRC).  Return
4586    true on success.  */
4587
4588 bool
4589 mips_expand_unaligned_store (rtx dest, rtx src, unsigned int width, int bitpos)
4590 {
4591   rtx left, right;
4592   enum machine_mode mode;
4593
4594   if (!mips_get_unaligned_mem (&dest, width, bitpos, &left, &right))
4595     return false;
4596
4597   mode = mode_for_size (width, MODE_INT, 0);
4598   src = gen_lowpart (mode, src);
4599
4600   if (mode == DImode)
4601     {
4602       emit_insn (gen_mov_sdl (dest, src, left));
4603       emit_insn (gen_mov_sdr (copy_rtx (dest), copy_rtx (src), right));
4604     }
4605   else
4606     {
4607       emit_insn (gen_mov_swl (dest, src, left));
4608       emit_insn (gen_mov_swr (copy_rtx (dest), copy_rtx (src), right));
4609     }
4610   return true;
4611 }
4612
4613 /* Return true if X is a MEM with the same size as MODE.  */
4614
4615 bool
4616 mips_mem_fits_mode_p (enum machine_mode mode, rtx x)
4617 {
4618   rtx size;
4619
4620   if (!MEM_P (x))
4621     return false;
4622
4623   size = MEM_SIZE (x);
4624   return size && INTVAL (size) == GET_MODE_SIZE (mode);
4625 }
4626
4627 /* Return true if (zero_extract OP SIZE POSITION) can be used as the
4628    source of an "ext" instruction or the destination of an "ins"
4629    instruction.  OP must be a register operand and the following
4630    conditions must hold:
4631
4632      0 <= POSITION < GET_MODE_BITSIZE (GET_MODE (op))
4633      0 < SIZE <= GET_MODE_BITSIZE (GET_MODE (op))
4634      0 < POSITION + SIZE <= GET_MODE_BITSIZE (GET_MODE (op))
4635
4636    Also reject lengths equal to a word as they are better handled
4637    by the move patterns.  */
4638
4639 bool
4640 mips_use_ins_ext_p (rtx op, rtx size, rtx position)
4641 {
4642   HOST_WIDE_INT len, pos;
4643
4644   if (!ISA_HAS_EXT_INS
4645       || !register_operand (op, VOIDmode)
4646       || GET_MODE_BITSIZE (GET_MODE (op)) > BITS_PER_WORD)
4647     return false;
4648
4649   len = INTVAL (size);
4650   pos = INTVAL (position);
4651
4652   if (len <= 0 || len >= GET_MODE_BITSIZE (GET_MODE (op))
4653       || pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (op)))
4654     return false;
4655
4656   return true;
4657 }
4658
4659 /* Set up globals to generate code for the ISA or processor
4660    described by INFO.  */
4661
4662 static void
4663 mips_set_architecture (const struct mips_cpu_info *info)
4664 {
4665   if (info != 0)
4666     {
4667       mips_arch_info = info;
4668       mips_arch = info->cpu;
4669       mips_isa = info->isa;
4670     }
4671 }
4672
4673
4674 /* Likewise for tuning.  */
4675
4676 static void
4677 mips_set_tune (const struct mips_cpu_info *info)
4678 {
4679   if (info != 0)
4680     {
4681       mips_tune_info = info;
4682       mips_tune = info->cpu;
4683     }
4684 }
4685
4686 /* Implement TARGET_HANDLE_OPTION.  */
4687
4688 static bool
4689 mips_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
4690 {
4691   switch (code)
4692     {
4693     case OPT_mabi_:
4694       if (strcmp (arg, "32") == 0)
4695         mips_abi = ABI_32;
4696       else if (strcmp (arg, "o64") == 0)
4697         mips_abi = ABI_O64;
4698       else if (strcmp (arg, "n32") == 0)
4699         mips_abi = ABI_N32;
4700       else if (strcmp (arg, "64") == 0)
4701         mips_abi = ABI_64;
4702       else if (strcmp (arg, "eabi") == 0)
4703         mips_abi = ABI_EABI;
4704       else
4705         return false;
4706       return true;
4707
4708     case OPT_march_:
4709     case OPT_mtune_:
4710       return mips_parse_cpu (arg) != 0;
4711
4712     case OPT_mips:
4713       mips_isa_info = mips_parse_cpu (ACONCAT (("mips", arg, NULL)));
4714       return mips_isa_info != 0;
4715
4716     case OPT_mno_flush_func:
4717       mips_cache_flush_func = NULL;
4718       return true;
4719
4720     default:
4721       return true;
4722     }
4723 }
4724
4725 /* Set up the threshold for data to go into the small data area, instead
4726    of the normal data area, and detect any conflicts in the switches.  */
4727
4728 void
4729 override_options (void)
4730 {
4731   int i, start, regno;
4732   enum machine_mode mode;
4733
4734   mips_section_threshold = g_switch_set ? g_switch_value : MIPS_DEFAULT_GVALUE;
4735
4736   /* The following code determines the architecture and register size.
4737      Similar code was added to GAS 2.14 (see tc-mips.c:md_after_parse_args()).
4738      The GAS and GCC code should be kept in sync as much as possible.  */
4739
4740   if (mips_arch_string != 0)
4741     mips_set_architecture (mips_parse_cpu (mips_arch_string));
4742
4743   if (mips_isa_info != 0)
4744     {
4745       if (mips_arch_info == 0)
4746         mips_set_architecture (mips_isa_info);
4747       else if (mips_arch_info->isa != mips_isa_info->isa)
4748         error ("-%s conflicts with the other architecture options, "
4749                "which specify a %s processor",
4750                mips_isa_info->name,
4751                mips_cpu_info_from_isa (mips_arch_info->isa)->name);
4752     }
4753
4754   if (mips_arch_info == 0)
4755     {
4756 #ifdef MIPS_CPU_STRING_DEFAULT
4757       mips_set_architecture (mips_parse_cpu (MIPS_CPU_STRING_DEFAULT));
4758 #else
4759       mips_set_architecture (mips_cpu_info_from_isa (MIPS_ISA_DEFAULT));
4760 #endif
4761     }
4762
4763   if (ABI_NEEDS_64BIT_REGS && !ISA_HAS_64BIT_REGS)
4764     error ("-march=%s is not compatible with the selected ABI",
4765            mips_arch_info->name);
4766
4767   /* Optimize for mips_arch, unless -mtune selects a different processor.  */
4768   if (mips_tune_string != 0)
4769     mips_set_tune (mips_parse_cpu (mips_tune_string));
4770
4771   if (mips_tune_info == 0)
4772     mips_set_tune (mips_arch_info);
4773
4774   /* Set cost structure for the processor.  */
4775   if (optimize_size)
4776     mips_cost = &mips_rtx_cost_optimize_size;
4777   else
4778     mips_cost = &mips_rtx_cost_data[mips_tune];
4779
4780   if ((target_flags_explicit & MASK_64BIT) != 0)
4781     {
4782       /* The user specified the size of the integer registers.  Make sure
4783          it agrees with the ABI and ISA.  */
4784       if (TARGET_64BIT && !ISA_HAS_64BIT_REGS)
4785         error ("-mgp64 used with a 32-bit processor");
4786       else if (!TARGET_64BIT && ABI_NEEDS_64BIT_REGS)
4787         error ("-mgp32 used with a 64-bit ABI");
4788       else if (TARGET_64BIT && ABI_NEEDS_32BIT_REGS)
4789         error ("-mgp64 used with a 32-bit ABI");
4790     }
4791   else
4792     {
4793       /* Infer the integer register size from the ABI and processor.
4794          Restrict ourselves to 32-bit registers if that's all the
4795          processor has, or if the ABI cannot handle 64-bit registers.  */
4796       if (ABI_NEEDS_32BIT_REGS || !ISA_HAS_64BIT_REGS)
4797         target_flags &= ~MASK_64BIT;
4798       else
4799         target_flags |= MASK_64BIT;
4800     }
4801
4802   if ((target_flags_explicit & MASK_FLOAT64) != 0)
4803     {
4804       /* Really, -mfp32 and -mfp64 are ornamental options.  There's
4805          only one right answer here.  */
4806       if (TARGET_64BIT && TARGET_DOUBLE_FLOAT && !TARGET_FLOAT64)
4807         error ("unsupported combination: %s", "-mgp64 -mfp32 -mdouble-float");
4808       else if (!TARGET_64BIT && TARGET_FLOAT64
4809                && !(ISA_HAS_MXHC1 && mips_abi == ABI_32))
4810         error ("-mgp32 and -mfp64 can only be combined if the target"
4811                " supports the mfhc1 and mthc1 instructions");
4812       else if (TARGET_SINGLE_FLOAT && TARGET_FLOAT64)
4813         error ("unsupported combination: %s", "-mfp64 -msingle-float");
4814     }
4815   else
4816     {
4817       /* -msingle-float selects 32-bit float registers.  Otherwise the
4818          float registers should be the same size as the integer ones.  */
4819       if (TARGET_64BIT && TARGET_DOUBLE_FLOAT)
4820         target_flags |= MASK_FLOAT64;
4821       else
4822         target_flags &= ~MASK_FLOAT64;
4823     }
4824
4825   /* End of code shared with GAS.  */
4826
4827   if ((target_flags_explicit & MASK_LONG64) == 0)
4828     {
4829       if ((mips_abi == ABI_EABI && TARGET_64BIT) || mips_abi == ABI_64)
4830         target_flags |= MASK_LONG64;
4831       else
4832         target_flags &= ~MASK_LONG64;
4833     }
4834
4835   if (MIPS_MARCH_CONTROLS_SOFT_FLOAT
4836       && (target_flags_explicit & MASK_SOFT_FLOAT) == 0)
4837     {
4838       /* For some configurations, it is useful to have -march control
4839          the default setting of MASK_SOFT_FLOAT.  */
4840       switch ((int) mips_arch)
4841         {
4842         case PROCESSOR_R4100:
4843         case PROCESSOR_R4111:
4844         case PROCESSOR_R4120:
4845         case PROCESSOR_R4130:
4846           target_flags |= MASK_SOFT_FLOAT;
4847           break;
4848
4849         default:
4850           target_flags &= ~MASK_SOFT_FLOAT;
4851           break;
4852         }
4853     }
4854
4855   if (!TARGET_OLDABI)
4856     flag_pcc_struct_return = 0;
4857
4858   if ((target_flags_explicit & MASK_BRANCHLIKELY) == 0)
4859     {
4860       /* If neither -mbranch-likely nor -mno-branch-likely was given
4861          on the command line, set MASK_BRANCHLIKELY based on the target
4862          architecture.
4863
4864          By default, we enable use of Branch Likely instructions on
4865          all architectures which support them with the following
4866          exceptions: when creating MIPS32 or MIPS64 code, and when
4867          tuning for architectures where their use tends to hurt
4868          performance.
4869
4870          The MIPS32 and MIPS64 architecture specifications say "Software
4871          is strongly encouraged to avoid use of Branch Likely
4872          instructions, as they will be removed from a future revision
4873          of the [MIPS32 and MIPS64] architecture."  Therefore, we do not
4874          issue those instructions unless instructed to do so by
4875          -mbranch-likely.  */
4876       if (ISA_HAS_BRANCHLIKELY
4877           && !(ISA_MIPS32 || ISA_MIPS32R2 || ISA_MIPS64)
4878           && !(TUNE_MIPS5500 || TUNE_SB1))
4879         target_flags |= MASK_BRANCHLIKELY;
4880       else
4881         target_flags &= ~MASK_BRANCHLIKELY;
4882     }
4883   if (TARGET_BRANCHLIKELY && !ISA_HAS_BRANCHLIKELY)
4884     warning (0, "generation of Branch Likely instructions enabled, but not supported by architecture");
4885
4886   /* The effect of -mabicalls isn't defined for the EABI.  */
4887   if (mips_abi == ABI_EABI && TARGET_ABICALLS)
4888     {
4889       error ("unsupported combination: %s", "-mabicalls -mabi=eabi");
4890       target_flags &= ~MASK_ABICALLS;
4891     }
4892
4893   if (TARGET_ABICALLS)
4894     {
4895       /* We need to set flag_pic for executables as well as DSOs
4896          because we may reference symbols that are not defined in
4897          the final executable.  (MIPS does not use things like
4898          copy relocs, for example.)
4899
4900          Also, there is a body of code that uses __PIC__ to distinguish
4901          between -mabicalls and -mno-abicalls code.  */
4902       flag_pic = 1;
4903       if (mips_section_threshold > 0)
4904         warning (0, "%<-G%> is incompatible with %<-mabicalls%>");
4905     }
4906
4907   /* mips_split_addresses is a half-way house between explicit
4908      relocations and the traditional assembler macros.  It can
4909      split absolute 32-bit symbolic constants into a high/lo_sum
4910      pair but uses macros for other sorts of access.
4911
4912      Like explicit relocation support for REL targets, it relies
4913      on GNU extensions in the assembler and the linker.
4914
4915      Although this code should work for -O0, it has traditionally
4916      been treated as an optimization.  */
4917   if (!TARGET_MIPS16 && TARGET_SPLIT_ADDRESSES
4918       && optimize && !flag_pic
4919       && !ABI_HAS_64BIT_SYMBOLS)
4920     mips_split_addresses = 1;
4921   else
4922     mips_split_addresses = 0;
4923
4924   /* -mvr4130-align is a "speed over size" optimization: it usually produces
4925      faster code, but at the expense of more nops.  Enable it at -O3 and
4926      above.  */
4927   if (optimize > 2 && (target_flags_explicit & MASK_VR4130_ALIGN) == 0)
4928     target_flags |= MASK_VR4130_ALIGN;
4929
4930   /* When compiling for the mips16, we cannot use floating point.  We
4931      record the original hard float value in mips16_hard_float.  */
4932   if (TARGET_MIPS16)
4933     {
4934       if (TARGET_SOFT_FLOAT)
4935         mips16_hard_float = 0;
4936       else
4937         mips16_hard_float = 1;
4938       target_flags |= MASK_SOFT_FLOAT;
4939
4940       /* Don't run the scheduler before reload, since it tends to
4941          increase register pressure.  */
4942       flag_schedule_insns = 0;
4943
4944       /* Don't do hot/cold partitioning.  The constant layout code expects
4945          the whole function to be in a single section.  */
4946       flag_reorder_blocks_and_partition = 0;
4947
4948       /* Silently disable -mexplicit-relocs since it doesn't apply
4949          to mips16 code.  Even so, it would overly pedantic to warn
4950          about "-mips16 -mexplicit-relocs", especially given that
4951          we use a %gprel() operator.  */
4952       target_flags &= ~MASK_EXPLICIT_RELOCS;
4953     }
4954
4955   /* When using explicit relocs, we call dbr_schedule from within
4956      mips_reorg.  */
4957   if (TARGET_EXPLICIT_RELOCS)
4958     {
4959       mips_flag_delayed_branch = flag_delayed_branch;
4960       flag_delayed_branch = 0;
4961     }
4962
4963 #ifdef MIPS_TFMODE_FORMAT
4964   REAL_MODE_FORMAT (TFmode) = &MIPS_TFMODE_FORMAT;
4965 #endif
4966
4967   /* Make sure that the user didn't turn off paired single support when
4968      MIPS-3D support is requested.  */
4969   if (TARGET_MIPS3D && (target_flags_explicit & MASK_PAIRED_SINGLE_FLOAT)
4970       && !TARGET_PAIRED_SINGLE_FLOAT)
4971     error ("-mips3d requires -mpaired-single");
4972
4973   /* If TARGET_MIPS3D, enable MASK_PAIRED_SINGLE_FLOAT.  */
4974   if (TARGET_MIPS3D)
4975     target_flags |= MASK_PAIRED_SINGLE_FLOAT;
4976
4977   /* Make sure that when TARGET_PAIRED_SINGLE_FLOAT is true, TARGET_FLOAT64
4978      and TARGET_HARD_FLOAT are both true.  */
4979   if (TARGET_PAIRED_SINGLE_FLOAT && !(TARGET_FLOAT64 && TARGET_HARD_FLOAT))
4980     error ("-mips3d/-mpaired-single must be used with -mfp64 -mhard-float");
4981
4982   /* Make sure that the ISA supports TARGET_PAIRED_SINGLE_FLOAT when it is
4983      enabled.  */
4984   if (TARGET_PAIRED_SINGLE_FLOAT && !ISA_MIPS64)
4985     error ("-mips3d/-mpaired-single must be used with -mips64");
4986
4987   if (TARGET_MIPS16 && TARGET_DSP)
4988     error ("-mips16 and -mdsp cannot be used together");
4989
4990   mips_print_operand_punct['?'] = 1;
4991   mips_print_operand_punct['#'] = 1;
4992   mips_print_operand_punct['/'] = 1;
4993   mips_print_operand_punct['&'] = 1;
4994   mips_print_operand_punct['!'] = 1;
4995   mips_print_operand_punct['*'] = 1;
4996   mips_print_operand_punct['@'] = 1;
4997   mips_print_operand_punct['.'] = 1;
4998   mips_print_operand_punct['('] = 1;
4999   mips_print_operand_punct[')'] = 1;
5000   mips_print_operand_punct['['] = 1;
5001   mips_print_operand_punct[']'] = 1;
5002   mips_print_operand_punct['<'] = 1;
5003   mips_print_operand_punct['>'] = 1;
5004   mips_print_operand_punct['{'] = 1;
5005   mips_print_operand_punct['}'] = 1;
5006   mips_print_operand_punct['^'] = 1;
5007   mips_print_operand_punct['$'] = 1;
5008   mips_print_operand_punct['+'] = 1;
5009   mips_print_operand_punct['~'] = 1;
5010
5011   /* Set up array to map GCC register number to debug register number.
5012      Ignore the special purpose register numbers.  */
5013
5014   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5015     mips_dbx_regno[i] = -1;
5016
5017   start = GP_DBX_FIRST - GP_REG_FIRST;
5018   for (i = GP_REG_FIRST; i <= GP_REG_LAST; i++)
5019     mips_dbx_regno[i] = i + start;
5020
5021   start = FP_DBX_FIRST - FP_REG_FIRST;
5022   for (i = FP_REG_FIRST; i <= FP_REG_LAST; i++)
5023     mips_dbx_regno[i] = i + start;
5024
5025   mips_dbx_regno[HI_REGNUM] = MD_DBX_FIRST + 0;
5026   mips_dbx_regno[LO_REGNUM] = MD_DBX_FIRST + 1;
5027
5028   /* Set up array giving whether a given register can hold a given mode.  */
5029
5030   for (mode = VOIDmode;
5031        mode != MAX_MACHINE_MODE;
5032        mode = (enum machine_mode) ((int)mode + 1))
5033     {
5034       register int size              = GET_MODE_SIZE (mode);
5035       register enum mode_class class = GET_MODE_CLASS (mode);
5036
5037       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
5038         {
5039           register int temp;
5040
5041           if (mode == CCV2mode)
5042             temp = (ISA_HAS_8CC
5043                     && ST_REG_P (regno)
5044                     && (regno - ST_REG_FIRST) % 2 == 0);
5045
5046           else if (mode == CCV4mode)
5047             temp = (ISA_HAS_8CC
5048                     && ST_REG_P (regno)
5049                     && (regno - ST_REG_FIRST) % 4 == 0);
5050
5051           else if (mode == CCmode)
5052             {
5053               if (! ISA_HAS_8CC)
5054                 temp = (regno == FPSW_REGNUM);
5055               else
5056                 temp = (ST_REG_P (regno) || GP_REG_P (regno)
5057                         || FP_REG_P (regno));
5058             }
5059
5060           else if (GP_REG_P (regno))
5061             temp = ((regno & 1) == 0 || size <= UNITS_PER_WORD);
5062
5063           else if (FP_REG_P (regno))
5064             temp = ((regno % FP_INC) == 0)
5065                     && (((class == MODE_FLOAT || class == MODE_COMPLEX_FLOAT
5066                           || class == MODE_VECTOR_FLOAT)
5067                          && size <= UNITS_PER_FPVALUE)
5068                         /* Allow integer modes that fit into a single
5069                            register.  We need to put integers into FPRs
5070                            when using instructions like cvt and trunc.
5071                            We can't allow sizes smaller than a word,
5072                            the FPU has no appropriate load/store
5073                            instructions for those.  */
5074                         || (class == MODE_INT
5075                             && size >= MIN_UNITS_PER_WORD
5076                             && size <= UNITS_PER_FPREG)
5077                         /* Allow TFmode for CCmode reloads.  */
5078                         || (ISA_HAS_8CC && mode == TFmode));
5079
5080           else if (ACC_REG_P (regno))
5081             temp = (INTEGRAL_MODE_P (mode)
5082                     && (size <= UNITS_PER_WORD
5083                         || (ACC_HI_REG_P (regno)
5084                             && size == 2 * UNITS_PER_WORD)));
5085
5086           else if (ALL_COP_REG_P (regno))
5087             temp = (class == MODE_INT && size <= UNITS_PER_WORD);
5088           else
5089             temp = 0;
5090
5091           mips_hard_regno_mode_ok[(int)mode][regno] = temp;
5092         }
5093     }
5094
5095   /* Save GPR registers in word_mode sized hunks.  word_mode hasn't been
5096      initialized yet, so we can't use that here.  */
5097   gpr_mode = TARGET_64BIT ? DImode : SImode;
5098
5099   /* Provide default values for align_* for 64-bit targets.  */
5100   if (TARGET_64BIT && !TARGET_MIPS16)
5101     {
5102       if (align_loops == 0)
5103         align_loops = 8;
5104       if (align_jumps == 0)
5105         align_jumps = 8;
5106       if (align_functions == 0)
5107         align_functions = 8;
5108     }
5109
5110   /* Function to allocate machine-dependent function status.  */
5111   init_machine_status = &mips_init_machine_status;
5112
5113   if (ABI_HAS_64BIT_SYMBOLS)
5114     {
5115       if (TARGET_EXPLICIT_RELOCS)
5116         {
5117           mips_split_p[SYMBOL_64_HIGH] = true;
5118           mips_hi_relocs[SYMBOL_64_HIGH] = "%highest(";
5119           mips_lo_relocs[SYMBOL_64_HIGH] = "%higher(";
5120
5121           mips_split_p[SYMBOL_64_MID] = true;
5122           mips_hi_relocs[SYMBOL_64_MID] = "%higher(";
5123           mips_lo_relocs[SYMBOL_64_MID] = "%hi(";
5124
5125           mips_split_p[SYMBOL_64_LOW] = true;
5126           mips_hi_relocs[SYMBOL_64_LOW] = "%hi(";
5127           mips_lo_relocs[SYMBOL_64_LOW] = "%lo(";
5128
5129           mips_split_p[SYMBOL_GENERAL] = true;
5130           mips_lo_relocs[SYMBOL_GENERAL] = "%lo(";
5131         }
5132     }
5133   else
5134     {
5135       if (TARGET_EXPLICIT_RELOCS || mips_split_addresses)
5136         {
5137           mips_split_p[SYMBOL_GENERAL] = true;
5138           mips_hi_relocs[SYMBOL_GENERAL] = "%hi(";
5139           mips_lo_relocs[SYMBOL_GENERAL] = "%lo(";
5140         }
5141     }
5142
5143   if (TARGET_MIPS16)
5144     {
5145       /* The high part is provided by a pseudo copy of $gp.  */
5146       mips_split_p[SYMBOL_SMALL_DATA] = true;
5147       mips_lo_relocs[SYMBOL_SMALL_DATA] = "%gprel(";
5148     }
5149
5150   if (TARGET_EXPLICIT_RELOCS)
5151     {
5152       /* Small data constants are kept whole until after reload,
5153          then lowered by mips_rewrite_small_data.  */
5154       mips_lo_relocs[SYMBOL_SMALL_DATA] = "%gp_rel(";
5155
5156       mips_split_p[SYMBOL_GOT_LOCAL] = true;
5157       if (TARGET_NEWABI)
5158         {
5159           mips_lo_relocs[SYMBOL_GOTOFF_PAGE] = "%got_page(";
5160           mips_lo_relocs[SYMBOL_GOT_LOCAL] = "%got_ofst(";
5161         }
5162       else
5163         {
5164           mips_lo_relocs[SYMBOL_GOTOFF_PAGE] = "%got(";
5165           mips_lo_relocs[SYMBOL_GOT_LOCAL] = "%lo(";
5166         }
5167
5168       if (TARGET_XGOT)
5169         {
5170           /* The HIGH and LO_SUM are matched by special .md patterns.  */
5171           mips_split_p[SYMBOL_GOT_GLOBAL] = true;
5172
5173           mips_split_p[SYMBOL_GOTOFF_GLOBAL] = true;
5174           mips_hi_relocs[SYMBOL_GOTOFF_GLOBAL] = "%got_hi(";
5175           mips_lo_relocs[SYMBOL_GOTOFF_GLOBAL] = "%got_lo(";
5176
5177           mips_split_p[SYMBOL_GOTOFF_CALL] = true;
5178           mips_hi_relocs[SYMBOL_GOTOFF_CALL] = "%call_hi(";
5179           mips_lo_relocs[SYMBOL_GOTOFF_CALL] = "%call_lo(";
5180         }
5181       else
5182         {
5183           if (TARGET_NEWABI)
5184             mips_lo_relocs[SYMBOL_GOTOFF_GLOBAL] = "%got_disp(";
5185           else
5186             mips_lo_relocs[SYMBOL_GOTOFF_GLOBAL] = "%got(";
5187           mips_lo_relocs[SYMBOL_GOTOFF_CALL] = "%call16(";
5188         }
5189     }
5190
5191   if (TARGET_NEWABI)
5192     {
5193       mips_split_p[SYMBOL_GOTOFF_LOADGP] = true;
5194       mips_hi_relocs[SYMBOL_GOTOFF_LOADGP] = "%hi(%neg(%gp_rel(";
5195       mips_lo_relocs[SYMBOL_GOTOFF_LOADGP] = "%lo(%neg(%gp_rel(";
5196     }
5197
5198   /* Thread-local relocation operators.  */
5199   mips_lo_relocs[SYMBOL_TLSGD] = "%tlsgd(";
5200   mips_lo_relocs[SYMBOL_TLSLDM] = "%tlsldm(";
5201   mips_split_p[SYMBOL_DTPREL] = 1;
5202   mips_hi_relocs[SYMBOL_DTPREL] = "%dtprel_hi(";
5203   mips_lo_relocs[SYMBOL_DTPREL] = "%dtprel_lo(";
5204   mips_lo_relocs[SYMBOL_GOTTPREL] = "%gottprel(";
5205   mips_split_p[SYMBOL_TPREL] = 1;
5206   mips_hi_relocs[SYMBOL_TPREL] = "%tprel_hi(";
5207   mips_lo_relocs[SYMBOL_TPREL] = "%tprel_lo(";
5208
5209   /* We don't have a thread pointer access instruction on MIPS16, or
5210      appropriate TLS relocations.  */
5211   if (TARGET_MIPS16)
5212     targetm.have_tls = false;
5213
5214   /* Default to working around R4000 errata only if the processor
5215      was selected explicitly.  */
5216   if ((target_flags_explicit & MASK_FIX_R4000) == 0
5217       && mips_matching_cpu_name_p (mips_arch_info->name, "r4000"))
5218     target_flags |= MASK_FIX_R4000;
5219
5220   /* Default to working around R4400 errata only if the processor
5221      was selected explicitly.  */
5222   if ((target_flags_explicit & MASK_FIX_R4400) == 0
5223       && mips_matching_cpu_name_p (mips_arch_info->name, "r4400"))
5224     target_flags |= MASK_FIX_R4400;
5225 }
5226
5227 /* Implement CONDITIONAL_REGISTER_USAGE.  */
5228
5229 void
5230 mips_conditional_register_usage (void)
5231 {
5232   if (!TARGET_DSP)
5233     {
5234       int regno;
5235
5236       for (regno = DSP_ACC_REG_FIRST; regno <= DSP_ACC_REG_LAST; regno++)
5237         fixed_regs[regno] = call_used_regs[regno] = 1;
5238     }
5239   if (!TARGET_HARD_FLOAT)
5240     {
5241       int regno;
5242
5243       for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno++)
5244         fixed_regs[regno] = call_used_regs[regno] = 1;
5245       for (regno = ST_REG_FIRST; regno <= ST_REG_LAST; regno++)
5246         fixed_regs[regno] = call_used_regs[regno] = 1;
5247     }
5248   else if (! ISA_HAS_8CC)
5249     {
5250       int regno;
5251
5252       /* We only have a single condition code register.  We
5253          implement this by hiding all the condition code registers,
5254          and generating RTL that refers directly to ST_REG_FIRST.  */
5255       for (regno = ST_REG_FIRST; regno <= ST_REG_LAST; regno++)
5256         fixed_regs[regno] = call_used_regs[regno] = 1;
5257     }
5258   /* In mips16 mode, we permit the $t temporary registers to be used
5259      for reload.  We prohibit the unused $s registers, since they
5260      are caller saved, and saving them via a mips16 register would
5261      probably waste more time than just reloading the value.  */
5262   if (TARGET_MIPS16)
5263     {
5264       fixed_regs[18] = call_used_regs[18] = 1;
5265       fixed_regs[19] = call_used_regs[19] = 1;
5266       fixed_regs[20] = call_used_regs[20] = 1;
5267       fixed_regs[21] = call_used_regs[21] = 1;
5268       fixed_regs[22] = call_used_regs[22] = 1;
5269       fixed_regs[23] = call_used_regs[23] = 1;
5270       fixed_regs[26] = call_used_regs[26] = 1;
5271       fixed_regs[27] = call_used_regs[27] = 1;
5272       fixed_regs[30] = call_used_regs[30] = 1;
5273     }
5274   /* fp20-23 are now caller saved.  */
5275   if (mips_abi == ABI_64)
5276     {
5277       int regno;
5278       for (regno = FP_REG_FIRST + 20; regno < FP_REG_FIRST + 24; regno++)
5279         call_really_used_regs[regno] = call_used_regs[regno] = 1;
5280     }
5281   /* Odd registers from fp21 to fp31 are now caller saved.  */
5282   if (mips_abi == ABI_N32)
5283     {
5284       int regno;
5285       for (regno = FP_REG_FIRST + 21; regno <= FP_REG_FIRST + 31; regno+=2)
5286         call_really_used_regs[regno] = call_used_regs[regno] = 1;
5287     }
5288 }
5289
5290 /* Allocate a chunk of memory for per-function machine-dependent data.  */
5291 static struct machine_function *
5292 mips_init_machine_status (void)
5293 {
5294   return ((struct machine_function *)
5295           ggc_alloc_cleared (sizeof (struct machine_function)));
5296 }
5297
5298 /* On the mips16, we want to allocate $24 (T_REG) before other
5299    registers for instructions for which it is possible.  This helps
5300    avoid shuffling registers around in order to set up for an xor,
5301    encouraging the compiler to use a cmp instead.  */
5302
5303 void
5304 mips_order_regs_for_local_alloc (void)
5305 {
5306   register int i;
5307
5308   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
5309     reg_alloc_order[i] = i;
5310
5311   if (TARGET_MIPS16)
5312     {
5313       /* It really doesn't matter where we put register 0, since it is
5314          a fixed register anyhow.  */
5315       reg_alloc_order[0] = 24;
5316       reg_alloc_order[24] = 0;
5317     }
5318 }
5319
5320 \f
5321 /* The MIPS debug format wants all automatic variables and arguments
5322    to be in terms of the virtual frame pointer (stack pointer before
5323    any adjustment in the function), while the MIPS 3.0 linker wants
5324    the frame pointer to be the stack pointer after the initial
5325    adjustment.  So, we do the adjustment here.  The arg pointer (which
5326    is eliminated) points to the virtual frame pointer, while the frame
5327    pointer (which may be eliminated) points to the stack pointer after
5328    the initial adjustments.  */
5329
5330 HOST_WIDE_INT
5331 mips_debugger_offset (rtx addr, HOST_WIDE_INT offset)
5332 {
5333   rtx offset2 = const0_rtx;
5334   rtx reg = eliminate_constant_term (addr, &offset2);
5335
5336   if (offset == 0)
5337     offset = INTVAL (offset2);
5338
5339   if (reg == stack_pointer_rtx || reg == frame_pointer_rtx
5340       || reg == hard_frame_pointer_rtx)
5341     {
5342       HOST_WIDE_INT frame_size = (!cfun->machine->frame.initialized)
5343                                   ? compute_frame_size (get_frame_size ())
5344                                   : cfun->machine->frame.total_size;
5345
5346       /* MIPS16 frame is smaller */
5347       if (frame_pointer_needed && TARGET_MIPS16)
5348         frame_size -= cfun->machine->frame.args_size;
5349
5350       offset = offset - frame_size;
5351     }
5352
5353   /* sdbout_parms does not want this to crash for unrecognized cases.  */
5354 #if 0
5355   else if (reg != arg_pointer_rtx)
5356     fatal_insn ("mips_debugger_offset called with non stack/frame/arg pointer",
5357                 addr);
5358 #endif
5359
5360   return offset;
5361 }
5362 \f
5363 /* Implement the PRINT_OPERAND macro.  The MIPS-specific operand codes are:
5364
5365    'X'  OP is CONST_INT, prints 32 bits in hexadecimal format = "0x%08x",
5366    'x'  OP is CONST_INT, prints 16 bits in hexadecimal format = "0x%04x",
5367    'h'  OP is HIGH, prints %hi(X),
5368    'd'  output integer constant in decimal,
5369    'z'  if the operand is 0, use $0 instead of normal operand.
5370    'D'  print second part of double-word register or memory operand.
5371    'L'  print low-order register of double-word register operand.
5372    'M'  print high-order register of double-word register operand.
5373    'C'  print part of opcode for a branch condition.
5374    'F'  print part of opcode for a floating-point branch condition.
5375    'N'  print part of opcode for a branch condition, inverted.
5376    'W'  print part of opcode for a floating-point branch condition, inverted.
5377    'T'  print 'f' for (eq:CC ...), 't' for (ne:CC ...),
5378               'z' for (eq:?I ...), 'n' for (ne:?I ...).
5379    't'  like 'T', but with the EQ/NE cases reversed
5380    'Y'  for a CONST_INT X, print mips_fp_conditions[X]
5381    'Z'  print the operand and a comma for ISA_HAS_8CC, otherwise print nothing
5382    'R'  print the reloc associated with LO_SUM
5383    'q'  print DSP accumulator registers
5384
5385    The punctuation characters are:
5386
5387    '('  Turn on .set noreorder
5388    ')'  Turn on .set reorder
5389    '['  Turn on .set noat
5390    ']'  Turn on .set at
5391    '<'  Turn on .set nomacro
5392    '>'  Turn on .set macro
5393    '{'  Turn on .set volatile (not GAS)
5394    '}'  Turn on .set novolatile (not GAS)
5395    '&'  Turn on .set noreorder if filling delay slots
5396    '*'  Turn on both .set noreorder and .set nomacro if filling delay slots
5397    '!'  Turn on .set nomacro if filling delay slots
5398    '#'  Print nop if in a .set noreorder section.
5399    '/'  Like '#', but does nothing within a delayed branch sequence
5400    '?'  Print 'l' if we are to use a branch likely instead of normal branch.
5401    '@'  Print the name of the assembler temporary register (at or $1).
5402    '.'  Print the name of the register with a hard-wired zero (zero or $0).
5403    '^'  Print the name of the pic call-through register (t9 or $25).
5404    '$'  Print the name of the stack pointer register (sp or $29).
5405    '+'  Print the name of the gp register (usually gp or $28).
5406    '~'  Output a branch alignment to LABEL_ALIGN(NULL).  */
5407
5408 void
5409 print_operand (FILE *file, rtx op, int letter)
5410 {
5411   register enum rtx_code code;
5412
5413   if (PRINT_OPERAND_PUNCT_VALID_P (letter))
5414     {
5415       switch (letter)
5416         {
5417         case '?':
5418           if (mips_branch_likely)
5419             putc ('l', file);
5420           break;
5421
5422         case '@':
5423           fputs (reg_names [GP_REG_FIRST + 1], file);
5424           break;
5425
5426         case '^':
5427           fputs (reg_names [PIC_FUNCTION_ADDR_REGNUM], file);
5428           break;
5429
5430         case '.':
5431           fputs (reg_names [GP_REG_FIRST + 0], file);
5432           break;
5433
5434         case '$':
5435           fputs (reg_names[STACK_POINTER_REGNUM], file);
5436           break;
5437
5438         case '+':
5439           fputs (reg_names[PIC_OFFSET_TABLE_REGNUM], file);
5440           break;
5441
5442         case '&':
5443           if (final_sequence != 0 && set_noreorder++ == 0)
5444             fputs (".set\tnoreorder\n\t", file);
5445           break;
5446
5447         case '*':
5448           if (final_sequence != 0)
5449             {
5450               if (set_noreorder++ == 0)
5451                 fputs (".set\tnoreorder\n\t", file);
5452
5453               if (set_nomacro++ == 0)
5454                 fputs (".set\tnomacro\n\t", file);
5455             }
5456           break;
5457
5458         case '!':
5459           if (final_sequence != 0 && set_nomacro++ == 0)
5460             fputs ("\n\t.set\tnomacro", file);
5461           break;
5462
5463         case '#':
5464           if (set_noreorder != 0)
5465             fputs ("\n\tnop", file);
5466           break;
5467
5468         case '/':
5469           /* Print an extra newline so that the delayed insn is separated
5470              from the following ones.  This looks neater and is consistent
5471              with non-nop delayed sequences.  */
5472           if (set_noreorder != 0 && final_sequence == 0)
5473             fputs ("\n\tnop\n", file);
5474           break;
5475
5476         case '(':
5477           if (set_noreorder++ == 0)
5478             fputs (".set\tnoreorder\n\t", file);
5479           break;
5480
5481         case ')':
5482           if (set_noreorder == 0)
5483             error ("internal error: %%) found without a %%( in assembler pattern");
5484
5485           else if (--set_noreorder == 0)
5486             fputs ("\n\t.set\treorder", file);
5487
5488           break;
5489
5490         case '[':
5491           if (set_noat++ == 0)
5492             fputs (".set\tnoat\n\t", file);
5493           break;
5494
5495         case ']':
5496           if (set_noat == 0)
5497             error ("internal error: %%] found without a %%[ in assembler pattern");
5498           else if (--set_noat == 0)
5499             fputs ("\n\t.set\tat", file);
5500
5501           break;
5502
5503         case '<':
5504           if (set_nomacro++ == 0)
5505             fputs (".set\tnomacro\n\t", file);
5506           break;
5507
5508         case '>':
5509           if (set_nomacro == 0)
5510             error ("internal error: %%> found without a %%< in assembler pattern");
5511           else if (--set_nomacro == 0)
5512             fputs ("\n\t.set\tmacro", file);
5513
5514           break;
5515
5516         case '{':
5517           if (set_volatile++ == 0)
5518             fputs ("#.set\tvolatile\n\t", file);
5519           break;
5520
5521         case '}':
5522           if (set_volatile == 0)
5523             error ("internal error: %%} found without a %%{ in assembler pattern");
5524           else if (--set_volatile == 0)
5525             fputs ("\n\t#.set\tnovolatile", file);
5526
5527           break;
5528
5529         case '~':
5530           {
5531             if (align_labels_log > 0)
5532               ASM_OUTPUT_ALIGN (file, align_labels_log);
5533           }
5534           break;
5535
5536         default:
5537           error ("PRINT_OPERAND: unknown punctuation '%c'", letter);
5538           break;
5539         }
5540
5541       return;
5542     }
5543
5544   if (! op)
5545     {
5546       error ("PRINT_OPERAND null pointer");
5547       return;
5548     }
5549
5550   code = GET_CODE (op);
5551
5552   if (letter == 'C')
5553     switch (code)
5554       {
5555       case EQ:  fputs ("eq",  file); break;
5556       case NE:  fputs ("ne",  file); break;
5557       case GT:  fputs ("gt",  file); break;
5558       case GE:  fputs ("ge",  file); break;
5559       case LT:  fputs ("lt",  file); break;
5560       case LE:  fputs ("le",  file); break;
5561       case GTU: fputs ("gtu", file); break;
5562       case GEU: fputs ("geu", file); break;
5563       case LTU: fputs ("ltu", file); break;
5564       case LEU: fputs ("leu", file); break;
5565       default:
5566         fatal_insn ("PRINT_OPERAND, invalid insn for %%C", op);
5567       }
5568
5569   else if (letter == 'N')
5570     switch (code)
5571       {
5572       case EQ:  fputs ("ne",  file); break;
5573       case NE:  fputs ("eq",  file); break;
5574       case GT:  fputs ("le",  file); break;
5575       case GE:  fputs ("lt",  file); break;
5576       case LT:  fputs ("ge",  file); break;
5577       case LE:  fputs ("gt",  file); break;
5578       case GTU: fputs ("leu", file); break;
5579       case GEU: fputs ("ltu", file); break;
5580       case LTU: fputs ("geu", file); break;
5581       case LEU: fputs ("gtu", file); break;
5582       default:
5583         fatal_insn ("PRINT_OPERAND, invalid insn for %%N", op);
5584       }
5585
5586   else if (letter == 'F')
5587     switch (code)
5588       {
5589       case EQ: fputs ("c1f", file); break;
5590       case NE: fputs ("c1t", file); break;
5591       default:
5592         fatal_insn ("PRINT_OPERAND, invalid insn for %%F", op);
5593       }
5594
5595   else if (letter == 'W')
5596     switch (code)
5597       {
5598       case EQ: fputs ("c1t", file); break;
5599       case NE: fputs ("c1f", file); break;
5600       default:
5601         fatal_insn ("PRINT_OPERAND, invalid insn for %%W", op);
5602       }
5603
5604   else if (letter == 'h')
5605     {
5606       if (GET_CODE (op) == HIGH)
5607         op = XEXP (op, 0);
5608
5609       print_operand_reloc (file, op, mips_hi_relocs);
5610     }
5611
5612   else if (letter == 'R')
5613     print_operand_reloc (file, op, mips_lo_relocs);
5614
5615   else if (letter == 'Y')
5616     {
5617       if (GET_CODE (op) == CONST_INT
5618           && ((unsigned HOST_WIDE_INT) INTVAL (op)
5619               < ARRAY_SIZE (mips_fp_conditions)))
5620         fputs (mips_fp_conditions[INTVAL (op)], file);
5621       else
5622         output_operand_lossage ("invalid %%Y value");
5623     }
5624
5625   else if (letter == 'Z')
5626     {
5627       if (ISA_HAS_8CC)
5628         {
5629           print_operand (file, op, 0);
5630           fputc (',', file);
5631         }
5632     }
5633
5634   else if (letter == 'q')
5635     {
5636       int regnum;
5637
5638       if (code != REG)
5639         fatal_insn ("PRINT_OPERAND, invalid insn for %%q", op);
5640
5641       regnum = REGNO (op);
5642       if (MD_REG_P (regnum))
5643         fprintf (file, "$ac0");
5644       else if (DSP_ACC_REG_P (regnum))
5645         fprintf (file, "$ac%c", reg_names[regnum][3]);
5646       else
5647         fatal_insn ("PRINT_OPERAND, invalid insn for %%q", op);
5648     }
5649
5650   else if (code == REG || code == SUBREG)
5651     {
5652       register int regnum;
5653
5654       if (code == REG)
5655         regnum = REGNO (op);
5656       else
5657         regnum = true_regnum (op);
5658
5659       if ((letter == 'M' && ! WORDS_BIG_ENDIAN)
5660           || (letter == 'L' && WORDS_BIG_ENDIAN)
5661           || letter == 'D')
5662         regnum++;
5663
5664       fprintf (file, "%s", reg_names[regnum]);
5665     }
5666
5667   else if (code == MEM)
5668     {
5669       if (letter == 'D')
5670         output_address (plus_constant (XEXP (op, 0), 4));
5671       else
5672         output_address (XEXP (op, 0));
5673     }
5674
5675   else if (letter == 'x' && GET_CODE (op) == CONST_INT)
5676     fprintf (file, HOST_WIDE_INT_PRINT_HEX, 0xffff & INTVAL(op));
5677
5678   else if (letter == 'X' && GET_CODE(op) == CONST_INT)
5679     fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op));
5680
5681   else if (letter == 'd' && GET_CODE(op) == CONST_INT)
5682     fprintf (file, HOST_WIDE_INT_PRINT_DEC, (INTVAL(op)));
5683
5684   else if (letter == 'z' && op == CONST0_RTX (GET_MODE (op)))
5685     fputs (reg_names[GP_REG_FIRST], file);
5686
5687   else if (letter == 'd' || letter == 'x' || letter == 'X')
5688     output_operand_lossage ("invalid use of %%d, %%x, or %%X");
5689
5690   else if (letter == 'T' || letter == 't')
5691     {
5692       int truth = (code == NE) == (letter == 'T');
5693       fputc ("zfnt"[truth * 2 + (GET_MODE (op) == CCmode)], file);
5694     }
5695
5696   else if (CONST_GP_P (op))
5697     fputs (reg_names[GLOBAL_POINTER_REGNUM], file);
5698
5699   else
5700     output_addr_const (file, op);
5701 }
5702
5703
5704 /* Print symbolic operand OP, which is part of a HIGH or LO_SUM.
5705    RELOCS is the array of relocations to use.  */
5706
5707 static void
5708 print_operand_reloc (FILE *file, rtx op, const char **relocs)
5709 {
5710   enum mips_symbol_type symbol_type;
5711   const char *p;
5712   rtx base;
5713   HOST_WIDE_INT offset;
5714
5715   if (!mips_symbolic_constant_p (op, &symbol_type) || relocs[symbol_type] == 0)
5716     fatal_insn ("PRINT_OPERAND, invalid operand for relocation", op);
5717
5718   /* If OP uses an UNSPEC address, we want to print the inner symbol.  */
5719   mips_split_const (op, &base, &offset);
5720   if (UNSPEC_ADDRESS_P (base))
5721     op = plus_constant (UNSPEC_ADDRESS (base), offset);
5722
5723   fputs (relocs[symbol_type], file);
5724   output_addr_const (file, op);
5725   for (p = relocs[symbol_type]; *p != 0; p++)
5726     if (*p == '(')
5727       fputc (')', file);
5728 }
5729 \f
5730 /* Output address operand X to FILE.  */
5731
5732 void
5733 print_operand_address (FILE *file, rtx x)
5734 {
5735   struct mips_address_info addr;
5736
5737   if (mips_classify_address (&addr, x, word_mode, true))
5738     switch (addr.type)
5739       {
5740       case ADDRESS_REG:
5741         print_operand (file, addr.offset, 0);
5742         fprintf (file, "(%s)", reg_names[REGNO (addr.reg)]);
5743         return;
5744
5745       case ADDRESS_LO_SUM:
5746         print_operand (file, addr.offset, 'R');
5747         fprintf (file, "(%s)", reg_names[REGNO (addr.reg)]);
5748         return;
5749
5750       case ADDRESS_CONST_INT:
5751         output_addr_const (file, x);
5752         fprintf (file, "(%s)", reg_names[0]);
5753         return;
5754
5755       case ADDRESS_SYMBOLIC:
5756         output_addr_const (file, x);
5757         return;
5758       }
5759   gcc_unreachable ();
5760 }
5761 \f
5762 /* When using assembler macros, keep track of all of small-data externs
5763    so that mips_file_end can emit the appropriate declarations for them.
5764
5765    In most cases it would be safe (though pointless) to emit .externs
5766    for other symbols too.  One exception is when an object is within
5767    the -G limit but declared by the user to be in a section other
5768    than .sbss or .sdata.  */
5769
5770 void
5771 mips_output_external (FILE *file, tree decl, const char *name)
5772 {
5773   default_elf_asm_output_external (file, decl, name);
5774
5775   /* We output the name if and only if TREE_SYMBOL_REFERENCED is
5776      set in order to avoid putting out names that are never really
5777      used. */
5778   if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
5779     {
5780       if (!TARGET_EXPLICIT_RELOCS && mips_in_small_data_p (decl))
5781         {
5782           fputs ("\t.extern\t", file);
5783           assemble_name (file, name);
5784           fprintf (file, ", " HOST_WIDE_INT_PRINT_DEC "\n",
5785                    int_size_in_bytes (TREE_TYPE (decl)));
5786         }
5787       else if (TARGET_IRIX
5788                && mips_abi == ABI_32
5789                && TREE_CODE (decl) == FUNCTION_DECL)
5790         {
5791           /* In IRIX 5 or IRIX 6 for the O32 ABI, we must output a
5792              `.global name .text' directive for every used but
5793              undefined function.  If we don't, the linker may perform
5794              an optimization (skipping over the insns that set $gp)
5795              when it is unsafe.  */
5796           fputs ("\t.globl ", file);
5797           assemble_name (file, name);
5798           fputs (" .text\n", file);
5799         }
5800     }
5801 }
5802 \f
5803 /* Emit a new filename to a stream.  If we are smuggling stabs, try to
5804    put out a MIPS ECOFF file and a stab.  */
5805
5806 void
5807 mips_output_filename (FILE *stream, const char *name)
5808 {
5809
5810   /* If we are emitting DWARF-2, let dwarf2out handle the ".file"
5811      directives.  */
5812   if (write_symbols == DWARF2_DEBUG)
5813     return;
5814   else if (mips_output_filename_first_time)
5815     {
5816       mips_output_filename_first_time = 0;
5817       num_source_filenames += 1;
5818       current_function_file = name;
5819       fprintf (stream, "\t.file\t%d ", num_source_filenames);
5820       output_quoted_string (stream, name);
5821       putc ('\n', stream);
5822     }
5823
5824   /* If we are emitting stabs, let dbxout.c handle this (except for
5825      the mips_output_filename_first_time case).  */
5826   else if (write_symbols == DBX_DEBUG)
5827     return;
5828
5829   else if (name != current_function_file
5830            && strcmp (name, current_function_file) != 0)
5831     {
5832       num_source_filenames += 1;
5833       current_function_file = name;
5834       fprintf (stream, "\t.file\t%d ", num_source_filenames);
5835       output_quoted_string (stream, name);
5836       putc ('\n', stream);
5837     }
5838 }
5839 \f
5840 /* Output an ASCII string, in a space-saving way.  PREFIX is the string
5841    that should be written before the opening quote, such as "\t.ascii\t"
5842    for real string data or "\t# " for a comment.  */
5843
5844 void
5845 mips_output_ascii (FILE *stream, const char *string_param, size_t len,
5846                    const char *prefix)
5847 {
5848   size_t i;
5849   int cur_pos = 17;
5850   register const unsigned char *string =
5851     (const unsigned char *)string_param;
5852
5853   fprintf (stream, "%s\"", prefix);
5854   for (i = 0; i < len; i++)
5855     {
5856       register int c = string[i];
5857
5858       if (ISPRINT (c))
5859         {
5860           if (c == '\\' || c == '\"')
5861             {
5862               putc ('\\', stream);
5863               cur_pos++;
5864             }
5865           putc (c, stream);
5866           cur_pos++;
5867         }
5868       else
5869         {
5870           fprintf (stream, "\\%03o", c);
5871           cur_pos += 4;
5872         }
5873
5874       if (cur_pos > 72 && i+1 < len)
5875         {
5876           cur_pos = 17;
5877           fprintf (stream, "\"\n%s\"", prefix);
5878         }
5879     }
5880   fprintf (stream, "\"\n");
5881 }
5882 \f
5883 /* Implement TARGET_ASM_FILE_START.  */
5884
5885 static void
5886 mips_file_start (void)
5887 {
5888   default_file_start ();
5889
5890   if (!TARGET_IRIX)
5891     {
5892       /* Generate a special section to describe the ABI switches used to
5893          produce the resultant binary.  This used to be done by the assembler
5894          setting bits in the ELF header's flags field, but we have run out of
5895          bits.  GDB needs this information in order to be able to correctly
5896          debug these binaries.  See the function mips_gdbarch_init() in
5897          gdb/mips-tdep.c.  This is unnecessary for the IRIX 5/6 ABIs and
5898          causes unnecessary IRIX 6 ld warnings.  */
5899       const char * abi_string = NULL;
5900
5901       switch (mips_abi)
5902         {
5903         case ABI_32:   abi_string = "abi32"; break;
5904         case ABI_N32:  abi_string = "abiN32"; break;
5905         case ABI_64:   abi_string = "abi64"; break;
5906         case ABI_O64:  abi_string = "abiO64"; break;
5907         case ABI_EABI: abi_string = TARGET_64BIT ? "eabi64" : "eabi32"; break;
5908         default:
5909           gcc_unreachable ();
5910         }
5911       /* Note - we use fprintf directly rather than calling switch_to_section
5912          because in this way we can avoid creating an allocated section.  We
5913          do not want this section to take up any space in the running
5914          executable.  */
5915       fprintf (asm_out_file, "\t.section .mdebug.%s\n", abi_string);
5916
5917       /* There is no ELF header flag to distinguish long32 forms of the
5918          EABI from long64 forms.  Emit a special section to help tools
5919          such as GDB.  Do the same for o64, which is sometimes used with
5920          -mlong64.  */
5921       if (mips_abi == ABI_EABI || mips_abi == ABI_O64)
5922         fprintf (asm_out_file, "\t.section .gcc_compiled_long%d\n",
5923                  TARGET_LONG64 ? 64 : 32);
5924
5925       /* Restore the default section.  */
5926       fprintf (asm_out_file, "\t.previous\n");
5927     }
5928
5929   /* Generate the pseudo ops that System V.4 wants.  */
5930   if (TARGET_ABICALLS)
5931     fprintf (asm_out_file, "\t.abicalls\n");
5932
5933   if (TARGET_MIPS16)
5934     fprintf (asm_out_file, "\t.set\tmips16\n");
5935
5936   if (flag_verbose_asm)
5937     fprintf (asm_out_file, "\n%s -G value = %d, Arch = %s, ISA = %d\n",
5938              ASM_COMMENT_START,
5939              mips_section_threshold, mips_arch_info->name, mips_isa);
5940 }
5941
5942 #ifdef BSS_SECTION_ASM_OP
5943 /* Implement ASM_OUTPUT_ALIGNED_BSS.  This differs from the default only
5944    in the use of sbss.  */
5945
5946 void
5947 mips_output_aligned_bss (FILE *stream, tree decl, const char *name,
5948                          unsigned HOST_WIDE_INT size, int align)
5949 {
5950   extern tree last_assemble_variable_decl;
5951
5952   if (mips_in_small_data_p (decl))
5953     switch_to_section (get_named_section (NULL, ".sbss", 0));
5954   else
5955     switch_to_section (bss_section);
5956   ASM_OUTPUT_ALIGN (stream, floor_log2 (align / BITS_PER_UNIT));
5957   last_assemble_variable_decl = decl;
5958   ASM_DECLARE_OBJECT_NAME (stream, name, decl);
5959   ASM_OUTPUT_SKIP (stream, size != 0 ? size : 1);
5960 }
5961 #endif
5962 \f
5963 /* Implement ASM_OUTPUT_ALIGNED_DECL_COMMON.  This is usually the same as the
5964    elfos.h version, but we also need to handle -muninit-const-in-rodata.  */
5965
5966 void
5967 mips_output_aligned_decl_common (FILE *stream, tree decl, const char *name,
5968                                  unsigned HOST_WIDE_INT size,
5969                                  unsigned int align)
5970 {
5971   /* If the target wants uninitialized const declarations in
5972      .rdata then don't put them in .comm.  */
5973   if (TARGET_EMBEDDED_DATA && TARGET_UNINIT_CONST_IN_RODATA
5974       && TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)
5975       && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5976     {
5977       if (TREE_PUBLIC (decl) && DECL_NAME (decl))
5978         targetm.asm_out.globalize_label (stream, name);
5979
5980       switch_to_section (readonly_data_section);
5981       ASM_OUTPUT_ALIGN (stream, floor_log2 (align / BITS_PER_UNIT));
5982       mips_declare_object (stream, name, "",
5983                            ":\n\t.space\t" HOST_WIDE_INT_PRINT_UNSIGNED "\n",
5984                            size);
5985     }
5986   else
5987     mips_declare_common_object (stream, name, "\n\t.comm\t",
5988                                 size, align, true);
5989 }
5990
5991 /* Declare a common object of SIZE bytes using asm directive INIT_STRING.
5992    NAME is the name of the object and ALIGN is the required alignment
5993    in bytes.  TAKES_ALIGNMENT_P is true if the directive takes a third
5994    alignment argument.  */
5995
5996 void
5997 mips_declare_common_object (FILE *stream, const char *name,
5998                             const char *init_string,
5999                             unsigned HOST_WIDE_INT size,
6000                             unsigned int align, bool takes_alignment_p)
6001 {
6002   if (!takes_alignment_p)
6003     {
6004       size += (align / BITS_PER_UNIT) - 1;
6005       size -= size % (align / BITS_PER_UNIT);
6006       mips_declare_object (stream, name, init_string,
6007                            "," HOST_WIDE_INT_PRINT_UNSIGNED "\n", size);
6008     }
6009   else
6010     mips_declare_object (stream, name, init_string,
6011                          "," HOST_WIDE_INT_PRINT_UNSIGNED ",%u\n",
6012                          size, align / BITS_PER_UNIT);
6013 }
6014
6015 /* Emit either a label, .comm, or .lcomm directive.  When using assembler
6016    macros, mark the symbol as written so that mips_file_end won't emit an
6017    .extern for it.  STREAM is the output file, NAME is the name of the
6018    symbol, INIT_STRING is the string that should be written before the
6019    symbol and FINAL_STRING is the string that should be written after it.
6020    FINAL_STRING is a printf() format that consumes the remaining arguments.  */
6021
6022 void
6023 mips_declare_object (FILE *stream, const char *name, const char *init_string,
6024                      const char *final_string, ...)
6025 {
6026   va_list ap;
6027
6028   fputs (init_string, stream);
6029   assemble_name (stream, name);
6030   va_start (ap, final_string);
6031   vfprintf (stream, final_string, ap);
6032   va_end (ap);
6033
6034   if (!TARGET_EXPLICIT_RELOCS)
6035     {
6036       tree name_tree = get_identifier (name);
6037       TREE_ASM_WRITTEN (name_tree) = 1;
6038     }
6039 }
6040
6041 #ifdef ASM_OUTPUT_SIZE_DIRECTIVE
6042 extern int size_directive_output;
6043
6044 /* Implement ASM_DECLARE_OBJECT_NAME.  This is like most of the standard ELF
6045    definitions except that it uses mips_declare_object() to emit the label.  */
6046
6047 void
6048 mips_declare_object_name (FILE *stream, const char *name,
6049                           tree decl ATTRIBUTE_UNUSED)
6050 {
6051 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
6052   ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "object");
6053 #endif
6054
6055   size_directive_output = 0;
6056   if (!flag_inhibit_size_directive && DECL_SIZE (decl))
6057     {
6058       HOST_WIDE_INT size;
6059
6060       size_directive_output = 1;
6061       size = int_size_in_bytes (TREE_TYPE (decl));
6062       ASM_OUTPUT_SIZE_DIRECTIVE (stream, name, size);
6063     }
6064
6065   mips_declare_object (stream, name, "", ":\n");
6066 }
6067
6068 /* Implement ASM_FINISH_DECLARE_OBJECT.  This is generic ELF stuff.  */
6069
6070 void
6071 mips_finish_declare_object (FILE *stream, tree decl, int top_level, int at_end)
6072 {
6073   const char *name;
6074
6075   name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
6076   if (!flag_inhibit_size_directive
6077       && DECL_SIZE (decl) != 0
6078       && !at_end && top_level
6079       && DECL_INITIAL (decl) == error_mark_node
6080       && !size_directive_output)
6081     {
6082       HOST_WIDE_INT size;
6083
6084       size_directive_output = 1;
6085       size = int_size_in_bytes (TREE_TYPE (decl));
6086       ASM_OUTPUT_SIZE_DIRECTIVE (stream, name, size);
6087     }
6088 }
6089 #endif
6090 \f
6091 /* Return true if X is a small data address that can be rewritten
6092    as a LO_SUM.  */
6093
6094 static bool
6095 mips_rewrite_small_data_p (rtx x)
6096 {
6097   enum mips_symbol_type symbol_type;
6098
6099   return (TARGET_EXPLICIT_RELOCS
6100           && mips_symbolic_constant_p (x, &symbol_type)
6101           && symbol_type == SYMBOL_SMALL_DATA);
6102 }
6103
6104
6105 /* A for_each_rtx callback for mips_small_data_pattern_p.  */
6106
6107 static int
6108 mips_small_data_pattern_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
6109 {
6110   if (GET_CODE (*loc) == LO_SUM)
6111     return -1;
6112
6113   return mips_rewrite_small_data_p (*loc);
6114 }
6115
6116 /* Return true if OP refers to small data symbols directly, not through
6117    a LO_SUM.  */
6118
6119 bool
6120 mips_small_data_pattern_p (rtx op)
6121 {
6122   return for_each_rtx (&op, mips_small_data_pattern_1, 0);
6123 }
6124 \f
6125 /* A for_each_rtx callback, used by mips_rewrite_small_data.  */
6126
6127 static int
6128 mips_rewrite_small_data_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
6129 {
6130   if (mips_rewrite_small_data_p (*loc))
6131     *loc = gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, *loc);
6132
6133   if (GET_CODE (*loc) == LO_SUM)
6134     return -1;
6135
6136   return 0;
6137 }
6138
6139 /* If possible, rewrite OP so that it refers to small data using
6140    explicit relocations.  */
6141
6142 rtx
6143 mips_rewrite_small_data (rtx op)
6144 {
6145   op = copy_insn (op);
6146   for_each_rtx (&op, mips_rewrite_small_data_1, 0);
6147   return op;
6148 }
6149 \f
6150 /* Return true if the current function has an insn that implicitly
6151    refers to $gp.  */
6152
6153 static bool
6154 mips_function_has_gp_insn (void)
6155 {
6156   /* Don't bother rechecking if we found one last time.  */
6157   if (!cfun->machine->has_gp_insn_p)
6158     {
6159       rtx insn;
6160
6161       push_topmost_sequence ();
6162       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6163         if (INSN_P (insn)
6164             && GET_CODE (PATTERN (insn)) != USE
6165             && GET_CODE (PATTERN (insn)) != CLOBBER
6166             && (get_attr_got (insn) != GOT_UNSET
6167                 || small_data_pattern (PATTERN (insn), VOIDmode)))
6168           break;
6169       pop_topmost_sequence ();
6170
6171       cfun->machine->has_gp_insn_p = (insn != 0);
6172     }
6173   return cfun->machine->has_gp_insn_p;
6174 }
6175
6176
6177 /* Return the register that should be used as the global pointer
6178    within this function.  Return 0 if the function doesn't need
6179    a global pointer.  */
6180
6181 static unsigned int
6182 mips_global_pointer (void)
6183 {
6184   unsigned int regno;
6185
6186   /* $gp is always available in non-abicalls code.  */
6187   if (!TARGET_ABICALLS)
6188     return GLOBAL_POINTER_REGNUM;
6189
6190   /* We must always provide $gp when it is used implicitly.  */
6191   if (!TARGET_EXPLICIT_RELOCS)
6192     return GLOBAL_POINTER_REGNUM;
6193
6194   /* FUNCTION_PROFILER includes a jal macro, so we need to give it
6195      a valid gp.  */
6196   if (current_function_profile)
6197     return GLOBAL_POINTER_REGNUM;
6198
6199   /* If the function has a nonlocal goto, $gp must hold the correct
6200      global pointer for the target function.  */
6201   if (current_function_has_nonlocal_goto)
6202     return GLOBAL_POINTER_REGNUM;
6203
6204   /* If the gp is never referenced, there's no need to initialize it.
6205      Note that reload can sometimes introduce constant pool references
6206      into a function that otherwise didn't need them.  For example,
6207      suppose we have an instruction like:
6208
6209           (set (reg:DF R1) (float:DF (reg:SI R2)))
6210
6211      If R2 turns out to be constant such as 1, the instruction may have a
6212      REG_EQUAL note saying that R1 == 1.0.  Reload then has the option of
6213      using this constant if R2 doesn't get allocated to a register.
6214
6215      In cases like these, reload will have added the constant to the pool
6216      but no instruction will yet refer to it.  */
6217   if (!regs_ever_live[GLOBAL_POINTER_REGNUM]
6218       && !current_function_uses_const_pool
6219       && !mips_function_has_gp_insn ())
6220     return 0;
6221
6222   /* We need a global pointer, but perhaps we can use a call-clobbered
6223      register instead of $gp.  */
6224   if (TARGET_NEWABI && current_function_is_leaf)
6225     for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
6226       if (!regs_ever_live[regno]
6227           && call_used_regs[regno]
6228           && !fixed_regs[regno]
6229           && regno != PIC_FUNCTION_ADDR_REGNUM)
6230         return regno;
6231
6232   return GLOBAL_POINTER_REGNUM;
6233 }
6234
6235
6236 /* Return true if the current function must save REGNO.  */
6237
6238 static bool
6239 mips_save_reg_p (unsigned int regno)
6240 {
6241   /* We only need to save $gp for NewABI PIC.  */
6242   if (regno == GLOBAL_POINTER_REGNUM)
6243     return (TARGET_ABICALLS && TARGET_NEWABI
6244             && cfun->machine->global_pointer == regno);
6245
6246   /* Check call-saved registers.  */
6247   if (regs_ever_live[regno] && !call_used_regs[regno])
6248     return true;
6249
6250   /* We need to save the old frame pointer before setting up a new one.  */
6251   if (regno == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
6252     return true;
6253
6254   /* We need to save the incoming return address if it is ever clobbered
6255      within the function.  */
6256   if (regno == GP_REG_FIRST + 31 && regs_ever_live[regno])
6257     return true;
6258
6259   if (TARGET_MIPS16)
6260     {
6261       tree return_type;
6262
6263       return_type = DECL_RESULT (current_function_decl);
6264
6265       /* $18 is a special case in mips16 code.  It may be used to call
6266          a function which returns a floating point value, but it is
6267          marked in call_used_regs.  */
6268       if (regno == GP_REG_FIRST + 18 && regs_ever_live[regno])
6269         return true;
6270
6271       /* $31 is also a special case.  It will be used to copy a return
6272          value into the floating point registers if the return value is
6273          floating point.  */
6274       if (regno == GP_REG_FIRST + 31
6275           && mips16_hard_float
6276           && !aggregate_value_p (return_type, current_function_decl)
6277           && GET_MODE_CLASS (DECL_MODE (return_type)) == MODE_FLOAT
6278           && GET_MODE_SIZE (DECL_MODE (return_type)) <= UNITS_PER_FPVALUE)
6279         return true;
6280     }
6281
6282   return false;
6283 }
6284
6285
6286 /* Return the bytes needed to compute the frame pointer from the current
6287    stack pointer.  SIZE is the size (in bytes) of the local variables.
6288
6289    MIPS stack frames look like:
6290
6291              Before call                        After call
6292         +-----------------------+       +-----------------------+
6293    high |                       |       |                       |
6294    mem. |                       |       |                       |
6295         |  caller's temps.      |       |  caller's temps.      |
6296         |                       |       |                       |
6297         +-----------------------+       +-----------------------+
6298         |                       |       |                       |
6299         |  arguments on stack.  |       |  arguments on stack.  |
6300         |                       |       |                       |
6301         +-----------------------+       +-----------------------+
6302         |  4 words to save      |       |  4 words to save      |
6303         |  arguments passed     |       |  arguments passed     |
6304         |  in registers, even   |       |  in registers, even   |
6305     SP->|  if not passed.       |  VFP->|  if not passed.       |
6306         +-----------------------+       +-----------------------+
6307                                         |                       |
6308                                         |  fp register save     |
6309                                         |                       |
6310                                         +-----------------------+
6311                                         |                       |
6312                                         |  gp register save     |
6313                                         |                       |
6314                                         +-----------------------+
6315                                         |                       |
6316                                         |  local variables      |
6317                                         |                       |
6318                                         +-----------------------+
6319                                         |                       |
6320                                         |  alloca allocations   |
6321                                         |                       |
6322                                         +-----------------------+
6323                                         |                       |
6324                                         |  GP save for V.4 abi  |
6325                                         |                       |
6326                                         +-----------------------+
6327                                         |                       |
6328                                         |  arguments on stack   |
6329                                         |                       |
6330                                         +-----------------------+
6331                                         |  4 words to save      |
6332                                         |  arguments passed     |
6333                                         |  in registers, even   |
6334    low                              SP->|  if not passed.       |
6335    memory                               +-----------------------+
6336
6337 */
6338
6339 HOST_WIDE_INT
6340 compute_frame_size (HOST_WIDE_INT size)
6341 {
6342   unsigned int regno;
6343   HOST_WIDE_INT total_size;     /* # bytes that the entire frame takes up */
6344   HOST_WIDE_INT var_size;       /* # bytes that variables take up */
6345   HOST_WIDE_INT args_size;      /* # bytes that outgoing arguments take up */
6346   HOST_WIDE_INT cprestore_size; /* # bytes that the cprestore slot takes up */
6347   HOST_WIDE_INT gp_reg_rounded; /* # bytes needed to store gp after rounding */
6348   HOST_WIDE_INT gp_reg_size;    /* # bytes needed to store gp regs */
6349   HOST_WIDE_INT fp_reg_size;    /* # bytes needed to store fp regs */
6350   unsigned int mask;            /* mask of saved gp registers */
6351   unsigned int fmask;           /* mask of saved fp registers */
6352
6353   cfun->machine->global_pointer = mips_global_pointer ();
6354
6355   gp_reg_size = 0;
6356   fp_reg_size = 0;
6357   mask = 0;
6358   fmask = 0;
6359   var_size = MIPS_STACK_ALIGN (size);
6360   args_size = current_function_outgoing_args_size;
6361   cprestore_size = MIPS_STACK_ALIGN (STARTING_FRAME_OFFSET) - args_size;
6362
6363   /* The space set aside by STARTING_FRAME_OFFSET isn't needed in leaf
6364      functions.  If the function has local variables, we're committed
6365      to allocating it anyway.  Otherwise reclaim it here.  */
6366   if (var_size == 0 && current_function_is_leaf)
6367     cprestore_size = args_size = 0;
6368
6369   /* The MIPS 3.0 linker does not like functions that dynamically
6370      allocate the stack and have 0 for STACK_DYNAMIC_OFFSET, since it
6371      looks like we are trying to create a second frame pointer to the
6372      function, so allocate some stack space to make it happy.  */
6373
6374   if (args_size == 0 && current_function_calls_alloca)
6375     args_size = 4 * UNITS_PER_WORD;
6376
6377   total_size = var_size + args_size + cprestore_size;
6378
6379   /* Calculate space needed for gp registers.  */
6380   for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
6381     if (mips_save_reg_p (regno))
6382       {
6383         gp_reg_size += GET_MODE_SIZE (gpr_mode);
6384         mask |= 1 << (regno - GP_REG_FIRST);
6385       }
6386
6387   /* We need to restore these for the handler.  */
6388   if (current_function_calls_eh_return)
6389     {
6390       unsigned int i;
6391       for (i = 0; ; ++i)
6392         {
6393           regno = EH_RETURN_DATA_REGNO (i);
6394           if (regno == INVALID_REGNUM)
6395             break;
6396           gp_reg_size += GET_MODE_SIZE (gpr_mode);
6397           mask |= 1 << (regno - GP_REG_FIRST);
6398         }
6399     }
6400
6401   /* This loop must iterate over the same space as its companion in
6402      save_restore_insns.  */
6403   for (regno = (FP_REG_LAST - FP_INC + 1);
6404        regno >= FP_REG_FIRST;
6405        regno -= FP_INC)
6406     {
6407       if (mips_save_reg_p (regno))
6408         {
6409           fp_reg_size += FP_INC * UNITS_PER_FPREG;
6410           fmask |= ((1 << FP_INC) - 1) << (regno - FP_REG_FIRST);
6411         }
6412     }
6413
6414   gp_reg_rounded = MIPS_STACK_ALIGN (gp_reg_size);
6415   total_size += gp_reg_rounded + MIPS_STACK_ALIGN (fp_reg_size);
6416
6417   /* Add in the space required for saving incoming register arguments.  */
6418   total_size += current_function_pretend_args_size;
6419   total_size += MIPS_STACK_ALIGN (cfun->machine->varargs_size);
6420
6421   /* Save other computed information.  */
6422   cfun->machine->frame.total_size = total_size;
6423   cfun->machine->frame.var_size = var_size;
6424   cfun->machine->frame.args_size = args_size;
6425   cfun->machine->frame.cprestore_size = cprestore_size;
6426   cfun->machine->frame.gp_reg_size = gp_reg_size;
6427   cfun->machine->frame.fp_reg_size = fp_reg_size;
6428   cfun->machine->frame.mask = mask;
6429   cfun->machine->frame.fmask = fmask;
6430   cfun->machine->frame.initialized = reload_completed;
6431   cfun->machine->frame.num_gp = gp_reg_size / UNITS_PER_WORD;
6432   cfun->machine->frame.num_fp = fp_reg_size / (FP_INC * UNITS_PER_FPREG);
6433
6434   if (mask)
6435     {
6436       HOST_WIDE_INT offset;
6437
6438       offset = (args_size + cprestore_size + var_size
6439                 + gp_reg_size - GET_MODE_SIZE (gpr_mode));
6440       cfun->machine->frame.gp_sp_offset = offset;
6441       cfun->machine->frame.gp_save_offset = offset - total_size;
6442     }
6443   else
6444     {
6445       cfun->machine->frame.gp_sp_offset = 0;
6446       cfun->machine->frame.gp_save_offset = 0;
6447     }
6448
6449   if (fmask)
6450     {
6451       HOST_WIDE_INT offset;
6452
6453       offset = (args_size + cprestore_size + var_size
6454                 + gp_reg_rounded + fp_reg_size
6455                 - FP_INC * UNITS_PER_FPREG);
6456       cfun->machine->frame.fp_sp_offset = offset;
6457       cfun->machine->frame.fp_save_offset = offset - total_size;
6458     }
6459   else
6460     {
6461       cfun->machine->frame.fp_sp_offset = 0;
6462       cfun->machine->frame.fp_save_offset = 0;
6463     }
6464
6465   /* Ok, we're done.  */
6466   return total_size;
6467 }
6468 \f
6469 /* Implement INITIAL_ELIMINATION_OFFSET.  FROM is either the frame
6470    pointer or argument pointer.  TO is either the stack pointer or
6471    hard frame pointer.  */
6472
6473 HOST_WIDE_INT
6474 mips_initial_elimination_offset (int from, int to)
6475 {
6476   HOST_WIDE_INT offset;
6477
6478   compute_frame_size (get_frame_size ());
6479
6480   /* Set OFFSET to the offset from the stack pointer.  */
6481   switch (from)
6482     {
6483     case FRAME_POINTER_REGNUM:
6484       offset = 0;
6485       break;
6486
6487     case ARG_POINTER_REGNUM:
6488       offset = (cfun->machine->frame.total_size
6489                 - current_function_pretend_args_size);
6490       break;
6491
6492     default:
6493       gcc_unreachable ();
6494     }
6495
6496   if (TARGET_MIPS16 && to == HARD_FRAME_POINTER_REGNUM)
6497     offset -= cfun->machine->frame.args_size;
6498
6499   return offset;
6500 }
6501 \f
6502 /* Implement RETURN_ADDR_RTX.  Note, we do not support moving
6503    back to a previous frame.  */
6504 rtx
6505 mips_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
6506 {
6507   if (count != 0)
6508     return const0_rtx;
6509
6510   return get_hard_reg_initial_val (Pmode, GP_REG_FIRST + 31);
6511 }
6512 \f
6513 /* Use FN to save or restore register REGNO.  MODE is the register's
6514    mode and OFFSET is the offset of its save slot from the current
6515    stack pointer.  */
6516
6517 static void
6518 mips_save_restore_reg (enum machine_mode mode, int regno,
6519                        HOST_WIDE_INT offset, mips_save_restore_fn fn)
6520 {
6521   rtx mem;
6522
6523   mem = gen_frame_mem (mode, plus_constant (stack_pointer_rtx, offset));
6524
6525   fn (gen_rtx_REG (mode, regno), mem);
6526 }
6527
6528
6529 /* Call FN for each register that is saved by the current function.
6530    SP_OFFSET is the offset of the current stack pointer from the start
6531    of the frame.  */
6532
6533 static void
6534 mips_for_each_saved_reg (HOST_WIDE_INT sp_offset, mips_save_restore_fn fn)
6535 {
6536 #define BITSET_P(VALUE, BIT) (((VALUE) & (1L << (BIT))) != 0)
6537
6538   enum machine_mode fpr_mode;
6539   HOST_WIDE_INT offset;
6540   int regno;
6541
6542   /* Save registers starting from high to low.  The debuggers prefer at least
6543      the return register be stored at func+4, and also it allows us not to
6544      need a nop in the epilog if at least one register is reloaded in
6545      addition to return address.  */
6546   offset = cfun->machine->frame.gp_sp_offset - sp_offset;
6547   for (regno = GP_REG_LAST; regno >= GP_REG_FIRST; regno--)
6548     if (BITSET_P (cfun->machine->frame.mask, regno - GP_REG_FIRST))
6549       {
6550         mips_save_restore_reg (gpr_mode, regno, offset, fn);
6551         offset -= GET_MODE_SIZE (gpr_mode);
6552       }
6553
6554   /* This loop must iterate over the same space as its companion in
6555      compute_frame_size.  */
6556   offset = cfun->machine->frame.fp_sp_offset - sp_offset;
6557   fpr_mode = (TARGET_SINGLE_FLOAT ? SFmode : DFmode);
6558   for (regno = (FP_REG_LAST - FP_INC + 1);
6559        regno >= FP_REG_FIRST;
6560        regno -= FP_INC)
6561     if (BITSET_P (cfun->machine->frame.fmask, regno - FP_REG_FIRST))
6562       {
6563         mips_save_restore_reg (fpr_mode, regno, offset, fn);
6564         offset -= GET_MODE_SIZE (fpr_mode);
6565       }
6566 #undef BITSET_P
6567 }
6568 \f
6569 /* If we're generating n32 or n64 abicalls, and the current function
6570    does not use $28 as its global pointer, emit a cplocal directive.
6571    Use pic_offset_table_rtx as the argument to the directive.  */
6572
6573 static void
6574 mips_output_cplocal (void)
6575 {
6576   if (!TARGET_EXPLICIT_RELOCS
6577       && cfun->machine->global_pointer > 0
6578       && cfun->machine->global_pointer != GLOBAL_POINTER_REGNUM)
6579     output_asm_insn (".cplocal %+", 0);
6580 }
6581
6582 /* Return the style of GP load sequence that is being used for the
6583    current function.  */
6584
6585 enum mips_loadgp_style
6586 mips_current_loadgp_style (void)
6587 {
6588   if (!TARGET_ABICALLS || cfun->machine->global_pointer == 0)
6589     return LOADGP_NONE;
6590
6591   if (TARGET_ABSOLUTE_ABICALLS)
6592     return LOADGP_ABSOLUTE;
6593
6594   return TARGET_NEWABI ? LOADGP_NEWABI : LOADGP_OLDABI;
6595 }
6596
6597 /* The __gnu_local_gp symbol.  */
6598
6599 static GTY(()) rtx mips_gnu_local_gp;
6600
6601 /* If we're generating n32 or n64 abicalls, emit instructions
6602    to set up the global pointer.  */
6603
6604 static void
6605 mips_emit_loadgp (void)
6606 {
6607   rtx addr, offset, incoming_address;
6608
6609   switch (mips_current_loadgp_style ())
6610     {
6611     case LOADGP_ABSOLUTE:
6612       if (mips_gnu_local_gp == NULL)
6613         {
6614           mips_gnu_local_gp = gen_rtx_SYMBOL_REF (Pmode, "__gnu_local_gp");
6615           SYMBOL_REF_FLAGS (mips_gnu_local_gp) |= SYMBOL_FLAG_LOCAL;
6616         }
6617       emit_insn (gen_loadgp_noshared (mips_gnu_local_gp));
6618       break;
6619
6620     case LOADGP_NEWABI:
6621       addr = XEXP (DECL_RTL (current_function_decl), 0);
6622       offset = mips_unspec_address (addr, SYMBOL_GOTOFF_LOADGP);
6623       incoming_address = gen_rtx_REG (Pmode, PIC_FUNCTION_ADDR_REGNUM);
6624       emit_insn (gen_loadgp (offset, incoming_address));
6625       if (!TARGET_EXPLICIT_RELOCS)
6626         emit_insn (gen_loadgp_blockage ());
6627       break;
6628
6629     default:
6630       break;
6631     }
6632 }
6633
6634 /* Set up the stack and frame (if desired) for the function.  */
6635
6636 static void
6637 mips_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
6638 {
6639   const char *fnname;
6640   HOST_WIDE_INT tsize = cfun->machine->frame.total_size;
6641
6642 #ifdef SDB_DEBUGGING_INFO
6643   if (debug_info_level != DINFO_LEVEL_TERSE && write_symbols == SDB_DEBUG)
6644     SDB_OUTPUT_SOURCE_LINE (file, DECL_SOURCE_LINE (current_function_decl));
6645 #endif
6646
6647   /* In mips16 mode, we may need to generate a 32 bit to handle
6648      floating point arguments.  The linker will arrange for any 32 bit
6649      functions to call this stub, which will then jump to the 16 bit
6650      function proper.  */
6651   if (TARGET_MIPS16 && !TARGET_SOFT_FLOAT
6652       && current_function_args_info.fp_code != 0)
6653     build_mips16_function_stub (file);
6654
6655   if (!FUNCTION_NAME_ALREADY_DECLARED)
6656     {
6657       /* Get the function name the same way that toplev.c does before calling
6658          assemble_start_function.  This is needed so that the name used here
6659          exactly matches the name used in ASM_DECLARE_FUNCTION_NAME.  */
6660       fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
6661
6662       if (!flag_inhibit_size_directive)
6663         {
6664           fputs ("\t.ent\t", file);
6665           assemble_name (file, fnname);
6666           fputs ("\n", file);
6667         }
6668
6669       assemble_name (file, fnname);
6670       fputs (":\n", file);
6671     }
6672
6673   /* Stop mips_file_end from treating this function as external.  */
6674   if (TARGET_IRIX && mips_abi == ABI_32)
6675     TREE_ASM_WRITTEN (DECL_NAME (cfun->decl)) = 1;
6676
6677   if (!flag_inhibit_size_directive)
6678     {
6679       /* .frame FRAMEREG, FRAMESIZE, RETREG */
6680       fprintf (file,
6681                "\t.frame\t%s," HOST_WIDE_INT_PRINT_DEC ",%s\t\t"
6682                "# vars= " HOST_WIDE_INT_PRINT_DEC ", regs= %d/%d"
6683                ", args= " HOST_WIDE_INT_PRINT_DEC
6684                ", gp= " HOST_WIDE_INT_PRINT_DEC "\n",
6685                (reg_names[(frame_pointer_needed)
6686                           ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM]),
6687                ((frame_pointer_needed && TARGET_MIPS16)
6688                 ? tsize - cfun->machine->frame.args_size
6689                 : tsize),
6690                reg_names[GP_REG_FIRST + 31],
6691                cfun->machine->frame.var_size,
6692                cfun->machine->frame.num_gp,
6693                cfun->machine->frame.num_fp,
6694                cfun->machine->frame.args_size,
6695                cfun->machine->frame.cprestore_size);
6696
6697       /* .mask MASK, GPOFFSET; .fmask FPOFFSET */
6698       fprintf (file, "\t.mask\t0x%08x," HOST_WIDE_INT_PRINT_DEC "\n",
6699                cfun->machine->frame.mask,
6700                cfun->machine->frame.gp_save_offset);
6701       fprintf (file, "\t.fmask\t0x%08x," HOST_WIDE_INT_PRINT_DEC "\n",
6702                cfun->machine->frame.fmask,
6703                cfun->machine->frame.fp_save_offset);
6704
6705       /* Require:
6706          OLD_SP == *FRAMEREG + FRAMESIZE => can find old_sp from nominated FP reg.
6707          HIGHEST_GP_SAVED == *FRAMEREG + FRAMESIZE + GPOFFSET => can find saved regs.  */
6708     }
6709
6710   if (mips_current_loadgp_style () == LOADGP_OLDABI)
6711     {
6712       /* Handle the initialization of $gp for SVR4 PIC.  */
6713       if (!cfun->machine->all_noreorder_p)
6714         output_asm_insn ("%(.cpload\t%^%)", 0);
6715       else
6716         output_asm_insn ("%(.cpload\t%^\n\t%<", 0);
6717     }
6718   else if (cfun->machine->all_noreorder_p)
6719     output_asm_insn ("%(%<", 0);
6720
6721   /* Tell the assembler which register we're using as the global
6722      pointer.  This is needed for thunks, since they can use either
6723      explicit relocs or assembler macros.  */
6724   mips_output_cplocal ();
6725 }
6726 \f
6727 /* Make the last instruction frame related and note that it performs
6728    the operation described by FRAME_PATTERN.  */
6729
6730 static void
6731 mips_set_frame_expr (rtx frame_pattern)
6732 {
6733   rtx insn;
6734
6735   insn = get_last_insn ();
6736   RTX_FRAME_RELATED_P (insn) = 1;
6737   REG_NOTES (insn) = alloc_EXPR_LIST (REG_FRAME_RELATED_EXPR,
6738                                       frame_pattern,
6739                                       REG_NOTES (insn));
6740 }
6741
6742
6743 /* Return a frame-related rtx that stores REG at MEM.
6744    REG must be a single register.  */
6745
6746 static rtx
6747 mips_frame_set (rtx mem, rtx reg)
6748 {
6749   rtx set;
6750
6751   /* If we're saving the return address register and the dwarf return
6752      address column differs from the hard register number, adjust the
6753      note reg to refer to the former.  */
6754   if (REGNO (reg) == GP_REG_FIRST + 31
6755       && DWARF_FRAME_RETURN_COLUMN != GP_REG_FIRST + 31)
6756     reg = gen_rtx_REG (GET_MODE (reg), DWARF_FRAME_RETURN_COLUMN);
6757
6758   set = gen_rtx_SET (VOIDmode, mem, reg);
6759   RTX_FRAME_RELATED_P (set) = 1;
6760
6761   return set;
6762 }
6763
6764
6765 /* Save register REG to MEM.  Make the instruction frame-related.  */
6766
6767 static void
6768 mips_save_reg (rtx reg, rtx mem)
6769 {
6770   if (GET_MODE (reg) == DFmode && !TARGET_FLOAT64)
6771     {
6772       rtx x1, x2;
6773
6774       if (mips_split_64bit_move_p (mem, reg))
6775         mips_split_64bit_move (mem, reg);
6776       else
6777         emit_move_insn (mem, reg);
6778
6779       x1 = mips_frame_set (mips_subword (mem, 0), mips_subword (reg, 0));
6780       x2 = mips_frame_set (mips_subword (mem, 1), mips_subword (reg, 1));
6781       mips_set_frame_expr (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, x1, x2)));
6782     }
6783   else
6784     {
6785       if (TARGET_MIPS16
6786           && REGNO (reg) != GP_REG_FIRST + 31
6787           && !M16_REG_P (REGNO (reg)))
6788         {
6789           /* Save a non-mips16 register by moving it through a temporary.
6790              We don't need to do this for $31 since there's a special
6791              instruction for it.  */
6792           emit_move_insn (MIPS_PROLOGUE_TEMP (GET_MODE (reg)), reg);
6793           emit_move_insn (mem, MIPS_PROLOGUE_TEMP (GET_MODE (reg)));
6794         }
6795       else
6796         emit_move_insn (mem, reg);
6797
6798       mips_set_frame_expr (mips_frame_set (mem, reg));
6799     }
6800 }
6801
6802
6803 /* Expand the prologue into a bunch of separate insns.  */
6804
6805 void
6806 mips_expand_prologue (void)
6807 {
6808   HOST_WIDE_INT size;
6809
6810   if (cfun->machine->global_pointer > 0)
6811     REGNO (pic_offset_table_rtx) = cfun->machine->global_pointer;
6812
6813   size = compute_frame_size (get_frame_size ());
6814
6815   /* Save the registers.  Allocate up to MIPS_MAX_FIRST_STACK_STEP
6816      bytes beforehand; this is enough to cover the register save area
6817      without going out of range.  */
6818   if ((cfun->machine->frame.mask | cfun->machine->frame.fmask) != 0)
6819     {
6820       HOST_WIDE_INT step1;
6821
6822       step1 = MIN (size, MIPS_MAX_FIRST_STACK_STEP);
6823       RTX_FRAME_RELATED_P (emit_insn (gen_add3_insn (stack_pointer_rtx,
6824                                                      stack_pointer_rtx,
6825                                                      GEN_INT (-step1)))) = 1;
6826       size -= step1;
6827       mips_for_each_saved_reg (size, mips_save_reg);
6828     }
6829
6830   /* Allocate the rest of the frame.  */
6831   if (size > 0)
6832     {
6833       if (SMALL_OPERAND (-size))
6834         RTX_FRAME_RELATED_P (emit_insn (gen_add3_insn (stack_pointer_rtx,
6835                                                        stack_pointer_rtx,
6836                                                        GEN_INT (-size)))) = 1;
6837       else
6838         {
6839           emit_move_insn (MIPS_PROLOGUE_TEMP (Pmode), GEN_INT (size));
6840           if (TARGET_MIPS16)
6841             {
6842               /* There are no instructions to add or subtract registers
6843                  from the stack pointer, so use the frame pointer as a
6844                  temporary.  We should always be using a frame pointer
6845                  in this case anyway.  */
6846               gcc_assert (frame_pointer_needed);
6847               emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
6848               emit_insn (gen_sub3_insn (hard_frame_pointer_rtx,
6849                                         hard_frame_pointer_rtx,
6850                                         MIPS_PROLOGUE_TEMP (Pmode)));
6851               emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
6852             }
6853           else
6854             emit_insn (gen_sub3_insn (stack_pointer_rtx,
6855                                       stack_pointer_rtx,
6856                                       MIPS_PROLOGUE_TEMP (Pmode)));
6857
6858           /* Describe the combined effect of the previous instructions.  */
6859           mips_set_frame_expr
6860             (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
6861                           plus_constant (stack_pointer_rtx, -size)));
6862         }
6863     }
6864
6865   /* Set up the frame pointer, if we're using one.  In mips16 code,
6866      we point the frame pointer ahead of the outgoing argument area.
6867      This should allow more variables & incoming arguments to be
6868      accessed with unextended instructions.  */
6869   if (frame_pointer_needed)
6870     {
6871       if (TARGET_MIPS16 && cfun->machine->frame.args_size != 0)
6872         {
6873           rtx offset = GEN_INT (cfun->machine->frame.args_size);
6874           if (SMALL_OPERAND (cfun->machine->frame.args_size))
6875             RTX_FRAME_RELATED_P
6876               (emit_insn (gen_add3_insn (hard_frame_pointer_rtx,
6877                                          stack_pointer_rtx,
6878                                          offset))) = 1;
6879           else
6880             {
6881               emit_move_insn (MIPS_PROLOGUE_TEMP (Pmode), offset);
6882               emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
6883               emit_insn (gen_add3_insn (hard_frame_pointer_rtx,
6884                                         hard_frame_pointer_rtx,
6885                                         MIPS_PROLOGUE_TEMP (Pmode)));
6886               mips_set_frame_expr
6887                 (gen_rtx_SET (VOIDmode, hard_frame_pointer_rtx,
6888                               plus_constant (stack_pointer_rtx,
6889                                              cfun->machine->frame.args_size)));
6890             }
6891         }
6892       else
6893         RTX_FRAME_RELATED_P (emit_move_insn (hard_frame_pointer_rtx,
6894                                              stack_pointer_rtx)) = 1;
6895     }
6896
6897   mips_emit_loadgp ();
6898
6899   /* If generating o32/o64 abicalls, save $gp on the stack.  */
6900   if (TARGET_ABICALLS && !TARGET_NEWABI && !current_function_is_leaf)
6901     emit_insn (gen_cprestore (GEN_INT (current_function_outgoing_args_size)));
6902
6903   /* If we are profiling, make sure no instructions are scheduled before
6904      the call to mcount.  */
6905
6906   if (current_function_profile)
6907     emit_insn (gen_blockage ());
6908 }
6909 \f
6910 /* Do any necessary cleanup after a function to restore stack, frame,
6911    and regs.  */
6912
6913 #define RA_MASK BITMASK_HIGH    /* 1 << 31 */
6914
6915 static void
6916 mips_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
6917                                HOST_WIDE_INT size ATTRIBUTE_UNUSED)
6918 {
6919   /* Reinstate the normal $gp.  */
6920   REGNO (pic_offset_table_rtx) = GLOBAL_POINTER_REGNUM;
6921   mips_output_cplocal ();
6922
6923   if (cfun->machine->all_noreorder_p)
6924     {
6925       /* Avoid using %>%) since it adds excess whitespace.  */
6926       output_asm_insn (".set\tmacro", 0);
6927       output_asm_insn (".set\treorder", 0);
6928       set_noreorder = set_nomacro = 0;
6929     }
6930
6931   if (!FUNCTION_NAME_ALREADY_DECLARED && !flag_inhibit_size_directive)
6932     {
6933       const char *fnname;
6934
6935       /* Get the function name the same way that toplev.c does before calling
6936          assemble_start_function.  This is needed so that the name used here
6937          exactly matches the name used in ASM_DECLARE_FUNCTION_NAME.  */
6938       fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
6939       fputs ("\t.end\t", file);
6940       assemble_name (file, fnname);
6941       fputs ("\n", file);
6942     }
6943 }
6944 \f
6945 /* Emit instructions to restore register REG from slot MEM.  */
6946
6947 static void
6948 mips_restore_reg (rtx reg, rtx mem)
6949 {
6950   /* There's no mips16 instruction to load $31 directly.  Load into
6951      $7 instead and adjust the return insn appropriately.  */
6952   if (TARGET_MIPS16 && REGNO (reg) == GP_REG_FIRST + 31)
6953     reg = gen_rtx_REG (GET_MODE (reg), 7);
6954
6955   if (TARGET_MIPS16 && !M16_REG_P (REGNO (reg)))
6956     {
6957       /* Can't restore directly; move through a temporary.  */
6958       emit_move_insn (MIPS_EPILOGUE_TEMP (GET_MODE (reg)), mem);
6959       emit_move_insn (reg, MIPS_EPILOGUE_TEMP (GET_MODE (reg)));
6960     }
6961   else
6962     emit_move_insn (reg, mem);
6963 }
6964
6965
6966 /* Expand the epilogue into a bunch of separate insns.  SIBCALL_P is true
6967    if this epilogue precedes a sibling call, false if it is for a normal
6968    "epilogue" pattern.  */
6969
6970 void
6971 mips_expand_epilogue (int sibcall_p)
6972 {
6973   HOST_WIDE_INT step1, step2;
6974   rtx base, target;
6975
6976   if (!sibcall_p && mips_can_use_return_insn ())
6977     {
6978       emit_jump_insn (gen_return ());
6979       return;
6980     }
6981
6982   /* Split the frame into two.  STEP1 is the amount of stack we should
6983      deallocate before restoring the registers.  STEP2 is the amount we
6984      should deallocate afterwards.
6985
6986      Start off by assuming that no registers need to be restored.  */
6987   step1 = cfun->machine->frame.total_size;
6988   step2 = 0;
6989
6990   /* Work out which register holds the frame address.  Account for the
6991      frame pointer offset used by mips16 code.  */
6992   if (!frame_pointer_needed)
6993     base = stack_pointer_rtx;
6994   else
6995     {
6996       base = hard_frame_pointer_rtx;
6997       if (TARGET_MIPS16)
6998         step1 -= cfun->machine->frame.args_size;
6999     }
7000
7001   /* If we need to restore registers, deallocate as much stack as
7002      possible in the second step without going out of range.  */
7003   if ((cfun->machine->frame.mask | cfun->machine->frame.fmask) != 0)
7004     {
7005       step2 = MIN (step1, MIPS_MAX_FIRST_STACK_STEP);
7006       step1 -= step2;
7007     }
7008
7009   /* Set TARGET to BASE + STEP1.  */
7010   target = base;
7011   if (step1 > 0)
7012     {
7013       rtx adjust;
7014
7015       /* Get an rtx for STEP1 that we can add to BASE.  */
7016       adjust = GEN_INT (step1);
7017       if (!SMALL_OPERAND (step1))
7018         {
7019           emit_move_insn (MIPS_EPILOGUE_TEMP (Pmode), adjust);
7020           adjust = MIPS_EPILOGUE_TEMP (Pmode);
7021         }
7022
7023       /* Normal mode code can copy the result straight into $sp.  */
7024       if (!TARGET_MIPS16)
7025         target = stack_pointer_rtx;
7026
7027       emit_insn (gen_add3_insn (target, base, adjust));
7028     }
7029
7030   /* Copy TARGET into the stack pointer.  */
7031   if (target != stack_pointer_rtx)
7032     emit_move_insn (stack_pointer_rtx, target);
7033
7034   /* If we're using addressing macros for n32/n64 abicalls, $gp is
7035      implicitly used by all SYMBOL_REFs.  We must emit a blockage
7036      insn before restoring it.  */
7037   if (TARGET_ABICALLS && TARGET_NEWABI && !TARGET_EXPLICIT_RELOCS)
7038     emit_insn (gen_blockage ());
7039
7040   /* Restore the registers.  */
7041   mips_for_each_saved_reg (cfun->machine->frame.total_size - step2,
7042                            mips_restore_reg);
7043
7044   /* Deallocate the final bit of the frame.  */
7045   if (step2 > 0)
7046     emit_insn (gen_add3_insn (stack_pointer_rtx,
7047                               stack_pointer_rtx,
7048                               GEN_INT (step2)));
7049
7050   /* Add in the __builtin_eh_return stack adjustment.  We need to
7051      use a temporary in mips16 code.  */
7052   if (current_function_calls_eh_return)
7053     {
7054       if (TARGET_MIPS16)
7055         {
7056           emit_move_insn (MIPS_EPILOGUE_TEMP (Pmode), stack_pointer_rtx);
7057           emit_insn (gen_add3_insn (MIPS_EPILOGUE_TEMP (Pmode),
7058                                     MIPS_EPILOGUE_TEMP (Pmode),
7059                                     EH_RETURN_STACKADJ_RTX));
7060           emit_move_insn (stack_pointer_rtx, MIPS_EPILOGUE_TEMP (Pmode));
7061         }
7062       else
7063         emit_insn (gen_add3_insn (stack_pointer_rtx,
7064                                   stack_pointer_rtx,
7065                                   EH_RETURN_STACKADJ_RTX));
7066     }
7067
7068   if (!sibcall_p)
7069     {
7070       /* The mips16 loads the return address into $7, not $31.  */
7071       if (TARGET_MIPS16 && (cfun->machine->frame.mask & RA_MASK) != 0)
7072         emit_jump_insn (gen_return_internal (gen_rtx_REG (Pmode,
7073                                                           GP_REG_FIRST + 7)));
7074       else
7075         emit_jump_insn (gen_return_internal (gen_rtx_REG (Pmode,
7076                                                           GP_REG_FIRST + 31)));
7077     }
7078 }
7079 \f
7080 /* Return nonzero if this function is known to have a null epilogue.
7081    This allows the optimizer to omit jumps to jumps if no stack
7082    was created.  */
7083
7084 int
7085 mips_can_use_return_insn (void)
7086 {
7087   tree return_type;
7088
7089   if (! reload_completed)
7090     return 0;
7091
7092   if (regs_ever_live[31] || current_function_profile)
7093     return 0;
7094
7095   return_type = DECL_RESULT (current_function_decl);
7096
7097   /* In mips16 mode, a function which returns a floating point value
7098      needs to arrange to copy the return value into the floating point
7099      registers.  */
7100   if (TARGET_MIPS16
7101       && mips16_hard_float
7102       && ! aggregate_value_p (return_type, current_function_decl)
7103       && GET_MODE_CLASS (DECL_MODE (return_type)) == MODE_FLOAT
7104       && GET_MODE_SIZE (DECL_MODE (return_type)) <= UNITS_PER_FPVALUE)
7105     return 0;
7106
7107   if (cfun->machine->frame.initialized)
7108     return cfun->machine->frame.total_size == 0;
7109
7110   return compute_frame_size (get_frame_size ()) == 0;
7111 }
7112 \f
7113 /* Implement TARGET_ASM_OUTPUT_MI_THUNK.  Generate rtl rather than asm text
7114    in order to avoid duplicating too much logic from elsewhere.  */
7115
7116 static void
7117 mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
7118                       HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
7119                       tree function)
7120 {
7121   rtx this, temp1, temp2, insn, fnaddr;
7122
7123   /* Pretend to be a post-reload pass while generating rtl.  */
7124   no_new_pseudos = 1;
7125   reload_completed = 1;
7126   reset_block_changes ();
7127
7128   /* Pick a global pointer for -mabicalls.  Use $15 rather than $28
7129      for TARGET_NEWABI since the latter is a call-saved register.  */
7130   if (TARGET_ABICALLS)
7131     cfun->machine->global_pointer
7132       = REGNO (pic_offset_table_rtx)
7133       = TARGET_NEWABI ? 15 : GLOBAL_POINTER_REGNUM;
7134
7135   /* Set up the global pointer for n32 or n64 abicalls.  */
7136   mips_emit_loadgp ();
7137
7138   /* We need two temporary registers in some cases.  */
7139   temp1 = gen_rtx_REG (Pmode, 2);
7140   temp2 = gen_rtx_REG (Pmode, 3);
7141
7142   /* Find out which register contains the "this" pointer.  */
7143   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
7144     this = gen_rtx_REG (Pmode, GP_ARG_FIRST + 1);
7145   else
7146     this = gen_rtx_REG (Pmode, GP_ARG_FIRST);
7147
7148   /* Add DELTA to THIS.  */
7149   if (delta != 0)
7150     {
7151       rtx offset = GEN_INT (delta);
7152       if (!SMALL_OPERAND (delta))
7153         {
7154           emit_move_insn (temp1, offset);
7155           offset = temp1;
7156         }
7157       emit_insn (gen_add3_insn (this, this, offset));
7158     }
7159
7160   /* If needed, add *(*THIS + VCALL_OFFSET) to THIS.  */
7161   if (vcall_offset != 0)
7162     {
7163       rtx addr;
7164
7165       /* Set TEMP1 to *THIS.  */
7166       emit_move_insn (temp1, gen_rtx_MEM (Pmode, this));
7167
7168       /* Set ADDR to a legitimate address for *THIS + VCALL_OFFSET.  */
7169       addr = mips_add_offset (temp2, temp1, vcall_offset);
7170
7171       /* Load the offset and add it to THIS.  */
7172       emit_move_insn (temp1, gen_rtx_MEM (Pmode, addr));
7173       emit_insn (gen_add3_insn (this, this, temp1));
7174     }
7175
7176   /* Jump to the target function.  Use a sibcall if direct jumps are
7177      allowed, otherwise load the address into a register first.  */
7178   fnaddr = XEXP (DECL_RTL (function), 0);
7179   if (TARGET_MIPS16 || TARGET_ABICALLS || TARGET_LONG_CALLS)
7180     {
7181       /* This is messy.  gas treats "la $25,foo" as part of a call
7182          sequence and may allow a global "foo" to be lazily bound.
7183          The general move patterns therefore reject this combination.
7184
7185          In this context, lazy binding would actually be OK for o32 and o64,
7186          but it's still wrong for n32 and n64; see mips_load_call_address.
7187          We must therefore load the address via a temporary register if
7188          mips_dangerous_for_la25_p.
7189
7190          If we jump to the temporary register rather than $25, the assembler
7191          can use the move insn to fill the jump's delay slot.  */
7192       if (TARGET_ABICALLS && !mips_dangerous_for_la25_p (fnaddr))
7193         temp1 = gen_rtx_REG (Pmode, PIC_FUNCTION_ADDR_REGNUM);
7194       mips_load_call_address (temp1, fnaddr, true);
7195
7196       if (TARGET_ABICALLS && REGNO (temp1) != PIC_FUNCTION_ADDR_REGNUM)
7197         emit_move_insn (gen_rtx_REG (Pmode, PIC_FUNCTION_ADDR_REGNUM), temp1);
7198       emit_jump_insn (gen_indirect_jump (temp1));
7199     }
7200   else
7201     {
7202       insn = emit_call_insn (gen_sibcall_internal (fnaddr, const0_rtx));
7203       SIBLING_CALL_P (insn) = 1;
7204     }
7205
7206   /* Run just enough of rest_of_compilation.  This sequence was
7207      "borrowed" from alpha.c.  */
7208   insn = get_insns ();
7209   insn_locators_initialize ();
7210   split_all_insns_noflow ();
7211   if (TARGET_MIPS16)
7212     mips16_lay_out_constants ();
7213   shorten_branches (insn);
7214   final_start_function (insn, file, 1);
7215   final (insn, file, 1);
7216   final_end_function ();
7217
7218   /* Clean up the vars set above.  Note that final_end_function resets
7219      the global pointer for us.  */
7220   reload_completed = 0;
7221   no_new_pseudos = 0;
7222 }
7223 \f
7224 /* Returns nonzero if X contains a SYMBOL_REF.  */
7225
7226 static int
7227 symbolic_expression_p (rtx x)
7228 {
7229   if (GET_CODE (x) == SYMBOL_REF)
7230     return 1;
7231
7232   if (GET_CODE (x) == CONST)
7233     return symbolic_expression_p (XEXP (x, 0));
7234
7235   if (UNARY_P (x))
7236     return symbolic_expression_p (XEXP (x, 0));
7237
7238   if (ARITHMETIC_P (x))
7239     return (symbolic_expression_p (XEXP (x, 0))
7240             || symbolic_expression_p (XEXP (x, 1)));
7241
7242   return 0;
7243 }
7244
7245 /* Choose the section to use for the constant rtx expression X that has
7246    mode MODE.  */
7247
7248 static section *
7249 mips_select_rtx_section (enum machine_mode mode, rtx x,
7250                          unsigned HOST_WIDE_INT align)
7251 {
7252   if (TARGET_MIPS16)
7253     {
7254       /* In mips16 mode, the constant table always goes in the same section
7255          as the function, so that constants can be loaded using PC relative
7256          addressing.  */
7257       return function_section (current_function_decl);
7258     }
7259   else if (TARGET_EMBEDDED_DATA)
7260     {
7261       /* For embedded applications, always put constants in read-only data,
7262          in order to reduce RAM usage.  */
7263       return mergeable_constant_section (mode, align, 0);
7264     }
7265   else
7266     {
7267       /* For hosted applications, always put constants in small data if
7268          possible, as this gives the best performance.  */
7269       /* ??? Consider using mergeable small data sections.  */
7270
7271       if (GET_MODE_SIZE (mode) <= (unsigned) mips_section_threshold
7272           && mips_section_threshold > 0)
7273         return get_named_section (NULL, ".sdata", 0);
7274       else if (flag_pic && symbolic_expression_p (x))
7275         return get_named_section (NULL, ".data.rel.ro", 3);
7276       else
7277         return mergeable_constant_section (mode, align, 0);
7278     }
7279 }
7280
7281 /* Implement TARGET_ASM_FUNCTION_RODATA_SECTION.
7282
7283    The complication here is that, with the combination TARGET_ABICALLS
7284    && !TARGET_GPWORD, jump tables will use absolute addresses, and should
7285    therefore not be included in the read-only part of a DSO.  Handle such
7286    cases by selecting a normal data section instead of a read-only one.
7287    The logic apes that in default_function_rodata_section.  */
7288
7289 static section *
7290 mips_function_rodata_section (tree decl)
7291 {
7292   if (!TARGET_ABICALLS || TARGET_GPWORD)
7293     return default_function_rodata_section (decl);
7294
7295   if (decl && DECL_SECTION_NAME (decl))
7296     {
7297       const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
7298       if (DECL_ONE_ONLY (decl) && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
7299         {
7300           char *rname = ASTRDUP (name);
7301           rname[14] = 'd';
7302           return get_section (rname, SECTION_LINKONCE | SECTION_WRITE, decl);
7303         }
7304       else if (flag_function_sections && flag_data_sections
7305                && strncmp (name, ".text.", 6) == 0)
7306         {
7307           char *rname = ASTRDUP (name);
7308           memcpy (rname + 1, "data", 4);
7309           return get_section (rname, SECTION_WRITE, decl);
7310         }
7311     }
7312   return data_section;
7313 }
7314
7315 /* Implement TARGET_IN_SMALL_DATA_P.  This function controls whether
7316    locally-defined objects go in a small data section.  It also controls
7317    the setting of the SYMBOL_REF_SMALL_P flag, which in turn helps
7318    mips_classify_symbol decide when to use %gp_rel(...)($gp) accesses.  */
7319
7320 static bool
7321 mips_in_small_data_p (tree decl)
7322 {
7323   HOST_WIDE_INT size;
7324
7325   if (TREE_CODE (decl) == STRING_CST || TREE_CODE (decl) == FUNCTION_DECL)
7326     return false;
7327
7328   /* We don't yet generate small-data references for -mabicalls.  See related
7329      -G handling in override_options.  */
7330   if (TARGET_ABICALLS)
7331     return false;
7332
7333   if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl) != 0)
7334     {
7335       const char *name;
7336
7337       /* Reject anything that isn't in a known small-data section.  */
7338       name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
7339       if (strcmp (name, ".sdata") != 0 && strcmp (name, ".sbss") != 0)
7340         return false;
7341
7342       /* If a symbol is defined externally, the assembler will use the
7343          usual -G rules when deciding how to implement macros.  */
7344       if (TARGET_EXPLICIT_RELOCS || !DECL_EXTERNAL (decl))
7345         return true;
7346     }
7347   else if (TARGET_EMBEDDED_DATA)
7348     {
7349       /* Don't put constants into the small data section: we want them
7350          to be in ROM rather than RAM.  */
7351       if (TREE_CODE (decl) != VAR_DECL)
7352         return false;
7353
7354       if (TREE_READONLY (decl)
7355           && !TREE_SIDE_EFFECTS (decl)
7356           && (!DECL_INITIAL (decl) || TREE_CONSTANT (DECL_INITIAL (decl))))
7357         return false;
7358     }
7359
7360   size = int_size_in_bytes (TREE_TYPE (decl));
7361   return (size > 0 && size <= mips_section_threshold);
7362 }
7363
7364 /* Implement TARGET_USE_ANCHORS_FOR_SYMBOL_P.  We don't want to use
7365    anchors for small data: the GP register acts as an anchor in that
7366    case.  We also don't want to use them for PC-relative accesses,
7367    where the PC acts as an anchor.  */
7368
7369 static bool
7370 mips_use_anchors_for_symbol_p (rtx symbol)
7371 {
7372   switch (mips_classify_symbol (symbol))
7373     {
7374     case SYMBOL_CONSTANT_POOL:
7375     case SYMBOL_SMALL_DATA:
7376       return false;
7377
7378     default:
7379       return true;
7380     }
7381 }
7382 \f
7383 /* See whether VALTYPE is a record whose fields should be returned in
7384    floating-point registers.  If so, return the number of fields and
7385    list them in FIELDS (which should have two elements).  Return 0
7386    otherwise.
7387
7388    For n32 & n64, a structure with one or two fields is returned in
7389    floating-point registers as long as every field has a floating-point
7390    type.  */
7391
7392 static int
7393 mips_fpr_return_fields (tree valtype, tree *fields)
7394 {
7395   tree field;
7396   int i;
7397
7398   if (!TARGET_NEWABI)
7399     return 0;
7400
7401   if (TREE_CODE (valtype) != RECORD_TYPE)
7402     return 0;
7403
7404   i = 0;
7405   for (field = TYPE_FIELDS (valtype); field != 0; field = TREE_CHAIN (field))
7406     {
7407       if (TREE_CODE (field) != FIELD_DECL)
7408         continue;
7409
7410       if (TREE_CODE (TREE_TYPE (field)) != REAL_TYPE)
7411         return 0;
7412
7413       if (i == 2)
7414         return 0;
7415
7416       fields[i++] = field;
7417     }
7418   return i;
7419 }
7420
7421
7422 /* Implement TARGET_RETURN_IN_MSB.  For n32 & n64, we should return
7423    a value in the most significant part of $2/$3 if:
7424
7425       - the target is big-endian;
7426
7427       - the value has a structure or union type (we generalize this to
7428         cover aggregates from other languages too); and
7429
7430       - the structure is not returned in floating-point registers.  */
7431
7432 static bool
7433 mips_return_in_msb (tree valtype)
7434 {
7435   tree fields[2];
7436
7437   return (TARGET_NEWABI
7438           && TARGET_BIG_ENDIAN
7439           && AGGREGATE_TYPE_P (valtype)
7440           && mips_fpr_return_fields (valtype, fields) == 0);
7441 }
7442
7443
7444 /* Return a composite value in a pair of floating-point registers.
7445    MODE1 and OFFSET1 are the mode and byte offset for the first value,
7446    likewise MODE2 and OFFSET2 for the second.  MODE is the mode of the
7447    complete value.
7448
7449    For n32 & n64, $f0 always holds the first value and $f2 the second.
7450    Otherwise the values are packed together as closely as possible.  */
7451
7452 static rtx
7453 mips_return_fpr_pair (enum machine_mode mode,
7454                       enum machine_mode mode1, HOST_WIDE_INT offset1,
7455                       enum machine_mode mode2, HOST_WIDE_INT offset2)
7456 {
7457   int inc;
7458
7459   inc = (TARGET_NEWABI ? 2 : FP_INC);
7460   return gen_rtx_PARALLEL
7461     (mode,
7462      gen_rtvec (2,
7463                 gen_rtx_EXPR_LIST (VOIDmode,
7464                                    gen_rtx_REG (mode1, FP_RETURN),
7465                                    GEN_INT (offset1)),
7466                 gen_rtx_EXPR_LIST (VOIDmode,
7467                                    gen_rtx_REG (mode2, FP_RETURN + inc),
7468                                    GEN_INT (offset2))));
7469
7470 }
7471
7472
7473 /* Implement FUNCTION_VALUE and LIBCALL_VALUE.  For normal calls,
7474    VALTYPE is the return type and MODE is VOIDmode.  For libcalls,
7475    VALTYPE is null and MODE is the mode of the return value.  */
7476
7477 rtx
7478 mips_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
7479                      enum machine_mode mode)
7480 {
7481   if (valtype)
7482     {
7483       tree fields[2];
7484       int unsignedp;
7485
7486       mode = TYPE_MODE (valtype);
7487       unsignedp = TYPE_UNSIGNED (valtype);
7488
7489       /* Since we define TARGET_PROMOTE_FUNCTION_RETURN that returns
7490          true, we must promote the mode just as PROMOTE_MODE does.  */
7491       mode = promote_mode (valtype, mode, &unsignedp, 1);
7492
7493       /* Handle structures whose fields are returned in $f0/$f2.  */
7494       switch (mips_fpr_return_fields (valtype, fields))
7495         {
7496         case 1:
7497           return gen_rtx_REG (mode, FP_RETURN);
7498
7499         case 2:
7500           return mips_return_fpr_pair (mode,
7501                                        TYPE_MODE (TREE_TYPE (fields[0])),
7502                                        int_byte_position (fields[0]),
7503                                        TYPE_MODE (TREE_TYPE (fields[1])),
7504                                        int_byte_position (fields[1]));
7505         }
7506
7507       /* If a value is passed in the most significant part of a register, see
7508          whether we have to round the mode up to a whole number of words.  */
7509       if (mips_return_in_msb (valtype))
7510         {
7511           HOST_WIDE_INT size = int_size_in_bytes (valtype);
7512           if (size % UNITS_PER_WORD != 0)
7513             {
7514               size += UNITS_PER_WORD - size % UNITS_PER_WORD;
7515               mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
7516             }
7517         }
7518
7519       /* For EABI, the class of return register depends entirely on MODE.
7520          For example, "struct { some_type x; }" and "union { some_type x; }"
7521          are returned in the same way as a bare "some_type" would be.
7522          Other ABIs only use FPRs for scalar, complex or vector types.  */
7523       if (mips_abi != ABI_EABI && !FLOAT_TYPE_P (valtype))
7524         return gen_rtx_REG (mode, GP_RETURN);
7525     }
7526
7527   if ((GET_MODE_CLASS (mode) == MODE_FLOAT
7528        || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
7529       && GET_MODE_SIZE (mode) <= UNITS_PER_HWFPVALUE)
7530     return gen_rtx_REG (mode, FP_RETURN);
7531
7532   /* Handle long doubles for n32 & n64.  */
7533   if (mode == TFmode)
7534     return mips_return_fpr_pair (mode,
7535                                  DImode, 0,
7536                                  DImode, GET_MODE_SIZE (mode) / 2);
7537
7538   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
7539       && GET_MODE_SIZE (mode) <= UNITS_PER_HWFPVALUE * 2)
7540     return mips_return_fpr_pair (mode,
7541                                  GET_MODE_INNER (mode), 0,
7542                                  GET_MODE_INNER (mode),
7543                                  GET_MODE_SIZE (mode) / 2);
7544
7545   return gen_rtx_REG (mode, GP_RETURN);
7546 }
7547
7548 /* Return nonzero when an argument must be passed by reference.  */
7549
7550 static bool
7551 mips_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
7552                         enum machine_mode mode, tree type,
7553                         bool named ATTRIBUTE_UNUSED)
7554 {
7555   if (mips_abi == ABI_EABI)
7556     {
7557       int size;
7558
7559       /* ??? How should SCmode be handled?  */
7560       if (mode == DImode || mode == DFmode)
7561         return 0;
7562
7563       size = type ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
7564       return size == -1 || size > UNITS_PER_WORD;
7565     }
7566   else
7567     {
7568       /* If we have a variable-sized parameter, we have no choice.  */
7569       return targetm.calls.must_pass_in_stack (mode, type);
7570     }
7571 }
7572
7573 static bool
7574 mips_callee_copies (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
7575                     enum machine_mode mode ATTRIBUTE_UNUSED,
7576                     tree type ATTRIBUTE_UNUSED, bool named)
7577 {
7578   return mips_abi == ABI_EABI && named;
7579 }
7580
7581 /* Return true if registers of class CLASS cannot change from mode FROM
7582    to mode TO.  */
7583
7584 bool
7585 mips_cannot_change_mode_class (enum machine_mode from,
7586                                enum machine_mode to, enum reg_class class)
7587 {
7588   if (MIN (GET_MODE_SIZE (from), GET_MODE_SIZE (to)) <= UNITS_PER_WORD
7589       && MAX (GET_MODE_SIZE (from), GET_MODE_SIZE (to)) > UNITS_PER_WORD)
7590     {
7591       if (TARGET_BIG_ENDIAN)
7592         {
7593           /* When a multi-word value is stored in paired floating-point
7594              registers, the first register always holds the low word.
7595              We therefore can't allow FPRs to change between single-word
7596              and multi-word modes.  */
7597           if (FP_INC > 1 && reg_classes_intersect_p (FP_REGS, class))
7598             return true;
7599         }
7600       else
7601         {
7602           /* LO_REGNO == HI_REGNO + 1, so if a multi-word value is stored
7603              in LO and HI, the high word always comes first.  We therefore
7604              can't allow values stored in HI to change between single-word
7605              and multi-word modes.
7606              This rule applies to both the original HI/LO pair and the new
7607              DSP accumulators.  */
7608           if (reg_classes_intersect_p (ACC_REGS, class))
7609             return true;
7610         }
7611     }
7612
7613   /* gcc assumes that each word of a multiword register can be accessed
7614      individually using SUBREGs.  This is not true for floating-point
7615      registers if they are bigger than a word.  */
7616   if (UNITS_PER_FPREG > UNITS_PER_WORD
7617       && GET_MODE_SIZE (from) > UNITS_PER_WORD
7618       && GET_MODE_SIZE (to) < UNITS_PER_FPREG
7619       && reg_classes_intersect_p (FP_REGS, class))
7620     return true;
7621
7622   /* Loading a 32-bit value into a 64-bit floating-point register
7623      will not sign-extend the value, despite what LOAD_EXTEND_OP says.
7624      We can't allow 64-bit float registers to change from SImode to
7625      to a wider mode.  */
7626   if (TARGET_64BIT
7627       && TARGET_FLOAT64
7628       && from == SImode
7629       && GET_MODE_SIZE (to) >= UNITS_PER_WORD
7630       && reg_classes_intersect_p (FP_REGS, class))
7631     return true;
7632
7633   return false;
7634 }
7635
7636 /* Return true if X should not be moved directly into register $25.
7637    We need this because many versions of GAS will treat "la $25,foo" as
7638    part of a call sequence and so allow a global "foo" to be lazily bound.  */
7639
7640 bool
7641 mips_dangerous_for_la25_p (rtx x)
7642 {
7643   HOST_WIDE_INT offset;
7644
7645   if (TARGET_EXPLICIT_RELOCS)
7646     return false;
7647
7648   mips_split_const (x, &x, &offset);
7649   return global_got_operand (x, VOIDmode);
7650 }
7651
7652 /* Implement PREFERRED_RELOAD_CLASS.  */
7653
7654 enum reg_class
7655 mips_preferred_reload_class (rtx x, enum reg_class class)
7656 {
7657   if (mips_dangerous_for_la25_p (x) && reg_class_subset_p (LEA_REGS, class))
7658     return LEA_REGS;
7659
7660   if (TARGET_HARD_FLOAT
7661       && FLOAT_MODE_P (GET_MODE (x))
7662       && reg_class_subset_p (FP_REGS, class))
7663     return FP_REGS;
7664
7665   if (reg_class_subset_p (GR_REGS, class))
7666     class = GR_REGS;
7667
7668   if (TARGET_MIPS16 && reg_class_subset_p (M16_REGS, class))
7669     class = M16_REGS;
7670
7671   return class;
7672 }
7673
7674 /* This function returns the register class required for a secondary
7675    register when copying between one of the registers in CLASS, and X,
7676    using MODE.  If IN_P is nonzero, the copy is going from X to the
7677    register, otherwise the register is the source.  A return value of
7678    NO_REGS means that no secondary register is required.  */
7679
7680 enum reg_class
7681 mips_secondary_reload_class (enum reg_class class,
7682                              enum machine_mode mode, rtx x, int in_p)
7683 {
7684   enum reg_class gr_regs = TARGET_MIPS16 ? M16_REGS : GR_REGS;
7685   int regno = -1;
7686   int gp_reg_p;
7687
7688   if (REG_P (x)|| GET_CODE (x) == SUBREG)
7689     regno = true_regnum (x);
7690
7691   gp_reg_p = TARGET_MIPS16 ? M16_REG_P (regno) : GP_REG_P (regno);
7692
7693   if (mips_dangerous_for_la25_p (x))
7694     {
7695       gr_regs = LEA_REGS;
7696       if (TEST_HARD_REG_BIT (reg_class_contents[(int) class], 25))
7697         return gr_regs;
7698     }
7699
7700   /* Copying from HI or LO to anywhere other than a general register
7701      requires a general register.
7702      This rule applies to both the original HI/LO pair and the new
7703      DSP accumulators.  */
7704   if (reg_class_subset_p (class, ACC_REGS))
7705     {
7706       if (TARGET_MIPS16 && in_p)
7707         {
7708           /* We can't really copy to HI or LO at all in mips16 mode.  */
7709           return M16_REGS;
7710         }
7711       return gp_reg_p ? NO_REGS : gr_regs;
7712     }
7713   if (ACC_REG_P (regno))
7714     {
7715       if (TARGET_MIPS16 && ! in_p)
7716         {
7717           /* We can't really copy to HI or LO at all in mips16 mode.  */
7718           return M16_REGS;
7719         }
7720       return class == gr_regs ? NO_REGS : gr_regs;
7721     }
7722
7723   /* We can only copy a value to a condition code register from a
7724      floating point register, and even then we require a scratch
7725      floating point register.  We can only copy a value out of a
7726      condition code register into a general register.  */
7727   if (class == ST_REGS)
7728     {
7729       if (in_p)
7730         return FP_REGS;
7731       return gp_reg_p ? NO_REGS : gr_regs;
7732     }
7733   if (ST_REG_P (regno))
7734     {
7735       if (! in_p)
7736         return FP_REGS;
7737       return class == gr_regs ? NO_REGS : gr_regs;
7738     }
7739
7740   if (class == FP_REGS)
7741     {
7742       if (MEM_P (x))
7743         {
7744           /* In this case we can use lwc1, swc1, ldc1 or sdc1.  */
7745           return NO_REGS;
7746         }
7747       else if (CONSTANT_P (x) && GET_MODE_CLASS (mode) == MODE_FLOAT)
7748         {
7749           /* We can use the l.s and l.d macros to load floating-point
7750              constants.  ??? For l.s, we could probably get better
7751              code by returning GR_REGS here.  */
7752           return NO_REGS;
7753         }
7754       else if (gp_reg_p || x == CONST0_RTX (mode))
7755         {
7756           /* In this case we can use mtc1, mfc1, dmtc1 or dmfc1.  */
7757           return NO_REGS;
7758         }
7759       else if (FP_REG_P (regno))
7760         {
7761           /* In this case we can use mov.s or mov.d.  */
7762           return NO_REGS;
7763         }
7764       else
7765         {
7766           /* Otherwise, we need to reload through an integer register.  */
7767           return gr_regs;
7768         }
7769     }
7770
7771   /* In mips16 mode, going between memory and anything but M16_REGS
7772      requires an M16_REG.  */
7773   if (TARGET_MIPS16)
7774     {
7775       if (class != M16_REGS && class != M16_NA_REGS)
7776         {
7777           if (gp_reg_p)
7778             return NO_REGS;
7779           return M16_REGS;
7780         }
7781       if (! gp_reg_p)
7782         {
7783           if (class == M16_REGS || class == M16_NA_REGS)
7784             return NO_REGS;
7785           return M16_REGS;
7786         }
7787     }
7788
7789   return NO_REGS;
7790 }
7791
7792 /* Implement CLASS_MAX_NREGS.
7793
7794    - UNITS_PER_FPREG controls the number of registers needed by FP_REGS.
7795
7796    - ST_REGS are always hold CCmode values, and CCmode values are
7797      considered to be 4 bytes wide.
7798
7799    All other register classes are covered by UNITS_PER_WORD.  Note that
7800    this is true even for unions of integer and float registers when the
7801    latter are smaller than the former.  The only supported combination
7802    in which case this occurs is -mgp64 -msingle-float, which has 64-bit
7803    words but 32-bit float registers.  A word-based calculation is correct
7804    in that case since -msingle-float disallows multi-FPR values.  */
7805
7806 int
7807 mips_class_max_nregs (enum reg_class class ATTRIBUTE_UNUSED,
7808                       enum machine_mode mode)
7809 {
7810   if (class == ST_REGS)
7811     return (GET_MODE_SIZE (mode) + 3) / 4;
7812   else if (class == FP_REGS)
7813     return (GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG;
7814   else
7815     return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7816 }
7817
7818 static bool
7819 mips_valid_pointer_mode (enum machine_mode mode)
7820 {
7821   return (mode == SImode || (TARGET_64BIT && mode == DImode));
7822 }
7823
7824 /* Target hook for vector_mode_supported_p.  */
7825
7826 static bool
7827 mips_vector_mode_supported_p (enum machine_mode mode)
7828 {
7829   switch (mode)
7830     {
7831     case V2SFmode:
7832       return TARGET_PAIRED_SINGLE_FLOAT;
7833
7834     case V2HImode:
7835     case V4QImode:
7836       return TARGET_DSP;
7837
7838     default:
7839       return false;
7840     }
7841 }
7842 \f
7843 /* If we can access small data directly (using gp-relative relocation
7844    operators) return the small data pointer, otherwise return null.
7845
7846    For each mips16 function which refers to GP relative symbols, we
7847    use a pseudo register, initialized at the start of the function, to
7848    hold the $gp value.  */
7849
7850 static rtx
7851 mips16_gp_pseudo_reg (void)
7852 {
7853   if (cfun->machine->mips16_gp_pseudo_rtx == NULL_RTX)
7854     {
7855       rtx unspec;
7856       rtx insn, scan;
7857
7858       cfun->machine->mips16_gp_pseudo_rtx = gen_reg_rtx (Pmode);
7859
7860       /* We want to initialize this to a value which gcc will believe
7861          is constant.  */
7862       start_sequence ();
7863       unspec = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx), UNSPEC_GP);
7864       emit_move_insn (cfun->machine->mips16_gp_pseudo_rtx,
7865                       gen_rtx_CONST (Pmode, unspec));
7866       insn = get_insns ();
7867       end_sequence ();
7868
7869       push_topmost_sequence ();
7870       /* We need to emit the initialization after the FUNCTION_BEG
7871          note, so that it will be integrated.  */
7872       for (scan = get_insns (); scan != NULL_RTX; scan = NEXT_INSN (scan))
7873         if (NOTE_P (scan)
7874             && NOTE_LINE_NUMBER (scan) == NOTE_INSN_FUNCTION_BEG)
7875           break;
7876       if (scan == NULL_RTX)
7877         scan = get_insns ();
7878       insn = emit_insn_after (insn, scan);
7879       pop_topmost_sequence ();
7880     }
7881
7882   return cfun->machine->mips16_gp_pseudo_rtx;
7883 }
7884
7885 /* Write out code to move floating point arguments in or out of
7886    general registers.  Output the instructions to FILE.  FP_CODE is
7887    the code describing which arguments are present (see the comment at
7888    the definition of CUMULATIVE_ARGS in mips.h).  FROM_FP_P is nonzero if
7889    we are copying from the floating point registers.  */
7890
7891 static void
7892 mips16_fp_args (FILE *file, int fp_code, int from_fp_p)
7893 {
7894   const char *s;
7895   int gparg, fparg;
7896   unsigned int f;
7897
7898   /* This code only works for the original 32 bit ABI and the O64 ABI.  */
7899   gcc_assert (TARGET_OLDABI);
7900
7901   if (from_fp_p)
7902     s = "mfc1";
7903   else
7904     s = "mtc1";
7905   gparg = GP_ARG_FIRST;
7906   fparg = FP_ARG_FIRST;
7907   for (f = (unsigned int) fp_code; f != 0; f >>= 2)
7908     {
7909       if ((f & 3) == 1)
7910         {
7911           if ((fparg & 1) != 0)
7912             ++fparg;
7913           fprintf (file, "\t%s\t%s,%s\n", s,
7914                    reg_names[gparg], reg_names[fparg]);
7915         }
7916       else if ((f & 3) == 2)
7917         {
7918           if (TARGET_64BIT)
7919             fprintf (file, "\td%s\t%s,%s\n", s,
7920                      reg_names[gparg], reg_names[fparg]);
7921           else
7922             {
7923               if ((fparg & 1) != 0)
7924                 ++fparg;
7925               if (TARGET_BIG_ENDIAN)
7926                 fprintf (file, "\t%s\t%s,%s\n\t%s\t%s,%s\n", s,
7927                          reg_names[gparg], reg_names[fparg + 1], s,
7928                          reg_names[gparg + 1], reg_names[fparg]);
7929               else
7930                 fprintf (file, "\t%s\t%s,%s\n\t%s\t%s,%s\n", s,
7931                          reg_names[gparg], reg_names[fparg], s,
7932                          reg_names[gparg + 1], reg_names[fparg + 1]);
7933               ++gparg;
7934               ++fparg;
7935             }
7936         }
7937       else
7938         gcc_unreachable ();
7939
7940       ++gparg;
7941       ++fparg;
7942     }
7943 }
7944
7945 /* Build a mips16 function stub.  This is used for functions which
7946    take arguments in the floating point registers.  It is 32 bit code
7947    that moves the floating point args into the general registers, and
7948    then jumps to the 16 bit code.  */
7949
7950 static void
7951 build_mips16_function_stub (FILE *file)
7952 {
7953   const char *fnname;
7954   char *secname, *stubname;
7955   tree stubid, stubdecl;
7956   int need_comma;
7957   unsigned int f;
7958
7959   fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
7960   secname = (char *) alloca (strlen (fnname) + 20);
7961   sprintf (secname, ".mips16.fn.%s", fnname);
7962   stubname = (char *) alloca (strlen (fnname) + 20);
7963   sprintf (stubname, "__fn_stub_%s", fnname);
7964   stubid = get_identifier (stubname);
7965   stubdecl = build_decl (FUNCTION_DECL, stubid,
7966                          build_function_type (void_type_node, NULL_TREE));
7967   DECL_SECTION_NAME (stubdecl) = build_string (strlen (secname), secname);
7968
7969   fprintf (file, "\t# Stub function for %s (", current_function_name ());
7970   need_comma = 0;
7971   for (f = (unsigned int) current_function_args_info.fp_code; f != 0; f >>= 2)
7972     {
7973       fprintf (file, "%s%s",
7974                need_comma ? ", " : "",
7975                (f & 3) == 1 ? "float" : "double");
7976       need_comma = 1;
7977     }
7978   fprintf (file, ")\n");
7979
7980   fprintf (file, "\t.set\tnomips16\n");
7981   switch_to_section (function_section (stubdecl));
7982   ASM_OUTPUT_ALIGN (file, floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT));
7983
7984   /* ??? If FUNCTION_NAME_ALREADY_DECLARED is defined, then we are
7985      within a .ent, and we cannot emit another .ent.  */
7986   if (!FUNCTION_NAME_ALREADY_DECLARED)
7987     {
7988       fputs ("\t.ent\t", file);
7989       assemble_name (file, stubname);
7990       fputs ("\n", file);
7991     }
7992
7993   assemble_name (file, stubname);
7994   fputs (":\n", file);
7995
7996   /* We don't want the assembler to insert any nops here.  */
7997   fprintf (file, "\t.set\tnoreorder\n");
7998
7999   mips16_fp_args (file, current_function_args_info.fp_code, 1);
8000
8001   fprintf (asm_out_file, "\t.set\tnoat\n");
8002   fprintf (asm_out_file, "\tla\t%s,", reg_names[GP_REG_FIRST + 1]);
8003   assemble_name (file, fnname);
8004   fprintf (file, "\n");
8005   fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]);
8006   fprintf (asm_out_file, "\t.set\tat\n");
8007
8008   /* Unfortunately, we can't fill the jump delay slot.  We can't fill
8009      with one of the mfc1 instructions, because the result is not
8010      available for one instruction, so if the very first instruction
8011      in the function refers to the register, it will see the wrong
8012      value.  */
8013   fprintf (file, "\tnop\n");
8014
8015   fprintf (file, "\t.set\treorder\n");
8016
8017   if (!FUNCTION_NAME_ALREADY_DECLARED)
8018     {
8019       fputs ("\t.end\t", file);
8020       assemble_name (file, stubname);
8021       fputs ("\n", file);
8022     }
8023
8024   fprintf (file, "\t.set\tmips16\n");
8025
8026   switch_to_section (function_section (current_function_decl));
8027 }
8028
8029 /* We keep a list of functions for which we have already built stubs
8030    in build_mips16_call_stub.  */
8031
8032 struct mips16_stub
8033 {
8034   struct mips16_stub *next;
8035   char *name;
8036   int fpret;
8037 };
8038
8039 static struct mips16_stub *mips16_stubs;
8040
8041 /* Build a call stub for a mips16 call.  A stub is needed if we are
8042    passing any floating point values which should go into the floating
8043    point registers.  If we are, and the call turns out to be to a 32
8044    bit function, the stub will be used to move the values into the
8045    floating point registers before calling the 32 bit function.  The
8046    linker will magically adjust the function call to either the 16 bit
8047    function or the 32 bit stub, depending upon where the function call
8048    is actually defined.
8049
8050    Similarly, we need a stub if the return value might come back in a
8051    floating point register.
8052
8053    RETVAL is the location of the return value, or null if this is
8054    a call rather than a call_value.  FN is the address of the
8055    function and ARG_SIZE is the size of the arguments.  FP_CODE
8056    is the code built by function_arg.  This function returns a nonzero
8057    value if it builds the call instruction itself.  */
8058
8059 int
8060 build_mips16_call_stub (rtx retval, rtx fn, rtx arg_size, int fp_code)
8061 {
8062   int fpret;
8063   const char *fnname;
8064   char *secname, *stubname;
8065   struct mips16_stub *l;
8066   tree stubid, stubdecl;
8067   int need_comma;
8068   unsigned int f;
8069
8070   /* We don't need to do anything if we aren't in mips16 mode, or if
8071      we were invoked with the -msoft-float option.  */
8072   if (! TARGET_MIPS16 || ! mips16_hard_float)
8073     return 0;
8074
8075   /* Figure out whether the value might come back in a floating point
8076      register.  */
8077   fpret = (retval != 0
8078            && GET_MODE_CLASS (GET_MODE (retval)) == MODE_FLOAT
8079            && GET_MODE_SIZE (GET_MODE (retval)) <= UNITS_PER_FPVALUE);
8080
8081   /* We don't need to do anything if there were no floating point
8082      arguments and the value will not be returned in a floating point
8083      register.  */
8084   if (fp_code == 0 && ! fpret)
8085     return 0;
8086
8087   /* We don't need to do anything if this is a call to a special
8088      mips16 support function.  */
8089   if (GET_CODE (fn) == SYMBOL_REF
8090       && strncmp (XSTR (fn, 0), "__mips16_", 9) == 0)
8091     return 0;
8092
8093   /* This code will only work for o32 and o64 abis.  The other ABI's
8094      require more sophisticated support.  */
8095   gcc_assert (TARGET_OLDABI);
8096
8097   /* We can only handle SFmode and DFmode floating point return
8098      values.  */
8099   if (fpret)
8100     gcc_assert (GET_MODE (retval) == SFmode || GET_MODE (retval) == DFmode);
8101
8102   /* If we're calling via a function pointer, then we must always call
8103      via a stub.  There are magic stubs provided in libgcc.a for each
8104      of the required cases.  Each of them expects the function address
8105      to arrive in register $2.  */
8106
8107   if (GET_CODE (fn) != SYMBOL_REF)
8108     {
8109       char buf[30];
8110       tree id;
8111       rtx stub_fn, insn;
8112
8113       /* ??? If this code is modified to support other ABI's, we need
8114          to handle PARALLEL return values here.  */
8115
8116       sprintf (buf, "__mips16_call_stub_%s%d",
8117                (fpret
8118                 ? (GET_MODE (retval) == SFmode ? "sf_" : "df_")
8119                 : ""),
8120                fp_code);
8121       id = get_identifier (buf);
8122       stub_fn = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (id));
8123
8124       emit_move_insn (gen_rtx_REG (Pmode, 2), fn);
8125
8126       if (retval == NULL_RTX)
8127         insn = gen_call_internal (stub_fn, arg_size);
8128       else
8129         insn = gen_call_value_internal (retval, stub_fn, arg_size);
8130       insn = emit_call_insn (insn);
8131
8132       /* Put the register usage information on the CALL.  */
8133       CALL_INSN_FUNCTION_USAGE (insn) =
8134         gen_rtx_EXPR_LIST (VOIDmode,
8135                            gen_rtx_USE (VOIDmode, gen_rtx_REG (Pmode, 2)),
8136                            CALL_INSN_FUNCTION_USAGE (insn));
8137
8138       /* If we are handling a floating point return value, we need to
8139          save $18 in the function prologue.  Putting a note on the
8140          call will mean that regs_ever_live[$18] will be true if the
8141          call is not eliminated, and we can check that in the prologue
8142          code.  */
8143       if (fpret)
8144         CALL_INSN_FUNCTION_USAGE (insn) =
8145           gen_rtx_EXPR_LIST (VOIDmode,
8146                              gen_rtx_USE (VOIDmode,
8147                                           gen_rtx_REG (word_mode, 18)),
8148                              CALL_INSN_FUNCTION_USAGE (insn));
8149
8150       /* Return 1 to tell the caller that we've generated the call
8151          insn.  */
8152       return 1;
8153     }
8154
8155   /* We know the function we are going to call.  If we have already
8156      built a stub, we don't need to do anything further.  */
8157
8158   fnname = XSTR (fn, 0);
8159   for (l = mips16_stubs; l != NULL; l = l->next)
8160     if (strcmp (l->name, fnname) == 0)
8161       break;
8162
8163   if (l == NULL)
8164     {
8165       /* Build a special purpose stub.  When the linker sees a
8166          function call in mips16 code, it will check where the target
8167          is defined.  If the target is a 32 bit call, the linker will
8168          search for the section defined here.  It can tell which
8169          symbol this section is associated with by looking at the
8170          relocation information (the name is unreliable, since this
8171          might be a static function).  If such a section is found, the
8172          linker will redirect the call to the start of the magic
8173          section.
8174
8175          If the function does not return a floating point value, the
8176          special stub section is named
8177              .mips16.call.FNNAME
8178
8179          If the function does return a floating point value, the stub
8180          section is named
8181              .mips16.call.fp.FNNAME
8182          */
8183
8184       secname = (char *) alloca (strlen (fnname) + 40);
8185       sprintf (secname, ".mips16.call.%s%s",
8186                fpret ? "fp." : "",
8187                fnname);
8188       stubname = (char *) alloca (strlen (fnname) + 20);
8189       sprintf (stubname, "__call_stub_%s%s",
8190                fpret ? "fp_" : "",
8191                fnname);
8192       stubid = get_identifier (stubname);
8193       stubdecl = build_decl (FUNCTION_DECL, stubid,
8194                              build_function_type (void_type_node, NULL_TREE));
8195       DECL_SECTION_NAME (stubdecl) = build_string (strlen (secname), secname);
8196
8197       fprintf (asm_out_file, "\t# Stub function to call %s%s (",
8198                (fpret
8199                 ? (GET_MODE (retval) == SFmode ? "float " : "double ")
8200                 : ""),
8201                fnname);
8202       need_comma = 0;
8203       for (f = (unsigned int) fp_code; f != 0; f >>= 2)
8204         {
8205           fprintf (asm_out_file, "%s%s",
8206                    need_comma ? ", " : "",
8207                    (f & 3) == 1 ? "float" : "double");
8208           need_comma = 1;
8209         }
8210       fprintf (asm_out_file, ")\n");
8211
8212       fprintf (asm_out_file, "\t.set\tnomips16\n");
8213       assemble_start_function (stubdecl, stubname);
8214
8215       if (!FUNCTION_NAME_ALREADY_DECLARED)
8216         {
8217           fputs ("\t.ent\t", asm_out_file);
8218           assemble_name (asm_out_file, stubname);
8219           fputs ("\n", asm_out_file);
8220
8221           assemble_name (asm_out_file, stubname);
8222           fputs (":\n", asm_out_file);
8223         }
8224
8225       /* We build the stub code by hand.  That's the only way we can
8226          do it, since we can't generate 32 bit code during a 16 bit
8227          compilation.  */
8228
8229       /* We don't want the assembler to insert any nops here.  */
8230       fprintf (asm_out_file, "\t.set\tnoreorder\n");
8231
8232       mips16_fp_args (asm_out_file, fp_code, 0);
8233
8234       if (! fpret)
8235         {
8236           fprintf (asm_out_file, "\t.set\tnoat\n");
8237           fprintf (asm_out_file, "\tla\t%s,%s\n", reg_names[GP_REG_FIRST + 1],
8238                    fnname);
8239           fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]);
8240           fprintf (asm_out_file, "\t.set\tat\n");
8241           /* Unfortunately, we can't fill the jump delay slot.  We
8242              can't fill with one of the mtc1 instructions, because the
8243              result is not available for one instruction, so if the
8244              very first instruction in the function refers to the
8245              register, it will see the wrong value.  */
8246           fprintf (asm_out_file, "\tnop\n");
8247         }
8248       else
8249         {
8250           fprintf (asm_out_file, "\tmove\t%s,%s\n",
8251                    reg_names[GP_REG_FIRST + 18], reg_names[GP_REG_FIRST + 31]);
8252           fprintf (asm_out_file, "\tjal\t%s\n", fnname);
8253           /* As above, we can't fill the delay slot.  */
8254           fprintf (asm_out_file, "\tnop\n");
8255           if (GET_MODE (retval) == SFmode)
8256             fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8257                      reg_names[GP_REG_FIRST + 2], reg_names[FP_REG_FIRST + 0]);
8258           else
8259             {
8260               if (TARGET_BIG_ENDIAN)
8261                 {
8262                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8263                            reg_names[GP_REG_FIRST + 2],
8264                            reg_names[FP_REG_FIRST + 1]);
8265                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8266                            reg_names[GP_REG_FIRST + 3],
8267                            reg_names[FP_REG_FIRST + 0]);
8268                 }
8269               else
8270                 {
8271                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8272                            reg_names[GP_REG_FIRST + 2],
8273                            reg_names[FP_REG_FIRST + 0]);
8274                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8275                            reg_names[GP_REG_FIRST + 3],
8276                            reg_names[FP_REG_FIRST + 1]);
8277                 }
8278             }
8279           fprintf (asm_out_file, "\tj\t%s\n", reg_names[GP_REG_FIRST + 18]);
8280           /* As above, we can't fill the delay slot.  */
8281           fprintf (asm_out_file, "\tnop\n");
8282         }
8283
8284       fprintf (asm_out_file, "\t.set\treorder\n");
8285
8286 #ifdef ASM_DECLARE_FUNCTION_SIZE
8287       ASM_DECLARE_FUNCTION_SIZE (asm_out_file, stubname, stubdecl);
8288 #endif
8289
8290       if (!FUNCTION_NAME_ALREADY_DECLARED)
8291         {
8292           fputs ("\t.end\t", asm_out_file);
8293           assemble_name (asm_out_file, stubname);
8294           fputs ("\n", asm_out_file);
8295         }
8296
8297       fprintf (asm_out_file, "\t.set\tmips16\n");
8298
8299       /* Record this stub.  */
8300       l = (struct mips16_stub *) xmalloc (sizeof *l);
8301       l->name = xstrdup (fnname);
8302       l->fpret = fpret;
8303       l->next = mips16_stubs;
8304       mips16_stubs = l;
8305     }
8306
8307   /* If we expect a floating point return value, but we've built a
8308      stub which does not expect one, then we're in trouble.  We can't
8309      use the existing stub, because it won't handle the floating point
8310      value.  We can't build a new stub, because the linker won't know
8311      which stub to use for the various calls in this object file.
8312      Fortunately, this case is illegal, since it means that a function
8313      was declared in two different ways in a single compilation.  */
8314   if (fpret && ! l->fpret)
8315     error ("cannot handle inconsistent calls to %qs", fnname);
8316
8317   /* If we are calling a stub which handles a floating point return
8318      value, we need to arrange to save $18 in the prologue.  We do
8319      this by marking the function call as using the register.  The
8320      prologue will later see that it is used, and emit code to save
8321      it.  */
8322
8323   if (l->fpret)
8324     {
8325       rtx insn;
8326
8327       if (retval == NULL_RTX)
8328         insn = gen_call_internal (fn, arg_size);
8329       else
8330         insn = gen_call_value_internal (retval, fn, arg_size);
8331       insn = emit_call_insn (insn);
8332
8333       CALL_INSN_FUNCTION_USAGE (insn) =
8334         gen_rtx_EXPR_LIST (VOIDmode,
8335                            gen_rtx_USE (VOIDmode, gen_rtx_REG (word_mode, 18)),
8336                            CALL_INSN_FUNCTION_USAGE (insn));
8337
8338       /* Return 1 to tell the caller that we've generated the call
8339          insn.  */
8340       return 1;
8341     }
8342
8343   /* Return 0 to let the caller generate the call insn.  */
8344   return 0;
8345 }
8346
8347 /* An entry in the mips16 constant pool.  VALUE is the pool constant,
8348    MODE is its mode, and LABEL is the CODE_LABEL associated with it.  */
8349
8350 struct mips16_constant {
8351   struct mips16_constant *next;
8352   rtx value;
8353   rtx label;
8354   enum machine_mode mode;
8355 };
8356
8357 /* Information about an incomplete mips16 constant pool.  FIRST is the
8358    first constant, HIGHEST_ADDRESS is the highest address that the first
8359    byte of the pool can have, and INSN_ADDRESS is the current instruction
8360    address.  */
8361
8362 struct mips16_constant_pool {
8363   struct mips16_constant *first;
8364   int highest_address;
8365   int insn_address;
8366 };
8367
8368 /* Add constant VALUE to POOL and return its label.  MODE is the
8369    value's mode (used for CONST_INTs, etc.).  */
8370
8371 static rtx
8372 add_constant (struct mips16_constant_pool *pool,
8373               rtx value, enum machine_mode mode)
8374 {
8375   struct mips16_constant **p, *c;
8376   bool first_of_size_p;
8377
8378   /* See whether the constant is already in the pool.  If so, return the
8379      existing label, otherwise leave P pointing to the place where the
8380      constant should be added.
8381
8382      Keep the pool sorted in increasing order of mode size so that we can
8383      reduce the number of alignments needed.  */
8384   first_of_size_p = true;
8385   for (p = &pool->first; *p != 0; p = &(*p)->next)
8386     {
8387       if (mode == (*p)->mode && rtx_equal_p (value, (*p)->value))
8388         return (*p)->label;
8389       if (GET_MODE_SIZE (mode) < GET_MODE_SIZE ((*p)->mode))
8390         break;
8391       if (GET_MODE_SIZE (mode) == GET_MODE_SIZE ((*p)->mode))
8392         first_of_size_p = false;
8393     }
8394
8395   /* In the worst case, the constant needed by the earliest instruction
8396      will end up at the end of the pool.  The entire pool must then be
8397      accessible from that instruction.
8398
8399      When adding the first constant, set the pool's highest address to
8400      the address of the first out-of-range byte.  Adjust this address
8401      downwards each time a new constant is added.  */
8402   if (pool->first == 0)
8403     /* For pc-relative lw, addiu and daddiu instructions, the base PC value
8404        is the address of the instruction with the lowest two bits clear.
8405        The base PC value for ld has the lowest three bits clear.  Assume
8406        the worst case here.  */
8407     pool->highest_address = pool->insn_address - (UNITS_PER_WORD - 2) + 0x8000;
8408   pool->highest_address -= GET_MODE_SIZE (mode);
8409   if (first_of_size_p)
8410     /* Take into account the worst possible padding due to alignment.  */
8411     pool->highest_address -= GET_MODE_SIZE (mode) - 1;
8412
8413   /* Create a new entry.  */
8414   c = (struct mips16_constant *) xmalloc (sizeof *c);
8415   c->value = value;
8416   c->mode = mode;
8417   c->label = gen_label_rtx ();
8418   c->next = *p;
8419   *p = c;
8420
8421   return c->label;
8422 }
8423
8424 /* Output constant VALUE after instruction INSN and return the last
8425    instruction emitted.  MODE is the mode of the constant.  */
8426
8427 static rtx
8428 dump_constants_1 (enum machine_mode mode, rtx value, rtx insn)
8429 {
8430   switch (GET_MODE_CLASS (mode))
8431     {
8432     case MODE_INT:
8433       {
8434         rtx size = GEN_INT (GET_MODE_SIZE (mode));
8435         return emit_insn_after (gen_consttable_int (value, size), insn);
8436       }
8437
8438     case MODE_FLOAT:
8439       return emit_insn_after (gen_consttable_float (value), insn);
8440
8441     case MODE_VECTOR_FLOAT:
8442     case MODE_VECTOR_INT:
8443       {
8444         int i;
8445         for (i = 0; i < CONST_VECTOR_NUNITS (value); i++)
8446           insn = dump_constants_1 (GET_MODE_INNER (mode),
8447                                    CONST_VECTOR_ELT (value, i), insn);
8448         return insn;
8449       }
8450
8451     default:
8452       gcc_unreachable ();
8453     }
8454 }
8455
8456
8457 /* Dump out the constants in CONSTANTS after INSN.  */
8458
8459 static void
8460 dump_constants (struct mips16_constant *constants, rtx insn)
8461 {
8462   struct mips16_constant *c, *next;
8463   int align;
8464
8465   align = 0;
8466   for (c = constants; c != NULL; c = next)
8467     {
8468       /* If necessary, increase the alignment of PC.  */
8469       if (align < GET_MODE_SIZE (c->mode))
8470         {
8471           int align_log = floor_log2 (GET_MODE_SIZE (c->mode));
8472           insn = emit_insn_after (gen_align (GEN_INT (align_log)), insn);
8473         }
8474       align = GET_MODE_SIZE (c->mode);
8475
8476       insn = emit_label_after (c->label, insn);
8477       insn = dump_constants_1 (c->mode, c->value, insn);
8478
8479       next = c->next;
8480       free (c);
8481     }
8482
8483   emit_barrier_after (insn);
8484 }
8485
8486 /* Return the length of instruction INSN.  */
8487
8488 static int
8489 mips16_insn_length (rtx insn)
8490 {
8491   if (JUMP_P (insn))
8492     {
8493       rtx body = PATTERN (insn);
8494       if (GET_CODE (body) == ADDR_VEC)
8495         return GET_MODE_SIZE (GET_MODE (body)) * XVECLEN (body, 0);
8496       if (GET_CODE (body) == ADDR_DIFF_VEC)
8497         return GET_MODE_SIZE (GET_MODE (body)) * XVECLEN (body, 1);
8498     }
8499   return get_attr_length (insn);
8500 }
8501
8502 /* Rewrite *X so that constant pool references refer to the constant's
8503    label instead.  DATA points to the constant pool structure.  */
8504
8505 static int
8506 mips16_rewrite_pool_refs (rtx *x, void *data)
8507 {
8508   struct mips16_constant_pool *pool = data;
8509   if (GET_CODE (*x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (*x))
8510     *x = gen_rtx_LABEL_REF (Pmode, add_constant (pool,
8511                                                  get_pool_constant (*x),
8512                                                  get_pool_mode (*x)));
8513   return 0;
8514 }
8515
8516 /* Build MIPS16 constant pools.  */
8517
8518 static void
8519 mips16_lay_out_constants (void)
8520 {
8521   struct mips16_constant_pool pool;
8522   rtx insn, barrier;
8523
8524   barrier = 0;
8525   memset (&pool, 0, sizeof (pool));
8526   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
8527     {
8528       /* Rewrite constant pool references in INSN.  */
8529       if (INSN_P (insn))
8530         for_each_rtx (&PATTERN (insn), mips16_rewrite_pool_refs, &pool);
8531
8532       pool.insn_address += mips16_insn_length (insn);
8533
8534       if (pool.first != NULL)
8535         {
8536           /* If there are no natural barriers between the first user of
8537              the pool and the highest acceptable address, we'll need to
8538              create a new instruction to jump around the constant pool.
8539              In the worst case, this instruction will be 4 bytes long.
8540
8541              If it's too late to do this transformation after INSN,
8542              do it immediately before INSN.  */
8543           if (barrier == 0 && pool.insn_address + 4 > pool.highest_address)
8544             {
8545               rtx label, jump;
8546
8547               label = gen_label_rtx ();
8548
8549               jump = emit_jump_insn_before (gen_jump (label), insn);
8550               JUMP_LABEL (jump) = label;
8551               LABEL_NUSES (label) = 1;
8552               barrier = emit_barrier_after (jump);
8553
8554               emit_label_after (label, barrier);
8555               pool.insn_address += 4;
8556             }
8557
8558           /* See whether the constant pool is now out of range of the first
8559              user.  If so, output the constants after the previous barrier.
8560              Note that any instructions between BARRIER and INSN (inclusive)
8561              will use negative offsets to refer to the pool.  */
8562           if (pool.insn_address > pool.highest_address)
8563             {
8564               dump_constants (pool.first, barrier);
8565               pool.first = NULL;
8566               barrier = 0;
8567             }
8568           else if (BARRIER_P (insn))
8569             barrier = insn;
8570         }
8571     }
8572   dump_constants (pool.first, get_last_insn ());
8573 }
8574 \f
8575 /* A temporary variable used by for_each_rtx callbacks, etc.  */
8576 static rtx mips_sim_insn;
8577
8578 /* A structure representing the state of the processor pipeline.
8579    Used by the mips_sim_* family of functions.  */
8580 struct mips_sim {
8581   /* The maximum number of instructions that can be issued in a cycle.
8582      (Caches mips_issue_rate.)  */
8583   unsigned int issue_rate;
8584
8585   /* The current simulation time.  */
8586   unsigned int time;
8587
8588   /* How many more instructions can be issued in the current cycle.  */
8589   unsigned int insns_left;
8590
8591   /* LAST_SET[X].INSN is the last instruction to set register X.
8592      LAST_SET[X].TIME is the time at which that instruction was issued.
8593      INSN is null if no instruction has yet set register X.  */
8594   struct {
8595     rtx insn;
8596     unsigned int time;
8597   } last_set[FIRST_PSEUDO_REGISTER];
8598
8599   /* The pipeline's current DFA state.  */
8600   state_t dfa_state;
8601 };
8602
8603 /* Reset STATE to the initial simulation state.  */
8604
8605 static void
8606 mips_sim_reset (struct mips_sim *state)
8607 {
8608   state->time = 0;
8609   state->insns_left = state->issue_rate;
8610   memset (&state->last_set, 0, sizeof (state->last_set));
8611   state_reset (state->dfa_state);
8612 }
8613
8614 /* Initialize STATE before its first use.  DFA_STATE points to an
8615    allocated but uninitialized DFA state.  */
8616
8617 static void
8618 mips_sim_init (struct mips_sim *state, state_t dfa_state)
8619 {
8620   state->issue_rate = mips_issue_rate ();
8621   state->dfa_state = dfa_state;
8622   mips_sim_reset (state);
8623 }
8624
8625 /* Advance STATE by one clock cycle.  */
8626
8627 static void
8628 mips_sim_next_cycle (struct mips_sim *state)
8629 {
8630   state->time++;
8631   state->insns_left = state->issue_rate;
8632   state_transition (state->dfa_state, 0);
8633 }
8634
8635 /* Advance simulation state STATE until instruction INSN can read
8636    register REG.  */
8637
8638 static void
8639 mips_sim_wait_reg (struct mips_sim *state, rtx insn, rtx reg)
8640 {
8641   unsigned int i;
8642
8643   for (i = 0; i < HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)); i++)
8644     if (state->last_set[REGNO (reg) + i].insn != 0)
8645       {
8646         unsigned int t;
8647
8648         t = state->last_set[REGNO (reg) + i].time;
8649         t += insn_latency (state->last_set[REGNO (reg) + i].insn, insn);
8650         while (state->time < t)
8651           mips_sim_next_cycle (state);
8652     }
8653 }
8654
8655 /* A for_each_rtx callback.  If *X is a register, advance simulation state
8656    DATA until mips_sim_insn can read the register's value.  */
8657
8658 static int
8659 mips_sim_wait_regs_2 (rtx *x, void *data)
8660 {
8661   if (REG_P (*x))
8662     mips_sim_wait_reg (data, mips_sim_insn, *x);
8663   return 0;
8664 }
8665
8666 /* Call mips_sim_wait_regs_2 (R, DATA) for each register R mentioned in *X.  */
8667
8668 static void
8669 mips_sim_wait_regs_1 (rtx *x, void *data)
8670 {
8671   for_each_rtx (x, mips_sim_wait_regs_2, data);
8672 }
8673
8674 /* Advance simulation state STATE until all of INSN's register
8675    dependencies are satisfied.  */
8676
8677 static void
8678 mips_sim_wait_regs (struct mips_sim *state, rtx insn)
8679 {
8680   mips_sim_insn = insn;
8681   note_uses (&PATTERN (insn), mips_sim_wait_regs_1, state);
8682 }
8683
8684 /* Advance simulation state STATE until the units required by
8685    instruction INSN are available.  */
8686
8687 static void
8688 mips_sim_wait_units (struct mips_sim *state, rtx insn)
8689 {
8690   state_t tmp_state;
8691
8692   tmp_state = alloca (state_size ());
8693   while (state->insns_left == 0
8694          || (memcpy (tmp_state, state->dfa_state, state_size ()),
8695              state_transition (tmp_state, insn) >= 0))
8696     mips_sim_next_cycle (state);
8697 }
8698
8699 /* Advance simulation state STATE until INSN is ready to issue.  */
8700
8701 static void
8702 mips_sim_wait_insn (struct mips_sim *state, rtx insn)
8703 {
8704   mips_sim_wait_regs (state, insn);
8705   mips_sim_wait_units (state, insn);
8706 }
8707
8708 /* mips_sim_insn has just set X.  Update the LAST_SET array
8709    in simulation state DATA.  */
8710
8711 static void
8712 mips_sim_record_set (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
8713 {
8714   struct mips_sim *state;
8715   unsigned int i;
8716
8717   state = data;
8718   if (REG_P (x))
8719     for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
8720       {
8721         state->last_set[REGNO (x) + i].insn = mips_sim_insn;
8722         state->last_set[REGNO (x) + i].time = state->time;
8723       }
8724 }
8725
8726 /* Issue instruction INSN in scheduler state STATE.  Assume that INSN
8727    can issue immediately (i.e., that mips_sim_wait_insn has already
8728    been called).  */
8729
8730 static void
8731 mips_sim_issue_insn (struct mips_sim *state, rtx insn)
8732 {
8733   state_transition (state->dfa_state, insn);
8734   state->insns_left--;
8735
8736   mips_sim_insn = insn;
8737   note_stores (PATTERN (insn), mips_sim_record_set, state);
8738 }
8739
8740 /* Simulate issuing a NOP in state STATE.  */
8741
8742 static void
8743 mips_sim_issue_nop (struct mips_sim *state)
8744 {
8745   if (state->insns_left == 0)
8746     mips_sim_next_cycle (state);
8747   state->insns_left--;
8748 }
8749
8750 /* Update simulation state STATE so that it's ready to accept the instruction
8751    after INSN.  INSN should be part of the main rtl chain, not a member of a
8752    SEQUENCE.  */
8753
8754 static void
8755 mips_sim_finish_insn (struct mips_sim *state, rtx insn)
8756 {
8757   /* If INSN is a jump with an implicit delay slot, simulate a nop.  */
8758   if (JUMP_P (insn))
8759     mips_sim_issue_nop (state);
8760
8761   switch (GET_CODE (SEQ_BEGIN (insn)))
8762     {
8763     case CODE_LABEL:
8764     case CALL_INSN:
8765       /* We can't predict the processor state after a call or label.  */
8766       mips_sim_reset (state);
8767       break;
8768
8769     case JUMP_INSN:
8770       /* The delay slots of branch likely instructions are only executed
8771          when the branch is taken.  Therefore, if the caller has simulated
8772          the delay slot instruction, STATE does not really reflect the state
8773          of the pipeline for the instruction after the delay slot.  Also,
8774          branch likely instructions tend to incur a penalty when not taken,
8775          so there will probably be an extra delay between the branch and
8776          the instruction after the delay slot.  */
8777       if (INSN_ANNULLED_BRANCH_P (SEQ_BEGIN (insn)))
8778         mips_sim_reset (state);
8779       break;
8780
8781     default:
8782       break;
8783     }
8784 }
8785 \f
8786 /* The VR4130 pipeline issues aligned pairs of instructions together,
8787    but it stalls the second instruction if it depends on the first.
8788    In order to cut down the amount of logic required, this dependence
8789    check is not based on a full instruction decode.  Instead, any non-SPECIAL
8790    instruction is assumed to modify the register specified by bits 20-16
8791    (which is usually the "rt" field).
8792
8793    In beq, beql, bne and bnel instructions, the rt field is actually an
8794    input, so we can end up with a false dependence between the branch
8795    and its delay slot.  If this situation occurs in instruction INSN,
8796    try to avoid it by swapping rs and rt.  */
8797
8798 static void
8799 vr4130_avoid_branch_rt_conflict (rtx insn)
8800 {
8801   rtx first, second;
8802
8803   first = SEQ_BEGIN (insn);
8804   second = SEQ_END (insn);
8805   if (JUMP_P (first)
8806       && NONJUMP_INSN_P (second)
8807       && GET_CODE (PATTERN (first)) == SET
8808       && GET_CODE (SET_DEST (PATTERN (first))) == PC
8809       && GET_CODE (SET_SRC (PATTERN (first))) == IF_THEN_ELSE)
8810     {
8811       /* Check for the right kind of condition.  */
8812       rtx cond = XEXP (SET_SRC (PATTERN (first)), 0);
8813       if ((GET_CODE (cond) == EQ || GET_CODE (cond) == NE)
8814           && REG_P (XEXP (cond, 0))
8815           && REG_P (XEXP (cond, 1))
8816           && reg_referenced_p (XEXP (cond, 1), PATTERN (second))
8817           && !reg_referenced_p (XEXP (cond, 0), PATTERN (second)))
8818         {
8819           /* SECOND mentions the rt register but not the rs register.  */
8820           rtx tmp = XEXP (cond, 0);
8821           XEXP (cond, 0) = XEXP (cond, 1);
8822           XEXP (cond, 1) = tmp;
8823         }
8824     }
8825 }
8826
8827 /* Implement -mvr4130-align.  Go through each basic block and simulate the
8828    processor pipeline.  If we find that a pair of instructions could execute
8829    in parallel, and the first of those instruction is not 8-byte aligned,
8830    insert a nop to make it aligned.  */
8831
8832 static void
8833 vr4130_align_insns (void)
8834 {
8835   struct mips_sim state;
8836   rtx insn, subinsn, last, last2, next;
8837   bool aligned_p;
8838
8839   dfa_start ();
8840
8841   /* LAST is the last instruction before INSN to have a nonzero length.
8842      LAST2 is the last such instruction before LAST.  */
8843   last = 0;
8844   last2 = 0;
8845
8846   /* ALIGNED_P is true if INSN is known to be at an aligned address.  */
8847   aligned_p = true;
8848
8849   mips_sim_init (&state, alloca (state_size ()));
8850   for (insn = get_insns (); insn != 0; insn = next)
8851     {
8852       unsigned int length;
8853
8854       next = NEXT_INSN (insn);
8855
8856       /* See the comment above vr4130_avoid_branch_rt_conflict for details.
8857          This isn't really related to the alignment pass, but we do it on
8858          the fly to avoid a separate instruction walk.  */
8859       vr4130_avoid_branch_rt_conflict (insn);
8860
8861       if (USEFUL_INSN_P (insn))
8862         FOR_EACH_SUBINSN (subinsn, insn)
8863           {
8864             mips_sim_wait_insn (&state, subinsn);
8865
8866             /* If we want this instruction to issue in parallel with the
8867                previous one, make sure that the previous instruction is
8868                aligned.  There are several reasons why this isn't worthwhile
8869                when the second instruction is a call:
8870
8871                   - Calls are less likely to be performance critical,
8872                   - There's a good chance that the delay slot can execute
8873                     in parallel with the call.
8874                   - The return address would then be unaligned.
8875
8876                In general, if we're going to insert a nop between instructions
8877                X and Y, it's better to insert it immediately after X.  That
8878                way, if the nop makes Y aligned, it will also align any labels
8879                between X and Y.  */
8880             if (state.insns_left != state.issue_rate
8881                 && !CALL_P (subinsn))
8882               {
8883                 if (subinsn == SEQ_BEGIN (insn) && aligned_p)
8884                   {
8885                     /* SUBINSN is the first instruction in INSN and INSN is
8886                        aligned.  We want to align the previous instruction
8887                        instead, so insert a nop between LAST2 and LAST.
8888
8889                        Note that LAST could be either a single instruction
8890                        or a branch with a delay slot.  In the latter case,
8891                        LAST, like INSN, is already aligned, but the delay
8892                        slot must have some extra delay that stops it from
8893                        issuing at the same time as the branch.  We therefore
8894                        insert a nop before the branch in order to align its
8895                        delay slot.  */
8896                     emit_insn_after (gen_nop (), last2);
8897                     aligned_p = false;
8898                   }
8899                 else if (subinsn != SEQ_BEGIN (insn) && !aligned_p)
8900                   {
8901                     /* SUBINSN is the delay slot of INSN, but INSN is
8902                        currently unaligned.  Insert a nop between
8903                        LAST and INSN to align it.  */
8904                     emit_insn_after (gen_nop (), last);
8905                     aligned_p = true;
8906                   }
8907               }
8908             mips_sim_issue_insn (&state, subinsn);
8909           }
8910       mips_sim_finish_insn (&state, insn);
8911
8912       /* Update LAST, LAST2 and ALIGNED_P for the next instruction.  */
8913       length = get_attr_length (insn);
8914       if (length > 0)
8915         {
8916           /* If the instruction is an asm statement or multi-instruction
8917              mips.md patern, the length is only an estimate.  Insert an
8918              8 byte alignment after it so that the following instructions
8919              can be handled correctly.  */
8920           if (NONJUMP_INSN_P (SEQ_BEGIN (insn))
8921               && (recog_memoized (insn) < 0 || length >= 8))
8922             {
8923               next = emit_insn_after (gen_align (GEN_INT (3)), insn);
8924               next = NEXT_INSN (next);
8925               mips_sim_next_cycle (&state);
8926               aligned_p = true;
8927             }
8928           else if (length & 4)
8929             aligned_p = !aligned_p;
8930           last2 = last;
8931           last = insn;
8932         }
8933
8934       /* See whether INSN is an aligned label.  */
8935       if (LABEL_P (insn) && label_to_alignment (insn) >= 3)
8936         aligned_p = true;
8937     }
8938   dfa_finish ();
8939 }
8940 \f
8941 /* Subroutine of mips_reorg.  If there is a hazard between INSN
8942    and a previous instruction, avoid it by inserting nops after
8943    instruction AFTER.
8944
8945    *DELAYED_REG and *HILO_DELAY describe the hazards that apply at
8946    this point.  If *DELAYED_REG is non-null, INSN must wait a cycle
8947    before using the value of that register.  *HILO_DELAY counts the
8948    number of instructions since the last hilo hazard (that is,
8949    the number of instructions since the last mflo or mfhi).
8950
8951    After inserting nops for INSN, update *DELAYED_REG and *HILO_DELAY
8952    for the next instruction.
8953
8954    LO_REG is an rtx for the LO register, used in dependence checking.  */
8955
8956 static void
8957 mips_avoid_hazard (rtx after, rtx insn, int *hilo_delay,
8958                    rtx *delayed_reg, rtx lo_reg)
8959 {
8960   rtx pattern, set;
8961   int nops, ninsns;
8962
8963   if (!INSN_P (insn))
8964     return;
8965
8966   pattern = PATTERN (insn);
8967
8968   /* Do not put the whole function in .set noreorder if it contains
8969      an asm statement.  We don't know whether there will be hazards
8970      between the asm statement and the gcc-generated code.  */
8971   if (GET_CODE (pattern) == ASM_INPUT || asm_noperands (pattern) >= 0)
8972     cfun->machine->all_noreorder_p = false;
8973
8974   /* Ignore zero-length instructions (barriers and the like).  */
8975   ninsns = get_attr_length (insn) / 4;
8976   if (ninsns == 0)
8977     return;
8978
8979   /* Work out how many nops are needed.  Note that we only care about
8980      registers that are explicitly mentioned in the instruction's pattern.
8981      It doesn't matter that calls use the argument registers or that they
8982      clobber hi and lo.  */
8983   if (*hilo_delay < 2 && reg_set_p (lo_reg, pattern))
8984     nops = 2 - *hilo_delay;
8985   else if (*delayed_reg != 0 && reg_referenced_p (*delayed_reg, pattern))
8986     nops = 1;
8987   else
8988     nops = 0;
8989
8990   /* Insert the nops between this instruction and the previous one.
8991      Each new nop takes us further from the last hilo hazard.  */
8992   *hilo_delay += nops;
8993   while (nops-- > 0)
8994     emit_insn_after (gen_hazard_nop (), after);
8995
8996   /* Set up the state for the next instruction.  */
8997   *hilo_delay += ninsns;
8998   *delayed_reg = 0;
8999   if (INSN_CODE (insn) >= 0)
9000     switch (get_attr_hazard (insn))
9001       {
9002       case HAZARD_NONE:
9003         break;
9004
9005       case HAZARD_HILO:
9006         *hilo_delay = 0;
9007         break;
9008
9009       case HAZARD_DELAY:
9010         set = single_set (insn);
9011         gcc_assert (set != 0);
9012         *delayed_reg = SET_DEST (set);
9013         break;
9014       }
9015 }
9016
9017
9018 /* Go through the instruction stream and insert nops where necessary.
9019    See if the whole function can then be put into .set noreorder &
9020    .set nomacro.  */
9021
9022 static void
9023 mips_avoid_hazards (void)
9024 {
9025   rtx insn, last_insn, lo_reg, delayed_reg;
9026   int hilo_delay, i;
9027
9028   /* Force all instructions to be split into their final form.  */
9029   split_all_insns_noflow ();
9030
9031   /* Recalculate instruction lengths without taking nops into account.  */
9032   cfun->machine->ignore_hazard_length_p = true;
9033   shorten_branches (get_insns ());
9034
9035   cfun->machine->all_noreorder_p = true;
9036
9037   /* Profiled functions can't be all noreorder because the profiler
9038      support uses assembler macros.  */
9039   if (current_function_profile)
9040     cfun->machine->all_noreorder_p = false;
9041
9042   /* Code compiled with -mfix-vr4120 can't be all noreorder because
9043      we rely on the assembler to work around some errata.  */
9044   if (TARGET_FIX_VR4120)
9045     cfun->machine->all_noreorder_p = false;
9046
9047   /* The same is true for -mfix-vr4130 if we might generate mflo or
9048      mfhi instructions.  Note that we avoid using mflo and mfhi if
9049      the VR4130 macc and dmacc instructions are available instead;
9050      see the *mfhilo_{si,di}_macc patterns.  */
9051   if (TARGET_FIX_VR4130 && !ISA_HAS_MACCHI)
9052     cfun->machine->all_noreorder_p = false;
9053
9054   last_insn = 0;
9055   hilo_delay = 2;
9056   delayed_reg = 0;
9057   lo_reg = gen_rtx_REG (SImode, LO_REGNUM);
9058
9059   for (insn = get_insns (); insn != 0; insn = NEXT_INSN (insn))
9060     if (INSN_P (insn))
9061       {
9062         if (GET_CODE (PATTERN (insn)) == SEQUENCE)
9063           for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
9064             mips_avoid_hazard (last_insn, XVECEXP (PATTERN (insn), 0, i),
9065                                &hilo_delay, &delayed_reg, lo_reg);
9066         else
9067           mips_avoid_hazard (last_insn, insn, &hilo_delay,
9068                              &delayed_reg, lo_reg);
9069
9070         last_insn = insn;
9071       }
9072 }
9073
9074
9075 /* Implement TARGET_MACHINE_DEPENDENT_REORG.  */
9076
9077 static void
9078 mips_reorg (void)
9079 {
9080   if (TARGET_MIPS16)
9081     mips16_lay_out_constants ();
9082   else if (TARGET_EXPLICIT_RELOCS)
9083     {
9084       if (mips_flag_delayed_branch)
9085         dbr_schedule (get_insns ());
9086       mips_avoid_hazards ();
9087       if (TUNE_MIPS4130 && TARGET_VR4130_ALIGN)
9088         vr4130_align_insns ();
9089     }
9090 }
9091
9092 /* This function does three things:
9093
9094    - Register the special divsi3 and modsi3 functions if -mfix-vr4120.
9095    - Register the mips16 hardware floating point stubs.
9096    - Register the gofast functions if selected using --enable-gofast.  */
9097
9098 #include "config/gofast.h"
9099
9100 static void
9101 mips_init_libfuncs (void)
9102 {
9103   if (TARGET_FIX_VR4120)
9104     {
9105       set_optab_libfunc (sdiv_optab, SImode, "__vr4120_divsi3");
9106       set_optab_libfunc (smod_optab, SImode, "__vr4120_modsi3");
9107     }
9108
9109   if (TARGET_MIPS16 && mips16_hard_float)
9110     {
9111       set_optab_libfunc (add_optab, SFmode, "__mips16_addsf3");
9112       set_optab_libfunc (sub_optab, SFmode, "__mips16_subsf3");
9113       set_optab_libfunc (smul_optab, SFmode, "__mips16_mulsf3");
9114       set_optab_libfunc (sdiv_optab, SFmode, "__mips16_divsf3");
9115
9116       set_optab_libfunc (eq_optab, SFmode, "__mips16_eqsf2");
9117       set_optab_libfunc (ne_optab, SFmode, "__mips16_nesf2");
9118       set_optab_libfunc (gt_optab, SFmode, "__mips16_gtsf2");
9119       set_optab_libfunc (ge_optab, SFmode, "__mips16_gesf2");
9120       set_optab_libfunc (lt_optab, SFmode, "__mips16_ltsf2");
9121       set_optab_libfunc (le_optab, SFmode, "__mips16_lesf2");
9122
9123       set_conv_libfunc (sfix_optab, SImode, SFmode, "__mips16_fix_truncsfsi");
9124       set_conv_libfunc (sfloat_optab, SFmode, SImode, "__mips16_floatsisf");
9125
9126       if (TARGET_DOUBLE_FLOAT)
9127         {
9128           set_optab_libfunc (add_optab, DFmode, "__mips16_adddf3");
9129           set_optab_libfunc (sub_optab, DFmode, "__mips16_subdf3");
9130           set_optab_libfunc (smul_optab, DFmode, "__mips16_muldf3");
9131           set_optab_libfunc (sdiv_optab, DFmode, "__mips16_divdf3");
9132
9133           set_optab_libfunc (eq_optab, DFmode, "__mips16_eqdf2");
9134           set_optab_libfunc (ne_optab, DFmode, "__mips16_nedf2");
9135           set_optab_libfunc (gt_optab, DFmode, "__mips16_gtdf2");
9136           set_optab_libfunc (ge_optab, DFmode, "__mips16_gedf2");
9137           set_optab_libfunc (lt_optab, DFmode, "__mips16_ltdf2");
9138           set_optab_libfunc (le_optab, DFmode, "__mips16_ledf2");
9139
9140           set_conv_libfunc (sext_optab, DFmode, SFmode, "__mips16_extendsfdf2");
9141           set_conv_libfunc (trunc_optab, SFmode, DFmode, "__mips16_truncdfsf2");
9142
9143           set_conv_libfunc (sfix_optab, SImode, DFmode, "__mips16_fix_truncdfsi");
9144           set_conv_libfunc (sfloat_optab, DFmode, SImode, "__mips16_floatsidf");
9145         }
9146     }
9147   else
9148     gofast_maybe_init_libfuncs ();
9149 }
9150
9151 /* Return a number assessing the cost of moving a register in class
9152    FROM to class TO.  The classes are expressed using the enumeration
9153    values such as `GENERAL_REGS'.  A value of 2 is the default; other
9154    values are interpreted relative to that.
9155
9156    It is not required that the cost always equal 2 when FROM is the
9157    same as TO; on some machines it is expensive to move between
9158    registers if they are not general registers.
9159
9160    If reload sees an insn consisting of a single `set' between two
9161    hard registers, and if `REGISTER_MOVE_COST' applied to their
9162    classes returns a value of 2, reload does not check to ensure that
9163    the constraints of the insn are met.  Setting a cost of other than
9164    2 will allow reload to verify that the constraints are met.  You
9165    should do this if the `movM' pattern's constraints do not allow
9166    such copying.
9167
9168    ??? We make the cost of moving from HI/LO into general
9169    registers the same as for one of moving general registers to
9170    HI/LO for TARGET_MIPS16 in order to prevent allocating a
9171    pseudo to HI/LO.  This might hurt optimizations though, it
9172    isn't clear if it is wise.  And it might not work in all cases.  We
9173    could solve the DImode LO reg problem by using a multiply, just
9174    like reload_{in,out}si.  We could solve the SImode/HImode HI reg
9175    problem by using divide instructions.  divu puts the remainder in
9176    the HI reg, so doing a divide by -1 will move the value in the HI
9177    reg for all values except -1.  We could handle that case by using a
9178    signed divide, e.g.  -1 / 2 (or maybe 1 / -2?).  We'd have to emit
9179    a compare/branch to test the input value to see which instruction
9180    we need to use.  This gets pretty messy, but it is feasible.  */
9181
9182 int
9183 mips_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
9184                          enum reg_class to, enum reg_class from)
9185 {
9186   if (from == M16_REGS && GR_REG_CLASS_P (to))
9187     return 2;
9188   else if (from == M16_NA_REGS && GR_REG_CLASS_P (to))
9189     return 2;
9190   else if (GR_REG_CLASS_P (from))
9191     {
9192       if (to == M16_REGS)
9193         return 2;
9194       else if (to == M16_NA_REGS)
9195         return 2;
9196       else if (GR_REG_CLASS_P (to))
9197         {
9198           if (TARGET_MIPS16)
9199             return 4;
9200           else
9201             return 2;
9202         }
9203       else if (to == FP_REGS)
9204         return 4;
9205       else if (reg_class_subset_p (to, ACC_REGS))
9206         {
9207           if (TARGET_MIPS16)
9208             return 12;
9209           else
9210             return 6;
9211         }
9212       else if (COP_REG_CLASS_P (to))
9213         {
9214           return 5;
9215         }
9216     }
9217   else if (from == FP_REGS)
9218     {
9219       if (GR_REG_CLASS_P (to))
9220         return 4;
9221       else if (to == FP_REGS)
9222         return 2;
9223       else if (to == ST_REGS)
9224         return 8;
9225     }
9226   else if (reg_class_subset_p (from, ACC_REGS))
9227     {
9228       if (GR_REG_CLASS_P (to))
9229         {
9230           if (TARGET_MIPS16)
9231             return 12;
9232           else
9233             return 6;
9234         }
9235     }
9236   else if (from == ST_REGS && GR_REG_CLASS_P (to))
9237     return 4;
9238   else if (COP_REG_CLASS_P (from))
9239     {
9240       return 5;
9241     }
9242
9243   /* Fall through.
9244      ??? What cases are these? Shouldn't we return 2 here?  */
9245
9246   return 12;
9247 }
9248
9249 /* Return the length of INSN.  LENGTH is the initial length computed by
9250    attributes in the machine-description file.  */
9251
9252 int
9253 mips_adjust_insn_length (rtx insn, int length)
9254 {
9255   /* A unconditional jump has an unfilled delay slot if it is not part
9256      of a sequence.  A conditional jump normally has a delay slot, but
9257      does not on MIPS16.  */
9258   if (CALL_P (insn) || (TARGET_MIPS16 ? simplejump_p (insn) : JUMP_P (insn)))
9259     length += 4;
9260
9261   /* See how many nops might be needed to avoid hardware hazards.  */
9262   if (!cfun->machine->ignore_hazard_length_p && INSN_CODE (insn) >= 0)
9263     switch (get_attr_hazard (insn))
9264       {
9265       case HAZARD_NONE:
9266         break;
9267
9268       case HAZARD_DELAY:
9269         length += 4;
9270         break;
9271
9272       case HAZARD_HILO:
9273         length += 8;
9274         break;
9275       }
9276
9277   /* All MIPS16 instructions are a measly two bytes.  */
9278   if (TARGET_MIPS16)
9279     length /= 2;
9280
9281   return length;
9282 }
9283
9284
9285 /* Return an asm sequence to start a noat block and load the address
9286    of a label into $1.  */
9287
9288 const char *
9289 mips_output_load_label (void)
9290 {
9291   if (TARGET_EXPLICIT_RELOCS)
9292     switch (mips_abi)
9293       {
9294       case ABI_N32:
9295         return "%[lw\t%@,%%got_page(%0)(%+)\n\taddiu\t%@,%@,%%got_ofst(%0)";
9296
9297       case ABI_64:
9298         return "%[ld\t%@,%%got_page(%0)(%+)\n\tdaddiu\t%@,%@,%%got_ofst(%0)";
9299
9300       default:
9301         if (ISA_HAS_LOAD_DELAY)
9302           return "%[lw\t%@,%%got(%0)(%+)%#\n\taddiu\t%@,%@,%%lo(%0)";
9303         return "%[lw\t%@,%%got(%0)(%+)\n\taddiu\t%@,%@,%%lo(%0)";
9304       }
9305   else
9306     {
9307       if (Pmode == DImode)
9308         return "%[dla\t%@,%0";
9309       else
9310         return "%[la\t%@,%0";
9311     }
9312 }
9313
9314 /* Return the assembly code for INSN, which has the operands given by
9315    OPERANDS, and which branches to OPERANDS[1] if some condition is true.
9316    BRANCH_IF_TRUE is the asm template that should be used if OPERANDS[1]
9317    is in range of a direct branch.  BRANCH_IF_FALSE is an inverted
9318    version of BRANCH_IF_TRUE.  */
9319
9320 const char *
9321 mips_output_conditional_branch (rtx insn, rtx *operands,
9322                                 const char *branch_if_true,
9323                                 const char *branch_if_false)
9324 {
9325   unsigned int length;
9326   rtx taken, not_taken;
9327
9328   length = get_attr_length (insn);
9329   if (length <= 8)
9330     {
9331       /* Just a simple conditional branch.  */
9332       mips_branch_likely = (final_sequence && INSN_ANNULLED_BRANCH_P (insn));
9333       return branch_if_true;
9334     }
9335
9336   /* Generate a reversed branch around a direct jump.  This fallback does
9337      not use branch-likely instructions.  */
9338   mips_branch_likely = false;
9339   not_taken = gen_label_rtx ();
9340   taken = operands[1];
9341
9342   /* Generate the reversed branch to NOT_TAKEN.  */
9343   operands[1] = not_taken;
9344   output_asm_insn (branch_if_false, operands);
9345
9346   /* If INSN has a delay slot, we must provide delay slots for both the
9347      branch to NOT_TAKEN and the conditional jump.  We must also ensure
9348      that INSN's delay slot is executed in the appropriate cases.  */
9349   if (final_sequence)
9350     {
9351       /* This first delay slot will always be executed, so use INSN's
9352          delay slot if is not annulled.  */
9353       if (!INSN_ANNULLED_BRANCH_P (insn))
9354         {
9355           final_scan_insn (XVECEXP (final_sequence, 0, 1),
9356                            asm_out_file, optimize, 1, NULL);
9357           INSN_DELETED_P (XVECEXP (final_sequence, 0, 1)) = 1;
9358         }
9359       else
9360         output_asm_insn ("nop", 0);
9361       fprintf (asm_out_file, "\n");
9362     }
9363
9364   /* Output the unconditional branch to TAKEN.  */
9365   if (length <= 16)
9366     output_asm_insn ("j\t%0%/", &taken);
9367   else
9368     {
9369       output_asm_insn (mips_output_load_label (), &taken);
9370       output_asm_insn ("jr\t%@%]%/", 0);
9371     }
9372
9373   /* Now deal with its delay slot; see above.  */
9374   if (final_sequence)
9375     {
9376       /* This delay slot will only be executed if the branch is taken.
9377          Use INSN's delay slot if is annulled.  */
9378       if (INSN_ANNULLED_BRANCH_P (insn))
9379         {
9380           final_scan_insn (XVECEXP (final_sequence, 0, 1),
9381                            asm_out_file, optimize, 1, NULL);
9382           INSN_DELETED_P (XVECEXP (final_sequence, 0, 1)) = 1;
9383         }
9384       else
9385         output_asm_insn ("nop", 0);
9386       fprintf (asm_out_file, "\n");
9387     }
9388
9389   /* Output NOT_TAKEN.  */
9390   (*targetm.asm_out.internal_label) (asm_out_file, "L",
9391                                      CODE_LABEL_NUMBER (not_taken));
9392   return "";
9393 }
9394
9395 /* Return the assembly code for INSN, which branches to OPERANDS[1]
9396    if some ordered condition is true.  The condition is given by
9397    OPERANDS[0] if !INVERTED_P, otherwise it is the inverse of
9398    OPERANDS[0].  OPERANDS[2] is the comparison's first operand;
9399    its second is always zero.  */
9400
9401 const char *
9402 mips_output_order_conditional_branch (rtx insn, rtx *operands, bool inverted_p)
9403 {
9404   const char *branch[2];
9405
9406   /* Make BRANCH[1] branch to OPERANDS[1] when the condition is true.
9407      Make BRANCH[0] branch on the inverse condition.  */
9408   switch (GET_CODE (operands[0]))
9409     {
9410       /* These cases are equivalent to comparisons against zero.  */
9411     case LEU:
9412       inverted_p = !inverted_p;
9413       /* Fall through.  */
9414     case GTU:
9415       branch[!inverted_p] = MIPS_BRANCH ("bne", "%2,%.,%1");
9416       branch[inverted_p] = MIPS_BRANCH ("beq", "%2,%.,%1");
9417       break;
9418
9419       /* These cases are always true or always false.  */
9420     case LTU:
9421       inverted_p = !inverted_p;
9422       /* Fall through.  */
9423     case GEU:
9424       branch[!inverted_p] = MIPS_BRANCH ("beq", "%.,%.,%1");
9425       branch[inverted_p] = MIPS_BRANCH ("bne", "%.,%.,%1");
9426       break;
9427
9428     default:
9429       branch[!inverted_p] = MIPS_BRANCH ("b%C0z", "%2,%1");
9430       branch[inverted_p] = MIPS_BRANCH ("b%N0z", "%2,%1");
9431       break;
9432     }
9433   return mips_output_conditional_branch (insn, operands, branch[1], branch[0]);
9434 }
9435 \f
9436 /* Used to output div or ddiv instruction DIVISION, which has the operands
9437    given by OPERANDS.  Add in a divide-by-zero check if needed.
9438
9439    When working around R4000 and R4400 errata, we need to make sure that
9440    the division is not immediately followed by a shift[1][2].  We also
9441    need to stop the division from being put into a branch delay slot[3].
9442    The easiest way to avoid both problems is to add a nop after the
9443    division.  When a divide-by-zero check is needed, this nop can be
9444    used to fill the branch delay slot.
9445
9446    [1] If a double-word or a variable shift executes immediately
9447        after starting an integer division, the shift may give an
9448        incorrect result.  See quotations of errata #16 and #28 from
9449        "MIPS R4000PC/SC Errata, Processor Revision 2.2 and 3.0"
9450        in mips.md for details.
9451
9452    [2] A similar bug to [1] exists for all revisions of the
9453        R4000 and the R4400 when run in an MC configuration.
9454        From "MIPS R4000MC Errata, Processor Revision 2.2 and 3.0":
9455
9456        "19. In this following sequence:
9457
9458                     ddiv                (or ddivu or div or divu)
9459                     dsll32              (or dsrl32, dsra32)
9460
9461             if an MPT stall occurs, while the divide is slipping the cpu
9462             pipeline, then the following double shift would end up with an
9463             incorrect result.
9464
9465             Workaround: The compiler needs to avoid generating any
9466             sequence with divide followed by extended double shift."
9467
9468        This erratum is also present in "MIPS R4400MC Errata, Processor
9469        Revision 1.0" and "MIPS R4400MC Errata, Processor Revision 2.0
9470        & 3.0" as errata #10 and #4, respectively.
9471
9472    [3] From "MIPS R4000PC/SC Errata, Processor Revision 2.2 and 3.0"
9473        (also valid for MIPS R4000MC processors):
9474
9475        "52. R4000SC: This bug does not apply for the R4000PC.
9476
9477             There are two flavors of this bug:
9478
9479             1) If the instruction just after divide takes an RF exception
9480                (tlb-refill, tlb-invalid) and gets an instruction cache
9481                miss (both primary and secondary) and the line which is
9482                currently in secondary cache at this index had the first
9483                data word, where the bits 5..2 are set, then R4000 would
9484                get a wrong result for the div.
9485
9486             ##1
9487                     nop
9488                     div r8, r9
9489                     -------------------         # end-of page. -tlb-refill
9490                     nop
9491             ##2
9492                     nop
9493                     div r8, r9
9494                     -------------------         # end-of page. -tlb-invalid
9495                     nop
9496
9497             2) If the divide is in the taken branch delay slot, where the
9498                target takes RF exception and gets an I-cache miss for the
9499                exception vector or where I-cache miss occurs for the
9500                target address, under the above mentioned scenarios, the
9501                div would get wrong results.
9502
9503             ##1
9504                     j   r2              # to next page mapped or unmapped
9505                     div r8,r9           # this bug would be there as long
9506                                         # as there is an ICache miss and
9507                     nop                 # the "data pattern" is present
9508
9509             ##2
9510                     beq r0, r0, NextPage        # to Next page
9511                     div r8,r9
9512                     nop
9513
9514             This bug is present for div, divu, ddiv, and ddivu
9515             instructions.
9516
9517             Workaround: For item 1), OS could make sure that the next page
9518             after the divide instruction is also mapped.  For item 2), the
9519             compiler could make sure that the divide instruction is not in
9520             the branch delay slot."
9521
9522        These processors have PRId values of 0x00004220 and 0x00004300 for
9523        the R4000 and 0x00004400, 0x00004500 and 0x00004600 for the R4400.  */
9524
9525 const char *
9526 mips_output_division (const char *division, rtx *operands)
9527 {
9528   const char *s;
9529
9530   s = division;
9531   if (TARGET_FIX_R4000 || TARGET_FIX_R4400)
9532     {
9533       output_asm_insn (s, operands);
9534       s = "nop";
9535     }
9536   if (TARGET_CHECK_ZERO_DIV)
9537     {
9538       if (TARGET_MIPS16)
9539         {
9540           output_asm_insn (s, operands);
9541           s = "bnez\t%2,1f\n\tbreak\t7\n1:";
9542         }
9543       else if (GENERATE_DIVIDE_TRAPS)
9544         {
9545           output_asm_insn (s, operands);
9546           s = "teq\t%2,%.,7";
9547         }
9548       else
9549         {
9550           output_asm_insn ("%(bne\t%2,%.,1f", operands);
9551           output_asm_insn (s, operands);
9552           s = "break\t7%)\n1:";
9553         }
9554     }
9555   return s;
9556 }
9557 \f
9558 /* Return true if GIVEN is the same as CANONICAL, or if it is CANONICAL
9559    with a final "000" replaced by "k".  Ignore case.
9560
9561    Note: this function is shared between GCC and GAS.  */
9562
9563 static bool
9564 mips_strict_matching_cpu_name_p (const char *canonical, const char *given)
9565 {
9566   while (*given != 0 && TOLOWER (*given) == TOLOWER (*canonical))
9567     given++, canonical++;
9568
9569   return ((*given == 0 && *canonical == 0)
9570           || (strcmp (canonical, "000") == 0 && strcasecmp (given, "k") == 0));
9571 }
9572
9573
9574 /* Return true if GIVEN matches CANONICAL, where GIVEN is a user-supplied
9575    CPU name.  We've traditionally allowed a lot of variation here.
9576
9577    Note: this function is shared between GCC and GAS.  */
9578
9579 static bool
9580 mips_matching_cpu_name_p (const char *canonical, const char *given)
9581 {
9582   /* First see if the name matches exactly, or with a final "000"
9583      turned into "k".  */
9584   if (mips_strict_matching_cpu_name_p (canonical, given))
9585     return true;
9586
9587   /* If not, try comparing based on numerical designation alone.
9588      See if GIVEN is an unadorned number, or 'r' followed by a number.  */
9589   if (TOLOWER (*given) == 'r')
9590     given++;
9591   if (!ISDIGIT (*given))
9592     return false;
9593
9594   /* Skip over some well-known prefixes in the canonical name,
9595      hoping to find a number there too.  */
9596   if (TOLOWER (canonical[0]) == 'v' && TOLOWER (canonical[1]) == 'r')
9597     canonical += 2;
9598   else if (TOLOWER (canonical[0]) == 'r' && TOLOWER (canonical[1]) == 'm')
9599     canonical += 2;
9600   else if (TOLOWER (canonical[0]) == 'r')
9601     canonical += 1;
9602
9603   return mips_strict_matching_cpu_name_p (canonical, given);
9604 }
9605
9606
9607 /* Return the mips_cpu_info entry for the processor or ISA given
9608    by CPU_STRING.  Return null if the string isn't recognized.
9609
9610    A similar function exists in GAS.  */
9611
9612 static const struct mips_cpu_info *
9613 mips_parse_cpu (const char *cpu_string)
9614 {
9615   const struct mips_cpu_info *p;
9616   const char *s;
9617
9618   /* In the past, we allowed upper-case CPU names, but it doesn't
9619      work well with the multilib machinery.  */
9620   for (s = cpu_string; *s != 0; s++)
9621     if (ISUPPER (*s))
9622       {
9623         warning (0, "the cpu name must be lower case");
9624         break;
9625       }
9626
9627   /* 'from-abi' selects the most compatible architecture for the given
9628      ABI: MIPS I for 32-bit ABIs and MIPS III for 64-bit ABIs.  For the
9629      EABIs, we have to decide whether we're using the 32-bit or 64-bit
9630      version.  Look first at the -mgp options, if given, otherwise base
9631      the choice on MASK_64BIT in TARGET_DEFAULT.  */
9632   if (strcasecmp (cpu_string, "from-abi") == 0)
9633     return mips_cpu_info_from_isa (ABI_NEEDS_32BIT_REGS ? 1
9634                                    : ABI_NEEDS_64BIT_REGS ? 3
9635                                    : (TARGET_64BIT ? 3 : 1));
9636
9637   /* 'default' has traditionally been a no-op.  Probably not very useful.  */
9638   if (strcasecmp (cpu_string, "default") == 0)
9639     return 0;
9640
9641   for (p = mips_cpu_info_table; p->name != 0; p++)
9642     if (mips_matching_cpu_name_p (p->name, cpu_string))
9643       return p;
9644
9645   return 0;
9646 }
9647
9648
9649 /* Return the processor associated with the given ISA level, or null
9650    if the ISA isn't valid.  */
9651
9652 static const struct mips_cpu_info *
9653 mips_cpu_info_from_isa (int isa)
9654 {
9655   const struct mips_cpu_info *p;
9656
9657   for (p = mips_cpu_info_table; p->name != 0; p++)
9658     if (p->isa == isa)
9659       return p;
9660
9661   return 0;
9662 }
9663 \f
9664 /* Implement HARD_REGNO_NREGS.  The size of FP registers is controlled
9665    by UNITS_PER_FPREG.  The size of FP status registers is always 4, because
9666    they only hold condition code modes, and CCmode is always considered to
9667    be 4 bytes wide.  All other registers are word sized.  */
9668
9669 unsigned int
9670 mips_hard_regno_nregs (int regno, enum machine_mode mode)
9671 {
9672   if (ST_REG_P (regno))
9673     return ((GET_MODE_SIZE (mode) + 3) / 4);
9674   else if (! FP_REG_P (regno))
9675     return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
9676   else
9677     return ((GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG);
9678 }
9679
9680 /* Implement TARGET_RETURN_IN_MEMORY.  Under the old (i.e., 32 and O64 ABIs)
9681    all BLKmode objects are returned in memory.  Under the new (N32 and
9682    64-bit MIPS ABIs) small structures are returned in a register.
9683    Objects with varying size must still be returned in memory, of
9684    course.  */
9685
9686 static bool
9687 mips_return_in_memory (tree type, tree fndecl ATTRIBUTE_UNUSED)
9688 {
9689   if (TARGET_OLDABI)
9690     return (TYPE_MODE (type) == BLKmode);
9691   else
9692     return ((int_size_in_bytes (type) > (2 * UNITS_PER_WORD))
9693             || (int_size_in_bytes (type) == -1));
9694 }
9695
9696 static bool
9697 mips_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
9698 {
9699   return !TARGET_OLDABI;
9700 }
9701 \f
9702 /* Return true if INSN is a multiply-add or multiply-subtract
9703    instruction and PREV assigns to the accumulator operand.  */
9704
9705 bool
9706 mips_linked_madd_p (rtx prev, rtx insn)
9707 {
9708   rtx x;
9709
9710   x = single_set (insn);
9711   if (x == 0)
9712     return false;
9713
9714   x = SET_SRC (x);
9715
9716   if (GET_CODE (x) == PLUS
9717       && GET_CODE (XEXP (x, 0)) == MULT
9718       && reg_set_p (XEXP (x, 1), prev))
9719     return true;
9720
9721   if (GET_CODE (x) == MINUS
9722       && GET_CODE (XEXP (x, 1)) == MULT
9723       && reg_set_p (XEXP (x, 0), prev))
9724     return true;
9725
9726   return false;
9727 }
9728 \f
9729 /* Used by TUNE_MACC_CHAINS to record the last scheduled instruction
9730    that may clobber hi or lo.  */
9731
9732 static rtx mips_macc_chains_last_hilo;
9733
9734 /* A TUNE_MACC_CHAINS helper function.  Record that instruction INSN has
9735    been scheduled, updating mips_macc_chains_last_hilo appropriately.  */
9736
9737 static void
9738 mips_macc_chains_record (rtx insn)
9739 {
9740   if (get_attr_may_clobber_hilo (insn))
9741     mips_macc_chains_last_hilo = insn;
9742 }
9743
9744 /* A TUNE_MACC_CHAINS helper function.  Search ready queue READY, which
9745    has NREADY elements, looking for a multiply-add or multiply-subtract
9746    instruction that is cumulative with mips_macc_chains_last_hilo.
9747    If there is one, promote it ahead of anything else that might
9748    clobber hi or lo.  */
9749
9750 static void
9751 mips_macc_chains_reorder (rtx *ready, int nready)
9752 {
9753   int i, j;
9754
9755   if (mips_macc_chains_last_hilo != 0)
9756     for (i = nready - 1; i >= 0; i--)
9757       if (mips_linked_madd_p (mips_macc_chains_last_hilo, ready[i]))
9758         {
9759           for (j = nready - 1; j > i; j--)
9760             if (recog_memoized (ready[j]) >= 0
9761                 && get_attr_may_clobber_hilo (ready[j]))
9762               {
9763                 mips_promote_ready (ready, i, j);
9764                 break;
9765               }
9766           break;
9767         }
9768 }
9769 \f
9770 /* The last instruction to be scheduled.  */
9771
9772 static rtx vr4130_last_insn;
9773
9774 /* A note_stores callback used by vr4130_true_reg_dependence_p.  DATA
9775    points to an rtx that is initially an instruction.  Nullify the rtx
9776    if the instruction uses the value of register X.  */
9777
9778 static void
9779 vr4130_true_reg_dependence_p_1 (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
9780 {
9781   rtx *insn_ptr = data;
9782   if (REG_P (x)
9783       && *insn_ptr != 0
9784       && reg_referenced_p (x, PATTERN (*insn_ptr)))
9785     *insn_ptr = 0;
9786 }
9787
9788 /* Return true if there is true register dependence between vr4130_last_insn
9789    and INSN.  */
9790
9791 static bool
9792 vr4130_true_reg_dependence_p (rtx insn)
9793 {
9794   note_stores (PATTERN (vr4130_last_insn),
9795                vr4130_true_reg_dependence_p_1, &insn);
9796   return insn == 0;
9797 }
9798
9799 /* A TUNE_MIPS4130 helper function.  Given that INSN1 is at the head of
9800    the ready queue and that INSN2 is the instruction after it, return
9801    true if it is worth promoting INSN2 ahead of INSN1.  Look for cases
9802    in which INSN1 and INSN2 can probably issue in parallel, but for
9803    which (INSN2, INSN1) should be less sensitive to instruction
9804    alignment than (INSN1, INSN2).  See 4130.md for more details.  */
9805
9806 static bool
9807 vr4130_swap_insns_p (rtx insn1, rtx insn2)
9808 {
9809   rtx dep;
9810
9811   /* Check for the following case:
9812
9813      1) there is some other instruction X with an anti dependence on INSN1;
9814      2) X has a higher priority than INSN2; and
9815      3) X is an arithmetic instruction (and thus has no unit restrictions).
9816
9817      If INSN1 is the last instruction blocking X, it would better to
9818      choose (INSN1, X) over (INSN2, INSN1).  */
9819   for (dep = INSN_DEPEND (insn1); dep != 0; dep = XEXP (dep, 1))
9820     if (REG_NOTE_KIND (dep) == REG_DEP_ANTI
9821         && INSN_PRIORITY (XEXP (dep, 0)) > INSN_PRIORITY (insn2)
9822         && recog_memoized (XEXP (dep, 0)) >= 0
9823         && get_attr_vr4130_class (XEXP (dep, 0)) == VR4130_CLASS_ALU)
9824       return false;
9825
9826   if (vr4130_last_insn != 0
9827       && recog_memoized (insn1) >= 0
9828       && recog_memoized (insn2) >= 0)
9829     {
9830       /* See whether INSN1 and INSN2 use different execution units,
9831          or if they are both ALU-type instructions.  If so, they can
9832          probably execute in parallel.  */
9833       enum attr_vr4130_class class1 = get_attr_vr4130_class (insn1);
9834       enum attr_vr4130_class class2 = get_attr_vr4130_class (insn2);
9835       if (class1 != class2 || class1 == VR4130_CLASS_ALU)
9836         {
9837           /* If only one of the instructions has a dependence on
9838              vr4130_last_insn, prefer to schedule the other one first.  */
9839           bool dep1 = vr4130_true_reg_dependence_p (insn1);
9840           bool dep2 = vr4130_true_reg_dependence_p (insn2);
9841           if (dep1 != dep2)
9842             return dep1;
9843
9844           /* Prefer to schedule INSN2 ahead of INSN1 if vr4130_last_insn
9845              is not an ALU-type instruction and if INSN1 uses the same
9846              execution unit.  (Note that if this condition holds, we already
9847              know that INSN2 uses a different execution unit.)  */
9848           if (class1 != VR4130_CLASS_ALU
9849               && recog_memoized (vr4130_last_insn) >= 0
9850               && class1 == get_attr_vr4130_class (vr4130_last_insn))
9851             return true;
9852         }
9853     }
9854   return false;
9855 }
9856
9857 /* A TUNE_MIPS4130 helper function.  (READY, NREADY) describes a ready
9858    queue with at least two instructions.  Swap the first two if
9859    vr4130_swap_insns_p says that it could be worthwhile.  */
9860
9861 static void
9862 vr4130_reorder (rtx *ready, int nready)
9863 {
9864   if (vr4130_swap_insns_p (ready[nready - 1], ready[nready - 2]))
9865     mips_promote_ready (ready, nready - 2, nready - 1);
9866 }
9867 \f
9868 /* Remove the instruction at index LOWER from ready queue READY and
9869    reinsert it in front of the instruction at index HIGHER.  LOWER must
9870    be <= HIGHER.  */
9871
9872 static void
9873 mips_promote_ready (rtx *ready, int lower, int higher)
9874 {
9875   rtx new_head;
9876   int i;
9877
9878   new_head = ready[lower];
9879   for (i = lower; i < higher; i++)
9880     ready[i] = ready[i + 1];
9881   ready[i] = new_head;
9882 }
9883
9884 /* Implement TARGET_SCHED_REORDER.  */
9885
9886 static int
9887 mips_sched_reorder (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
9888                     rtx *ready, int *nreadyp, int cycle)
9889 {
9890   if (!reload_completed && TUNE_MACC_CHAINS)
9891     {
9892       if (cycle == 0)
9893         mips_macc_chains_last_hilo = 0;
9894       if (*nreadyp > 0)
9895         mips_macc_chains_reorder (ready, *nreadyp);
9896     }
9897   if (reload_completed && TUNE_MIPS4130 && !TARGET_VR4130_ALIGN)
9898     {
9899       if (cycle == 0)
9900         vr4130_last_insn = 0;
9901       if (*nreadyp > 1)
9902         vr4130_reorder (ready, *nreadyp);
9903     }
9904   return mips_issue_rate ();
9905 }
9906
9907 /* Implement TARGET_SCHED_VARIABLE_ISSUE.  */
9908
9909 static int
9910 mips_variable_issue (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
9911                      rtx insn, int more)
9912 {
9913   switch (GET_CODE (PATTERN (insn)))
9914     {
9915     case USE:
9916     case CLOBBER:
9917       /* Don't count USEs and CLOBBERs against the issue rate.  */
9918       break;
9919
9920     default:
9921       more--;
9922       if (!reload_completed && TUNE_MACC_CHAINS)
9923         mips_macc_chains_record (insn);
9924       vr4130_last_insn = insn;
9925       break;
9926     }
9927   return more;
9928 }
9929 \f
9930 /* Implement TARGET_SCHED_ADJUST_COST.  We assume that anti and output
9931    dependencies have no cost.  */
9932
9933 static int
9934 mips_adjust_cost (rtx insn ATTRIBUTE_UNUSED, rtx link,
9935                   rtx dep ATTRIBUTE_UNUSED, int cost)
9936 {
9937   if (REG_NOTE_KIND (link) != 0)
9938     return 0;
9939   return cost;
9940 }
9941
9942 /* Return the number of instructions that can be issued per cycle.  */
9943
9944 static int
9945 mips_issue_rate (void)
9946 {
9947   switch (mips_tune)
9948     {
9949     case PROCESSOR_R4130:
9950     case PROCESSOR_R5400:
9951     case PROCESSOR_R5500:
9952     case PROCESSOR_R7000:
9953     case PROCESSOR_R9000:
9954       return 2;
9955
9956     case PROCESSOR_SB1:
9957     case PROCESSOR_SB1A:
9958       /* This is actually 4, but we get better performance if we claim 3.
9959          This is partly because of unwanted speculative code motion with the
9960          larger number, and partly because in most common cases we can't
9961          reach the theoretical max of 4.  */
9962       return 3;
9963
9964     default:
9965       return 1;
9966     }
9967 }
9968
9969 /* Implements TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD.  This should
9970    be as wide as the scheduling freedom in the DFA.  */
9971
9972 static int
9973 mips_multipass_dfa_lookahead (void)
9974 {
9975   /* Can schedule up to 4 of the 6 function units in any one cycle.  */
9976   if (TUNE_SB1)
9977     return 4;
9978
9979   return 0;
9980 }
9981
9982 /* Implements a store data bypass check.  We need this because the cprestore
9983    pattern is type store, but defined using an UNSPEC.  This UNSPEC causes the
9984    default routine to abort.  We just return false for that case.  */
9985 /* ??? Should try to give a better result here than assuming false.  */
9986
9987 int
9988 mips_store_data_bypass_p (rtx out_insn, rtx in_insn)
9989 {
9990   if (GET_CODE (PATTERN (in_insn)) == UNSPEC_VOLATILE)
9991     return false;
9992
9993   return ! store_data_bypass_p (out_insn, in_insn);
9994 }
9995 \f
9996 /* Given that we have an rtx of the form (prefetch ... WRITE LOCALITY),
9997    return the first operand of the associated "pref" or "prefx" insn.  */
9998
9999 rtx
10000 mips_prefetch_cookie (rtx write, rtx locality)
10001 {
10002   /* store_streamed / load_streamed.  */
10003   if (INTVAL (locality) <= 0)
10004     return GEN_INT (INTVAL (write) + 4);
10005
10006   /* store / load.  */
10007   if (INTVAL (locality) <= 2)
10008     return write;
10009
10010   /* store_retained / load_retained.  */
10011   return GEN_INT (INTVAL (write) + 6);
10012 }
10013 \f
10014 /* MIPS builtin function support. */
10015
10016 struct builtin_description
10017 {
10018   /* The code of the main .md file instruction.  See mips_builtin_type
10019      for more information.  */
10020   enum insn_code icode;
10021
10022   /* The floating-point comparison code to use with ICODE, if any.  */
10023   enum mips_fp_condition cond;
10024
10025   /* The name of the builtin function.  */
10026   const char *name;
10027
10028   /* Specifies how the function should be expanded.  */
10029   enum mips_builtin_type builtin_type;
10030
10031   /* The function's prototype.  */
10032   enum mips_function_type function_type;
10033
10034   /* The target flags required for this function.  */
10035   int target_flags;
10036 };
10037
10038 /* Define a MIPS_BUILTIN_DIRECT function for instruction CODE_FOR_mips_<INSN>.
10039    FUNCTION_TYPE and TARGET_FLAGS are builtin_description fields.  */
10040 #define DIRECT_BUILTIN(INSN, FUNCTION_TYPE, TARGET_FLAGS)               \
10041   { CODE_FOR_mips_ ## INSN, 0, "__builtin_mips_" #INSN,                 \
10042     MIPS_BUILTIN_DIRECT, FUNCTION_TYPE, TARGET_FLAGS }
10043
10044 /* Define __builtin_mips_<INSN>_<COND>_{s,d}, both of which require
10045    TARGET_FLAGS.  */
10046 #define CMP_SCALAR_BUILTINS(INSN, COND, TARGET_FLAGS)                   \
10047   { CODE_FOR_mips_ ## INSN ## _cond_s, MIPS_FP_COND_ ## COND,           \
10048     "__builtin_mips_" #INSN "_" #COND "_s",                             \
10049     MIPS_BUILTIN_CMP_SINGLE, MIPS_INT_FTYPE_SF_SF, TARGET_FLAGS },      \
10050   { CODE_FOR_mips_ ## INSN ## _cond_d, MIPS_FP_COND_ ## COND,           \
10051     "__builtin_mips_" #INSN "_" #COND "_d",                             \
10052     MIPS_BUILTIN_CMP_SINGLE, MIPS_INT_FTYPE_DF_DF, TARGET_FLAGS }
10053
10054 /* Define __builtin_mips_{any,all,upper,lower}_<INSN>_<COND>_ps.
10055    The lower and upper forms require TARGET_FLAGS while the any and all
10056    forms require MASK_MIPS3D.  */
10057 #define CMP_PS_BUILTINS(INSN, COND, TARGET_FLAGS)                       \
10058   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10059     "__builtin_mips_any_" #INSN "_" #COND "_ps",                        \
10060     MIPS_BUILTIN_CMP_ANY, MIPS_INT_FTYPE_V2SF_V2SF, MASK_MIPS3D },      \
10061   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10062     "__builtin_mips_all_" #INSN "_" #COND "_ps",                        \
10063     MIPS_BUILTIN_CMP_ALL, MIPS_INT_FTYPE_V2SF_V2SF, MASK_MIPS3D },      \
10064   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10065     "__builtin_mips_lower_" #INSN "_" #COND "_ps",                      \
10066     MIPS_BUILTIN_CMP_LOWER, MIPS_INT_FTYPE_V2SF_V2SF, TARGET_FLAGS },   \
10067   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10068     "__builtin_mips_upper_" #INSN "_" #COND "_ps",                      \
10069     MIPS_BUILTIN_CMP_UPPER, MIPS_INT_FTYPE_V2SF_V2SF, TARGET_FLAGS }
10070
10071 /* Define __builtin_mips_{any,all}_<INSN>_<COND>_4s.  The functions
10072    require MASK_MIPS3D.  */
10073 #define CMP_4S_BUILTINS(INSN, COND)                                     \
10074   { CODE_FOR_mips_ ## INSN ## _cond_4s, MIPS_FP_COND_ ## COND,          \
10075     "__builtin_mips_any_" #INSN "_" #COND "_4s",                        \
10076     MIPS_BUILTIN_CMP_ANY, MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,           \
10077     MASK_MIPS3D },                                                      \
10078   { CODE_FOR_mips_ ## INSN ## _cond_4s, MIPS_FP_COND_ ## COND,          \
10079     "__builtin_mips_all_" #INSN "_" #COND "_4s",                        \
10080     MIPS_BUILTIN_CMP_ALL, MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,           \
10081     MASK_MIPS3D }
10082
10083 /* Define __builtin_mips_mov{t,f}_<INSN>_<COND>_ps.  The comparison
10084    instruction requires TARGET_FLAGS.  */
10085 #define MOVTF_BUILTINS(INSN, COND, TARGET_FLAGS)                        \
10086   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10087     "__builtin_mips_movt_" #INSN "_" #COND "_ps",                       \
10088     MIPS_BUILTIN_MOVT, MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,             \
10089     TARGET_FLAGS },                                                     \
10090   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
10091     "__builtin_mips_movf_" #INSN "_" #COND "_ps",                       \
10092     MIPS_BUILTIN_MOVF, MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,             \
10093     TARGET_FLAGS }
10094
10095 /* Define all the builtins related to c.cond.fmt condition COND.  */
10096 #define CMP_BUILTINS(COND)                                              \
10097   MOVTF_BUILTINS (c, COND, MASK_PAIRED_SINGLE_FLOAT),                   \
10098   MOVTF_BUILTINS (cabs, COND, MASK_MIPS3D),                             \
10099   CMP_SCALAR_BUILTINS (cabs, COND, MASK_MIPS3D),                        \
10100   CMP_PS_BUILTINS (c, COND, MASK_PAIRED_SINGLE_FLOAT),                  \
10101   CMP_PS_BUILTINS (cabs, COND, MASK_MIPS3D),                            \
10102   CMP_4S_BUILTINS (c, COND),                                            \
10103   CMP_4S_BUILTINS (cabs, COND)
10104
10105 static const struct builtin_description mips_bdesc[] =
10106 {
10107   DIRECT_BUILTIN (pll_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10108   DIRECT_BUILTIN (pul_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10109   DIRECT_BUILTIN (plu_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10110   DIRECT_BUILTIN (puu_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10111   DIRECT_BUILTIN (cvt_ps_s, MIPS_V2SF_FTYPE_SF_SF, MASK_PAIRED_SINGLE_FLOAT),
10112   DIRECT_BUILTIN (cvt_s_pl, MIPS_SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10113   DIRECT_BUILTIN (cvt_s_pu, MIPS_SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10114   DIRECT_BUILTIN (abs_ps, MIPS_V2SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10115
10116   DIRECT_BUILTIN (alnv_ps, MIPS_V2SF_FTYPE_V2SF_V2SF_INT,
10117                   MASK_PAIRED_SINGLE_FLOAT),
10118   DIRECT_BUILTIN (addr_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10119   DIRECT_BUILTIN (mulr_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10120   DIRECT_BUILTIN (cvt_pw_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10121   DIRECT_BUILTIN (cvt_ps_pw, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10122
10123   DIRECT_BUILTIN (recip1_s, MIPS_SF_FTYPE_SF, MASK_MIPS3D),
10124   DIRECT_BUILTIN (recip1_d, MIPS_DF_FTYPE_DF, MASK_MIPS3D),
10125   DIRECT_BUILTIN (recip1_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10126   DIRECT_BUILTIN (recip2_s, MIPS_SF_FTYPE_SF_SF, MASK_MIPS3D),
10127   DIRECT_BUILTIN (recip2_d, MIPS_DF_FTYPE_DF_DF, MASK_MIPS3D),
10128   DIRECT_BUILTIN (recip2_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10129
10130   DIRECT_BUILTIN (rsqrt1_s, MIPS_SF_FTYPE_SF, MASK_MIPS3D),
10131   DIRECT_BUILTIN (rsqrt1_d, MIPS_DF_FTYPE_DF, MASK_MIPS3D),
10132   DIRECT_BUILTIN (rsqrt1_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10133   DIRECT_BUILTIN (rsqrt2_s, MIPS_SF_FTYPE_SF_SF, MASK_MIPS3D),
10134   DIRECT_BUILTIN (rsqrt2_d, MIPS_DF_FTYPE_DF_DF, MASK_MIPS3D),
10135   DIRECT_BUILTIN (rsqrt2_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10136
10137   MIPS_FP_CONDITIONS (CMP_BUILTINS)
10138 };
10139
10140 /* Builtin functions for the SB-1 processor.  */
10141
10142 #define CODE_FOR_mips_sqrt_ps CODE_FOR_sqrtv2sf2
10143
10144 static const struct builtin_description sb1_bdesc[] =
10145 {
10146   DIRECT_BUILTIN (sqrt_ps, MIPS_V2SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT)
10147 };
10148
10149 /* Builtin functions for DSP ASE.  */
10150
10151 #define CODE_FOR_mips_addq_ph CODE_FOR_addv2hi3
10152 #define CODE_FOR_mips_addu_qb CODE_FOR_addv4qi3
10153 #define CODE_FOR_mips_subq_ph CODE_FOR_subv2hi3
10154 #define CODE_FOR_mips_subu_qb CODE_FOR_subv4qi3
10155
10156 /* Define a MIPS_BUILTIN_DIRECT_NO_TARGET function for instruction
10157    CODE_FOR_mips_<INSN>.  FUNCTION_TYPE and TARGET_FLAGS are
10158    builtin_description fields.  */
10159 #define DIRECT_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE, TARGET_FLAGS)     \
10160   { CODE_FOR_mips_ ## INSN, 0, "__builtin_mips_" #INSN,                 \
10161     MIPS_BUILTIN_DIRECT_NO_TARGET, FUNCTION_TYPE, TARGET_FLAGS }
10162
10163 /* Define __builtin_mips_bposge<VALUE>.  <VALUE> is 32 for the MIPS32 DSP
10164    branch instruction.  TARGET_FLAGS is a builtin_description field.  */
10165 #define BPOSGE_BUILTIN(VALUE, TARGET_FLAGS)                             \
10166   { CODE_FOR_mips_bposge, 0, "__builtin_mips_bposge" #VALUE,            \
10167     MIPS_BUILTIN_BPOSGE ## VALUE, MIPS_SI_FTYPE_VOID, TARGET_FLAGS }
10168
10169 static const struct builtin_description dsp_bdesc[] =
10170 {
10171   DIRECT_BUILTIN (addq_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10172   DIRECT_BUILTIN (addq_s_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10173   DIRECT_BUILTIN (addq_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10174   DIRECT_BUILTIN (addu_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10175   DIRECT_BUILTIN (addu_s_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10176   DIRECT_BUILTIN (subq_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10177   DIRECT_BUILTIN (subq_s_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10178   DIRECT_BUILTIN (subq_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10179   DIRECT_BUILTIN (subu_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10180   DIRECT_BUILTIN (subu_s_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10181   DIRECT_BUILTIN (addsc, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10182   DIRECT_BUILTIN (addwc, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10183   DIRECT_BUILTIN (modsub, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10184   DIRECT_BUILTIN (raddu_w_qb, MIPS_SI_FTYPE_V4QI, MASK_DSP),
10185   DIRECT_BUILTIN (absq_s_ph, MIPS_V2HI_FTYPE_V2HI, MASK_DSP),
10186   DIRECT_BUILTIN (absq_s_w, MIPS_SI_FTYPE_SI, MASK_DSP),
10187   DIRECT_BUILTIN (precrq_qb_ph, MIPS_V4QI_FTYPE_V2HI_V2HI, MASK_DSP),
10188   DIRECT_BUILTIN (precrq_ph_w, MIPS_V2HI_FTYPE_SI_SI, MASK_DSP),
10189   DIRECT_BUILTIN (precrq_rs_ph_w, MIPS_V2HI_FTYPE_SI_SI, MASK_DSP),
10190   DIRECT_BUILTIN (precrqu_s_qb_ph, MIPS_V4QI_FTYPE_V2HI_V2HI, MASK_DSP),
10191   DIRECT_BUILTIN (preceq_w_phl, MIPS_SI_FTYPE_V2HI, MASK_DSP),
10192   DIRECT_BUILTIN (preceq_w_phr, MIPS_SI_FTYPE_V2HI, MASK_DSP),
10193   DIRECT_BUILTIN (precequ_ph_qbl, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10194   DIRECT_BUILTIN (precequ_ph_qbr, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10195   DIRECT_BUILTIN (precequ_ph_qbla, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10196   DIRECT_BUILTIN (precequ_ph_qbra, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10197   DIRECT_BUILTIN (preceu_ph_qbl, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10198   DIRECT_BUILTIN (preceu_ph_qbr, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10199   DIRECT_BUILTIN (preceu_ph_qbla, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10200   DIRECT_BUILTIN (preceu_ph_qbra, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10201   DIRECT_BUILTIN (shll_qb, MIPS_V4QI_FTYPE_V4QI_SI, MASK_DSP),
10202   DIRECT_BUILTIN (shll_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10203   DIRECT_BUILTIN (shll_s_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10204   DIRECT_BUILTIN (shll_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10205   DIRECT_BUILTIN (shrl_qb, MIPS_V4QI_FTYPE_V4QI_SI, MASK_DSP),
10206   DIRECT_BUILTIN (shra_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10207   DIRECT_BUILTIN (shra_r_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10208   DIRECT_BUILTIN (shra_r_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10209   DIRECT_BUILTIN (muleu_s_ph_qbl, MIPS_V2HI_FTYPE_V4QI_V2HI, MASK_DSP),
10210   DIRECT_BUILTIN (muleu_s_ph_qbr, MIPS_V2HI_FTYPE_V4QI_V2HI, MASK_DSP),
10211   DIRECT_BUILTIN (mulq_rs_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10212   DIRECT_BUILTIN (muleq_s_w_phl, MIPS_SI_FTYPE_V2HI_V2HI, MASK_DSP),
10213   DIRECT_BUILTIN (muleq_s_w_phr, MIPS_SI_FTYPE_V2HI_V2HI, MASK_DSP),
10214   DIRECT_BUILTIN (dpau_h_qbl, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10215   DIRECT_BUILTIN (dpau_h_qbr, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10216   DIRECT_BUILTIN (dpsu_h_qbl, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10217   DIRECT_BUILTIN (dpsu_h_qbr, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10218   DIRECT_BUILTIN (dpaq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10219   DIRECT_BUILTIN (dpsq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10220   DIRECT_BUILTIN (mulsaq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10221   DIRECT_BUILTIN (dpaq_sa_l_w, MIPS_DI_FTYPE_DI_SI_SI, MASK_DSP),
10222   DIRECT_BUILTIN (dpsq_sa_l_w, MIPS_DI_FTYPE_DI_SI_SI, MASK_DSP),
10223   DIRECT_BUILTIN (maq_s_w_phl, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10224   DIRECT_BUILTIN (maq_s_w_phr, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10225   DIRECT_BUILTIN (maq_sa_w_phl, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10226   DIRECT_BUILTIN (maq_sa_w_phr, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10227   DIRECT_BUILTIN (bitrev, MIPS_SI_FTYPE_SI, MASK_DSP),
10228   DIRECT_BUILTIN (insv, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10229   DIRECT_BUILTIN (repl_qb, MIPS_V4QI_FTYPE_SI, MASK_DSP),
10230   DIRECT_BUILTIN (repl_ph, MIPS_V2HI_FTYPE_SI, MASK_DSP),
10231   DIRECT_NO_TARGET_BUILTIN (cmpu_eq_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10232   DIRECT_NO_TARGET_BUILTIN (cmpu_lt_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10233   DIRECT_NO_TARGET_BUILTIN (cmpu_le_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10234   DIRECT_BUILTIN (cmpgu_eq_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10235   DIRECT_BUILTIN (cmpgu_lt_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10236   DIRECT_BUILTIN (cmpgu_le_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10237   DIRECT_NO_TARGET_BUILTIN (cmp_eq_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10238   DIRECT_NO_TARGET_BUILTIN (cmp_lt_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10239   DIRECT_NO_TARGET_BUILTIN (cmp_le_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10240   DIRECT_BUILTIN (pick_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10241   DIRECT_BUILTIN (pick_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10242   DIRECT_BUILTIN (packrl_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10243   DIRECT_BUILTIN (extr_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10244   DIRECT_BUILTIN (extr_r_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10245   DIRECT_BUILTIN (extr_rs_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10246   DIRECT_BUILTIN (extr_s_h, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10247   DIRECT_BUILTIN (extp, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10248   DIRECT_BUILTIN (extpdp, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10249   DIRECT_BUILTIN (shilo, MIPS_DI_FTYPE_DI_SI, MASK_DSP),
10250   DIRECT_BUILTIN (mthlip, MIPS_DI_FTYPE_DI_SI, MASK_DSP),
10251   DIRECT_NO_TARGET_BUILTIN (wrdsp, MIPS_VOID_FTYPE_SI_SI, MASK_DSP),
10252   DIRECT_BUILTIN (rddsp, MIPS_SI_FTYPE_SI, MASK_DSP),
10253   DIRECT_BUILTIN (lbux, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10254   DIRECT_BUILTIN (lhx, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10255   DIRECT_BUILTIN (lwx, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10256   BPOSGE_BUILTIN (32, MASK_DSP)
10257 };
10258
10259 /* This helps provide a mapping from builtin function codes to bdesc
10260    arrays.  */
10261
10262 struct bdesc_map
10263 {
10264   /* The builtin function table that this entry describes.  */
10265   const struct builtin_description *bdesc;
10266
10267   /* The number of entries in the builtin function table.  */
10268   unsigned int size;
10269
10270   /* The target processor that supports these builtin functions.
10271      PROCESSOR_MAX means we enable them for all processors.  */
10272   enum processor_type proc;
10273 };
10274
10275 static const struct bdesc_map bdesc_arrays[] =
10276 {
10277   { mips_bdesc, ARRAY_SIZE (mips_bdesc), PROCESSOR_MAX },
10278   { sb1_bdesc, ARRAY_SIZE (sb1_bdesc), PROCESSOR_SB1 },
10279   { dsp_bdesc, ARRAY_SIZE (dsp_bdesc), PROCESSOR_MAX }
10280 };
10281
10282 /* Take the head of argument list *ARGLIST and convert it into a form
10283    suitable for input operand OP of instruction ICODE.  Return the value
10284    and point *ARGLIST at the next element of the list.  */
10285
10286 static rtx
10287 mips_prepare_builtin_arg (enum insn_code icode,
10288                           unsigned int op, tree *arglist)
10289 {
10290   rtx value;
10291   enum machine_mode mode;
10292
10293   value = expand_normal (TREE_VALUE (*arglist));
10294   mode = insn_data[icode].operand[op].mode;
10295   if (!insn_data[icode].operand[op].predicate (value, mode))
10296     {
10297       value = copy_to_mode_reg (mode, value);
10298       /* Check the predicate again.  */
10299       if (!insn_data[icode].operand[op].predicate (value, mode))
10300         {
10301           error ("invalid argument to builtin function");
10302           return const0_rtx;
10303         }
10304     }
10305
10306   *arglist = TREE_CHAIN (*arglist);
10307   return value;
10308 }
10309
10310 /* Return an rtx suitable for output operand OP of instruction ICODE.
10311    If TARGET is non-null, try to use it where possible.  */
10312
10313 static rtx
10314 mips_prepare_builtin_target (enum insn_code icode, unsigned int op, rtx target)
10315 {
10316   enum machine_mode mode;
10317
10318   mode = insn_data[icode].operand[op].mode;
10319   if (target == 0 || !insn_data[icode].operand[op].predicate (target, mode))
10320     target = gen_reg_rtx (mode);
10321
10322   return target;
10323 }
10324
10325 /* Expand builtin functions.  This is called from TARGET_EXPAND_BUILTIN.  */
10326
10327 rtx
10328 mips_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
10329                      enum machine_mode mode ATTRIBUTE_UNUSED,
10330                      int ignore ATTRIBUTE_UNUSED)
10331 {
10332   enum insn_code icode;
10333   enum mips_builtin_type type;
10334   tree fndecl, arglist;
10335   unsigned int fcode;
10336   const struct builtin_description *bdesc;
10337   const struct bdesc_map *m;
10338
10339   fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
10340   arglist = TREE_OPERAND (exp, 1);
10341   fcode = DECL_FUNCTION_CODE (fndecl);
10342
10343   bdesc = NULL;
10344   for (m = bdesc_arrays; m < &bdesc_arrays[ARRAY_SIZE (bdesc_arrays)]; m++)
10345     {
10346       if (fcode < m->size)
10347         {
10348           bdesc = m->bdesc;
10349           icode = bdesc[fcode].icode;
10350           type = bdesc[fcode].builtin_type;
10351           break;
10352         }
10353       fcode -= m->size;
10354     }
10355   if (bdesc == NULL)
10356     return 0;
10357
10358   switch (type)
10359     {
10360     case MIPS_BUILTIN_DIRECT:
10361       return mips_expand_builtin_direct (icode, target, arglist, true);
10362
10363     case MIPS_BUILTIN_DIRECT_NO_TARGET:
10364       return mips_expand_builtin_direct (icode, target, arglist, false);
10365
10366     case MIPS_BUILTIN_MOVT:
10367     case MIPS_BUILTIN_MOVF:
10368       return mips_expand_builtin_movtf (type, icode, bdesc[fcode].cond,
10369                                         target, arglist);
10370
10371     case MIPS_BUILTIN_CMP_ANY:
10372     case MIPS_BUILTIN_CMP_ALL:
10373     case MIPS_BUILTIN_CMP_UPPER:
10374     case MIPS_BUILTIN_CMP_LOWER:
10375     case MIPS_BUILTIN_CMP_SINGLE:
10376       return mips_expand_builtin_compare (type, icode, bdesc[fcode].cond,
10377                                           target, arglist);
10378
10379     case MIPS_BUILTIN_BPOSGE32:
10380       return mips_expand_builtin_bposge (type, target);
10381
10382     default:
10383       return 0;
10384     }
10385 }
10386
10387 /* Init builtin functions.  This is called from TARGET_INIT_BUILTIN.  */
10388
10389 void
10390 mips_init_builtins (void)
10391 {
10392   const struct builtin_description *d;
10393   const struct bdesc_map *m;
10394   tree types[(int) MIPS_MAX_FTYPE_MAX];
10395   tree V2SF_type_node;
10396   tree V2HI_type_node;
10397   tree V4QI_type_node;
10398   unsigned int offset;
10399
10400   /* We have only builtins for -mpaired-single, -mips3d and -mdsp.  */
10401   if (!TARGET_PAIRED_SINGLE_FLOAT && !TARGET_DSP)
10402     return;
10403
10404   if (TARGET_PAIRED_SINGLE_FLOAT)
10405     {
10406       V2SF_type_node = build_vector_type_for_mode (float_type_node, V2SFmode);
10407
10408       types[MIPS_V2SF_FTYPE_V2SF]
10409         = build_function_type_list (V2SF_type_node, V2SF_type_node, NULL_TREE);
10410
10411       types[MIPS_V2SF_FTYPE_V2SF_V2SF]
10412         = build_function_type_list (V2SF_type_node,
10413                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10414
10415       types[MIPS_V2SF_FTYPE_V2SF_V2SF_INT]
10416         = build_function_type_list (V2SF_type_node,
10417                                     V2SF_type_node, V2SF_type_node,
10418                                     integer_type_node, NULL_TREE);
10419
10420       types[MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF]
10421         = build_function_type_list (V2SF_type_node,
10422                                     V2SF_type_node, V2SF_type_node,
10423                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10424
10425       types[MIPS_V2SF_FTYPE_SF_SF]
10426         = build_function_type_list (V2SF_type_node,
10427                                     float_type_node, float_type_node, NULL_TREE);
10428
10429       types[MIPS_INT_FTYPE_V2SF_V2SF]
10430         = build_function_type_list (integer_type_node,
10431                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10432
10433       types[MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF]
10434         = build_function_type_list (integer_type_node,
10435                                     V2SF_type_node, V2SF_type_node,
10436                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10437
10438       types[MIPS_INT_FTYPE_SF_SF]
10439         = build_function_type_list (integer_type_node,
10440                                     float_type_node, float_type_node, NULL_TREE);
10441
10442       types[MIPS_INT_FTYPE_DF_DF]
10443         = build_function_type_list (integer_type_node,
10444                                     double_type_node, double_type_node, NULL_TREE);
10445
10446       types[MIPS_SF_FTYPE_V2SF]
10447         = build_function_type_list (float_type_node, V2SF_type_node, NULL_TREE);
10448
10449       types[MIPS_SF_FTYPE_SF]
10450         = build_function_type_list (float_type_node,
10451                                     float_type_node, NULL_TREE);
10452
10453       types[MIPS_SF_FTYPE_SF_SF]
10454         = build_function_type_list (float_type_node,
10455                                     float_type_node, float_type_node, NULL_TREE);
10456
10457       types[MIPS_DF_FTYPE_DF]
10458         = build_function_type_list (double_type_node,
10459                                     double_type_node, NULL_TREE);
10460
10461       types[MIPS_DF_FTYPE_DF_DF]
10462         = build_function_type_list (double_type_node,
10463                                     double_type_node, double_type_node, NULL_TREE);
10464     }
10465
10466   if (TARGET_DSP)
10467     {
10468       V2HI_type_node = build_vector_type_for_mode (intHI_type_node, V2HImode);
10469       V4QI_type_node = build_vector_type_for_mode (intQI_type_node, V4QImode);
10470
10471       types[MIPS_V2HI_FTYPE_V2HI_V2HI]
10472         = build_function_type_list (V2HI_type_node,
10473                                     V2HI_type_node, V2HI_type_node,
10474                                     NULL_TREE);
10475
10476       types[MIPS_SI_FTYPE_SI_SI]
10477         = build_function_type_list (intSI_type_node,
10478                                     intSI_type_node, intSI_type_node,
10479                                     NULL_TREE);
10480
10481       types[MIPS_V4QI_FTYPE_V4QI_V4QI]
10482         = build_function_type_list (V4QI_type_node,
10483                                     V4QI_type_node, V4QI_type_node,
10484                                     NULL_TREE);
10485
10486       types[MIPS_SI_FTYPE_V4QI]
10487         = build_function_type_list (intSI_type_node,
10488                                     V4QI_type_node,
10489                                     NULL_TREE);
10490
10491       types[MIPS_V2HI_FTYPE_V2HI]
10492         = build_function_type_list (V2HI_type_node,
10493                                     V2HI_type_node,
10494                                     NULL_TREE);
10495
10496       types[MIPS_SI_FTYPE_SI]
10497         = build_function_type_list (intSI_type_node,
10498                                     intSI_type_node,
10499                                     NULL_TREE);
10500
10501       types[MIPS_V4QI_FTYPE_V2HI_V2HI]
10502         = build_function_type_list (V4QI_type_node,
10503                                     V2HI_type_node, V2HI_type_node,
10504                                     NULL_TREE);
10505
10506       types[MIPS_V2HI_FTYPE_SI_SI]
10507         = build_function_type_list (V2HI_type_node,
10508                                     intSI_type_node, intSI_type_node,
10509                                     NULL_TREE);
10510
10511       types[MIPS_SI_FTYPE_V2HI]
10512         = build_function_type_list (intSI_type_node,
10513                                     V2HI_type_node,
10514                                     NULL_TREE);
10515
10516       types[MIPS_V2HI_FTYPE_V4QI]
10517         = build_function_type_list (V2HI_type_node,
10518                                     V4QI_type_node,
10519                                     NULL_TREE);
10520
10521       types[MIPS_V4QI_FTYPE_V4QI_SI]
10522         = build_function_type_list (V4QI_type_node,
10523                                     V4QI_type_node, intSI_type_node,
10524                                     NULL_TREE);
10525
10526       types[MIPS_V2HI_FTYPE_V2HI_SI]
10527         = build_function_type_list (V2HI_type_node,
10528                                     V2HI_type_node, intSI_type_node,
10529                                     NULL_TREE);
10530
10531       types[MIPS_V2HI_FTYPE_V4QI_V2HI]
10532         = build_function_type_list (V2HI_type_node,
10533                                     V4QI_type_node, V2HI_type_node,
10534                                     NULL_TREE);
10535
10536       types[MIPS_SI_FTYPE_V2HI_V2HI]
10537         = build_function_type_list (intSI_type_node,
10538                                     V2HI_type_node, V2HI_type_node,
10539                                     NULL_TREE);
10540
10541       types[MIPS_DI_FTYPE_DI_V4QI_V4QI]
10542         = build_function_type_list (intDI_type_node,
10543                                     intDI_type_node, V4QI_type_node, V4QI_type_node,
10544                                     NULL_TREE);
10545
10546       types[MIPS_DI_FTYPE_DI_V2HI_V2HI]
10547         = build_function_type_list (intDI_type_node,
10548                                     intDI_type_node, V2HI_type_node, V2HI_type_node,
10549                                     NULL_TREE);
10550
10551       types[MIPS_DI_FTYPE_DI_SI_SI]
10552         = build_function_type_list (intDI_type_node,
10553                                     intDI_type_node, intSI_type_node, intSI_type_node,
10554                                     NULL_TREE);
10555
10556       types[MIPS_V4QI_FTYPE_SI]
10557         = build_function_type_list (V4QI_type_node,
10558                                     intSI_type_node,
10559                                     NULL_TREE);
10560
10561       types[MIPS_V2HI_FTYPE_SI]
10562         = build_function_type_list (V2HI_type_node,
10563                                     intSI_type_node,
10564                                     NULL_TREE);
10565
10566       types[MIPS_VOID_FTYPE_V4QI_V4QI]
10567         = build_function_type_list (void_type_node,
10568                                     V4QI_type_node, V4QI_type_node,
10569                                     NULL_TREE);
10570
10571       types[MIPS_SI_FTYPE_V4QI_V4QI]
10572         = build_function_type_list (intSI_type_node,
10573                                     V4QI_type_node, V4QI_type_node,
10574                                     NULL_TREE);
10575
10576       types[MIPS_VOID_FTYPE_V2HI_V2HI]
10577         = build_function_type_list (void_type_node,
10578                                     V2HI_type_node, V2HI_type_node,
10579                                     NULL_TREE);
10580
10581       types[MIPS_SI_FTYPE_DI_SI]
10582         = build_function_type_list (intSI_type_node,
10583                                     intDI_type_node, intSI_type_node,
10584                                     NULL_TREE);
10585
10586       types[MIPS_DI_FTYPE_DI_SI]
10587         = build_function_type_list (intDI_type_node,
10588                                     intDI_type_node, intSI_type_node,
10589                                     NULL_TREE);
10590
10591       types[MIPS_VOID_FTYPE_SI_SI]
10592         = build_function_type_list (void_type_node,
10593                                     intSI_type_node, intSI_type_node,
10594                                     NULL_TREE);
10595
10596       types[MIPS_SI_FTYPE_PTR_SI]
10597         = build_function_type_list (intSI_type_node,
10598                                     ptr_type_node, intSI_type_node,
10599                                     NULL_TREE);
10600
10601       types[MIPS_SI_FTYPE_VOID]
10602         = build_function_type (intSI_type_node, void_list_node);
10603     }
10604
10605   /* Iterate through all of the bdesc arrays, initializing all of the
10606      builtin functions.  */
10607
10608   offset = 0;
10609   for (m = bdesc_arrays; m < &bdesc_arrays[ARRAY_SIZE (bdesc_arrays)]; m++)
10610     {
10611       if (m->proc == PROCESSOR_MAX || (m->proc == mips_arch))
10612         for (d = m->bdesc; d < &m->bdesc[m->size]; d++)
10613           if ((d->target_flags & target_flags) == d->target_flags)
10614             add_builtin_function (d->name, types[d->function_type],
10615                                   d - m->bdesc + offset,
10616                                   BUILT_IN_MD, NULL, NULL);
10617       offset += m->size;
10618     }
10619 }
10620
10621 /* Expand a MIPS_BUILTIN_DIRECT function.  ICODE is the code of the
10622    .md pattern and ARGLIST is the list of function arguments.  TARGET,
10623    if nonnull, suggests a good place to put the result.
10624    HAS_TARGET indicates the function must return something.  */
10625
10626 static rtx
10627 mips_expand_builtin_direct (enum insn_code icode, rtx target, tree arglist,
10628                             bool has_target)
10629 {
10630   rtx ops[MAX_RECOG_OPERANDS];
10631   int i = 0;
10632
10633   if (has_target)
10634     {
10635       /* We save target to ops[0].  */
10636       ops[0] = mips_prepare_builtin_target (icode, 0, target);
10637       i = 1;
10638     }
10639
10640   /* We need to test if arglist is not zero.  Some instructions have extra
10641      clobber registers.  */
10642   for (; i < insn_data[icode].n_operands && arglist != 0; i++)
10643     ops[i] = mips_prepare_builtin_arg (icode, i, &arglist);
10644
10645   switch (i)
10646     {
10647     case 2:
10648       emit_insn (GEN_FCN (icode) (ops[0], ops[1]));
10649       break;
10650
10651     case 3:
10652       emit_insn (GEN_FCN (icode) (ops[0], ops[1], ops[2]));
10653       break;
10654
10655     case 4:
10656       emit_insn (GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3]));
10657       break;
10658
10659     default:
10660       gcc_unreachable ();
10661     }
10662   return target;
10663 }
10664
10665 /* Expand a __builtin_mips_movt_*_ps() or __builtin_mips_movf_*_ps()
10666    function (TYPE says which).  ARGLIST is the list of arguments to the
10667    function, ICODE is the instruction that should be used to compare
10668    the first two arguments, and COND is the condition it should test.
10669    TARGET, if nonnull, suggests a good place to put the result.  */
10670
10671 static rtx
10672 mips_expand_builtin_movtf (enum mips_builtin_type type,
10673                            enum insn_code icode, enum mips_fp_condition cond,
10674                            rtx target, tree arglist)
10675 {
10676   rtx cmp_result, op0, op1;
10677
10678   cmp_result = mips_prepare_builtin_target (icode, 0, 0);
10679   op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10680   op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10681   emit_insn (GEN_FCN (icode) (cmp_result, op0, op1, GEN_INT (cond)));
10682
10683   icode = CODE_FOR_mips_cond_move_tf_ps;
10684   target = mips_prepare_builtin_target (icode, 0, target);
10685   if (type == MIPS_BUILTIN_MOVT)
10686     {
10687       op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10688       op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10689     }
10690   else
10691     {
10692       op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10693       op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10694     }
10695   emit_insn (gen_mips_cond_move_tf_ps (target, op0, op1, cmp_result));
10696   return target;
10697 }
10698
10699 /* Move VALUE_IF_TRUE into TARGET if CONDITION is true; move VALUE_IF_FALSE
10700    into TARGET otherwise.  Return TARGET.  */
10701
10702 static rtx
10703 mips_builtin_branch_and_move (rtx condition, rtx target,
10704                               rtx value_if_true, rtx value_if_false)
10705 {
10706   rtx true_label, done_label;
10707
10708   true_label = gen_label_rtx ();
10709   done_label = gen_label_rtx ();
10710
10711   /* First assume that CONDITION is false.  */
10712   emit_move_insn (target, value_if_false);
10713
10714   /* Branch to TRUE_LABEL if CONDITION is true and DONE_LABEL otherwise.  */
10715   emit_jump_insn (gen_condjump (condition, true_label));
10716   emit_jump_insn (gen_jump (done_label));
10717   emit_barrier ();
10718
10719   /* Fix TARGET if CONDITION is true.  */
10720   emit_label (true_label);
10721   emit_move_insn (target, value_if_true);
10722
10723   emit_label (done_label);
10724   return target;
10725 }
10726
10727 /* Expand a comparison builtin of type BUILTIN_TYPE.  ICODE is the code
10728    of the comparison instruction and COND is the condition it should test.
10729    ARGLIST is the list of function arguments and TARGET, if nonnull,
10730    suggests a good place to put the boolean result.  */
10731
10732 static rtx
10733 mips_expand_builtin_compare (enum mips_builtin_type builtin_type,
10734                              enum insn_code icode, enum mips_fp_condition cond,
10735                              rtx target, tree arglist)
10736 {
10737   rtx offset, condition, cmp_result, ops[MAX_RECOG_OPERANDS];
10738   int i;
10739
10740   if (target == 0 || GET_MODE (target) != SImode)
10741     target = gen_reg_rtx (SImode);
10742
10743   /* Prepare the operands to the comparison.  */
10744   cmp_result = mips_prepare_builtin_target (icode, 0, 0);
10745   for (i = 1; i < insn_data[icode].n_operands - 1; i++)
10746     ops[i] = mips_prepare_builtin_arg (icode, i, &arglist);
10747
10748   switch (insn_data[icode].n_operands)
10749     {
10750     case 4:
10751       emit_insn (GEN_FCN (icode) (cmp_result, ops[1], ops[2], GEN_INT (cond)));
10752       break;
10753
10754     case 6:
10755       emit_insn (GEN_FCN (icode) (cmp_result, ops[1], ops[2],
10756                                   ops[3], ops[4], GEN_INT (cond)));
10757       break;
10758
10759     default:
10760       gcc_unreachable ();
10761     }
10762
10763   /* If the comparison sets more than one register, we define the result
10764      to be 0 if all registers are false and -1 if all registers are true.
10765      The value of the complete result is indeterminate otherwise.  */
10766   switch (builtin_type)
10767     {
10768     case MIPS_BUILTIN_CMP_ALL:
10769       condition = gen_rtx_NE (VOIDmode, cmp_result, constm1_rtx);
10770       return mips_builtin_branch_and_move (condition, target,
10771                                            const0_rtx, const1_rtx);
10772
10773     case MIPS_BUILTIN_CMP_UPPER:
10774     case MIPS_BUILTIN_CMP_LOWER:
10775       offset = GEN_INT (builtin_type == MIPS_BUILTIN_CMP_UPPER);
10776       condition = gen_single_cc (cmp_result, offset);
10777       return mips_builtin_branch_and_move (condition, target,
10778                                            const1_rtx, const0_rtx);
10779
10780     default:
10781       condition = gen_rtx_NE (VOIDmode, cmp_result, const0_rtx);
10782       return mips_builtin_branch_and_move (condition, target,
10783                                            const1_rtx, const0_rtx);
10784     }
10785 }
10786
10787 /* Expand a bposge builtin of type BUILTIN_TYPE.  TARGET, if nonnull,
10788    suggests a good place to put the boolean result.  */
10789
10790 static rtx
10791 mips_expand_builtin_bposge (enum mips_builtin_type builtin_type, rtx target)
10792 {
10793   rtx condition, cmp_result;
10794   int cmp_value;
10795
10796   if (target == 0 || GET_MODE (target) != SImode)
10797     target = gen_reg_rtx (SImode);
10798
10799   cmp_result = gen_rtx_REG (CCDSPmode, CCDSP_PO_REGNUM);
10800
10801   if (builtin_type == MIPS_BUILTIN_BPOSGE32)
10802     cmp_value = 32;
10803   else
10804     gcc_assert (0);
10805
10806   condition = gen_rtx_GE (VOIDmode, cmp_result, GEN_INT (cmp_value));
10807   return mips_builtin_branch_and_move (condition, target,
10808                                        const1_rtx, const0_rtx);
10809 }
10810 \f
10811 /* Set SYMBOL_REF_FLAGS for the SYMBOL_REF inside RTL, which belongs to DECL.
10812    FIRST is true if this is the first time handling this decl.  */
10813
10814 static void
10815 mips_encode_section_info (tree decl, rtx rtl, int first)
10816 {
10817   default_encode_section_info (decl, rtl, first);
10818
10819   if (TREE_CODE (decl) == FUNCTION_DECL
10820       && lookup_attribute ("long_call", TYPE_ATTRIBUTES (TREE_TYPE (decl))))
10821     {
10822       rtx symbol = XEXP (rtl, 0);
10823       SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LONG_CALL;
10824     }
10825 }
10826
10827 /* Implement TARGET_EXTRA_LIVE_ON_ENTRY.  PIC_FUNCTION_ADDR_REGNUM is live
10828    on entry to a function when generating -mshared abicalls code.  */
10829
10830 static void
10831 mips_extra_live_on_entry (bitmap regs)
10832 {
10833   if (TARGET_ABICALLS && !TARGET_ABSOLUTE_ABICALLS)
10834     bitmap_set_bit (regs, PIC_FUNCTION_ADDR_REGNUM);
10835 }
10836
10837 /* SImode values are represented as sign-extended to DImode.  */
10838
10839 int
10840 mips_mode_rep_extended (enum machine_mode mode, enum machine_mode mode_rep)
10841 {
10842   if (TARGET_64BIT && mode == SImode && mode_rep == DImode)
10843     return SIGN_EXTEND;
10844
10845   return UNKNOWN;
10846 }
10847 \f
10848 #include "gt-mips.h"