OSDN Git Service

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