OSDN Git Service

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