OSDN Git Service

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