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 section *mips_select_rtx_section (enum machine_mode, rtx,
 332                                          unsigned HOST_WIDE_INT);
 333 static section *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 calling switch_to_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     switch_to_section (get_named_section (NULL, ".sbss", 0));
5808   else
5809     switch_to_section (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       switch_to_section (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 section *
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       return 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       return 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         return get_named_section (NULL, ".sdata", 0);
7139       else if (flag_pic && symbolic_expression_p (x))
7140         return get_named_section (NULL, ".data.rel.ro", 3);
7141       else
7142         return 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 section *
7155 mips_function_rodata_section (tree decl)
7156 {
7157   if (!TARGET_ABICALLS || TARGET_GPWORD)
7158     return default_function_rodata_section (decl);
7159
7160   if (decl && DECL_SECTION_NAME (decl))
7161     {
7162       const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
7163       if (DECL_ONE_ONLY (decl) && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
7164         {
7165           char *rname = ASTRDUP (name);
7166           rname[14] = 'd';
7167           return get_section (rname, SECTION_LINKONCE | SECTION_WRITE, decl);
7168         }
7169       else if (flag_function_sections && flag_data_sections
7170                && strncmp (name, ".text.", 6) == 0)
7171         {
7172           char *rname = ASTRDUP (name);
7173           memcpy (rname + 1, "data", 4);
7174           return get_section (rname, SECTION_WRITE, decl);
7175         }
7176     }
7177   return data_section;
7178 }
7179
7180 /* Implement TARGET_IN_SMALL_DATA_P.  Return true if it would be safe to
7181    access DECL using %gp_rel(...)($gp).  */
7182
7183 static bool
7184 mips_in_small_data_p (tree decl)
7185 {
7186   HOST_WIDE_INT size;
7187
7188   if (TREE_CODE (decl) == STRING_CST || TREE_CODE (decl) == FUNCTION_DECL)
7189     return false;
7190
7191   /* We don't yet generate small-data references for -mabicalls.  See related
7192      -G handling in override_options.  */
7193   if (TARGET_ABICALLS)
7194     return false;
7195
7196   if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl) != 0)
7197     {
7198       const char *name;
7199
7200       /* Reject anything that isn't in a known small-data section.  */
7201       name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
7202       if (strcmp (name, ".sdata") != 0 && strcmp (name, ".sbss") != 0)
7203         return false;
7204
7205       /* If a symbol is defined externally, the assembler will use the
7206          usual -G rules when deciding how to implement macros.  */
7207       if (TARGET_EXPLICIT_RELOCS || !DECL_EXTERNAL (decl))
7208         return true;
7209     }
7210   else if (TARGET_EMBEDDED_DATA)
7211     {
7212       /* Don't put constants into the small data section: we want them
7213          to be in ROM rather than RAM.  */
7214       if (TREE_CODE (decl) != VAR_DECL)
7215         return false;
7216
7217       if (TREE_READONLY (decl)
7218           && !TREE_SIDE_EFFECTS (decl)
7219           && (!DECL_INITIAL (decl) || TREE_CONSTANT (DECL_INITIAL (decl))))
7220         return false;
7221     }
7222
7223   size = int_size_in_bytes (TREE_TYPE (decl));
7224   return (size > 0 && size <= mips_section_threshold);
7225 }
7226 \f
7227 /* See whether VALTYPE is a record whose fields should be returned in
7228    floating-point registers.  If so, return the number of fields and
7229    list them in FIELDS (which should have two elements).  Return 0
7230    otherwise.
7231
7232    For n32 & n64, a structure with one or two fields is returned in
7233    floating-point registers as long as every field has a floating-point
7234    type.  */
7235
7236 static int
7237 mips_fpr_return_fields (tree valtype, tree *fields)
7238 {
7239   tree field;
7240   int i;
7241
7242   if (!TARGET_NEWABI)
7243     return 0;
7244
7245   if (TREE_CODE (valtype) != RECORD_TYPE)
7246     return 0;
7247
7248   i = 0;
7249   for (field = TYPE_FIELDS (valtype); field != 0; field = TREE_CHAIN (field))
7250     {
7251       if (TREE_CODE (field) != FIELD_DECL)
7252         continue;
7253
7254       if (TREE_CODE (TREE_TYPE (field)) != REAL_TYPE)
7255         return 0;
7256
7257       if (i == 2)
7258         return 0;
7259
7260       fields[i++] = field;
7261     }
7262   return i;
7263 }
7264
7265
7266 /* Implement TARGET_RETURN_IN_MSB.  For n32 & n64, we should return
7267    a value in the most significant part of $2/$3 if:
7268
7269       - the target is big-endian;
7270
7271       - the value has a structure or union type (we generalize this to
7272         cover aggregates from other languages too); and
7273
7274       - the structure is not returned in floating-point registers.  */
7275
7276 static bool
7277 mips_return_in_msb (tree valtype)
7278 {
7279   tree fields[2];
7280
7281   return (TARGET_NEWABI
7282           && TARGET_BIG_ENDIAN
7283           && AGGREGATE_TYPE_P (valtype)
7284           && mips_fpr_return_fields (valtype, fields) == 0);
7285 }
7286
7287
7288 /* Return a composite value in a pair of floating-point registers.
7289    MODE1 and OFFSET1 are the mode and byte offset for the first value,
7290    likewise MODE2 and OFFSET2 for the second.  MODE is the mode of the
7291    complete value.
7292
7293    For n32 & n64, $f0 always holds the first value and $f2 the second.
7294    Otherwise the values are packed together as closely as possible.  */
7295
7296 static rtx
7297 mips_return_fpr_pair (enum machine_mode mode,
7298                       enum machine_mode mode1, HOST_WIDE_INT offset1,
7299                       enum machine_mode mode2, HOST_WIDE_INT offset2)
7300 {
7301   int inc;
7302
7303   inc = (TARGET_NEWABI ? 2 : FP_INC);
7304   return gen_rtx_PARALLEL
7305     (mode,
7306      gen_rtvec (2,
7307                 gen_rtx_EXPR_LIST (VOIDmode,
7308                                    gen_rtx_REG (mode1, FP_RETURN),
7309                                    GEN_INT (offset1)),
7310                 gen_rtx_EXPR_LIST (VOIDmode,
7311                                    gen_rtx_REG (mode2, FP_RETURN + inc),
7312                                    GEN_INT (offset2))));
7313
7314 }
7315
7316
7317 /* Implement FUNCTION_VALUE and LIBCALL_VALUE.  For normal calls,
7318    VALTYPE is the return type and MODE is VOIDmode.  For libcalls,
7319    VALTYPE is null and MODE is the mode of the return value.  */
7320
7321 rtx
7322 mips_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
7323                      enum machine_mode mode)
7324 {
7325   if (valtype)
7326     {
7327       tree fields[2];
7328       int unsignedp;
7329
7330       mode = TYPE_MODE (valtype);
7331       unsignedp = TYPE_UNSIGNED (valtype);
7332
7333       /* Since we define TARGET_PROMOTE_FUNCTION_RETURN that returns
7334          true, we must promote the mode just as PROMOTE_MODE does.  */
7335       mode = promote_mode (valtype, mode, &unsignedp, 1);
7336
7337       /* Handle structures whose fields are returned in $f0/$f2.  */
7338       switch (mips_fpr_return_fields (valtype, fields))
7339         {
7340         case 1:
7341           return gen_rtx_REG (mode, FP_RETURN);
7342
7343         case 2:
7344           return mips_return_fpr_pair (mode,
7345                                        TYPE_MODE (TREE_TYPE (fields[0])),
7346                                        int_byte_position (fields[0]),
7347                                        TYPE_MODE (TREE_TYPE (fields[1])),
7348                                        int_byte_position (fields[1]));
7349         }
7350
7351       /* If a value is passed in the most significant part of a register, see
7352          whether we have to round the mode up to a whole number of words.  */
7353       if (mips_return_in_msb (valtype))
7354         {
7355           HOST_WIDE_INT size = int_size_in_bytes (valtype);
7356           if (size % UNITS_PER_WORD != 0)
7357             {
7358               size += UNITS_PER_WORD - size % UNITS_PER_WORD;
7359               mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
7360             }
7361         }
7362
7363       /* For EABI, the class of return register depends entirely on MODE.
7364          For example, "struct { some_type x; }" and "union { some_type x; }"
7365          are returned in the same way as a bare "some_type" would be.
7366          Other ABIs only use FPRs for scalar, complex or vector types.  */
7367       if (mips_abi != ABI_EABI && !FLOAT_TYPE_P (valtype))
7368         return gen_rtx_REG (mode, GP_RETURN);
7369     }
7370
7371   if ((GET_MODE_CLASS (mode) == MODE_FLOAT
7372        || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
7373       && GET_MODE_SIZE (mode) <= UNITS_PER_HWFPVALUE)
7374     return gen_rtx_REG (mode, FP_RETURN);
7375
7376   /* Handle long doubles for n32 & n64.  */
7377   if (mode == TFmode)
7378     return mips_return_fpr_pair (mode,
7379                                  DImode, 0,
7380                                  DImode, GET_MODE_SIZE (mode) / 2);
7381
7382   if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
7383       && GET_MODE_SIZE (mode) <= UNITS_PER_HWFPVALUE * 2)
7384     return mips_return_fpr_pair (mode,
7385                                  GET_MODE_INNER (mode), 0,
7386                                  GET_MODE_INNER (mode),
7387                                  GET_MODE_SIZE (mode) / 2);
7388
7389   return gen_rtx_REG (mode, GP_RETURN);
7390 }
7391
7392 /* Return nonzero when an argument must be passed by reference.  */
7393
7394 static bool
7395 mips_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
7396                         enum machine_mode mode, tree type,
7397                         bool named ATTRIBUTE_UNUSED)
7398 {
7399   if (mips_abi == ABI_EABI)
7400     {
7401       int size;
7402
7403       /* ??? How should SCmode be handled?  */
7404       if (type == NULL_TREE || mode == DImode || mode == DFmode)
7405         return 0;
7406
7407       size = int_size_in_bytes (type);
7408       return size == -1 || size > UNITS_PER_WORD;
7409     }
7410   else
7411     {
7412       /* If we have a variable-sized parameter, we have no choice.  */
7413       return targetm.calls.must_pass_in_stack (mode, type);
7414     }
7415 }
7416
7417 static bool
7418 mips_callee_copies (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
7419                     enum machine_mode mode ATTRIBUTE_UNUSED,
7420                     tree type ATTRIBUTE_UNUSED, bool named)
7421 {
7422   return mips_abi == ABI_EABI && named;
7423 }
7424
7425 /* Return true if registers of class CLASS cannot change from mode FROM
7426    to mode TO.  */
7427
7428 bool
7429 mips_cannot_change_mode_class (enum machine_mode from,
7430                                enum machine_mode to, enum reg_class class)
7431 {
7432   if (MIN (GET_MODE_SIZE (from), GET_MODE_SIZE (to)) <= UNITS_PER_WORD
7433       && MAX (GET_MODE_SIZE (from), GET_MODE_SIZE (to)) > UNITS_PER_WORD)
7434     {
7435       if (TARGET_BIG_ENDIAN)
7436         {
7437           /* When a multi-word value is stored in paired floating-point
7438              registers, the first register always holds the low word.
7439              We therefore can't allow FPRs to change between single-word
7440              and multi-word modes.  */
7441           if (FP_INC > 1 && reg_classes_intersect_p (FP_REGS, class))
7442             return true;
7443         }
7444       else
7445         {
7446           /* LO_REGNO == HI_REGNO + 1, so if a multi-word value is stored
7447              in LO and HI, the high word always comes first.  We therefore
7448              can't allow values stored in HI to change between single-word
7449              and multi-word modes.
7450              This rule applies to both the original HI/LO pair and the new
7451              DSP accumulators.  */
7452           if (reg_classes_intersect_p (ACC_REGS, class))
7453             return true;
7454         }
7455     }
7456   /* Loading a 32-bit value into a 64-bit floating-point register
7457      will not sign-extend the value, despite what LOAD_EXTEND_OP says.
7458      We can't allow 64-bit float registers to change from SImode to
7459      to a wider mode.  */
7460   if (TARGET_FLOAT64
7461       && from == SImode
7462       && GET_MODE_SIZE (to) >= UNITS_PER_WORD
7463       && reg_classes_intersect_p (FP_REGS, class))
7464     return true;
7465   return false;
7466 }
7467
7468 /* Return true if X should not be moved directly into register $25.
7469    We need this because many versions of GAS will treat "la $25,foo" as
7470    part of a call sequence and so allow a global "foo" to be lazily bound.  */
7471
7472 bool
7473 mips_dangerous_for_la25_p (rtx x)
7474 {
7475   HOST_WIDE_INT offset;
7476
7477   if (TARGET_EXPLICIT_RELOCS)
7478     return false;
7479
7480   mips_split_const (x, &x, &offset);
7481   return global_got_operand (x, VOIDmode);
7482 }
7483
7484 /* Implement PREFERRED_RELOAD_CLASS.  */
7485
7486 enum reg_class
7487 mips_preferred_reload_class (rtx x, enum reg_class class)
7488 {
7489   if (mips_dangerous_for_la25_p (x) && reg_class_subset_p (LEA_REGS, class))
7490     return LEA_REGS;
7491
7492   if (TARGET_HARD_FLOAT
7493       && FLOAT_MODE_P (GET_MODE (x))
7494       && reg_class_subset_p (FP_REGS, class))
7495     return FP_REGS;
7496
7497   if (reg_class_subset_p (GR_REGS, class))
7498     class = GR_REGS;
7499
7500   if (TARGET_MIPS16 && reg_class_subset_p (M16_REGS, class))
7501     class = M16_REGS;
7502
7503   return class;
7504 }
7505
7506 /* This function returns the register class required for a secondary
7507    register when copying between one of the registers in CLASS, and X,
7508    using MODE.  If IN_P is nonzero, the copy is going from X to the
7509    register, otherwise the register is the source.  A return value of
7510    NO_REGS means that no secondary register is required.  */
7511
7512 enum reg_class
7513 mips_secondary_reload_class (enum reg_class class,
7514                              enum machine_mode mode, rtx x, int in_p)
7515 {
7516   enum reg_class gr_regs = TARGET_MIPS16 ? M16_REGS : GR_REGS;
7517   int regno = -1;
7518   int gp_reg_p;
7519
7520   if (REG_P (x)|| GET_CODE (x) == SUBREG)
7521     regno = true_regnum (x);
7522
7523   gp_reg_p = TARGET_MIPS16 ? M16_REG_P (regno) : GP_REG_P (regno);
7524
7525   if (mips_dangerous_for_la25_p (x))
7526     {
7527       gr_regs = LEA_REGS;
7528       if (TEST_HARD_REG_BIT (reg_class_contents[(int) class], 25))
7529         return gr_regs;
7530     }
7531
7532   /* Copying from HI or LO to anywhere other than a general register
7533      requires a general register.
7534      This rule applies to both the original HI/LO pair and the new
7535      DSP accumulators.  */
7536   if (reg_class_subset_p (class, ACC_REGS))
7537     {
7538       if (TARGET_MIPS16 && in_p)
7539         {
7540           /* We can't really copy to HI or LO at all in mips16 mode.  */
7541           return M16_REGS;
7542         }
7543       return gp_reg_p ? NO_REGS : gr_regs;
7544     }
7545   if (ACC_REG_P (regno))
7546     {
7547       if (TARGET_MIPS16 && ! in_p)
7548         {
7549           /* We can't really copy to HI or LO at all in mips16 mode.  */
7550           return M16_REGS;
7551         }
7552       return class == gr_regs ? NO_REGS : gr_regs;
7553     }
7554
7555   /* We can only copy a value to a condition code register from a
7556      floating point register, and even then we require a scratch
7557      floating point register.  We can only copy a value out of a
7558      condition code register into a general register.  */
7559   if (class == ST_REGS)
7560     {
7561       if (in_p)
7562         return FP_REGS;
7563       return gp_reg_p ? NO_REGS : gr_regs;
7564     }
7565   if (ST_REG_P (regno))
7566     {
7567       if (! in_p)
7568         return FP_REGS;
7569       return class == gr_regs ? NO_REGS : gr_regs;
7570     }
7571
7572   if (class == FP_REGS)
7573     {
7574       if (MEM_P (x))
7575         {
7576           /* In this case we can use lwc1, swc1, ldc1 or sdc1.  */
7577           return NO_REGS;
7578         }
7579       else if (CONSTANT_P (x) && GET_MODE_CLASS (mode) == MODE_FLOAT)
7580         {
7581           /* We can use the l.s and l.d macros to load floating-point
7582              constants.  ??? For l.s, we could probably get better
7583              code by returning GR_REGS here.  */
7584           return NO_REGS;
7585         }
7586       else if (gp_reg_p || x == CONST0_RTX (mode))
7587         {
7588           /* In this case we can use mtc1, mfc1, dmtc1 or dmfc1.  */
7589           return NO_REGS;
7590         }
7591       else if (FP_REG_P (regno))
7592         {
7593           /* In this case we can use mov.s or mov.d.  */
7594           return NO_REGS;
7595         }
7596       else
7597         {
7598           /* Otherwise, we need to reload through an integer register.  */
7599           return gr_regs;
7600         }
7601     }
7602
7603   /* In mips16 mode, going between memory and anything but M16_REGS
7604      requires an M16_REG.  */
7605   if (TARGET_MIPS16)
7606     {
7607       if (class != M16_REGS && class != M16_NA_REGS)
7608         {
7609           if (gp_reg_p)
7610             return NO_REGS;
7611           return M16_REGS;
7612         }
7613       if (! gp_reg_p)
7614         {
7615           if (class == M16_REGS || class == M16_NA_REGS)
7616             return NO_REGS;
7617           return M16_REGS;
7618         }
7619     }
7620
7621   return NO_REGS;
7622 }
7623
7624 /* Implement CLASS_MAX_NREGS.
7625
7626    Usually all registers are word-sized.  The only supported exception
7627    is -mgp64 -msingle-float, which has 64-bit words but 32-bit float
7628    registers.  A word-based calculation is correct even in that case,
7629    since -msingle-float disallows multi-FPR values.
7630
7631    The FP status registers are an exception to this rule.  They are always
7632    4 bytes wide as they only hold condition code modes, and CCmode is always
7633    considered to be 4 bytes wide.  */
7634
7635 int
7636 mips_class_max_nregs (enum reg_class class ATTRIBUTE_UNUSED,
7637                       enum machine_mode mode)
7638 {
7639   if (class == ST_REGS)
7640     return (GET_MODE_SIZE (mode) + 3) / 4;
7641   else
7642     return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
7643 }
7644
7645 static bool
7646 mips_valid_pointer_mode (enum machine_mode mode)
7647 {
7648   return (mode == SImode || (TARGET_64BIT && mode == DImode));
7649 }
7650
7651 /* Target hook for vector_mode_supported_p.  */
7652
7653 static bool
7654 mips_vector_mode_supported_p (enum machine_mode mode)
7655 {
7656   switch (mode)
7657     {
7658     case V2SFmode:
7659       return TARGET_PAIRED_SINGLE_FLOAT;
7660
7661     case V2HImode:
7662     case V4QImode:
7663       return TARGET_DSP;
7664
7665     default:
7666       return false;
7667     }
7668 }
7669 \f
7670 /* If we can access small data directly (using gp-relative relocation
7671    operators) return the small data pointer, otherwise return null.
7672
7673    For each mips16 function which refers to GP relative symbols, we
7674    use a pseudo register, initialized at the start of the function, to
7675    hold the $gp value.  */
7676
7677 static rtx
7678 mips16_gp_pseudo_reg (void)
7679 {
7680   if (cfun->machine->mips16_gp_pseudo_rtx == NULL_RTX)
7681     {
7682       rtx unspec;
7683       rtx insn, scan;
7684
7685       cfun->machine->mips16_gp_pseudo_rtx = gen_reg_rtx (Pmode);
7686
7687       /* We want to initialize this to a value which gcc will believe
7688          is constant.  */
7689       start_sequence ();
7690       unspec = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, const0_rtx), UNSPEC_GP);
7691       emit_move_insn (cfun->machine->mips16_gp_pseudo_rtx,
7692                       gen_rtx_CONST (Pmode, unspec));
7693       insn = get_insns ();
7694       end_sequence ();
7695
7696       push_topmost_sequence ();
7697       /* We need to emit the initialization after the FUNCTION_BEG
7698          note, so that it will be integrated.  */
7699       for (scan = get_insns (); scan != NULL_RTX; scan = NEXT_INSN (scan))
7700         if (NOTE_P (scan)
7701             && NOTE_LINE_NUMBER (scan) == NOTE_INSN_FUNCTION_BEG)
7702           break;
7703       if (scan == NULL_RTX)
7704         scan = get_insns ();
7705       insn = emit_insn_after (insn, scan);
7706       pop_topmost_sequence ();
7707     }
7708
7709   return cfun->machine->mips16_gp_pseudo_rtx;
7710 }
7711
7712 /* Write out code to move floating point arguments in or out of
7713    general registers.  Output the instructions to FILE.  FP_CODE is
7714    the code describing which arguments are present (see the comment at
7715    the definition of CUMULATIVE_ARGS in mips.h).  FROM_FP_P is nonzero if
7716    we are copying from the floating point registers.  */
7717
7718 static void
7719 mips16_fp_args (FILE *file, int fp_code, int from_fp_p)
7720 {
7721   const char *s;
7722   int gparg, fparg;
7723   unsigned int f;
7724
7725   /* This code only works for the original 32 bit ABI and the O64 ABI.  */
7726   gcc_assert (TARGET_OLDABI);
7727
7728   if (from_fp_p)
7729     s = "mfc1";
7730   else
7731     s = "mtc1";
7732   gparg = GP_ARG_FIRST;
7733   fparg = FP_ARG_FIRST;
7734   for (f = (unsigned int) fp_code; f != 0; f >>= 2)
7735     {
7736       if ((f & 3) == 1)
7737         {
7738           if ((fparg & 1) != 0)
7739             ++fparg;
7740           fprintf (file, "\t%s\t%s,%s\n", s,
7741                    reg_names[gparg], reg_names[fparg]);
7742         }
7743       else if ((f & 3) == 2)
7744         {
7745           if (TARGET_64BIT)
7746             fprintf (file, "\td%s\t%s,%s\n", s,
7747                      reg_names[gparg], reg_names[fparg]);
7748           else
7749             {
7750               if ((fparg & 1) != 0)
7751                 ++fparg;
7752               if (TARGET_BIG_ENDIAN)
7753                 fprintf (file, "\t%s\t%s,%s\n\t%s\t%s,%s\n", s,
7754                          reg_names[gparg], reg_names[fparg + 1], s,
7755                          reg_names[gparg + 1], reg_names[fparg]);
7756               else
7757                 fprintf (file, "\t%s\t%s,%s\n\t%s\t%s,%s\n", s,
7758                          reg_names[gparg], reg_names[fparg], s,
7759                          reg_names[gparg + 1], reg_names[fparg + 1]);
7760               ++gparg;
7761               ++fparg;
7762             }
7763         }
7764       else
7765         gcc_unreachable ();
7766
7767       ++gparg;
7768       ++fparg;
7769     }
7770 }
7771
7772 /* Build a mips16 function stub.  This is used for functions which
7773    take arguments in the floating point registers.  It is 32 bit code
7774    that moves the floating point args into the general registers, and
7775    then jumps to the 16 bit code.  */
7776
7777 static void
7778 build_mips16_function_stub (FILE *file)
7779 {
7780   const char *fnname;
7781   char *secname, *stubname;
7782   tree stubid, stubdecl;
7783   int need_comma;
7784   unsigned int f;
7785
7786   fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
7787   secname = (char *) alloca (strlen (fnname) + 20);
7788   sprintf (secname, ".mips16.fn.%s", fnname);
7789   stubname = (char *) alloca (strlen (fnname) + 20);
7790   sprintf (stubname, "__fn_stub_%s", fnname);
7791   stubid = get_identifier (stubname);
7792   stubdecl = build_decl (FUNCTION_DECL, stubid,
7793                          build_function_type (void_type_node, NULL_TREE));
7794   DECL_SECTION_NAME (stubdecl) = build_string (strlen (secname), secname);
7795
7796   fprintf (file, "\t# Stub function for %s (", current_function_name ());
7797   need_comma = 0;
7798   for (f = (unsigned int) current_function_args_info.fp_code; f != 0; f >>= 2)
7799     {
7800       fprintf (file, "%s%s",
7801                need_comma ? ", " : "",
7802                (f & 3) == 1 ? "float" : "double");
7803       need_comma = 1;
7804     }
7805   fprintf (file, ")\n");
7806
7807   fprintf (file, "\t.set\tnomips16\n");
7808   switch_to_section (function_section (stubdecl));
7809   ASM_OUTPUT_ALIGN (file, floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT));
7810
7811   /* ??? If FUNCTION_NAME_ALREADY_DECLARED is defined, then we are
7812      within a .ent, and we cannot emit another .ent.  */
7813   if (!FUNCTION_NAME_ALREADY_DECLARED)
7814     {
7815       fputs ("\t.ent\t", file);
7816       assemble_name (file, stubname);
7817       fputs ("\n", file);
7818     }
7819
7820   assemble_name (file, stubname);
7821   fputs (":\n", file);
7822
7823   /* We don't want the assembler to insert any nops here.  */
7824   fprintf (file, "\t.set\tnoreorder\n");
7825
7826   mips16_fp_args (file, current_function_args_info.fp_code, 1);
7827
7828   fprintf (asm_out_file, "\t.set\tnoat\n");
7829   fprintf (asm_out_file, "\tla\t%s,", reg_names[GP_REG_FIRST + 1]);
7830   assemble_name (file, fnname);
7831   fprintf (file, "\n");
7832   fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]);
7833   fprintf (asm_out_file, "\t.set\tat\n");
7834
7835   /* Unfortunately, we can't fill the jump delay slot.  We can't fill
7836      with one of the mfc1 instructions, because the result is not
7837      available for one instruction, so if the very first instruction
7838      in the function refers to the register, it will see the wrong
7839      value.  */
7840   fprintf (file, "\tnop\n");
7841
7842   fprintf (file, "\t.set\treorder\n");
7843
7844   if (!FUNCTION_NAME_ALREADY_DECLARED)
7845     {
7846       fputs ("\t.end\t", file);
7847       assemble_name (file, stubname);
7848       fputs ("\n", file);
7849     }
7850
7851   fprintf (file, "\t.set\tmips16\n");
7852
7853   switch_to_section (function_section (current_function_decl));
7854 }
7855
7856 /* We keep a list of functions for which we have already built stubs
7857    in build_mips16_call_stub.  */
7858
7859 struct mips16_stub
7860 {
7861   struct mips16_stub *next;
7862   char *name;
7863   int fpret;
7864 };
7865
7866 static struct mips16_stub *mips16_stubs;
7867
7868 /* Build a call stub for a mips16 call.  A stub is needed if we are
7869    passing any floating point values which should go into the floating
7870    point registers.  If we are, and the call turns out to be to a 32
7871    bit function, the stub will be used to move the values into the
7872    floating point registers before calling the 32 bit function.  The
7873    linker will magically adjust the function call to either the 16 bit
7874    function or the 32 bit stub, depending upon where the function call
7875    is actually defined.
7876
7877    Similarly, we need a stub if the return value might come back in a
7878    floating point register.
7879
7880    RETVAL is the location of the return value, or null if this is
7881    a call rather than a call_value.  FN is the address of the
7882    function and ARG_SIZE is the size of the arguments.  FP_CODE
7883    is the code built by function_arg.  This function returns a nonzero
7884    value if it builds the call instruction itself.  */
7885
7886 int
7887 build_mips16_call_stub (rtx retval, rtx fn, rtx arg_size, int fp_code)
7888 {
7889   int fpret;
7890   const char *fnname;
7891   char *secname, *stubname;
7892   struct mips16_stub *l;
7893   tree stubid, stubdecl;
7894   int need_comma;
7895   unsigned int f;
7896
7897   /* We don't need to do anything if we aren't in mips16 mode, or if
7898      we were invoked with the -msoft-float option.  */
7899   if (! TARGET_MIPS16 || ! mips16_hard_float)
7900     return 0;
7901
7902   /* Figure out whether the value might come back in a floating point
7903      register.  */
7904   fpret = (retval != 0
7905            && GET_MODE_CLASS (GET_MODE (retval)) == MODE_FLOAT
7906            && GET_MODE_SIZE (GET_MODE (retval)) <= UNITS_PER_FPVALUE);
7907
7908   /* We don't need to do anything if there were no floating point
7909      arguments and the value will not be returned in a floating point
7910      register.  */
7911   if (fp_code == 0 && ! fpret)
7912     return 0;
7913
7914   /* We don't need to do anything if this is a call to a special
7915      mips16 support function.  */
7916   if (GET_CODE (fn) == SYMBOL_REF
7917       && strncmp (XSTR (fn, 0), "__mips16_", 9) == 0)
7918     return 0;
7919
7920   /* This code will only work for o32 and o64 abis.  The other ABI's
7921      require more sophisticated support.  */
7922   gcc_assert (TARGET_OLDABI);
7923
7924   /* We can only handle SFmode and DFmode floating point return
7925      values.  */
7926   if (fpret)
7927     gcc_assert (GET_MODE (retval) == SFmode || GET_MODE (retval) == DFmode);
7928
7929   /* If we're calling via a function pointer, then we must always call
7930      via a stub.  There are magic stubs provided in libgcc.a for each
7931      of the required cases.  Each of them expects the function address
7932      to arrive in register $2.  */
7933
7934   if (GET_CODE (fn) != SYMBOL_REF)
7935     {
7936       char buf[30];
7937       tree id;
7938       rtx stub_fn, insn;
7939
7940       /* ??? If this code is modified to support other ABI's, we need
7941          to handle PARALLEL return values here.  */
7942
7943       sprintf (buf, "__mips16_call_stub_%s%d",
7944                (fpret
7945                 ? (GET_MODE (retval) == SFmode ? "sf_" : "df_")
7946                 : ""),
7947                fp_code);
7948       id = get_identifier (buf);
7949       stub_fn = gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (id));
7950
7951       emit_move_insn (gen_rtx_REG (Pmode, 2), fn);
7952
7953       if (retval == NULL_RTX)
7954         insn = gen_call_internal (stub_fn, arg_size);
7955       else
7956         insn = gen_call_value_internal (retval, stub_fn, arg_size);
7957       insn = emit_call_insn (insn);
7958
7959       /* Put the register usage information on the CALL.  */
7960       CALL_INSN_FUNCTION_USAGE (insn) =
7961         gen_rtx_EXPR_LIST (VOIDmode,
7962                            gen_rtx_USE (VOIDmode, gen_rtx_REG (Pmode, 2)),
7963                            CALL_INSN_FUNCTION_USAGE (insn));
7964
7965       /* If we are handling a floating point return value, we need to
7966          save $18 in the function prologue.  Putting a note on the
7967          call will mean that regs_ever_live[$18] will be true if the
7968          call is not eliminated, and we can check that in the prologue
7969          code.  */
7970       if (fpret)
7971         CALL_INSN_FUNCTION_USAGE (insn) =
7972           gen_rtx_EXPR_LIST (VOIDmode,
7973                              gen_rtx_USE (VOIDmode,
7974                                           gen_rtx_REG (word_mode, 18)),
7975                              CALL_INSN_FUNCTION_USAGE (insn));
7976
7977       /* Return 1 to tell the caller that we've generated the call
7978          insn.  */
7979       return 1;
7980     }
7981
7982   /* We know the function we are going to call.  If we have already
7983      built a stub, we don't need to do anything further.  */
7984
7985   fnname = XSTR (fn, 0);
7986   for (l = mips16_stubs; l != NULL; l = l->next)
7987     if (strcmp (l->name, fnname) == 0)
7988       break;
7989
7990   if (l == NULL)
7991     {
7992       /* Build a special purpose stub.  When the linker sees a
7993          function call in mips16 code, it will check where the target
7994          is defined.  If the target is a 32 bit call, the linker will
7995          search for the section defined here.  It can tell which
7996          symbol this section is associated with by looking at the
7997          relocation information (the name is unreliable, since this
7998          might be a static function).  If such a section is found, the
7999          linker will redirect the call to the start of the magic
8000          section.
8001
8002          If the function does not return a floating point value, the
8003          special stub section is named
8004              .mips16.call.FNNAME
8005
8006          If the function does return a floating point value, the stub
8007          section is named
8008              .mips16.call.fp.FNNAME
8009          */
8010
8011       secname = (char *) alloca (strlen (fnname) + 40);
8012       sprintf (secname, ".mips16.call.%s%s",
8013                fpret ? "fp." : "",
8014                fnname);
8015       stubname = (char *) alloca (strlen (fnname) + 20);
8016       sprintf (stubname, "__call_stub_%s%s",
8017                fpret ? "fp_" : "",
8018                fnname);
8019       stubid = get_identifier (stubname);
8020       stubdecl = build_decl (FUNCTION_DECL, stubid,
8021                              build_function_type (void_type_node, NULL_TREE));
8022       DECL_SECTION_NAME (stubdecl) = build_string (strlen (secname), secname);
8023
8024       fprintf (asm_out_file, "\t# Stub function to call %s%s (",
8025                (fpret
8026                 ? (GET_MODE (retval) == SFmode ? "float " : "double ")
8027                 : ""),
8028                fnname);
8029       need_comma = 0;
8030       for (f = (unsigned int) fp_code; f != 0; f >>= 2)
8031         {
8032           fprintf (asm_out_file, "%s%s",
8033                    need_comma ? ", " : "",
8034                    (f & 3) == 1 ? "float" : "double");
8035           need_comma = 1;
8036         }
8037       fprintf (asm_out_file, ")\n");
8038
8039       fprintf (asm_out_file, "\t.set\tnomips16\n");
8040       assemble_start_function (stubdecl, stubname);
8041
8042       if (!FUNCTION_NAME_ALREADY_DECLARED)
8043         {
8044           fputs ("\t.ent\t", asm_out_file);
8045           assemble_name (asm_out_file, stubname);
8046           fputs ("\n", asm_out_file);
8047
8048           assemble_name (asm_out_file, stubname);
8049           fputs (":\n", asm_out_file);
8050         }
8051
8052       /* We build the stub code by hand.  That's the only way we can
8053          do it, since we can't generate 32 bit code during a 16 bit
8054          compilation.  */
8055
8056       /* We don't want the assembler to insert any nops here.  */
8057       fprintf (asm_out_file, "\t.set\tnoreorder\n");
8058
8059       mips16_fp_args (asm_out_file, fp_code, 0);
8060
8061       if (! fpret)
8062         {
8063           fprintf (asm_out_file, "\t.set\tnoat\n");
8064           fprintf (asm_out_file, "\tla\t%s,%s\n", reg_names[GP_REG_FIRST + 1],
8065                    fnname);
8066           fprintf (asm_out_file, "\tjr\t%s\n", reg_names[GP_REG_FIRST + 1]);
8067           fprintf (asm_out_file, "\t.set\tat\n");
8068           /* Unfortunately, we can't fill the jump delay slot.  We
8069              can't fill with one of the mtc1 instructions, because the
8070              result is not available for one instruction, so if the
8071              very first instruction in the function refers to the
8072              register, it will see the wrong value.  */
8073           fprintf (asm_out_file, "\tnop\n");
8074         }
8075       else
8076         {
8077           fprintf (asm_out_file, "\tmove\t%s,%s\n",
8078                    reg_names[GP_REG_FIRST + 18], reg_names[GP_REG_FIRST + 31]);
8079           fprintf (asm_out_file, "\tjal\t%s\n", fnname);
8080           /* As above, we can't fill the delay slot.  */
8081           fprintf (asm_out_file, "\tnop\n");
8082           if (GET_MODE (retval) == SFmode)
8083             fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8084                      reg_names[GP_REG_FIRST + 2], reg_names[FP_REG_FIRST + 0]);
8085           else
8086             {
8087               if (TARGET_BIG_ENDIAN)
8088                 {
8089                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8090                            reg_names[GP_REG_FIRST + 2],
8091                            reg_names[FP_REG_FIRST + 1]);
8092                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8093                            reg_names[GP_REG_FIRST + 3],
8094                            reg_names[FP_REG_FIRST + 0]);
8095                 }
8096               else
8097                 {
8098                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8099                            reg_names[GP_REG_FIRST + 2],
8100                            reg_names[FP_REG_FIRST + 0]);
8101                   fprintf (asm_out_file, "\tmfc1\t%s,%s\n",
8102                            reg_names[GP_REG_FIRST + 3],
8103                            reg_names[FP_REG_FIRST + 1]);
8104                 }
8105             }
8106           fprintf (asm_out_file, "\tj\t%s\n", reg_names[GP_REG_FIRST + 18]);
8107           /* As above, we can't fill the delay slot.  */
8108           fprintf (asm_out_file, "\tnop\n");
8109         }
8110
8111       fprintf (asm_out_file, "\t.set\treorder\n");
8112
8113 #ifdef ASM_DECLARE_FUNCTION_SIZE
8114       ASM_DECLARE_FUNCTION_SIZE (asm_out_file, stubname, stubdecl);
8115 #endif
8116
8117       if (!FUNCTION_NAME_ALREADY_DECLARED)
8118         {
8119           fputs ("\t.end\t", asm_out_file);
8120           assemble_name (asm_out_file, stubname);
8121           fputs ("\n", asm_out_file);
8122         }
8123
8124       fprintf (asm_out_file, "\t.set\tmips16\n");
8125
8126       /* Record this stub.  */
8127       l = (struct mips16_stub *) xmalloc (sizeof *l);
8128       l->name = xstrdup (fnname);
8129       l->fpret = fpret;
8130       l->next = mips16_stubs;
8131       mips16_stubs = l;
8132     }
8133
8134   /* If we expect a floating point return value, but we've built a
8135      stub which does not expect one, then we're in trouble.  We can't
8136      use the existing stub, because it won't handle the floating point
8137      value.  We can't build a new stub, because the linker won't know
8138      which stub to use for the various calls in this object file.
8139      Fortunately, this case is illegal, since it means that a function
8140      was declared in two different ways in a single compilation.  */
8141   if (fpret && ! l->fpret)
8142     error ("cannot handle inconsistent calls to %qs", fnname);
8143
8144   /* If we are calling a stub which handles a floating point return
8145      value, we need to arrange to save $18 in the prologue.  We do
8146      this by marking the function call as using the register.  The
8147      prologue will later see that it is used, and emit code to save
8148      it.  */
8149
8150   if (l->fpret)
8151     {
8152       rtx insn;
8153
8154       if (retval == NULL_RTX)
8155         insn = gen_call_internal (fn, arg_size);
8156       else
8157         insn = gen_call_value_internal (retval, fn, arg_size);
8158       insn = emit_call_insn (insn);
8159
8160       CALL_INSN_FUNCTION_USAGE (insn) =
8161         gen_rtx_EXPR_LIST (VOIDmode,
8162                            gen_rtx_USE (VOIDmode, gen_rtx_REG (word_mode, 18)),
8163                            CALL_INSN_FUNCTION_USAGE (insn));
8164
8165       /* Return 1 to tell the caller that we've generated the call
8166          insn.  */
8167       return 1;
8168     }
8169
8170   /* Return 0 to let the caller generate the call insn.  */
8171   return 0;
8172 }
8173
8174 /* An entry in the mips16 constant pool.  VALUE is the pool constant,
8175    MODE is its mode, and LABEL is the CODE_LABEL associated with it.  */
8176
8177 struct mips16_constant {
8178   struct mips16_constant *next;
8179   rtx value;
8180   rtx label;
8181   enum machine_mode mode;
8182 };
8183
8184 /* Information about an incomplete mips16 constant pool.  FIRST is the
8185    first constant, HIGHEST_ADDRESS is the highest address that the first
8186    byte of the pool can have, and INSN_ADDRESS is the current instruction
8187    address.  */
8188
8189 struct mips16_constant_pool {
8190   struct mips16_constant *first;
8191   int highest_address;
8192   int insn_address;
8193 };
8194
8195 /* Add constant VALUE to POOL and return its label.  MODE is the
8196    value's mode (used for CONST_INTs, etc.).  */
8197
8198 static rtx
8199 add_constant (struct mips16_constant_pool *pool,
8200               rtx value, enum machine_mode mode)
8201 {
8202   struct mips16_constant **p, *c;
8203   bool first_of_size_p;
8204
8205   /* See whether the constant is already in the pool.  If so, return the
8206      existing label, otherwise leave P pointing to the place where the
8207      constant should be added.
8208
8209      Keep the pool sorted in increasing order of mode size so that we can
8210      reduce the number of alignments needed.  */
8211   first_of_size_p = true;
8212   for (p = &pool->first; *p != 0; p = &(*p)->next)
8213     {
8214       if (mode == (*p)->mode && rtx_equal_p (value, (*p)->value))
8215         return (*p)->label;
8216       if (GET_MODE_SIZE (mode) < GET_MODE_SIZE ((*p)->mode))
8217         break;
8218       if (GET_MODE_SIZE (mode) == GET_MODE_SIZE ((*p)->mode))
8219         first_of_size_p = false;
8220     }
8221
8222   /* In the worst case, the constant needed by the earliest instruction
8223      will end up at the end of the pool.  The entire pool must then be
8224      accessible from that instruction.
8225
8226      When adding the first constant, set the pool's highest address to
8227      the address of the first out-of-range byte.  Adjust this address
8228      downwards each time a new constant is added.  */
8229   if (pool->first == 0)
8230     /* For pc-relative lw, addiu and daddiu instructions, the base PC value
8231        is the address of the instruction with the lowest two bits clear.
8232        The base PC value for ld has the lowest three bits clear.  Assume
8233        the worst case here.  */
8234     pool->highest_address = pool->insn_address - (UNITS_PER_WORD - 2) + 0x8000;
8235   pool->highest_address -= GET_MODE_SIZE (mode);
8236   if (first_of_size_p)
8237     /* Take into account the worst possible padding due to alignment.  */
8238     pool->highest_address -= GET_MODE_SIZE (mode) - 1;
8239
8240   /* Create a new entry.  */
8241   c = (struct mips16_constant *) xmalloc (sizeof *c);
8242   c->value = value;
8243   c->mode = mode;
8244   c->label = gen_label_rtx ();
8245   c->next = *p;
8246   *p = c;
8247
8248   return c->label;
8249 }
8250
8251 /* Output constant VALUE after instruction INSN and return the last
8252    instruction emitted.  MODE is the mode of the constant.  */
8253
8254 static rtx
8255 dump_constants_1 (enum machine_mode mode, rtx value, rtx insn)
8256 {
8257   switch (GET_MODE_CLASS (mode))
8258     {
8259     case MODE_INT:
8260       {
8261         rtx size = GEN_INT (GET_MODE_SIZE (mode));
8262         return emit_insn_after (gen_consttable_int (value, size), insn);
8263       }
8264
8265     case MODE_FLOAT:
8266       return emit_insn_after (gen_consttable_float (value), insn);
8267
8268     case MODE_VECTOR_FLOAT:
8269     case MODE_VECTOR_INT:
8270       {
8271         int i;
8272         for (i = 0; i < CONST_VECTOR_NUNITS (value); i++)
8273           insn = dump_constants_1 (GET_MODE_INNER (mode),
8274                                    CONST_VECTOR_ELT (value, i), insn);
8275         return insn;
8276       }
8277
8278     default:
8279       gcc_unreachable ();
8280     }
8281 }
8282
8283
8284 /* Dump out the constants in CONSTANTS after INSN.  */
8285
8286 static void
8287 dump_constants (struct mips16_constant *constants, rtx insn)
8288 {
8289   struct mips16_constant *c, *next;
8290   int align;
8291
8292   align = 0;
8293   for (c = constants; c != NULL; c = next)
8294     {
8295       /* If necessary, increase the alignment of PC.  */
8296       if (align < GET_MODE_SIZE (c->mode))
8297         {
8298           int align_log = floor_log2 (GET_MODE_SIZE (c->mode));
8299           insn = emit_insn_after (gen_align (GEN_INT (align_log)), insn);
8300         }
8301       align = GET_MODE_SIZE (c->mode);
8302
8303       insn = emit_label_after (c->label, insn);
8304       insn = dump_constants_1 (c->mode, c->value, insn);
8305
8306       next = c->next;
8307       free (c);
8308     }
8309
8310   emit_barrier_after (insn);
8311 }
8312
8313 /* Return the length of instruction INSN.  */
8314
8315 static int
8316 mips16_insn_length (rtx insn)
8317 {
8318   if (JUMP_P (insn))
8319     {
8320       rtx body = PATTERN (insn);
8321       if (GET_CODE (body) == ADDR_VEC)
8322         return GET_MODE_SIZE (GET_MODE (body)) * XVECLEN (body, 0);
8323       if (GET_CODE (body) == ADDR_DIFF_VEC)
8324         return GET_MODE_SIZE (GET_MODE (body)) * XVECLEN (body, 1);
8325     }
8326   return get_attr_length (insn);
8327 }
8328
8329 /* Rewrite *X so that constant pool references refer to the constant's
8330    label instead.  DATA points to the constant pool structure.  */
8331
8332 static int
8333 mips16_rewrite_pool_refs (rtx *x, void *data)
8334 {
8335   struct mips16_constant_pool *pool = data;
8336   if (GET_CODE (*x) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (*x))
8337     *x = gen_rtx_LABEL_REF (Pmode, add_constant (pool,
8338                                                  get_pool_constant (*x),
8339                                                  get_pool_mode (*x)));
8340   return 0;
8341 }
8342
8343 /* Build MIPS16 constant pools.  */
8344
8345 static void
8346 mips16_lay_out_constants (void)
8347 {
8348   struct mips16_constant_pool pool;
8349   rtx insn, barrier;
8350
8351   barrier = 0;
8352   memset (&pool, 0, sizeof (pool));
8353   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
8354     {
8355       /* Rewrite constant pool references in INSN.  */
8356       if (INSN_P (insn))
8357         for_each_rtx (&PATTERN (insn), mips16_rewrite_pool_refs, &pool);
8358
8359       pool.insn_address += mips16_insn_length (insn);
8360
8361       if (pool.first != NULL)
8362         {
8363           /* If there are no natural barriers between the first user of
8364              the pool and the highest acceptable address, we'll need to
8365              create a new instruction to jump around the constant pool.
8366              In the worst case, this instruction will be 4 bytes long.
8367
8368              If it's too late to do this transformation after INSN,
8369              do it immediately before INSN.  */
8370           if (barrier == 0 && pool.insn_address + 4 > pool.highest_address)
8371             {
8372               rtx label, jump;
8373
8374               label = gen_label_rtx ();
8375
8376               jump = emit_jump_insn_before (gen_jump (label), insn);
8377               JUMP_LABEL (jump) = label;
8378               LABEL_NUSES (label) = 1;
8379               barrier = emit_barrier_after (jump);
8380
8381               emit_label_after (label, barrier);
8382               pool.insn_address += 4;
8383             }
8384
8385           /* See whether the constant pool is now out of range of the first
8386              user.  If so, output the constants after the previous barrier.
8387              Note that any instructions between BARRIER and INSN (inclusive)
8388              will use negative offsets to refer to the pool.  */
8389           if (pool.insn_address > pool.highest_address)
8390             {
8391               dump_constants (pool.first, barrier);
8392               pool.first = NULL;
8393               barrier = 0;
8394             }
8395           else if (BARRIER_P (insn))
8396             barrier = insn;
8397         }
8398     }
8399   dump_constants (pool.first, get_last_insn ());
8400 }
8401 \f
8402 /* A temporary variable used by for_each_rtx callbacks, etc.  */
8403 static rtx mips_sim_insn;
8404
8405 /* A structure representing the state of the processor pipeline.
8406    Used by the mips_sim_* family of functions.  */
8407 struct mips_sim {
8408   /* The maximum number of instructions that can be issued in a cycle.
8409      (Caches mips_issue_rate.)  */
8410   unsigned int issue_rate;
8411
8412   /* The current simulation time.  */
8413   unsigned int time;
8414
8415   /* How many more instructions can be issued in the current cycle.  */
8416   unsigned int insns_left;
8417
8418   /* LAST_SET[X].INSN is the last instruction to set register X.
8419      LAST_SET[X].TIME is the time at which that instruction was issued.
8420      INSN is null if no instruction has yet set register X.  */
8421   struct {
8422     rtx insn;
8423     unsigned int time;
8424   } last_set[FIRST_PSEUDO_REGISTER];
8425
8426   /* The pipeline's current DFA state.  */
8427   state_t dfa_state;
8428 };
8429
8430 /* Reset STATE to the initial simulation state.  */
8431
8432 static void
8433 mips_sim_reset (struct mips_sim *state)
8434 {
8435   state->time = 0;
8436   state->insns_left = state->issue_rate;
8437   memset (&state->last_set, 0, sizeof (state->last_set));
8438   state_reset (state->dfa_state);
8439 }
8440
8441 /* Initialize STATE before its first use.  DFA_STATE points to an
8442    allocated but uninitialized DFA state.  */
8443
8444 static void
8445 mips_sim_init (struct mips_sim *state, state_t dfa_state)
8446 {
8447   state->issue_rate = mips_issue_rate ();
8448   state->dfa_state = dfa_state;
8449   mips_sim_reset (state);
8450 }
8451
8452 /* Advance STATE by one clock cycle.  */
8453
8454 static void
8455 mips_sim_next_cycle (struct mips_sim *state)
8456 {
8457   state->time++;
8458   state->insns_left = state->issue_rate;
8459   state_transition (state->dfa_state, 0);
8460 }
8461
8462 /* Advance simulation state STATE until instruction INSN can read
8463    register REG.  */
8464
8465 static void
8466 mips_sim_wait_reg (struct mips_sim *state, rtx insn, rtx reg)
8467 {
8468   unsigned int i;
8469
8470   for (i = 0; i < HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)); i++)
8471     if (state->last_set[REGNO (reg) + i].insn != 0)
8472       {
8473         unsigned int t;
8474
8475         t = state->last_set[REGNO (reg) + i].time;
8476         t += insn_latency (state->last_set[REGNO (reg) + i].insn, insn);
8477         while (state->time < t)
8478           mips_sim_next_cycle (state);
8479     }
8480 }
8481
8482 /* A for_each_rtx callback.  If *X is a register, advance simulation state
8483    DATA until mips_sim_insn can read the register's value.  */
8484
8485 static int
8486 mips_sim_wait_regs_2 (rtx *x, void *data)
8487 {
8488   if (REG_P (*x))
8489     mips_sim_wait_reg (data, mips_sim_insn, *x);
8490   return 0;
8491 }
8492
8493 /* Call mips_sim_wait_regs_2 (R, DATA) for each register R mentioned in *X.  */
8494
8495 static void
8496 mips_sim_wait_regs_1 (rtx *x, void *data)
8497 {
8498   for_each_rtx (x, mips_sim_wait_regs_2, data);
8499 }
8500
8501 /* Advance simulation state STATE until all of INSN's register
8502    dependencies are satisfied.  */
8503
8504 static void
8505 mips_sim_wait_regs (struct mips_sim *state, rtx insn)
8506 {
8507   mips_sim_insn = insn;
8508   note_uses (&PATTERN (insn), mips_sim_wait_regs_1, state);
8509 }
8510
8511 /* Advance simulation state STATE until the units required by
8512    instruction INSN are available.  */
8513
8514 static void
8515 mips_sim_wait_units (struct mips_sim *state, rtx insn)
8516 {
8517   state_t tmp_state;
8518
8519   tmp_state = alloca (state_size ());
8520   while (state->insns_left == 0
8521          || (memcpy (tmp_state, state->dfa_state, state_size ()),
8522              state_transition (tmp_state, insn) >= 0))
8523     mips_sim_next_cycle (state);
8524 }
8525
8526 /* Advance simulation state STATE until INSN is ready to issue.  */
8527
8528 static void
8529 mips_sim_wait_insn (struct mips_sim *state, rtx insn)
8530 {
8531   mips_sim_wait_regs (state, insn);
8532   mips_sim_wait_units (state, insn);
8533 }
8534
8535 /* mips_sim_insn has just set X.  Update the LAST_SET array
8536    in simulation state DATA.  */
8537
8538 static void
8539 mips_sim_record_set (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
8540 {
8541   struct mips_sim *state;
8542   unsigned int i;
8543
8544   state = data;
8545   if (REG_P (x))
8546     for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
8547       {
8548         state->last_set[REGNO (x) + i].insn = mips_sim_insn;
8549         state->last_set[REGNO (x) + i].time = state->time;
8550       }
8551 }
8552
8553 /* Issue instruction INSN in scheduler state STATE.  Assume that INSN
8554    can issue immediately (i.e., that mips_sim_wait_insn has already
8555    been called).  */
8556
8557 static void
8558 mips_sim_issue_insn (struct mips_sim *state, rtx insn)
8559 {
8560   state_transition (state->dfa_state, insn);
8561   state->insns_left--;
8562
8563   mips_sim_insn = insn;
8564   note_stores (PATTERN (insn), mips_sim_record_set, state);
8565 }
8566
8567 /* Simulate issuing a NOP in state STATE.  */
8568
8569 static void
8570 mips_sim_issue_nop (struct mips_sim *state)
8571 {
8572   if (state->insns_left == 0)
8573     mips_sim_next_cycle (state);
8574   state->insns_left--;
8575 }
8576
8577 /* Update simulation state STATE so that it's ready to accept the instruction
8578    after INSN.  INSN should be part of the main rtl chain, not a member of a
8579    SEQUENCE.  */
8580
8581 static void
8582 mips_sim_finish_insn (struct mips_sim *state, rtx insn)
8583 {
8584   /* If INSN is a jump with an implicit delay slot, simulate a nop.  */
8585   if (JUMP_P (insn))
8586     mips_sim_issue_nop (state);
8587
8588   switch (GET_CODE (SEQ_BEGIN (insn)))
8589     {
8590     case CODE_LABEL:
8591     case CALL_INSN:
8592       /* We can't predict the processor state after a call or label.  */
8593       mips_sim_reset (state);
8594       break;
8595
8596     case JUMP_INSN:
8597       /* The delay slots of branch likely instructions are only executed
8598          when the branch is taken.  Therefore, if the caller has simulated
8599          the delay slot instruction, STATE does not really reflect the state
8600          of the pipeline for the instruction after the delay slot.  Also,
8601          branch likely instructions tend to incur a penalty when not taken,
8602          so there will probably be an extra delay between the branch and
8603          the instruction after the delay slot.  */
8604       if (INSN_ANNULLED_BRANCH_P (SEQ_BEGIN (insn)))
8605         mips_sim_reset (state);
8606       break;
8607
8608     default:
8609       break;
8610     }
8611 }
8612 \f
8613 /* The VR4130 pipeline issues aligned pairs of instructions together,
8614    but it stalls the second instruction if it depends on the first.
8615    In order to cut down the amount of logic required, this dependence
8616    check is not based on a full instruction decode.  Instead, any non-SPECIAL
8617    instruction is assumed to modify the register specified by bits 20-16
8618    (which is usually the "rt" field).
8619
8620    In beq, beql, bne and bnel instructions, the rt field is actually an
8621    input, so we can end up with a false dependence between the branch
8622    and its delay slot.  If this situation occurs in instruction INSN,
8623    try to avoid it by swapping rs and rt.  */
8624
8625 static void
8626 vr4130_avoid_branch_rt_conflict (rtx insn)
8627 {
8628   rtx first, second;
8629
8630   first = SEQ_BEGIN (insn);
8631   second = SEQ_END (insn);
8632   if (JUMP_P (first)
8633       && NONJUMP_INSN_P (second)
8634       && GET_CODE (PATTERN (first)) == SET
8635       && GET_CODE (SET_DEST (PATTERN (first))) == PC
8636       && GET_CODE (SET_SRC (PATTERN (first))) == IF_THEN_ELSE)
8637     {
8638       /* Check for the right kind of condition.  */
8639       rtx cond = XEXP (SET_SRC (PATTERN (first)), 0);
8640       if ((GET_CODE (cond) == EQ || GET_CODE (cond) == NE)
8641           && REG_P (XEXP (cond, 0))
8642           && REG_P (XEXP (cond, 1))
8643           && reg_referenced_p (XEXP (cond, 1), PATTERN (second))
8644           && !reg_referenced_p (XEXP (cond, 0), PATTERN (second)))
8645         {
8646           /* SECOND mentions the rt register but not the rs register.  */
8647           rtx tmp = XEXP (cond, 0);
8648           XEXP (cond, 0) = XEXP (cond, 1);
8649           XEXP (cond, 1) = tmp;
8650         }
8651     }
8652 }
8653
8654 /* Implement -mvr4130-align.  Go through each basic block and simulate the
8655    processor pipeline.  If we find that a pair of instructions could execute
8656    in parallel, and the first of those instruction is not 8-byte aligned,
8657    insert a nop to make it aligned.  */
8658
8659 static void
8660 vr4130_align_insns (void)
8661 {
8662   struct mips_sim state;
8663   rtx insn, subinsn, last, last2, next;
8664   bool aligned_p;
8665
8666   dfa_start ();
8667
8668   /* LAST is the last instruction before INSN to have a nonzero length.
8669      LAST2 is the last such instruction before LAST.  */
8670   last = 0;
8671   last2 = 0;
8672
8673   /* ALIGNED_P is true if INSN is known to be at an aligned address.  */
8674   aligned_p = true;
8675
8676   mips_sim_init (&state, alloca (state_size ()));
8677   for (insn = get_insns (); insn != 0; insn = next)
8678     {
8679       unsigned int length;
8680
8681       next = NEXT_INSN (insn);
8682
8683       /* See the comment above vr4130_avoid_branch_rt_conflict for details.
8684          This isn't really related to the alignment pass, but we do it on
8685          the fly to avoid a separate instruction walk.  */
8686       vr4130_avoid_branch_rt_conflict (insn);
8687
8688       if (USEFUL_INSN_P (insn))
8689         FOR_EACH_SUBINSN (subinsn, insn)
8690           {
8691             mips_sim_wait_insn (&state, subinsn);
8692
8693             /* If we want this instruction to issue in parallel with the
8694                previous one, make sure that the previous instruction is
8695                aligned.  There are several reasons why this isn't worthwhile
8696                when the second instruction is a call:
8697
8698                   - Calls are less likely to be performance critical,
8699                   - There's a good chance that the delay slot can execute
8700                     in parallel with the call.
8701                   - The return address would then be unaligned.
8702
8703                In general, if we're going to insert a nop between instructions
8704                X and Y, it's better to insert it immediately after X.  That
8705                way, if the nop makes Y aligned, it will also align any labels
8706                between X and Y.  */
8707             if (state.insns_left != state.issue_rate
8708                 && !CALL_P (subinsn))
8709               {
8710                 if (subinsn == SEQ_BEGIN (insn) && aligned_p)
8711                   {
8712                     /* SUBINSN is the first instruction in INSN and INSN is
8713                        aligned.  We want to align the previous instruction
8714                        instead, so insert a nop between LAST2 and LAST.
8715
8716                        Note that LAST could be either a single instruction
8717                        or a branch with a delay slot.  In the latter case,
8718                        LAST, like INSN, is already aligned, but the delay
8719                        slot must have some extra delay that stops it from
8720                        issuing at the same time as the branch.  We therefore
8721                        insert a nop before the branch in order to align its
8722                        delay slot.  */
8723                     emit_insn_after (gen_nop (), last2);
8724                     aligned_p = false;
8725                   }
8726                 else if (subinsn != SEQ_BEGIN (insn) && !aligned_p)
8727                   {
8728                     /* SUBINSN is the delay slot of INSN, but INSN is
8729                        currently unaligned.  Insert a nop between
8730                        LAST and INSN to align it.  */
8731                     emit_insn_after (gen_nop (), last);
8732                     aligned_p = true;
8733                   }
8734               }
8735             mips_sim_issue_insn (&state, subinsn);
8736           }
8737       mips_sim_finish_insn (&state, insn);
8738
8739       /* Update LAST, LAST2 and ALIGNED_P for the next instruction.  */
8740       length = get_attr_length (insn);
8741       if (length > 0)
8742         {
8743           /* If the instruction is an asm statement or multi-instruction
8744              mips.md patern, the length is only an estimate.  Insert an
8745              8 byte alignment after it so that the following instructions
8746              can be handled correctly.  */
8747           if (NONJUMP_INSN_P (SEQ_BEGIN (insn))
8748               && (recog_memoized (insn) < 0 || length >= 8))
8749             {
8750               next = emit_insn_after (gen_align (GEN_INT (3)), insn);
8751               next = NEXT_INSN (next);
8752               mips_sim_next_cycle (&state);
8753               aligned_p = true;
8754             }
8755           else if (length & 4)
8756             aligned_p = !aligned_p;
8757           last2 = last;
8758           last = insn;
8759         }
8760
8761       /* See whether INSN is an aligned label.  */
8762       if (LABEL_P (insn) && label_to_alignment (insn) >= 3)
8763         aligned_p = true;
8764     }
8765   dfa_finish ();
8766 }
8767 \f
8768 /* Subroutine of mips_reorg.  If there is a hazard between INSN
8769    and a previous instruction, avoid it by inserting nops after
8770    instruction AFTER.
8771
8772    *DELAYED_REG and *HILO_DELAY describe the hazards that apply at
8773    this point.  If *DELAYED_REG is non-null, INSN must wait a cycle
8774    before using the value of that register.  *HILO_DELAY counts the
8775    number of instructions since the last hilo hazard (that is,
8776    the number of instructions since the last mflo or mfhi).
8777
8778    After inserting nops for INSN, update *DELAYED_REG and *HILO_DELAY
8779    for the next instruction.
8780
8781    LO_REG is an rtx for the LO register, used in dependence checking.  */
8782
8783 static void
8784 mips_avoid_hazard (rtx after, rtx insn, int *hilo_delay,
8785                    rtx *delayed_reg, rtx lo_reg)
8786 {
8787   rtx pattern, set;
8788   int nops, ninsns;
8789
8790   if (!INSN_P (insn))
8791     return;
8792
8793   pattern = PATTERN (insn);
8794
8795   /* Do not put the whole function in .set noreorder if it contains
8796      an asm statement.  We don't know whether there will be hazards
8797      between the asm statement and the gcc-generated code.  */
8798   if (GET_CODE (pattern) == ASM_INPUT || asm_noperands (pattern) >= 0)
8799     cfun->machine->all_noreorder_p = false;
8800
8801   /* Ignore zero-length instructions (barriers and the like).  */
8802   ninsns = get_attr_length (insn) / 4;
8803   if (ninsns == 0)
8804     return;
8805
8806   /* Work out how many nops are needed.  Note that we only care about
8807      registers that are explicitly mentioned in the instruction's pattern.
8808      It doesn't matter that calls use the argument registers or that they
8809      clobber hi and lo.  */
8810   if (*hilo_delay < 2 && reg_set_p (lo_reg, pattern))
8811     nops = 2 - *hilo_delay;
8812   else if (*delayed_reg != 0 && reg_referenced_p (*delayed_reg, pattern))
8813     nops = 1;
8814   else
8815     nops = 0;
8816
8817   /* Insert the nops between this instruction and the previous one.
8818      Each new nop takes us further from the last hilo hazard.  */
8819   *hilo_delay += nops;
8820   while (nops-- > 0)
8821     emit_insn_after (gen_hazard_nop (), after);
8822
8823   /* Set up the state for the next instruction.  */
8824   *hilo_delay += ninsns;
8825   *delayed_reg = 0;
8826   if (INSN_CODE (insn) >= 0)
8827     switch (get_attr_hazard (insn))
8828       {
8829       case HAZARD_NONE:
8830         break;
8831
8832       case HAZARD_HILO:
8833         *hilo_delay = 0;
8834         break;
8835
8836       case HAZARD_DELAY:
8837         set = single_set (insn);
8838         gcc_assert (set != 0);
8839         *delayed_reg = SET_DEST (set);
8840         break;
8841       }
8842 }
8843
8844
8845 /* Go through the instruction stream and insert nops where necessary.
8846    See if the whole function can then be put into .set noreorder &
8847    .set nomacro.  */
8848
8849 static void
8850 mips_avoid_hazards (void)
8851 {
8852   rtx insn, last_insn, lo_reg, delayed_reg;
8853   int hilo_delay, i;
8854
8855   /* Force all instructions to be split into their final form.  */
8856   split_all_insns_noflow ();
8857
8858   /* Recalculate instruction lengths without taking nops into account.  */
8859   cfun->machine->ignore_hazard_length_p = true;
8860   shorten_branches (get_insns ());
8861
8862   cfun->machine->all_noreorder_p = true;
8863
8864   /* Profiled functions can't be all noreorder because the profiler
8865      support uses assembler macros.  */
8866   if (current_function_profile)
8867     cfun->machine->all_noreorder_p = false;
8868
8869   /* Code compiled with -mfix-vr4120 can't be all noreorder because
8870      we rely on the assembler to work around some errata.  */
8871   if (TARGET_FIX_VR4120)
8872     cfun->machine->all_noreorder_p = false;
8873
8874   /* The same is true for -mfix-vr4130 if we might generate mflo or
8875      mfhi instructions.  Note that we avoid using mflo and mfhi if
8876      the VR4130 macc and dmacc instructions are available instead;
8877      see the *mfhilo_{si,di}_macc patterns.  */
8878   if (TARGET_FIX_VR4130 && !ISA_HAS_MACCHI)
8879     cfun->machine->all_noreorder_p = false;
8880
8881   last_insn = 0;
8882   hilo_delay = 2;
8883   delayed_reg = 0;
8884   lo_reg = gen_rtx_REG (SImode, LO_REGNUM);
8885
8886   for (insn = get_insns (); insn != 0; insn = NEXT_INSN (insn))
8887     if (INSN_P (insn))
8888       {
8889         if (GET_CODE (PATTERN (insn)) == SEQUENCE)
8890           for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
8891             mips_avoid_hazard (last_insn, XVECEXP (PATTERN (insn), 0, i),
8892                                &hilo_delay, &delayed_reg, lo_reg);
8893         else
8894           mips_avoid_hazard (last_insn, insn, &hilo_delay,
8895                              &delayed_reg, lo_reg);
8896
8897         last_insn = insn;
8898       }
8899 }
8900
8901
8902 /* Implement TARGET_MACHINE_DEPENDENT_REORG.  */
8903
8904 static void
8905 mips_reorg (void)
8906 {
8907   if (TARGET_MIPS16)
8908     mips16_lay_out_constants ();
8909   else if (TARGET_EXPLICIT_RELOCS)
8910     {
8911       if (mips_flag_delayed_branch)
8912         dbr_schedule (get_insns (), dump_file);
8913       mips_avoid_hazards ();
8914       if (TUNE_MIPS4130 && TARGET_VR4130_ALIGN)
8915         vr4130_align_insns ();
8916     }
8917 }
8918
8919 /* This function does three things:
8920
8921    - Register the special divsi3 and modsi3 functions if -mfix-vr4120.
8922    - Register the mips16 hardware floating point stubs.
8923    - Register the gofast functions if selected using --enable-gofast.  */
8924
8925 #include "config/gofast.h"
8926
8927 static void
8928 mips_init_libfuncs (void)
8929 {
8930   if (TARGET_FIX_VR4120)
8931     {
8932       set_optab_libfunc (sdiv_optab, SImode, "__vr4120_divsi3");
8933       set_optab_libfunc (smod_optab, SImode, "__vr4120_modsi3");
8934     }
8935
8936   if (TARGET_MIPS16 && mips16_hard_float)
8937     {
8938       set_optab_libfunc (add_optab, SFmode, "__mips16_addsf3");
8939       set_optab_libfunc (sub_optab, SFmode, "__mips16_subsf3");
8940       set_optab_libfunc (smul_optab, SFmode, "__mips16_mulsf3");
8941       set_optab_libfunc (sdiv_optab, SFmode, "__mips16_divsf3");
8942
8943       set_optab_libfunc (eq_optab, SFmode, "__mips16_eqsf2");
8944       set_optab_libfunc (ne_optab, SFmode, "__mips16_nesf2");
8945       set_optab_libfunc (gt_optab, SFmode, "__mips16_gtsf2");
8946       set_optab_libfunc (ge_optab, SFmode, "__mips16_gesf2");
8947       set_optab_libfunc (lt_optab, SFmode, "__mips16_ltsf2");
8948       set_optab_libfunc (le_optab, SFmode, "__mips16_lesf2");
8949
8950       set_conv_libfunc (sfix_optab, SImode, SFmode, "__mips16_fix_truncsfsi");
8951       set_conv_libfunc (sfloat_optab, SFmode, SImode, "__mips16_floatsisf");
8952
8953       if (TARGET_DOUBLE_FLOAT)
8954         {
8955           set_optab_libfunc (add_optab, DFmode, "__mips16_adddf3");
8956           set_optab_libfunc (sub_optab, DFmode, "__mips16_subdf3");
8957           set_optab_libfunc (smul_optab, DFmode, "__mips16_muldf3");
8958           set_optab_libfunc (sdiv_optab, DFmode, "__mips16_divdf3");
8959
8960           set_optab_libfunc (eq_optab, DFmode, "__mips16_eqdf2");
8961           set_optab_libfunc (ne_optab, DFmode, "__mips16_nedf2");
8962           set_optab_libfunc (gt_optab, DFmode, "__mips16_gtdf2");
8963           set_optab_libfunc (ge_optab, DFmode, "__mips16_gedf2");
8964           set_optab_libfunc (lt_optab, DFmode, "__mips16_ltdf2");
8965           set_optab_libfunc (le_optab, DFmode, "__mips16_ledf2");
8966
8967           set_conv_libfunc (sext_optab, DFmode, SFmode, "__mips16_extendsfdf2");
8968           set_conv_libfunc (trunc_optab, SFmode, DFmode, "__mips16_truncdfsf2");
8969
8970           set_conv_libfunc (sfix_optab, SImode, DFmode, "__mips16_fix_truncdfsi");
8971           set_conv_libfunc (sfloat_optab, DFmode, SImode, "__mips16_floatsidf");
8972         }
8973     }
8974   else
8975     gofast_maybe_init_libfuncs ();
8976 }
8977
8978 /* Return a number assessing the cost of moving a register in class
8979    FROM to class TO.  The classes are expressed using the enumeration
8980    values such as `GENERAL_REGS'.  A value of 2 is the default; other
8981    values are interpreted relative to that.
8982
8983    It is not required that the cost always equal 2 when FROM is the
8984    same as TO; on some machines it is expensive to move between
8985    registers if they are not general registers.
8986
8987    If reload sees an insn consisting of a single `set' between two
8988    hard registers, and if `REGISTER_MOVE_COST' applied to their
8989    classes returns a value of 2, reload does not check to ensure that
8990    the constraints of the insn are met.  Setting a cost of other than
8991    2 will allow reload to verify that the constraints are met.  You
8992    should do this if the `movM' pattern's constraints do not allow
8993    such copying.
8994
8995    ??? We make the cost of moving from HI/LO into general
8996    registers the same as for one of moving general registers to
8997    HI/LO for TARGET_MIPS16 in order to prevent allocating a
8998    pseudo to HI/LO.  This might hurt optimizations though, it
8999    isn't clear if it is wise.  And it might not work in all cases.  We
9000    could solve the DImode LO reg problem by using a multiply, just
9001    like reload_{in,out}si.  We could solve the SImode/HImode HI reg
9002    problem by using divide instructions.  divu puts the remainder in
9003    the HI reg, so doing a divide by -1 will move the value in the HI
9004    reg for all values except -1.  We could handle that case by using a
9005    signed divide, e.g.  -1 / 2 (or maybe 1 / -2?).  We'd have to emit
9006    a compare/branch to test the input value to see which instruction
9007    we need to use.  This gets pretty messy, but it is feasible.  */
9008
9009 int
9010 mips_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
9011                          enum reg_class to, enum reg_class from)
9012 {
9013   if (from == M16_REGS && GR_REG_CLASS_P (to))
9014     return 2;
9015   else if (from == M16_NA_REGS && GR_REG_CLASS_P (to))
9016     return 2;
9017   else if (GR_REG_CLASS_P (from))
9018     {
9019       if (to == M16_REGS)
9020         return 2;
9021       else if (to == M16_NA_REGS)
9022         return 2;
9023       else if (GR_REG_CLASS_P (to))
9024         {
9025           if (TARGET_MIPS16)
9026             return 4;
9027           else
9028             return 2;
9029         }
9030       else if (to == FP_REGS)
9031         return 4;
9032       else if (reg_class_subset_p (to, ACC_REGS))
9033         {
9034           if (TARGET_MIPS16)
9035             return 12;
9036           else
9037             return 6;
9038         }
9039       else if (COP_REG_CLASS_P (to))
9040         {
9041           return 5;
9042         }
9043     }
9044   else if (from == FP_REGS)
9045     {
9046       if (GR_REG_CLASS_P (to))
9047         return 4;
9048       else if (to == FP_REGS)
9049         return 2;
9050       else if (to == ST_REGS)
9051         return 8;
9052     }
9053   else if (reg_class_subset_p (from, ACC_REGS))
9054     {
9055       if (GR_REG_CLASS_P (to))
9056         {
9057           if (TARGET_MIPS16)
9058             return 12;
9059           else
9060             return 6;
9061         }
9062     }
9063   else if (from == ST_REGS && GR_REG_CLASS_P (to))
9064     return 4;
9065   else if (COP_REG_CLASS_P (from))
9066     {
9067       return 5;
9068     }
9069
9070   /* Fall through.
9071      ??? What cases are these? Shouldn't we return 2 here?  */
9072
9073   return 12;
9074 }
9075
9076 /* Return the length of INSN.  LENGTH is the initial length computed by
9077    attributes in the machine-description file.  */
9078
9079 int
9080 mips_adjust_insn_length (rtx insn, int length)
9081 {
9082   /* A unconditional jump has an unfilled delay slot if it is not part
9083      of a sequence.  A conditional jump normally has a delay slot, but
9084      does not on MIPS16.  */
9085   if (CALL_P (insn) || (TARGET_MIPS16 ? simplejump_p (insn) : JUMP_P (insn)))
9086     length += 4;
9087
9088   /* See how many nops might be needed to avoid hardware hazards.  */
9089   if (!cfun->machine->ignore_hazard_length_p && INSN_CODE (insn) >= 0)
9090     switch (get_attr_hazard (insn))
9091       {
9092       case HAZARD_NONE:
9093         break;
9094
9095       case HAZARD_DELAY:
9096         length += 4;
9097         break;
9098
9099       case HAZARD_HILO:
9100         length += 8;
9101         break;
9102       }
9103
9104   /* All MIPS16 instructions are a measly two bytes.  */
9105   if (TARGET_MIPS16)
9106     length /= 2;
9107
9108   return length;
9109 }
9110
9111
9112 /* Return an asm sequence to start a noat block and load the address
9113    of a label into $1.  */
9114
9115 const char *
9116 mips_output_load_label (void)
9117 {
9118   if (TARGET_EXPLICIT_RELOCS)
9119     switch (mips_abi)
9120       {
9121       case ABI_N32:
9122         return "%[lw\t%@,%%got_page(%0)(%+)\n\taddiu\t%@,%@,%%got_ofst(%0)";
9123
9124       case ABI_64:
9125         return "%[ld\t%@,%%got_page(%0)(%+)\n\tdaddiu\t%@,%@,%%got_ofst(%0)";
9126
9127       default:
9128         if (ISA_HAS_LOAD_DELAY)
9129           return "%[lw\t%@,%%got(%0)(%+)%#\n\taddiu\t%@,%@,%%lo(%0)";
9130         return "%[lw\t%@,%%got(%0)(%+)\n\taddiu\t%@,%@,%%lo(%0)";
9131       }
9132   else
9133     {
9134       if (Pmode == DImode)
9135         return "%[dla\t%@,%0";
9136       else
9137         return "%[la\t%@,%0";
9138     }
9139 }
9140
9141
9142 /* Output assembly instructions to peform a conditional branch.
9143
9144    INSN is the branch instruction.  OPERANDS[0] is the condition.
9145    OPERANDS[1] is the target of the branch.  OPERANDS[2] is the target
9146    of the first operand to the condition.  If TWO_OPERANDS_P is
9147    nonzero the comparison takes two operands; OPERANDS[3] will be the
9148    second operand.
9149
9150    If INVERTED_P is nonzero we are to branch if the condition does
9151    not hold.  If FLOAT_P is nonzero this is a floating-point comparison.
9152
9153    LENGTH is the length (in bytes) of the sequence we are to generate.
9154    That tells us whether to generate a simple conditional branch, or a
9155    reversed conditional branch around a `jr' instruction.  */
9156 const char *
9157 mips_output_conditional_branch (rtx insn, rtx *operands, int two_operands_p,
9158                                 int float_p, int inverted_p, int length)
9159 {
9160   static char buffer[200];
9161   /* The kind of comparison we are doing.  */
9162   enum rtx_code code = GET_CODE (operands[0]);
9163   /* Nonzero if the opcode for the comparison needs a `z' indicating
9164      that it is a comparison against zero.  */
9165   int need_z_p;
9166   /* A string to use in the assembly output to represent the first
9167      operand.  */
9168   const char *op1 = "%z2";
9169   /* A string to use in the assembly output to represent the second
9170      operand.  Use the hard-wired zero register if there's no second
9171      operand.  */
9172   const char *op2 = (two_operands_p ? ",%z3" : ",%.");
9173   /* The operand-printing string for the comparison.  */
9174   const char *const comp = (float_p ? "%F0" : "%C0");
9175   /* The operand-printing string for the inverted comparison.  */
9176   const char *const inverted_comp = (float_p ? "%W0" : "%N0");
9177
9178   /* The MIPS processors (for levels of the ISA at least two), have
9179      "likely" variants of each branch instruction.  These instructions
9180      annul the instruction in the delay slot if the branch is not
9181      taken.  */
9182   mips_branch_likely = (final_sequence && INSN_ANNULLED_BRANCH_P (insn));
9183
9184   if (!two_operands_p)
9185     {
9186       /* To compute whether than A > B, for example, we normally
9187          subtract B from A and then look at the sign bit.  But, if we
9188          are doing an unsigned comparison, and B is zero, we don't
9189          have to do the subtraction.  Instead, we can just check to
9190          see if A is nonzero.  Thus, we change the CODE here to
9191          reflect the simpler comparison operation.  */
9192       switch (code)
9193         {
9194         case GTU:
9195           code = NE;
9196           break;
9197
9198         case LEU:
9199           code = EQ;
9200           break;
9201
9202         case GEU:
9203           /* A condition which will always be true.  */
9204           code = EQ;
9205           op1 = "%.";
9206           break;
9207
9208         case LTU:
9209           /* A condition which will always be false.  */
9210           code = NE;
9211           op1 = "%.";
9212           break;
9213
9214         default:
9215           /* Not a special case.  */
9216           break;
9217         }
9218     }
9219
9220   /* Relative comparisons are always done against zero.  But
9221      equality comparisons are done between two operands, and therefore
9222      do not require a `z' in the assembly language output.  */
9223   need_z_p = (!float_p && code != EQ && code != NE);
9224   /* For comparisons against zero, the zero is not provided
9225      explicitly.  */
9226   if (need_z_p)
9227     op2 = "";
9228
9229   /* Begin by terminating the buffer.  That way we can always use
9230      strcat to add to it.  */
9231   buffer[0] = '\0';
9232
9233   switch (length)
9234     {
9235     case 4:
9236     case 8:
9237       /* Just a simple conditional branch.  */
9238       if (float_p)
9239         sprintf (buffer, "%%*b%s%%?\t%%Z2%%1%%/",
9240                  inverted_p ? inverted_comp : comp);
9241       else
9242         sprintf (buffer, "%%*b%s%s%%?\t%s%s,%%1%%/",
9243                  inverted_p ? inverted_comp : comp,
9244                  need_z_p ? "z" : "",
9245                  op1,
9246                  op2);
9247       return buffer;
9248
9249     case 12:
9250     case 16:
9251     case 24:
9252     case 28:
9253       {
9254         /* Generate a reversed conditional branch around ` j'
9255            instruction:
9256
9257                 .set noreorder
9258                 .set nomacro
9259                 bc    l
9260                 delay_slot or #nop
9261                 j     target
9262                 #nop
9263              l:
9264                 .set macro
9265                 .set reorder
9266
9267            If the original branch was a likely branch, the delay slot
9268            must be executed only if the branch is taken, so generate:
9269
9270                 .set noreorder
9271                 .set nomacro
9272                 bc    l
9273                 #nop
9274                 j     target
9275                 delay slot or #nop
9276              l:
9277                 .set macro
9278                 .set reorder
9279
9280            When generating PIC, instead of:
9281
9282                 j     target
9283
9284            we emit:
9285
9286                 .set noat
9287                 la    $at, target
9288                 jr    $at
9289                 .set at
9290         */
9291
9292         rtx orig_target;
9293         rtx target = gen_label_rtx ();
9294
9295         orig_target = operands[1];
9296         operands[1] = target;
9297         /* Generate the reversed comparison.  This takes four
9298            bytes.  */
9299         if (float_p)
9300           sprintf (buffer, "%%*b%s\t%%Z2%%1",
9301                    inverted_p ? comp : inverted_comp);
9302         else
9303           sprintf (buffer, "%%*b%s%s\t%s%s,%%1",
9304                    inverted_p ? comp : inverted_comp,
9305                    need_z_p ? "z" : "",
9306                    op1,
9307                    op2);
9308         output_asm_insn (buffer, operands);
9309
9310         if (length != 16 && length != 28 && ! mips_branch_likely)
9311           {
9312             /* Output delay slot instruction.  */
9313             rtx insn = final_sequence;
9314             final_scan_insn (XVECEXP (insn, 0, 1), asm_out_file,
9315                              optimize, 1, NULL);
9316             INSN_DELETED_P (XVECEXP (insn, 0, 1)) = 1;
9317           }
9318         else
9319           output_asm_insn ("%#", 0);
9320
9321         if (length <= 16)
9322           output_asm_insn ("j\t%0", &orig_target);
9323         else
9324           {
9325             output_asm_insn (mips_output_load_label (), &orig_target);
9326             output_asm_insn ("jr\t%@%]", 0);
9327           }
9328
9329         if (length != 16 && length != 28 && mips_branch_likely)
9330           {
9331             /* Output delay slot instruction.  */
9332             rtx insn = final_sequence;
9333             final_scan_insn (XVECEXP (insn, 0, 1), asm_out_file,
9334                              optimize, 1, NULL);
9335             INSN_DELETED_P (XVECEXP (insn, 0, 1)) = 1;
9336           }
9337         else
9338           output_asm_insn ("%#", 0);
9339
9340         (*targetm.asm_out.internal_label) (asm_out_file, "L",
9341                                    CODE_LABEL_NUMBER (target));
9342
9343         return "";
9344       }
9345
9346     default:
9347       gcc_unreachable ();
9348     }
9349
9350   /* NOTREACHED */
9351   return 0;
9352 }
9353 \f
9354 /* Used to output div or ddiv instruction DIVISION, which has the operands
9355    given by OPERANDS.  Add in a divide-by-zero check if needed.
9356
9357    When working around R4000 and R4400 errata, we need to make sure that
9358    the division is not immediately followed by a shift[1][2].  We also
9359    need to stop the division from being put into a branch delay slot[3].
9360    The easiest way to avoid both problems is to add a nop after the
9361    division.  When a divide-by-zero check is needed, this nop can be
9362    used to fill the branch delay slot.
9363
9364    [1] If a double-word or a variable shift executes immediately
9365        after starting an integer division, the shift may give an
9366        incorrect result.  See quotations of errata #16 and #28 from
9367        "MIPS R4000PC/SC Errata, Processor Revision 2.2 and 3.0"
9368        in mips.md for details.
9369
9370    [2] A similar bug to [1] exists for all revisions of the
9371        R4000 and the R4400 when run in an MC configuration.
9372        From "MIPS R4000MC Errata, Processor Revision 2.2 and 3.0":
9373
9374        "19. In this following sequence:
9375
9376                     ddiv                (or ddivu or div or divu)
9377                     dsll32              (or dsrl32, dsra32)
9378
9379             if an MPT stall occurs, while the divide is slipping the cpu
9380             pipeline, then the following double shift would end up with an
9381             incorrect result.
9382
9383             Workaround: The compiler needs to avoid generating any
9384             sequence with divide followed by extended double shift."
9385
9386        This erratum is also present in "MIPS R4400MC Errata, Processor
9387        Revision 1.0" and "MIPS R4400MC Errata, Processor Revision 2.0
9388        & 3.0" as errata #10 and #4, respectively.
9389
9390    [3] From "MIPS R4000PC/SC Errata, Processor Revision 2.2 and 3.0"
9391        (also valid for MIPS R4000MC processors):
9392
9393        "52. R4000SC: This bug does not apply for the R4000PC.
9394
9395             There are two flavors of this bug:
9396
9397             1) If the instruction just after divide takes an RF exception
9398                (tlb-refill, tlb-invalid) and gets an instruction cache
9399                miss (both primary and secondary) and the line which is
9400                currently in secondary cache at this index had the first
9401                data word, where the bits 5..2 are set, then R4000 would
9402                get a wrong result for the div.
9403
9404             ##1
9405                     nop
9406                     div r8, r9
9407                     -------------------         # end-of page. -tlb-refill
9408                     nop
9409             ##2
9410                     nop
9411                     div r8, r9
9412                     -------------------         # end-of page. -tlb-invalid
9413                     nop
9414
9415             2) If the divide is in the taken branch delay slot, where the
9416                target takes RF exception and gets an I-cache miss for the
9417                exception vector or where I-cache miss occurs for the
9418                target address, under the above mentioned scenarios, the
9419                div would get wrong results.
9420
9421             ##1
9422                     j   r2              # to next page mapped or unmapped
9423                     div r8,r9           # this bug would be there as long
9424                                         # as there is an ICache miss and
9425                     nop                 # the "data pattern" is present
9426
9427             ##2
9428                     beq r0, r0, NextPage        # to Next page
9429                     div r8,r9
9430                     nop
9431
9432             This bug is present for div, divu, ddiv, and ddivu
9433             instructions.
9434
9435             Workaround: For item 1), OS could make sure that the next page
9436             after the divide instruction is also mapped.  For item 2), the
9437             compiler could make sure that the divide instruction is not in
9438             the branch delay slot."
9439
9440        These processors have PRId values of 0x00004220 and 0x00004300 for
9441        the R4000 and 0x00004400, 0x00004500 and 0x00004600 for the R4400.  */
9442
9443 const char *
9444 mips_output_division (const char *division, rtx *operands)
9445 {
9446   const char *s;
9447
9448   s = division;
9449   if (TARGET_FIX_R4000 || TARGET_FIX_R4400)
9450     {
9451       output_asm_insn (s, operands);
9452       s = "nop";
9453     }
9454   if (TARGET_CHECK_ZERO_DIV)
9455     {
9456       if (TARGET_MIPS16)
9457         {
9458           output_asm_insn (s, operands);
9459           s = "bnez\t%2,1f\n\tbreak\t7\n1:";
9460         }
9461       else if (GENERATE_DIVIDE_TRAPS)
9462         {
9463           output_asm_insn (s, operands);
9464           s = "teq\t%2,%.,7";
9465         }
9466       else
9467         {
9468           output_asm_insn ("%(bne\t%2,%.,1f", operands);
9469           output_asm_insn (s, operands);
9470           s = "break\t7%)\n1:";
9471         }
9472     }
9473   return s;
9474 }
9475 \f
9476 /* Return true if GIVEN is the same as CANONICAL, or if it is CANONICAL
9477    with a final "000" replaced by "k".  Ignore case.
9478
9479    Note: this function is shared between GCC and GAS.  */
9480
9481 static bool
9482 mips_strict_matching_cpu_name_p (const char *canonical, const char *given)
9483 {
9484   while (*given != 0 && TOLOWER (*given) == TOLOWER (*canonical))
9485     given++, canonical++;
9486
9487   return ((*given == 0 && *canonical == 0)
9488           || (strcmp (canonical, "000") == 0 && strcasecmp (given, "k") == 0));
9489 }
9490
9491
9492 /* Return true if GIVEN matches CANONICAL, where GIVEN is a user-supplied
9493    CPU name.  We've traditionally allowed a lot of variation here.
9494
9495    Note: this function is shared between GCC and GAS.  */
9496
9497 static bool
9498 mips_matching_cpu_name_p (const char *canonical, const char *given)
9499 {
9500   /* First see if the name matches exactly, or with a final "000"
9501      turned into "k".  */
9502   if (mips_strict_matching_cpu_name_p (canonical, given))
9503     return true;
9504
9505   /* If not, try comparing based on numerical designation alone.
9506      See if GIVEN is an unadorned number, or 'r' followed by a number.  */
9507   if (TOLOWER (*given) == 'r')
9508     given++;
9509   if (!ISDIGIT (*given))
9510     return false;
9511
9512   /* Skip over some well-known prefixes in the canonical name,
9513      hoping to find a number there too.  */
9514   if (TOLOWER (canonical[0]) == 'v' && TOLOWER (canonical[1]) == 'r')
9515     canonical += 2;
9516   else if (TOLOWER (canonical[0]) == 'r' && TOLOWER (canonical[1]) == 'm')
9517     canonical += 2;
9518   else if (TOLOWER (canonical[0]) == 'r')
9519     canonical += 1;
9520
9521   return mips_strict_matching_cpu_name_p (canonical, given);
9522 }
9523
9524
9525 /* Return the mips_cpu_info entry for the processor or ISA given
9526    by CPU_STRING.  Return null if the string isn't recognized.
9527
9528    A similar function exists in GAS.  */
9529
9530 static const struct mips_cpu_info *
9531 mips_parse_cpu (const char *cpu_string)
9532 {
9533   const struct mips_cpu_info *p;
9534   const char *s;
9535
9536   /* In the past, we allowed upper-case CPU names, but it doesn't
9537      work well with the multilib machinery.  */
9538   for (s = cpu_string; *s != 0; s++)
9539     if (ISUPPER (*s))
9540       {
9541         warning (0, "the cpu name must be lower case");
9542         break;
9543       }
9544
9545   /* 'from-abi' selects the most compatible architecture for the given
9546      ABI: MIPS I for 32-bit ABIs and MIPS III for 64-bit ABIs.  For the
9547      EABIs, we have to decide whether we're using the 32-bit or 64-bit
9548      version.  Look first at the -mgp options, if given, otherwise base
9549      the choice on MASK_64BIT in TARGET_DEFAULT.  */
9550   if (strcasecmp (cpu_string, "from-abi") == 0)
9551     return mips_cpu_info_from_isa (ABI_NEEDS_32BIT_REGS ? 1
9552                                    : ABI_NEEDS_64BIT_REGS ? 3
9553                                    : (TARGET_64BIT ? 3 : 1));
9554
9555   /* 'default' has traditionally been a no-op.  Probably not very useful.  */
9556   if (strcasecmp (cpu_string, "default") == 0)
9557     return 0;
9558
9559   for (p = mips_cpu_info_table; p->name != 0; p++)
9560     if (mips_matching_cpu_name_p (p->name, cpu_string))
9561       return p;
9562
9563   return 0;
9564 }
9565
9566
9567 /* Return the processor associated with the given ISA level, or null
9568    if the ISA isn't valid.  */
9569
9570 static const struct mips_cpu_info *
9571 mips_cpu_info_from_isa (int isa)
9572 {
9573   const struct mips_cpu_info *p;
9574
9575   for (p = mips_cpu_info_table; p->name != 0; p++)
9576     if (p->isa == isa)
9577       return p;
9578
9579   return 0;
9580 }
9581 \f
9582 /* Implement HARD_REGNO_NREGS.  The size of FP registers is controlled
9583    by UNITS_PER_FPREG.  The size of FP status registers is always 4, because
9584    they only hold condition code modes, and CCmode is always considered to
9585    be 4 bytes wide.  All other registers are word sized.  */
9586
9587 unsigned int
9588 mips_hard_regno_nregs (int regno, enum machine_mode mode)
9589 {
9590   if (ST_REG_P (regno))
9591     return ((GET_MODE_SIZE (mode) + 3) / 4);
9592   else if (! FP_REG_P (regno))
9593     return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
9594   else
9595     return ((GET_MODE_SIZE (mode) + UNITS_PER_FPREG - 1) / UNITS_PER_FPREG);
9596 }
9597
9598 /* Implement TARGET_RETURN_IN_MEMORY.  Under the old (i.e., 32 and O64 ABIs)
9599    all BLKmode objects are returned in memory.  Under the new (N32 and
9600    64-bit MIPS ABIs) small structures are returned in a register.
9601    Objects with varying size must still be returned in memory, of
9602    course.  */
9603
9604 static bool
9605 mips_return_in_memory (tree type, tree fndecl ATTRIBUTE_UNUSED)
9606 {
9607   if (TARGET_OLDABI)
9608     return (TYPE_MODE (type) == BLKmode);
9609   else
9610     return ((int_size_in_bytes (type) > (2 * UNITS_PER_WORD))
9611             || (int_size_in_bytes (type) == -1));
9612 }
9613
9614 static bool
9615 mips_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
9616 {
9617   return !TARGET_OLDABI;
9618 }
9619 \f
9620 /* Return true if INSN is a multiply-add or multiply-subtract
9621    instruction and PREV assigns to the accumulator operand.  */
9622
9623 bool
9624 mips_linked_madd_p (rtx prev, rtx insn)
9625 {
9626   rtx x;
9627
9628   x = single_set (insn);
9629   if (x == 0)
9630     return false;
9631
9632   x = SET_SRC (x);
9633
9634   if (GET_CODE (x) == PLUS
9635       && GET_CODE (XEXP (x, 0)) == MULT
9636       && reg_set_p (XEXP (x, 1), prev))
9637     return true;
9638
9639   if (GET_CODE (x) == MINUS
9640       && GET_CODE (XEXP (x, 1)) == MULT
9641       && reg_set_p (XEXP (x, 0), prev))
9642     return true;
9643
9644   return false;
9645 }
9646 \f
9647 /* Used by TUNE_MACC_CHAINS to record the last scheduled instruction
9648    that may clobber hi or lo.  */
9649
9650 static rtx mips_macc_chains_last_hilo;
9651
9652 /* A TUNE_MACC_CHAINS helper function.  Record that instruction INSN has
9653    been scheduled, updating mips_macc_chains_last_hilo appropriately.  */
9654
9655 static void
9656 mips_macc_chains_record (rtx insn)
9657 {
9658   if (get_attr_may_clobber_hilo (insn))
9659     mips_macc_chains_last_hilo = insn;
9660 }
9661
9662 /* A TUNE_MACC_CHAINS helper function.  Search ready queue READY, which
9663    has NREADY elements, looking for a multiply-add or multiply-subtract
9664    instruction that is cumulative with mips_macc_chains_last_hilo.
9665    If there is one, promote it ahead of anything else that might
9666    clobber hi or lo.  */
9667
9668 static void
9669 mips_macc_chains_reorder (rtx *ready, int nready)
9670 {
9671   int i, j;
9672
9673   if (mips_macc_chains_last_hilo != 0)
9674     for (i = nready - 1; i >= 0; i--)
9675       if (mips_linked_madd_p (mips_macc_chains_last_hilo, ready[i]))
9676         {
9677           for (j = nready - 1; j > i; j--)
9678             if (recog_memoized (ready[j]) >= 0
9679                 && get_attr_may_clobber_hilo (ready[j]))
9680               {
9681                 mips_promote_ready (ready, i, j);
9682                 break;
9683               }
9684           break;
9685         }
9686 }
9687 \f
9688 /* The last instruction to be scheduled.  */
9689
9690 static rtx vr4130_last_insn;
9691
9692 /* A note_stores callback used by vr4130_true_reg_dependence_p.  DATA
9693    points to an rtx that is initially an instruction.  Nullify the rtx
9694    if the instruction uses the value of register X.  */
9695
9696 static void
9697 vr4130_true_reg_dependence_p_1 (rtx x, rtx pat ATTRIBUTE_UNUSED, void *data)
9698 {
9699   rtx *insn_ptr = data;
9700   if (REG_P (x)
9701       && *insn_ptr != 0
9702       && reg_referenced_p (x, PATTERN (*insn_ptr)))
9703     *insn_ptr = 0;
9704 }
9705
9706 /* Return true if there is true register dependence between vr4130_last_insn
9707    and INSN.  */
9708
9709 static bool
9710 vr4130_true_reg_dependence_p (rtx insn)
9711 {
9712   note_stores (PATTERN (vr4130_last_insn),
9713                vr4130_true_reg_dependence_p_1, &insn);
9714   return insn == 0;
9715 }
9716
9717 /* A TUNE_MIPS4130 helper function.  Given that INSN1 is at the head of
9718    the ready queue and that INSN2 is the instruction after it, return
9719    true if it is worth promoting INSN2 ahead of INSN1.  Look for cases
9720    in which INSN1 and INSN2 can probably issue in parallel, but for
9721    which (INSN2, INSN1) should be less sensitive to instruction
9722    alignment than (INSN1, INSN2).  See 4130.md for more details.  */
9723
9724 static bool
9725 vr4130_swap_insns_p (rtx insn1, rtx insn2)
9726 {
9727   rtx dep;
9728
9729   /* Check for the following case:
9730
9731      1) there is some other instruction X with an anti dependence on INSN1;
9732      2) X has a higher priority than INSN2; and
9733      3) X is an arithmetic instruction (and thus has no unit restrictions).
9734
9735      If INSN1 is the last instruction blocking X, it would better to
9736      choose (INSN1, X) over (INSN2, INSN1).  */
9737   for (dep = INSN_DEPEND (insn1); dep != 0; dep = XEXP (dep, 1))
9738     if (REG_NOTE_KIND (dep) == REG_DEP_ANTI
9739         && INSN_PRIORITY (XEXP (dep, 0)) > INSN_PRIORITY (insn2)
9740         && recog_memoized (XEXP (dep, 0)) >= 0
9741         && get_attr_vr4130_class (XEXP (dep, 0)) == VR4130_CLASS_ALU)
9742       return false;
9743
9744   if (vr4130_last_insn != 0
9745       && recog_memoized (insn1) >= 0
9746       && recog_memoized (insn2) >= 0)
9747     {
9748       /* See whether INSN1 and INSN2 use different execution units,
9749          or if they are both ALU-type instructions.  If so, they can
9750          probably execute in parallel.  */
9751       enum attr_vr4130_class class1 = get_attr_vr4130_class (insn1);
9752       enum attr_vr4130_class class2 = get_attr_vr4130_class (insn2);
9753       if (class1 != class2 || class1 == VR4130_CLASS_ALU)
9754         {
9755           /* If only one of the instructions has a dependence on
9756              vr4130_last_insn, prefer to schedule the other one first.  */
9757           bool dep1 = vr4130_true_reg_dependence_p (insn1);
9758           bool dep2 = vr4130_true_reg_dependence_p (insn2);
9759           if (dep1 != dep2)
9760             return dep1;
9761
9762           /* Prefer to schedule INSN2 ahead of INSN1 if vr4130_last_insn
9763              is not an ALU-type instruction and if INSN1 uses the same
9764              execution unit.  (Note that if this condition holds, we already
9765              know that INSN2 uses a different execution unit.)  */
9766           if (class1 != VR4130_CLASS_ALU
9767               && recog_memoized (vr4130_last_insn) >= 0
9768               && class1 == get_attr_vr4130_class (vr4130_last_insn))
9769             return true;
9770         }
9771     }
9772   return false;
9773 }
9774
9775 /* A TUNE_MIPS4130 helper function.  (READY, NREADY) describes a ready
9776    queue with at least two instructions.  Swap the first two if
9777    vr4130_swap_insns_p says that it could be worthwhile.  */
9778
9779 static void
9780 vr4130_reorder (rtx *ready, int nready)
9781 {
9782   if (vr4130_swap_insns_p (ready[nready - 1], ready[nready - 2]))
9783     mips_promote_ready (ready, nready - 2, nready - 1);
9784 }
9785 \f
9786 /* Remove the instruction at index LOWER from ready queue READY and
9787    reinsert it in front of the instruction at index HIGHER.  LOWER must
9788    be <= HIGHER.  */
9789
9790 static void
9791 mips_promote_ready (rtx *ready, int lower, int higher)
9792 {
9793   rtx new_head;
9794   int i;
9795
9796   new_head = ready[lower];
9797   for (i = lower; i < higher; i++)
9798     ready[i] = ready[i + 1];
9799   ready[i] = new_head;
9800 }
9801
9802 /* Implement TARGET_SCHED_REORDER.  */
9803
9804 static int
9805 mips_sched_reorder (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
9806                     rtx *ready, int *nreadyp, int cycle)
9807 {
9808   if (!reload_completed && TUNE_MACC_CHAINS)
9809     {
9810       if (cycle == 0)
9811         mips_macc_chains_last_hilo = 0;
9812       if (*nreadyp > 0)
9813         mips_macc_chains_reorder (ready, *nreadyp);
9814     }
9815   if (reload_completed && TUNE_MIPS4130 && !TARGET_VR4130_ALIGN)
9816     {
9817       if (cycle == 0)
9818         vr4130_last_insn = 0;
9819       if (*nreadyp > 1)
9820         vr4130_reorder (ready, *nreadyp);
9821     }
9822   return mips_issue_rate ();
9823 }
9824
9825 /* Implement TARGET_SCHED_VARIABLE_ISSUE.  */
9826
9827 static int
9828 mips_variable_issue (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
9829                      rtx insn, int more)
9830 {
9831   switch (GET_CODE (PATTERN (insn)))
9832     {
9833     case USE:
9834     case CLOBBER:
9835       /* Don't count USEs and CLOBBERs against the issue rate.  */
9836       break;
9837
9838     default:
9839       more--;
9840       if (!reload_completed && TUNE_MACC_CHAINS)
9841         mips_macc_chains_record (insn);
9842       vr4130_last_insn = insn;
9843       break;
9844     }
9845   return more;
9846 }
9847 \f
9848 /* Implement TARGET_SCHED_ADJUST_COST.  We assume that anti and output
9849    dependencies have no cost.  */
9850
9851 static int
9852 mips_adjust_cost (rtx insn ATTRIBUTE_UNUSED, rtx link,
9853                   rtx dep ATTRIBUTE_UNUSED, int cost)
9854 {
9855   if (REG_NOTE_KIND (link) != 0)
9856     return 0;
9857   return cost;
9858 }
9859
9860 /* Return the number of instructions that can be issued per cycle.  */
9861
9862 static int
9863 mips_issue_rate (void)
9864 {
9865   switch (mips_tune)
9866     {
9867     case PROCESSOR_R4130:
9868     case PROCESSOR_R5400:
9869     case PROCESSOR_R5500:
9870     case PROCESSOR_R7000:
9871     case PROCESSOR_R9000:
9872       return 2;
9873
9874     case PROCESSOR_SB1:
9875       /* This is actually 4, but we get better performance if we claim 3.
9876          This is partly because of unwanted speculative code motion with the
9877          larger number, and partly because in most common cases we can't
9878          reach the theoretical max of 4.  */
9879       return 3;
9880
9881     default:
9882       return 1;
9883     }
9884 }
9885
9886 /* Implements TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD.  This should
9887    be as wide as the scheduling freedom in the DFA.  */
9888
9889 static int
9890 mips_multipass_dfa_lookahead (void)
9891 {
9892   /* Can schedule up to 4 of the 6 function units in any one cycle.  */
9893   if (mips_tune == PROCESSOR_SB1)
9894     return 4;
9895
9896   return 0;
9897 }
9898 \f
9899 /* Given that we have an rtx of the form (prefetch ... WRITE LOCALITY),
9900    return the first operand of the associated "pref" or "prefx" insn.  */
9901
9902 rtx
9903 mips_prefetch_cookie (rtx write, rtx locality)
9904 {
9905   /* store_streamed / load_streamed.  */
9906   if (INTVAL (locality) <= 0)
9907     return GEN_INT (INTVAL (write) + 4);
9908
9909   /* store / load.  */
9910   if (INTVAL (locality) <= 2)
9911     return write;
9912
9913   /* store_retained / load_retained.  */
9914   return GEN_INT (INTVAL (write) + 6);
9915 }
9916 \f
9917 /* MIPS builtin function support. */
9918
9919 struct builtin_description
9920 {
9921   /* The code of the main .md file instruction.  See mips_builtin_type
9922      for more information.  */
9923   enum insn_code icode;
9924
9925   /* The floating-point comparison code to use with ICODE, if any.  */
9926   enum mips_fp_condition cond;
9927
9928   /* The name of the builtin function.  */
9929   const char *name;
9930
9931   /* Specifies how the function should be expanded.  */
9932   enum mips_builtin_type builtin_type;
9933
9934   /* The function's prototype.  */
9935   enum mips_function_type function_type;
9936
9937   /* The target flags required for this function.  */
9938   int target_flags;
9939 };
9940
9941 /* Define a MIPS_BUILTIN_DIRECT function for instruction CODE_FOR_mips_<INSN>.
9942    FUNCTION_TYPE and TARGET_FLAGS are builtin_description fields.  */
9943 #define DIRECT_BUILTIN(INSN, FUNCTION_TYPE, TARGET_FLAGS)               \
9944   { CODE_FOR_mips_ ## INSN, 0, "__builtin_mips_" #INSN,                 \
9945     MIPS_BUILTIN_DIRECT, FUNCTION_TYPE, TARGET_FLAGS }
9946
9947 /* Define __builtin_mips_<INSN>_<COND>_{s,d}, both of which require
9948    TARGET_FLAGS.  */
9949 #define CMP_SCALAR_BUILTINS(INSN, COND, TARGET_FLAGS)                   \
9950   { CODE_FOR_mips_ ## INSN ## _cond_s, MIPS_FP_COND_ ## COND,           \
9951     "__builtin_mips_" #INSN "_" #COND "_s",                             \
9952     MIPS_BUILTIN_CMP_SINGLE, MIPS_INT_FTYPE_SF_SF, TARGET_FLAGS },      \
9953   { CODE_FOR_mips_ ## INSN ## _cond_d, MIPS_FP_COND_ ## COND,           \
9954     "__builtin_mips_" #INSN "_" #COND "_d",                             \
9955     MIPS_BUILTIN_CMP_SINGLE, MIPS_INT_FTYPE_DF_DF, TARGET_FLAGS }
9956
9957 /* Define __builtin_mips_{any,all,upper,lower}_<INSN>_<COND>_ps.
9958    The lower and upper forms require TARGET_FLAGS while the any and all
9959    forms require MASK_MIPS3D.  */
9960 #define CMP_PS_BUILTINS(INSN, COND, TARGET_FLAGS)                       \
9961   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9962     "__builtin_mips_any_" #INSN "_" #COND "_ps",                        \
9963     MIPS_BUILTIN_CMP_ANY, MIPS_INT_FTYPE_V2SF_V2SF, MASK_MIPS3D },      \
9964   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9965     "__builtin_mips_all_" #INSN "_" #COND "_ps",                        \
9966     MIPS_BUILTIN_CMP_ALL, MIPS_INT_FTYPE_V2SF_V2SF, MASK_MIPS3D },      \
9967   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9968     "__builtin_mips_lower_" #INSN "_" #COND "_ps",                      \
9969     MIPS_BUILTIN_CMP_LOWER, MIPS_INT_FTYPE_V2SF_V2SF, TARGET_FLAGS },   \
9970   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9971     "__builtin_mips_upper_" #INSN "_" #COND "_ps",                      \
9972     MIPS_BUILTIN_CMP_UPPER, MIPS_INT_FTYPE_V2SF_V2SF, TARGET_FLAGS }
9973
9974 /* Define __builtin_mips_{any,all}_<INSN>_<COND>_4s.  The functions
9975    require MASK_MIPS3D.  */
9976 #define CMP_4S_BUILTINS(INSN, COND)                                     \
9977   { CODE_FOR_mips_ ## INSN ## _cond_4s, MIPS_FP_COND_ ## COND,          \
9978     "__builtin_mips_any_" #INSN "_" #COND "_4s",                        \
9979     MIPS_BUILTIN_CMP_ANY, MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,           \
9980     MASK_MIPS3D },                                                      \
9981   { CODE_FOR_mips_ ## INSN ## _cond_4s, MIPS_FP_COND_ ## COND,          \
9982     "__builtin_mips_all_" #INSN "_" #COND "_4s",                        \
9983     MIPS_BUILTIN_CMP_ALL, MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,           \
9984     MASK_MIPS3D }
9985
9986 /* Define __builtin_mips_mov{t,f}_<INSN>_<COND>_ps.  The comparison
9987    instruction requires TARGET_FLAGS.  */
9988 #define MOVTF_BUILTINS(INSN, COND, TARGET_FLAGS)                        \
9989   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9990     "__builtin_mips_movt_" #INSN "_" #COND "_ps",                       \
9991     MIPS_BUILTIN_MOVT, MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,             \
9992     TARGET_FLAGS },                                                     \
9993   { CODE_FOR_mips_ ## INSN ## _cond_ps, MIPS_FP_COND_ ## COND,          \
9994     "__builtin_mips_movf_" #INSN "_" #COND "_ps",                       \
9995     MIPS_BUILTIN_MOVF, MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,             \
9996     TARGET_FLAGS }
9997
9998 /* Define all the builtins related to c.cond.fmt condition COND.  */
9999 #define CMP_BUILTINS(COND)                                              \
10000   MOVTF_BUILTINS (c, COND, MASK_PAIRED_SINGLE_FLOAT),                   \
10001   MOVTF_BUILTINS (cabs, COND, MASK_MIPS3D),                             \
10002   CMP_SCALAR_BUILTINS (cabs, COND, MASK_MIPS3D),                        \
10003   CMP_PS_BUILTINS (c, COND, MASK_PAIRED_SINGLE_FLOAT),                  \
10004   CMP_PS_BUILTINS (cabs, COND, MASK_MIPS3D),                            \
10005   CMP_4S_BUILTINS (c, COND),                                            \
10006   CMP_4S_BUILTINS (cabs, COND)
10007
10008 /* __builtin_mips_abs_ps() maps to the standard absM2 pattern.  */
10009 #define CODE_FOR_mips_abs_ps CODE_FOR_absv2sf2
10010
10011 static const struct builtin_description mips_bdesc[] =
10012 {
10013   DIRECT_BUILTIN (pll_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10014   DIRECT_BUILTIN (pul_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10015   DIRECT_BUILTIN (plu_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10016   DIRECT_BUILTIN (puu_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10017   DIRECT_BUILTIN (cvt_ps_s, MIPS_V2SF_FTYPE_SF_SF, MASK_PAIRED_SINGLE_FLOAT),
10018   DIRECT_BUILTIN (cvt_s_pl, MIPS_SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10019   DIRECT_BUILTIN (cvt_s_pu, MIPS_SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10020   DIRECT_BUILTIN (abs_ps, MIPS_V2SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT),
10021
10022   DIRECT_BUILTIN (alnv_ps, MIPS_V2SF_FTYPE_V2SF_V2SF_INT,
10023                   MASK_PAIRED_SINGLE_FLOAT),
10024   DIRECT_BUILTIN (addr_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10025   DIRECT_BUILTIN (mulr_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10026   DIRECT_BUILTIN (cvt_pw_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10027   DIRECT_BUILTIN (cvt_ps_pw, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10028
10029   DIRECT_BUILTIN (recip1_s, MIPS_SF_FTYPE_SF, MASK_MIPS3D),
10030   DIRECT_BUILTIN (recip1_d, MIPS_DF_FTYPE_DF, MASK_MIPS3D),
10031   DIRECT_BUILTIN (recip1_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10032   DIRECT_BUILTIN (recip2_s, MIPS_SF_FTYPE_SF_SF, MASK_MIPS3D),
10033   DIRECT_BUILTIN (recip2_d, MIPS_DF_FTYPE_DF_DF, MASK_MIPS3D),
10034   DIRECT_BUILTIN (recip2_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10035
10036   DIRECT_BUILTIN (rsqrt1_s, MIPS_SF_FTYPE_SF, MASK_MIPS3D),
10037   DIRECT_BUILTIN (rsqrt1_d, MIPS_DF_FTYPE_DF, MASK_MIPS3D),
10038   DIRECT_BUILTIN (rsqrt1_ps, MIPS_V2SF_FTYPE_V2SF, MASK_MIPS3D),
10039   DIRECT_BUILTIN (rsqrt2_s, MIPS_SF_FTYPE_SF_SF, MASK_MIPS3D),
10040   DIRECT_BUILTIN (rsqrt2_d, MIPS_DF_FTYPE_DF_DF, MASK_MIPS3D),
10041   DIRECT_BUILTIN (rsqrt2_ps, MIPS_V2SF_FTYPE_V2SF_V2SF, MASK_MIPS3D),
10042
10043   MIPS_FP_CONDITIONS (CMP_BUILTINS)
10044 };
10045
10046 /* Builtin functions for the SB-1 processor.  */
10047
10048 #define CODE_FOR_mips_sqrt_ps CODE_FOR_sqrtv2sf2
10049
10050 static const struct builtin_description sb1_bdesc[] =
10051 {
10052   DIRECT_BUILTIN (sqrt_ps, MIPS_V2SF_FTYPE_V2SF, MASK_PAIRED_SINGLE_FLOAT)
10053 };
10054
10055 /* Builtin functions for DSP ASE.  */
10056
10057 #define CODE_FOR_mips_addq_ph CODE_FOR_addv2hi3
10058 #define CODE_FOR_mips_addu_qb CODE_FOR_addv4qi3
10059 #define CODE_FOR_mips_subq_ph CODE_FOR_subv2hi3
10060 #define CODE_FOR_mips_subu_qb CODE_FOR_subv4qi3
10061
10062 /* Define a MIPS_BUILTIN_DIRECT_NO_TARGET function for instruction
10063    CODE_FOR_mips_<INSN>.  FUNCTION_TYPE and TARGET_FLAGS are
10064    builtin_description fields.  */
10065 #define DIRECT_NO_TARGET_BUILTIN(INSN, FUNCTION_TYPE, TARGET_FLAGS)     \
10066   { CODE_FOR_mips_ ## INSN, 0, "__builtin_mips_" #INSN,                 \
10067     MIPS_BUILTIN_DIRECT_NO_TARGET, FUNCTION_TYPE, TARGET_FLAGS }
10068
10069 /* Define __builtin_mips_bposge<VALUE>.  <VALUE> is 32 for the MIPS32 DSP
10070    branch instruction.  TARGET_FLAGS is a builtin_description field.  */
10071 #define BPOSGE_BUILTIN(VALUE, TARGET_FLAGS)                             \
10072   { CODE_FOR_mips_bposge, 0, "__builtin_mips_bposge" #VALUE,            \
10073     MIPS_BUILTIN_BPOSGE ## VALUE, MIPS_SI_FTYPE_VOID, TARGET_FLAGS }
10074
10075 static const struct builtin_description dsp_bdesc[] =
10076 {
10077   DIRECT_BUILTIN (addq_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10078   DIRECT_BUILTIN (addq_s_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10079   DIRECT_BUILTIN (addq_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10080   DIRECT_BUILTIN (addu_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10081   DIRECT_BUILTIN (addu_s_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10082   DIRECT_BUILTIN (subq_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10083   DIRECT_BUILTIN (subq_s_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10084   DIRECT_BUILTIN (subq_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10085   DIRECT_BUILTIN (subu_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10086   DIRECT_BUILTIN (subu_s_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10087   DIRECT_BUILTIN (addsc, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10088   DIRECT_BUILTIN (addwc, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10089   DIRECT_BUILTIN (modsub, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10090   DIRECT_BUILTIN (raddu_w_qb, MIPS_SI_FTYPE_V4QI, MASK_DSP),
10091   DIRECT_BUILTIN (absq_s_ph, MIPS_V2HI_FTYPE_V2HI, MASK_DSP),
10092   DIRECT_BUILTIN (absq_s_w, MIPS_SI_FTYPE_SI, MASK_DSP),
10093   DIRECT_BUILTIN (precrq_qb_ph, MIPS_V4QI_FTYPE_V2HI_V2HI, MASK_DSP),
10094   DIRECT_BUILTIN (precrq_ph_w, MIPS_V2HI_FTYPE_SI_SI, MASK_DSP),
10095   DIRECT_BUILTIN (precrq_rs_ph_w, MIPS_V2HI_FTYPE_SI_SI, MASK_DSP),
10096   DIRECT_BUILTIN (precrqu_s_qb_ph, MIPS_V4QI_FTYPE_V2HI_V2HI, MASK_DSP),
10097   DIRECT_BUILTIN (preceq_w_phl, MIPS_SI_FTYPE_V2HI, MASK_DSP),
10098   DIRECT_BUILTIN (preceq_w_phr, MIPS_SI_FTYPE_V2HI, MASK_DSP),
10099   DIRECT_BUILTIN (precequ_ph_qbl, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10100   DIRECT_BUILTIN (precequ_ph_qbr, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10101   DIRECT_BUILTIN (precequ_ph_qbla, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10102   DIRECT_BUILTIN (precequ_ph_qbra, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10103   DIRECT_BUILTIN (preceu_ph_qbl, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10104   DIRECT_BUILTIN (preceu_ph_qbr, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10105   DIRECT_BUILTIN (preceu_ph_qbla, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10106   DIRECT_BUILTIN (preceu_ph_qbra, MIPS_V2HI_FTYPE_V4QI, MASK_DSP),
10107   DIRECT_BUILTIN (shll_qb, MIPS_V4QI_FTYPE_V4QI_SI, MASK_DSP),
10108   DIRECT_BUILTIN (shll_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10109   DIRECT_BUILTIN (shll_s_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10110   DIRECT_BUILTIN (shll_s_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10111   DIRECT_BUILTIN (shrl_qb, MIPS_V4QI_FTYPE_V4QI_SI, MASK_DSP),
10112   DIRECT_BUILTIN (shra_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10113   DIRECT_BUILTIN (shra_r_ph, MIPS_V2HI_FTYPE_V2HI_SI, MASK_DSP),
10114   DIRECT_BUILTIN (shra_r_w, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10115   DIRECT_BUILTIN (muleu_s_ph_qbl, MIPS_V2HI_FTYPE_V4QI_V2HI, MASK_DSP),
10116   DIRECT_BUILTIN (muleu_s_ph_qbr, MIPS_V2HI_FTYPE_V4QI_V2HI, MASK_DSP),
10117   DIRECT_BUILTIN (mulq_rs_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10118   DIRECT_BUILTIN (muleq_s_w_phl, MIPS_SI_FTYPE_V2HI_V2HI, MASK_DSP),
10119   DIRECT_BUILTIN (muleq_s_w_phr, MIPS_SI_FTYPE_V2HI_V2HI, MASK_DSP),
10120   DIRECT_BUILTIN (dpau_h_qbl, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10121   DIRECT_BUILTIN (dpau_h_qbr, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10122   DIRECT_BUILTIN (dpsu_h_qbl, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10123   DIRECT_BUILTIN (dpsu_h_qbr, MIPS_DI_FTYPE_DI_V4QI_V4QI, MASK_DSP),
10124   DIRECT_BUILTIN (dpaq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10125   DIRECT_BUILTIN (dpsq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10126   DIRECT_BUILTIN (mulsaq_s_w_ph, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10127   DIRECT_BUILTIN (dpaq_sa_l_w, MIPS_DI_FTYPE_DI_SI_SI, MASK_DSP),
10128   DIRECT_BUILTIN (dpsq_sa_l_w, MIPS_DI_FTYPE_DI_SI_SI, MASK_DSP),
10129   DIRECT_BUILTIN (maq_s_w_phl, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10130   DIRECT_BUILTIN (maq_s_w_phr, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10131   DIRECT_BUILTIN (maq_sa_w_phl, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10132   DIRECT_BUILTIN (maq_sa_w_phr, MIPS_DI_FTYPE_DI_V2HI_V2HI, MASK_DSP),
10133   DIRECT_BUILTIN (bitrev, MIPS_SI_FTYPE_SI, MASK_DSP),
10134   DIRECT_BUILTIN (insv, MIPS_SI_FTYPE_SI_SI, MASK_DSP),
10135   DIRECT_BUILTIN (repl_qb, MIPS_V4QI_FTYPE_SI, MASK_DSP),
10136   DIRECT_BUILTIN (repl_ph, MIPS_V2HI_FTYPE_SI, MASK_DSP),
10137   DIRECT_NO_TARGET_BUILTIN (cmpu_eq_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10138   DIRECT_NO_TARGET_BUILTIN (cmpu_lt_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10139   DIRECT_NO_TARGET_BUILTIN (cmpu_le_qb, MIPS_VOID_FTYPE_V4QI_V4QI, MASK_DSP),
10140   DIRECT_BUILTIN (cmpgu_eq_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10141   DIRECT_BUILTIN (cmpgu_lt_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10142   DIRECT_BUILTIN (cmpgu_le_qb, MIPS_SI_FTYPE_V4QI_V4QI, MASK_DSP),
10143   DIRECT_NO_TARGET_BUILTIN (cmp_eq_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10144   DIRECT_NO_TARGET_BUILTIN (cmp_lt_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10145   DIRECT_NO_TARGET_BUILTIN (cmp_le_ph, MIPS_VOID_FTYPE_V2HI_V2HI, MASK_DSP),
10146   DIRECT_BUILTIN (pick_qb, MIPS_V4QI_FTYPE_V4QI_V4QI, MASK_DSP),
10147   DIRECT_BUILTIN (pick_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10148   DIRECT_BUILTIN (packrl_ph, MIPS_V2HI_FTYPE_V2HI_V2HI, MASK_DSP),
10149   DIRECT_BUILTIN (extr_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10150   DIRECT_BUILTIN (extr_r_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10151   DIRECT_BUILTIN (extr_rs_w, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10152   DIRECT_BUILTIN (extr_s_h, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10153   DIRECT_BUILTIN (extp, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10154   DIRECT_BUILTIN (extpdp, MIPS_SI_FTYPE_DI_SI, MASK_DSP),
10155   DIRECT_BUILTIN (shilo, MIPS_DI_FTYPE_DI_SI, MASK_DSP),
10156   DIRECT_BUILTIN (mthlip, MIPS_DI_FTYPE_DI_SI, MASK_DSP),
10157   DIRECT_NO_TARGET_BUILTIN (wrdsp, MIPS_VOID_FTYPE_SI_SI, MASK_DSP),
10158   DIRECT_BUILTIN (rddsp, MIPS_SI_FTYPE_SI, MASK_DSP),
10159   DIRECT_BUILTIN (lbux, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10160   DIRECT_BUILTIN (lhx, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10161   DIRECT_BUILTIN (lwx, MIPS_SI_FTYPE_PTR_SI, MASK_DSP),
10162   BPOSGE_BUILTIN (32, MASK_DSP)
10163 };
10164
10165 /* This helps provide a mapping from builtin function codes to bdesc
10166    arrays.  */
10167
10168 struct bdesc_map
10169 {
10170   /* The builtin function table that this entry describes.  */
10171   const struct builtin_description *bdesc;
10172
10173   /* The number of entries in the builtin function table.  */
10174   unsigned int size;
10175
10176   /* The target processor that supports these builtin functions.
10177      PROCESSOR_MAX means we enable them for all processors.  */
10178   enum processor_type proc;
10179 };
10180
10181 static const struct bdesc_map bdesc_arrays[] =
10182 {
10183   { mips_bdesc, ARRAY_SIZE (mips_bdesc), PROCESSOR_MAX },
10184   { sb1_bdesc, ARRAY_SIZE (sb1_bdesc), PROCESSOR_SB1 },
10185   { dsp_bdesc, ARRAY_SIZE (dsp_bdesc), PROCESSOR_MAX }
10186 };
10187
10188 /* Take the head of argument list *ARGLIST and convert it into a form
10189    suitable for input operand OP of instruction ICODE.  Return the value
10190    and point *ARGLIST at the next element of the list.  */
10191
10192 static rtx
10193 mips_prepare_builtin_arg (enum insn_code icode,
10194                           unsigned int op, tree *arglist)
10195 {
10196   rtx value;
10197   enum machine_mode mode;
10198
10199   value = expand_expr (TREE_VALUE (*arglist), NULL_RTX, VOIDmode, 0);
10200   mode = insn_data[icode].operand[op].mode;
10201   if (!insn_data[icode].operand[op].predicate (value, mode))
10202     {
10203       value = copy_to_mode_reg (mode, value);
10204       /* Check the predicate again.  */
10205       if (!insn_data[icode].operand[op].predicate (value, mode))
10206         {
10207           error ("invalid argument to builtin function");
10208           return const0_rtx;
10209         }
10210     }
10211
10212   *arglist = TREE_CHAIN (*arglist);
10213   return value;
10214 }
10215
10216 /* Return an rtx suitable for output operand OP of instruction ICODE.
10217    If TARGET is non-null, try to use it where possible.  */
10218
10219 static rtx
10220 mips_prepare_builtin_target (enum insn_code icode, unsigned int op, rtx target)
10221 {
10222   enum machine_mode mode;
10223
10224   mode = insn_data[icode].operand[op].mode;
10225   if (target == 0 || !insn_data[icode].operand[op].predicate (target, mode))
10226     target = gen_reg_rtx (mode);
10227
10228   return target;
10229 }
10230
10231 /* Expand builtin functions.  This is called from TARGET_EXPAND_BUILTIN.  */
10232
10233 rtx
10234 mips_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
10235                      enum machine_mode mode ATTRIBUTE_UNUSED,
10236                      int ignore ATTRIBUTE_UNUSED)
10237 {
10238   enum insn_code icode;
10239   enum mips_builtin_type type;
10240   tree fndecl, arglist;
10241   unsigned int fcode;
10242   const struct builtin_description *bdesc;
10243   const struct bdesc_map *m;
10244
10245   fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
10246   arglist = TREE_OPERAND (exp, 1);
10247   fcode = DECL_FUNCTION_CODE (fndecl);
10248
10249   bdesc = NULL;
10250   for (m = bdesc_arrays; m < &bdesc_arrays[ARRAY_SIZE (bdesc_arrays)]; m++)
10251     {
10252       if (fcode < m->size)
10253         {
10254           bdesc = m->bdesc;
10255           icode = bdesc[fcode].icode;
10256           type = bdesc[fcode].builtin_type;
10257           break;
10258         }
10259       fcode -= m->size;
10260     }
10261   if (bdesc == NULL)
10262     return 0;
10263
10264   switch (type)
10265     {
10266     case MIPS_BUILTIN_DIRECT:
10267       return mips_expand_builtin_direct (icode, target, arglist, true);
10268
10269     case MIPS_BUILTIN_DIRECT_NO_TARGET:
10270       return mips_expand_builtin_direct (icode, target, arglist, false);
10271
10272     case MIPS_BUILTIN_MOVT:
10273     case MIPS_BUILTIN_MOVF:
10274       return mips_expand_builtin_movtf (type, icode, bdesc[fcode].cond,
10275                                         target, arglist);
10276
10277     case MIPS_BUILTIN_CMP_ANY:
10278     case MIPS_BUILTIN_CMP_ALL:
10279     case MIPS_BUILTIN_CMP_UPPER:
10280     case MIPS_BUILTIN_CMP_LOWER:
10281     case MIPS_BUILTIN_CMP_SINGLE:
10282       return mips_expand_builtin_compare (type, icode, bdesc[fcode].cond,
10283                                           target, arglist);
10284
10285     case MIPS_BUILTIN_BPOSGE32:
10286       return mips_expand_builtin_bposge (type, target);
10287
10288     default:
10289       return 0;
10290     }
10291 }
10292
10293 /* Init builtin functions.  This is called from TARGET_INIT_BUILTIN.  */
10294
10295 void
10296 mips_init_builtins (void)
10297 {
10298   const struct builtin_description *d;
10299   const struct bdesc_map *m;
10300   tree types[(int) MIPS_MAX_FTYPE_MAX];
10301   tree V2SF_type_node;
10302   tree V2HI_type_node;
10303   tree V4QI_type_node;
10304   unsigned int offset;
10305
10306   /* We have only builtins for -mpaired-single, -mips3d and -mdsp.  */
10307   if (!TARGET_PAIRED_SINGLE_FLOAT && !TARGET_DSP)
10308     return;
10309
10310   if (TARGET_PAIRED_SINGLE_FLOAT)
10311     {
10312       V2SF_type_node = build_vector_type_for_mode (float_type_node, V2SFmode);
10313
10314       types[MIPS_V2SF_FTYPE_V2SF]
10315         = build_function_type_list (V2SF_type_node, V2SF_type_node, NULL_TREE);
10316
10317       types[MIPS_V2SF_FTYPE_V2SF_V2SF]
10318         = build_function_type_list (V2SF_type_node,
10319                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10320
10321       types[MIPS_V2SF_FTYPE_V2SF_V2SF_INT]
10322         = build_function_type_list (V2SF_type_node,
10323                                     V2SF_type_node, V2SF_type_node,
10324                                     integer_type_node, NULL_TREE);
10325
10326       types[MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF]
10327         = build_function_type_list (V2SF_type_node,
10328                                     V2SF_type_node, V2SF_type_node,
10329                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10330
10331       types[MIPS_V2SF_FTYPE_SF_SF]
10332         = build_function_type_list (V2SF_type_node,
10333                                     float_type_node, float_type_node, NULL_TREE);
10334
10335       types[MIPS_INT_FTYPE_V2SF_V2SF]
10336         = build_function_type_list (integer_type_node,
10337                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10338
10339       types[MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF]
10340         = build_function_type_list (integer_type_node,
10341                                     V2SF_type_node, V2SF_type_node,
10342                                     V2SF_type_node, V2SF_type_node, NULL_TREE);
10343
10344       types[MIPS_INT_FTYPE_SF_SF]
10345         = build_function_type_list (integer_type_node,
10346                                     float_type_node, float_type_node, NULL_TREE);
10347
10348       types[MIPS_INT_FTYPE_DF_DF]
10349         = build_function_type_list (integer_type_node,
10350                                     double_type_node, double_type_node, NULL_TREE);
10351
10352       types[MIPS_SF_FTYPE_V2SF]
10353         = build_function_type_list (float_type_node, V2SF_type_node, NULL_TREE);
10354
10355       types[MIPS_SF_FTYPE_SF]
10356         = build_function_type_list (float_type_node,
10357                                     float_type_node, NULL_TREE);
10358
10359       types[MIPS_SF_FTYPE_SF_SF]
10360         = build_function_type_list (float_type_node,
10361                                     float_type_node, float_type_node, NULL_TREE);
10362
10363       types[MIPS_DF_FTYPE_DF]
10364         = build_function_type_list (double_type_node,
10365                                     double_type_node, NULL_TREE);
10366
10367       types[MIPS_DF_FTYPE_DF_DF]
10368         = build_function_type_list (double_type_node,
10369                                     double_type_node, double_type_node, NULL_TREE);
10370     }
10371
10372   if (TARGET_DSP)
10373     {
10374       V2HI_type_node = build_vector_type_for_mode (intHI_type_node, V2HImode);
10375       V4QI_type_node = build_vector_type_for_mode (intQI_type_node, V4QImode);
10376
10377       types[MIPS_V2HI_FTYPE_V2HI_V2HI]
10378         = build_function_type_list (V2HI_type_node,
10379                                     V2HI_type_node, V2HI_type_node,
10380                                     NULL_TREE);
10381
10382       types[MIPS_SI_FTYPE_SI_SI]
10383         = build_function_type_list (intSI_type_node,
10384                                     intSI_type_node, intSI_type_node,
10385                                     NULL_TREE);
10386
10387       types[MIPS_V4QI_FTYPE_V4QI_V4QI]
10388         = build_function_type_list (V4QI_type_node,
10389                                     V4QI_type_node, V4QI_type_node,
10390                                     NULL_TREE);
10391
10392       types[MIPS_SI_FTYPE_V4QI]
10393         = build_function_type_list (intSI_type_node,
10394                                     V4QI_type_node,
10395                                     NULL_TREE);
10396
10397       types[MIPS_V2HI_FTYPE_V2HI]
10398         = build_function_type_list (V2HI_type_node,
10399                                     V2HI_type_node,
10400                                     NULL_TREE);
10401
10402       types[MIPS_SI_FTYPE_SI]
10403         = build_function_type_list (intSI_type_node,
10404                                     intSI_type_node,
10405                                     NULL_TREE);
10406
10407       types[MIPS_V4QI_FTYPE_V2HI_V2HI]
10408         = build_function_type_list (V4QI_type_node,
10409                                     V2HI_type_node, V2HI_type_node,
10410                                     NULL_TREE);
10411
10412       types[MIPS_V2HI_FTYPE_SI_SI]
10413         = build_function_type_list (V2HI_type_node,
10414                                     intSI_type_node, intSI_type_node,
10415                                     NULL_TREE);
10416
10417       types[MIPS_SI_FTYPE_V2HI]
10418         = build_function_type_list (intSI_type_node,
10419                                     V2HI_type_node,
10420                                     NULL_TREE);
10421
10422       types[MIPS_V2HI_FTYPE_V4QI]
10423         = build_function_type_list (V2HI_type_node,
10424                                     V4QI_type_node,
10425                                     NULL_TREE);
10426
10427       types[MIPS_V4QI_FTYPE_V4QI_SI]
10428         = build_function_type_list (V4QI_type_node,
10429                                     V4QI_type_node, intSI_type_node,
10430                                     NULL_TREE);
10431
10432       types[MIPS_V2HI_FTYPE_V2HI_SI]
10433         = build_function_type_list (V2HI_type_node,
10434                                     V2HI_type_node, intSI_type_node,
10435                                     NULL_TREE);
10436
10437       types[MIPS_V2HI_FTYPE_V4QI_V2HI]
10438         = build_function_type_list (V2HI_type_node,
10439                                     V4QI_type_node, V2HI_type_node,
10440                                     NULL_TREE);
10441
10442       types[MIPS_SI_FTYPE_V2HI_V2HI]
10443         = build_function_type_list (intSI_type_node,
10444                                     V2HI_type_node, V2HI_type_node,
10445                                     NULL_TREE);
10446
10447       types[MIPS_DI_FTYPE_DI_V4QI_V4QI]
10448         = build_function_type_list (intDI_type_node,
10449                                     intDI_type_node, V4QI_type_node, V4QI_type_node,
10450                                     NULL_TREE);
10451
10452       types[MIPS_DI_FTYPE_DI_V2HI_V2HI]
10453         = build_function_type_list (intDI_type_node,
10454                                     intDI_type_node, V2HI_type_node, V2HI_type_node,
10455                                     NULL_TREE);
10456
10457       types[MIPS_DI_FTYPE_DI_SI_SI]
10458         = build_function_type_list (intDI_type_node,
10459                                     intDI_type_node, intSI_type_node, intSI_type_node,
10460                                     NULL_TREE);
10461
10462       types[MIPS_V4QI_FTYPE_SI]
10463         = build_function_type_list (V4QI_type_node,
10464                                     intSI_type_node,
10465                                     NULL_TREE);
10466
10467       types[MIPS_V2HI_FTYPE_SI]
10468         = build_function_type_list (V2HI_type_node,
10469                                     intSI_type_node,
10470                                     NULL_TREE);
10471
10472       types[MIPS_VOID_FTYPE_V4QI_V4QI]
10473         = build_function_type_list (void_type_node,
10474                                     V4QI_type_node, V4QI_type_node,
10475                                     NULL_TREE);
10476
10477       types[MIPS_SI_FTYPE_V4QI_V4QI]
10478         = build_function_type_list (intSI_type_node,
10479                                     V4QI_type_node, V4QI_type_node,
10480                                     NULL_TREE);
10481
10482       types[MIPS_VOID_FTYPE_V2HI_V2HI]
10483         = build_function_type_list (void_type_node,
10484                                     V2HI_type_node, V2HI_type_node,
10485                                     NULL_TREE);
10486
10487       types[MIPS_SI_FTYPE_DI_SI]
10488         = build_function_type_list (intSI_type_node,
10489                                     intDI_type_node, intSI_type_node,
10490                                     NULL_TREE);
10491
10492       types[MIPS_DI_FTYPE_DI_SI]
10493         = build_function_type_list (intDI_type_node,
10494                                     intDI_type_node, intSI_type_node,
10495                                     NULL_TREE);
10496
10497       types[MIPS_VOID_FTYPE_SI_SI]
10498         = build_function_type_list (void_type_node,
10499                                     intSI_type_node, intSI_type_node,
10500                                     NULL_TREE);
10501
10502       types[MIPS_SI_FTYPE_PTR_SI]
10503         = build_function_type_list (intSI_type_node,
10504                                     ptr_type_node, intSI_type_node,
10505                                     NULL_TREE);
10506
10507       types[MIPS_SI_FTYPE_VOID]
10508         = build_function_type (intSI_type_node, void_list_node);
10509     }
10510
10511   /* Iterate through all of the bdesc arrays, initializing all of the
10512      builtin functions.  */
10513
10514   offset = 0;
10515   for (m = bdesc_arrays; m < &bdesc_arrays[ARRAY_SIZE (bdesc_arrays)]; m++)
10516     {
10517       if (m->proc == PROCESSOR_MAX || (m->proc == mips_arch))
10518         for (d = m->bdesc; d < &m->bdesc[m->size]; d++)
10519           if ((d->target_flags & target_flags) == d->target_flags)
10520             lang_hooks.builtin_function (d->name, types[d->function_type],
10521                                          d - m->bdesc + offset,
10522                                          BUILT_IN_MD, NULL, NULL);
10523       offset += m->size;
10524     }
10525 }
10526
10527 /* Expand a MIPS_BUILTIN_DIRECT function.  ICODE is the code of the
10528    .md pattern and ARGLIST is the list of function arguments.  TARGET,
10529    if nonnull, suggests a good place to put the result.
10530    HAS_TARGET indicates the function must return something.  */
10531
10532 static rtx
10533 mips_expand_builtin_direct (enum insn_code icode, rtx target, tree arglist,
10534                             bool has_target)
10535 {
10536   rtx ops[MAX_RECOG_OPERANDS];
10537   int i = 0;
10538
10539   if (has_target)
10540     {
10541       /* We save target to ops[0].  */
10542       ops[0] = mips_prepare_builtin_target (icode, 0, target);
10543       i = 1;
10544     }
10545
10546   /* We need to test if arglist is not zero.  Some instructions have extra
10547      clobber registers.  */
10548   for (; i < insn_data[icode].n_operands && arglist != 0; i++)
10549     ops[i] = mips_prepare_builtin_arg (icode, i, &arglist);
10550
10551   switch (i)
10552     {
10553     case 2:
10554       emit_insn (GEN_FCN (icode) (ops[0], ops[1]));
10555       break;
10556
10557     case 3:
10558       emit_insn (GEN_FCN (icode) (ops[0], ops[1], ops[2]));
10559       break;
10560
10561     case 4:
10562       emit_insn (GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3]));
10563       break;
10564
10565     default:
10566       gcc_unreachable ();
10567     }
10568   return target;
10569 }
10570
10571 /* Expand a __builtin_mips_movt_*_ps() or __builtin_mips_movf_*_ps()
10572    function (TYPE says which).  ARGLIST is the list of arguments to the
10573    function, ICODE is the instruction that should be used to compare
10574    the first two arguments, and COND is the condition it should test.
10575    TARGET, if nonnull, suggests a good place to put the result.  */
10576
10577 static rtx
10578 mips_expand_builtin_movtf (enum mips_builtin_type type,
10579                            enum insn_code icode, enum mips_fp_condition cond,
10580                            rtx target, tree arglist)
10581 {
10582   rtx cmp_result, op0, op1;
10583
10584   cmp_result = mips_prepare_builtin_target (icode, 0, 0);
10585   op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10586   op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10587   emit_insn (GEN_FCN (icode) (cmp_result, op0, op1, GEN_INT (cond)));
10588
10589   icode = CODE_FOR_mips_cond_move_tf_ps;
10590   target = mips_prepare_builtin_target (icode, 0, target);
10591   if (type == MIPS_BUILTIN_MOVT)
10592     {
10593       op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10594       op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10595     }
10596   else
10597     {
10598       op0 = mips_prepare_builtin_arg (icode, 1, &arglist);
10599       op1 = mips_prepare_builtin_arg (icode, 2, &arglist);
10600     }
10601   emit_insn (gen_mips_cond_move_tf_ps (target, op0, op1, cmp_result));
10602   return target;
10603 }
10604
10605 /* Expand a comparison builtin of type BUILTIN_TYPE.  ICODE is the code
10606    of the comparison instruction and COND is the condition it should test.
10607    ARGLIST is the list of function arguments and TARGET, if nonnull,
10608    suggests a good place to put the boolean result.  */
10609
10610 static rtx
10611 mips_expand_builtin_compare (enum mips_builtin_type builtin_type,
10612                              enum insn_code icode, enum mips_fp_condition cond,
10613                              rtx target, tree arglist)
10614 {
10615   rtx label1, label2, if_then_else;
10616   rtx pat, cmp_result, ops[MAX_RECOG_OPERANDS];
10617   rtx target_if_equal, target_if_unequal;
10618   int cmp_value, i;
10619
10620   if (target == 0 || GET_MODE (target) != SImode)
10621     target = gen_reg_rtx (SImode);
10622
10623   /* Prepare the operands to the comparison.  */
10624   cmp_result = mips_prepare_builtin_target (icode, 0, 0);
10625   for (i = 1; i < insn_data[icode].n_operands - 1; i++)
10626     ops[i] = mips_prepare_builtin_arg (icode, i, &arglist);
10627
10628   switch (insn_data[icode].n_operands)
10629     {
10630     case 4:
10631       pat = GEN_FCN (icode) (cmp_result, ops[1], ops[2], GEN_INT (cond));
10632       break;
10633
10634     case 6:
10635       pat = GEN_FCN (icode) (cmp_result, ops[1], ops[2],
10636                              ops[3], ops[4], GEN_INT (cond));
10637       break;
10638
10639     default:
10640       gcc_unreachable ();
10641     }
10642
10643   /* If the comparison sets more than one register, we define the result
10644      to be 0 if all registers are false and -1 if all registers are true.
10645      The value of the complete result is indeterminate otherwise.  It is
10646      possible to test individual registers using SUBREGs.
10647
10648      Set up CMP_RESULT, CMP_VALUE, TARGET_IF_EQUAL and TARGET_IF_UNEQUAL so
10649      that the result should be TARGET_IF_EQUAL if (EQ CMP_RESULT CMP_VALUE)
10650      and TARGET_IF_UNEQUAL otherwise.  */
10651   if (builtin_type == MIPS_BUILTIN_CMP_ALL)
10652     {
10653       cmp_value = -1;
10654       target_if_equal = const1_rtx;
10655       target_if_unequal = const0_rtx;
10656     }
10657   else
10658     {
10659       cmp_value = 0;
10660       target_if_equal = const0_rtx;
10661       target_if_unequal = const1_rtx;
10662       if (builtin_type == MIPS_BUILTIN_CMP_UPPER)
10663         cmp_result = simplify_gen_subreg (CCmode, cmp_result, CCV2mode, 4);
10664       else if (builtin_type == MIPS_BUILTIN_CMP_LOWER)
10665         cmp_result = simplify_gen_subreg (CCmode, cmp_result, CCV2mode, 0);
10666     }
10667
10668   /* First assume that CMP_RESULT == CMP_VALUE.  */
10669   emit_move_insn (target, target_if_equal);
10670
10671   /* Branch to LABEL1 if CMP_RESULT != CMP_VALUE.  */
10672   emit_insn (pat);
10673   label1 = gen_label_rtx ();
10674   label2 = gen_label_rtx ();
10675   if_then_else
10676     = gen_rtx_IF_THEN_ELSE (VOIDmode,
10677                             gen_rtx_fmt_ee (NE, GET_MODE (cmp_result),
10678                                             cmp_result, GEN_INT (cmp_value)),
10679                             gen_rtx_LABEL_REF (VOIDmode, label1), pc_rtx);
10680   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, if_then_else));
10681   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
10682                                gen_rtx_LABEL_REF (VOIDmode, label2)));
10683   emit_barrier ();
10684   emit_label (label1);
10685
10686   /* Fix TARGET for CMP_RESULT != CMP_VALUE.  */
10687   emit_move_insn (target, target_if_unequal);
10688   emit_label (label2);
10689
10690   return target;
10691 }
10692
10693 /* Expand a bposge builtin of type BUILTIN_TYPE.  TARGET, if nonnull,
10694    suggests a good place to put the boolean result.
10695
10696    The sequence we want is
10697
10698         li      target, 0
10699         bposge* label1
10700         j       label2
10701    label1:
10702         li      target, 1
10703    label2:  */
10704
10705 static rtx
10706 mips_expand_builtin_bposge (enum mips_builtin_type builtin_type, rtx target)
10707 {
10708   rtx label1, label2, if_then_else;
10709   rtx cmp_result;
10710   int cmp_value;
10711
10712   if (target == 0 || GET_MODE (target) != SImode)
10713     target = gen_reg_rtx (SImode);
10714
10715   cmp_result = gen_rtx_REG (CCDSPmode, CCDSP_PO_REGNUM);
10716
10717   if (builtin_type == MIPS_BUILTIN_BPOSGE32)
10718     cmp_value = 32;
10719   else
10720     gcc_assert (0);
10721
10722   /* Move 0 to target */
10723   emit_move_insn (target, const0_rtx);
10724
10725   /* Generate two labels */
10726   label1 = gen_label_rtx ();
10727   label2 = gen_label_rtx ();
10728
10729   /* Generate if_then_else */
10730   if_then_else
10731     = gen_rtx_IF_THEN_ELSE (VOIDmode,
10732                             gen_rtx_fmt_ee (GE, CCDSPmode,
10733                                             cmp_result, GEN_INT (cmp_value)),
10734                             gen_rtx_LABEL_REF (VOIDmode, label1), pc_rtx);
10735
10736   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, if_then_else));
10737   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
10738                                gen_rtx_LABEL_REF (VOIDmode, label2)));
10739   emit_barrier ();
10740   emit_label (label1);
10741   emit_move_insn (target, const1_rtx);
10742   emit_label (label2);
10743
10744   return target;
10745 }
10746 \f
10747 /* Set SYMBOL_REF_FLAGS for the SYMBOL_REF inside RTL, which belongs to DECL.
10748    FIRST is true if this is the first time handling this decl.  */
10749
10750 static void
10751 mips_encode_section_info (tree decl, rtx rtl, int first)
10752 {
10753   default_encode_section_info (decl, rtl, first);
10754
10755   if (TREE_CODE (decl) == FUNCTION_DECL
10756       && lookup_attribute ("long_call", TYPE_ATTRIBUTES (TREE_TYPE (decl))))
10757     {
10758       rtx symbol = XEXP (rtl, 0);
10759       SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LONG_CALL;
10760     }
10761 }
10762 \f
10763 #include "gt-mips.h"