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