OSDN Git Service

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