gcc/config/mips/mips.c

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