OSDN Git Service

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