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