OSDN Git Service

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