OSDN Git Service

da8b4aa4c961a0161bc2a505ca7adb7007e73305
[pf3gnuchains/gcc-fork.git] / 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, 2006, 2007
4    Free Software Foundation, Inc.
5    Contributed by A. Lichnewsky, lich@inria.inria.fr.
6    Changes by Michael Meissner, meissner@osf.org.
7    64-bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
8    Brendan Eich, brendan@microunity.com.
9
10 This file is part of GCC.
11
12 GCC is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
15 any later version.
16
17 GCC is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3.  If not see
24 <http://www.gnu.org/licenses/>.  */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include <signal.h>
31 #include "rtl.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "real.h"
35 #include "insn-config.h"
36 #include "conditions.h"
37 #include "insn-attr.h"
38 #include "recog.h"
39 #include "toplev.h"
40 #include "output.h"
41 #include "tree.h"
42 #include "function.h"
43 #include "expr.h"
44 #include "optabs.h"
45 #include "flags.h"
46 #include "reload.h"
47 #include "tm_p.h"
48 #include "ggc.h"
49 #include "gstab.h"
50 #include "hashtab.h"
51 #include "debug.h"
52 #include "target.h"
53 #include "target-def.h"
54 #include "integrate.h"
55 #include "langhooks.h"
56 #include "cfglayout.h"
57 #include "sched-int.h"
58 #include "tree-gimple.h"
59 #include "bitmap.h"
60 #include "diagnostic.h"
61
62 /* True if X is an UNSPEC wrapper around a SYMBOL_REF or LABEL_REF.  */
63 #define UNSPEC_ADDRESS_P(X)                                     \
64   (GET_CODE (X) == UNSPEC                                       \
65    && XINT (X, 1) >= UNSPEC_ADDRESS_FIRST                       \
66    && XINT (X, 1) < UNSPEC_ADDRESS_FIRST + NUM_SYMBOL_TYPES)
67
68 /* Extract the symbol or label from UNSPEC wrapper X.  */
69 #define UNSPEC_ADDRESS(X) \
70   XVECEXP (X, 0, 0)
71
72 /* Extract the symbol type from UNSPEC wrapper X.  */
73 #define UNSPEC_ADDRESS_TYPE(X) \
74   ((enum mips_symbol_type) (XINT (X, 1) - UNSPEC_ADDRESS_FIRST))
75
76 /* The maximum distance between the top of the stack frame and the
77    value $sp has when we save and restore registers.
78
79    The value for normal-mode code must be a SMALL_OPERAND and must
80    preserve the maximum stack alignment.  We therefore use a value
81    of 0x7ff0 in this case.
82
83    MIPS16e SAVE and RESTORE instructions can adjust the stack pointer by
84    up to 0x7f8 bytes and can usually save or restore all the registers
85    that we need to save or restore.  (Note that we can only use these
86    instructions for o32, for which the stack alignment is 8 bytes.)
87
88    We use a maximum gap of 0x100 or 0x400 for MIPS16 code when SAVE and
89    RESTORE are not available.  We can then use unextended instructions
90    to save and restore registers, and to allocate and deallocate the top
91    part of the frame.  */
92 #define MIPS_MAX_FIRST_STACK_STEP                                       \
93   (!TARGET_MIPS16 ? 0x7ff0                                              \
94    : GENERATE_MIPS16E_SAVE_RESTORE ? 0x7f8                              \
95    : TARGET_64BIT ? 0x100 : 0x400)
96
97 /* True if INSN is a mips.md pattern or asm statement.  */
98 #define USEFUL_INSN_P(INSN)                                             \
99   (INSN_P (INSN)                                                        \
100    && GET_CODE (PATTERN (INSN)) != USE                                  \
101    && GET_CODE (PATTERN (INSN)) != CLOBBER                              \
102    && GET_CODE (PATTERN (INSN)) != ADDR_VEC                             \
103    && GET_CODE (PATTERN (INSN)) != ADDR_DIFF_VEC)
104
105 /* If INSN is a delayed branch sequence, return the first instruction
106    in the sequence, otherwise return INSN itself.  */
107 #define SEQ_BEGIN(INSN)                                                 \
108   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
109    ? XVECEXP (PATTERN (INSN), 0, 0)                                     \
110    : (INSN))
111
112 /* Likewise for the last instruction in a delayed branch sequence.  */
113 #define SEQ_END(INSN)                                                   \
114   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
115    ? XVECEXP (PATTERN (INSN), 0, XVECLEN (PATTERN (INSN), 0) - 1)       \
116    : (INSN))
117
118 /* Execute the following loop body with SUBINSN set to each instruction
119    between SEQ_BEGIN (INSN) and SEQ_END (INSN) inclusive.  */
120 #define FOR_EACH_SUBINSN(SUBINSN, INSN)                                 \
121   for ((SUBINSN) = SEQ_BEGIN (INSN);                                    \
122        (SUBINSN) != NEXT_INSN (SEQ_END (INSN));                         \
123        (SUBINSN) = NEXT_INSN (SUBINSN))
124
125 /* True if bit BIT is set in VALUE.  */
126 #define BITSET_P(VALUE, BIT) (((VALUE) & (1 << (BIT))) != 0)
127
128 /* Classifies an address.
129
130    ADDRESS_REG
131        A natural register + offset address.  The register satisfies
132        mips_valid_base_register_p and the offset is a const_arith_operand.
133
134    ADDRESS_LO_SUM
135        A LO_SUM rtx.  The first operand is a valid base register and
136        the second operand is a symbolic address.
137
138    ADDRESS_CONST_INT
139        A signed 16-bit constant address.
140
141    ADDRESS_SYMBOLIC:
142        A constant symbolic address.  */
143 enum mips_address_type {
144   ADDRESS_REG,
145   ADDRESS_LO_SUM,
146   ADDRESS_CONST_INT,
147   ADDRESS_SYMBOLIC
148 };
149
150 /* Macros to create an enumeration identifier for a function prototype.  */
151 #define MIPS_FTYPE_NAME1(A, B) MIPS_##A##_FTYPE_##B
152 #define MIPS_FTYPE_NAME2(A, B, C) MIPS_##A##_FTYPE_##B##_##C
153 #define MIPS_FTYPE_NAME3(A, B, C, D) MIPS_##A##_FTYPE_##B##_##C##_##D
154 #define MIPS_FTYPE_NAME4(A, B, C, D, E) MIPS_##A##_FTYPE_##B##_##C##_##D##_##E
155
156 /* Classifies the prototype of a built-in function.  */
157 enum mips_function_type {
158 #define DEF_MIPS_FTYPE(NARGS, LIST) MIPS_FTYPE_NAME##NARGS LIST,
159 #include "config/mips/mips-ftypes.def"
160 #undef DEF_MIPS_FTYPE
161   MIPS_MAX_FTYPE_MAX
162 };
163
164 /* Specifies how a built-in function should be converted into rtl.  */
165 enum mips_builtin_type {
166   /* The function corresponds directly to an .md pattern.  The return
167      value is mapped to operand 0 and the arguments are mapped to
168      operands 1 and above.  */
169   MIPS_BUILTIN_DIRECT,
170
171   /* The function corresponds directly to an .md pattern.  There is no return
172      value and the arguments are mapped to operands 0 and above.  */
173   MIPS_BUILTIN_DIRECT_NO_TARGET,
174
175   /* The function corresponds to a comparison instruction followed by
176      a mips_cond_move_tf_ps pattern.  The first two arguments are the
177      values to compare and the second two arguments are the vector
178      operands for the movt.ps or movf.ps instruction (in assembly order).  */
179   MIPS_BUILTIN_MOVF,
180   MIPS_BUILTIN_MOVT,
181
182   /* The function corresponds to a V2SF comparison instruction.  Operand 0
183      of this instruction is the result of the comparison, which has mode
184      CCV2 or CCV4.  The function arguments are mapped to operands 1 and
185      above.  The function's return value is an SImode boolean that is
186      true under the following conditions:
187
188      MIPS_BUILTIN_CMP_ANY: one of the registers is true
189      MIPS_BUILTIN_CMP_ALL: all of the registers are true
190      MIPS_BUILTIN_CMP_LOWER: the first register is true
191      MIPS_BUILTIN_CMP_UPPER: the second register is true.  */
192   MIPS_BUILTIN_CMP_ANY,
193   MIPS_BUILTIN_CMP_ALL,
194   MIPS_BUILTIN_CMP_UPPER,
195   MIPS_BUILTIN_CMP_LOWER,
196
197   /* As above, but the instruction only sets a single $fcc register.  */
198   MIPS_BUILTIN_CMP_SINGLE,
199
200   /* For generating bposge32 branch instructions in MIPS32 DSP ASE.  */
201   MIPS_BUILTIN_BPOSGE32
202 };
203
204 /* Invoke MACRO (COND) for each C.cond.fmt condition.  */
205 #define MIPS_FP_CONDITIONS(MACRO) \
206   MACRO (f),    \
207   MACRO (un),   \
208   MACRO (eq),   \
209   MACRO (ueq),  \
210   MACRO (olt),  \
211   MACRO (ult),  \
212   MACRO (ole),  \
213   MACRO (ule),  \
214   MACRO (sf),   \
215   MACRO (ngle), \
216   MACRO (seq),  \
217   MACRO (ngl),  \
218   MACRO (lt),   \
219   MACRO (nge),  \
220   MACRO (le),   \
221   MACRO (ngt)
222
223 /* Enumerates the codes above as MIPS_FP_COND_<X>.  */
224 #define DECLARE_MIPS_COND(X) MIPS_FP_COND_ ## X
225 enum mips_fp_condition {
226   MIPS_FP_CONDITIONS (DECLARE_MIPS_COND)
227 };
228
229 /* Index X provides the string representation of MIPS_FP_COND_<X>.  */
230 #define STRINGIFY(X) #X
231 static const char *const mips_fp_conditions[] = {
232   MIPS_FP_CONDITIONS (STRINGIFY)
233 };
234
235 /* Information about a function's frame layout.  */
236 struct mips_frame_info GTY(()) {
237   /* The size of the frame in bytes.  */
238   HOST_WIDE_INT total_size;
239
240   /* The number of bytes allocated to variables.  */
241   HOST_WIDE_INT var_size;
242
243   /* The number of bytes allocated to outgoing function arguments.  */
244   HOST_WIDE_INT args_size;
245
246   /* The number of bytes allocated to the .cprestore slot, or 0 if there
247      is no such slot.  */
248   HOST_WIDE_INT cprestore_size;
249
250   /* Bit X is set if the function saves or restores GPR X.  */
251   unsigned int mask;
252
253   /* Likewise FPR X.  */
254   unsigned int fmask;
255
256   /* The number of GPRs and FPRs saved.  */
257   unsigned int num_gp;
258   unsigned int num_fp;
259
260   /* The offset of the topmost GPR and FPR save slots from the top of
261      the frame, or zero if no such slots are needed.  */
262   HOST_WIDE_INT gp_save_offset;
263   HOST_WIDE_INT fp_save_offset;
264
265   /* Likewise, but giving offsets from the bottom of the frame.  */
266   HOST_WIDE_INT gp_sp_offset;
267   HOST_WIDE_INT fp_sp_offset;
268
269   /* The offset of arg_pointer_rtx from frame_pointer_rtx.  */
270   HOST_WIDE_INT arg_pointer_offset;
271
272   /* The offset of hard_frame_pointer_rtx from frame_pointer_rtx.  */
273   HOST_WIDE_INT hard_frame_pointer_offset;
274 };
275
276 struct machine_function GTY(()) {
277   /* The register returned by mips16_gp_pseudo_reg; see there for details.  */
278   rtx mips16_gp_pseudo_rtx;
279
280   /* The number of extra stack bytes taken up by register varargs.
281      This area is allocated by the callee at the very top of the frame.  */
282   int varargs_size;
283
284   /* The current frame information, calculated by mips_compute_frame_info.  */
285   struct mips_frame_info frame;
286
287   /* The register to use as the function's global pointer.  */
288   unsigned int global_pointer;
289
290   /* True if mips_adjust_insn_length should ignore an instruction's
291      hazard attribute.  */
292   bool ignore_hazard_length_p;
293
294   /* True if the whole function is suitable for .set noreorder and
295      .set nomacro.  */
296   bool all_noreorder_p;
297
298   /* True if the function is known to have an instruction that needs $gp.  */
299   bool has_gp_insn_p;
300
301   /* True if we have emitted an instruction to initialize
302      mips16_gp_pseudo_rtx.  */
303   bool initialized_mips16_gp_pseudo_p;
304 };
305
306 /* Information about a single argument.  */
307 struct mips_arg_info {
308   /* True if the argument is passed in a floating-point register, or
309      would have been if we hadn't run out of registers.  */
310   bool fpr_p;
311
312   /* The number of words passed in registers, rounded up.  */
313   unsigned int reg_words;
314
315   /* For EABI, the offset of the first register from GP_ARG_FIRST or
316      FP_ARG_FIRST.  For other ABIs, the offset of the first register from
317      the start of the ABI's argument structure (see the CUMULATIVE_ARGS
318      comment for details).
319
320      The value is MAX_ARGS_IN_REGISTERS if the argument is passed entirely
321      on the stack.  */
322   unsigned int reg_offset;
323
324   /* The number of words that must be passed on the stack, rounded up.  */
325   unsigned int stack_words;
326
327   /* The offset from the start of the stack overflow area of the argument's
328      first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
329   unsigned int stack_offset;
330 };
331
332 /* Information about an address described by mips_address_type.
333
334    ADDRESS_CONST_INT
335        No fields are used.
336
337    ADDRESS_REG
338        REG is the base register and OFFSET is the constant offset.
339
340    ADDRESS_LO_SUM
341        REG and OFFSET are the operands to the LO_SUM and SYMBOL_TYPE
342        is the type of symbol it references.
343
344    ADDRESS_SYMBOLIC
345        SYMBOL_TYPE is the type of symbol that the address references.  */
346 struct mips_address_info {
347   enum mips_address_type type;
348   rtx reg;
349   rtx offset;
350   enum mips_symbol_type symbol_type;
351 };
352
353 /* One stage in a constant building sequence.  These sequences have
354    the form:
355
356         A = VALUE[0]
357         A = A CODE[1] VALUE[1]
358         A = A CODE[2] VALUE[2]
359         ...
360
361    where A is an accumulator, each CODE[i] is a binary rtl operation
362    and each VALUE[i] is a constant integer.  CODE[0] is undefined.  */
363 struct mips_integer_op {
364   enum rtx_code code;
365   unsigned HOST_WIDE_INT value;
366 };
367
368 /* The largest number of operations needed to load an integer constant.
369    The worst accepted case for 64-bit constants is LUI,ORI,SLL,ORI,SLL,ORI.
370    When the lowest bit is clear, we can try, but reject a sequence with
371    an extra SLL at the end.  */
372 #define MIPS_MAX_INTEGER_OPS 7
373
374 /* Information about a MIPS16e SAVE or RESTORE instruction.  */
375 struct mips16e_save_restore_info {
376   /* The number of argument registers saved by a SAVE instruction.
377      0 for RESTORE instructions.  */
378   unsigned int nargs;
379
380   /* Bit X is set if the instruction saves or restores GPR X.  */
381   unsigned int mask;
382
383   /* The total number of bytes to allocate.  */
384   HOST_WIDE_INT size;
385 };
386
387 /* Global variables for machine-dependent things.  */
388
389 /* The -G setting, or the configuration's default small-data limit if
390    no -G option is given.  */
391 static unsigned int mips_small_data_threshold;
392
393 /* The number of file directives written by mips_output_filename.  */
394 int num_source_filenames;
395
396 /* The name that appeared in the last .file directive written by
397    mips_output_filename, or "" if mips_output_filename hasn't
398    written anything yet.  */
399 const char *current_function_file = "";
400
401 /* A label counter used by PUT_SDB_BLOCK_START and PUT_SDB_BLOCK_END.  */
402 int sdb_label_count;
403
404 /* Arrays that map GCC register numbers to debugger register numbers.  */
405 int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
406 int mips_dwarf_regno[FIRST_PSEUDO_REGISTER];
407
408 /* The nesting depth of the PRINT_OPERAND '%(', '%<' and '%[' constructs.  */
409 int set_noreorder;
410 int set_nomacro;
411 static int set_noat;
412
413 /* True if we're writing out a branch-likely instruction rather than a
414    normal branch.  */
415 static bool mips_branch_likely;
416
417 /* The operands passed to the last cmpMM expander.  */
418 rtx cmp_operands[2];
419
420 /* The current instruction-set architecture.  */
421 enum processor_type mips_arch;
422 const struct mips_cpu_info *mips_arch_info;
423
424 /* The processor that we should tune the code for.  */
425 enum processor_type mips_tune;
426 const struct mips_cpu_info *mips_tune_info;
427
428 /* The ISA level associated with mips_arch.  */
429 int mips_isa;
430
431 /* The architecture selected by -mipsN, or null if -mipsN wasn't used.  */
432 static const struct mips_cpu_info *mips_isa_option_info;
433
434 /* Which ABI to use.  */
435 int mips_abi = MIPS_ABI_DEFAULT;
436
437 /* Which cost information to use.  */
438 const struct mips_rtx_cost_data *mips_cost;
439
440 /* The ambient target flags, excluding MASK_MIPS16.  */
441 static int mips_base_target_flags;
442
443 /* True if MIPS16 is the default mode.  */
444 static bool mips_base_mips16;
445
446 /* The ambient values of other global variables.  */
447 static int mips_base_delayed_branch; /* flag_delayed_branch */
448 static int mips_base_schedule_insns; /* flag_schedule_insns */
449 static int mips_base_reorder_blocks_and_partition; /* flag_reorder... */
450 static int mips_base_move_loop_invariants; /* flag_move_loop_invariants */
451 static int mips_base_align_loops; /* align_loops */
452 static int mips_base_align_jumps; /* align_jumps */
453 static int mips_base_align_functions; /* align_functions */
454
455 /* The -mcode-readable setting.  */
456 enum mips_code_readable_setting mips_code_readable = CODE_READABLE_YES;
457
458 /* Index [M][R] is true if register R is allowed to hold a value of mode M.  */
459 bool mips_hard_regno_mode_ok[(int) MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
460
461 /* Index C is true if character C is a valid PRINT_OPERAND punctation
462    character.  */
463 bool mips_print_operand_punct[256];
464
465 static GTY (()) int mips_output_filename_first_time = 1;
466
467 /* mips_split_p[X] is true if symbols of type X can be split by
468    mips_split_symbol.  */
469 bool mips_split_p[NUM_SYMBOL_TYPES];
470
471 /* mips_lo_relocs[X] is the relocation to use when a symbol of type X
472    appears in a LO_SUM.  It can be null if such LO_SUMs aren't valid or
473    if they are matched by a special .md file pattern.  */
474 static const char *mips_lo_relocs[NUM_SYMBOL_TYPES];
475
476 /* Likewise for HIGHs.  */
477 static const char *mips_hi_relocs[NUM_SYMBOL_TYPES];
478
479 /* Index R is the smallest register class that contains register R.  */
480 const enum reg_class mips_regno_to_class[FIRST_PSEUDO_REGISTER] = {
481   LEA_REGS,     LEA_REGS,       M16_NA_REGS,    V1_REG,
482   M16_REGS,     M16_REGS,       M16_REGS,       M16_REGS,
483   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
484   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
485   M16_NA_REGS,  M16_NA_REGS,    LEA_REGS,       LEA_REGS,
486   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
487   T_REG,        PIC_FN_ADDR_REG, LEA_REGS,      LEA_REGS,
488   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
489   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
490   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
491   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
492   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
493   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
494   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
495   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
496   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
497   MD0_REG,      MD1_REG,        NO_REGS,        ST_REGS,
498   ST_REGS,      ST_REGS,        ST_REGS,        ST_REGS,
499   ST_REGS,      ST_REGS,        ST_REGS,        NO_REGS,
500   NO_REGS,      ALL_REGS,       ALL_REGS,       NO_REGS,
501   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
502   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
503   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
504   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
505   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
506   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
507   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
508   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
509   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
510   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
511   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
512   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
513   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
514   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
515   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
516   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
517   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
518   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
519   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
520   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
521   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
522   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
523   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
524   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
525   DSP_ACC_REGS, DSP_ACC_REGS,   DSP_ACC_REGS,   DSP_ACC_REGS,
526   DSP_ACC_REGS, DSP_ACC_REGS,   ALL_REGS,       ALL_REGS,
527   ALL_REGS,     ALL_REGS,       ALL_REGS,       ALL_REGS
528 };
529
530 /* The value of TARGET_ATTRIBUTE_TABLE.  */
531 const struct attribute_spec mips_attribute_table[] = {
532   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
533   { "long_call",   0, 0, false, true,  true,  NULL },
534   { "far",         0, 0, false, true,  true,  NULL },
535   { "near",        0, 0, false, true,  true,  NULL },
536   /* We would really like to treat "mips16" and "nomips16" as type
537      attributes, but GCC doesn't provide the hooks we need to support
538      the right conversion rules.  As declaration attributes, they affect
539      code generation but don't carry other semantics.  */
540   { "mips16",      0, 0, true,  false, false, NULL },
541   { "nomips16",    0, 0, true,  false, false, NULL },
542   { NULL,          0, 0, false, false, false, NULL }
543 };
544 \f
545 /* A table describing all the processors GCC knows about.  Names are
546    matched in the order listed.  The first mention of an ISA level is
547    taken as the canonical name for that ISA.
548
549    To ease comparison, please keep this table in the same order
550    as GAS's mips_cpu_info_table.  Please also make sure that
551    MIPS_ISA_LEVEL_SPEC and MIPS_ARCH_FLOAT_SPEC handle all -march
552    options correctly.  */
553 static const struct mips_cpu_info mips_cpu_info_table[] = {
554   /* Entries for generic ISAs.  */
555   { "mips1", PROCESSOR_R3000, 1, 0 },
556   { "mips2", PROCESSOR_R6000, 2, 0 },
557   { "mips3", PROCESSOR_R4000, 3, 0 },
558   { "mips4", PROCESSOR_R8000, 4, 0 },
559   /* Prefer not to use branch-likely instructions for generic MIPS32rX
560      and MIPS64rX code.  The instructions were officially deprecated
561      in revisions 2 and earlier, but revision 3 is likely to downgrade
562      that to a recommendation to avoid the instructions in code that
563      isn't tuned to a specific processor.  */
564   { "mips32", PROCESSOR_4KC, 32, PTF_AVOID_BRANCHLIKELY },
565   { "mips32r2", PROCESSOR_M4K, 33, PTF_AVOID_BRANCHLIKELY },
566   { "mips64", PROCESSOR_5KC, 64, PTF_AVOID_BRANCHLIKELY },
567
568   /* MIPS I processors.  */
569   { "r3000", PROCESSOR_R3000, 1, 0 },
570   { "r2000", PROCESSOR_R3000, 1, 0 },
571   { "r3900", PROCESSOR_R3900, 1, 0 },
572
573   /* MIPS II processors.  */
574   { "r6000", PROCESSOR_R6000, 2, 0 },
575
576   /* MIPS III processors.  */
577   { "r4000", PROCESSOR_R4000, 3, 0 },
578   { "vr4100", PROCESSOR_R4100, 3, 0 },
579   { "vr4111", PROCESSOR_R4111, 3, 0 },
580   { "vr4120", PROCESSOR_R4120, 3, 0 },
581   { "vr4130", PROCESSOR_R4130, 3, 0 },
582   { "vr4300", PROCESSOR_R4300, 3, 0 },
583   { "r4400", PROCESSOR_R4000, 3, 0 },
584   { "r4600", PROCESSOR_R4600, 3, 0 },
585   { "orion", PROCESSOR_R4600, 3, 0 },
586   { "r4650", PROCESSOR_R4650, 3, 0 },
587
588   /* MIPS IV processors. */
589   { "r8000", PROCESSOR_R8000, 4, 0 },
590   { "vr5000", PROCESSOR_R5000, 4, 0 },
591   { "vr5400", PROCESSOR_R5400, 4, 0 },
592   { "vr5500", PROCESSOR_R5500, 4, PTF_AVOID_BRANCHLIKELY },
593   { "rm7000", PROCESSOR_R7000, 4, 0 },
594   { "rm9000", PROCESSOR_R9000, 4, 0 },
595
596   /* MIPS32 processors.  */
597   { "4kc", PROCESSOR_4KC, 32, 0 },
598   { "4km", PROCESSOR_4KC, 32, 0 },
599   { "4kp", PROCESSOR_4KP, 32, 0 },
600   { "4ksc", PROCESSOR_4KC, 32, 0 },
601
602   /* MIPS32 Release 2 processors.  */
603   { "m4k", PROCESSOR_M4K, 33, 0 },
604   { "4kec", PROCESSOR_4KC, 33, 0 },
605   { "4kem", PROCESSOR_4KC, 33, 0 },
606   { "4kep", PROCESSOR_4KP, 33, 0 },
607   { "4ksd", PROCESSOR_4KC, 33, 0 },
608
609   { "24kc", PROCESSOR_24KC, 33, 0 },
610   { "24kf2_1", PROCESSOR_24KF2_1, 33, 0 },
611   { "24kf", PROCESSOR_24KF2_1, 33, 0 },
612   { "24kf1_1", PROCESSOR_24KF1_1, 33, 0 },
613   { "24kfx", PROCESSOR_24KF1_1, 33, 0 },
614   { "24kx", PROCESSOR_24KF1_1, 33, 0 },
615
616   { "24kec", PROCESSOR_24KC, 33, 0 }, /* 24K with DSP.  */
617   { "24kef2_1", PROCESSOR_24KF2_1, 33, 0 },
618   { "24kef", PROCESSOR_24KF2_1, 33, 0 },
619   { "24kef1_1", PROCESSOR_24KF1_1, 33, 0 },
620   { "24kefx", PROCESSOR_24KF1_1, 33, 0 },
621   { "24kex", PROCESSOR_24KF1_1, 33, 0 },
622
623   { "34kc", PROCESSOR_24KC, 33, 0 }, /* 34K with MT/DSP.  */
624   { "34kf2_1", PROCESSOR_24KF2_1, 33, 0 },
625   { "34kf", PROCESSOR_24KF2_1, 33, 0 },
626   { "34kf1_1", PROCESSOR_24KF1_1, 33, 0 },
627   { "34kfx", PROCESSOR_24KF1_1, 33, 0 },
628   { "34kx", PROCESSOR_24KF1_1, 33, 0 },
629
630   { "74kc", PROCESSOR_74KC, 33, 0 }, /* 74K with DSPr2.  */
631   { "74kf2_1", PROCESSOR_74KF2_1, 33, 0 },
632   { "74kf", PROCESSOR_74KF2_1, 33, 0 },
633   { "74kf1_1", PROCESSOR_74KF1_1, 33, 0 },
634   { "74kfx", PROCESSOR_74KF1_1, 33, 0 },
635   { "74kx", PROCESSOR_74KF1_1, 33, 0 },
636   { "74kf3_2", PROCESSOR_74KF3_2, 33, 0 },
637
638   /* MIPS64 processors.  */
639   { "5kc", PROCESSOR_5KC, 64, 0 },
640   { "5kf", PROCESSOR_5KF, 64, 0 },
641   { "20kc", PROCESSOR_20KC, 64, PTF_AVOID_BRANCHLIKELY },
642   { "sb1", PROCESSOR_SB1, 64, PTF_AVOID_BRANCHLIKELY },
643   { "sb1a", PROCESSOR_SB1A, 64, PTF_AVOID_BRANCHLIKELY },
644   { "sr71000", PROCESSOR_SR71000, 64, PTF_AVOID_BRANCHLIKELY },
645 };
646
647 /* Default costs.  If these are used for a processor we should look
648    up the actual costs.  */
649 #define DEFAULT_COSTS COSTS_N_INSNS (6),  /* fp_add */       \
650                       COSTS_N_INSNS (7),  /* fp_mult_sf */   \
651                       COSTS_N_INSNS (8),  /* fp_mult_df */   \
652                       COSTS_N_INSNS (23), /* fp_div_sf */    \
653                       COSTS_N_INSNS (36), /* fp_div_df */    \
654                       COSTS_N_INSNS (10), /* int_mult_si */  \
655                       COSTS_N_INSNS (10), /* int_mult_di */  \
656                       COSTS_N_INSNS (69), /* int_div_si */   \
657                       COSTS_N_INSNS (69), /* int_div_di */   \
658                                        2, /* branch_cost */  \
659                                        4  /* memory_latency */
660
661 /* Floating-point costs for processors without an FPU.  Just assume that
662    all floating-point libcalls are very expensive.  */
663 #define SOFT_FP_COSTS COSTS_N_INSNS (256), /* fp_add */       \
664                       COSTS_N_INSNS (256), /* fp_mult_sf */   \
665                       COSTS_N_INSNS (256), /* fp_mult_df */   \
666                       COSTS_N_INSNS (256), /* fp_div_sf */    \
667                       COSTS_N_INSNS (256)  /* fp_div_df */
668
669 /* Costs to use when optimizing for size.  */
670 static const struct mips_rtx_cost_data mips_rtx_cost_optimize_size = {
671   COSTS_N_INSNS (1),            /* fp_add */
672   COSTS_N_INSNS (1),            /* fp_mult_sf */
673   COSTS_N_INSNS (1),            /* fp_mult_df */
674   COSTS_N_INSNS (1),            /* fp_div_sf */
675   COSTS_N_INSNS (1),            /* fp_div_df */
676   COSTS_N_INSNS (1),            /* int_mult_si */
677   COSTS_N_INSNS (1),            /* int_mult_di */
678   COSTS_N_INSNS (1),            /* int_div_si */
679   COSTS_N_INSNS (1),            /* int_div_di */
680                    2,           /* branch_cost */
681                    4            /* memory_latency */
682 };
683
684 /* Costs to use when optimizing for speed, indexed by processor.  */
685 static const struct mips_rtx_cost_data mips_rtx_cost_data[PROCESSOR_MAX] = {
686   { /* R3000 */
687     COSTS_N_INSNS (2),            /* fp_add */
688     COSTS_N_INSNS (4),            /* fp_mult_sf */
689     COSTS_N_INSNS (5),            /* fp_mult_df */
690     COSTS_N_INSNS (12),           /* fp_div_sf */
691     COSTS_N_INSNS (19),           /* fp_div_df */
692     COSTS_N_INSNS (12),           /* int_mult_si */
693     COSTS_N_INSNS (12),           /* int_mult_di */
694     COSTS_N_INSNS (35),           /* int_div_si */
695     COSTS_N_INSNS (35),           /* int_div_di */
696                      1,           /* branch_cost */
697                      4            /* memory_latency */
698   },
699   { /* 4KC */
700     SOFT_FP_COSTS,
701     COSTS_N_INSNS (6),            /* int_mult_si */
702     COSTS_N_INSNS (6),            /* int_mult_di */
703     COSTS_N_INSNS (36),           /* int_div_si */
704     COSTS_N_INSNS (36),           /* int_div_di */
705                      1,           /* branch_cost */
706                      4            /* memory_latency */
707   },
708   { /* 4KP */
709     SOFT_FP_COSTS,
710     COSTS_N_INSNS (36),           /* int_mult_si */
711     COSTS_N_INSNS (36),           /* int_mult_di */
712     COSTS_N_INSNS (37),           /* int_div_si */
713     COSTS_N_INSNS (37),           /* int_div_di */
714                      1,           /* branch_cost */
715                      4            /* memory_latency */
716   },
717   { /* 5KC */
718     SOFT_FP_COSTS,
719     COSTS_N_INSNS (4),            /* int_mult_si */
720     COSTS_N_INSNS (11),           /* int_mult_di */
721     COSTS_N_INSNS (36),           /* int_div_si */
722     COSTS_N_INSNS (68),           /* int_div_di */
723                      1,           /* branch_cost */
724                      4            /* memory_latency */
725   },
726   { /* 5KF */
727     COSTS_N_INSNS (4),            /* fp_add */
728     COSTS_N_INSNS (4),            /* fp_mult_sf */
729     COSTS_N_INSNS (5),            /* fp_mult_df */
730     COSTS_N_INSNS (17),           /* fp_div_sf */
731     COSTS_N_INSNS (32),           /* fp_div_df */
732     COSTS_N_INSNS (4),            /* int_mult_si */
733     COSTS_N_INSNS (11),           /* int_mult_di */
734     COSTS_N_INSNS (36),           /* int_div_si */
735     COSTS_N_INSNS (68),           /* int_div_di */
736                      1,           /* branch_cost */
737                      4            /* memory_latency */
738   },
739   { /* 20KC */
740     COSTS_N_INSNS (4),            /* fp_add */
741     COSTS_N_INSNS (4),            /* fp_mult_sf */
742     COSTS_N_INSNS (5),            /* fp_mult_df */
743     COSTS_N_INSNS (17),           /* fp_div_sf */
744     COSTS_N_INSNS (32),           /* fp_div_df */
745     COSTS_N_INSNS (4),            /* int_mult_si */
746     COSTS_N_INSNS (7),            /* int_mult_di */
747     COSTS_N_INSNS (42),           /* int_div_si */
748     COSTS_N_INSNS (72),           /* int_div_di */
749                      1,           /* branch_cost */
750                      4            /* memory_latency */
751   },
752   { /* 24KC */
753     SOFT_FP_COSTS,
754     COSTS_N_INSNS (5),            /* int_mult_si */
755     COSTS_N_INSNS (5),            /* int_mult_di */
756     COSTS_N_INSNS (41),           /* int_div_si */
757     COSTS_N_INSNS (41),           /* int_div_di */
758                      1,           /* branch_cost */
759                      4            /* memory_latency */
760   },
761   { /* 24KF2_1 */
762     COSTS_N_INSNS (8),            /* fp_add */
763     COSTS_N_INSNS (8),            /* fp_mult_sf */
764     COSTS_N_INSNS (10),           /* fp_mult_df */
765     COSTS_N_INSNS (34),           /* fp_div_sf */
766     COSTS_N_INSNS (64),           /* fp_div_df */
767     COSTS_N_INSNS (5),            /* int_mult_si */
768     COSTS_N_INSNS (5),            /* int_mult_di */
769     COSTS_N_INSNS (41),           /* int_div_si */
770     COSTS_N_INSNS (41),           /* int_div_di */
771                      1,           /* branch_cost */
772                      4            /* memory_latency */
773   },
774   { /* 24KF1_1 */
775     COSTS_N_INSNS (4),            /* fp_add */
776     COSTS_N_INSNS (4),            /* fp_mult_sf */
777     COSTS_N_INSNS (5),            /* fp_mult_df */
778     COSTS_N_INSNS (17),           /* fp_div_sf */
779     COSTS_N_INSNS (32),           /* fp_div_df */
780     COSTS_N_INSNS (5),            /* int_mult_si */
781     COSTS_N_INSNS (5),            /* int_mult_di */
782     COSTS_N_INSNS (41),           /* int_div_si */
783     COSTS_N_INSNS (41),           /* int_div_di */
784                      1,           /* branch_cost */
785                      4            /* memory_latency */
786   },
787   { /* 74KC */
788     SOFT_FP_COSTS,
789     COSTS_N_INSNS (5),            /* int_mult_si */
790     COSTS_N_INSNS (5),            /* int_mult_di */
791     COSTS_N_INSNS (41),           /* int_div_si */
792     COSTS_N_INSNS (41),           /* int_div_di */
793                      1,           /* branch_cost */
794                      4            /* memory_latency */
795   },
796   { /* 74KF2_1 */
797     COSTS_N_INSNS (8),            /* fp_add */
798     COSTS_N_INSNS (8),            /* fp_mult_sf */
799     COSTS_N_INSNS (10),           /* fp_mult_df */
800     COSTS_N_INSNS (34),           /* fp_div_sf */
801     COSTS_N_INSNS (64),           /* fp_div_df */
802     COSTS_N_INSNS (5),            /* int_mult_si */
803     COSTS_N_INSNS (5),            /* int_mult_di */
804     COSTS_N_INSNS (41),           /* int_div_si */
805     COSTS_N_INSNS (41),           /* int_div_di */
806                      1,           /* branch_cost */
807                      4            /* memory_latency */
808   },
809   { /* 74KF1_1 */
810     COSTS_N_INSNS (4),            /* fp_add */
811     COSTS_N_INSNS (4),            /* fp_mult_sf */
812     COSTS_N_INSNS (5),            /* fp_mult_df */
813     COSTS_N_INSNS (17),           /* fp_div_sf */
814     COSTS_N_INSNS (32),           /* fp_div_df */
815     COSTS_N_INSNS (5),            /* int_mult_si */
816     COSTS_N_INSNS (5),            /* int_mult_di */
817     COSTS_N_INSNS (41),           /* int_div_si */
818     COSTS_N_INSNS (41),           /* int_div_di */
819                      1,           /* branch_cost */
820                      4            /* memory_latency */
821   },
822   { /* 74KF3_2 */
823     COSTS_N_INSNS (6),            /* fp_add */
824     COSTS_N_INSNS (6),            /* fp_mult_sf */
825     COSTS_N_INSNS (7),            /* fp_mult_df */
826     COSTS_N_INSNS (25),           /* fp_div_sf */
827     COSTS_N_INSNS (48),           /* fp_div_df */
828     COSTS_N_INSNS (5),            /* int_mult_si */
829     COSTS_N_INSNS (5),            /* int_mult_di */
830     COSTS_N_INSNS (41),           /* int_div_si */
831     COSTS_N_INSNS (41),           /* int_div_di */
832                      1,           /* branch_cost */
833                      4            /* memory_latency */
834   },
835   { /* M4k */
836     DEFAULT_COSTS
837   },
838   { /* R3900 */
839     COSTS_N_INSNS (2),            /* fp_add */
840     COSTS_N_INSNS (4),            /* fp_mult_sf */
841     COSTS_N_INSNS (5),            /* fp_mult_df */
842     COSTS_N_INSNS (12),           /* fp_div_sf */
843     COSTS_N_INSNS (19),           /* fp_div_df */
844     COSTS_N_INSNS (2),            /* int_mult_si */
845     COSTS_N_INSNS (2),            /* int_mult_di */
846     COSTS_N_INSNS (35),           /* int_div_si */
847     COSTS_N_INSNS (35),           /* int_div_di */
848                      1,           /* branch_cost */
849                      4            /* memory_latency */
850   },
851   { /* R6000 */
852     COSTS_N_INSNS (3),            /* fp_add */
853     COSTS_N_INSNS (5),            /* fp_mult_sf */
854     COSTS_N_INSNS (6),            /* fp_mult_df */
855     COSTS_N_INSNS (15),           /* fp_div_sf */
856     COSTS_N_INSNS (16),           /* fp_div_df */
857     COSTS_N_INSNS (17),           /* int_mult_si */
858     COSTS_N_INSNS (17),           /* int_mult_di */
859     COSTS_N_INSNS (38),           /* int_div_si */
860     COSTS_N_INSNS (38),           /* int_div_di */
861                      2,           /* branch_cost */
862                      6            /* memory_latency */
863   },
864   { /* R4000 */
865      COSTS_N_INSNS (6),           /* fp_add */
866      COSTS_N_INSNS (7),           /* fp_mult_sf */
867      COSTS_N_INSNS (8),           /* fp_mult_df */
868      COSTS_N_INSNS (23),          /* fp_div_sf */
869      COSTS_N_INSNS (36),          /* fp_div_df */
870      COSTS_N_INSNS (10),          /* int_mult_si */
871      COSTS_N_INSNS (10),          /* int_mult_di */
872      COSTS_N_INSNS (69),          /* int_div_si */
873      COSTS_N_INSNS (69),          /* int_div_di */
874                       2,          /* branch_cost */
875                       6           /* memory_latency */
876   },
877   { /* R4100 */
878     DEFAULT_COSTS
879   },
880   { /* R4111 */
881     DEFAULT_COSTS
882   },
883   { /* R4120 */
884     DEFAULT_COSTS
885   },
886   { /* R4130 */
887     /* The only costs that appear to be updated here are
888        integer multiplication.  */
889     SOFT_FP_COSTS,
890     COSTS_N_INSNS (4),            /* int_mult_si */
891     COSTS_N_INSNS (6),            /* int_mult_di */
892     COSTS_N_INSNS (69),           /* int_div_si */
893     COSTS_N_INSNS (69),           /* int_div_di */
894                      1,           /* branch_cost */
895                      4            /* memory_latency */
896   },
897   { /* R4300 */
898     DEFAULT_COSTS
899   },
900   { /* R4600 */
901     DEFAULT_COSTS
902   },
903   { /* R4650 */
904     DEFAULT_COSTS
905   },
906   { /* R5000 */
907     COSTS_N_INSNS (6),            /* fp_add */
908     COSTS_N_INSNS (4),            /* fp_mult_sf */
909     COSTS_N_INSNS (5),            /* fp_mult_df */
910     COSTS_N_INSNS (23),           /* fp_div_sf */
911     COSTS_N_INSNS (36),           /* fp_div_df */
912     COSTS_N_INSNS (5),            /* int_mult_si */
913     COSTS_N_INSNS (5),            /* int_mult_di */
914     COSTS_N_INSNS (36),           /* int_div_si */
915     COSTS_N_INSNS (36),           /* int_div_di */
916                      1,           /* branch_cost */
917                      4            /* memory_latency */
918   },
919   { /* R5400 */
920     COSTS_N_INSNS (6),            /* fp_add */
921     COSTS_N_INSNS (5),            /* fp_mult_sf */
922     COSTS_N_INSNS (6),            /* fp_mult_df */
923     COSTS_N_INSNS (30),           /* fp_div_sf */
924     COSTS_N_INSNS (59),           /* fp_div_df */
925     COSTS_N_INSNS (3),            /* int_mult_si */
926     COSTS_N_INSNS (4),            /* int_mult_di */
927     COSTS_N_INSNS (42),           /* int_div_si */
928     COSTS_N_INSNS (74),           /* int_div_di */
929                      1,           /* branch_cost */
930                      4            /* memory_latency */
931   },
932   { /* R5500 */
933     COSTS_N_INSNS (6),            /* fp_add */
934     COSTS_N_INSNS (5),            /* fp_mult_sf */
935     COSTS_N_INSNS (6),            /* fp_mult_df */
936     COSTS_N_INSNS (30),           /* fp_div_sf */
937     COSTS_N_INSNS (59),           /* fp_div_df */
938     COSTS_N_INSNS (5),            /* int_mult_si */
939     COSTS_N_INSNS (9),            /* int_mult_di */
940     COSTS_N_INSNS (42),           /* int_div_si */
941     COSTS_N_INSNS (74),           /* int_div_di */
942                      1,           /* branch_cost */
943                      4            /* memory_latency */
944   },
945   { /* R7000 */
946     /* The only costs that are changed here are
947        integer multiplication.  */
948     COSTS_N_INSNS (6),            /* fp_add */
949     COSTS_N_INSNS (7),            /* fp_mult_sf */
950     COSTS_N_INSNS (8),            /* fp_mult_df */
951     COSTS_N_INSNS (23),           /* fp_div_sf */
952     COSTS_N_INSNS (36),           /* fp_div_df */
953     COSTS_N_INSNS (5),            /* int_mult_si */
954     COSTS_N_INSNS (9),            /* int_mult_di */
955     COSTS_N_INSNS (69),           /* int_div_si */
956     COSTS_N_INSNS (69),           /* int_div_di */
957                      1,           /* branch_cost */
958                      4            /* memory_latency */
959   },
960   { /* R8000 */
961     DEFAULT_COSTS
962   },
963   { /* R9000 */
964     /* The only costs that are changed here are
965        integer multiplication.  */
966     COSTS_N_INSNS (6),            /* fp_add */
967     COSTS_N_INSNS (7),            /* fp_mult_sf */
968     COSTS_N_INSNS (8),            /* fp_mult_df */
969     COSTS_N_INSNS (23),           /* fp_div_sf */
970     COSTS_N_INSNS (36),           /* fp_div_df */
971     COSTS_N_INSNS (3),            /* int_mult_si */
972     COSTS_N_INSNS (8),            /* int_mult_di */
973     COSTS_N_INSNS (69),           /* int_div_si */
974     COSTS_N_INSNS (69),           /* int_div_di */
975                      1,           /* branch_cost */
976                      4            /* memory_latency */
977   },
978   { /* SB1 */
979     /* These costs are the same as the SB-1A below.  */
980     COSTS_N_INSNS (4),            /* fp_add */
981     COSTS_N_INSNS (4),            /* fp_mult_sf */
982     COSTS_N_INSNS (4),            /* fp_mult_df */
983     COSTS_N_INSNS (24),           /* fp_div_sf */
984     COSTS_N_INSNS (32),           /* fp_div_df */
985     COSTS_N_INSNS (3),            /* int_mult_si */
986     COSTS_N_INSNS (4),            /* int_mult_di */
987     COSTS_N_INSNS (36),           /* int_div_si */
988     COSTS_N_INSNS (68),           /* int_div_di */
989                      1,           /* branch_cost */
990                      4            /* memory_latency */
991   },
992   { /* SB1-A */
993     /* These costs are the same as the SB-1 above.  */
994     COSTS_N_INSNS (4),            /* fp_add */
995     COSTS_N_INSNS (4),            /* fp_mult_sf */
996     COSTS_N_INSNS (4),            /* fp_mult_df */
997     COSTS_N_INSNS (24),           /* fp_div_sf */
998     COSTS_N_INSNS (32),           /* fp_div_df */
999     COSTS_N_INSNS (3),            /* int_mult_si */
1000     COSTS_N_INSNS (4),            /* int_mult_di */
1001     COSTS_N_INSNS (36),           /* int_div_si */
1002     COSTS_N_INSNS (68),           /* int_div_di */
1003                      1,           /* branch_cost */
1004                      4            /* memory_latency */
1005   },
1006   { /* SR71000 */
1007     DEFAULT_COSTS
1008   },
1009 };
1010 \f
1011 /* This hash table keeps track of implicit "mips16" and "nomips16" attributes
1012    for -mflip_mips16.  It maps decl names onto a boolean mode setting.  */
1013 struct mflip_mips16_entry GTY (()) {
1014   const char *name;
1015   bool mips16_p;
1016 };
1017 static GTY ((param_is (struct mflip_mips16_entry))) htab_t mflip_mips16_htab;
1018
1019 /* Hash table callbacks for mflip_mips16_htab.  */
1020
1021 static hashval_t
1022 mflip_mips16_htab_hash (const void *entry)
1023 {
1024   return htab_hash_string (((const struct mflip_mips16_entry *) entry)->name);
1025 }
1026
1027 static int
1028 mflip_mips16_htab_eq (const void *entry, const void *name)
1029 {
1030   return strcmp (((const struct mflip_mips16_entry *) entry)->name,
1031                  (const char *) name) == 0;
1032 }
1033
1034 /* True if -mflip-mips16 should next add an attribute for the default MIPS16
1035    mode, false if it should next add an attribute for the opposite mode.  */
1036 static GTY(()) bool mips16_flipper;
1037
1038 /* DECL is a function that needs a default "mips16" or "nomips16" attribute
1039    for -mflip-mips16.  Return true if it should use "mips16" and false if
1040    it should use "nomips16".  */
1041
1042 static bool
1043 mflip_mips16_use_mips16_p (tree decl)
1044 {
1045   struct mflip_mips16_entry *entry;
1046   const char *name;
1047   hashval_t hash;
1048   void **slot;
1049
1050   /* Use the opposite of the command-line setting for anonymous decls.  */
1051   if (!DECL_NAME (decl))
1052     return !mips_base_mips16;
1053
1054   if (!mflip_mips16_htab)
1055     mflip_mips16_htab = htab_create_ggc (37, mflip_mips16_htab_hash,
1056                                          mflip_mips16_htab_eq, NULL);
1057
1058   name = IDENTIFIER_POINTER (DECL_NAME (decl));
1059   hash = htab_hash_string (name);
1060   slot = htab_find_slot_with_hash (mflip_mips16_htab, name, hash, INSERT);
1061   entry = (struct mflip_mips16_entry *) *slot;
1062   if (!entry)
1063     {
1064       mips16_flipper = !mips16_flipper;
1065       entry = GGC_NEW (struct mflip_mips16_entry);
1066       entry->name = name;
1067       entry->mips16_p = mips16_flipper ? !mips_base_mips16 : mips_base_mips16;
1068       *slot = entry;
1069     }
1070   return entry->mips16_p;
1071 }
1072 \f
1073 /* Predicates to test for presence of "near" and "far"/"long_call"
1074    attributes on the given TYPE.  */
1075
1076 static bool
1077 mips_near_type_p (const_tree type)
1078 {
1079   return lookup_attribute ("near", TYPE_ATTRIBUTES (type)) != NULL;
1080 }
1081
1082 static bool
1083 mips_far_type_p (const_tree type)
1084 {
1085   return (lookup_attribute ("long_call", TYPE_ATTRIBUTES (type)) != NULL
1086           || lookup_attribute ("far", TYPE_ATTRIBUTES (type)) != NULL);
1087 }
1088
1089 /* Similar predicates for "mips16"/"nomips16" function attributes.  */
1090
1091 static bool
1092 mips_mips16_decl_p (const_tree decl)
1093 {
1094   return lookup_attribute ("mips16", DECL_ATTRIBUTES (decl)) != NULL;
1095 }
1096
1097 static bool
1098 mips_nomips16_decl_p (const_tree decl)
1099 {
1100   return lookup_attribute ("nomips16", DECL_ATTRIBUTES (decl)) != NULL;
1101 }
1102
1103 /* Return true if function DECL is a MIPS16 function.  Return the ambient
1104    setting if DECL is null.  */
1105
1106 static bool
1107 mips_use_mips16_mode_p (tree decl)
1108 {
1109   if (decl)
1110     {
1111       /* Nested functions must use the same frame pointer as their
1112          parent and must therefore use the same ISA mode.  */
1113       tree parent = decl_function_context (decl);
1114       if (parent)
1115         decl = parent;
1116       if (mips_mips16_decl_p (decl))
1117         return true;
1118       if (mips_nomips16_decl_p (decl))
1119         return false;
1120     }
1121   return mips_base_mips16;
1122 }
1123
1124 /* Implement TARGET_COMP_TYPE_ATTRIBUTES.  */
1125
1126 static int
1127 mips_comp_type_attributes (const_tree type1, const_tree type2)
1128 {
1129   /* Disallow mixed near/far attributes.  */
1130   if (mips_far_type_p (type1) && mips_near_type_p (type2))
1131     return 0;
1132   if (mips_near_type_p (type1) && mips_far_type_p (type2))
1133     return 0;
1134   return 1;
1135 }
1136
1137 /* Implement TARGET_INSERT_ATTRIBUTES.  */
1138
1139 static void
1140 mips_insert_attributes (tree decl, tree *attributes)
1141 {
1142   const char *name;
1143   bool mips16_p, nomips16_p;
1144
1145   /* Check for "mips16" and "nomips16" attributes.  */
1146   mips16_p = lookup_attribute ("mips16", *attributes) != NULL;
1147   nomips16_p = lookup_attribute ("nomips16", *attributes) != NULL;
1148   if (TREE_CODE (decl) != FUNCTION_DECL)
1149     {
1150       if (mips16_p)
1151         error ("%qs attribute only applies to functions", "mips16");
1152       if (nomips16_p)
1153         error ("%qs attribute only applies to functions", "nomips16");
1154     }
1155   else
1156     {
1157       mips16_p |= mips_mips16_decl_p (decl);
1158       nomips16_p |= mips_nomips16_decl_p (decl);
1159       if (mips16_p || nomips16_p)
1160         {
1161           /* DECL cannot be simultaneously "mips16" and "nomips16".  */
1162           if (mips16_p && nomips16_p)
1163             error ("%qs cannot have both %<mips16%> and "
1164                    "%<nomips16%> attributes",
1165                    IDENTIFIER_POINTER (DECL_NAME (decl)));
1166         }
1167       else if (TARGET_FLIP_MIPS16 && !DECL_ARTIFICIAL (decl))
1168         {
1169           /* Implement -mflip-mips16.  If DECL has neither a "nomips16" nor a
1170              "mips16" attribute, arbitrarily pick one.  We must pick the same
1171              setting for duplicate declarations of a function.  */
1172           name = mflip_mips16_use_mips16_p (decl) ? "mips16" : "nomips16";
1173           *attributes = tree_cons (get_identifier (name), NULL, *attributes);
1174         }
1175     }
1176 }
1177
1178 /* Implement TARGET_MERGE_DECL_ATTRIBUTES.  */
1179
1180 static tree
1181 mips_merge_decl_attributes (tree olddecl, tree newdecl)
1182 {
1183   /* The decls' "mips16" and "nomips16" attributes must match exactly.  */
1184   if (mips_mips16_decl_p (olddecl) != mips_mips16_decl_p (newdecl))
1185     error ("%qs redeclared with conflicting %qs attributes",
1186            IDENTIFIER_POINTER (DECL_NAME (newdecl)), "mips16");
1187   if (mips_nomips16_decl_p (olddecl) != mips_nomips16_decl_p (newdecl))
1188     error ("%qs redeclared with conflicting %qs attributes",
1189            IDENTIFIER_POINTER (DECL_NAME (newdecl)), "nomips16");
1190
1191   return merge_attributes (DECL_ATTRIBUTES (olddecl),
1192                            DECL_ATTRIBUTES (newdecl));
1193 }
1194 \f
1195 /* If X is a PLUS of a CONST_INT, return the two terms in *BASE_PTR
1196    and *OFFSET_PTR.  Return X in *BASE_PTR and 0 in *OFFSET_PTR otherwise.  */
1197
1198 static void
1199 mips_split_plus (rtx x, rtx *base_ptr, HOST_WIDE_INT *offset_ptr)
1200 {
1201   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
1202     {
1203       *base_ptr = XEXP (x, 0);
1204       *offset_ptr = INTVAL (XEXP (x, 1));
1205     }
1206   else
1207     {
1208       *base_ptr = x;
1209       *offset_ptr = 0;
1210     }
1211 }
1212 \f
1213 static unsigned int mips_build_integer (struct mips_integer_op *,
1214                                         unsigned HOST_WIDE_INT);
1215
1216 /* A subroutine of mips_build_integer, with the same interface.
1217    Assume that the final action in the sequence should be a left shift.  */
1218
1219 static unsigned int
1220 mips_build_shift (struct mips_integer_op *codes, HOST_WIDE_INT value)
1221 {
1222   unsigned int i, shift;
1223
1224   /* Shift VALUE right until its lowest bit is set.  Shift arithmetically
1225      since signed numbers are easier to load than unsigned ones.  */
1226   shift = 0;
1227   while ((value & 1) == 0)
1228     value /= 2, shift++;
1229
1230   i = mips_build_integer (codes, value);
1231   codes[i].code = ASHIFT;
1232   codes[i].value = shift;
1233   return i + 1;
1234 }
1235
1236 /* As for mips_build_shift, but assume that the final action will be
1237    an IOR or PLUS operation.  */
1238
1239 static unsigned int
1240 mips_build_lower (struct mips_integer_op *codes, unsigned HOST_WIDE_INT value)
1241 {
1242   unsigned HOST_WIDE_INT high;
1243   unsigned int i;
1244
1245   high = value & ~(unsigned HOST_WIDE_INT) 0xffff;
1246   if (!LUI_OPERAND (high) && (value & 0x18000) == 0x18000)
1247     {
1248       /* The constant is too complex to load with a simple LUI/ORI pair,
1249          so we want to give the recursive call as many trailing zeros as
1250          possible.  In this case, we know bit 16 is set and that the
1251          low 16 bits form a negative number.  If we subtract that number
1252          from VALUE, we will clear at least the lowest 17 bits, maybe more.  */
1253       i = mips_build_integer (codes, CONST_HIGH_PART (value));
1254       codes[i].code = PLUS;
1255       codes[i].value = CONST_LOW_PART (value);
1256     }
1257   else
1258     {
1259       /* Either this is a simple LUI/ORI pair, or clearing the lowest 16
1260          bits gives a value with at least 17 trailing zeros.  */
1261       i = mips_build_integer (codes, high);
1262       codes[i].code = IOR;
1263       codes[i].value = value & 0xffff;
1264     }
1265   return i + 1;
1266 }
1267
1268 /* Fill CODES with a sequence of rtl operations to load VALUE.
1269    Return the number of operations needed.  */
1270
1271 static unsigned int
1272 mips_build_integer (struct mips_integer_op *codes,
1273                     unsigned HOST_WIDE_INT value)
1274 {
1275   if (SMALL_OPERAND (value)
1276       || SMALL_OPERAND_UNSIGNED (value)
1277       || LUI_OPERAND (value))
1278     {
1279       /* The value can be loaded with a single instruction.  */
1280       codes[0].code = UNKNOWN;
1281       codes[0].value = value;
1282       return 1;
1283     }
1284   else if ((value & 1) != 0 || LUI_OPERAND (CONST_HIGH_PART (value)))
1285     {
1286       /* Either the constant is a simple LUI/ORI combination or its
1287          lowest bit is set.  We don't want to shift in this case.  */
1288       return mips_build_lower (codes, value);
1289     }
1290   else if ((value & 0xffff) == 0)
1291     {
1292       /* The constant will need at least three actions.  The lowest
1293          16 bits are clear, so the final action will be a shift.  */
1294       return mips_build_shift (codes, value);
1295     }
1296   else
1297     {
1298       /* The final action could be a shift, add or inclusive OR.
1299          Rather than use a complex condition to select the best
1300          approach, try both mips_build_shift and mips_build_lower
1301          and pick the one that gives the shortest sequence.
1302          Note that this case is only used once per constant.  */
1303       struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
1304       unsigned int cost, alt_cost;
1305
1306       cost = mips_build_shift (codes, value);
1307       alt_cost = mips_build_lower (alt_codes, value);
1308       if (alt_cost < cost)
1309         {
1310           memcpy (codes, alt_codes, alt_cost * sizeof (codes[0]));
1311           cost = alt_cost;
1312         }
1313       return cost;
1314     }
1315 }
1316 \f
1317 /* Return true if X is a thread-local symbol.  */
1318
1319 static bool
1320 mips_tls_symbol_p (rtx x)
1321 {
1322   return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
1323 }
1324
1325 /* Return true if SYMBOL_REF X is associated with a global symbol
1326    (in the STB_GLOBAL sense).  */
1327
1328 static bool
1329 mips_global_symbol_p (const_rtx x)
1330 {
1331   const_tree decl = SYMBOL_REF_DECL (x);
1332
1333   if (!decl)
1334     return !SYMBOL_REF_LOCAL_P (x);
1335
1336   /* Weakref symbols are not TREE_PUBLIC, but their targets are global
1337      or weak symbols.  Relocations in the object file will be against
1338      the target symbol, so it's that symbol's binding that matters here.  */
1339   return DECL_P (decl) && (TREE_PUBLIC (decl) || DECL_WEAK (decl));
1340 }
1341
1342 /* Return true if SYMBOL_REF X binds locally.  */
1343
1344 static bool
1345 mips_symbol_binds_local_p (const_rtx x)
1346 {
1347   return (SYMBOL_REF_DECL (x)
1348           ? targetm.binds_local_p (SYMBOL_REF_DECL (x))
1349           : SYMBOL_REF_LOCAL_P (x));
1350 }
1351
1352 /* Return true if rtx constants of mode MODE should be put into a small
1353    data section.  */
1354
1355 static bool
1356 mips_rtx_constant_in_small_data_p (enum machine_mode mode)
1357 {
1358   return (!TARGET_EMBEDDED_DATA
1359           && TARGET_LOCAL_SDATA
1360           && GET_MODE_SIZE (mode) <= mips_small_data_threshold);
1361 }
1362
1363 /* Return true if X should not be moved directly into register $25.
1364    We need this because many versions of GAS will treat "la $25,foo" as
1365    part of a call sequence and so allow a global "foo" to be lazily bound.  */
1366
1367 bool
1368 mips_dangerous_for_la25_p (rtx x)
1369 {
1370   return (!TARGET_EXPLICIT_RELOCS
1371           && TARGET_USE_GOT
1372           && GET_CODE (x) == SYMBOL_REF
1373           && mips_global_symbol_p (x));
1374 }
1375
1376 /* Return the method that should be used to access SYMBOL_REF or
1377    LABEL_REF X in context CONTEXT.  */
1378
1379 static enum mips_symbol_type
1380 mips_classify_symbol (const_rtx x, enum mips_symbol_context context)
1381 {
1382   if (TARGET_RTP_PIC)
1383     return SYMBOL_GOT_DISP;
1384
1385   if (GET_CODE (x) == LABEL_REF)
1386     {
1387       /* LABEL_REFs are used for jump tables as well as text labels.
1388          Only return SYMBOL_PC_RELATIVE if we know the label is in
1389          the text section.  */
1390       if (TARGET_MIPS16_SHORT_JUMP_TABLES)
1391         return SYMBOL_PC_RELATIVE;
1392
1393       if (TARGET_ABICALLS && !TARGET_ABSOLUTE_ABICALLS)
1394         return SYMBOL_GOT_PAGE_OFST;
1395
1396       return SYMBOL_ABSOLUTE;
1397     }
1398
1399   gcc_assert (GET_CODE (x) == SYMBOL_REF);
1400
1401   if (SYMBOL_REF_TLS_MODEL (x))
1402     return SYMBOL_TLS;
1403
1404   if (CONSTANT_POOL_ADDRESS_P (x))
1405     {
1406       if (TARGET_MIPS16_TEXT_LOADS)
1407         return SYMBOL_PC_RELATIVE;
1408
1409       if (TARGET_MIPS16_PCREL_LOADS && context == SYMBOL_CONTEXT_MEM)
1410         return SYMBOL_PC_RELATIVE;
1411
1412       if (mips_rtx_constant_in_small_data_p (get_pool_mode (x)))
1413         return SYMBOL_GP_RELATIVE;
1414     }
1415
1416   /* Do not use small-data accesses for weak symbols; they may end up
1417      being zero.  */
1418   if (TARGET_GPOPT && SYMBOL_REF_SMALL_P (x) && !SYMBOL_REF_WEAK (x))
1419     return SYMBOL_GP_RELATIVE;
1420
1421   /* Don't use GOT accesses for locally-binding symbols when -mno-shared
1422      is in effect.  */
1423   if (TARGET_ABICALLS
1424       && !(TARGET_ABSOLUTE_ABICALLS && mips_symbol_binds_local_p (x)))
1425     {
1426       /* There are three cases to consider:
1427
1428             - o32 PIC (either with or without explicit relocs)
1429             - n32/n64 PIC without explicit relocs
1430             - n32/n64 PIC with explicit relocs
1431
1432          In the first case, both local and global accesses will use an
1433          R_MIPS_GOT16 relocation.  We must correctly predict which of
1434          the two semantics (local or global) the assembler and linker
1435          will apply.  The choice depends on the symbol's binding rather
1436          than its visibility.
1437
1438          In the second case, the assembler will not use R_MIPS_GOT16
1439          relocations, but it chooses between local and global accesses
1440          in the same way as for o32 PIC.
1441
1442          In the third case we have more freedom since both forms of
1443          access will work for any kind of symbol.  However, there seems
1444          little point in doing things differently.  */
1445       if (mips_global_symbol_p (x))
1446         return SYMBOL_GOT_DISP;
1447
1448       return SYMBOL_GOT_PAGE_OFST;
1449     }
1450
1451   if (TARGET_MIPS16_PCREL_LOADS && context != SYMBOL_CONTEXT_CALL)
1452     return SYMBOL_FORCE_TO_MEM;
1453
1454   return SYMBOL_ABSOLUTE;
1455 }
1456
1457 /* Classify the base of symbolic expression X, given that X appears in
1458    context CONTEXT.  */
1459
1460 static enum mips_symbol_type
1461 mips_classify_symbolic_expression (rtx x, enum mips_symbol_context context)
1462 {
1463   rtx offset;
1464
1465   split_const (x, &x, &offset);
1466   if (UNSPEC_ADDRESS_P (x))
1467     return UNSPEC_ADDRESS_TYPE (x);
1468
1469   return mips_classify_symbol (x, context);
1470 }
1471
1472 /* Return true if OFFSET is within the range [0, ALIGN), where ALIGN
1473    is the alignment in bytes of SYMBOL_REF X.  */
1474
1475 static bool
1476 mips_offset_within_alignment_p (rtx x, HOST_WIDE_INT offset)
1477 {
1478   HOST_WIDE_INT align;
1479
1480   align = SYMBOL_REF_DECL (x) ? DECL_ALIGN_UNIT (SYMBOL_REF_DECL (x)) : 1;
1481   return IN_RANGE (offset, 0, align - 1);
1482 }
1483
1484 /* Return true if X is a symbolic constant that can be used in context
1485    CONTEXT.  If it is, store the type of the symbol in *SYMBOL_TYPE.  */
1486
1487 bool
1488 mips_symbolic_constant_p (rtx x, enum mips_symbol_context context,
1489                           enum mips_symbol_type *symbol_type)
1490 {
1491   rtx offset;
1492
1493   split_const (x, &x, &offset);
1494   if (UNSPEC_ADDRESS_P (x))
1495     {
1496       *symbol_type = UNSPEC_ADDRESS_TYPE (x);
1497       x = UNSPEC_ADDRESS (x);
1498     }
1499   else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
1500     {
1501       *symbol_type = mips_classify_symbol (x, context);
1502       if (*symbol_type == SYMBOL_TLS)
1503         return false;
1504     }
1505   else
1506     return false;
1507
1508   if (offset == const0_rtx)
1509     return true;
1510
1511   /* Check whether a nonzero offset is valid for the underlying
1512      relocations.  */
1513   switch (*symbol_type)
1514     {
1515     case SYMBOL_ABSOLUTE:
1516     case SYMBOL_FORCE_TO_MEM:
1517     case SYMBOL_32_HIGH:
1518     case SYMBOL_64_HIGH:
1519     case SYMBOL_64_MID:
1520     case SYMBOL_64_LOW:
1521       /* If the target has 64-bit pointers and the object file only
1522          supports 32-bit symbols, the values of those symbols will be
1523          sign-extended.  In this case we can't allow an arbitrary offset
1524          in case the 32-bit value X + OFFSET has a different sign from X.  */
1525       if (Pmode == DImode && !ABI_HAS_64BIT_SYMBOLS)
1526         return offset_within_block_p (x, INTVAL (offset));
1527
1528       /* In other cases the relocations can handle any offset.  */
1529       return true;
1530
1531     case SYMBOL_PC_RELATIVE:
1532       /* Allow constant pool references to be converted to LABEL+CONSTANT.
1533          In this case, we no longer have access to the underlying constant,
1534          but the original symbol-based access was known to be valid.  */
1535       if (GET_CODE (x) == LABEL_REF)
1536         return true;
1537
1538       /* Fall through.  */
1539
1540     case SYMBOL_GP_RELATIVE:
1541       /* Make sure that the offset refers to something within the
1542          same object block.  This should guarantee that the final
1543          PC- or GP-relative offset is within the 16-bit limit.  */
1544       return offset_within_block_p (x, INTVAL (offset));
1545
1546     case SYMBOL_GOT_PAGE_OFST:
1547     case SYMBOL_GOTOFF_PAGE:
1548       /* If the symbol is global, the GOT entry will contain the symbol's
1549          address, and we will apply a 16-bit offset after loading it.
1550          If the symbol is local, the linker should provide enough local
1551          GOT entries for a 16-bit offset, but larger offsets may lead
1552          to GOT overflow.  */
1553       return SMALL_INT (offset);
1554
1555     case SYMBOL_TPREL:
1556     case SYMBOL_DTPREL:
1557       /* There is no carry between the HI and LO REL relocations, so the
1558          offset is only valid if we know it won't lead to such a carry.  */
1559       return mips_offset_within_alignment_p (x, INTVAL (offset));
1560
1561     case SYMBOL_GOT_DISP:
1562     case SYMBOL_GOTOFF_DISP:
1563     case SYMBOL_GOTOFF_CALL:
1564     case SYMBOL_GOTOFF_LOADGP:
1565     case SYMBOL_TLSGD:
1566     case SYMBOL_TLSLDM:
1567     case SYMBOL_GOTTPREL:
1568     case SYMBOL_TLS:
1569     case SYMBOL_HALF:
1570       return false;
1571     }
1572   gcc_unreachable ();
1573 }
1574 \f
1575 /* Like mips_symbol_insns, but treat extended MIPS16 instructions as a
1576    single instruction.  We rely on the fact that, in the worst case,
1577    all instructions involved in a MIPS16 address calculation are usually
1578    extended ones.  */
1579
1580 static int
1581 mips_symbol_insns_1 (enum mips_symbol_type type, enum machine_mode mode)
1582 {
1583   switch (type)
1584     {
1585     case SYMBOL_ABSOLUTE:
1586       /* When using 64-bit symbols, we need 5 preparatory instructions,
1587          such as:
1588
1589              lui     $at,%highest(symbol)
1590              daddiu  $at,$at,%higher(symbol)
1591              dsll    $at,$at,16
1592              daddiu  $at,$at,%hi(symbol)
1593              dsll    $at,$at,16
1594
1595          The final address is then $at + %lo(symbol).  With 32-bit
1596          symbols we just need a preparatory LUI for normal mode and
1597          a preparatory LI and SLL for MIPS16.  */
1598       return ABI_HAS_64BIT_SYMBOLS ? 6 : TARGET_MIPS16 ? 3 : 2;
1599
1600     case SYMBOL_GP_RELATIVE:
1601       /* Treat GP-relative accesses as taking a single instruction on
1602          MIPS16 too; the copy of $gp can often be shared.  */
1603       return 1;
1604
1605     case SYMBOL_PC_RELATIVE:
1606       /* PC-relative constants can be only be used with ADDIUPC,
1607          DADDIUPC, LWPC and LDPC.  */
1608       if (mode == MAX_MACHINE_MODE
1609           || GET_MODE_SIZE (mode) == 4
1610           || GET_MODE_SIZE (mode) == 8)
1611         return 1;
1612
1613       /* The constant must be loaded using ADDIUPC or DADDIUPC first.  */
1614       return 0;
1615
1616     case SYMBOL_FORCE_TO_MEM:
1617       /* LEAs will be converted into constant-pool references by
1618          mips_reorg.  */
1619       if (mode == MAX_MACHINE_MODE)
1620         return 1;
1621
1622       /* The constant must be loaded and then dereferenced.  */
1623       return 0;
1624
1625     case SYMBOL_GOT_DISP:
1626       /* The constant will have to be loaded from the GOT before it
1627          is used in an address.  */
1628       if (mode != MAX_MACHINE_MODE)
1629         return 0;
1630
1631       /* Fall through.  */
1632
1633     case SYMBOL_GOT_PAGE_OFST:
1634       /* Unless -funit-at-a-time is in effect, we can't be sure whether the
1635          local/global classification is accurate.  The worst cases are:
1636
1637          (1) For local symbols when generating o32 or o64 code.  The assembler
1638              will use:
1639
1640                  lw           $at,%got(symbol)
1641                  nop
1642
1643              ...and the final address will be $at + %lo(symbol).
1644
1645          (2) For global symbols when -mxgot.  The assembler will use:
1646
1647                  lui     $at,%got_hi(symbol)
1648                  (d)addu $at,$at,$gp
1649
1650              ...and the final address will be $at + %got_lo(symbol).  */
1651       return 3;
1652
1653     case SYMBOL_GOTOFF_PAGE:
1654     case SYMBOL_GOTOFF_DISP:
1655     case SYMBOL_GOTOFF_CALL:
1656     case SYMBOL_GOTOFF_LOADGP:
1657     case SYMBOL_32_HIGH:
1658     case SYMBOL_64_HIGH:
1659     case SYMBOL_64_MID:
1660     case SYMBOL_64_LOW:
1661     case SYMBOL_TLSGD:
1662     case SYMBOL_TLSLDM:
1663     case SYMBOL_DTPREL:
1664     case SYMBOL_GOTTPREL:
1665     case SYMBOL_TPREL:
1666     case SYMBOL_HALF:
1667       /* A 16-bit constant formed by a single relocation, or a 32-bit
1668          constant formed from a high 16-bit relocation and a low 16-bit
1669          relocation.  Use mips_split_p to determine which.  32-bit
1670          constants need an "lui; addiu" sequence for normal mode and
1671          an "li; sll; addiu" sequence for MIPS16 mode.  */
1672       return !mips_split_p[type] ? 1 : TARGET_MIPS16 ? 3 : 2;
1673
1674     case SYMBOL_TLS:
1675       /* We don't treat a bare TLS symbol as a constant.  */
1676       return 0;
1677     }
1678   gcc_unreachable ();
1679 }
1680
1681 /* If MODE is MAX_MACHINE_MODE, return the number of instructions needed
1682    to load symbols of type TYPE into a register.  Return 0 if the given
1683    type of symbol cannot be used as an immediate operand.
1684
1685    Otherwise, return the number of instructions needed to load or store
1686    values of mode MODE to or from addresses of type TYPE.  Return 0 if
1687    the given type of symbol is not valid in addresses.
1688
1689    In both cases, treat extended MIPS16 instructions as two instructions.  */
1690
1691 static int
1692 mips_symbol_insns (enum mips_symbol_type type, enum machine_mode mode)
1693 {
1694   return mips_symbol_insns_1 (type, mode) * (TARGET_MIPS16 ? 2 : 1);
1695 }
1696 \f
1697 /* A for_each_rtx callback.  Stop the search if *X references a
1698    thread-local symbol.  */
1699
1700 static int
1701 mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1702 {
1703   return mips_tls_symbol_p (*x);
1704 }
1705
1706 /* Implement TARGET_CANNOT_FORCE_CONST_MEM.  */
1707
1708 static bool
1709 mips_cannot_force_const_mem (rtx x)
1710 {
1711   rtx base, offset;
1712
1713   if (!TARGET_MIPS16)
1714     {
1715       /* As an optimization, reject constants that mips_legitimize_move
1716          can expand inline.
1717
1718          Suppose we have a multi-instruction sequence that loads constant C
1719          into register R.  If R does not get allocated a hard register, and
1720          R is used in an operand that allows both registers and memory
1721          references, reload will consider forcing C into memory and using
1722          one of the instruction's memory alternatives.  Returning false
1723          here will force it to use an input reload instead.  */
1724       if (GET_CODE (x) == CONST_INT)
1725         return true;
1726
1727       split_const (x, &base, &offset);
1728       if (symbolic_operand (base, VOIDmode) && SMALL_INT (offset))
1729         return true;
1730     }
1731
1732   /* TLS symbols must be computed by mips_legitimize_move.  */
1733   if (for_each_rtx (&x, &mips_tls_symbol_ref_1, NULL))
1734     return true;
1735
1736   return false;
1737 }
1738
1739 /* Implement TARGET_USE_BLOCKS_FOR_CONSTANT_P.  We can't use blocks for
1740    constants when we're using a per-function constant pool.  */
1741
1742 static bool
1743 mips_use_blocks_for_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED,
1744                                 const_rtx x ATTRIBUTE_UNUSED)
1745 {
1746   return !TARGET_MIPS16_PCREL_LOADS;
1747 }
1748 \f
1749 /* Return true if register REGNO is a valid base register for mode MODE.
1750    STRICT_P is true if REG_OK_STRICT is in effect.  */
1751
1752 int
1753 mips_regno_mode_ok_for_base_p (int regno, enum machine_mode mode,
1754                                bool strict_p)
1755 {
1756   if (!HARD_REGISTER_NUM_P (regno))
1757     {
1758       if (!strict_p)
1759         return true;
1760       regno = reg_renumber[regno];
1761     }
1762
1763   /* These fake registers will be eliminated to either the stack or
1764      hard frame pointer, both of which are usually valid base registers.
1765      Reload deals with the cases where the eliminated form isn't valid.  */
1766   if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
1767     return true;
1768
1769   /* In MIPS16 mode, the stack pointer can only address word and doubleword
1770      values, nothing smaller.  There are two problems here:
1771
1772        (a) Instantiating virtual registers can introduce new uses of the
1773            stack pointer.  If these virtual registers are valid addresses,
1774            the stack pointer should be too.
1775
1776        (b) Most uses of the stack pointer are not made explicit until
1777            FRAME_POINTER_REGNUM and ARG_POINTER_REGNUM have been eliminated.
1778            We don't know until that stage whether we'll be eliminating to the
1779            stack pointer (which needs the restriction) or the hard frame
1780            pointer (which doesn't).
1781
1782      All in all, it seems more consistent to only enforce this restriction
1783      during and after reload.  */
1784   if (TARGET_MIPS16 && regno == STACK_POINTER_REGNUM)
1785     return !strict_p || GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8;
1786
1787   return TARGET_MIPS16 ? M16_REG_P (regno) : GP_REG_P (regno);
1788 }
1789
1790 /* Return true if X is a valid base register for mode MODE.
1791    STRICT_P is true if REG_OK_STRICT is in effect.  */
1792
1793 static bool
1794 mips_valid_base_register_p (rtx x, enum machine_mode mode, bool strict_p)
1795 {
1796   if (!strict_p && GET_CODE (x) == SUBREG)
1797     x = SUBREG_REG (x);
1798
1799   return (REG_P (x)
1800           && mips_regno_mode_ok_for_base_p (REGNO (x), mode, strict_p));
1801 }
1802
1803 /* Return true if X is a valid address for machine mode MODE.  If it is,
1804    fill in INFO appropriately.  STRICT_P is true if REG_OK_STRICT is in
1805    effect.  */
1806
1807 static bool
1808 mips_classify_address (struct mips_address_info *info, rtx x,
1809                        enum machine_mode mode, bool strict_p)
1810 {
1811   switch (GET_CODE (x))
1812     {
1813     case REG:
1814     case SUBREG:
1815       info->type = ADDRESS_REG;
1816       info->reg = x;
1817       info->offset = const0_rtx;
1818       return mips_valid_base_register_p (info->reg, mode, strict_p);
1819
1820     case PLUS:
1821       info->type = ADDRESS_REG;
1822       info->reg = XEXP (x, 0);
1823       info->offset = XEXP (x, 1);
1824       return (mips_valid_base_register_p (info->reg, mode, strict_p)
1825               && const_arith_operand (info->offset, VOIDmode));
1826
1827     case LO_SUM:
1828       info->type = ADDRESS_LO_SUM;
1829       info->reg = XEXP (x, 0);
1830       info->offset = XEXP (x, 1);
1831       /* We have to trust the creator of the LO_SUM to do something vaguely
1832          sane.  Target-independent code that creates a LO_SUM should also
1833          create and verify the matching HIGH.  Target-independent code that
1834          adds an offset to a LO_SUM must prove that the offset will not
1835          induce a carry.  Failure to do either of these things would be
1836          a bug, and we are not required to check for it here.  The MIPS
1837          backend itself should only create LO_SUMs for valid symbolic
1838          constants, with the high part being either a HIGH or a copy
1839          of _gp. */
1840       info->symbol_type
1841         = mips_classify_symbolic_expression (info->offset, SYMBOL_CONTEXT_MEM);
1842       return (mips_valid_base_register_p (info->reg, mode, strict_p)
1843               && mips_symbol_insns (info->symbol_type, mode) > 0
1844               && mips_lo_relocs[info->symbol_type] != 0);
1845
1846     case CONST_INT:
1847       /* Small-integer addresses don't occur very often, but they
1848          are legitimate if $0 is a valid base register.  */
1849       info->type = ADDRESS_CONST_INT;
1850       return !TARGET_MIPS16 && SMALL_INT (x);
1851
1852     case CONST:
1853     case LABEL_REF:
1854     case SYMBOL_REF:
1855       info->type = ADDRESS_SYMBOLIC;
1856       return (mips_symbolic_constant_p (x, SYMBOL_CONTEXT_MEM,
1857                                         &info->symbol_type)
1858               && mips_symbol_insns (info->symbol_type, mode) > 0
1859               && !mips_split_p[info->symbol_type]);
1860
1861     default:
1862       return false;
1863     }
1864 }
1865
1866 /* Return true if X is a legitimate address for a memory operand of mode
1867    MODE.  STRICT_P is true if REG_OK_STRICT is in effect.  */
1868
1869 bool
1870 mips_legitimate_address_p (enum machine_mode mode, rtx x, bool strict_p)
1871 {
1872   struct mips_address_info addr;
1873
1874   return mips_classify_address (&addr, x, mode, strict_p);
1875 }
1876
1877 /* Return true if X is a legitimate $sp-based address for mode MDOE.  */
1878
1879 bool
1880 mips_stack_address_p (rtx x, enum machine_mode mode)
1881 {
1882   struct mips_address_info addr;
1883
1884   return (mips_classify_address (&addr, x, mode, false)
1885           && addr.type == ADDRESS_REG
1886           && addr.reg == stack_pointer_rtx);
1887 }
1888
1889 /* Return true if ADDR matches the pattern for the LWXS load scaled indexed
1890    address instruction.  Note that such addresses are not considered
1891    legitimate in the GO_IF_LEGITIMATE_ADDRESS sense, because their use
1892    is so restricted.  */
1893
1894 static bool
1895 mips_lwxs_address_p (rtx addr)
1896 {
1897   if (ISA_HAS_LWXS
1898       && GET_CODE (addr) == PLUS
1899       && REG_P (XEXP (addr, 1)))
1900     {
1901       rtx offset = XEXP (addr, 0);
1902       if (GET_CODE (offset) == MULT
1903           && REG_P (XEXP (offset, 0))
1904           && GET_CODE (XEXP (offset, 1)) == CONST_INT
1905           && INTVAL (XEXP (offset, 1)) == 4)
1906         return true;
1907     }
1908   return false;
1909 }
1910 \f
1911 /* Return true if a value at OFFSET bytes from base register BASE can be
1912    accessed using an unextended MIPS16 instruction.  MODE is the mode of
1913    the value.
1914
1915    Usually the offset in an unextended instruction is a 5-bit field.
1916    The offset is unsigned and shifted left once for LH and SH, twice
1917    for LW and SW, and so on.  An exception is LWSP and SWSP, which have
1918    an 8-bit immediate field that's shifted left twice.  */
1919
1920 static bool
1921 mips16_unextended_reference_p (enum machine_mode mode, rtx base,
1922                                unsigned HOST_WIDE_INT offset)
1923 {
1924   if (offset % GET_MODE_SIZE (mode) == 0)
1925     {
1926       if (GET_MODE_SIZE (mode) == 4 && base == stack_pointer_rtx)
1927         return offset < 256U * GET_MODE_SIZE (mode);
1928       return offset < 32U * GET_MODE_SIZE (mode);
1929     }
1930   return false;
1931 }
1932
1933 /* Return the number of instructions needed to load or store a value
1934    of mode MODE at address X.  Return 0 if X isn't valid for MODE.
1935    Assume that multiword moves may need to be split into word moves
1936    if MIGHT_SPLIT_P, otherwise assume that a single load or store is
1937    enough.
1938
1939    For MIPS16 code, count extended instructions as two instructions.  */
1940
1941 int
1942 mips_address_insns (rtx x, enum machine_mode mode, bool might_split_p)
1943 {
1944   struct mips_address_info addr;
1945   int factor;
1946
1947   /* BLKmode is used for single unaligned loads and stores and should
1948      not count as a multiword mode.  (GET_MODE_SIZE (BLKmode) is pretty
1949      meaningless, so we have to single it out as a special case one way
1950      or the other.)  */
1951   if (mode != BLKmode && might_split_p)
1952     factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1953   else
1954     factor = 1;
1955
1956   if (mips_classify_address (&addr, x, mode, false))
1957     switch (addr.type)
1958       {
1959       case ADDRESS_REG:
1960         if (TARGET_MIPS16
1961             && !mips16_unextended_reference_p (mode, addr.reg,
1962                                                UINTVAL (addr.offset)))
1963           return factor * 2;
1964         return factor;
1965
1966       case ADDRESS_LO_SUM:
1967         return TARGET_MIPS16 ? factor * 2 : factor;
1968
1969       case ADDRESS_CONST_INT:
1970         return factor;
1971
1972       case ADDRESS_SYMBOLIC:
1973         return factor * mips_symbol_insns (addr.symbol_type, mode);
1974       }
1975   return 0;
1976 }
1977
1978 /* Return the number of instructions needed to load constant X.
1979    Return 0 if X isn't a valid constant.  */
1980
1981 int
1982 mips_const_insns (rtx x)
1983 {
1984   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
1985   enum mips_symbol_type symbol_type;
1986   rtx offset;
1987
1988   switch (GET_CODE (x))
1989     {
1990     case HIGH:
1991       if (!mips_symbolic_constant_p (XEXP (x, 0), SYMBOL_CONTEXT_LEA,
1992                                      &symbol_type)
1993           || !mips_split_p[symbol_type])
1994         return 0;
1995
1996       /* This is simply an LUI for normal mode.  It is an extended
1997          LI followed by an extended SLL for MIPS16.  */
1998       return TARGET_MIPS16 ? 4 : 1;
1999
2000     case CONST_INT:
2001       if (TARGET_MIPS16)
2002         /* Unsigned 8-bit constants can be loaded using an unextended
2003            LI instruction.  Unsigned 16-bit constants can be loaded
2004            using an extended LI.  Negative constants must be loaded
2005            using LI and then negated.  */
2006         return (IN_RANGE (INTVAL (x), 0, 255) ? 1
2007                 : SMALL_OPERAND_UNSIGNED (INTVAL (x)) ? 2
2008                 : IN_RANGE (-INTVAL (x), 0, 255) ? 2
2009                 : SMALL_OPERAND_UNSIGNED (-INTVAL (x)) ? 3
2010                 : 0);
2011
2012       return mips_build_integer (codes, INTVAL (x));
2013
2014     case CONST_DOUBLE:
2015     case CONST_VECTOR:
2016       /* Allow zeros for normal mode, where we can use $0.  */
2017       return !TARGET_MIPS16 && x == CONST0_RTX (GET_MODE (x)) ? 1 : 0;
2018
2019     case CONST:
2020       if (CONST_GP_P (x))
2021         return 1;
2022
2023       /* See if we can refer to X directly.  */
2024       if (mips_symbolic_constant_p (x, SYMBOL_CONTEXT_LEA, &symbol_type))
2025         return mips_symbol_insns (symbol_type, MAX_MACHINE_MODE);
2026
2027       /* Otherwise try splitting the constant into a base and offset.
2028          16-bit offsets can be added using an extra ADDIU.  Larger offsets
2029          must be calculated separately and then added to the base.  */
2030       split_const (x, &x, &offset);
2031       if (offset != 0)
2032         {
2033           int n = mips_const_insns (x);
2034           if (n != 0)
2035             {
2036               if (SMALL_INT (offset))
2037                 return n + 1;
2038               else
2039                 return n + 1 + mips_build_integer (codes, INTVAL (offset));
2040             }
2041         }
2042       return 0;
2043
2044     case SYMBOL_REF:
2045     case LABEL_REF:
2046       return mips_symbol_insns (mips_classify_symbol (x, SYMBOL_CONTEXT_LEA),
2047                                 MAX_MACHINE_MODE);
2048
2049     default:
2050       return 0;
2051     }
2052 }
2053
2054 /* Return the number of instructions needed to implement INSN,
2055    given that it loads from or stores to MEM.  Count extended
2056    MIPS16 instructions as two instructions.  */
2057
2058 int
2059 mips_load_store_insns (rtx mem, rtx insn)
2060 {
2061   enum machine_mode mode;
2062   bool might_split_p;
2063   rtx set;
2064
2065   gcc_assert (MEM_P (mem));
2066   mode = GET_MODE (mem);
2067
2068   /* Try to prove that INSN does not need to be split.  */
2069   might_split_p = true;
2070   if (GET_MODE_BITSIZE (mode) == 64)
2071     {
2072       set = single_set (insn);
2073       if (set && !mips_split_64bit_move_p (SET_DEST (set), SET_SRC (set)))
2074         might_split_p = false;
2075     }
2076
2077   return mips_address_insns (XEXP (mem, 0), mode, might_split_p);
2078 }
2079
2080 /* Return the number of instructions needed for an integer division.  */
2081
2082 int
2083 mips_idiv_insns (void)
2084 {
2085   int count;
2086
2087   count = 1;
2088   if (TARGET_CHECK_ZERO_DIV)
2089     {
2090       if (GENERATE_DIVIDE_TRAPS)
2091         count++;
2092       else
2093         count += 2;
2094     }
2095
2096   if (TARGET_FIX_R4000 || TARGET_FIX_R4400)
2097     count++;
2098   return count;
2099 }
2100 \f
2101 /* Emit a move from SRC to DEST.  Assume that the move expanders can
2102    handle all moves if !can_create_pseudo_p ().  The distinction is
2103    important because, unlike emit_move_insn, the move expanders know
2104    how to force Pmode objects into the constant pool even when the
2105    constant pool address is not itself legitimate.  */
2106
2107 rtx
2108 mips_emit_move (rtx dest, rtx src)
2109 {
2110   return (can_create_pseudo_p ()
2111           ? emit_move_insn (dest, src)
2112           : emit_move_insn_1 (dest, src));
2113 }
2114
2115 /* Emit an instruction of the form (set TARGET (CODE OP0 OP1)).  */
2116
2117 static void
2118 mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
2119 {
2120   emit_insn (gen_rtx_SET (VOIDmode, target,
2121                           gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
2122 }
2123
2124 /* Copy VALUE to a register and return that register.  If new pseudos
2125    are allowed, copy it into a new register, otherwise use DEST.  */
2126
2127 static rtx
2128 mips_force_temporary (rtx dest, rtx value)
2129 {
2130   if (can_create_pseudo_p ())
2131     return force_reg (Pmode, value);
2132   else
2133     {
2134       mips_emit_move (dest, value);
2135       return dest;
2136     }
2137 }
2138
2139 /* Emit a call sequence with call pattern PATTERN and return the call
2140    instruction itself (which is not necessarily the last instruction
2141    emitted).  LAZY_P is true if the call address is lazily-bound.  */
2142
2143 static rtx
2144 mips_emit_call_insn (rtx pattern, bool lazy_p)
2145 {
2146   rtx insn;
2147
2148   insn = emit_call_insn (pattern);
2149
2150   /* Lazy-binding stubs require $gp to be valid on entry.  */
2151   if (lazy_p)
2152     use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
2153
2154   if (TARGET_USE_GOT)
2155     {
2156       /* See the comment above load_call<mode> for details.  */
2157       use_reg (&CALL_INSN_FUNCTION_USAGE (insn),
2158                gen_rtx_REG (Pmode, GOT_VERSION_REGNUM));
2159       emit_insn (gen_update_got_version ());
2160     }
2161   return insn;
2162 }
2163 \f
2164 /* Return an instruction that copies $gp into register REG.  We want
2165    GCC to treat the register's value as constant, so that its value
2166    can be rematerialized on demand.  */
2167
2168 static rtx
2169 gen_load_const_gp (rtx reg)
2170 {
2171   return (Pmode == SImode
2172           ? gen_load_const_gp_si (reg)
2173           : gen_load_const_gp_di (reg));
2174 }
2175
2176 /* Return a pseudo register that contains the value of $gp throughout
2177    the current function.  Such registers are needed by MIPS16 functions,
2178    for which $gp itself is not a valid base register or addition operand.  */
2179
2180 static rtx
2181 mips16_gp_pseudo_reg (void)
2182 {
2183   if (cfun->machine->mips16_gp_pseudo_rtx == NULL_RTX)
2184     cfun->machine->mips16_gp_pseudo_rtx = gen_reg_rtx (Pmode);
2185
2186   /* Don't emit an instruction to initialize the pseudo register if
2187      we are being called from the tree optimizers' cost-calculation
2188      routines.  */
2189   if (!cfun->machine->initialized_mips16_gp_pseudo_p
2190       && (current_ir_type () != IR_GIMPLE || currently_expanding_to_rtl))
2191     {
2192       rtx insn, scan, after;
2193
2194       insn = gen_load_const_gp (cfun->machine->mips16_gp_pseudo_rtx);
2195
2196       push_topmost_sequence ();
2197       /* We need to emit the initialization after the FUNCTION_BEG
2198          note, so that it will be integrated.  */
2199       after = get_insns ();
2200       for (scan = after; scan != NULL_RTX; scan = NEXT_INSN (scan))
2201         if (NOTE_P (scan) && NOTE_KIND (scan) == NOTE_INSN_FUNCTION_BEG)
2202           {
2203             after = scan;
2204             break;
2205           }
2206       insn = emit_insn_after (insn, after);
2207       pop_topmost_sequence ();
2208
2209       cfun->machine->initialized_mips16_gp_pseudo_p = true;
2210     }
2211
2212   return cfun->machine->mips16_gp_pseudo_rtx;
2213 }
2214
2215 /* If MODE is MAX_MACHINE_MODE, ADDR appears as a move operand, otherwise
2216    it appears in a MEM of that mode.  Return true if ADDR is a legitimate
2217    constant in that context and can be split into a high part and a LO_SUM.
2218    If so, and if LO_SUM_OUT is nonnull, emit the high part and return
2219    the LO_SUM in *LO_SUM_OUT.  Leave *LO_SUM_OUT unchanged otherwise.
2220
2221    TEMP is as for mips_force_temporary and is used to load the high
2222    part into a register.  */
2223
2224 bool
2225 mips_split_symbol (rtx temp, rtx addr, enum machine_mode mode, rtx *lo_sum_out)
2226 {
2227   enum mips_symbol_context context;
2228   enum mips_symbol_type symbol_type;
2229   rtx high;
2230
2231   context = (mode == MAX_MACHINE_MODE
2232              ? SYMBOL_CONTEXT_LEA
2233              : SYMBOL_CONTEXT_MEM);
2234   if (!mips_symbolic_constant_p (addr, context, &symbol_type)
2235       || mips_symbol_insns (symbol_type, mode) == 0
2236       || !mips_split_p[symbol_type])
2237     return false;
2238
2239   if (lo_sum_out)
2240     {
2241       if (symbol_type == SYMBOL_GP_RELATIVE)
2242         {
2243           if (!can_create_pseudo_p ())
2244             {
2245               emit_insn (gen_load_const_gp (temp));
2246               high = temp;
2247             }
2248           else
2249             high = mips16_gp_pseudo_reg ();
2250         }
2251       else
2252         {
2253           high = gen_rtx_HIGH (Pmode, copy_rtx (addr));
2254           high = mips_force_temporary (temp, high);
2255         }
2256       *lo_sum_out = gen_rtx_LO_SUM (Pmode, high, addr);
2257     }
2258   return true;
2259 }
2260
2261 /* Wrap symbol or label BASE in an UNSPEC address of type SYMBOL_TYPE,
2262    then add CONST_INT OFFSET to the result.  */
2263
2264 static rtx
2265 mips_unspec_address_offset (rtx base, rtx offset,
2266                             enum mips_symbol_type symbol_type)
2267 {
2268   base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base),
2269                          UNSPEC_ADDRESS_FIRST + symbol_type);
2270   if (offset != const0_rtx)
2271     base = gen_rtx_PLUS (Pmode, base, offset);
2272   return gen_rtx_CONST (Pmode, base);
2273 }
2274
2275 /* Return an UNSPEC address with underlying address ADDRESS and symbol
2276    type SYMBOL_TYPE.  */
2277
2278 rtx
2279 mips_unspec_address (rtx address, enum mips_symbol_type symbol_type)
2280 {
2281   rtx base, offset;
2282
2283   split_const (address, &base, &offset);
2284   return mips_unspec_address_offset (base, offset, symbol_type);
2285 }
2286
2287 /* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the
2288    high part to BASE and return the result.  Just return BASE otherwise.
2289    TEMP is as for mips_force_temporary.
2290
2291    The returned expression can be used as the first operand to a LO_SUM.  */
2292
2293 static rtx
2294 mips_unspec_offset_high (rtx temp, rtx base, rtx addr,
2295                          enum mips_symbol_type symbol_type)
2296 {
2297   if (mips_split_p[symbol_type])
2298     {
2299       addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type));
2300       addr = mips_force_temporary (temp, addr);
2301       base = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base));
2302     }
2303   return base;
2304 }
2305
2306 /* Return a legitimate address for REG + OFFSET.  TEMP is as for
2307    mips_force_temporary; it is only needed when OFFSET is not a
2308    SMALL_OPERAND.  */
2309
2310 static rtx
2311 mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
2312 {
2313   if (!SMALL_OPERAND (offset))
2314     {
2315       rtx high;
2316
2317       if (TARGET_MIPS16)
2318         {
2319           /* Load the full offset into a register so that we can use
2320              an unextended instruction for the address itself.  */
2321           high = GEN_INT (offset);
2322           offset = 0;
2323         }
2324       else
2325         {
2326           /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.  */
2327           high = GEN_INT (CONST_HIGH_PART (offset));
2328           offset = CONST_LOW_PART (offset);
2329         }
2330       high = mips_force_temporary (temp, high);
2331       reg = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, high, reg));
2332     }
2333   return plus_constant (reg, offset);
2334 }
2335 \f
2336 /* The __tls_get_attr symbol.  */
2337 static GTY(()) rtx mips_tls_symbol;
2338
2339 /* Return an instruction sequence that calls __tls_get_addr.  SYM is
2340    the TLS symbol we are referencing and TYPE is the symbol type to use
2341    (either global dynamic or local dynamic).  V0 is an RTX for the
2342    return value location.  */
2343
2344 static rtx
2345 mips_call_tls_get_addr (rtx sym, enum mips_symbol_type type, rtx v0)
2346 {
2347   rtx insn, loc, a0;
2348
2349   a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST);
2350
2351   if (!mips_tls_symbol)
2352     mips_tls_symbol = init_one_libfunc ("__tls_get_addr");
2353
2354   loc = mips_unspec_address (sym, type);
2355
2356   start_sequence ();
2357
2358   emit_insn (gen_rtx_SET (Pmode, a0,
2359                           gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, loc)));
2360   insn = mips_expand_call (v0, mips_tls_symbol, const0_rtx, const0_rtx, false);
2361   CONST_OR_PURE_CALL_P (insn) = 1;
2362   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
2363   insn = get_insns ();
2364
2365   end_sequence ();
2366
2367   return insn;
2368 }
2369
2370 /* Generate the code to access LOC, a thread-local SYMBOL_REF, and return
2371    its address.  The return value will be both a valid address and a valid
2372    SET_SRC (either a REG or a LO_SUM).  */
2373
2374 static rtx
2375 mips_legitimize_tls_address (rtx loc)
2376 {
2377   rtx dest, insn, v0, v1, tmp1, tmp2, eqv;
2378   enum tls_model model;
2379
2380   if (TARGET_MIPS16)
2381     {
2382       sorry ("MIPS16 TLS");
2383       return gen_reg_rtx (Pmode);
2384     }
2385
2386   model = SYMBOL_REF_TLS_MODEL (loc);
2387   /* Only TARGET_ABICALLS code can have more than one module; other
2388      code must be be static and should not use a GOT.  All TLS models
2389      reduce to local exec in this situation.  */
2390   if (!TARGET_ABICALLS)
2391     model = TLS_MODEL_LOCAL_EXEC;
2392
2393   switch (model)
2394     {
2395     case TLS_MODEL_GLOBAL_DYNAMIC:
2396       v0 = gen_rtx_REG (Pmode, GP_RETURN);
2397       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSGD, v0);
2398       dest = gen_reg_rtx (Pmode);
2399       emit_libcall_block (insn, dest, v0, loc);
2400       break;
2401
2402     case TLS_MODEL_LOCAL_DYNAMIC:
2403       v0 = gen_rtx_REG (Pmode, GP_RETURN);
2404       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSLDM, v0);
2405       tmp1 = gen_reg_rtx (Pmode);
2406
2407       /* Attach a unique REG_EQUIV, to allow the RTL optimizers to
2408          share the LDM result with other LD model accesses.  */
2409       eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
2410                             UNSPEC_TLS_LDM);
2411       emit_libcall_block (insn, tmp1, v0, eqv);
2412
2413       tmp2 = mips_unspec_offset_high (NULL, tmp1, loc, SYMBOL_DTPREL);
2414       dest = gen_rtx_LO_SUM (Pmode, tmp2,
2415                              mips_unspec_address (loc, SYMBOL_DTPREL));
2416       break;
2417
2418     case TLS_MODEL_INITIAL_EXEC:
2419       v1 = gen_rtx_REG (Pmode, GP_RETURN + 1);
2420       tmp1 = gen_reg_rtx (Pmode);
2421       tmp2 = mips_unspec_address (loc, SYMBOL_GOTTPREL);
2422       if (Pmode == DImode)
2423         {
2424           emit_insn (gen_tls_get_tp_di (v1));
2425           emit_insn (gen_load_gotdi (tmp1, pic_offset_table_rtx, tmp2));
2426         }
2427       else
2428         {
2429           emit_insn (gen_tls_get_tp_si (v1));
2430           emit_insn (gen_load_gotsi (tmp1, pic_offset_table_rtx, tmp2));
2431         }
2432       dest = gen_reg_rtx (Pmode);
2433       emit_insn (gen_add3_insn (dest, tmp1, v1));
2434       break;
2435
2436     case TLS_MODEL_LOCAL_EXEC:
2437       v1 = gen_rtx_REG (Pmode, GP_RETURN + 1);
2438       if (Pmode == DImode)
2439         emit_insn (gen_tls_get_tp_di (v1));
2440       else
2441         emit_insn (gen_tls_get_tp_si (v1));
2442
2443       tmp1 = mips_unspec_offset_high (NULL, v1, loc, SYMBOL_TPREL);
2444       dest = gen_rtx_LO_SUM (Pmode, tmp1,
2445                              mips_unspec_address (loc, SYMBOL_TPREL));
2446       break;
2447
2448     default:
2449       gcc_unreachable ();
2450     }
2451   return dest;
2452 }
2453 \f
2454 /* This function is used to implement LEGITIMIZE_ADDRESS.  If *XLOC can
2455    be legitimized in a way that the generic machinery might not expect,
2456    put the new address in *XLOC and return true.  MODE is the mode of
2457    the memory being accessed.  */
2458
2459 bool
2460 mips_legitimize_address (rtx *xloc, enum machine_mode mode)
2461 {
2462   rtx base;
2463   HOST_WIDE_INT offset;
2464
2465   if (mips_tls_symbol_p (*xloc))
2466     {
2467       *xloc = mips_legitimize_tls_address (*xloc);
2468       return true;
2469     }
2470
2471   /* See if the address can split into a high part and a LO_SUM.  */
2472   if (mips_split_symbol (NULL, *xloc, mode, xloc))
2473     return true;
2474
2475   /* Handle BASE + OFFSET using mips_add_offset.  */
2476   mips_split_plus (*xloc, &base, &offset);
2477   if (offset != 0)
2478     {
2479       if (!mips_valid_base_register_p (base, mode, false))
2480         base = copy_to_mode_reg (Pmode, base);
2481       *xloc = mips_add_offset (NULL, base, offset);
2482       return true;
2483     }
2484   return false;
2485 }
2486
2487 /* Load VALUE into DEST.  TEMP is as for mips_force_temporary.  */
2488
2489 void
2490 mips_move_integer (rtx temp, rtx dest, unsigned HOST_WIDE_INT value)
2491 {
2492   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2493   enum machine_mode mode;
2494   unsigned int i, num_ops;
2495   rtx x;
2496
2497   mode = GET_MODE (dest);
2498   num_ops = mips_build_integer (codes, value);
2499
2500   /* Apply each binary operation to X.  Invariant: X is a legitimate
2501      source operand for a SET pattern.  */
2502   x = GEN_INT (codes[0].value);
2503   for (i = 1; i < num_ops; i++)
2504     {
2505       if (!can_create_pseudo_p ())
2506         {
2507           emit_insn (gen_rtx_SET (VOIDmode, temp, x));
2508           x = temp;
2509         }
2510       else
2511         x = force_reg (mode, x);
2512       x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
2513     }
2514
2515   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
2516 }
2517
2518 /* Subroutine of mips_legitimize_move.  Move constant SRC into register
2519    DEST given that SRC satisfies immediate_operand but doesn't satisfy
2520    move_operand.  */
2521
2522 static void
2523 mips_legitimize_const_move (enum machine_mode mode, rtx dest, rtx src)
2524 {
2525   rtx base, offset;
2526
2527   /* Split moves of big integers into smaller pieces.  */
2528   if (splittable_const_int_operand (src, mode))
2529     {
2530       mips_move_integer (dest, dest, INTVAL (src));
2531       return;
2532     }
2533
2534   /* Split moves of symbolic constants into high/low pairs.  */
2535   if (mips_split_symbol (dest, src, MAX_MACHINE_MODE, &src))
2536     {
2537       emit_insn (gen_rtx_SET (VOIDmode, dest, src));
2538       return;
2539     }
2540
2541   /* Generate the appropriate access sequences for TLS symbols.  */
2542   if (mips_tls_symbol_p (src))
2543     {
2544       mips_emit_move (dest, mips_legitimize_tls_address (src));
2545       return;
2546     }
2547
2548   /* If we have (const (plus symbol offset)), and that expression cannot
2549      be forced into memory, load the symbol first and add in the offset.
2550      In non-MIPS16 mode, prefer to do this even if the constant _can_ be
2551      forced into memory, as it usually produces better code.  */
2552   split_const (src, &base, &offset);
2553   if (offset != const0_rtx
2554       && (targetm.cannot_force_const_mem (src)
2555           || (!TARGET_MIPS16 && can_create_pseudo_p ())))
2556     {
2557       base = mips_force_temporary (dest, base);
2558       mips_emit_move (dest, mips_add_offset (NULL, base, INTVAL (offset)));
2559       return;
2560     }
2561
2562   src = force_const_mem (mode, src);
2563
2564   /* When using explicit relocs, constant pool references are sometimes
2565      not legitimate addresses.  */
2566   mips_split_symbol (dest, XEXP (src, 0), mode, &XEXP (src, 0));
2567   mips_emit_move (dest, src);
2568 }
2569
2570 /* If (set DEST SRC) is not a valid move instruction, emit an equivalent
2571    sequence that is valid.  */
2572
2573 bool
2574 mips_legitimize_move (enum machine_mode mode, rtx dest, rtx src)
2575 {
2576   if (!register_operand (dest, mode) && !reg_or_0_operand (src, mode))
2577     {
2578       mips_emit_move (dest, force_reg (mode, src));
2579       return true;
2580     }
2581
2582   /* Check for individual, fully-reloaded mflo and mfhi instructions.  */
2583   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
2584       && REG_P (src) && MD_REG_P (REGNO (src))
2585       && REG_P (dest) && GP_REG_P (REGNO (dest)))
2586     {
2587       int other_regno = REGNO (src) == HI_REGNUM ? LO_REGNUM : HI_REGNUM;
2588       if (GET_MODE_SIZE (mode) <= 4)
2589         emit_insn (gen_mfhilo_si (gen_lowpart (SImode, dest),
2590                                   gen_lowpart (SImode, src),
2591                                   gen_rtx_REG (SImode, other_regno)));
2592       else
2593         emit_insn (gen_mfhilo_di (gen_lowpart (DImode, dest),
2594                                   gen_lowpart (DImode, src),
2595                                   gen_rtx_REG (DImode, other_regno)));
2596       return true;
2597     }
2598
2599   /* We need to deal with constants that would be legitimate
2600      immediate_operands but aren't legitimate move_operands.  */
2601   if (CONSTANT_P (src) && !move_operand (src, mode))
2602     {
2603       mips_legitimize_const_move (mode, dest, src);
2604       set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (src));
2605       return true;
2606     }
2607   return false;
2608 }
2609 \f
2610 /* Return true if value X in context CONTEXT is a small-data address
2611    that can be rewritten as a LO_SUM.  */
2612
2613 static bool
2614 mips_rewrite_small_data_p (rtx x, enum mips_symbol_context context)
2615 {
2616   enum mips_symbol_type symbol_type;
2617
2618   return (TARGET_EXPLICIT_RELOCS
2619           && mips_symbolic_constant_p (x, context, &symbol_type)
2620           && symbol_type == SYMBOL_GP_RELATIVE);
2621 }
2622
2623 /* A for_each_rtx callback for mips_small_data_pattern_p.  DATA is the
2624    containing MEM, or null if none.  */
2625
2626 static int
2627 mips_small_data_pattern_1 (rtx *loc, void *data)
2628 {
2629   enum mips_symbol_context context;
2630
2631   if (GET_CODE (*loc) == LO_SUM)
2632     return -1;
2633
2634   if (MEM_P (*loc))
2635     {
2636       if (for_each_rtx (&XEXP (*loc, 0), mips_small_data_pattern_1, *loc))
2637         return 1;
2638       return -1;
2639     }
2640
2641   context = data ? SYMBOL_CONTEXT_MEM : SYMBOL_CONTEXT_LEA;
2642   return mips_rewrite_small_data_p (*loc, context);
2643 }
2644
2645 /* Return true if OP refers to small data symbols directly, not through
2646    a LO_SUM.  */
2647
2648 bool
2649 mips_small_data_pattern_p (rtx op)
2650 {
2651   return for_each_rtx (&op, mips_small_data_pattern_1, NULL);
2652 }
2653
2654 /* A for_each_rtx callback, used by mips_rewrite_small_data.
2655    DATA is the containing MEM, or null if none.  */
2656
2657 static int
2658 mips_rewrite_small_data_1 (rtx *loc, void *data)
2659 {
2660   enum mips_symbol_context context;
2661
2662   if (MEM_P (*loc))
2663     {
2664       for_each_rtx (&XEXP (*loc, 0), mips_rewrite_small_data_1, *loc);
2665       return -1;
2666     }
2667
2668   context = data ? SYMBOL_CONTEXT_MEM : SYMBOL_CONTEXT_LEA;
2669   if (mips_rewrite_small_data_p (*loc, context))
2670     *loc = gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, *loc);
2671
2672   if (GET_CODE (*loc) == LO_SUM)
2673     return -1;
2674
2675   return 0;
2676 }
2677
2678 /* Rewrite instruction pattern PATTERN so that it refers to small data
2679    using explicit relocations.  */
2680
2681 rtx
2682 mips_rewrite_small_data (rtx pattern)
2683 {
2684   pattern = copy_insn (pattern);
2685   for_each_rtx (&pattern, mips_rewrite_small_data_1, NULL);
2686   return pattern;
2687 }
2688 \f
2689 /* We need a lot of little routines to check the range of MIPS16 immediate
2690    operands.  */
2691
2692 static int
2693 m16_check_op (rtx op, int low, int high, int mask)
2694 {
2695   return (GET_CODE (op) == CONST_INT
2696           && IN_RANGE (INTVAL (op), low, high)
2697           && (INTVAL (op) & mask) == 0);
2698 }
2699
2700 int
2701 m16_uimm3_b (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2702 {
2703   return m16_check_op (op, 0x1, 0x8, 0);
2704 }
2705
2706 int
2707 m16_simm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2708 {
2709   return m16_check_op (op, -0x8, 0x7, 0);
2710 }
2711
2712 int
2713 m16_nsimm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2714 {
2715   return m16_check_op (op, -0x7, 0x8, 0);
2716 }
2717
2718 int
2719 m16_simm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2720 {
2721   return m16_check_op (op, -0x10, 0xf, 0);
2722 }
2723
2724 int
2725 m16_nsimm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2726 {
2727   return m16_check_op (op, -0xf, 0x10, 0);
2728 }
2729
2730 int
2731 m16_uimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2732 {
2733   return m16_check_op (op, -0x10 << 2, 0xf << 2, 3);
2734 }
2735
2736 int
2737 m16_nuimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2738 {
2739   return m16_check_op (op, -0xf << 2, 0x10 << 2, 3);
2740 }
2741
2742 int
2743 m16_simm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2744 {
2745   return m16_check_op (op, -0x80, 0x7f, 0);
2746 }
2747
2748 int
2749 m16_nsimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2750 {
2751   return m16_check_op (op, -0x7f, 0x80, 0);
2752 }
2753
2754 int
2755 m16_uimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2756 {
2757   return m16_check_op (op, 0x0, 0xff, 0);
2758 }
2759
2760 int
2761 m16_nuimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2762 {
2763   return m16_check_op (op, -0xff, 0x0, 0);
2764 }
2765
2766 int
2767 m16_uimm8_m1_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2768 {
2769   return m16_check_op (op, -0x1, 0xfe, 0);
2770 }
2771
2772 int
2773 m16_uimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2774 {
2775   return m16_check_op (op, 0x0, 0xff << 2, 3);
2776 }
2777
2778 int
2779 m16_nuimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2780 {
2781   return m16_check_op (op, -0xff << 2, 0x0, 3);
2782 }
2783
2784 int
2785 m16_simm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2786 {
2787   return m16_check_op (op, -0x80 << 3, 0x7f << 3, 7);
2788 }
2789
2790 int
2791 m16_nsimm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2792 {
2793   return m16_check_op (op, -0x7f << 3, 0x80 << 3, 7);
2794 }
2795 \f
2796 /* The cost of loading values from the constant pool.  It should be
2797    larger than the cost of any constant we want to synthesize inline.  */
2798 #define CONSTANT_POOL_COST COSTS_N_INSNS (TARGET_MIPS16 ? 4 : 8)
2799
2800 /* Return the cost of X when used as an operand to the MIPS16 instruction
2801    that implements CODE.  Return -1 if there is no such instruction, or if
2802    X is not a valid immediate operand for it.  */
2803
2804 static int
2805 mips16_constant_cost (int code, HOST_WIDE_INT x)
2806 {
2807   switch (code)
2808     {
2809     case ASHIFT:
2810     case ASHIFTRT:
2811     case LSHIFTRT:
2812       /* Shifts by between 1 and 8 bits (inclusive) are unextended,
2813          other shifts are extended.  The shift patterns truncate the shift
2814          count to the right size, so there are no out-of-range values.  */
2815       if (IN_RANGE (x, 1, 8))
2816         return 0;
2817       return COSTS_N_INSNS (1);
2818
2819     case PLUS:
2820       if (IN_RANGE (x, -128, 127))
2821         return 0;
2822       if (SMALL_OPERAND (x))
2823         return COSTS_N_INSNS (1);
2824       return -1;
2825
2826     case LEU:
2827       /* Like LE, but reject the always-true case.  */
2828       if (x == -1)
2829         return -1;
2830     case LE:
2831       /* We add 1 to the immediate and use SLT.  */
2832       x += 1;
2833     case XOR:
2834       /* We can use CMPI for an xor with an unsigned 16-bit X.  */
2835     case LT:
2836     case LTU:
2837       if (IN_RANGE (x, 0, 255))
2838         return 0;
2839       if (SMALL_OPERAND_UNSIGNED (x))
2840         return COSTS_N_INSNS (1);
2841       return -1;
2842
2843     case EQ:
2844     case NE:
2845       /* Equality comparisons with 0 are cheap.  */
2846       if (x == 0)
2847         return 0;
2848       return -1;
2849
2850     default:
2851       return -1;
2852     }
2853 }
2854
2855 /* Return true if there is a non-MIPS16 instruction that implements CODE
2856    and if that instruction accepts X as an immediate operand.  */
2857
2858 static int
2859 mips_immediate_operand_p (int code, HOST_WIDE_INT x)
2860 {
2861   switch (code)
2862     {
2863     case ASHIFT:
2864     case ASHIFTRT:
2865     case LSHIFTRT:
2866       /* All shift counts are truncated to a valid constant.  */
2867       return true;
2868
2869     case ROTATE:
2870     case ROTATERT:
2871       /* Likewise rotates, if the target supports rotates at all.  */
2872       return ISA_HAS_ROR;
2873
2874     case AND:
2875     case IOR:
2876     case XOR:
2877       /* These instructions take 16-bit unsigned immediates.  */
2878       return SMALL_OPERAND_UNSIGNED (x);
2879
2880     case PLUS:
2881     case LT:
2882     case LTU:
2883       /* These instructions take 16-bit signed immediates.  */
2884       return SMALL_OPERAND (x);
2885
2886     case EQ:
2887     case NE:
2888     case GT:
2889     case GTU:
2890       /* The "immediate" forms of these instructions are really
2891          implemented as comparisons with register 0.  */
2892       return x == 0;
2893
2894     case GE:
2895     case GEU:
2896       /* Likewise, meaning that the only valid immediate operand is 1.  */
2897       return x == 1;
2898
2899     case LE:
2900       /* We add 1 to the immediate and use SLT.  */
2901       return SMALL_OPERAND (x + 1);
2902
2903     case LEU:
2904       /* Likewise SLTU, but reject the always-true case.  */
2905       return SMALL_OPERAND (x + 1) && x + 1 != 0;
2906
2907     case SIGN_EXTRACT:
2908     case ZERO_EXTRACT:
2909       /* The bit position and size are immediate operands.  */
2910       return ISA_HAS_EXT_INS;
2911
2912     default:
2913       /* By default assume that $0 can be used for 0.  */
2914       return x == 0;
2915     }
2916 }
2917
2918 /* Return the cost of binary operation X, given that the instruction
2919    sequence for a word-sized or smaller operation has cost SINGLE_COST
2920    and that the sequence of a double-word operation has cost DOUBLE_COST.  */
2921
2922 static int
2923 mips_binary_cost (rtx x, int single_cost, int double_cost)
2924 {
2925   int cost;
2926
2927   if (GET_MODE_SIZE (GET_MODE (x)) == UNITS_PER_WORD * 2)
2928     cost = double_cost;
2929   else
2930     cost = single_cost;
2931   return (cost
2932           + rtx_cost (XEXP (x, 0), 0)
2933           + rtx_cost (XEXP (x, 1), GET_CODE (x)));
2934 }
2935
2936 /* Return the cost of floating-point multiplications of mode MODE.  */
2937
2938 static int
2939 mips_fp_mult_cost (enum machine_mode mode)
2940 {
2941   return mode == DFmode ? mips_cost->fp_mult_df : mips_cost->fp_mult_sf;
2942 }
2943
2944 /* Return the cost of floating-point divisions of mode MODE.  */
2945
2946 static int
2947 mips_fp_div_cost (enum machine_mode mode)
2948 {
2949   return mode == DFmode ? mips_cost->fp_div_df : mips_cost->fp_div_sf;
2950 }
2951
2952 /* Return the cost of sign-extending OP to mode MODE, not including the
2953    cost of OP itself.  */
2954
2955 static int
2956 mips_sign_extend_cost (enum machine_mode mode, rtx op)
2957 {
2958   if (MEM_P (op))
2959     /* Extended loads are as cheap as unextended ones.  */
2960     return 0;
2961
2962   if (TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode)
2963     /* A sign extension from SImode to DImode in 64-bit mode is free.  */
2964     return 0;
2965
2966   if (ISA_HAS_SEB_SEH || GENERATE_MIPS16E)
2967     /* We can use SEB or SEH.  */
2968     return COSTS_N_INSNS (1);
2969
2970   /* We need to use a shift left and a shift right.  */
2971   return COSTS_N_INSNS (TARGET_MIPS16 ? 4 : 2);
2972 }
2973
2974 /* Return the cost of zero-extending OP to mode MODE, not including the
2975    cost of OP itself.  */
2976
2977 static int
2978 mips_zero_extend_cost (enum machine_mode mode, rtx op)
2979 {
2980   if (MEM_P (op))
2981     /* Extended loads are as cheap as unextended ones.  */
2982     return 0;
2983
2984   if (TARGET_64BIT && mode == DImode && GET_MODE (op) == SImode)
2985     /* We need a shift left by 32 bits and a shift right by 32 bits.  */
2986     return COSTS_N_INSNS (TARGET_MIPS16 ? 4 : 2);
2987
2988   if (GENERATE_MIPS16E)
2989     /* We can use ZEB or ZEH.  */
2990     return COSTS_N_INSNS (1);
2991
2992   if (TARGET_MIPS16)
2993     /* We need to load 0xff or 0xffff into a register and use AND.  */
2994     return COSTS_N_INSNS (GET_MODE (op) == QImode ? 2 : 3);
2995
2996   /* We can use ANDI.  */
2997   return COSTS_N_INSNS (1);
2998 }
2999
3000 /* Implement TARGET_RTX_COSTS.  */
3001
3002 static bool
3003 mips_rtx_costs (rtx x, int code, int outer_code, int *total)
3004 {
3005   enum machine_mode mode = GET_MODE (x);
3006   bool float_mode_p = FLOAT_MODE_P (mode);
3007   int cost;
3008   rtx addr;
3009
3010   /* The cost of a COMPARE is hard to define for MIPS.  COMPAREs don't
3011      appear in the instruction stream, and the cost of a comparison is
3012      really the cost of the branch or scc condition.  At the time of
3013      writing, GCC only uses an explicit outer COMPARE code when optabs
3014      is testing whether a constant is expensive enough to force into a
3015      register.  We want optabs to pass such constants through the MIPS
3016      expanders instead, so make all constants very cheap here.  */
3017   if (outer_code == COMPARE)
3018     {
3019       gcc_assert (CONSTANT_P (x));
3020       *total = 0;
3021       return true;
3022     }
3023
3024   switch (code)
3025     {
3026     case CONST_INT:
3027       /* Treat *clear_upper32-style ANDs as having zero cost in the
3028          second operand.  The cost is entirely in the first operand.
3029
3030          ??? This is needed because we would otherwise try to CSE
3031          the constant operand.  Although that's the right thing for
3032          instructions that continue to be a register operation throughout
3033          compilation, it is disastrous for instructions that could
3034          later be converted into a memory operation.  */
3035       if (TARGET_64BIT
3036           && outer_code == AND
3037           && UINTVAL (x) == 0xffffffff)
3038         {
3039           *total = 0;
3040           return true;
3041         }
3042
3043       if (TARGET_MIPS16)
3044         {
3045           cost = mips16_constant_cost (outer_code, INTVAL (x));
3046           if (cost >= 0)
3047             {
3048               *total = cost;
3049               return true;
3050             }
3051         }
3052       else
3053         {
3054           /* When not optimizing for size, we care more about the cost
3055              of hot code, and hot code is often in a loop.  If a constant
3056              operand needs to be forced into a register, we will often be
3057              able to hoist the constant load out of the loop, so the load
3058              should not contribute to the cost.  */
3059           if (!optimize_size
3060               || mips_immediate_operand_p (outer_code, INTVAL (x)))
3061             {
3062               *total = 0;
3063               return true;
3064             }
3065         }
3066       /* Fall through.  */
3067
3068     case CONST:
3069     case SYMBOL_REF:
3070     case LABEL_REF:
3071     case CONST_DOUBLE:
3072       if (force_to_mem_operand (x, VOIDmode))
3073         {
3074           *total = COSTS_N_INSNS (1);
3075           return true;
3076         }
3077       cost = mips_const_insns (x);
3078       if (cost > 0)
3079         {
3080           /* If the constant is likely to be stored in a GPR, SETs of
3081              single-insn constants are as cheap as register sets; we
3082              never want to CSE them.
3083
3084              Don't reduce the cost of storing a floating-point zero in
3085              FPRs.  If we have a zero in an FPR for other reasons, we
3086              can get better cfg-cleanup and delayed-branch results by
3087              using it consistently, rather than using $0 sometimes and
3088              an FPR at other times.  Also, moves between floating-point
3089              registers are sometimes cheaper than (D)MTC1 $0.  */
3090           if (cost == 1
3091               && outer_code == SET
3092               && !(float_mode_p && TARGET_HARD_FLOAT))
3093             cost = 0;
3094           /* When non-MIPS16 code loads a constant N>1 times, we rarely
3095              want to CSE the constant itself.  It is usually better to
3096              have N copies of the last operation in the sequence and one
3097              shared copy of the other operations.  (Note that this is
3098              not true for MIPS16 code, where the final operation in the
3099              sequence is often an extended instruction.)
3100
3101              Also, if we have a CONST_INT, we don't know whether it is
3102              for a word or doubleword operation, so we cannot rely on
3103              the result of mips_build_integer.  */
3104           else if (!TARGET_MIPS16
3105                    && (outer_code == SET || mode == VOIDmode))
3106             cost = 1;
3107           *total = COSTS_N_INSNS (cost);
3108           return true;
3109         }
3110       /* The value will need to be fetched from the constant pool.  */
3111       *total = CONSTANT_POOL_COST;
3112       return true;
3113
3114     case MEM:
3115       /* If the address is legitimate, return the number of
3116          instructions it needs.  */
3117       addr = XEXP (x, 0);
3118       cost = mips_address_insns (addr, mode, true);
3119       if (cost > 0)
3120         {
3121           *total = COSTS_N_INSNS (cost + 1);
3122           return true;
3123         }
3124       /* Check for a scaled indexed address.  */
3125       if (mips_lwxs_address_p (addr))
3126         {
3127           *total = COSTS_N_INSNS (2);
3128           return true;
3129         }
3130       /* Otherwise use the default handling.  */
3131       return false;
3132
3133     case FFS:
3134       *total = COSTS_N_INSNS (6);
3135       return false;
3136
3137     case NOT:
3138       *total = COSTS_N_INSNS (GET_MODE_SIZE (mode) > UNITS_PER_WORD ? 2 : 1);
3139       return false;
3140
3141     case AND:
3142       /* Check for a *clear_upper32 pattern and treat it like a zero
3143          extension.  See the pattern's comment for details.  */
3144       if (TARGET_64BIT
3145           && mode == DImode
3146           && CONST_INT_P (XEXP (x, 1))
3147           && UINTVAL (XEXP (x, 1)) == 0xffffffff)
3148         {
3149           *total = (mips_zero_extend_cost (mode, XEXP (x, 0))
3150                     + rtx_cost (XEXP (x, 0), 0));
3151           return true;
3152         }
3153       /* Fall through.  */
3154
3155     case IOR:
3156     case XOR:
3157       /* Double-word operations use two single-word operations.  */
3158       *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (2));
3159       return true;
3160
3161     case ASHIFT:
3162     case ASHIFTRT:
3163     case LSHIFTRT:
3164     case ROTATE:
3165     case ROTATERT:
3166       if (CONSTANT_P (XEXP (x, 1)))
3167         *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (4));
3168       else
3169         *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (12));
3170       return true;
3171
3172     case ABS:
3173       if (float_mode_p)
3174         *total = mips_cost->fp_add;
3175       else
3176         *total = COSTS_N_INSNS (4);
3177       return false;
3178
3179     case LO_SUM:
3180       /* Low-part immediates need an extended MIPS16 instruction.  */
3181       *total = (COSTS_N_INSNS (TARGET_MIPS16 ? 2 : 1)
3182                 + rtx_cost (XEXP (x, 0), 0));
3183       return true;
3184
3185     case LT:
3186     case LTU:
3187     case LE:
3188     case LEU:
3189     case GT:
3190     case GTU:
3191     case GE:
3192     case GEU:
3193     case EQ:
3194     case NE:
3195     case UNORDERED:
3196     case LTGT:
3197       /* Branch comparisons have VOIDmode, so use the first operand's
3198          mode instead.  */
3199       mode = GET_MODE (XEXP (x, 0));
3200       if (FLOAT_MODE_P (mode))
3201         {
3202           *total = mips_cost->fp_add;
3203           return false;
3204         }
3205       *total = mips_binary_cost (x, COSTS_N_INSNS (1), COSTS_N_INSNS (4));
3206       return true;
3207
3208     case MINUS:
3209       if (float_mode_p
3210           && ISA_HAS_NMADD_NMSUB (mode)
3211           && TARGET_FUSED_MADD
3212           && !HONOR_NANS (mode)
3213           && !HONOR_SIGNED_ZEROS (mode))
3214         {
3215           /* See if we can use NMADD or NMSUB.  See mips.md for the
3216              associated patterns.  */
3217           rtx op0 = XEXP (x, 0);
3218           rtx op1 = XEXP (x, 1);
3219           if (GET_CODE (op0) == MULT && GET_CODE (XEXP (op0, 0)) == NEG)
3220             {
3221               *total = (mips_fp_mult_cost (mode)
3222                         + rtx_cost (XEXP (XEXP (op0, 0), 0), 0)
3223                         + rtx_cost (XEXP (op0, 1), 0)
3224                         + rtx_cost (op1, 0));
3225               return true;
3226             }
3227           if (GET_CODE (op1) == MULT)
3228             {
3229               *total = (mips_fp_mult_cost (mode)
3230                         + rtx_cost (op0, 0)
3231                         + rtx_cost (XEXP (op1, 0), 0)
3232                         + rtx_cost (XEXP (op1, 1), 0));
3233               return true;
3234             }
3235         }
3236       /* Fall through.  */
3237
3238     case PLUS:
3239       if (float_mode_p)
3240         {
3241           /* If this is part of a MADD or MSUB, treat the PLUS as
3242              being free.  */
3243           if (ISA_HAS_FP4
3244               && TARGET_FUSED_MADD
3245               && GET_CODE (XEXP (x, 0)) == MULT)
3246             *total = 0;
3247           else
3248             *total = mips_cost->fp_add;
3249           return false;
3250         }
3251
3252       /* Double-word operations require three single-word operations and
3253          an SLTU.  The MIPS16 version then needs to move the result of
3254          the SLTU from $24 to a MIPS16 register.  */
3255       *total = mips_binary_cost (x, COSTS_N_INSNS (1),
3256                                  COSTS_N_INSNS (TARGET_MIPS16 ? 5 : 4));
3257       return true;
3258
3259     case NEG:
3260       if (float_mode_p
3261           && ISA_HAS_NMADD_NMSUB (mode)
3262           && TARGET_FUSED_MADD
3263           && !HONOR_NANS (mode)
3264           && HONOR_SIGNED_ZEROS (mode))
3265         {
3266           /* See if we can use NMADD or NMSUB.  See mips.md for the
3267              associated patterns.  */
3268           rtx op = XEXP (x, 0);
3269           if ((GET_CODE (op) == PLUS || GET_CODE (op) == MINUS)
3270               && GET_CODE (XEXP (op, 0)) == MULT)
3271             {
3272               *total = (mips_fp_mult_cost (mode)
3273                         + rtx_cost (XEXP (XEXP (op, 0), 0), 0)
3274                         + rtx_cost (XEXP (XEXP (op, 0), 1), 0)
3275                         + rtx_cost (XEXP (op, 1), 0));
3276               return true;
3277             }
3278         }
3279
3280       if (float_mode_p)
3281         *total = mips_cost->fp_add;
3282       else
3283         *total = COSTS_N_INSNS (GET_MODE_SIZE (mode) > UNITS_PER_WORD ? 4 : 1);
3284       return false;
3285
3286     case MULT:
3287       if (float_mode_p)
3288         *total = mips_fp_mult_cost (mode);
3289       else if (mode == DImode && !TARGET_64BIT)
3290         /* Synthesized from 2 mulsi3s, 1 mulsidi3 and two additions,
3291            where the mulsidi3 always includes an MFHI and an MFLO.  */
3292         *total = (optimize_size
3293                   ? COSTS_N_INSNS (ISA_HAS_MUL3 ? 7 : 9)
3294                   : mips_cost->int_mult_si * 3 + 6);
3295       else if (optimize_size)
3296         *total = (ISA_HAS_MUL3 ? 1 : 2);
3297       else if (mode == DImode)
3298         *total = mips_cost->int_mult_di;
3299       else
3300         *total = mips_cost->int_mult_si;
3301       return false;
3302
3303     case DIV:
3304       /* Check for a reciprocal.  */
3305       if (float_mode_p
3306           && ISA_HAS_FP4
3307           && flag_unsafe_math_optimizations
3308           && XEXP (x, 0) == CONST1_RTX (mode))
3309         {
3310           if (outer_code == SQRT || GET_CODE (XEXP (x, 1)) == SQRT)
3311             /* An rsqrt<mode>a or rsqrt<mode>b pattern.  Count the
3312                division as being free.  */
3313             *total = rtx_cost (XEXP (x, 1), 0);
3314           else
3315             *total = mips_fp_div_cost (mode) + rtx_cost (XEXP (x, 1), 0);
3316           return true;
3317         }
3318       /* Fall through.  */
3319
3320     case SQRT:
3321     case MOD:
3322       if (float_mode_p)
3323         {
3324           *total = mips_fp_div_cost (mode);
3325           return false;
3326         }
3327       /* Fall through.  */
3328
3329     case UDIV:
3330     case UMOD:
3331       if (optimize_size)
3332         {
3333           /* It is our responsibility to make division by a power of 2
3334              as cheap as 2 register additions if we want the division
3335              expanders to be used for such operations; see the setting
3336              of sdiv_pow2_cheap in optabs.c.  Using (D)DIV for MIPS16
3337              should always produce shorter code than using
3338              expand_sdiv2_pow2.  */
3339           if (TARGET_MIPS16
3340               && CONST_INT_P (XEXP (x, 1))
3341               && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
3342             {
3343               *total = COSTS_N_INSNS (2) + rtx_cost (XEXP (x, 0), 0);
3344               return true;
3345             }
3346           *total = COSTS_N_INSNS (mips_idiv_insns ());
3347         }
3348       else if (mode == DImode)
3349         *total = mips_cost->int_div_di;
3350       else
3351         *total = mips_cost->int_div_si;
3352       return false;
3353
3354     case SIGN_EXTEND:
3355       *total = mips_sign_extend_cost (mode, XEXP (x, 0));
3356       return false;
3357
3358     case ZERO_EXTEND:
3359       *total = mips_zero_extend_cost (mode, XEXP (x, 0));
3360       return false;
3361
3362     case FLOAT:
3363     case UNSIGNED_FLOAT:
3364     case FIX:
3365     case FLOAT_EXTEND:
3366     case FLOAT_TRUNCATE:
3367       *total = mips_cost->fp_add;
3368       return false;
3369
3370     default:
3371       return false;
3372     }
3373 }
3374
3375 /* Implement TARGET_ADDRESS_COST.  */
3376
3377 static int
3378 mips_address_cost (rtx addr)
3379 {
3380   return mips_address_insns (addr, SImode, false);
3381 }
3382 \f
3383 /* Return one word of double-word value OP, taking into account the fixed
3384    endianness of certain registers.  HIGH_P is true to select the high part,
3385    false to select the low part.  */
3386
3387 rtx
3388 mips_subword (rtx op, bool high_p)
3389 {
3390   unsigned int byte, offset;
3391   enum machine_mode mode;
3392
3393   mode = GET_MODE (op);
3394   if (mode == VOIDmode)
3395     mode = DImode;
3396
3397   if (TARGET_BIG_ENDIAN ? !high_p : high_p)
3398     byte = UNITS_PER_WORD;
3399   else
3400     byte = 0;
3401
3402   if (FP_REG_RTX_P (op))
3403     {
3404       /* Paired FPRs are always ordered little-endian.  */
3405       offset = (UNITS_PER_WORD < UNITS_PER_HWFPVALUE ? high_p : byte != 0);
3406       return gen_rtx_REG (word_mode, REGNO (op) + offset);
3407     }
3408
3409   if (MEM_P (op))
3410     return mips_rewrite_small_data (adjust_address (op, word_mode, byte));
3411
3412   return simplify_gen_subreg (word_mode, op, mode, byte);
3413 }
3414
3415 /* Return true if a 64-bit move from SRC to DEST should be split into two.  */
3416
3417 bool
3418 mips_split_64bit_move_p (rtx dest, rtx src)
3419 {
3420   if (TARGET_64BIT)
3421     return false;
3422
3423   /* FPR-to-FPR moves can be done in a single instruction, if they're
3424      allowed at all.  */
3425   if (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest))
3426     return false;
3427
3428   /* Check for floating-point loads and stores.  */
3429   if (ISA_HAS_LDC1_SDC1)
3430     {
3431       if (FP_REG_RTX_P (dest) && MEM_P (src))
3432         return false;
3433       if (FP_REG_RTX_P (src) && MEM_P (dest))
3434         return false;
3435     }
3436   return true;
3437 }
3438
3439 /* Split a doubleword move from SRC to DEST.  On 32-bit targets,
3440    this function handles 64-bit moves for which mips_split_64bit_move_p
3441    holds.  For 64-bit targets, this function handles 128-bit moves.  */
3442
3443 void
3444 mips_split_doubleword_move (rtx dest, rtx src)
3445 {
3446   if (FP_REG_RTX_P (dest) || FP_REG_RTX_P (src))
3447     {
3448       if (!TARGET_64BIT && GET_MODE (dest) == DImode)
3449         emit_insn (gen_move_doubleword_fprdi (dest, src));
3450       else if (!TARGET_64BIT && GET_MODE (dest) == DFmode)
3451         emit_insn (gen_move_doubleword_fprdf (dest, src));
3452       else if (!TARGET_64BIT && GET_MODE (dest) == V2SFmode)
3453         emit_insn (gen_move_doubleword_fprv2sf (dest, src));
3454       else if (TARGET_64BIT && GET_MODE (dest) == TFmode)
3455         emit_insn (gen_move_doubleword_fprtf (dest, src));
3456       else
3457         gcc_unreachable ();
3458     }
3459   else
3460     {
3461       /* The operation can be split into two normal moves.  Decide in
3462          which order to do them.  */
3463       rtx low_dest;
3464
3465       low_dest = mips_subword (dest, false);
3466       if (REG_P (low_dest)
3467           && reg_overlap_mentioned_p (low_dest, src))
3468         {
3469           mips_emit_move (mips_subword (dest, true), mips_subword (src, true));
3470           mips_emit_move (low_dest, mips_subword (src, false));
3471         }
3472       else
3473         {
3474           mips_emit_move (low_dest, mips_subword (src, false));
3475           mips_emit_move (mips_subword (dest, true), mips_subword (src, true));
3476         }
3477     }
3478 }
3479 \f
3480 /* Return the appropriate instructions to move SRC into DEST.  Assume
3481    that SRC is operand 1 and DEST is operand 0.  */
3482
3483 const char *
3484 mips_output_move (rtx dest, rtx src)
3485 {
3486   enum rtx_code dest_code, src_code;
3487   enum machine_mode mode;
3488   enum mips_symbol_type symbol_type;
3489   bool dbl_p;
3490
3491   dest_code = GET_CODE (dest);
3492   src_code = GET_CODE (src);
3493   mode = GET_MODE (dest);
3494   dbl_p = (GET_MODE_SIZE (mode) == 8);
3495
3496   if (dbl_p && mips_split_64bit_move_p (dest, src))
3497     return "#";
3498
3499   if ((src_code == REG && GP_REG_P (REGNO (src)))
3500       || (!TARGET_MIPS16 && src == CONST0_RTX (mode)))
3501     {
3502       if (dest_code == REG)
3503         {
3504           if (GP_REG_P (REGNO (dest)))
3505             return "move\t%0,%z1";
3506
3507           if (MD_REG_P (REGNO (dest)))
3508             return "mt%0\t%z1";
3509
3510           if (DSP_ACC_REG_P (REGNO (dest)))
3511             {
3512               static char retval[] = "mt__\t%z1,%q0";
3513
3514               retval[2] = reg_names[REGNO (dest)][4];
3515               retval[3] = reg_names[REGNO (dest)][5];
3516               return retval;
3517             }
3518
3519           if (FP_REG_P (REGNO (dest)))
3520             return dbl_p ? "dmtc1\t%z1,%0" : "mtc1\t%z1,%0";
3521
3522           if (ALL_COP_REG_P (REGNO (dest)))
3523             {
3524               static char retval[] = "dmtc_\t%z1,%0";
3525
3526               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
3527               return dbl_p ? retval : retval + 1;
3528             }
3529         }
3530       if (dest_code == MEM)
3531         return dbl_p ? "sd\t%z1,%0" : "sw\t%z1,%0";
3532     }
3533   if (dest_code == REG && GP_REG_P (REGNO (dest)))
3534     {
3535       if (src_code == REG)
3536         {
3537           /* Handled by separate patterns.  */
3538           gcc_assert (!MD_REG_P (REGNO (src)));
3539
3540           if (DSP_ACC_REG_P (REGNO (src)))
3541             {
3542               static char retval[] = "mf__\t%0,%q1";
3543
3544               retval[2] = reg_names[REGNO (src)][4];
3545               retval[3] = reg_names[REGNO (src)][5];
3546               return retval;
3547             }
3548
3549           if (FP_REG_P (REGNO (src)))
3550             return dbl_p ? "dmfc1\t%0,%1" : "mfc1\t%0,%1";
3551
3552           if (ALL_COP_REG_P (REGNO (src)))
3553             {
3554               static char retval[] = "dmfc_\t%0,%1";
3555
3556               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
3557               return dbl_p ? retval : retval + 1;
3558             }
3559
3560           if (ST_REG_P (REGNO (src)) && ISA_HAS_8CC)
3561             return "lui\t%0,0x3f80\n\tmovf\t%0,%.,%1";
3562         }
3563
3564       if (src_code == MEM)
3565         return dbl_p ? "ld\t%0,%1" : "lw\t%0,%1";
3566
3567       if (src_code == CONST_INT)
3568         {
3569           /* Don't use the X format for the operand itself, because that
3570              will give out-of-range numbers for 64-bit hosts and 32-bit
3571              targets.  */
3572           if (!TARGET_MIPS16)
3573             return "li\t%0,%1\t\t\t# %X1";
3574
3575           if (SMALL_OPERAND_UNSIGNED (INTVAL (src)))
3576             return "li\t%0,%1";
3577
3578           if (SMALL_OPERAND_UNSIGNED (-INTVAL (src)))
3579             return "#";
3580         }
3581
3582       if (src_code == HIGH)
3583         return TARGET_MIPS16 ? "#" : "lui\t%0,%h1";
3584
3585       if (CONST_GP_P (src))
3586         return "move\t%0,%1";
3587
3588       if (mips_symbolic_constant_p (src, SYMBOL_CONTEXT_LEA, &symbol_type)
3589           && mips_lo_relocs[symbol_type] != 0)
3590         {
3591           /* A signed 16-bit constant formed by applying a relocation
3592              operator to a symbolic address.  */
3593           gcc_assert (!mips_split_p[symbol_type]);
3594           return "li\t%0,%R1";
3595         }
3596
3597       if (symbolic_operand (src, VOIDmode))
3598         {
3599           gcc_assert (TARGET_MIPS16
3600                       ? TARGET_MIPS16_TEXT_LOADS
3601                       : !TARGET_EXPLICIT_RELOCS);
3602           return dbl_p ? "dla\t%0,%1" : "la\t%0,%1";
3603         }
3604     }
3605   if (src_code == REG && FP_REG_P (REGNO (src)))
3606     {
3607       if (dest_code == REG && FP_REG_P (REGNO (dest)))
3608         {
3609           if (GET_MODE (dest) == V2SFmode)
3610             return "mov.ps\t%0,%1";
3611           else
3612             return dbl_p ? "mov.d\t%0,%1" : "mov.s\t%0,%1";
3613         }
3614
3615       if (dest_code == MEM)
3616         return dbl_p ? "sdc1\t%1,%0" : "swc1\t%1,%0";
3617     }
3618   if (dest_code == REG && FP_REG_P (REGNO (dest)))
3619     {
3620       if (src_code == MEM)
3621         return dbl_p ? "ldc1\t%0,%1" : "lwc1\t%0,%1";
3622     }
3623   if (dest_code == REG && ALL_COP_REG_P (REGNO (dest)) && src_code == MEM)
3624     {
3625       static char retval[] = "l_c_\t%0,%1";
3626
3627       retval[1] = (dbl_p ? 'd' : 'w');
3628       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
3629       return retval;
3630     }
3631   if (dest_code == MEM && src_code == REG && ALL_COP_REG_P (REGNO (src)))
3632     {
3633       static char retval[] = "s_c_\t%1,%0";
3634
3635       retval[1] = (dbl_p ? 'd' : 'w');
3636       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
3637       return retval;
3638     }
3639   gcc_unreachable ();
3640 }
3641 \f
3642 /* Return true if CMP1 is a suitable second operand for integer ordering
3643    test CODE.  See also the *sCC patterns in mips.md.  */
3644
3645 static bool
3646 mips_int_order_operand_ok_p (enum rtx_code code, rtx cmp1)
3647 {
3648   switch (code)
3649     {
3650     case GT:
3651     case GTU:
3652       return reg_or_0_operand (cmp1, VOIDmode);
3653
3654     case GE:
3655     case GEU:
3656       return !TARGET_MIPS16 && cmp1 == const1_rtx;
3657
3658     case LT:
3659     case LTU:
3660       return arith_operand (cmp1, VOIDmode);
3661
3662     case LE:
3663       return sle_operand (cmp1, VOIDmode);
3664
3665     case LEU:
3666       return sleu_operand (cmp1, VOIDmode);
3667
3668     default:
3669       gcc_unreachable ();
3670     }
3671 }
3672
3673 /* Return true if *CMP1 (of mode MODE) is a valid second operand for
3674    integer ordering test *CODE, or if an equivalent combination can
3675    be formed by adjusting *CODE and *CMP1.  When returning true, update
3676    *CODE and *CMP1 with the chosen code and operand, otherwise leave
3677    them alone.  */
3678
3679 static bool
3680 mips_canonicalize_int_order_test (enum rtx_code *code, rtx *cmp1,
3681                                   enum machine_mode mode)
3682 {
3683   HOST_WIDE_INT plus_one;
3684
3685   if (mips_int_order_operand_ok_p (*code, *cmp1))
3686     return true;
3687
3688   if (GET_CODE (*cmp1) == CONST_INT)
3689     switch (*code)
3690       {
3691       case LE:
3692         plus_one = trunc_int_for_mode (UINTVAL (*cmp1) + 1, mode);
3693         if (INTVAL (*cmp1) < plus_one)
3694           {
3695             *code = LT;
3696             *cmp1 = force_reg (mode, GEN_INT (plus_one));
3697             return true;
3698           }
3699         break;
3700
3701       case LEU:
3702         plus_one = trunc_int_for_mode (UINTVAL (*cmp1) + 1, mode);
3703         if (plus_one != 0)
3704           {
3705             *code = LTU;
3706             *cmp1 = force_reg (mode, GEN_INT (plus_one));
3707             return true;
3708           }
3709         break;
3710
3711       default:
3712         break;
3713       }
3714   return false;
3715 }
3716
3717 /* Compare CMP0 and CMP1 using ordering test CODE and store the result
3718    in TARGET.  CMP0 and TARGET are register_operands that have the same
3719    integer mode.  If INVERT_PTR is nonnull, it's OK to set TARGET to the
3720    inverse of the result and flip *INVERT_PTR instead.  */
3721
3722 static void
3723 mips_emit_int_order_test (enum rtx_code code, bool *invert_ptr,
3724                           rtx target, rtx cmp0, rtx cmp1)
3725 {
3726   enum machine_mode mode;
3727
3728   /* First see if there is a MIPS instruction that can do this operation.
3729      If not, try doing the same for the inverse operation.  If that also
3730      fails, force CMP1 into a register and try again.  */
3731   mode = GET_MODE (target);
3732   if (mips_canonicalize_int_order_test (&code, &cmp1, mode))
3733     mips_emit_binary (code, target, cmp0, cmp1);
3734   else
3735     {
3736       enum rtx_code inv_code = reverse_condition (code);
3737       if (!mips_canonicalize_int_order_test (&inv_code, &cmp1, mode))
3738         {
3739           cmp1 = force_reg (mode, cmp1);
3740           mips_emit_int_order_test (code, invert_ptr, target, cmp0, cmp1);
3741         }
3742       else if (invert_ptr == 0)
3743         {
3744           rtx inv_target = gen_reg_rtx (mode);
3745           mips_emit_binary (inv_code, inv_target, cmp0, cmp1);
3746           mips_emit_binary (XOR, target, inv_target, const1_rtx);
3747         }
3748       else
3749         {
3750           *invert_ptr = !*invert_ptr;
3751           mips_emit_binary (inv_code, target, cmp0, cmp1);
3752         }
3753     }
3754 }
3755
3756 /* Return a register that is zero iff CMP0 and CMP1 are equal.
3757    The register will have the same mode as CMP0.  */
3758
3759 static rtx
3760 mips_zero_if_equal (rtx cmp0, rtx cmp1)
3761 {
3762   if (cmp1 == const0_rtx)
3763     return cmp0;
3764
3765   if (uns_arith_operand (cmp1, VOIDmode))
3766     return expand_binop (GET_MODE (cmp0), xor_optab,
3767                          cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3768
3769   return expand_binop (GET_MODE (cmp0), sub_optab,
3770                        cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3771 }
3772
3773 /* Convert *CODE into a code that can be used in a floating-point
3774    scc instruction (C.cond.fmt).  Return true if the values of
3775    the condition code registers will be inverted, with 0 indicating
3776    that the condition holds.  */
3777
3778 static bool
3779 mips_reversed_fp_cond (enum rtx_code *code)
3780 {
3781   switch (*code)
3782     {
3783     case NE:
3784     case LTGT:
3785     case ORDERED:
3786       *code = reverse_condition_maybe_unordered (*code);
3787       return true;
3788
3789     default:
3790       return false;
3791     }
3792 }
3793
3794 /* Convert a comparison into something that can be used in a branch or
3795    conditional move.  cmp_operands[0] and cmp_operands[1] are the values
3796    being compared and *CODE is the code used to compare them.
3797
3798    Update *CODE, *OP0 and *OP1 so that they describe the final comparison.
3799    If NEED_EQ_NE_P, then only EQ or NE comparisons against zero are possible,
3800    otherwise any standard branch condition can be used.  The standard branch
3801    conditions are:
3802
3803       - EQ or NE between two registers.
3804       - any comparison between a register and zero.  */
3805
3806 static void
3807 mips_emit_compare (enum rtx_code *code, rtx *op0, rtx *op1, bool need_eq_ne_p)
3808 {
3809   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) == MODE_INT)
3810     {
3811       if (!need_eq_ne_p && cmp_operands[1] == const0_rtx)
3812         {
3813           *op0 = cmp_operands[0];
3814           *op1 = cmp_operands[1];
3815         }
3816       else if (*code == EQ || *code == NE)
3817         {
3818           if (need_eq_ne_p)
3819             {
3820               *op0 = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3821               *op1 = const0_rtx;
3822             }
3823           else
3824             {
3825               *op0 = cmp_operands[0];
3826               *op1 = force_reg (GET_MODE (*op0), cmp_operands[1]);
3827             }
3828         }
3829       else
3830         {
3831           /* The comparison needs a separate scc instruction.  Store the
3832              result of the scc in *OP0 and compare it against zero.  */
3833           bool invert = false;
3834           *op0 = gen_reg_rtx (GET_MODE (cmp_operands[0]));
3835           mips_emit_int_order_test (*code, &invert, *op0,
3836                                     cmp_operands[0], cmp_operands[1]);
3837           *code = (invert ? EQ : NE);
3838           *op1 = const0_rtx;
3839         }
3840     }
3841   else if (ALL_FIXED_POINT_MODE_P (GET_MODE (cmp_operands[0])))
3842     {
3843       *op0 = gen_rtx_REG (CCDSPmode, CCDSP_CC_REGNUM);
3844       mips_emit_binary (*code, *op0, cmp_operands[0], cmp_operands[1]);
3845       *code = NE;
3846       *op1 = const0_rtx;
3847     }
3848   else
3849     {
3850       enum rtx_code cmp_code;
3851
3852       /* Floating-point tests use a separate C.cond.fmt comparison to
3853          set a condition code register.  The branch or conditional move
3854          will then compare that register against zero.
3855
3856          Set CMP_CODE to the code of the comparison instruction and
3857          *CODE to the code that the branch or move should use.  */
3858       cmp_code = *code;
3859       *code = mips_reversed_fp_cond (&cmp_code) ? EQ : NE;
3860       *op0 = (ISA_HAS_8CC
3861               ? gen_reg_rtx (CCmode)
3862               : gen_rtx_REG (CCmode, FPSW_REGNUM));
3863       *op1 = const0_rtx;
3864       mips_emit_binary (cmp_code, *op0, cmp_operands[0], cmp_operands[1]);
3865     }
3866 }
3867 \f
3868 /* Try comparing cmp_operands[0] and cmp_operands[1] using rtl code CODE.
3869    Store the result in TARGET and return true if successful.
3870
3871    On 64-bit targets, TARGET may be wider than cmp_operands[0].  */
3872
3873 bool
3874 mips_expand_scc (enum rtx_code code, rtx target)
3875 {
3876   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) != MODE_INT)
3877     return false;
3878
3879   target = gen_lowpart (GET_MODE (cmp_operands[0]), target);
3880   if (code == EQ || code == NE)
3881     {
3882       rtx zie = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3883       mips_emit_binary (code, target, zie, const0_rtx);
3884     }
3885   else
3886     mips_emit_int_order_test (code, 0, target,
3887                               cmp_operands[0], cmp_operands[1]);
3888   return true;
3889 }
3890
3891 /* Compare cmp_operands[0] with cmp_operands[1] using comparison code
3892    CODE and jump to OPERANDS[0] if the condition holds.  */
3893
3894 void
3895 mips_expand_conditional_branch (rtx *operands, enum rtx_code code)
3896 {
3897   rtx op0, op1, condition;
3898
3899   mips_emit_compare (&code, &op0, &op1, TARGET_MIPS16);
3900   condition = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
3901   emit_jump_insn (gen_condjump (condition, operands[0]));
3902 }
3903
3904 /* Implement:
3905
3906    (set temp (COND:CCV2 CMP_OP0 CMP_OP1))
3907    (set DEST (unspec [TRUE_SRC FALSE_SRC temp] UNSPEC_MOVE_TF_PS))  */
3908
3909 void
3910 mips_expand_vcondv2sf (rtx dest, rtx true_src, rtx false_src,
3911                        enum rtx_code cond, rtx cmp_op0, rtx cmp_op1)
3912 {
3913   rtx cmp_result;
3914   bool reversed_p;
3915
3916   reversed_p = mips_reversed_fp_cond (&cond);
3917   cmp_result = gen_reg_rtx (CCV2mode);
3918   emit_insn (gen_scc_ps (cmp_result,
3919                          gen_rtx_fmt_ee (cond, VOIDmode, cmp_op0, cmp_op1)));
3920   if (reversed_p)
3921     emit_insn (gen_mips_cond_move_tf_ps (dest, false_src, true_src,
3922                                          cmp_result));
3923   else
3924     emit_insn (gen_mips_cond_move_tf_ps (dest, true_src, false_src,
3925                                          cmp_result));
3926 }
3927
3928 /* Compare cmp_operands[0] with cmp_operands[1] using the code of
3929    OPERANDS[1].  Move OPERANDS[2] into OPERANDS[0] if the condition
3930    holds, otherwise move OPERANDS[3] into OPERANDS[0].  */
3931
3932 void
3933 mips_expand_conditional_move (rtx *operands)
3934 {
3935   enum rtx_code code;
3936   rtx cond, op0, op1;
3937
3938   code = GET_CODE (operands[1]);
3939   mips_emit_compare (&code, &op0, &op1, true);
3940   cond = gen_rtx_fmt_ee (code, GET_MODE (op0), op0, op1),
3941   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3942                           gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]), cond,
3943                                                 operands[2], operands[3])));
3944 }
3945
3946 /* Compare cmp_operands[0] with cmp_operands[1] using rtl code CODE,
3947    then trap if the condition holds.  */
3948
3949 void
3950 mips_expand_conditional_trap (enum rtx_code code)
3951 {
3952   rtx op0, op1;
3953   enum machine_mode mode;
3954
3955   /* MIPS conditional trap instructions don't have GT or LE flavors,
3956      so we must swap the operands and convert to LT and GE respectively.  */
3957   switch (code)
3958     {
3959     case GT:
3960     case LE:
3961     case GTU:
3962     case LEU:
3963       code = swap_condition (code);
3964       op0 = cmp_operands[1];
3965       op1 = cmp_operands[0];
3966       break;
3967
3968     default:
3969       op0 = cmp_operands[0];
3970       op1 = cmp_operands[1];
3971       break;
3972     }
3973
3974   mode = GET_MODE (cmp_operands[0]);
3975   op0 = force_reg (mode, op0);
3976   if (!arith_operand (op1, mode))
3977     op1 = force_reg (mode, op1);
3978
3979   emit_insn (gen_rtx_TRAP_IF (VOIDmode,
3980                               gen_rtx_fmt_ee (code, mode, op0, op1),
3981                               const0_rtx));
3982 }
3983 \f
3984 /* Initialize *CUM for a call to a function of type FNTYPE.  */
3985
3986 void
3987 mips_init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype)
3988 {
3989   memset (cum, 0, sizeof (*cum));
3990   cum->prototype = (fntype && prototype_p (fntype));
3991   cum->gp_reg_found = (cum->prototype && stdarg_p (fntype));
3992 }
3993
3994 /* Fill INFO with information about a single argument.  CUM is the
3995    cumulative state for earlier arguments.  MODE is the mode of this
3996    argument and TYPE is its type (if known).  NAMED is true if this
3997    is a named (fixed) argument rather than a variable one.  */
3998
3999 static void
4000 mips_get_arg_info (struct mips_arg_info *info, const CUMULATIVE_ARGS *cum,
4001                    enum machine_mode mode, tree type, int named)
4002 {
4003   bool doubleword_aligned_p;
4004   unsigned int num_bytes, num_words, max_regs;
4005
4006   /* Work out the size of the argument.  */
4007   num_bytes = type ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
4008   num_words = (num_bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
4009
4010   /* Decide whether it should go in a floating-point register, assuming
4011      one is free.  Later code checks for availability.
4012
4013      The checks against UNITS_PER_FPVALUE handle the soft-float and
4014      single-float cases.  */
4015   switch (mips_abi)
4016     {
4017     case ABI_EABI:
4018       /* The EABI conventions have traditionally been defined in terms
4019          of TYPE_MODE, regardless of the actual type.  */
4020       info->fpr_p = ((GET_MODE_CLASS (mode) == MODE_FLOAT
4021                       || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
4022                      && GET_MODE_SIZE (mode) <= UNITS_PER_FPVALUE);
4023       break;
4024
4025     case ABI_32:
4026     case ABI_O64:
4027       /* Only leading floating-point scalars are passed in
4028          floating-point registers.  We also handle vector floats the same
4029          say, which is OK because they are not covered by the standard ABI.  */
4030       info->fpr_p = (!cum->gp_reg_found
4031                      && cum->arg_number < 2
4032                      && (type == 0
4033                          || SCALAR_FLOAT_TYPE_P (type)
4034                          || VECTOR_FLOAT_TYPE_P (type))
4035                      && (GET_MODE_CLASS (mode) == MODE_FLOAT
4036                          || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
4037                      && GET_MODE_SIZE (mode) <= UNITS_PER_FPVALUE);
4038       break;
4039