OSDN Git Service

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