OSDN Git Service

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