OSDN Git Service

a12e82af707efa48073c2728ffb9f9c96425e32f
[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 Free Software Foundation, Inc.
4    Contributed by A. Lichnewsky, lich@inria.inria.fr.
5    Changes by Michael Meissner, meissner@osf.org.
6    64 bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
7    Brendan Eich, brendan@microunity.com.
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
14 any later version.
15
16 GCC is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING.  If not, write to
23 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
24 Boston, MA 02110-1301, USA.  */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include <signal.h>
31 #include "rtl.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "real.h"
35 #include "insn-config.h"
36 #include "conditions.h"
37 #include "insn-attr.h"
38 #include "recog.h"
39 #include "toplev.h"
40 #include "output.h"
41 #include "tree.h"
42 #include "function.h"
43 #include "expr.h"
44 #include "optabs.h"
45 #include "flags.h"
46 #include "reload.h"
47 #include "tm_p.h"
48 #include "ggc.h"
49 #include "gstab.h"
50 #include "hashtab.h"
51 #include "debug.h"
52 #include "target.h"
53 #include "target-def.h"
54 #include "integrate.h"
55 #include "langhooks.h"
56 #include "cfglayout.h"
57 #include "sched-int.h"
58 #include "tree-gimple.h"
59 #include "bitmap.h"
60
61 /* True if X is an unspec wrapper around a SYMBOL_REF or LABEL_REF.  */
62 #define UNSPEC_ADDRESS_P(X)                                     \
63   (GET_CODE (X) == UNSPEC                                       \
64    && XINT (X, 1) >= UNSPEC_ADDRESS_FIRST                       \
65    && XINT (X, 1) < UNSPEC_ADDRESS_FIRST + NUM_SYMBOL_TYPES)
66
67 /* Extract the symbol or label from UNSPEC wrapper X.  */
68 #define UNSPEC_ADDRESS(X) \
69   XVECEXP (X, 0, 0)
70
71 /* Extract the symbol type from UNSPEC wrapper X.  */
72 #define UNSPEC_ADDRESS_TYPE(X) \
73   ((enum mips_symbol_type) (XINT (X, 1) - UNSPEC_ADDRESS_FIRST))
74
75 /* The maximum distance between the top of the stack frame and the
76    value $sp has when we save & restore registers.
77
78    Use a maximum gap of 0x100 in the mips16 case.  We can then use
79    unextended instructions to save and restore registers, and to
80    allocate and deallocate the top part of the frame.
81
82    The value in the !mips16 case must be a SMALL_OPERAND and must
83    preserve the maximum stack alignment.  */
84 #define MIPS_MAX_FIRST_STACK_STEP (TARGET_MIPS16 ? 0x100 : 0x7ff0)
85
86 /* True if INSN is a mips.md pattern or asm statement.  */
87 #define USEFUL_INSN_P(INSN)                                             \
88   (INSN_P (INSN)                                                        \
89    && GET_CODE (PATTERN (INSN)) != USE                                  \
90    && GET_CODE (PATTERN (INSN)) != CLOBBER                              \
91    && GET_CODE (PATTERN (INSN)) != ADDR_VEC                             \
92    && GET_CODE (PATTERN (INSN)) != ADDR_DIFF_VEC)
93
94 /* If INSN is a delayed branch sequence, return the first instruction
95    in the sequence, otherwise return INSN itself.  */
96 #define SEQ_BEGIN(INSN)                                                 \
97   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
98    ? XVECEXP (PATTERN (INSN), 0, 0)                                     \
99    : (INSN))
100
101 /* Likewise for the last instruction in a delayed branch sequence.  */
102 #define SEQ_END(INSN)                                                   \
103   (INSN_P (INSN) && GET_CODE (PATTERN (INSN)) == SEQUENCE               \
104    ? XVECEXP (PATTERN (INSN), 0, XVECLEN (PATTERN (INSN), 0) - 1)       \
105    : (INSN))
106
107 /* Execute the following loop body with SUBINSN set to each instruction
108    between SEQ_BEGIN (INSN) and SEQ_END (INSN) inclusive.  */
109 #define FOR_EACH_SUBINSN(SUBINSN, INSN)                                 \
110   for ((SUBINSN) = SEQ_BEGIN (INSN);                                    \
111        (SUBINSN) != NEXT_INSN (SEQ_END (INSN));                         \
112        (SUBINSN) = NEXT_INSN (SUBINSN))
113
114 /* Classifies an address.
115
116    ADDRESS_REG
117        A natural register + offset address.  The register satisfies
118        mips_valid_base_register_p and the offset is a const_arith_operand.
119
120    ADDRESS_LO_SUM
121        A LO_SUM rtx.  The first operand is a valid base register and
122        the second operand is a symbolic address.
123
124    ADDRESS_CONST_INT
125        A signed 16-bit constant address.
126
127    ADDRESS_SYMBOLIC:
128        A constant symbolic address (equivalent to CONSTANT_SYMBOLIC).  */
129 enum mips_address_type {
130   ADDRESS_REG,
131   ADDRESS_LO_SUM,
132   ADDRESS_CONST_INT,
133   ADDRESS_SYMBOLIC
134 };
135
136 /* Classifies the prototype of a builtin function.  */
137 enum mips_function_type
138 {
139   MIPS_V2SF_FTYPE_V2SF,
140   MIPS_V2SF_FTYPE_V2SF_V2SF,
141   MIPS_V2SF_FTYPE_V2SF_V2SF_INT,
142   MIPS_V2SF_FTYPE_V2SF_V2SF_V2SF_V2SF,
143   MIPS_V2SF_FTYPE_SF_SF,
144   MIPS_INT_FTYPE_V2SF_V2SF,
145   MIPS_INT_FTYPE_V2SF_V2SF_V2SF_V2SF,
146   MIPS_INT_FTYPE_SF_SF,
147   MIPS_INT_FTYPE_DF_DF,
148   MIPS_SF_FTYPE_V2SF,
149   MIPS_SF_FTYPE_SF,
150   MIPS_SF_FTYPE_SF_SF,
151   MIPS_DF_FTYPE_DF,
152   MIPS_DF_FTYPE_DF_DF,
153
154   /* For MIPS DSP ASE  */
155   MIPS_DI_FTYPE_DI_SI,
156   MIPS_DI_FTYPE_DI_SI_SI,
157   MIPS_DI_FTYPE_DI_V2HI_V2HI,
158   MIPS_DI_FTYPE_DI_V4QI_V4QI,
159   MIPS_SI_FTYPE_DI_SI,
160   MIPS_SI_FTYPE_PTR_SI,
161   MIPS_SI_FTYPE_SI,
162   MIPS_SI_FTYPE_SI_SI,
163   MIPS_SI_FTYPE_V2HI,
164   MIPS_SI_FTYPE_V2HI_V2HI,
165   MIPS_SI_FTYPE_V4QI,
166   MIPS_SI_FTYPE_V4QI_V4QI,
167   MIPS_SI_FTYPE_VOID,
168   MIPS_V2HI_FTYPE_SI,
169   MIPS_V2HI_FTYPE_SI_SI,
170   MIPS_V2HI_FTYPE_V2HI,
171   MIPS_V2HI_FTYPE_V2HI_SI,
172   MIPS_V2HI_FTYPE_V2HI_V2HI,
173   MIPS_V2HI_FTYPE_V4QI,
174   MIPS_V2HI_FTYPE_V4QI_V2HI,
175   MIPS_V4QI_FTYPE_SI,
176   MIPS_V4QI_FTYPE_V2HI_V2HI,
177   MIPS_V4QI_FTYPE_V4QI_SI,
178   MIPS_V4QI_FTYPE_V4QI_V4QI,
179   MIPS_VOID_FTYPE_SI_SI,
180   MIPS_VOID_FTYPE_V2HI_V2HI,
181   MIPS_VOID_FTYPE_V4QI_V4QI,
182
183   /* The last type.  */
184   MIPS_MAX_FTYPE_MAX
185 };
186
187 /* Specifies how a builtin function should be converted into rtl.  */
188 enum mips_builtin_type
189 {
190   /* The builtin corresponds directly to an .md pattern.  The return
191      value is mapped to operand 0 and the arguments are mapped to
192      operands 1 and above.  */
193   MIPS_BUILTIN_DIRECT,
194
195   /* The builtin corresponds directly to an .md pattern.  There is no return
196      value and the arguments are mapped to operands 0 and above.  */
197   MIPS_BUILTIN_DIRECT_NO_TARGET,
198
199   /* The builtin corresponds to a comparison instruction followed by
200      a mips_cond_move_tf_ps pattern.  The first two arguments are the
201      values to compare and the second two arguments are the vector
202      operands for the movt.ps or movf.ps instruction (in assembly order).  */
203   MIPS_BUILTIN_MOVF,
204   MIPS_BUILTIN_MOVT,
205
206   /* The builtin corresponds to a V2SF comparison instruction.  Operand 0
207      of this instruction is the result of the comparison, which has mode
208      CCV2 or CCV4.  The function arguments are mapped to operands 1 and
209      above.  The function's return value is an SImode boolean that is
210      true under the following conditions:
211
212      MIPS_BUILTIN_CMP_ANY: one of the registers is true
213      MIPS_BUILTIN_CMP_ALL: all of the registers are true
214      MIPS_BUILTIN_CMP_LOWER: the first register is true
215      MIPS_BUILTIN_CMP_UPPER: the second register is true.  */
216   MIPS_BUILTIN_CMP_ANY,
217   MIPS_BUILTIN_CMP_ALL,
218   MIPS_BUILTIN_CMP_UPPER,
219   MIPS_BUILTIN_CMP_LOWER,
220
221   /* As above, but the instruction only sets a single $fcc register.  */
222   MIPS_BUILTIN_CMP_SINGLE,
223
224   /* For generating bposge32 branch instructions in MIPS32 DSP ASE.  */
225   MIPS_BUILTIN_BPOSGE32
226 };
227
228 /* Invokes MACRO (COND) for each c.cond.fmt condition.  */
229 #define MIPS_FP_CONDITIONS(MACRO) \
230   MACRO (f),    \
231   MACRO (un),   \
232   MACRO (eq),   \
233   MACRO (ueq),  \
234   MACRO (olt),  \
235   MACRO (ult),  \
236   MACRO (ole),  \
237   MACRO (ule),  \
238   MACRO (sf),   \
239   MACRO (ngle), \
240   MACRO (seq),  \
241   MACRO (ngl),  \
242   MACRO (lt),   \
243   MACRO (nge),  \
244   MACRO (le),   \
245   MACRO (ngt)
246
247 /* Enumerates the codes above as MIPS_FP_COND_<X>.  */
248 #define DECLARE_MIPS_COND(X) MIPS_FP_COND_ ## X
249 enum mips_fp_condition {
250   MIPS_FP_CONDITIONS (DECLARE_MIPS_COND)
251 };
252
253 /* Index X provides the string representation of MIPS_FP_COND_<X>.  */
254 #define STRINGIFY(X) #X
255 static const char *const mips_fp_conditions[] = {
256   MIPS_FP_CONDITIONS (STRINGIFY)
257 };
258
259 /* A function to save or store a register.  The first argument is the
260    register and the second is the stack slot.  */
261 typedef void (*mips_save_restore_fn) (rtx, rtx);
262
263 struct mips16_constant;
264 struct mips_arg_info;
265 struct mips_address_info;
266 struct mips_integer_op;
267 struct mips_sim;
268
269 static enum mips_symbol_type mips_classify_symbol (rtx);
270 static void mips_split_const (rtx, rtx *, HOST_WIDE_INT *);
271 static bool mips_offset_within_object_p (rtx, HOST_WIDE_INT);
272 static bool mips_valid_base_register_p (rtx, enum machine_mode, int);
273 static bool mips_symbolic_address_p (enum mips_symbol_type, enum machine_mode);
274 static bool mips_classify_address (struct mips_address_info *, rtx,
275                                    enum machine_mode, int);
276 static bool mips_cannot_force_const_mem (rtx);
277 static bool mips_use_blocks_for_constant_p (enum machine_mode, rtx);
278 static int mips_symbol_insns (enum mips_symbol_type);
279 static bool mips16_unextended_reference_p (enum machine_mode mode, rtx, rtx);
280 static rtx mips_force_temporary (rtx, rtx);
281 static rtx mips_unspec_offset_high (rtx, rtx, rtx, enum mips_symbol_type);
282 static rtx mips_add_offset (rtx, rtx, HOST_WIDE_INT);
283 static unsigned int mips_build_shift (struct mips_integer_op *, HOST_WIDE_INT);
284 static unsigned int mips_build_lower (struct mips_integer_op *,
285                                       unsigned HOST_WIDE_INT);
286 static unsigned int mips_build_integer (struct mips_integer_op *,
287                                         unsigned HOST_WIDE_INT);
288 static void mips_legitimize_const_move (enum machine_mode, rtx, rtx);
289 static int m16_check_op (rtx, int, int, int);
290 static bool mips_rtx_costs (rtx, int, int, int *);
291 static int mips_address_cost (rtx);
292 static void mips_emit_compare (enum rtx_code *, rtx *, rtx *, bool);
293 static void mips_load_call_address (rtx, rtx, int);
294 static bool mips_function_ok_for_sibcall (tree, tree);
295 static void mips_block_move_straight (rtx, rtx, HOST_WIDE_INT);
296 static void mips_adjust_block_mem (rtx, HOST_WIDE_INT, rtx *, rtx *);
297 static void mips_block_move_loop (rtx, rtx, HOST_WIDE_INT);
298 static void mips_arg_info (const CUMULATIVE_ARGS *, enum machine_mode,
299                            tree, int, struct mips_arg_info *);
300 static bool mips_get_unaligned_mem (rtx *, unsigned int, int, rtx *, rtx *);
301 static void mips_set_architecture (const struct mips_cpu_info *);
302 static void mips_set_tune (const struct mips_cpu_info *);
303 static bool mips_handle_option (size_t, const char *, int);
304 static struct machine_function *mips_init_machine_status (void);
305 static void print_operand_reloc (FILE *, rtx, const char **);
306 #if TARGET_IRIX
307 static void irix_output_external_libcall (rtx);
308 #endif
309 static void mips_file_start (void);
310 static void mips_file_end (void);
311 static bool mips_rewrite_small_data_p (rtx);
312 static int mips_small_data_pattern_1 (rtx *, void *);
313 static int mips_rewrite_small_data_1 (rtx *, void *);
314 static bool mips_function_has_gp_insn (void);
315 static unsigned int mips_global_pointer (void);
316 static bool mips_save_reg_p (unsigned int);
317 static void mips_save_restore_reg (enum machine_mode, int, HOST_WIDE_INT,
318                                    mips_save_restore_fn);
319 static void mips_for_each_saved_reg (HOST_WIDE_INT, mips_save_restore_fn);
320 static void mips_output_cplocal (void);
321 static void mips_emit_loadgp (void);
322 static void mips_output_function_prologue (FILE *, HOST_WIDE_INT);
323 static void mips_set_frame_expr (rtx);
324 static rtx mips_frame_set (rtx, rtx);
325 static void mips_save_reg (rtx, rtx);
326 static void mips_output_function_epilogue (FILE *, HOST_WIDE_INT);
327 static void mips_restore_reg (rtx, rtx);
328 static void mips_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
329                                   HOST_WIDE_INT, tree);
330 static int symbolic_expression_p (rtx);
331 static section *mips_select_rtx_section (enum machine_mode, rtx,
332                                          unsigned HOST_WIDE_INT);
333 static section *mips_function_rodata_section (tree);
334 static bool mips_in_small_data_p (tree);
335 static bool mips_use_anchors_for_symbol_p (rtx);
336 static int mips_fpr_return_fields (tree, tree *);
337 static bool mips_return_in_msb (tree);
338 static rtx mips_return_fpr_pair (enum machine_mode mode,
339                                  enum machine_mode mode1, HOST_WIDE_INT,
340                                  enum machine_mode mode2, HOST_WIDE_INT);
341 static rtx mips16_gp_pseudo_reg (void);
342 static void mips16_fp_args (FILE *, int, int);
343 static void build_mips16_function_stub (FILE *);
344 static rtx dump_constants_1 (enum machine_mode, rtx, rtx);
345 static void dump_constants (struct mips16_constant *, rtx);
346 static int mips16_insn_length (rtx);
347 static int mips16_rewrite_pool_refs (rtx *, void *);
348 static void mips16_lay_out_constants (void);
349 static void mips_sim_reset (struct mips_sim *);
350 static void mips_sim_init (struct mips_sim *, state_t);
351 static void mips_sim_next_cycle (struct mips_sim *);
352 static void mips_sim_wait_reg (struct mips_sim *, rtx, rtx);
353 static int mips_sim_wait_regs_2 (rtx *, void *);
354 static void mips_sim_wait_regs_1 (rtx *, void *);
355 static void mips_sim_wait_regs (struct mips_sim *, rtx);
356 static void mips_sim_wait_units (struct mips_sim *, rtx);
357 static void mips_sim_wait_insn (struct mips_sim *, rtx);
358 static void mips_sim_record_set (rtx, rtx, void *);
359 static void mips_sim_issue_insn (struct mips_sim *, rtx);
360 static void mips_sim_issue_nop (struct mips_sim *);
361 static void mips_sim_finish_insn (struct mips_sim *, rtx);
362 static void vr4130_avoid_branch_rt_conflict (rtx);
363 static void vr4130_align_insns (void);
364 static void mips_avoid_hazard (rtx, rtx, int *, rtx *, rtx);
365 static void mips_avoid_hazards (void);
366 static void mips_reorg (void);
367 static bool mips_strict_matching_cpu_name_p (const char *, const char *);
368 static bool mips_matching_cpu_name_p (const char *, const char *);
369 static const struct mips_cpu_info *mips_parse_cpu (const char *);
370 static const struct mips_cpu_info *mips_cpu_info_from_isa (int);
371 static bool mips_return_in_memory (tree, tree);
372 static bool mips_strict_argument_naming (CUMULATIVE_ARGS *);
373 static void mips_macc_chains_record (rtx);
374 static void mips_macc_chains_reorder (rtx *, int);
375 static void vr4130_true_reg_dependence_p_1 (rtx, rtx, void *);
376 static bool vr4130_true_reg_dependence_p (rtx);
377 static bool vr4130_swap_insns_p (rtx, rtx);
378 static void vr4130_reorder (rtx *, int);
379 static void mips_promote_ready (rtx *, int, int);
380 static int mips_sched_reorder (FILE *, int, rtx *, int *, int);
381 static int mips_variable_issue (FILE *, int, rtx, int);
382 static int mips_adjust_cost (rtx, rtx, rtx, int);
383 static int mips_issue_rate (void);
384 static int mips_multipass_dfa_lookahead (void);
385 static void mips_init_libfuncs (void);
386 static void mips_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
387                                          tree, int *, int);
388 static tree mips_build_builtin_va_list (void);
389 static tree mips_gimplify_va_arg_expr (tree, tree, tree *, tree *);
390 static bool mips_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode mode,
391                                     tree, bool);
392 static bool mips_callee_copies (CUMULATIVE_ARGS *, enum machine_mode mode,
393                                 tree, bool);
394 static int mips_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode mode,
395                                    tree, bool);
396 static bool mips_valid_pointer_mode (enum machine_mode);
397 static bool mips_vector_mode_supported_p (enum machine_mode);
398 static rtx mips_prepare_builtin_arg (enum insn_code, unsigned int, tree *);
399 static rtx mips_prepare_builtin_target (enum insn_code, unsigned int, rtx);
400 static rtx mips_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
401 static void mips_init_builtins (void);
402 static rtx mips_expand_builtin_direct (enum insn_code, rtx, tree, bool);
403 static rtx mips_expand_builtin_movtf (enum mips_builtin_type,
404                                       enum insn_code, enum mips_fp_condition,
405                                       rtx, tree);
406 static rtx mips_expand_builtin_compare (enum mips_builtin_type,
407                                         enum insn_code, enum mips_fp_condition,
408                                         rtx, tree);
409 static rtx mips_expand_builtin_bposge (enum mips_builtin_type, rtx);
410 static void mips_encode_section_info (tree, rtx, int);
411 static void mips_extra_live_on_entry (bitmap);
412 static int mips_mode_rep_extended (enum machine_mode, enum machine_mode);
413
414 /* Structure to be filled in by compute_frame_size with register
415    save masks, and offsets for the current function.  */
416
417 struct mips_frame_info GTY(())
418 {
419   HOST_WIDE_INT total_size;     /* # bytes that the entire frame takes up */
420   HOST_WIDE_INT var_size;       /* # bytes that variables take up */
421   HOST_WIDE_INT args_size;      /* # bytes that outgoing arguments take up */
422   HOST_WIDE_INT cprestore_size; /* # bytes that the .cprestore slot takes up */
423   HOST_WIDE_INT gp_reg_size;    /* # bytes needed to store gp regs */
424   HOST_WIDE_INT fp_reg_size;    /* # bytes needed to store fp regs */
425   unsigned int mask;            /* mask of saved gp registers */
426   unsigned int fmask;           /* mask of saved fp registers */
427   HOST_WIDE_INT gp_save_offset; /* offset from vfp to store gp registers */
428   HOST_WIDE_INT fp_save_offset; /* offset from vfp to store fp registers */
429   HOST_WIDE_INT gp_sp_offset;   /* offset from new sp to store gp registers */
430   HOST_WIDE_INT fp_sp_offset;   /* offset from new sp to store fp registers */
431   bool initialized;             /* true if frame size already calculated */
432   int num_gp;                   /* number of gp registers saved */
433   int num_fp;                   /* number of fp registers saved */
434 };
435
436 struct machine_function GTY(()) {
437   /* Pseudo-reg holding the value of $28 in a mips16 function which
438      refers to GP relative global variables.  */
439   rtx mips16_gp_pseudo_rtx;
440
441   /* The number of extra stack bytes taken up by register varargs.
442      This area is allocated by the callee at the very top of the frame.  */
443   int varargs_size;
444
445   /* Current frame information, calculated by compute_frame_size.  */
446   struct mips_frame_info frame;
447
448   /* The register to use as the global pointer within this function.  */
449   unsigned int global_pointer;
450
451   /* True if mips_adjust_insn_length should ignore an instruction's
452      hazard attribute.  */
453   bool ignore_hazard_length_p;
454
455   /* True if the whole function is suitable for .set noreorder and
456      .set nomacro.  */
457   bool all_noreorder_p;
458
459   /* True if the function is known to have an instruction that needs $gp.  */
460   bool has_gp_insn_p;
461 };
462
463 /* Information about a single argument.  */
464 struct mips_arg_info
465 {
466   /* True if the argument is passed in a floating-point register, or
467      would have been if we hadn't run out of registers.  */
468   bool fpr_p;
469
470   /* The number of words passed in registers, rounded up.  */
471   unsigned int reg_words;
472
473   /* For EABI, the offset of the first register from GP_ARG_FIRST or
474      FP_ARG_FIRST.  For other ABIs, the offset of the first register from
475      the start of the ABI's argument structure (see the CUMULATIVE_ARGS
476      comment for details).
477
478      The value is MAX_ARGS_IN_REGISTERS if the argument is passed entirely
479      on the stack.  */
480   unsigned int reg_offset;
481
482   /* The number of words that must be passed on the stack, rounded up.  */
483   unsigned int stack_words;
484
485   /* The offset from the start of the stack overflow area of the argument's
486      first stack word.  Only meaningful when STACK_WORDS is nonzero.  */
487   unsigned int stack_offset;
488 };
489
490
491 /* Information about an address described by mips_address_type.
492
493    ADDRESS_CONST_INT
494        No fields are used.
495
496    ADDRESS_REG
497        REG is the base register and OFFSET is the constant offset.
498
499    ADDRESS_LO_SUM
500        REG is the register that contains the high part of the address,
501        OFFSET is the symbolic address being referenced and SYMBOL_TYPE
502        is the type of OFFSET's symbol.
503
504    ADDRESS_SYMBOLIC
505        SYMBOL_TYPE is the type of symbol being referenced.  */
506
507 struct mips_address_info
508 {
509   enum mips_address_type type;
510   rtx reg;
511   rtx offset;
512   enum mips_symbol_type symbol_type;
513 };
514
515
516 /* One stage in a constant building sequence.  These sequences have
517    the form:
518
519         A = VALUE[0]
520         A = A CODE[1] VALUE[1]
521         A = A CODE[2] VALUE[2]
522         ...
523
524    where A is an accumulator, each CODE[i] is a binary rtl operation
525    and each VALUE[i] is a constant integer.  */
526 struct mips_integer_op {
527   enum rtx_code code;
528   unsigned HOST_WIDE_INT value;
529 };
530
531
532 /* The largest number of operations needed to load an integer constant.
533    The worst accepted case for 64-bit constants is LUI,ORI,SLL,ORI,SLL,ORI.
534    When the lowest bit is clear, we can try, but reject a sequence with
535    an extra SLL at the end.  */
536 #define MIPS_MAX_INTEGER_OPS 7
537
538
539 /* Global variables for machine-dependent things.  */
540
541 /* Threshold for data being put into the small data/bss area, instead
542    of the normal data area.  */
543 int mips_section_threshold = -1;
544
545 /* Count the number of .file directives, so that .loc is up to date.  */
546 int num_source_filenames = 0;
547
548 /* Count the number of sdb related labels are generated (to find block
549    start and end boundaries).  */
550 int sdb_label_count = 0;
551
552 /* Next label # for each statement for Silicon Graphics IRIS systems.  */
553 int sym_lineno = 0;
554
555 /* Linked list of all externals that are to be emitted when optimizing
556    for the global pointer if they haven't been declared by the end of
557    the program with an appropriate .comm or initialization.  */
558
559 struct extern_list GTY (())
560 {
561   struct extern_list *next;     /* next external */
562   const char *name;             /* name of the external */
563   int size;                     /* size in bytes */
564 };
565
566 static GTY (()) struct extern_list *extern_head = 0;
567
568 /* Name of the file containing the current function.  */
569 const char *current_function_file = "";
570
571 /* Number of nested .set noreorder, noat, nomacro, and volatile requests.  */
572 int set_noreorder;
573 int set_noat;
574 int set_nomacro;
575 int set_volatile;
576
577 /* The next branch instruction is a branch likely, not branch normal.  */
578 int mips_branch_likely;
579
580 /* The operands passed to the last cmpMM expander.  */
581 rtx cmp_operands[2];
582
583 /* The target cpu for code generation.  */
584 enum processor_type mips_arch;
585 const struct mips_cpu_info *mips_arch_info;
586
587 /* The target cpu for optimization and scheduling.  */
588 enum processor_type mips_tune;
589 const struct mips_cpu_info *mips_tune_info;
590
591 /* Which instruction set architecture to use.  */
592 int mips_isa;
593
594 /* Which ABI to use.  */
595 int mips_abi = MIPS_ABI_DEFAULT;
596
597 /* Cost information to use.  */
598 const struct mips_rtx_cost_data *mips_cost;
599
600 /* Whether we are generating mips16 hard float code.  In mips16 mode
601    we always set TARGET_SOFT_FLOAT; this variable is nonzero if
602    -msoft-float was not specified by the user, which means that we
603    should arrange to call mips32 hard floating point code.  */
604 int mips16_hard_float;
605
606 /* The architecture selected by -mipsN.  */
607 static const struct mips_cpu_info *mips_isa_info;
608
609 /* If TRUE, we split addresses into their high and low parts in the RTL.  */
610 int mips_split_addresses;
611
612 /* Mode used for saving/restoring general purpose registers.  */
613 static enum machine_mode gpr_mode;
614
615 /* Array giving truth value on whether or not a given hard register
616    can support a given mode.  */
617 char mips_hard_regno_mode_ok[(int)MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
618
619 /* List of all MIPS punctuation characters used by print_operand.  */
620 char mips_print_operand_punct[256];
621
622 /* Map GCC register number to debugger register number.  */
623 int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
624
625 /* A copy of the original flag_delayed_branch: see override_options.  */
626 static int mips_flag_delayed_branch;
627
628 static GTY (()) int mips_output_filename_first_time = 1;
629
630 /* mips_split_p[X] is true if symbols of type X can be split by
631    mips_split_symbol().  */
632 bool mips_split_p[NUM_SYMBOL_TYPES];
633
634 /* mips_lo_relocs[X] is the relocation to use when a symbol of type X
635    appears in a LO_SUM.  It can be null if such LO_SUMs aren't valid or
636    if they are matched by a special .md file pattern.  */
637 static const char *mips_lo_relocs[NUM_SYMBOL_TYPES];
638
639 /* Likewise for HIGHs.  */
640 static const char *mips_hi_relocs[NUM_SYMBOL_TYPES];
641
642 /* Map hard register number to register class */
643 const enum reg_class mips_regno_to_class[] =
644 {
645   LEA_REGS,     LEA_REGS,       M16_NA_REGS,    V1_REG,
646   M16_REGS,     M16_REGS,       M16_REGS,       M16_REGS,
647   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
648   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
649   M16_NA_REGS,  M16_NA_REGS,    LEA_REGS,       LEA_REGS,
650   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
651   T_REG,        PIC_FN_ADDR_REG, LEA_REGS,      LEA_REGS,
652   LEA_REGS,     LEA_REGS,       LEA_REGS,       LEA_REGS,
653   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
654   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
655   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
656   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
657   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
658   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
659   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
660   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
661   HI_REG,       LO_REG,         NO_REGS,        ST_REGS,
662   ST_REGS,      ST_REGS,        ST_REGS,        ST_REGS,
663   ST_REGS,      ST_REGS,        ST_REGS,        NO_REGS,
664   NO_REGS,      ALL_REGS,       ALL_REGS,       NO_REGS,
665   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
666   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
667   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
668   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
669   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
670   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
671   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
672   COP0_REGS,    COP0_REGS,      COP0_REGS,      COP0_REGS,
673   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
674   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
675   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
676   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
677   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
678   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
679   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
680   COP2_REGS,    COP2_REGS,      COP2_REGS,      COP2_REGS,
681   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
682   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
683   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
684   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
685   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
686   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
687   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
688   COP3_REGS,    COP3_REGS,      COP3_REGS,      COP3_REGS,
689   DSP_ACC_REGS, DSP_ACC_REGS,   DSP_ACC_REGS,   DSP_ACC_REGS,
690   DSP_ACC_REGS, DSP_ACC_REGS,   ALL_REGS,       ALL_REGS,
691   ALL_REGS,     ALL_REGS,       ALL_REGS,       ALL_REGS
692 };
693
694 /* Table of machine dependent attributes.  */
695 const struct attribute_spec mips_attribute_table[] =
696 {
697   { "long_call",   0, 0, false, true,  true,  NULL },
698   { NULL,          0, 0, false, false, false, NULL }
699 };
700 \f
701 /* A table describing all the processors gcc knows about.  Names are
702    matched in the order listed.  The first mention of an ISA level is
703    taken as the canonical name for that ISA.
704
705    To ease comparison, please keep this table in the same order as
706    gas's mips_cpu_info_table[].  */
707 const struct mips_cpu_info mips_cpu_info_table[] = {
708   /* Entries for generic ISAs */
709   { "mips1", PROCESSOR_R3000, 1 },
710   { "mips2", PROCESSOR_R6000, 2 },
711   { "mips3", PROCESSOR_R4000, 3 },
712   { "mips4", PROCESSOR_R8000, 4 },
713   { "mips32", PROCESSOR_4KC, 32 },
714   { "mips32r2", PROCESSOR_M4K, 33 },
715   { "mips64", PROCESSOR_5KC, 64 },
716
717   /* MIPS I */
718   { "r3000", PROCESSOR_R3000, 1 },
719   { "r2000", PROCESSOR_R3000, 1 }, /* = r3000 */
720   { "r3900", PROCESSOR_R3900, 1 },
721
722   /* MIPS II */
723   { "r6000", PROCESSOR_R6000, 2 },
724
725   /* MIPS III */
726   { "r4000", PROCESSOR_R4000, 3 },
727   { "vr4100", PROCESSOR_R4100, 3 },
728   { "vr4111", PROCESSOR_R4111, 3 },
729   { "vr4120", PROCESSOR_R4120, 3 },
730   { "vr4130", PROCESSOR_R4130, 3 },
731   { "vr4300", PROCESSOR_R4300, 3 },
732   { "r4400", PROCESSOR_R4000, 3 }, /* = r4000 */
733   { "r4600", PROCESSOR_R4600, 3 },
734   { "orion", PROCESSOR_R4600, 3 }, /* = r4600 */
735   { "r4650", PROCESSOR_R4650, 3 },
736
737   /* MIPS IV */
738   { "r8000", PROCESSOR_R8000, 4 },
739   { "vr5000", PROCESSOR_R5000, 4 },
740   { "vr5400", PROCESSOR_R5400, 4 },
741   { "vr5500", PROCESSOR_R5500, 4 },
742   { "rm7000", PROCESSOR_R7000, 4 },
743   { "rm9000", PROCESSOR_R9000, 4 },
744
745   /* MIPS32 */
746   { "4kc", PROCESSOR_4KC, 32 },
747   { "4km", PROCESSOR_4KC, 32 }, /* = 4kc */
748   { "4kp", PROCESSOR_4KP, 32 },
749
750   /* MIPS32 Release 2 */
751   { "m4k", PROCESSOR_M4K, 33 },
752   { "24k", PROCESSOR_24K, 33 },
753   { "24kc", PROCESSOR_24K, 33 },  /* 24K  no FPU */
754   { "24kf", PROCESSOR_24K, 33 },  /* 24K 1:2 FPU */
755   { "24kx", PROCESSOR_24KX, 33 }, /* 24K 1:1 FPU */
756
757   /* MIPS64 */
758   { "5kc", PROCESSOR_5KC, 64 },
759   { "5kf", PROCESSOR_5KF, 64 },
760   { "20kc", PROCESSOR_20KC, 64 },
761   { "sb1", PROCESSOR_SB1, 64 },
762   { "sr71000", PROCESSOR_SR71000, 64 },
763
764   /* End marker */
765   { 0, 0, 0 }
766 };
767
768 /* Default costs. If these are used for a processor we should look
769    up the actual costs.  */
770 #define DEFAULT_COSTS COSTS_N_INSNS (6),  /* fp_add */       \
771                       COSTS_N_INSNS (7),  /* fp_mult_sf */   \
772                       COSTS_N_INSNS (8),  /* fp_mult_df */   \
773                       COSTS_N_INSNS (23), /* fp_div_sf */    \
774                       COSTS_N_INSNS (36), /* fp_div_df */    \
775                       COSTS_N_INSNS (10), /* int_mult_si */  \
776                       COSTS_N_INSNS (10), /* int_mult_di */  \
777                       COSTS_N_INSNS (69), /* int_div_si */   \
778                       COSTS_N_INSNS (69), /* int_div_di */   \
779                                        2, /* branch_cost */  \
780                                        4  /* memory_latency */
781
782 /* Need to replace these with the costs of calling the appropriate
783    libgcc routine.  */
784 #define SOFT_FP_COSTS COSTS_N_INSNS (256), /* fp_add */       \
785                       COSTS_N_INSNS (256), /* fp_mult_sf */   \
786                       COSTS_N_INSNS (256), /* fp_mult_df */   \
787                       COSTS_N_INSNS (256), /* fp_div_sf */    \
788                       COSTS_N_INSNS (256)  /* fp_div_df */
789
790 static struct mips_rtx_cost_data const mips_rtx_cost_data[PROCESSOR_MAX] =
791   {
792     { /* R3000 */
793       COSTS_N_INSNS (2),            /* fp_add */
794       COSTS_N_INSNS (4),            /* fp_mult_sf */
795       COSTS_N_INSNS (5),            /* fp_mult_df */
796       COSTS_N_INSNS (12),           /* fp_div_sf */
797       COSTS_N_INSNS (19),           /* fp_div_df */
798       COSTS_N_INSNS (12),           /* int_mult_si */
799       COSTS_N_INSNS (12),           /* int_mult_di */
800       COSTS_N_INSNS (35),           /* int_div_si */
801       COSTS_N_INSNS (35),           /* int_div_di */
802                        1,           /* branch_cost */
803                        4            /* memory_latency */
804
805     },
806     { /* 4KC */
807       SOFT_FP_COSTS,
808       COSTS_N_INSNS (6),            /* int_mult_si */
809       COSTS_N_INSNS (6),            /* int_mult_di */
810       COSTS_N_INSNS (36),           /* int_div_si */
811       COSTS_N_INSNS (36),           /* int_div_di */
812                        1,           /* branch_cost */
813                        4            /* memory_latency */
814     },
815     { /* 4KP */
816       SOFT_FP_COSTS,
817       COSTS_N_INSNS (36),           /* int_mult_si */
818       COSTS_N_INSNS (36),           /* int_mult_di */
819       COSTS_N_INSNS (37),           /* int_div_si */
820       COSTS_N_INSNS (37),           /* int_div_di */
821                        1,           /* branch_cost */
822                        4            /* memory_latency */
823     },
824     { /* 5KC */
825       SOFT_FP_COSTS,
826       COSTS_N_INSNS (4),            /* int_mult_si */
827       COSTS_N_INSNS (11),           /* int_mult_di */
828       COSTS_N_INSNS (36),           /* int_div_si */
829       COSTS_N_INSNS (68),           /* int_div_di */
830                        1,           /* branch_cost */
831                        4            /* memory_latency */
832     },
833     { /* 5KF */
834       COSTS_N_INSNS (4),            /* fp_add */
835       COSTS_N_INSNS (4),            /* fp_mult_sf */
836       COSTS_N_INSNS (5),            /* fp_mult_df */
837       COSTS_N_INSNS (17),           /* fp_div_sf */
838       COSTS_N_INSNS (32),           /* fp_div_df */
839       COSTS_N_INSNS (4),            /* int_mult_si */
840       COSTS_N_INSNS (11),           /* int_mult_di */
841       COSTS_N_INSNS (36),           /* int_div_si */
842       COSTS_N_INSNS (68),           /* int_div_di */
843                        1,           /* branch_cost */
844                        4            /* memory_latency */
845     },
846     { /* 20KC */
847       DEFAULT_COSTS
848     },
849     { /* 24k */
850       COSTS_N_INSNS (8),            /* fp_add */
851       COSTS_N_INSNS (8),            /* fp_mult_sf */
852       COSTS_N_INSNS (10),           /* fp_mult_df */
853       COSTS_N_INSNS (34),           /* fp_div_sf */
854       COSTS_N_INSNS (64),           /* fp_div_df */
855       COSTS_N_INSNS (5),            /* int_mult_si */
856       COSTS_N_INSNS (5),            /* int_mult_di */
857       COSTS_N_INSNS (41),           /* int_div_si */
858       COSTS_N_INSNS (41),           /* int_div_di */
859                        1,           /* branch_cost */
860                        4            /* memory_latency */
861     },
862     { /* 24kx */
863       COSTS_N_INSNS (4),            /* fp_add */
864       COSTS_N_INSNS (4),            /* fp_mult_sf */
865       COSTS_N_INSNS (5),            /* fp_mult_df */
866       COSTS_N_INSNS (17),           /* fp_div_sf */
867       COSTS_N_INSNS (32),           /* fp_div_df */
868       COSTS_N_INSNS (5),            /* int_mult_si */
869       COSTS_N_INSNS (5),            /* int_mult_di */
870       COSTS_N_INSNS (41),           /* int_div_si */
871       COSTS_N_INSNS (41),           /* int_div_di */
872                        1,           /* branch_cost */
873                        4            /* memory_latency */
874     },
875     { /* M4k */
876       DEFAULT_COSTS
877     },
878     { /* R3900 */
879       COSTS_N_INSNS (2),            /* fp_add */
880       COSTS_N_INSNS (4),            /* fp_mult_sf */
881       COSTS_N_INSNS (5),            /* fp_mult_df */
882       COSTS_N_INSNS (12),           /* fp_div_sf */
883       COSTS_N_INSNS (19),           /* fp_div_df */
884       COSTS_N_INSNS (2),            /* int_mult_si */
885       COSTS_N_INSNS (2),            /* int_mult_di */
886       COSTS_N_INSNS (35),           /* int_div_si */
887       COSTS_N_INSNS (35),           /* int_div_di */
888                        1,           /* branch_cost */
889                        4            /* memory_latency */
890     },
891     { /* R6000 */
892       COSTS_N_INSNS (3),            /* fp_add */
893       COSTS_N_INSNS (5),            /* fp_mult_sf */
894       COSTS_N_INSNS (6),            /* fp_mult_df */
895       COSTS_N_INSNS (15),           /* fp_div_sf */
896       COSTS_N_INSNS (16),           /* fp_div_df */
897       COSTS_N_INSNS (17),           /* int_mult_si */
898       COSTS_N_INSNS (17),           /* int_mult_di */
899       COSTS_N_INSNS (38),           /* int_div_si */
900       COSTS_N_INSNS (38),           /* int_div_di */
901                        2,           /* branch_cost */
902                        6            /* memory_latency */
903     },
904     { /* R4000 */
905        COSTS_N_INSNS (6),           /* fp_add */
906        COSTS_N_INSNS (7),           /* fp_mult_sf */
907        COSTS_N_INSNS (8),           /* fp_mult_df */
908        COSTS_N_INSNS (23),          /* fp_div_sf */
909        COSTS_N_INSNS (36),          /* fp_div_df */
910        COSTS_N_INSNS (10),          /* int_mult_si */
911        COSTS_N_INSNS (10),          /* int_mult_di */
912        COSTS_N_INSNS (69),          /* int_div_si */
913        COSTS_N_INSNS (69),          /* int_div_di */
914                         2,          /* branch_cost */
915                         6           /* memory_latency */
916     },
917     { /* R4100 */
918       DEFAULT_COSTS
919     },
920     { /* R4111 */
921       DEFAULT_COSTS
922     },
923     { /* R4120 */
924       DEFAULT_COSTS
925     },
926     { /* R4130 */
927       /* The only costs that appear to be updated here are
928          integer multiplication.  */
929       SOFT_FP_COSTS,
930       COSTS_N_INSNS (4),            /* int_mult_si */
931       COSTS_N_INSNS (6),            /* int_mult_di */
932       COSTS_N_INSNS (69),           /* int_div_si */
933       COSTS_N_INSNS (69),           /* int_div_di */
934                        1,           /* branch_cost */
935                        4            /* memory_latency */
936     },
937     { /* R4300 */
938       DEFAULT_COSTS
939     },
940     { /* R4600 */
941       DEFAULT_COSTS
942     },
943     { /* R4650 */
944       DEFAULT_COSTS
945     },
946     { /* R5000 */
947       COSTS_N_INSNS (6),            /* fp_add */
948       COSTS_N_INSNS (4),            /* fp_mult_sf */
949       COSTS_N_INSNS (5),            /* fp_mult_df */
950       COSTS_N_INSNS (23),           /* fp_div_sf */
951       COSTS_N_INSNS (36),           /* fp_div_df */
952       COSTS_N_INSNS (5),            /* int_mult_si */
953       COSTS_N_INSNS (5),            /* int_mult_di */
954       COSTS_N_INSNS (36),           /* int_div_si */
955       COSTS_N_INSNS (36),           /* int_div_di */
956                        1,           /* branch_cost */
957                        4            /* memory_latency */
958     },
959     { /* R5400 */
960       COSTS_N_INSNS (6),            /* fp_add */
961       COSTS_N_INSNS (5),            /* fp_mult_sf */
962       COSTS_N_INSNS (6),            /* fp_mult_df */
963       COSTS_N_INSNS (30),           /* fp_div_sf */
964       COSTS_N_INSNS (59),           /* fp_div_df */
965       COSTS_N_INSNS (3),            /* int_mult_si */
966       COSTS_N_INSNS (4),            /* int_mult_di */
967       COSTS_N_INSNS (42),           /* int_div_si */
968       COSTS_N_INSNS (74),           /* int_div_di */
969                        1,           /* branch_cost */
970                        4            /* memory_latency */
971     },
972     { /* R5500 */
973       COSTS_N_INSNS (6),            /* fp_add */
974       COSTS_N_INSNS (5),            /* fp_mult_sf */
975       COSTS_N_INSNS (6),            /* fp_mult_df */
976       COSTS_N_INSNS (30),           /* fp_div_sf */
977       COSTS_N_INSNS (59),           /* fp_div_df */
978       COSTS_N_INSNS (5),            /* int_mult_si */
979       COSTS_N_INSNS (9),            /* int_mult_di */
980       COSTS_N_INSNS (42),           /* int_div_si */
981       COSTS_N_INSNS (74),           /* int_div_di */
982                        1,           /* branch_cost */
983                        4            /* memory_latency */
984     },
985     { /* R7000 */
986       /* The only costs that are changed here are
987          integer multiplication.  */
988       COSTS_N_INSNS (6),            /* fp_add */
989       COSTS_N_INSNS (7),            /* fp_mult_sf */
990       COSTS_N_INSNS (8),            /* fp_mult_df */
991       COSTS_N_INSNS (23),           /* fp_div_sf */
992       COSTS_N_INSNS (36),           /* fp_div_df */
993       COSTS_N_INSNS (5),            /* int_mult_si */
994       COSTS_N_INSNS (9),            /* int_mult_di */
995       COSTS_N_INSNS (69),           /* int_div_si */
996       COSTS_N_INSNS (69),           /* int_div_di */
997                        1,           /* branch_cost */
998                        4            /* memory_latency */
999     },
1000     { /* R8000 */
1001       DEFAULT_COSTS
1002     },
1003     { /* R9000 */
1004       /* The only costs that are changed here are
1005          integer multiplication.  */
1006       COSTS_N_INSNS (6),            /* fp_add */
1007       COSTS_N_INSNS (7),            /* fp_mult_sf */
1008       COSTS_N_INSNS (8),            /* fp_mult_df */
1009       COSTS_N_INSNS (23),           /* fp_div_sf */
1010       COSTS_N_INSNS (36),           /* fp_div_df */
1011       COSTS_N_INSNS (3),            /* int_mult_si */
1012       COSTS_N_INSNS (8),            /* int_mult_di */
1013       COSTS_N_INSNS (69),           /* int_div_si */
1014       COSTS_N_INSNS (69),           /* int_div_di */
1015                        1,           /* branch_cost */
1016                        4            /* memory_latency */
1017     },
1018     { /* SB1 */
1019       COSTS_N_INSNS (4),            /* fp_add */
1020       COSTS_N_INSNS (4),            /* fp_mult_sf */
1021       COSTS_N_INSNS (4),            /* fp_mult_df */
1022       COSTS_N_INSNS (24),           /* fp_div_sf */
1023       COSTS_N_INSNS (32),           /* fp_div_df */
1024       COSTS_N_INSNS (3),            /* int_mult_si */
1025       COSTS_N_INSNS (4),            /* int_mult_di */
1026       COSTS_N_INSNS (36),           /* int_div_si */
1027       COSTS_N_INSNS (68),           /* int_div_di */
1028                        1,           /* branch_cost */
1029                        4            /* memory_latency */
1030     },
1031     { /* SR71000 */
1032       DEFAULT_COSTS
1033     },
1034   };
1035
1036 \f
1037 /* Nonzero if -march should decide the default value of MASK_SOFT_FLOAT.  */
1038 #ifndef MIPS_MARCH_CONTROLS_SOFT_FLOAT
1039 #define MIPS_MARCH_CONTROLS_SOFT_FLOAT 0
1040 #endif
1041 \f
1042 /* Initialize the GCC target structure.  */
1043 #undef TARGET_ASM_ALIGNED_HI_OP
1044 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
1045 #undef TARGET_ASM_ALIGNED_SI_OP
1046 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
1047 #undef TARGET_ASM_ALIGNED_DI_OP
1048 #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t"
1049
1050 #undef TARGET_ASM_FUNCTION_PROLOGUE
1051 #define TARGET_ASM_FUNCTION_PROLOGUE mips_output_function_prologue
1052 #undef TARGET_ASM_FUNCTION_EPILOGUE
1053 #define TARGET_ASM_FUNCTION_EPILOGUE mips_output_function_epilogue
1054 #undef TARGET_ASM_SELECT_RTX_SECTION
1055 #define TARGET_ASM_SELECT_RTX_SECTION mips_select_rtx_section
1056 #undef TARGET_ASM_FUNCTION_RODATA_SECTION
1057 #define TARGET_ASM_FUNCTION_RODATA_SECTION mips_function_rodata_section
1058
1059 #undef TARGET_SCHED_REORDER
1060 #define TARGET_SCHED_REORDER mips_sched_reorder
1061 #undef TARGET_SCHED_VARIABLE_ISSUE
1062 #define TARGET_SCHED_VARIABLE_ISSUE mips_variable_issue
1063 #undef TARGET_SCHED_ADJUST_COST
1064 #define TARGET_SCHED_ADJUST_COST mips_adjust_cost
1065 #undef TARGET_SCHED_ISSUE_RATE
1066 #define TARGET_SCHED_ISSUE_RATE mips_issue_rate
1067 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1068 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
1069   mips_multipass_dfa_lookahead
1070
1071 #undef TARGET_DEFAULT_TARGET_FLAGS
1072 #define TARGET_DEFAULT_TARGET_FLAGS             \
1073   (TARGET_DEFAULT                               \
1074    | TARGET_CPU_DEFAULT                         \
1075    | TARGET_ENDIAN_DEFAULT                      \
1076    | TARGET_FP_EXCEPTIONS_DEFAULT               \
1077    | MASK_CHECK_ZERO_DIV                        \
1078    | MASK_FUSED_MADD)
1079 #undef TARGET_HANDLE_OPTION
1080 #define TARGET_HANDLE_OPTION mips_handle_option
1081
1082 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1083 #define TARGET_FUNCTION_OK_FOR_SIBCALL mips_function_ok_for_sibcall
1084
1085 #undef TARGET_VALID_POINTER_MODE
1086 #define TARGET_VALID_POINTER_MODE mips_valid_pointer_mode
1087 #undef TARGET_RTX_COSTS
1088 #define TARGET_RTX_COSTS mips_rtx_costs
1089 #undef TARGET_ADDRESS_COST
1090 #define TARGET_ADDRESS_COST mips_address_cost
1091
1092 #undef TARGET_IN_SMALL_DATA_P
1093 #define TARGET_IN_SMALL_DATA_P mips_in_small_data_p
1094
1095 #undef TARGET_MACHINE_DEPENDENT_REORG
1096 #define TARGET_MACHINE_DEPENDENT_REORG mips_reorg
1097
1098 #undef TARGET_ASM_FILE_START
1099 #undef TARGET_ASM_FILE_END
1100 #define TARGET_ASM_FILE_START mips_file_start
1101 #define TARGET_ASM_FILE_END mips_file_end
1102 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
1103 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
1104
1105 #undef TARGET_INIT_LIBFUNCS
1106 #define TARGET_INIT_LIBFUNCS mips_init_libfuncs
1107
1108 #undef TARGET_BUILD_BUILTIN_VA_LIST
1109 #define TARGET_BUILD_BUILTIN_VA_LIST mips_build_builtin_va_list
1110 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1111 #define TARGET_GIMPLIFY_VA_ARG_EXPR mips_gimplify_va_arg_expr
1112
1113 #undef TARGET_PROMOTE_FUNCTION_ARGS
1114 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
1115 #undef TARGET_PROMOTE_FUNCTION_RETURN
1116 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
1117 #undef TARGET_PROMOTE_PROTOTYPES
1118 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
1119
1120 #undef TARGET_RETURN_IN_MEMORY
1121 #define TARGET_RETURN_IN_MEMORY mips_return_in_memory
1122 #undef TARGET_RETURN_IN_MSB
1123 #define TARGET_RETURN_IN_MSB mips_return_in_msb
1124
1125 #undef TARGET_ASM_OUTPUT_MI_THUNK
1126 #define TARGET_ASM_OUTPUT_MI_THUNK mips_output_mi_thunk
1127 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1128 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
1129
1130 #undef TARGET_SETUP_INCOMING_VARARGS
1131 #define TARGET_SETUP_INCOMING_VARARGS mips_setup_incoming_varargs
1132 #undef TARGET_STRICT_ARGUMENT_NAMING
1133 #define TARGET_STRICT_ARGUMENT_NAMING mips_strict_argument_naming
1134 #undef TARGET_MUST_PASS_IN_STACK
1135 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
1136 #undef TARGET_PASS_BY_REFERENCE
1137 #define TARGET_PASS_BY_REFERENCE mips_pass_by_reference
1138 #undef TARGET_CALLEE_COPIES
1139 #define TARGET_CALLEE_COPIES mips_callee_copies
1140 #undef TARGET_ARG_PARTIAL_BYTES
1141 #define TARGET_ARG_PARTIAL_BYTES mips_arg_partial_bytes
1142
1143 #undef TARGET_MODE_REP_EXTENDED
1144 #define TARGET_MODE_REP_EXTENDED mips_mode_rep_extended
1145
1146 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1147 #define TARGET_VECTOR_MODE_SUPPORTED_P mips_vector_mode_supported_p
1148
1149 #undef TARGET_INIT_BUILTINS
1150 #define TARGET_INIT_BUILTINS mips_init_builtins
1151 #undef TARGET_EXPAND_BUILTIN
1152 #define TARGET_EXPAND_BUILTIN mips_expand_builtin
1153
1154 #undef TARGET_HAVE_TLS
1155 #define TARGET_HAVE_TLS HAVE_AS_TLS
1156
1157 #undef TARGET_CANNOT_FORCE_CONST_MEM
1158 #define TARGET_CANNOT_FORCE_CONST_MEM mips_cannot_force_const_mem
1159
1160 #undef TARGET_ENCODE_SECTION_INFO
1161 #define TARGET_ENCODE_SECTION_INFO mips_encode_section_info
1162
1163 #undef TARGET_ATTRIBUTE_TABLE
1164 #define TARGET_ATTRIBUTE_TABLE mips_attribute_table
1165
1166 #undef TARGET_EXTRA_LIVE_ON_ENTRY
1167 #define TARGET_EXTRA_LIVE_ON_ENTRY mips_extra_live_on_entry
1168
1169 #undef TARGET_MIN_ANCHOR_OFFSET
1170 #define TARGET_MIN_ANCHOR_OFFSET -32768
1171 #undef TARGET_MAX_ANCHOR_OFFSET
1172 #define TARGET_MAX_ANCHOR_OFFSET 32767
1173 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1174 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P mips_use_blocks_for_constant_p
1175 #undef TARGET_USE_ANCHORS_FOR_SYMBOL_P
1176 #define TARGET_USE_ANCHORS_FOR_SYMBOL_P mips_use_anchors_for_symbol_p
1177
1178 struct gcc_target targetm = TARGET_INITIALIZER;
1179 \f
1180 /* Classify symbol X, which must be a SYMBOL_REF or a LABEL_REF.  */
1181
1182 static enum mips_symbol_type
1183 mips_classify_symbol (rtx x)
1184 {
1185   if (GET_CODE (x) == LABEL_REF)
1186     {
1187       if (TARGET_MIPS16)
1188         return SYMBOL_CONSTANT_POOL;
1189       if (TARGET_ABICALLS && !TARGET_ABSOLUTE_ABICALLS)
1190         return SYMBOL_GOT_LOCAL;
1191       return SYMBOL_GENERAL;
1192     }
1193
1194   gcc_assert (GET_CODE (x) == SYMBOL_REF);
1195
1196   if (SYMBOL_REF_TLS_MODEL (x))
1197     return SYMBOL_TLS;
1198
1199   if (CONSTANT_POOL_ADDRESS_P (x))
1200     {
1201       if (TARGET_MIPS16)
1202         return SYMBOL_CONSTANT_POOL;
1203
1204       if (GET_MODE_SIZE (get_pool_mode (x)) <= mips_section_threshold)
1205         return SYMBOL_SMALL_DATA;
1206     }
1207
1208   if (SYMBOL_REF_SMALL_P (x))
1209     return SYMBOL_SMALL_DATA;
1210
1211   if (TARGET_ABICALLS)
1212     {
1213       if (SYMBOL_REF_DECL (x) == 0)
1214         {
1215           if (!SYMBOL_REF_LOCAL_P (x))
1216             return SYMBOL_GOT_GLOBAL;
1217         }
1218       else
1219         {
1220           /* Don't use GOT accesses for locally-binding symbols if
1221              TARGET_ABSOLUTE_ABICALLS.  Otherwise, there are three
1222              cases to consider:
1223
1224                 - o32 PIC (either with or without explicit relocs)
1225                 - n32/n64 PIC without explicit relocs
1226                 - n32/n64 PIC with explicit relocs
1227
1228              In the first case, both local and global accesses will use an
1229              R_MIPS_GOT16 relocation.  We must correctly predict which of
1230              the two semantics (local or global) the assembler and linker
1231              will apply.  The choice doesn't depend on the symbol's
1232              visibility, so we deliberately ignore decl_visibility and
1233              binds_local_p here.
1234
1235              In the second case, the assembler will not use R_MIPS_GOT16
1236              relocations, but it chooses between local and global accesses
1237              in the same way as for o32 PIC.
1238
1239              In the third case we have more freedom since both forms of
1240              access will work for any kind of symbol.  However, there seems
1241              little point in doing things differently.  */
1242           if (DECL_P (SYMBOL_REF_DECL (x))
1243               && TREE_PUBLIC (SYMBOL_REF_DECL (x))
1244               && !(TARGET_ABSOLUTE_ABICALLS
1245                    && targetm.binds_local_p (SYMBOL_REF_DECL (x))))
1246             return SYMBOL_GOT_GLOBAL;
1247         }
1248
1249       if (!TARGET_ABSOLUTE_ABICALLS)
1250         return SYMBOL_GOT_LOCAL;
1251     }
1252
1253   return SYMBOL_GENERAL;
1254 }
1255
1256
1257 /* Split X into a base and a constant offset, storing them in *BASE
1258    and *OFFSET respectively.  */
1259
1260 static void
1261 mips_split_const (rtx x, rtx *base, HOST_WIDE_INT *offset)
1262 {
1263   *offset = 0;
1264
1265   if (GET_CODE (x) == CONST)
1266     x = XEXP (x, 0);
1267
1268   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
1269     {
1270       *offset += INTVAL (XEXP (x, 1));
1271       x = XEXP (x, 0);
1272     }
1273   *base = x;
1274 }
1275
1276
1277 /* Return true if SYMBOL is a SYMBOL_REF and OFFSET + SYMBOL points
1278    to the same object as SYMBOL, or to the same object_block.  */
1279
1280 static bool
1281 mips_offset_within_object_p (rtx symbol, HOST_WIDE_INT offset)
1282 {
1283   if (GET_CODE (symbol) != SYMBOL_REF)
1284     return false;
1285
1286   if (CONSTANT_POOL_ADDRESS_P (symbol)
1287       && offset >= 0
1288       && offset < (int) GET_MODE_SIZE (get_pool_mode (symbol)))
1289     return true;
1290
1291   if (SYMBOL_REF_DECL (symbol) != 0
1292       && offset >= 0
1293       && offset < int_size_in_bytes (TREE_TYPE (SYMBOL_REF_DECL (symbol))))
1294     return true;
1295
1296   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol)
1297       && SYMBOL_REF_BLOCK (symbol)
1298       && SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0
1299       && ((unsigned HOST_WIDE_INT) offset + SYMBOL_REF_BLOCK_OFFSET (symbol)
1300           < (unsigned HOST_WIDE_INT) SYMBOL_REF_BLOCK (symbol)->size))
1301     return true;
1302
1303   return false;
1304 }
1305
1306
1307 /* Return true if X is a symbolic constant that can be calculated in
1308    the same way as a bare symbol.  If it is, store the type of the
1309    symbol in *SYMBOL_TYPE.  */
1310
1311 bool
1312 mips_symbolic_constant_p (rtx x, enum mips_symbol_type *symbol_type)
1313 {
1314   HOST_WIDE_INT offset;
1315
1316   mips_split_const (x, &x, &offset);
1317   if (UNSPEC_ADDRESS_P (x))
1318     *symbol_type = UNSPEC_ADDRESS_TYPE (x);
1319   else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
1320     {
1321       *symbol_type = mips_classify_symbol (x);
1322       if (*symbol_type == SYMBOL_TLS)
1323         return false;
1324     }
1325   else
1326     return false;
1327
1328   if (offset == 0)
1329     return true;
1330
1331   /* Check whether a nonzero offset is valid for the underlying
1332      relocations.  */
1333   switch (*symbol_type)
1334     {
1335     case SYMBOL_GENERAL:
1336     case SYMBOL_64_HIGH:
1337     case SYMBOL_64_MID:
1338     case SYMBOL_64_LOW:
1339       /* If the target has 64-bit pointers and the object file only
1340          supports 32-bit symbols, the values of those symbols will be
1341          sign-extended.  In this case we can't allow an arbitrary offset
1342          in case the 32-bit value X + OFFSET has a different sign from X.  */
1343       if (Pmode == DImode && !ABI_HAS_64BIT_SYMBOLS)
1344         return mips_offset_within_object_p (x, offset);
1345
1346       /* In other cases the relocations can handle any offset.  */
1347       return true;
1348
1349     case SYMBOL_CONSTANT_POOL:
1350       /* Allow constant pool references to be converted to LABEL+CONSTANT.
1351          In this case, we no longer have access to the underlying constant,
1352          but the original symbol-based access was known to be valid.  */
1353       if (GET_CODE (x) == LABEL_REF)
1354         return true;
1355
1356       /* Fall through.  */
1357
1358     case SYMBOL_SMALL_DATA:
1359       /* Make sure that the offset refers to something within the
1360          underlying object.  This should guarantee that the final
1361          PC- or GP-relative offset is within the 16-bit limit.  */
1362       return mips_offset_within_object_p (x, offset);
1363
1364     case SYMBOL_GOT_LOCAL:
1365     case SYMBOL_GOTOFF_PAGE:
1366       /* The linker should provide enough local GOT entries for a
1367          16-bit offset.  Larger offsets may lead to GOT overflow.  */
1368       return SMALL_OPERAND (offset);
1369
1370     case SYMBOL_GOT_GLOBAL:
1371     case SYMBOL_GOTOFF_GLOBAL:
1372     case SYMBOL_GOTOFF_CALL:
1373     case SYMBOL_GOTOFF_LOADGP:
1374     case SYMBOL_TLSGD:
1375     case SYMBOL_TLSLDM:
1376     case SYMBOL_DTPREL:
1377     case SYMBOL_TPREL:
1378     case SYMBOL_GOTTPREL:
1379     case SYMBOL_TLS:
1380       return false;
1381     }
1382   gcc_unreachable ();
1383 }
1384
1385
1386 /* This function is used to implement REG_MODE_OK_FOR_BASE_P.  */
1387
1388 int
1389 mips_regno_mode_ok_for_base_p (int regno, enum machine_mode mode, int strict)
1390 {
1391   if (regno >= FIRST_PSEUDO_REGISTER)
1392     {
1393       if (!strict)
1394         return true;
1395       regno = reg_renumber[regno];
1396     }
1397
1398   /* These fake registers will be eliminated to either the stack or
1399      hard frame pointer, both of which are usually valid base registers.
1400      Reload deals with the cases where the eliminated form isn't valid.  */
1401   if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
1402     return true;
1403
1404   /* In mips16 mode, the stack pointer can only address word and doubleword
1405      values, nothing smaller.  There are two problems here:
1406
1407        (a) Instantiating virtual registers can introduce new uses of the
1408            stack pointer.  If these virtual registers are valid addresses,
1409            the stack pointer should be too.
1410
1411        (b) Most uses of the stack pointer are not made explicit until
1412            FRAME_POINTER_REGNUM and ARG_POINTER_REGNUM have been eliminated.
1413            We don't know until that stage whether we'll be eliminating to the
1414            stack pointer (which needs the restriction) or the hard frame
1415            pointer (which doesn't).
1416
1417      All in all, it seems more consistent to only enforce this restriction
1418      during and after reload.  */
1419   if (TARGET_MIPS16 && regno == STACK_POINTER_REGNUM)
1420     return !strict || GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8;
1421
1422   return TARGET_MIPS16 ? M16_REG_P (regno) : GP_REG_P (regno);
1423 }
1424
1425
1426 /* Return true if X is a valid base register for the given mode.
1427    Allow only hard registers if STRICT.  */
1428
1429 static bool
1430 mips_valid_base_register_p (rtx x, enum machine_mode mode, int strict)
1431 {
1432   if (!strict && GET_CODE (x) == SUBREG)
1433     x = SUBREG_REG (x);
1434
1435   return (REG_P (x)
1436           && mips_regno_mode_ok_for_base_p (REGNO (x), mode, strict));
1437 }
1438
1439
1440 /* Return true if symbols of type SYMBOL_TYPE can directly address a value
1441    with mode MODE.  This is used for both symbolic and LO_SUM addresses.  */
1442
1443 static bool
1444 mips_symbolic_address_p (enum mips_symbol_type symbol_type,
1445                          enum machine_mode mode)
1446 {
1447   switch (symbol_type)
1448     {
1449     case SYMBOL_GENERAL:
1450       return !TARGET_MIPS16;
1451
1452     case SYMBOL_SMALL_DATA:
1453       return true;
1454
1455     case SYMBOL_CONSTANT_POOL:
1456       /* PC-relative addressing is only available for lw and ld.  */
1457       return GET_MODE_SIZE (mode) == 4 || GET_MODE_SIZE (mode) == 8;
1458
1459     case SYMBOL_GOT_LOCAL:
1460       return true;
1461
1462     case SYMBOL_GOT_GLOBAL:
1463       /* The address will have to be loaded from the GOT first.  */
1464       return false;
1465
1466     case SYMBOL_GOTOFF_PAGE:
1467     case SYMBOL_GOTOFF_GLOBAL:
1468     case SYMBOL_GOTOFF_CALL:
1469     case SYMBOL_GOTOFF_LOADGP:
1470     case SYMBOL_TLS:
1471     case SYMBOL_TLSGD:
1472     case SYMBOL_TLSLDM:
1473     case SYMBOL_DTPREL:
1474     case SYMBOL_GOTTPREL:
1475     case SYMBOL_TPREL:
1476     case SYMBOL_64_HIGH:
1477     case SYMBOL_64_MID:
1478     case SYMBOL_64_LOW:
1479       return true;
1480     }
1481   gcc_unreachable ();
1482 }
1483
1484
1485 /* Return true if X is a valid address for machine mode MODE.  If it is,
1486    fill in INFO appropriately.  STRICT is true if we should only accept
1487    hard base registers.  */
1488
1489 static bool
1490 mips_classify_address (struct mips_address_info *info, rtx x,
1491                        enum machine_mode mode, int strict)
1492 {
1493   switch (GET_CODE (x))
1494     {
1495     case REG:
1496     case SUBREG:
1497       info->type = ADDRESS_REG;
1498       info->reg = x;
1499       info->offset = const0_rtx;
1500       return mips_valid_base_register_p (info->reg, mode, strict);
1501
1502     case PLUS:
1503       info->type = ADDRESS_REG;
1504       info->reg = XEXP (x, 0);
1505       info->offset = XEXP (x, 1);
1506       return (mips_valid_base_register_p (info->reg, mode, strict)
1507               && const_arith_operand (info->offset, VOIDmode));
1508
1509     case LO_SUM:
1510       info->type = ADDRESS_LO_SUM;
1511       info->reg = XEXP (x, 0);
1512       info->offset = XEXP (x, 1);
1513       return (mips_valid_base_register_p (info->reg, mode, strict)
1514               && mips_symbolic_constant_p (info->offset, &info->symbol_type)
1515               && mips_symbolic_address_p (info->symbol_type, mode)
1516               && mips_lo_relocs[info->symbol_type] != 0);
1517
1518     case CONST_INT:
1519       /* Small-integer addresses don't occur very often, but they
1520          are legitimate if $0 is a valid base register.  */
1521       info->type = ADDRESS_CONST_INT;
1522       return !TARGET_MIPS16 && SMALL_INT (x);
1523
1524     case CONST:
1525     case LABEL_REF:
1526     case SYMBOL_REF:
1527       info->type = ADDRESS_SYMBOLIC;
1528       return (mips_symbolic_constant_p (x, &info->symbol_type)
1529               && mips_symbolic_address_p (info->symbol_type, mode)
1530               && !mips_split_p[info->symbol_type]);
1531
1532     default:
1533       return false;
1534     }
1535 }
1536
1537 /* Return true if X is a thread-local symbol.  */
1538
1539 static bool
1540 mips_tls_operand_p (rtx x)
1541 {
1542   return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
1543 }
1544
1545 /* Return true if X can not be forced into a constant pool.  */
1546
1547 static int
1548 mips_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1549 {
1550   return mips_tls_operand_p (*x);
1551 }
1552
1553 /* Return true if X can not be forced into a constant pool.  */
1554
1555 static bool
1556 mips_cannot_force_const_mem (rtx x)
1557 {
1558   rtx base;
1559   HOST_WIDE_INT offset;
1560
1561   if (!TARGET_MIPS16)
1562     {
1563       /* As an optimization, reject constants that mips_legitimize_move
1564          can expand inline.
1565
1566          Suppose we have a multi-instruction sequence that loads constant C
1567          into register R.  If R does not get allocated a hard register, and
1568          R is used in an operand that allows both registers and memory
1569          references, reload will consider forcing C into memory and using
1570          one of the instruction's memory alternatives.  Returning false
1571          here will force it to use an input reload instead.  */
1572       if (GET_CODE (x) == CONST_INT)
1573         return true;
1574
1575       mips_split_const (x, &base, &offset);
1576       if (symbolic_operand (base, VOIDmode) && SMALL_OPERAND (offset))
1577         return true;
1578     }
1579
1580   if (TARGET_HAVE_TLS && for_each_rtx (&x, &mips_tls_symbol_ref_1, 0))
1581     return true;
1582
1583   return false;
1584 }
1585
1586 /* Implement TARGET_USE_BLOCKS_FOR_CONSTANT_P.  MIPS16 uses per-function
1587    constant pools, but normal-mode code doesn't need to.  */
1588
1589 static bool
1590 mips_use_blocks_for_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED,
1591                                 rtx x ATTRIBUTE_UNUSED)
1592 {
1593   return !TARGET_MIPS16;
1594 }
1595 \f
1596 /* Return the number of instructions needed to load a symbol of the
1597    given type into a register.  If valid in an address, the same number
1598    of instructions are needed for loads and stores.  Treat extended
1599    mips16 instructions as two instructions.  */
1600
1601 static int
1602 mips_symbol_insns (enum mips_symbol_type type)
1603 {
1604   switch (type)
1605     {
1606     case SYMBOL_GENERAL:
1607       /* In mips16 code, general symbols must be fetched from the
1608          constant pool.  */
1609       if (TARGET_MIPS16)
1610         return 0;
1611
1612       /* When using 64-bit symbols, we need 5 preparatory instructions,
1613          such as:
1614
1615              lui     $at,%highest(symbol)
1616              daddiu  $at,$at,%higher(symbol)
1617              dsll    $at,$at,16
1618              daddiu  $at,$at,%hi(symbol)
1619              dsll    $at,$at,16
1620
1621          The final address is then $at + %lo(symbol).  With 32-bit
1622          symbols we just need a preparatory lui.  */
1623       return (ABI_HAS_64BIT_SYMBOLS ? 6 : 2);
1624
1625     case SYMBOL_SMALL_DATA:
1626       return 1;
1627
1628     case SYMBOL_CONSTANT_POOL:
1629       /* This case is for mips16 only.  Assume we'll need an
1630          extended instruction.  */
1631       return 2;
1632
1633     case SYMBOL_GOT_LOCAL:
1634     case SYMBOL_GOT_GLOBAL:
1635       /* Unless -funit-at-a-time is in effect, we can't be sure whether
1636          the local/global classification is accurate.  See override_options
1637          for details.
1638
1639          The worst cases are:
1640
1641          (1) For local symbols when generating o32 or o64 code.  The assembler
1642              will use:
1643
1644                  lw           $at,%got(symbol)
1645                  nop
1646
1647              ...and the final address will be $at + %lo(symbol).
1648
1649          (2) For global symbols when -mxgot.  The assembler will use:
1650
1651                  lui     $at,%got_hi(symbol)
1652                  (d)addu $at,$at,$gp
1653
1654              ...and the final address will be $at + %got_lo(symbol).  */
1655       return 3;
1656
1657     case SYMBOL_GOTOFF_PAGE:
1658     case SYMBOL_GOTOFF_GLOBAL:
1659     case SYMBOL_GOTOFF_CALL:
1660     case SYMBOL_GOTOFF_LOADGP:
1661     case SYMBOL_64_HIGH:
1662     case SYMBOL_64_MID:
1663     case SYMBOL_64_LOW:
1664     case SYMBOL_TLSGD:
1665     case SYMBOL_TLSLDM:
1666     case SYMBOL_DTPREL:
1667     case SYMBOL_GOTTPREL:
1668     case SYMBOL_TPREL:
1669       /* Check whether the offset is a 16- or 32-bit value.  */
1670       return mips_split_p[type] ? 2 : 1;
1671
1672     case SYMBOL_TLS:
1673       /* We don't treat a bare TLS symbol as a constant.  */
1674       return 0;
1675     }
1676   gcc_unreachable ();
1677 }
1678
1679 /* Return true if X is a legitimate $sp-based address for mode MDOE.  */
1680
1681 bool
1682 mips_stack_address_p (rtx x, enum machine_mode mode)
1683 {
1684   struct mips_address_info addr;
1685
1686   return (mips_classify_address (&addr, x, mode, false)
1687           && addr.type == ADDRESS_REG
1688           && addr.reg == stack_pointer_rtx);
1689 }
1690
1691 /* Return true if a value at OFFSET bytes from BASE can be accessed
1692    using an unextended mips16 instruction.  MODE is the mode of the
1693    value.
1694
1695    Usually the offset in an unextended instruction is a 5-bit field.
1696    The offset is unsigned and shifted left once for HIs, twice
1697    for SIs, and so on.  An exception is SImode accesses off the
1698    stack pointer, which have an 8-bit immediate field.  */
1699
1700 static bool
1701 mips16_unextended_reference_p (enum machine_mode mode, rtx base, rtx offset)
1702 {
1703   if (TARGET_MIPS16
1704       && GET_CODE (offset) == CONST_INT
1705       && INTVAL (offset) >= 0
1706       && (INTVAL (offset) & (GET_MODE_SIZE (mode) - 1)) == 0)
1707     {
1708       if (GET_MODE_SIZE (mode) == 4 && base == stack_pointer_rtx)
1709         return INTVAL (offset) < 256 * GET_MODE_SIZE (mode);
1710       return INTVAL (offset) < 32 * GET_MODE_SIZE (mode);
1711     }
1712   return false;
1713 }
1714
1715
1716 /* Return the number of instructions needed to load or store a value
1717    of mode MODE at X.  Return 0 if X isn't valid for MODE.
1718
1719    For mips16 code, count extended instructions as two instructions.  */
1720
1721 int
1722 mips_address_insns (rtx x, enum machine_mode mode)
1723 {
1724   struct mips_address_info addr;
1725   int factor;
1726
1727   if (mode == BLKmode)
1728     /* BLKmode is used for single unaligned loads and stores.  */
1729     factor = 1;
1730   else
1731     /* Each word of a multi-word value will be accessed individually.  */
1732     factor = (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1733
1734   if (mips_classify_address (&addr, x, mode, false))
1735     switch (addr.type)
1736       {
1737       case ADDRESS_REG:
1738         if (TARGET_MIPS16
1739             && !mips16_unextended_reference_p (mode, addr.reg, addr.offset))
1740           return factor * 2;
1741         return factor;
1742
1743       case ADDRESS_LO_SUM:
1744         return (TARGET_MIPS16 ? factor * 2 : factor);
1745
1746       case ADDRESS_CONST_INT:
1747         return factor;
1748
1749       case ADDRESS_SYMBOLIC:
1750         return factor * mips_symbol_insns (addr.symbol_type);
1751       }
1752   return 0;
1753 }
1754
1755
1756 /* Likewise for constant X.  */
1757
1758 int
1759 mips_const_insns (rtx x)
1760 {
1761   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
1762   enum mips_symbol_type symbol_type;
1763   HOST_WIDE_INT offset;
1764
1765   switch (GET_CODE (x))
1766     {
1767     case HIGH:
1768       if (TARGET_MIPS16
1769           || !mips_symbolic_constant_p (XEXP (x, 0), &symbol_type)
1770           || !mips_split_p[symbol_type])
1771         return 0;
1772
1773       return 1;
1774
1775     case CONST_INT:
1776       if (TARGET_MIPS16)
1777         /* Unsigned 8-bit constants can be loaded using an unextended
1778            LI instruction.  Unsigned 16-bit constants can be loaded
1779            using an extended LI.  Negative constants must be loaded
1780            using LI and then negated.  */
1781         return (INTVAL (x) >= 0 && INTVAL (x) < 256 ? 1
1782                 : SMALL_OPERAND_UNSIGNED (INTVAL (x)) ? 2
1783                 : INTVAL (x) > -256 && INTVAL (x) < 0 ? 2
1784                 : SMALL_OPERAND_UNSIGNED (-INTVAL (x)) ? 3
1785                 : 0);
1786
1787       return mips_build_integer (codes, INTVAL (x));
1788
1789     case CONST_DOUBLE:
1790     case CONST_VECTOR:
1791       return (!TARGET_MIPS16 && x == CONST0_RTX (GET_MODE (x)) ? 1 : 0);
1792
1793     case CONST:
1794       if (CONST_GP_P (x))
1795         return 1;
1796
1797       /* See if we can refer to X directly.  */
1798       if (mips_symbolic_constant_p (x, &symbol_type))
1799         return mips_symbol_insns (symbol_type);
1800
1801       /* Otherwise try splitting the constant into a base and offset.
1802          16-bit offsets can be added using an extra addiu.  Larger offsets
1803          must be calculated separately and then added to the base.  */
1804       mips_split_const (x, &x, &offset);
1805       if (offset != 0)
1806         {
1807           int n = mips_const_insns (x);
1808           if (n != 0)
1809             {
1810               if (SMALL_OPERAND (offset))
1811                 return n + 1;
1812               else
1813                 return n + 1 + mips_build_integer (codes, offset);
1814             }
1815         }
1816       return 0;
1817
1818     case SYMBOL_REF:
1819     case LABEL_REF:
1820       return mips_symbol_insns (mips_classify_symbol (x));
1821
1822     default:
1823       return 0;
1824     }
1825 }
1826
1827
1828 /* Return the number of instructions needed for memory reference X.
1829    Count extended mips16 instructions as two instructions.  */
1830
1831 int
1832 mips_fetch_insns (rtx x)
1833 {
1834   gcc_assert (MEM_P (x));
1835   return mips_address_insns (XEXP (x, 0), GET_MODE (x));
1836 }
1837
1838
1839 /* Return the number of instructions needed for an integer division.  */
1840
1841 int
1842 mips_idiv_insns (void)
1843 {
1844   int count;
1845
1846   count = 1;
1847   if (TARGET_CHECK_ZERO_DIV)
1848     {
1849       if (GENERATE_DIVIDE_TRAPS)
1850         count++;
1851       else
1852         count += 2;
1853     }
1854
1855   if (TARGET_FIX_R4000 || TARGET_FIX_R4400)
1856     count++;
1857   return count;
1858 }
1859 \f
1860 /* This function is used to implement GO_IF_LEGITIMATE_ADDRESS.  It
1861    returns a nonzero value if X is a legitimate address for a memory
1862    operand of the indicated MODE.  STRICT is nonzero if this function
1863    is called during reload.  */
1864
1865 bool
1866 mips_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
1867 {
1868   struct mips_address_info addr;
1869
1870   return mips_classify_address (&addr, x, mode, strict);
1871 }
1872
1873
1874 /* Copy VALUE to a register and return that register.  If new psuedos
1875    are allowed, copy it into a new register, otherwise use DEST.  */
1876
1877 static rtx
1878 mips_force_temporary (rtx dest, rtx value)
1879 {
1880   if (!no_new_pseudos)
1881     return force_reg (Pmode, value);
1882   else
1883     {
1884       emit_move_insn (copy_rtx (dest), value);
1885       return dest;
1886     }
1887 }
1888
1889
1890 /* Return a LO_SUM expression for ADDR.  TEMP is as for mips_force_temporary
1891    and is used to load the high part into a register.  */
1892
1893 rtx
1894 mips_split_symbol (rtx temp, rtx addr)
1895 {
1896   rtx high;
1897
1898   if (TARGET_MIPS16)
1899     high = mips16_gp_pseudo_reg ();
1900   else
1901     high = mips_force_temporary (temp, gen_rtx_HIGH (Pmode, copy_rtx (addr)));
1902   return gen_rtx_LO_SUM (Pmode, high, addr);
1903 }
1904
1905
1906 /* Return an UNSPEC address with underlying address ADDRESS and symbol
1907    type SYMBOL_TYPE.  */
1908
1909 rtx
1910 mips_unspec_address (rtx address, enum mips_symbol_type symbol_type)
1911 {
1912   rtx base;
1913   HOST_WIDE_INT offset;
1914
1915   mips_split_const (address, &base, &offset);
1916   base = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, base),
1917                          UNSPEC_ADDRESS_FIRST + symbol_type);
1918   return plus_constant (gen_rtx_CONST (Pmode, base), offset);
1919 }
1920
1921
1922 /* If mips_unspec_address (ADDR, SYMBOL_TYPE) is a 32-bit value, add the
1923    high part to BASE and return the result.  Just return BASE otherwise.
1924    TEMP is available as a temporary register if needed.
1925
1926    The returned expression can be used as the first operand to a LO_SUM.  */
1927
1928 static rtx
1929 mips_unspec_offset_high (rtx temp, rtx base, rtx addr,
1930                          enum mips_symbol_type symbol_type)
1931 {
1932   if (mips_split_p[symbol_type])
1933     {
1934       addr = gen_rtx_HIGH (Pmode, mips_unspec_address (addr, symbol_type));
1935       addr = mips_force_temporary (temp, addr);
1936       return mips_force_temporary (temp, gen_rtx_PLUS (Pmode, addr, base));
1937     }
1938   return base;
1939 }
1940
1941
1942 /* Return a legitimate address for REG + OFFSET.  TEMP is as for
1943    mips_force_temporary; it is only needed when OFFSET is not a
1944    SMALL_OPERAND.  */
1945
1946 static rtx
1947 mips_add_offset (rtx temp, rtx reg, HOST_WIDE_INT offset)
1948 {
1949   if (!SMALL_OPERAND (offset))
1950     {
1951       rtx high;
1952       if (TARGET_MIPS16)
1953         {
1954           /* Load the full offset into a register so that we can use
1955              an unextended instruction for the address itself.  */
1956           high = GEN_INT (offset);
1957           offset = 0;
1958         }
1959       else
1960         {
1961           /* Leave OFFSET as a 16-bit offset and put the excess in HIGH.  */
1962           high = GEN_INT (CONST_HIGH_PART (offset));
1963           offset = CONST_LOW_PART (offset);
1964         }
1965       high = mips_force_temporary (temp, high);
1966       reg = mips_force_temporary (temp, gen_rtx_PLUS (Pmode, high, reg));
1967     }
1968   return plus_constant (reg, offset);
1969 }
1970
1971 /* Emit a call to __tls_get_addr.  SYM is the TLS symbol we are
1972    referencing, and TYPE is the symbol type to use (either global
1973    dynamic or local dynamic).  V0 is an RTX for the return value
1974    location.  The entire insn sequence is returned.  */
1975
1976 static GTY(()) rtx mips_tls_symbol;
1977
1978 static rtx
1979 mips_call_tls_get_addr (rtx sym, enum mips_symbol_type type, rtx v0)
1980 {
1981   rtx insn, loc, tga, a0;
1982
1983   a0 = gen_rtx_REG (Pmode, GP_ARG_FIRST);
1984
1985   if (!mips_tls_symbol)
1986     mips_tls_symbol = init_one_libfunc ("__tls_get_addr");
1987
1988   loc = mips_unspec_address (sym, type);
1989
1990   start_sequence ();
1991
1992   emit_insn (gen_rtx_SET (Pmode, a0,
1993                           gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, loc)));
1994   tga = gen_rtx_MEM (Pmode, mips_tls_symbol);
1995   insn = emit_call_insn (gen_call_value (v0, tga, const0_rtx, const0_rtx));
1996   CONST_OR_PURE_CALL_P (insn) = 1;
1997   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), v0);
1998   use_reg (&CALL_INSN_FUNCTION_USAGE (insn), a0);
1999   insn = get_insns ();
2000
2001   end_sequence ();
2002
2003   return insn;
2004 }
2005
2006 /* Generate the code to access LOC, a thread local SYMBOL_REF.  The
2007    return value will be a valid address and move_operand (either a REG
2008    or a LO_SUM).  */
2009
2010 static rtx
2011 mips_legitimize_tls_address (rtx loc)
2012 {
2013   rtx dest, insn, v0, v1, tmp1, tmp2, eqv;
2014   enum tls_model model;
2015
2016   v0 = gen_rtx_REG (Pmode, GP_RETURN);
2017   v1 = gen_rtx_REG (Pmode, GP_RETURN + 1);
2018
2019   model = SYMBOL_REF_TLS_MODEL (loc);
2020
2021   switch (model)
2022     {
2023     case TLS_MODEL_GLOBAL_DYNAMIC:
2024       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSGD, v0);
2025       dest = gen_reg_rtx (Pmode);
2026       emit_libcall_block (insn, dest, v0, loc);
2027       break;
2028
2029     case TLS_MODEL_LOCAL_DYNAMIC:
2030       insn = mips_call_tls_get_addr (loc, SYMBOL_TLSLDM, v0);
2031       tmp1 = gen_reg_rtx (Pmode);
2032
2033       /* Attach a unique REG_EQUIV, to allow the RTL optimizers to
2034          share the LDM result with other LD model accesses.  */
2035       eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
2036                             UNSPEC_TLS_LDM);
2037       emit_libcall_block (insn, tmp1, v0, eqv);
2038
2039       tmp2 = mips_unspec_offset_high (NULL, tmp1, loc, SYMBOL_DTPREL);
2040       dest = gen_rtx_LO_SUM (Pmode, tmp2,
2041                              mips_unspec_address (loc, SYMBOL_DTPREL));
2042       break;
2043
2044     case TLS_MODEL_INITIAL_EXEC:
2045       tmp1 = gen_reg_rtx (Pmode);
2046       tmp2 = mips_unspec_address (loc, SYMBOL_GOTTPREL);
2047       if (Pmode == DImode)
2048         {
2049           emit_insn (gen_tls_get_tp_di (v1));
2050           emit_insn (gen_load_gotdi (tmp1, pic_offset_table_rtx, tmp2));
2051         }
2052       else
2053         {
2054           emit_insn (gen_tls_get_tp_si (v1));
2055           emit_insn (gen_load_gotsi (tmp1, pic_offset_table_rtx, tmp2));
2056         }
2057       dest = gen_reg_rtx (Pmode);
2058       emit_insn (gen_add3_insn (dest, tmp1, v1));
2059       break;
2060
2061     case TLS_MODEL_LOCAL_EXEC:
2062
2063       if (Pmode == DImode)
2064         emit_insn (gen_tls_get_tp_di (v1));
2065       else
2066         emit_insn (gen_tls_get_tp_si (v1));
2067
2068       tmp1 = mips_unspec_offset_high (NULL, v1, loc, SYMBOL_TPREL);
2069       dest = gen_rtx_LO_SUM (Pmode, tmp1,
2070                              mips_unspec_address (loc, SYMBOL_TPREL));
2071       break;
2072
2073     default:
2074       gcc_unreachable ();
2075     }
2076
2077   return dest;
2078 }
2079
2080 /* This function is used to implement LEGITIMIZE_ADDRESS.  If *XLOC can
2081    be legitimized in a way that the generic machinery might not expect,
2082    put the new address in *XLOC and return true.  MODE is the mode of
2083    the memory being accessed.  */
2084
2085 bool
2086 mips_legitimize_address (rtx *xloc, enum machine_mode mode)
2087 {
2088   enum mips_symbol_type symbol_type;
2089
2090   if (mips_tls_operand_p (*xloc))
2091     {
2092       *xloc = mips_legitimize_tls_address (*xloc);
2093       return true;
2094     }
2095
2096   /* See if the address can split into a high part and a LO_SUM.  */
2097   if (mips_symbolic_constant_p (*xloc, &symbol_type)
2098       && mips_symbolic_address_p (symbol_type, mode)
2099       && mips_split_p[symbol_type])
2100     {
2101       *xloc = mips_split_symbol (0, *xloc);
2102       return true;
2103     }
2104
2105   if (GET_CODE (*xloc) == PLUS && GET_CODE (XEXP (*xloc, 1)) == CONST_INT)
2106     {
2107       /* Handle REG + CONSTANT using mips_add_offset.  */
2108       rtx reg;
2109
2110       reg = XEXP (*xloc, 0);
2111       if (!mips_valid_base_register_p (reg, mode, 0))
2112         reg = copy_to_mode_reg (Pmode, reg);
2113       *xloc = mips_add_offset (0, reg, INTVAL (XEXP (*xloc, 1)));
2114       return true;
2115     }
2116
2117   return false;
2118 }
2119
2120
2121 /* Subroutine of mips_build_integer (with the same interface).
2122    Assume that the final action in the sequence should be a left shift.  */
2123
2124 static unsigned int
2125 mips_build_shift (struct mips_integer_op *codes, HOST_WIDE_INT value)
2126 {
2127   unsigned int i, shift;
2128
2129   /* Shift VALUE right until its lowest bit is set.  Shift arithmetically
2130      since signed numbers are easier to load than unsigned ones.  */
2131   shift = 0;
2132   while ((value & 1) == 0)
2133     value /= 2, shift++;
2134
2135   i = mips_build_integer (codes, value);
2136   codes[i].code = ASHIFT;
2137   codes[i].value = shift;
2138   return i + 1;
2139 }
2140
2141
2142 /* As for mips_build_shift, but assume that the final action will be
2143    an IOR or PLUS operation.  */
2144
2145 static unsigned int
2146 mips_build_lower (struct mips_integer_op *codes, unsigned HOST_WIDE_INT value)
2147 {
2148   unsigned HOST_WIDE_INT high;
2149   unsigned int i;
2150
2151   high = value & ~(unsigned HOST_WIDE_INT) 0xffff;
2152   if (!LUI_OPERAND (high) && (value & 0x18000) == 0x18000)
2153     {
2154       /* The constant is too complex to load with a simple lui/ori pair
2155          so our goal is to clear as many trailing zeros as possible.
2156          In this case, we know bit 16 is set and that the low 16 bits
2157          form a negative number.  If we subtract that number from VALUE,
2158          we will clear at least the lowest 17 bits, maybe more.  */
2159       i = mips_build_integer (codes, CONST_HIGH_PART (value));
2160       codes[i].code = PLUS;
2161       codes[i].value = CONST_LOW_PART (value);
2162     }
2163   else
2164     {
2165       i = mips_build_integer (codes, high);
2166       codes[i].code = IOR;
2167       codes[i].value = value & 0xffff;
2168     }
2169   return i + 1;
2170 }
2171
2172
2173 /* Fill CODES with a sequence of rtl operations to load VALUE.
2174    Return the number of operations needed.  */
2175
2176 static unsigned int
2177 mips_build_integer (struct mips_integer_op *codes,
2178                     unsigned HOST_WIDE_INT value)
2179 {
2180   if (SMALL_OPERAND (value)
2181       || SMALL_OPERAND_UNSIGNED (value)
2182       || LUI_OPERAND (value))
2183     {
2184       /* The value can be loaded with a single instruction.  */
2185       codes[0].code = UNKNOWN;
2186       codes[0].value = value;
2187       return 1;
2188     }
2189   else if ((value & 1) != 0 || LUI_OPERAND (CONST_HIGH_PART (value)))
2190     {
2191       /* Either the constant is a simple LUI/ORI combination or its
2192          lowest bit is set.  We don't want to shift in this case.  */
2193       return mips_build_lower (codes, value);
2194     }
2195   else if ((value & 0xffff) == 0)
2196     {
2197       /* The constant will need at least three actions.  The lowest
2198          16 bits are clear, so the final action will be a shift.  */
2199       return mips_build_shift (codes, value);
2200     }
2201   else
2202     {
2203       /* The final action could be a shift, add or inclusive OR.
2204          Rather than use a complex condition to select the best
2205          approach, try both mips_build_shift and mips_build_lower
2206          and pick the one that gives the shortest sequence.
2207          Note that this case is only used once per constant.  */
2208       struct mips_integer_op alt_codes[MIPS_MAX_INTEGER_OPS];
2209       unsigned int cost, alt_cost;
2210
2211       cost = mips_build_shift (codes, value);
2212       alt_cost = mips_build_lower (alt_codes, value);
2213       if (alt_cost < cost)
2214         {
2215           memcpy (codes, alt_codes, alt_cost * sizeof (codes[0]));
2216           cost = alt_cost;
2217         }
2218       return cost;
2219     }
2220 }
2221
2222
2223 /* Load VALUE into DEST, using TEMP as a temporary register if need be.  */
2224
2225 void
2226 mips_move_integer (rtx dest, rtx temp, unsigned HOST_WIDE_INT value)
2227 {
2228   struct mips_integer_op codes[MIPS_MAX_INTEGER_OPS];
2229   enum machine_mode mode;
2230   unsigned int i, cost;
2231   rtx x;
2232
2233   mode = GET_MODE (dest);
2234   cost = mips_build_integer (codes, value);
2235
2236   /* Apply each binary operation to X.  Invariant: X is a legitimate
2237      source operand for a SET pattern.  */
2238   x = GEN_INT (codes[0].value);
2239   for (i = 1; i < cost; i++)
2240     {
2241       if (no_new_pseudos)
2242         {
2243           emit_insn (gen_rtx_SET (VOIDmode, temp, x));
2244           x = temp;
2245         }
2246       else
2247         x = force_reg (mode, x);
2248       x = gen_rtx_fmt_ee (codes[i].code, mode, x, GEN_INT (codes[i].value));
2249     }
2250
2251   emit_insn (gen_rtx_SET (VOIDmode, dest, x));
2252 }
2253
2254
2255 /* Subroutine of mips_legitimize_move.  Move constant SRC into register
2256    DEST given that SRC satisfies immediate_operand but doesn't satisfy
2257    move_operand.  */
2258
2259 static void
2260 mips_legitimize_const_move (enum machine_mode mode, rtx dest, rtx src)
2261 {
2262   rtx base;
2263   HOST_WIDE_INT offset;
2264
2265   /* Split moves of big integers into smaller pieces.  */
2266   if (splittable_const_int_operand (src, mode))
2267     {
2268       mips_move_integer (dest, dest, INTVAL (src));
2269       return;
2270     }
2271
2272   /* Split moves of symbolic constants into high/low pairs.  */
2273   if (splittable_symbolic_operand (src, mode))
2274     {
2275       emit_insn (gen_rtx_SET (VOIDmode, dest, mips_split_symbol (dest, src)));
2276       return;
2277     }
2278
2279   if (mips_tls_operand_p (src))
2280     {
2281       emit_move_insn (dest, mips_legitimize_tls_address (src));
2282       return;
2283     }
2284
2285   /* If we have (const (plus symbol offset)), load the symbol first
2286      and then add in the offset.  This is usually better than forcing
2287      the constant into memory, at least in non-mips16 code.  */
2288   mips_split_const (src, &base, &offset);
2289   if (!TARGET_MIPS16
2290       && offset != 0
2291       && (!no_new_pseudos || SMALL_OPERAND (offset)))
2292     {
2293       base = mips_force_temporary (dest, base);
2294       emit_move_insn (dest, mips_add_offset (0, base, offset));
2295       return;
2296     }
2297
2298   src = force_const_mem (mode, src);
2299
2300   /* When using explicit relocs, constant pool references are sometimes
2301      not legitimate addresses.  */
2302   if (!memory_operand (src, VOIDmode))
2303     src = replace_equiv_address (src, mips_split_symbol (dest, XEXP (src, 0)));
2304   emit_move_insn (dest, src);
2305 }
2306
2307
2308 /* If (set DEST SRC) is not a valid instruction, emit an equivalent
2309    sequence that is valid.  */
2310
2311 bool
2312 mips_legitimize_move (enum machine_mode mode, rtx dest, rtx src)
2313 {
2314   if (!register_operand (dest, mode) && !reg_or_0_operand (src, mode))
2315     {
2316       emit_move_insn (dest, force_reg (mode, src));
2317       return true;
2318     }
2319
2320   /* Check for individual, fully-reloaded mflo and mfhi instructions.  */
2321   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD
2322       && REG_P (src) && MD_REG_P (REGNO (src))
2323       && REG_P (dest) && GP_REG_P (REGNO (dest)))
2324     {
2325       int other_regno = REGNO (src) == HI_REGNUM ? LO_REGNUM : HI_REGNUM;
2326       if (GET_MODE_SIZE (mode) <= 4)
2327         emit_insn (gen_mfhilo_si (gen_rtx_REG (SImode, REGNO (dest)),
2328                                   gen_rtx_REG (SImode, REGNO (src)),
2329                                   gen_rtx_REG (SImode, other_regno)));
2330       else
2331         emit_insn (gen_mfhilo_di (gen_rtx_REG (DImode, REGNO (dest)),
2332                                   gen_rtx_REG (DImode, REGNO (src)),
2333                                   gen_rtx_REG (DImode, other_regno)));
2334       return true;
2335     }
2336
2337   /* We need to deal with constants that would be legitimate
2338      immediate_operands but not legitimate move_operands.  */
2339   if (CONSTANT_P (src) && !move_operand (src, mode))
2340     {
2341       mips_legitimize_const_move (mode, dest, src);
2342       set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (src));
2343       return true;
2344     }
2345   return false;
2346 }
2347 \f
2348 /* We need a lot of little routines to check constant values on the
2349    mips16.  These are used to figure out how long the instruction will
2350    be.  It would be much better to do this using constraints, but
2351    there aren't nearly enough letters available.  */
2352
2353 static int
2354 m16_check_op (rtx op, int low, int high, int mask)
2355 {
2356   return (GET_CODE (op) == CONST_INT
2357           && INTVAL (op) >= low
2358           && INTVAL (op) <= high
2359           && (INTVAL (op) & mask) == 0);
2360 }
2361
2362 int
2363 m16_uimm3_b (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2364 {
2365   return m16_check_op (op, 0x1, 0x8, 0);
2366 }
2367
2368 int
2369 m16_simm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2370 {
2371   return m16_check_op (op, - 0x8, 0x7, 0);
2372 }
2373
2374 int
2375 m16_nsimm4_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2376 {
2377   return m16_check_op (op, - 0x7, 0x8, 0);
2378 }
2379
2380 int
2381 m16_simm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2382 {
2383   return m16_check_op (op, - 0x10, 0xf, 0);
2384 }
2385
2386 int
2387 m16_nsimm5_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2388 {
2389   return m16_check_op (op, - 0xf, 0x10, 0);
2390 }
2391
2392 int
2393 m16_uimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2394 {
2395   return m16_check_op (op, (- 0x10) << 2, 0xf << 2, 3);
2396 }
2397
2398 int
2399 m16_nuimm5_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2400 {
2401   return m16_check_op (op, (- 0xf) << 2, 0x10 << 2, 3);
2402 }
2403
2404 int
2405 m16_simm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2406 {
2407   return m16_check_op (op, - 0x80, 0x7f, 0);
2408 }
2409
2410 int
2411 m16_nsimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2412 {
2413   return m16_check_op (op, - 0x7f, 0x80, 0);
2414 }
2415
2416 int
2417 m16_uimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2418 {
2419   return m16_check_op (op, 0x0, 0xff, 0);
2420 }
2421
2422 int
2423 m16_nuimm8_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2424 {
2425   return m16_check_op (op, - 0xff, 0x0, 0);
2426 }
2427
2428 int
2429 m16_uimm8_m1_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2430 {
2431   return m16_check_op (op, - 0x1, 0xfe, 0);
2432 }
2433
2434 int
2435 m16_uimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2436 {
2437   return m16_check_op (op, 0x0, 0xff << 2, 3);
2438 }
2439
2440 int
2441 m16_nuimm8_4 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2442 {
2443   return m16_check_op (op, (- 0xff) << 2, 0x0, 3);
2444 }
2445
2446 int
2447 m16_simm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2448 {
2449   return m16_check_op (op, (- 0x80) << 3, 0x7f << 3, 7);
2450 }
2451
2452 int
2453 m16_nsimm8_8 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2454 {
2455   return m16_check_op (op, (- 0x7f) << 3, 0x80 << 3, 7);
2456 }
2457 \f
2458 static bool
2459 mips_rtx_costs (rtx x, int code, int outer_code, int *total)
2460 {
2461   enum machine_mode mode = GET_MODE (x);
2462   bool float_mode_p = FLOAT_MODE_P (mode);
2463
2464   switch (code)
2465     {
2466     case CONST_INT:
2467       if (TARGET_MIPS16)
2468         {
2469           /* A number between 1 and 8 inclusive is efficient for a shift.
2470              Otherwise, we will need an extended instruction.  */
2471           if ((outer_code) == ASHIFT || (outer_code) == ASHIFTRT
2472               || (outer_code) == LSHIFTRT)
2473             {
2474               if (INTVAL (x) >= 1 && INTVAL (x) <= 8)
2475                 *total = 0;
2476               else
2477                 *total = COSTS_N_INSNS (1);
2478               return true;
2479             }
2480
2481           /* We can use cmpi for an xor with an unsigned 16 bit value.  */
2482           if ((outer_code) == XOR
2483               && INTVAL (x) >= 0 && INTVAL (x) < 0x10000)
2484             {
2485               *total = 0;
2486               return true;
2487             }
2488
2489           /* We may be able to use slt or sltu for a comparison with a
2490              signed 16 bit value.  (The boundary conditions aren't quite
2491              right, but this is just a heuristic anyhow.)  */
2492           if (((outer_code) == LT || (outer_code) == LE
2493                || (outer_code) == GE || (outer_code) == GT
2494                || (outer_code) == LTU || (outer_code) == LEU
2495                || (outer_code) == GEU || (outer_code) == GTU)
2496               && INTVAL (x) >= -0x8000 && INTVAL (x) < 0x8000)
2497             {
2498               *total = 0;
2499               return true;
2500             }
2501
2502           /* Equality comparisons with 0 are cheap.  */
2503           if (((outer_code) == EQ || (outer_code) == NE)
2504               && INTVAL (x) == 0)
2505             {
2506               *total = 0;
2507               return true;
2508             }
2509
2510           /* Constants in the range 0...255 can be loaded with an unextended
2511              instruction.  They are therefore as cheap as a register move.
2512
2513              Given the choice between "li R1,0...255" and "move R1,R2"
2514              (where R2 is a known constant), it is usually better to use "li",
2515              since we do not want to unnecessarily extend the lifetime
2516              of R2.  */
2517           if (outer_code == SET
2518               && INTVAL (x) >= 0
2519               && INTVAL (x) < 256)
2520             {
2521               *total = 0;
2522               return true;
2523             }
2524         }
2525       else
2526         {
2527           /* These can be used anywhere. */
2528           *total = 0;
2529           return true;
2530         }
2531
2532       /* Otherwise fall through to the handling below because
2533          we'll need to construct the constant.  */
2534
2535     case CONST:
2536     case SYMBOL_REF:
2537     case LABEL_REF:
2538     case CONST_DOUBLE:
2539       if (LEGITIMATE_CONSTANT_P (x))
2540         {
2541           *total = COSTS_N_INSNS (1);
2542           return true;
2543         }
2544       else
2545         {
2546           /* The value will need to be fetched from the constant pool.  */
2547           *total = CONSTANT_POOL_COST;
2548           return true;
2549         }
2550
2551     case MEM:
2552       {
2553         /* If the address is legitimate, return the number of
2554            instructions it needs, otherwise use the default handling.  */
2555         int n = mips_address_insns (XEXP (x, 0), GET_MODE (x));
2556         if (n > 0)
2557           {
2558             *total = COSTS_N_INSNS (n + 1);
2559             return true;
2560           }
2561         return false;
2562       }
2563
2564     case FFS:
2565       *total = COSTS_N_INSNS (6);
2566       return true;
2567
2568     case NOT:
2569       *total = COSTS_N_INSNS ((mode == DImode && !TARGET_64BIT) ? 2 : 1);
2570       return true;
2571
2572     case AND:
2573     case IOR:
2574     case XOR:
2575       if (mode == DImode && !TARGET_64BIT)
2576         {
2577           *total = COSTS_N_INSNS (2);
2578           return true;
2579         }
2580       return false;
2581
2582     case ASHIFT:
2583     case ASHIFTRT:
2584     case LSHIFTRT:
2585       if (mode == DImode && !TARGET_64BIT)
2586         {
2587           *total = COSTS_N_INSNS ((GET_CODE (XEXP (x, 1)) == CONST_INT)
2588                                   ? 4 : 12);
2589           return true;
2590         }
2591       return false;
2592
2593     case ABS:
2594       if (float_mode_p)
2595         *total = COSTS_N_INSNS (1);
2596       else
2597         *total = COSTS_N_INSNS (4);
2598       return true;
2599
2600     case LO_SUM:
2601       *total = COSTS_N_INSNS (1);
2602       return true;
2603
2604     case PLUS:
2605     case MINUS:
2606       if (float_mode_p)
2607         {
2608           *total = mips_cost->fp_add;
2609           return true;
2610         }
2611
2612       else if (mode == DImode && !TARGET_64BIT)
2613         {
2614           *total = COSTS_N_INSNS (4);
2615           return true;
2616         }
2617       return false;
2618
2619     case NEG:
2620       if (mode == DImode && !TARGET_64BIT)
2621         {
2622           *total = COSTS_N_INSNS (4);
2623           return true;
2624         }
2625       return false;
2626
2627     case MULT:
2628       if (mode == SFmode)
2629         *total = mips_cost->fp_mult_sf;
2630
2631       else if (mode == DFmode)
2632         *total = mips_cost->fp_mult_df;
2633
2634       else if (mode == SImode)
2635         *total = mips_cost->int_mult_si;
2636
2637       else
2638         *total = mips_cost->int_mult_di;
2639
2640       return true;
2641
2642     case DIV:
2643     case MOD:
2644       if (float_mode_p)
2645         {
2646           if (mode == SFmode)
2647             *total = mips_cost->fp_div_sf;
2648           else
2649             *total = mips_cost->fp_div_df;
2650
2651           return true;
2652         }
2653       /* Fall through.  */
2654
2655     case UDIV:
2656     case UMOD:
2657       if (mode == DImode)
2658         *total = mips_cost->int_div_di;
2659       else
2660         *total = mips_cost->int_div_si;
2661
2662       return true;
2663
2664     case SIGN_EXTEND:
2665       /* A sign extend from SImode to DImode in 64 bit mode is often
2666          zero instructions, because the result can often be used
2667          directly by another instruction; we'll call it one.  */
2668       if (TARGET_64BIT && mode == DImode
2669           && GET_MODE (XEXP (x, 0)) == SImode)
2670         *total = COSTS_N_INSNS (1);
2671       else
2672         *total = COSTS_N_INSNS (2);
2673       return true;
2674
2675     case ZERO_EXTEND:
2676       if (TARGET_64BIT && mode == DImode
2677           && GET_MODE (XEXP (x, 0)) == SImode)
2678         *total = COSTS_N_INSNS (2);
2679       else
2680         *total = COSTS_N_INSNS (1);
2681       return true;
2682
2683     case FLOAT:
2684     case UNSIGNED_FLOAT:
2685     case FIX:
2686     case FLOAT_EXTEND:
2687     case FLOAT_TRUNCATE:
2688     case SQRT:
2689       *total = mips_cost->fp_add;
2690       return true;
2691
2692     default:
2693       return false;
2694     }
2695 }
2696
2697 /* Provide the costs of an addressing mode that contains ADDR.
2698    If ADDR is not a valid address, its cost is irrelevant.  */
2699
2700 static int
2701 mips_address_cost (rtx addr)
2702 {
2703   return mips_address_insns (addr, SImode);
2704 }
2705 \f
2706 /* Return one word of double-word value OP, taking into account the fixed
2707    endianness of certain registers.  HIGH_P is true to select the high part,
2708    false to select the low part.  */
2709
2710 rtx
2711 mips_subword (rtx op, int high_p)
2712 {
2713   unsigned int byte;
2714   enum machine_mode mode;
2715
2716   mode = GET_MODE (op);
2717   if (mode == VOIDmode)
2718     mode = DImode;
2719
2720   if (TARGET_BIG_ENDIAN ? !high_p : high_p)
2721     byte = UNITS_PER_WORD;
2722   else
2723     byte = 0;
2724
2725   if (REG_P (op))
2726     {
2727       if (FP_REG_P (REGNO (op)))
2728         return gen_rtx_REG (word_mode, high_p ? REGNO (op) + 1 : REGNO (op));
2729       if (ACC_HI_REG_P (REGNO (op)))
2730         return gen_rtx_REG (word_mode, high_p ? REGNO (op) : REGNO (op) + 1);
2731     }
2732
2733   if (MEM_P (op))
2734     return mips_rewrite_small_data (adjust_address (op, word_mode, byte));
2735
2736   return simplify_gen_subreg (word_mode, op, mode, byte);
2737 }
2738
2739
2740 /* Return true if a 64-bit move from SRC to DEST should be split into two.  */
2741
2742 bool
2743 mips_split_64bit_move_p (rtx dest, rtx src)
2744 {
2745   if (TARGET_64BIT)
2746     return false;
2747
2748   /* FP->FP moves can be done in a single instruction.  */
2749   if (FP_REG_RTX_P (src) && FP_REG_RTX_P (dest))
2750     return false;
2751
2752   /* Check for floating-point loads and stores.  They can be done using
2753      ldc1 and sdc1 on MIPS II and above.  */
2754   if (mips_isa > 1)
2755     {
2756       if (FP_REG_RTX_P (dest) && MEM_P (src))
2757         return false;
2758       if (FP_REG_RTX_P (src) && MEM_P (dest))
2759         return false;
2760     }
2761   return true;
2762 }
2763
2764
2765 /* Split a 64-bit move from SRC to DEST assuming that
2766    mips_split_64bit_move_p holds.
2767
2768    Moves into and out of FPRs cause some difficulty here.  Such moves
2769    will always be DFmode, since paired FPRs are not allowed to store
2770    DImode values.  The most natural representation would be two separate
2771    32-bit moves, such as:
2772
2773         (set (reg:SI $f0) (mem:SI ...))
2774         (set (reg:SI $f1) (mem:SI ...))
2775
2776    However, the second insn is invalid because odd-numbered FPRs are
2777    not allowed to store independent values.  Use the patterns load_df_low,
2778    load_df_high and store_df_high instead.  */
2779
2780 void
2781 mips_split_64bit_move (rtx dest, rtx src)
2782 {
2783   if (FP_REG_RTX_P (dest))
2784     {
2785       /* Loading an FPR from memory or from GPRs.  */
2786       emit_insn (gen_load_df_low (copy_rtx (dest), mips_subword (src, 0)));
2787       emit_insn (gen_load_df_high (dest, mips_subword (src, 1),
2788                                    copy_rtx (dest)));
2789     }
2790   else if (FP_REG_RTX_P (src))
2791     {
2792       /* Storing an FPR into memory or GPRs.  */
2793       emit_move_insn (mips_subword (dest, 0), mips_subword (src, 0));
2794       emit_insn (gen_store_df_high (mips_subword (dest, 1), src));
2795     }
2796   else
2797     {
2798       /* The operation can be split into two normal moves.  Decide in
2799          which order to do them.  */
2800       rtx low_dest;
2801
2802       low_dest = mips_subword (dest, 0);
2803       if (REG_P (low_dest)
2804           && reg_overlap_mentioned_p (low_dest, src))
2805         {
2806           emit_move_insn (mips_subword (dest, 1), mips_subword (src, 1));
2807           emit_move_insn (low_dest, mips_subword (src, 0));
2808         }
2809       else
2810         {
2811           emit_move_insn (low_dest, mips_subword (src, 0));
2812           emit_move_insn (mips_subword (dest, 1), mips_subword (src, 1));
2813         }
2814     }
2815 }
2816 \f
2817 /* Return the appropriate instructions to move SRC into DEST.  Assume
2818    that SRC is operand 1 and DEST is operand 0.  */
2819
2820 const char *
2821 mips_output_move (rtx dest, rtx src)
2822 {
2823   enum rtx_code dest_code, src_code;
2824   bool dbl_p;
2825
2826   dest_code = GET_CODE (dest);
2827   src_code = GET_CODE (src);
2828   dbl_p = (GET_MODE_SIZE (GET_MODE (dest)) == 8);
2829
2830   if (dbl_p && mips_split_64bit_move_p (dest, src))
2831     return "#";
2832
2833   if ((src_code == REG && GP_REG_P (REGNO (src)))
2834       || (!TARGET_MIPS16 && src == CONST0_RTX (GET_MODE (dest))))
2835     {
2836       if (dest_code == REG)
2837         {
2838           if (GP_REG_P (REGNO (dest)))
2839             return "move\t%0,%z1";
2840
2841           if (MD_REG_P (REGNO (dest)))
2842             return "mt%0\t%z1";
2843
2844           if (DSP_ACC_REG_P (REGNO (dest)))
2845             {
2846               static char retval[] = "mt__\t%z1,%q0";
2847               retval[2] = reg_names[REGNO (dest)][4];
2848               retval[3] = reg_names[REGNO (dest)][5];
2849               return retval;
2850             }
2851
2852           if (FP_REG_P (REGNO (dest)))
2853             return (dbl_p ? "dmtc1\t%z1,%0" : "mtc1\t%z1,%0");
2854
2855           if (ALL_COP_REG_P (REGNO (dest)))
2856             {
2857               static char retval[] = "dmtc_\t%z1,%0";
2858
2859               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
2860               return (dbl_p ? retval : retval + 1);
2861             }
2862         }
2863       if (dest_code == MEM)
2864         return (dbl_p ? "sd\t%z1,%0" : "sw\t%z1,%0");
2865     }
2866   if (dest_code == REG && GP_REG_P (REGNO (dest)))
2867     {
2868       if (src_code == REG)
2869         {
2870           if (DSP_ACC_REG_P (REGNO (src)))
2871             {
2872               static char retval[] = "mf__\t%0,%q1";
2873               retval[2] = reg_names[REGNO (src)][4];
2874               retval[3] = reg_names[REGNO (src)][5];
2875               return retval;
2876             }
2877
2878           if (ST_REG_P (REGNO (src)) && ISA_HAS_8CC)
2879             return "lui\t%0,0x3f80\n\tmovf\t%0,%.,%1";
2880
2881           if (FP_REG_P (REGNO (src)))
2882             return (dbl_p ? "dmfc1\t%0,%1" : "mfc1\t%0,%1");
2883
2884           if (ALL_COP_REG_P (REGNO (src)))
2885             {
2886               static char retval[] = "dmfc_\t%0,%1";
2887
2888               retval[4] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
2889               return (dbl_p ? retval : retval + 1);
2890             }
2891         }
2892
2893       if (src_code == MEM)
2894         return (dbl_p ? "ld\t%0,%1" : "lw\t%0,%1");
2895
2896       if (src_code == CONST_INT)
2897         {
2898           /* Don't use the X format, because that will give out of
2899              range numbers for 64 bit hosts and 32 bit targets.  */
2900           if (!TARGET_MIPS16)
2901             return "li\t%0,%1\t\t\t# %X1";
2902
2903           if (INTVAL (src) >= 0 && INTVAL (src) <= 0xffff)
2904             return "li\t%0,%1";
2905
2906           if (INTVAL (src) < 0 && INTVAL (src) >= -0xffff)
2907             return "#";
2908         }
2909
2910       if (src_code == HIGH)
2911         return "lui\t%0,%h1";
2912
2913       if (CONST_GP_P (src))
2914         return "move\t%0,%1";
2915
2916       if (symbolic_operand (src, VOIDmode))
2917         return (dbl_p ? "dla\t%0,%1" : "la\t%0,%1");
2918     }
2919   if (src_code == REG && FP_REG_P (REGNO (src)))
2920     {
2921       if (dest_code == REG && FP_REG_P (REGNO (dest)))
2922         {
2923           if (GET_MODE (dest) == V2SFmode)
2924             return "mov.ps\t%0,%1";
2925           else
2926             return (dbl_p ? "mov.d\t%0,%1" : "mov.s\t%0,%1");
2927         }
2928
2929       if (dest_code == MEM)
2930         return (dbl_p ? "sdc1\t%1,%0" : "swc1\t%1,%0");
2931     }
2932   if (dest_code == REG && FP_REG_P (REGNO (dest)))
2933     {
2934       if (src_code == MEM)
2935         return (dbl_p ? "ldc1\t%0,%1" : "lwc1\t%0,%1");
2936     }
2937   if (dest_code == REG && ALL_COP_REG_P (REGNO (dest)) && src_code == MEM)
2938     {
2939       static char retval[] = "l_c_\t%0,%1";
2940
2941       retval[1] = (dbl_p ? 'd' : 'w');
2942       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (dest));
2943       return retval;
2944     }
2945   if (dest_code == MEM && src_code == REG && ALL_COP_REG_P (REGNO (src)))
2946     {
2947       static char retval[] = "s_c_\t%1,%0";
2948
2949       retval[1] = (dbl_p ? 'd' : 'w');
2950       retval[3] = COPNUM_AS_CHAR_FROM_REGNUM (REGNO (src));
2951       return retval;
2952     }
2953   gcc_unreachable ();
2954 }
2955 \f
2956 /* Restore $gp from its save slot.  Valid only when using o32 or
2957    o64 abicalls.  */
2958
2959 void
2960 mips_restore_gp (void)
2961 {
2962   rtx address, slot;
2963
2964   gcc_assert (TARGET_ABICALLS && TARGET_OLDABI);
2965
2966   address = mips_add_offset (pic_offset_table_rtx,
2967                              frame_pointer_needed
2968                              ? hard_frame_pointer_rtx
2969                              : stack_pointer_rtx,
2970                              current_function_outgoing_args_size);
2971   slot = gen_rtx_MEM (Pmode, address);
2972
2973   emit_move_insn (pic_offset_table_rtx, slot);
2974   if (!TARGET_EXPLICIT_RELOCS)
2975     emit_insn (gen_blockage ());
2976 }
2977 \f
2978 /* Emit an instruction of the form (set TARGET (CODE OP0 OP1)).  */
2979
2980 static void
2981 mips_emit_binary (enum rtx_code code, rtx target, rtx op0, rtx op1)
2982 {
2983   emit_insn (gen_rtx_SET (VOIDmode, target,
2984                           gen_rtx_fmt_ee (code, GET_MODE (target), op0, op1)));
2985 }
2986
2987 /* Return true if CMP1 is a suitable second operand for relational
2988    operator CODE.  See also the *sCC patterns in mips.md.  */
2989
2990 static bool
2991 mips_relational_operand_ok_p (enum rtx_code code, rtx cmp1)
2992 {
2993   switch (code)
2994     {
2995     case GT:
2996     case GTU:
2997       return reg_or_0_operand (cmp1, VOIDmode);
2998
2999     case GE:
3000     case GEU:
3001       return !TARGET_MIPS16 && cmp1 == const1_rtx;
3002
3003     case LT:
3004     case LTU:
3005       return arith_operand (cmp1, VOIDmode);
3006
3007     case LE:
3008       return sle_operand (cmp1, VOIDmode);
3009
3010     case LEU:
3011       return sleu_operand (cmp1, VOIDmode);
3012
3013     default:
3014       gcc_unreachable ();
3015     }
3016 }
3017
3018 /* Canonicalize LE or LEU comparisons into LT comparisons when
3019    possible to avoid extra instructions or inverting the
3020    comparison.  */
3021
3022 static bool
3023 mips_canonicalize_comparison (enum rtx_code *code, rtx *cmp1, 
3024                               enum machine_mode mode)
3025 {
3026   HOST_WIDE_INT original, plus_one;
3027
3028   if (GET_CODE (*cmp1) != CONST_INT)
3029     return false;
3030   
3031   original = INTVAL (*cmp1);
3032   plus_one = trunc_int_for_mode ((unsigned HOST_WIDE_INT) original + 1, mode);
3033   
3034   switch (*code)
3035     {
3036     case LE:
3037       if (original < plus_one)
3038         {
3039           *code = LT;
3040           *cmp1 = force_reg (mode, GEN_INT (plus_one));
3041           return true;
3042         }
3043       break;
3044       
3045     case LEU:
3046       if (plus_one != 0)
3047         {
3048           *code = LTU;
3049           *cmp1 = force_reg (mode, GEN_INT (plus_one));
3050           return true;
3051         }
3052       break;
3053       
3054     default:
3055       return false;
3056    }
3057   
3058   return false;
3059
3060 }
3061
3062 /* Compare CMP0 and CMP1 using relational operator CODE and store the
3063    result in TARGET.  CMP0 and TARGET are register_operands that have
3064    the same integer mode.  If INVERT_PTR is nonnull, it's OK to set
3065    TARGET to the inverse of the result and flip *INVERT_PTR instead.  */
3066
3067 static void
3068 mips_emit_int_relational (enum rtx_code code, bool *invert_ptr,
3069                           rtx target, rtx cmp0, rtx cmp1)
3070 {
3071   /* First see if there is a MIPS instruction that can do this operation
3072      with CMP1 in its current form. If not, try to canonicalize the
3073      comparison to LT. If that fails, try doing the same for the
3074      inverse operation.  If that also fails, force CMP1 into a register
3075      and try again.  */
3076   if (mips_relational_operand_ok_p (code, cmp1))
3077     mips_emit_binary (code, target, cmp0, cmp1);
3078   else if (mips_canonicalize_comparison (&code, &cmp1, GET_MODE (target)))
3079     mips_emit_binary (code, target, cmp0, cmp1);
3080   else
3081     {
3082       enum rtx_code inv_code = reverse_condition (code);
3083       if (!mips_relational_operand_ok_p (inv_code, cmp1))
3084         {
3085           cmp1 = force_reg (GET_MODE (cmp0), cmp1);
3086           mips_emit_int_relational (code, invert_ptr, target, cmp0, cmp1);
3087         }
3088       else if (invert_ptr == 0)
3089         {
3090           rtx inv_target = gen_reg_rtx (GET_MODE (target));
3091           mips_emit_binary (inv_code, inv_target, cmp0, cmp1);
3092           mips_emit_binary (XOR, target, inv_target, const1_rtx);
3093         }
3094       else
3095         {
3096           *invert_ptr = !*invert_ptr;
3097           mips_emit_binary (inv_code, target, cmp0, cmp1);
3098         }
3099     }
3100 }
3101
3102 /* Return a register that is zero iff CMP0 and CMP1 are equal.
3103    The register will have the same mode as CMP0.  */
3104
3105 static rtx
3106 mips_zero_if_equal (rtx cmp0, rtx cmp1)
3107 {
3108   if (cmp1 == const0_rtx)
3109     return cmp0;
3110
3111   if (uns_arith_operand (cmp1, VOIDmode))
3112     return expand_binop (GET_MODE (cmp0), xor_optab,
3113                          cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3114
3115   return expand_binop (GET_MODE (cmp0), sub_optab,
3116                        cmp0, cmp1, 0, 0, OPTAB_DIRECT);
3117 }
3118
3119 /* Convert *CODE into a code that can be used in a floating-point
3120    scc instruction (c.<cond>.<fmt>).  Return true if the values of
3121    the condition code registers will be inverted, with 0 indicating
3122    that the condition holds.  */
3123
3124 static bool
3125 mips_reverse_fp_cond_p (enum rtx_code *code)
3126 {
3127   switch (*code)
3128     {
3129     case NE:
3130     case LTGT:
3131     case ORDERED:
3132       *code = reverse_condition_maybe_unordered (*code);
3133       return true;
3134
3135     default:
3136       return false;
3137     }
3138 }
3139
3140 /* Convert a comparison into something that can be used in a branch or
3141    conditional move.  cmp_operands[0] and cmp_operands[1] are the values
3142    being compared and *CODE is the code used to compare them.
3143
3144    Update *CODE, *OP0 and *OP1 so that they describe the final comparison.
3145    If NEED_EQ_NE_P, then only EQ/NE comparisons against zero are possible,
3146    otherwise any standard branch condition can be used.  The standard branch
3147    conditions are:
3148
3149       - EQ/NE between two registers.
3150       - any comparison between a register and zero.  */
3151
3152 static void
3153 mips_emit_compare (enum rtx_code *code, rtx *op0, rtx *op1, bool need_eq_ne_p)
3154 {
3155   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) == MODE_INT)
3156     {
3157       if (!need_eq_ne_p && cmp_operands[1] == const0_rtx)
3158         {
3159           *op0 = cmp_operands[0];
3160           *op1 = cmp_operands[1];
3161         }
3162       else if (*code == EQ || *code == NE)
3163         {
3164           if (need_eq_ne_p)
3165             {
3166               *op0 = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3167               *op1 = const0_rtx;
3168             }
3169           else
3170             {
3171               *op0 = cmp_operands[0];
3172               *op1 = force_reg (GET_MODE (*op0), cmp_operands[1]);
3173             }
3174         }
3175       else
3176         {
3177           /* The comparison needs a separate scc instruction.  Store the
3178              result of the scc in *OP0 and compare it against zero.  */
3179           bool invert = false;
3180           *op0 = gen_reg_rtx (GET_MODE (cmp_operands[0]));
3181           *op1 = const0_rtx;
3182           mips_emit_int_relational (*code, &invert, *op0,
3183                                     cmp_operands[0], cmp_operands[1]);
3184           *code = (invert ? EQ : NE);
3185         }
3186     }
3187   else
3188     {
3189       enum rtx_code cmp_code;
3190
3191       /* Floating-point tests use a separate c.cond.fmt comparison to
3192          set a condition code register.  The branch or conditional move
3193          will then compare that register against zero.
3194
3195          Set CMP_CODE to the code of the comparison instruction and
3196          *CODE to the code that the branch or move should use.  */
3197       cmp_code = *code;
3198       *code = mips_reverse_fp_cond_p (&cmp_code) ? EQ : NE;
3199       *op0 = (ISA_HAS_8CC
3200               ? gen_reg_rtx (CCmode)
3201               : gen_rtx_REG (CCmode, FPSW_REGNUM));
3202       *op1 = const0_rtx;
3203       mips_emit_binary (cmp_code, *op0, cmp_operands[0], cmp_operands[1]);
3204     }
3205 }
3206 \f
3207 /* Try comparing cmp_operands[0] and cmp_operands[1] using rtl code CODE.
3208    Store the result in TARGET and return true if successful.
3209
3210    On 64-bit targets, TARGET may be wider than cmp_operands[0].  */
3211
3212 bool
3213 mips_emit_scc (enum rtx_code code, rtx target)
3214 {
3215   if (GET_MODE_CLASS (GET_MODE (cmp_operands[0])) != MODE_INT)
3216     return false;
3217
3218   target = gen_lowpart (GET_MODE (cmp_operands[0]), target);
3219   if (code == EQ || code == NE)
3220     {
3221       rtx zie = mips_zero_if_equal (cmp_operands[0], cmp_operands[1]);
3222       mips_emit_binary (code, target, zie, const0_rtx);
3223     }
3224   else
3225     mips_emit_int_relational (code, 0, target,
3226                               cmp_operands[0], cmp_operands[1]);
3227   return true;
3228 }
3229
3230 /* Emit the common code for doing conditional branches.
3231    operand[0] is the label to jump to.
3232    The comparison operands are saved away by cmp{si,di,sf,df}.  */
3233
3234 void
3235 gen_conditional_branch (rtx *operands, enum rtx_code code)
3236 {
3237   rtx op0, op1, condition;
3238
3239   mips_emit_compare (&code, &op0, &op1, TARGET_MIPS16);
3240   condition = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
3241   emit_jump_insn (gen_condjump (condition, operands[0]));
3242 }
3243
3244 /* Implement:
3245
3246    (set temp (COND:CCV2 CMP_OP0 CMP_OP1))
3247    (set DEST (unspec [TRUE_SRC FALSE_SRC temp] UNSPEC_MOVE_TF_PS))  */
3248
3249 void
3250 mips_expand_vcondv2sf (rtx dest, rtx true_src, rtx false_src,
3251                        enum rtx_code cond, rtx cmp_op0, rtx cmp_op1)
3252 {
3253   rtx cmp_result;
3254   bool reversed_p;
3255
3256   reversed_p = mips_reverse_fp_cond_p (&cond);
3257   cmp_result = gen_reg_rtx (CCV2mode);
3258   emit_insn (gen_scc_ps (cmp_result,
3259                          gen_rtx_fmt_ee (cond, VOIDmode, cmp_op0, cmp_op1)));
3260   if (reversed_p)
3261     emit_insn (gen_mips_cond_move_tf_ps (dest, false_src, true_src,
3262                                          cmp_result));
3263   else
3264     emit_insn (gen_mips_cond_move_tf_ps (dest, true_src, false_src,
3265                                          cmp_result));
3266 }
3267
3268 /* Emit the common code for conditional moves.  OPERANDS is the array
3269    of operands passed to the conditional move define_expand.  */
3270
3271 void
3272 gen_conditional_move (rtx *operands)
3273 {
3274   enum rtx_code code;
3275   rtx op0, op1;
3276
3277   code = GET_CODE (operands[1]);
3278   mips_emit_compare (&code, &op0, &op1, true);
3279   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
3280                           gen_rtx_IF_THEN_ELSE (GET_MODE (operands[0]),
3281                                                 gen_rtx_fmt_ee (code,
3282                                                                 GET_MODE (op0),
3283                                                                 op0, op1),
3284                                                 operands[2], operands[3])));
3285 }
3286
3287 /* Emit a conditional trap.  OPERANDS is the array of operands passed to
3288    the conditional_trap expander.  */
3289
3290 void
3291 mips_gen_conditional_trap (rtx *operands)
3292 {
3293   rtx op0, op1;
3294   enum rtx_code cmp_code = GET_CODE (operands[0]);
3295   enum machine_mode mode = GET_MODE (cmp_operands[0]);
3296
3297   /* MIPS conditional trap machine instructions don't have GT or LE
3298      flavors, so we must invert the comparison and convert to LT and
3299      GE, respectively.  */
3300   switch (cmp_code)
3301     {
3302     case GT: cmp_code = LT; break;
3303     case LE: cmp_code = GE; break;
3304     case GTU: cmp_code = LTU; break;
3305     case LEU: cmp_code = GEU; break;
3306     default: break;
3307     }
3308   if (cmp_code == GET_CODE (operands[0]))
3309     {
3310       op0 = cmp_operands[0];
3311       op1 = cmp_operands[1];
3312     }
3313   else
3314     {
3315       op0 = cmp_operands[1];
3316       op1 = cmp_operands[0];
3317     }
3318   op0 = force_reg (mode, op0);
3319   if (!arith_operand (op1, mode))
3320     op1 = force_reg (mode, op1);
3321
3322   emit_insn (gen_rtx_TRAP_IF (VOIDmode,
3323                               gen_rtx_fmt_ee (cmp_code, mode, op0, op1),
3324                               operands[1]));
3325 }
3326 \f
3327 /* Load function address ADDR into register DEST.  SIBCALL_P is true
3328    if the address is needed for a sibling call.  */
3329
3330 static void
3331 mips_load_call_address (rtx dest, rtx addr, int sibcall_p)
3332 {
3333   /* If we're generating PIC, and this call is to a global function,
3334      try to allow its address to be resolved lazily.  This isn't
3335      possible for NewABI sibcalls since the value of $gp on entry
3336      to the stub would be our caller's gp, not ours.  */
3337   if (TARGET_EXPLICIT_RELOCS
3338       && !(sibcall_p && TARGET_NEWABI)
3339       && global_got_operand (addr, VOIDmode))
3340     {
3341       rtx high, lo_sum_symbol;
3342
3343       high = mips_unspec_offset_high (dest, pic_offset_table_rtx,
3344                                       addr, SYMBOL_GOTOFF_CALL);
3345       lo_sum_symbol = mips_unspec_address (addr, SYMBOL_GOTOFF_CALL);
3346       if (Pmode == SImode)
3347         emit_insn (gen_load_callsi (dest, high, lo_sum_symbol));
3348       else
3349         emit_insn (gen_load_calldi (dest, high, lo_sum_symbol));
3350     }
3351   else
3352     emit_move_insn (dest, addr);
3353 }
3354
3355
3356 /* Expand a call or call_value instruction.  RESULT is where the
3357    result will go (null for calls), ADDR is the address of the
3358    function, ARGS_SIZE is the size of the arguments and AUX is
3359    the value passed to us by mips_function_arg.  SIBCALL_P is true
3360    if we are expanding a sibling call, false if we're expanding
3361    a normal call.  */
3362
3363 void
3364 mips_expand_call (rtx result, rtx addr, rtx args_size, rtx aux, int sibcall_p)
3365 {
3366   rtx orig_addr, pattern, insn;
3367
3368   orig_addr = addr;
3369   if (!call_insn_operand (addr, VOIDmode))
3370     {
3371       addr = gen_reg_rtx (Pmode);
3372       mips_load_call_address (addr, orig_addr, sibcall_p);
3373     }
3374
3375   if (TARGET_MIPS16
3376       && mips16_hard_float
3377       && build_mips16_call_stub (result, addr, args_size,
3378                                  aux == 0 ? 0 : (int) GET_MODE (aux)))
3379     return;
3380
3381   if (result == 0)
3382     pattern = (sibcall_p
3383                ? gen_sibcall_internal (addr, args_size)
3384                : gen_call_internal (addr, args_size));
3385   else if (GET_CODE (result) == PARALLEL && XVECLEN (result, 0) == 2)
3386     {
3387       rtx reg1, reg2;
3388
3389       reg1 = XEXP (XVECEXP (result, 0, 0), 0);
3390       reg2 = XEXP (XVECEXP (result, 0, 1), 0);
3391       pattern =
3392         (sibcall_p
3393          ? gen_sibcall_value_multiple_internal (reg1, addr, args_size, reg2)
3394          : gen_call_value_multiple_internal (reg1, addr, args_size, reg2));
3395     }
3396   else
3397     pattern = (sibcall_p
3398                ? gen_sibcall_value_internal (result, addr, args_size)
3399                : gen_call_value_internal (result, addr, args_size));
3400
3401   insn = emit_call_insn (pattern);
3402
3403   /* Lazy-binding stubs require $gp to be valid on entry.  */
3404   if (global_got_operand (orig_addr, VOIDmode))
3405     use_reg (&CALL_INSN_FUNCTION_USAGE (insn), pic_offset_table_rtx);
3406 }
3407
3408
3409 /* We can handle any sibcall when TARGET_SIBCALLS is true.  */
3410
3411 static bool
3412 mips_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED,
3413                               tree exp ATTRIBUTE_UNUSED)
3414 {
3415   return TARGET_SIBCALLS;
3416 }
3417 \f
3418 /* Emit code to move general operand SRC into condition-code
3419    register DEST.  SCRATCH is a scratch TFmode float register.
3420    The sequence is:
3421
3422         FP1 = SRC
3423         FP2 = 0.0f
3424         DEST = FP2 < FP1
3425
3426    where FP1 and FP2 are single-precision float registers
3427    taken from SCRATCH.  */
3428
3429 void
3430 mips_emit_fcc_reload (rtx dest, rtx src, rtx scratch)
3431 {
3432   rtx fp1, fp2;
3433
3434   /* Change the source to SFmode.  */
3435   if (MEM_P (src))
3436     src = adjust_address (src, SFmode, 0);
3437   else if (REG_P (src) || GET_CODE (src) == SUBREG)
3438     src = gen_rtx_REG (SFmode, true_regnum (src));
3439
3440   fp1 = gen_rtx_REG (SFmode, REGNO (scratch));
3441   fp2 = gen_rtx_REG (SFmode, REGNO (scratch) + FP_INC);
3442
3443   emit_move_insn (copy_rtx (fp1), src);
3444   emit_move_insn (copy_rtx (fp2), CONST0_RTX (SFmode));
3445   emit_insn (gen_slt_sf (dest, fp2, fp1));
3446 }
3447 \f
3448 /* Emit code to change the current function's return address to
3449    ADDRESS.  SCRATCH is available as a scratch register, if needed.
3450    ADDRESS and SCRATCH are both word-mode GPRs.  */
3451
3452 void
3453 mips_set_return_address (rtx address, rtx scratch)
3454 {
3455   rtx slot_address;
3456
3457   compute_frame_size (get_frame_size ());
3458   gcc_assert ((cfun->machine->frame.mask >> 31) & 1);
3459   slot_address = mips_add_offset (scratch, stack_pointer_rtx,
3460                                   cfun->machine->frame.gp_sp_offset);
3461
3462   emit_move_insn (gen_rtx_MEM (GET_MODE (address), slot_address), address);
3463 }
3464 \f
3465 /* Emit straight-line code to move LENGTH bytes from SRC to DEST.
3466    Assume that the areas do not overlap.  */
3467
3468 static void
3469 mips_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length)
3470 {
3471   HOST_WIDE_INT offset, delta;
3472   unsigned HOST_WIDE_INT bits;
3473   int i;
3474   enum machine_mode mode;
3475   rtx *regs;
3476
3477   /* Work out how many bits to move at a time.  If both operands have
3478      half-word alignment, it is usually better to move in half words.
3479      For instance, lh/lh/sh/sh is usually better than lwl/lwr/swl/swr
3480      and lw/lw/sw/sw is usually better than ldl/ldr/sdl/sdr.
3481      Otherwise move word-sized chunks.  */
3482   if (MEM_ALIGN (src) == BITS_PER_WORD / 2