OSDN Git Service

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