OSDN Git Service

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