OSDN Git Service

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