OSDN Git Service

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