OSDN Git Service

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