OSDN Git Service

2001-07-21 H.J. Lu (hjl@gnu.org)
[pf3gnuchains/gcc-fork.git] / gcc / config / mips / mips.c
1 /* Subroutines for insn-output.c for MIPS
2    Copyright (C) 1989, 1990, 1991, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001 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 GNU CC.
10
11 GNU CC 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 GNU CC 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 GNU CC; 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 /* ??? The TARGET_FP_CALL_32 macros are intended to simulate a 32 bit
27    calling convention in 64 bit mode.  It doesn't work though, and should
28    be replaced with something better designed.  */
29
30 #include "config.h"
31 #include "system.h"
32 #include <signal.h>
33 #include "rtl.h"
34 #include "regs.h"
35 #include "hard-reg-set.h"
36 #include "real.h"
37 #include "insn-config.h"
38 #include "conditions.h"
39 #include "insn-attr.h"
40 #include "recog.h"
41 #include "toplev.h"
42 #include "output.h"
43
44 #include "tree.h"
45 #include "function.h"
46 #include "expr.h"
47 #include "flags.h"
48 #include "reload.h"
49 #include "output.h"
50 #include "tm_p.h"
51 #include "ggc.h"
52 #include "gstab.h"
53 #include "target.h"
54 #include "target-def.h"
55
56 #ifdef __GNU_STAB__
57 #define STAB_CODE_TYPE enum __stab_debug_code
58 #else
59 #define STAB_CODE_TYPE int
60 #endif
61
62 extern tree   lookup_name PARAMS ((tree));
63
64 /* Enumeration for all of the relational tests, so that we can build
65    arrays indexed by the test type, and not worry about the order
66    of EQ, NE, etc. */
67
68 enum internal_test {
69     ITEST_EQ,
70     ITEST_NE,
71     ITEST_GT,
72     ITEST_GE,
73     ITEST_LT,
74     ITEST_LE,
75     ITEST_GTU,
76     ITEST_GEU,
77     ITEST_LTU,
78     ITEST_LEU,
79     ITEST_MAX
80   };
81
82
83 struct constant;
84 static enum internal_test map_test_to_internal_test     PARAMS ((enum rtx_code));
85 static int mips16_simple_memory_operand         PARAMS ((rtx, rtx,
86                                                         enum machine_mode));
87 static int m16_check_op                         PARAMS ((rtx, int, int, int));
88 static void block_move_loop                     PARAMS ((rtx, rtx,
89                                                          unsigned int,
90                                                          int,
91                                                          rtx, rtx));
92 static void block_move_call                     PARAMS ((rtx, rtx, rtx));
93 static FILE *mips_make_temp_file                PARAMS ((void));
94 static void save_restore_insns                  PARAMS ((int, rtx,
95                                                         long, FILE *));
96 static void mips16_output_gp_offset             PARAMS ((FILE *, rtx));
97 static void mips16_fp_args                      PARAMS ((FILE *, int, int));
98 static void build_mips16_function_stub          PARAMS ((FILE *));
99 static void mips16_optimize_gp                  PARAMS ((rtx));
100 static rtx add_constant                         PARAMS ((struct constant **,
101                                                         rtx,
102                                                         enum machine_mode));
103 static void dump_constants                      PARAMS ((struct constant *,
104                                                         rtx));
105 static rtx mips_find_symbol                     PARAMS ((rtx));
106 static void abort_with_insn                     PARAMS ((rtx, const char *))
107   ATTRIBUTE_NORETURN;
108 static int symbolic_expression_p                PARAMS ((rtx));
109 static void mips_add_gc_roots                   PARAMS ((void));
110 static void mips_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
111 static void mips_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
112 static enum processor_type mips_parse_cpu       PARAMS ((const char *));
113
114 /* Global variables for machine-dependent things.  */
115
116 /* Threshold for data being put into the small data/bss area, instead
117    of the normal data area (references to the small data/bss area take
118    1 instruction, and use the global pointer, references to the normal
119    data area takes 2 instructions).  */
120 int mips_section_threshold = -1;
121
122 /* Count the number of .file directives, so that .loc is up to date.  */
123 int num_source_filenames = 0;
124
125 /* Count the number of sdb related labels are generated (to find block
126    start and end boundaries).  */
127 int sdb_label_count = 0;
128
129 /* Next label # for each statement for Silicon Graphics IRIS systems. */
130 int sym_lineno = 0;
131
132 /* Non-zero if inside of a function, because the stupid MIPS asm can't
133    handle .files inside of functions.  */
134 int inside_function = 0;
135
136 /* Files to separate the text and the data output, so that all of the data
137    can be emitted before the text, which will mean that the assembler will
138    generate smaller code, based on the global pointer.  */
139 FILE *asm_out_data_file;
140 FILE *asm_out_text_file;
141
142 /* Linked list of all externals that are to be emitted when optimizing
143    for the global pointer if they haven't been declared by the end of
144    the program with an appropriate .comm or initialization.  */
145
146 struct extern_list
147 {
148   struct extern_list *next;     /* next external */
149   const char *name;             /* name of the external */
150   int size;                     /* size in bytes */
151 } *extern_head = 0;
152
153 /* Name of the file containing the current function.  */
154 const char *current_function_file = "";
155
156 /* Warning given that Mips ECOFF can't support changing files
157    within a function.  */
158 int file_in_function_warning = FALSE;
159
160 /* Whether to suppress issuing .loc's because the user attempted
161    to change the filename within a function.  */
162 int ignore_line_number = FALSE;
163
164 /* Number of nested .set noreorder, noat, nomacro, and volatile requests.  */
165 int set_noreorder;
166 int set_noat;
167 int set_nomacro;
168 int set_volatile;
169
170 /* The next branch instruction is a branch likely, not branch normal.  */
171 int mips_branch_likely;
172
173 /* Count of delay slots and how many are filled.  */
174 int dslots_load_total;
175 int dslots_load_filled;
176 int dslots_jump_total;
177 int dslots_jump_filled;
178
179 /* # of nops needed by previous insn */
180 int dslots_number_nops;
181
182 /* Number of 1/2/3 word references to data items (ie, not jal's).  */
183 int num_refs[3];
184
185 /* registers to check for load delay */
186 rtx mips_load_reg, mips_load_reg2, mips_load_reg3, mips_load_reg4;
187
188 /* Cached operands, and operator to compare for use in set/branch/trap
189    on condition codes.  */
190 rtx branch_cmp[2];
191
192 /* what type of branch to use */
193 enum cmp_type branch_type;
194
195 /* Number of previously seen half-pic pointers and references.  */
196 static int prev_half_pic_ptrs = 0;
197 static int prev_half_pic_refs = 0;
198
199 /* The target cpu for code generation.  */
200 enum processor_type mips_arch;
201
202 /* The target cpu for optimization and scheduling.  */
203 enum processor_type mips_tune;
204
205 /* which instruction set architecture to use.  */
206 int mips_isa;
207
208 #ifdef MIPS_ABI_DEFAULT
209 /* Which ABI to use.  This is defined to a constant in mips.h if the target
210    doesn't support multiple ABIs.  */
211 int mips_abi;
212 #endif
213
214 /* Strings to hold which cpu and instruction set architecture to use.  */
215 const char *mips_cpu_string;    /* for -mcpu=<xxx> */
216 const char *mips_arch_string;   /* for -march=<xxx> */
217 const char *mips_tune_string;   /* for -mtune=<xxx> */
218 const char *mips_isa_string;    /* for -mips{1,2,3,4} */
219 const char *mips_abi_string;    /* for -mabi={32,n32,64,eabi} */
220
221 /* Whether we are generating mips16 code.  This is a synonym for
222    TARGET_MIPS16, and exists for use as an attribute.  */
223 int mips16;
224
225 /* This variable is set by -mno-mips16.  We only care whether
226    -mno-mips16 appears or not, and using a string in this fashion is
227    just a way to avoid using up another bit in target_flags.  */
228 const char *mips_no_mips16_string;
229
230 /* This is only used to determine if an type size setting option was
231    explicitly specified (-mlong64, -mint64, -mlong32).  The specs
232    set this option if such an option is used. */
233 const char *mips_explicit_type_size_string;
234
235 /* Whether we are generating mips16 hard float code.  In mips16 mode
236    we always set TARGET_SOFT_FLOAT; this variable is nonzero if
237    -msoft-float was not specified by the user, which means that we
238    should arrange to call mips32 hard floating point code.  */
239 int mips16_hard_float;
240
241 /* This variable is set by -mentry.  We only care whether -mentry
242    appears or not, and using a string in this fashion is just a way to
243    avoid using up another bit in target_flags.  */
244 const char *mips_entry_string;
245
246 /* Whether we should entry and exit pseudo-ops in mips16 mode.  */
247 int mips_entry;
248
249 /* If TRUE, we split addresses into their high and low parts in the RTL.  */
250 int mips_split_addresses;
251
252 /* Generating calls to position independent functions?  */
253 enum mips_abicalls_type mips_abicalls;
254
255 /* High and low marks for floating point values which we will accept
256    as legitimate constants for LEGITIMATE_CONSTANT_P.  These are
257    initialized in override_options.  */
258 REAL_VALUE_TYPE dfhigh, dflow, sfhigh, sflow;
259
260 /* Mode used for saving/restoring general purpose registers.  */
261 static enum machine_mode gpr_mode;
262
263 /* Array giving truth value on whether or not a given hard register
264    can support a given mode.  */
265 char mips_hard_regno_mode_ok[(int)MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
266
267 /* Current frame information calculated by compute_frame_size.  */
268 struct mips_frame_info current_frame_info;
269
270 /* Zero structure to initialize current_frame_info.  */
271 struct mips_frame_info zero_frame_info;
272
273 /* Temporary filename used to buffer .text until end of program
274    for -mgpopt.  */
275 static char *temp_filename;
276
277 /* Pseudo-reg holding the address of the current function when
278    generating embedded PIC code.  Created by LEGITIMIZE_ADDRESS, used
279    by mips_finalize_pic if it was created.  */
280 rtx embedded_pic_fnaddr_rtx;
281
282 /* The length of all strings seen when compiling for the mips16.  This
283    is used to tell how many strings are in the constant pool, so that
284    we can see if we may have an overflow.  This is reset each time the
285    constant pool is output.  */
286 int mips_string_length;
287
288 /* Pseudo-reg holding the value of $28 in a mips16 function which
289    refers to GP relative global variables.  */
290 rtx mips16_gp_pseudo_rtx;
291
292 /* In mips16 mode, we build a list of all the string constants we see
293    in a particular function.  */
294
295 struct string_constant
296 {
297   struct string_constant *next;
298   const char *label;
299 };
300
301 static struct string_constant *string_constants;
302
303 /* List of all MIPS punctuation characters used by print_operand.  */
304 char mips_print_operand_punct[256];
305
306 /* Map GCC register number to debugger register number.  */
307 int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
308
309 /* Buffer to use to enclose a load/store operation with %{ %} to
310    turn on .set volatile.  */
311 static char volatile_buffer[60];
312
313 /* Hardware names for the registers.  If -mrnames is used, this
314    will be overwritten with mips_sw_reg_names.  */
315
316 char mips_reg_names[][8] =
317 {
318  "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
319  "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
320  "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
321  "$24",  "$25",  "$26",  "$27",  "$28",  "$sp",  "$fp",  "$31",
322  "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
323  "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
324  "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
325  "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
326  "hi",   "lo",   "accum","$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
327  "$fcc5","$fcc6","$fcc7","$rap"
328 };
329
330 /* Mips software names for the registers, used to overwrite the
331    mips_reg_names array.  */
332
333 char mips_sw_reg_names[][8] =
334 {
335   "$zero","$at",  "$v0",  "$v1",  "$a0",  "$a1",  "$a2",  "$a3",
336   "$t0",  "$t1",  "$t2",  "$t3",  "$t4",  "$t5",  "$t6",  "$t7",
337   "$s0",  "$s1",  "$s2",  "$s3",  "$s4",  "$s5",  "$s6",  "$s7",
338   "$t8",  "$t9",  "$k0",  "$k1",  "$gp",  "$sp",  "$fp",  "$ra",
339   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
340   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
341   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
342   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
343   "hi",   "lo",   "accum","$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
344   "$fcc5","$fcc6","$fcc7","$rap"
345 };
346
347 /* Map hard register number to register class */
348 enum reg_class mips_regno_to_class[] =
349 {
350   GR_REGS,      GR_REGS,        M16_NA_REGS,    M16_NA_REGS,
351   M16_REGS,     M16_REGS,       M16_REGS,       M16_REGS,
352   GR_REGS,      GR_REGS,        GR_REGS,        GR_REGS,
353   GR_REGS,      GR_REGS,        GR_REGS,        GR_REGS,
354   M16_NA_REGS,  M16_NA_REGS,    GR_REGS,        GR_REGS,
355   GR_REGS,      GR_REGS,        GR_REGS,        GR_REGS,
356   T_REG,        GR_REGS,        GR_REGS,        GR_REGS,
357   GR_REGS,      GR_REGS,        GR_REGS,        GR_REGS,
358   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
359   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
360   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
361   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
362   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
363   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
364   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
365   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
366   HI_REG,       LO_REG,         HILO_REG,       ST_REGS,
367   ST_REGS,      ST_REGS,        ST_REGS,        ST_REGS,
368   ST_REGS,      ST_REGS,        ST_REGS,        GR_REGS
369 };
370
371 /* Map register constraint character to register class.  */
372 enum reg_class mips_char_to_class[256] =
373 {
374   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
375   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
376   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
377   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
378   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
379   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
380   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
381   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
382   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
383   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
384   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
385   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
386   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
387   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
388   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
389   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
390   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
391   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
392   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
393   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
394   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
395   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
396   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
397   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
398   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
399   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
400   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
401   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
402   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
403   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
404   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
405   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
406   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
407   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
408   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
409   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
410   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
411   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
412   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
413   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
414   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
415   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
416   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
417   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
418   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
419   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
420   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
421   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
422   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
423   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
424   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
425   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
426   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
427   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
428   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
429   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
430   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
431   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
432   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
433   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
434   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
435   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
436   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
437   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
438 };
439 \f
440 /* Initialize the GCC target structure.  */
441 #undef TARGET_ASM_FUNCTION_PROLOGUE
442 #define TARGET_ASM_FUNCTION_PROLOGUE mips_output_function_prologue
443 #undef TARGET_ASM_FUNCTION_EPILOGUE
444 #define TARGET_ASM_FUNCTION_EPILOGUE mips_output_function_epilogue
445
446 struct gcc_target targetm = TARGET_INITIALIZER;
447 \f
448 /* Return truth value of whether OP can be used as an operands
449    where a register or 16 bit unsigned integer is needed.  */
450
451 int
452 uns_arith_operand (op, mode)
453      rtx op;
454      enum machine_mode mode;
455 {
456   if (GET_CODE (op) == CONST_INT && SMALL_INT_UNSIGNED (op))
457     return 1;
458
459   return register_operand (op, mode);
460 }
461
462 /* Return truth value of whether OP can be used as an operands
463    where a 16 bit integer is needed  */
464
465 int
466 arith_operand (op, mode)
467      rtx op;
468      enum machine_mode mode;
469 {
470   if (GET_CODE (op) == CONST_INT && SMALL_INT (op))
471     return 1;
472
473   /* On the mips16, a GP relative value is a signed 16 bit offset.  */
474   if (TARGET_MIPS16 && GET_CODE (op) == CONST && mips16_gp_offset_p (op))
475     return 1;
476
477   return register_operand (op, mode);
478 }
479
480 /* Return truth value of whether OP can be used as an operand in a two
481    address arithmetic insn (such as set 123456,%o4) of mode MODE.  */
482
483 int
484 arith32_operand (op, mode)
485      rtx op;
486      enum machine_mode mode;
487 {
488   if (GET_CODE (op) == CONST_INT)
489     return 1;
490
491   return register_operand (op, mode);
492 }
493
494 /* Return truth value of whether OP is a integer which fits in 16 bits  */
495
496 int
497 small_int (op, mode)
498      rtx op;
499      enum machine_mode mode ATTRIBUTE_UNUSED;
500 {
501   return (GET_CODE (op) == CONST_INT && SMALL_INT (op));
502 }
503
504 /* Return truth value of whether OP is a 32 bit integer which is too big to
505    be loaded with one instruction.  */
506
507 int
508 large_int (op, mode)
509      rtx op;
510      enum machine_mode mode ATTRIBUTE_UNUSED;
511 {
512   HOST_WIDE_INT value;
513
514   if (GET_CODE (op) != CONST_INT)
515     return 0;
516
517   value = INTVAL (op);
518
519   /* ior reg,$r0,value */
520   if ((value & ~ ((HOST_WIDE_INT) 0x0000ffff)) == 0)
521     return 0;
522
523   /* subu reg,$r0,value */
524   if (((unsigned HOST_WIDE_INT) (value + 32768)) <= 32767)
525     return 0;
526
527   /* lui reg,value>>16 */
528   if ((value & 0x0000ffff) == 0)
529     return 0;
530
531   return 1;
532 }
533
534 /* Return truth value of whether OP is a register or the constant 0.
535    In mips16 mode, we only accept a register, since the mips16 does
536    not have $0.  */
537
538 int
539 reg_or_0_operand (op, mode)
540      rtx op;
541      enum machine_mode mode;
542 {
543   switch (GET_CODE (op))
544     {
545     case CONST_INT:
546       if (TARGET_MIPS16)
547         return 0;
548       return INTVAL (op) == 0;
549
550     case CONST_DOUBLE:
551       if (TARGET_MIPS16)
552         return 0;
553       return op == CONST0_RTX (mode);
554
555     case REG:
556     case SUBREG:
557       return register_operand (op, mode);
558
559     default:
560       break;
561     }
562
563   return 0;
564 }
565
566 /* Return truth value of whether OP is a register or the constant 0,
567    even in mips16 mode. */
568
569 int
570 true_reg_or_0_operand (op, mode)
571      rtx op;
572      enum machine_mode mode;
573 {
574   switch (GET_CODE (op))
575     {
576     case CONST_INT:
577       return INTVAL (op) == 0;
578
579     case CONST_DOUBLE:
580       return op == CONST0_RTX (mode);
581
582     case REG:
583     case SUBREG:
584       return register_operand (op, mode);
585
586     default:
587       break;
588     }
589
590   return 0;
591 }
592
593 /* Return truth value if a CONST_DOUBLE is ok to be a legitimate constant.  */
594
595 int
596 mips_const_double_ok (op, mode)
597      rtx op;
598      enum machine_mode mode;
599 {
600   REAL_VALUE_TYPE d;
601
602   if (GET_CODE (op) != CONST_DOUBLE)
603     return 0;
604
605   if (mode == VOIDmode)
606     return 1;
607
608   if (mode != SFmode && mode != DFmode)
609     return 0;
610
611   if (op == CONST0_RTX (mode))
612     return 1;
613
614   /* ??? li.s does not work right with SGI's Irix 6 assembler.  */
615   if (mips_abi != ABI_32 && mips_abi != ABI_O64 && mips_abi != ABI_EABI)
616     return 0;
617
618   REAL_VALUE_FROM_CONST_DOUBLE (d, op);
619
620   if (REAL_VALUE_ISNAN (d))
621     return FALSE;
622
623   if (REAL_VALUE_NEGATIVE (d))
624     d = REAL_VALUE_NEGATE (d);
625
626   if (mode == DFmode)
627     {
628       if (REAL_VALUES_LESS (d, dfhigh)
629           && REAL_VALUES_LESS (dflow, d))
630         return 1;
631     }
632   else
633     {
634       if (REAL_VALUES_LESS (d, sfhigh)
635           && REAL_VALUES_LESS (sflow, d))
636         return 1;
637     }
638
639   return 0;
640 }
641
642 /* Accept the floating point constant 1 in the appropriate mode.  */
643
644 int
645 const_float_1_operand (op, mode)
646      rtx op;
647      enum machine_mode mode;
648 {
649   REAL_VALUE_TYPE d;
650   static REAL_VALUE_TYPE onedf;
651   static REAL_VALUE_TYPE onesf;
652   static int one_initialized;
653
654   if (GET_CODE (op) != CONST_DOUBLE
655       || mode != GET_MODE (op)
656       || (mode != DFmode && mode != SFmode))
657     return 0;
658
659   REAL_VALUE_FROM_CONST_DOUBLE (d, op);
660
661   /* We only initialize these values if we need them, since we will
662      never get called unless mips_isa >= 4.  */
663   if (! one_initialized)
664     {
665       onedf = REAL_VALUE_ATOF ("1.0", DFmode);
666       onesf = REAL_VALUE_ATOF ("1.0", SFmode);
667       one_initialized = 1;
668     }
669
670   if (mode == DFmode)
671     return REAL_VALUES_EQUAL (d, onedf);
672   else
673     return REAL_VALUES_EQUAL (d, onesf);
674 }
675
676 /* Return true if a memory load or store of REG plus OFFSET in MODE
677    can be represented in a single word on the mips16.  */
678
679 static int
680 mips16_simple_memory_operand (reg, offset, mode)
681      rtx reg;
682      rtx offset;
683      enum machine_mode mode;
684 {
685   unsigned int size;
686   int off;
687
688   if (mode == BLKmode)
689     {
690       /* We can't tell, because we don't know how the value will
691          eventually be accessed.  Returning 0 here does no great
692          harm; it just prevents some possible instruction scheduling.  */
693       return 0;
694     }
695
696   size = GET_MODE_SIZE (mode);
697
698   if (INTVAL (offset) % size != 0)
699     return 0;
700   if (REGNO (reg) == STACK_POINTER_REGNUM && GET_MODE_SIZE (mode) == 4)
701     off = 0x100;
702   else
703     off = 0x20;
704   if (INTVAL (offset) >= 0 && INTVAL (offset) < (HOST_WIDE_INT)(off * size))
705     return 1;
706   return 0;
707 }
708
709 /* Return truth value if a memory operand fits in a single instruction
710    (ie, register + small offset).  */
711
712 int
713 simple_memory_operand (op, mode)
714      rtx op;
715      enum machine_mode mode;
716 {
717   rtx addr, plus0, plus1;
718
719   /* Eliminate non-memory operations */
720   if (GET_CODE (op) != MEM)
721     return 0;
722
723   /* dword operations really put out 2 instructions, so eliminate them.  */
724   /* ??? This isn't strictly correct.  It is OK to accept multiword modes
725      here, since the length attributes are being set correctly, but only
726      if the address is offsettable.  LO_SUM is not offsettable.  */
727   if (GET_MODE_SIZE (GET_MODE (op)) > (unsigned) UNITS_PER_WORD)
728     return 0;
729
730   /* Decode the address now.  */
731   addr = XEXP (op, 0);
732   switch (GET_CODE (addr))
733     {
734     case REG:
735     case LO_SUM:
736       return 1;
737
738     case CONST_INT:
739       if (TARGET_MIPS16)
740         return 0;
741       return SMALL_INT (addr);
742
743     case PLUS:
744       plus0 = XEXP (addr, 0);
745       plus1 = XEXP (addr, 1);
746       if (GET_CODE (plus0) == REG
747           && GET_CODE (plus1) == CONST_INT && SMALL_INT (plus1)
748           && (! TARGET_MIPS16
749               || mips16_simple_memory_operand (plus0, plus1, mode)))
750         return 1;
751
752       else if (GET_CODE (plus1) == REG
753                && GET_CODE (plus0) == CONST_INT && SMALL_INT (plus0)
754                && (! TARGET_MIPS16
755                    || mips16_simple_memory_operand (plus1, plus0, mode)))
756         return 1;
757
758       else
759         return 0;
760
761 #if 0
762       /* We used to allow small symbol refs here (ie, stuff in .sdata
763          or .sbss), but this causes some bugs in G++.  Also, it won't
764          interfere if the MIPS linker rewrites the store instruction
765          because the function is PIC.  */
766
767     case LABEL_REF:             /* never gp relative */
768       break;
769
770     case CONST:
771       /* If -G 0, we can never have a GP relative memory operation.
772          Also, save some time if not optimizing.  */
773       if (!TARGET_GP_OPT)
774         return 0;
775
776       {
777         rtx offset = const0_rtx;
778         addr = eliminate_constant_term (XEXP (addr, 0), &offset);
779         if (GET_CODE (op) != SYMBOL_REF)
780           return 0;
781
782         /* let's be paranoid.... */
783         if (! SMALL_INT (offset))
784           return 0;
785       }
786
787       /* fall through */
788
789     case SYMBOL_REF:
790       return SYMBOL_REF_FLAG (addr);
791 #endif
792
793       /* This SYMBOL_REF case is for the mips16.  If the above case is
794          reenabled, this one should be merged in.  */
795     case SYMBOL_REF:
796       /* References to the constant pool on the mips16 use a small
797          offset if the function is small.  The only time we care about
798          getting this right is during delayed branch scheduling, so
799          don't need to check until then.  The machine_dependent_reorg
800          function will set the total length of the instructions used
801          in the function in current_frame_info.  If that is small
802          enough, we know for sure that this is a small offset.  It
803          would be better if we could take into account the location of
804          the instruction within the function, but we can't, because we
805          don't know where we are.  */
806       if (TARGET_MIPS16
807           && CONSTANT_POOL_ADDRESS_P (addr)
808           && current_frame_info.insns_len > 0)
809         {
810           long size;
811
812           size = current_frame_info.insns_len + get_pool_size ();
813           if (GET_MODE_SIZE (mode) == 4)
814             return size < 4 * 0x100;
815           else if (GET_MODE_SIZE (mode) == 8)
816             return size < 8 * 0x20;
817           else
818             return 0;
819         }
820
821       return 0;
822
823     default:
824       break;
825     }
826
827   return 0;
828 }
829
830 /* Return nonzero for a memory address that can be used to load or store
831    a doubleword.  */
832
833 int
834 double_memory_operand (op, mode)
835      rtx op;
836      enum machine_mode mode;
837 {
838   if (GET_CODE (op) != MEM
839       || ! memory_operand (op, mode))
840     {
841       /* During reload, we accept a pseudo register if it has an
842          appropriate memory address.  If we don't do this, we will
843          wind up reloading into a register, and then reloading that
844          register from memory, when we could just reload directly from
845          memory.  */
846       if (reload_in_progress
847           && GET_CODE (op) == REG
848           && REGNO (op) >= FIRST_PSEUDO_REGISTER
849           && reg_renumber[REGNO (op)] < 0
850           && reg_equiv_mem[REGNO (op)] != 0
851           && double_memory_operand (reg_equiv_mem[REGNO (op)], mode))
852         return 1;
853
854       /* All reloaded addresses are valid in TARGET_64BIT mode.  This is
855          the same test performed for 'm' in find_reloads.  */
856
857       if (reload_in_progress
858           && TARGET_64BIT
859           && (GET_CODE (op) == MEM
860               || (GET_CODE (op) == REG
861                   && REGNO (op) >= FIRST_PSEUDO_REGISTER
862                   && reg_renumber[REGNO (op)] < 0)))
863         return 1;
864
865       if (reload_in_progress
866           && TARGET_MIPS16
867           && GET_CODE (op) == MEM)
868         {
869           rtx addr;
870
871           addr = XEXP (op, 0);
872
873           /* During reload on the mips16, we accept a large offset
874              from the frame pointer or the stack pointer.  This large
875              address will get reloaded anyhow.  */
876           if (GET_CODE (addr) == PLUS
877               && GET_CODE (XEXP (addr, 0)) == REG
878               && (REGNO (XEXP (addr, 0)) == (unsigned) HARD_FRAME_POINTER_REGNUM
879                   || REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM)
880               && ((GET_CODE (XEXP (addr, 1)) == CONST_INT
881                    && ! SMALL_INT (XEXP (addr, 1)))
882                   || (GET_CODE (XEXP (addr, 1)) == SYMBOL_REF
883                       && CONSTANT_POOL_ADDRESS_P (XEXP (addr, 1)))))
884             return 1;
885
886           /* Similarly, we accept a case where the memory address is
887              itself on the stack, and will be reloaded. */
888           if (GET_CODE (addr) == MEM)
889             {
890               rtx maddr;
891
892               maddr = XEXP (addr, 0);
893               if (GET_CODE (maddr) == PLUS
894                   && GET_CODE (XEXP (maddr, 0)) == REG
895                   && (REGNO (XEXP (maddr, 0)) == (unsigned) HARD_FRAME_POINTER_REGNUM
896                       || REGNO (XEXP (maddr, 0)) == STACK_POINTER_REGNUM)
897                   && ((GET_CODE (XEXP (maddr, 1)) == CONST_INT
898                        && ! SMALL_INT (XEXP (maddr, 1)))
899                       || (GET_CODE (XEXP (maddr, 1)) == SYMBOL_REF
900                           && CONSTANT_POOL_ADDRESS_P (XEXP (maddr, 1)))))
901                 return 1;
902             }
903
904           /* We also accept the same case when we have a 16 bit signed
905              offset mixed in as well.  The large address will get
906              reloaded, and the 16 bit offset will be OK.  */
907           if (GET_CODE (addr) == PLUS
908               && GET_CODE (XEXP (addr, 0)) == MEM
909               && GET_CODE (XEXP (addr, 1)) == CONST_INT
910               && SMALL_INT (XEXP (addr, 1)))
911             {
912               addr = XEXP (XEXP (addr, 0), 0);
913               if (GET_CODE (addr) == PLUS
914                   && GET_CODE (XEXP (addr, 0)) == REG
915                   && (REGNO (XEXP (addr, 0)) == (unsigned) HARD_FRAME_POINTER_REGNUM
916                       || REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM)
917                   && ((GET_CODE (XEXP (addr, 1)) == CONST_INT
918                        && ! SMALL_INT (XEXP (addr, 1)))
919                       || (GET_CODE (XEXP (addr, 1)) == SYMBOL_REF
920                           && CONSTANT_POOL_ADDRESS_P (XEXP (addr, 1)))))
921                 return 1;
922             }
923         }
924
925       return 0;
926     }
927
928   if (TARGET_64BIT)
929     {
930       /* In this case we can use an instruction like sd.  */
931       return 1;
932     }
933
934   /* Make sure that 4 added to the address is a valid memory address.
935      This essentially just checks for overflow in an added constant.  */
936
937   if (CONSTANT_ADDRESS_P (XEXP (op, 0)))
938     return 1;
939
940   op = adjust_address_nv (op, GET_MODE_CLASS (mode) == MODE_INT
941                           ? SImode : SFmode, 4);
942   return memory_address_p (GET_MODE (op), XEXP (op, 0));
943 }
944
945 /* Return nonzero if the code of this rtx pattern is EQ or NE.  */
946
947 int
948 equality_op (op, mode)
949      rtx op;
950      enum machine_mode mode;
951 {
952   if (mode != GET_MODE (op))
953     return 0;
954
955   return GET_CODE (op) == EQ || GET_CODE (op) == NE;
956 }
957
958 /* Return nonzero if the code is a relational operations (EQ, LE, etc.) */
959
960 int
961 cmp_op (op, mode)
962      rtx op;
963      enum machine_mode mode;
964 {
965   if (mode != GET_MODE (op))
966     return 0;
967
968   return GET_RTX_CLASS (GET_CODE (op)) == '<';
969 }
970
971 /* Return nonzero if the code is a relational operation suitable for a
972    conditional trap instructuion (only EQ, NE, LT, LTU, GE, GEU).
973    We need this in the insn that expands `trap_if' in order to prevent
974    combine from erroneously altering the condition.  */
975
976 int
977 trap_cmp_op (op, mode)
978      rtx op;
979      enum machine_mode mode;
980 {
981   if (mode != GET_MODE (op))
982     return 0;
983
984   switch (GET_CODE (op))
985     {
986     case EQ:
987     case NE:
988     case LT:
989     case LTU:
990     case GE:
991     case GEU:
992       return 1;
993
994     default:
995       return 0;
996     }
997 }
998
999 /* Return nonzero if the operand is either the PC or a label_ref.  */
1000
1001 int
1002 pc_or_label_operand (op, mode)
1003      rtx op;
1004      enum machine_mode mode ATTRIBUTE_UNUSED;
1005 {
1006   if (op == pc_rtx)
1007     return 1;
1008
1009   if (GET_CODE (op) == LABEL_REF)
1010     return 1;
1011
1012   return 0;
1013 }
1014
1015 /* Test for a valid operand for a call instruction.
1016    Don't allow the arg pointer register or virtual regs
1017    since they may change into reg + const, which the patterns
1018    can't handle yet.  */
1019
1020 int
1021 call_insn_operand (op, mode)
1022      rtx op;
1023      enum machine_mode mode ATTRIBUTE_UNUSED;
1024 {
1025   return (CONSTANT_ADDRESS_P (op)
1026           || (GET_CODE (op) == REG && op != arg_pointer_rtx
1027               && ! (REGNO (op) >= FIRST_PSEUDO_REGISTER
1028                     && REGNO (op) <= LAST_VIRTUAL_REGISTER)));
1029 }
1030
1031 /* Return nonzero if OPERAND is valid as a source operand for a move
1032    instruction.  */
1033
1034 int
1035 move_operand (op, mode)
1036      rtx op;
1037      enum machine_mode mode;
1038 {
1039   /* Accept any general operand after reload has started; doing so
1040      avoids losing if reload does an in-place replacement of a register
1041      with a SYMBOL_REF or CONST.  */
1042   return (general_operand (op, mode)
1043           && (! (mips_split_addresses && mips_check_split (op, mode))
1044               || reload_in_progress || reload_completed)
1045           && ! (TARGET_MIPS16
1046                 && GET_CODE (op) == SYMBOL_REF
1047                 && ! mips16_constant (op, mode, 1, 0)));
1048 }
1049
1050 /* Return nonzero if OPERAND is valid as a source operand for movdi.
1051    This accepts not only general_operand, but also sign extended
1052    constants and registers.  We need to accept sign extended constants
1053    in case a sign extended register which is used in an expression,
1054    and is equivalent to a constant, is spilled.  */
1055
1056 int
1057 movdi_operand (op, mode)
1058      rtx op;
1059      enum machine_mode mode;
1060 {
1061   if (TARGET_64BIT
1062       && mode == DImode
1063       && GET_CODE (op) == SIGN_EXTEND
1064       && GET_MODE (op) == DImode
1065       && (GET_MODE (XEXP (op, 0)) == SImode
1066           || (GET_CODE (XEXP (op, 0)) == CONST_INT
1067               && GET_MODE (XEXP (op, 0)) == VOIDmode))
1068       && (register_operand (XEXP (op, 0), SImode)
1069           || immediate_operand (XEXP (op, 0), SImode)))
1070     return 1;
1071
1072   return (general_operand (op, mode)
1073           && ! (TARGET_MIPS16
1074                 && GET_CODE (op) == SYMBOL_REF
1075                 && ! mips16_constant (op, mode, 1, 0)));
1076 }
1077
1078 /* Like register_operand, but when in 64 bit mode also accept a sign
1079    extend of a 32 bit register, since the value is known to be already
1080    sign extended.  */
1081
1082 int
1083 se_register_operand (op, mode)
1084      rtx op;
1085      enum machine_mode mode;
1086 {
1087   if (TARGET_64BIT
1088       && mode == DImode
1089       && GET_CODE (op) == SIGN_EXTEND
1090       && GET_MODE (op) == DImode
1091       && GET_MODE (XEXP (op, 0)) == SImode
1092       && register_operand (XEXP (op, 0), SImode))
1093     return 1;
1094
1095   return register_operand (op, mode);
1096 }
1097
1098 /* Like reg_or_0_operand, but when in 64 bit mode also accept a sign
1099    extend of a 32 bit register, since the value is known to be already
1100    sign extended.  */
1101
1102 int
1103 se_reg_or_0_operand (op, mode)
1104      rtx op;
1105      enum machine_mode mode;
1106 {
1107   if (TARGET_64BIT
1108       && mode == DImode
1109       && GET_CODE (op) == SIGN_EXTEND
1110       && GET_MODE (op) == DImode
1111       && GET_MODE (XEXP (op, 0)) == SImode
1112       && register_operand (XEXP (op, 0), SImode))
1113     return 1;
1114
1115   return reg_or_0_operand (op, mode);
1116 }
1117
1118 /* Like uns_arith_operand, but when in 64 bit mode also accept a sign
1119    extend of a 32 bit register, since the value is known to be already
1120    sign extended.  */
1121
1122 int
1123 se_uns_arith_operand (op, mode)
1124      rtx op;
1125      enum machine_mode mode;
1126 {
1127   if (TARGET_64BIT
1128       && mode == DImode
1129       && GET_CODE (op) == SIGN_EXTEND
1130       && GET_MODE (op) == DImode
1131       && GET_MODE (XEXP (op, 0)) == SImode
1132       && register_operand (XEXP (op, 0), SImode))
1133     return 1;
1134
1135   return uns_arith_operand (op, mode);
1136 }
1137
1138 /* Like arith_operand, but when in 64 bit mode also accept a sign
1139    extend of a 32 bit register, since the value is known to be already
1140    sign extended.  */
1141
1142 int
1143 se_arith_operand (op, mode)
1144      rtx op;
1145      enum machine_mode mode;
1146 {
1147   if (TARGET_64BIT
1148       && mode == DImode
1149       && GET_CODE (op) == SIGN_EXTEND
1150       && GET_MODE (op) == DImode
1151       && GET_MODE (XEXP (op, 0)) == SImode
1152       && register_operand (XEXP (op, 0), SImode))
1153     return 1;
1154
1155   return arith_operand (op, mode);
1156 }
1157
1158 /* Like nonmemory_operand, but when in 64 bit mode also accept a sign
1159    extend of a 32 bit register, since the value is known to be already
1160    sign extended.  */
1161
1162 int
1163 se_nonmemory_operand (op, mode)
1164      rtx op;
1165      enum machine_mode mode;
1166 {
1167   if (TARGET_64BIT
1168       && mode == DImode
1169       && GET_CODE (op) == SIGN_EXTEND
1170       && GET_MODE (op) == DImode
1171       && GET_MODE (XEXP (op, 0)) == SImode
1172       && register_operand (XEXP (op, 0), SImode))
1173     return 1;
1174
1175   return nonmemory_operand (op, mode);
1176 }
1177
1178 /* Like nonimmediate_operand, but when in 64 bit mode also accept a
1179    sign extend of a 32 bit register, since the value is known to be
1180    already sign extended.  */
1181
1182 int
1183 se_nonimmediate_operand (op, mode)
1184      rtx op;
1185      enum machine_mode mode;
1186 {
1187   if (TARGET_64BIT
1188       && mode == DImode
1189       && GET_CODE (op) == SIGN_EXTEND
1190       && GET_MODE (op) == DImode
1191       && GET_MODE (XEXP (op, 0)) == SImode
1192       && register_operand (XEXP (op, 0), SImode))
1193     return 1;
1194
1195   return nonimmediate_operand (op, mode);
1196 }
1197
1198 /* Accept any operand that can appear in a mips16 constant table
1199    instruction.  We can't use any of the standard operand functions
1200    because for these instructions we accept values that are not
1201    accepted by LEGITIMATE_CONSTANT, such as arbitrary SYMBOL_REFs.  */
1202
1203 int
1204 consttable_operand (op, mode)
1205      rtx op;
1206      enum machine_mode mode ATTRIBUTE_UNUSED;
1207 {
1208   return CONSTANT_P (op);
1209 }
1210
1211 /* Return nonzero if we split the address into high and low parts.  */
1212
1213 /* ??? We should also handle reg+array somewhere.  We get four
1214    instructions currently, lui %hi/addui %lo/addui reg/lw.  Better is
1215    lui %hi/addui reg/lw %lo.  Fixing GO_IF_LEGITIMATE_ADDRESS to accept
1216    (plus (reg) (symbol_ref)) doesn't work because the SYMBOL_REF is broken
1217    out of the address, then we have 4 instructions to combine.  Perhaps
1218    add a 3->2 define_split for combine.  */
1219
1220 /* ??? We could also split a CONST_INT here if it is a large_int().
1221    However, it doesn't seem to be very useful to have %hi(constant).
1222    We would be better off by doing the masking ourselves and then putting
1223    the explicit high part of the constant in the RTL.  This will give better
1224    optimization.  Also, %hi(constant) needs assembler changes to work.
1225    There is already a define_split that does this.  */
1226
1227 int
1228 mips_check_split (address, mode)
1229      rtx address;
1230      enum machine_mode mode;
1231 {
1232   /* ??? This is the same check used in simple_memory_operand.
1233      We use it here because LO_SUM is not offsettable.  */
1234   if (GET_MODE_SIZE (mode) > (unsigned) UNITS_PER_WORD)
1235     return 0;
1236
1237   if ((GET_CODE (address) == SYMBOL_REF && ! SYMBOL_REF_FLAG (address))
1238       || (GET_CODE (address) == CONST
1239           && GET_CODE (XEXP (XEXP (address, 0), 0)) == SYMBOL_REF
1240           && ! SYMBOL_REF_FLAG (XEXP (XEXP (address, 0), 0)))
1241       || GET_CODE (address) == LABEL_REF)
1242     return 1;
1243
1244   return 0;
1245 }
1246
1247 /* This function is used to implement REG_MODE_OK_FOR_BASE_P.  */
1248
1249 int
1250 mips_reg_mode_ok_for_base_p (reg, mode, strict)
1251      rtx reg;
1252      enum machine_mode mode;
1253      int strict;
1254 {
1255   return (strict
1256           ? REGNO_MODE_OK_FOR_BASE_P (REGNO (reg), mode)
1257           : GP_REG_OR_PSEUDO_NONSTRICT_P (REGNO (reg), mode));
1258 }
1259
1260 /* This function is used to implement GO_IF_LEGITIMATE_ADDRESS.  It
1261    returns a nonzero value if XINSN is a legitimate address for a
1262    memory operand of the indicated MODE.  STRICT is non-zero if this
1263    function is called during reload.  */
1264
1265 int
1266 mips_legitimate_address_p (mode, xinsn, strict)
1267      enum machine_mode mode;
1268      rtx xinsn;
1269      int strict;
1270 {
1271   if (TARGET_DEBUG_B_MODE)
1272     {
1273       GO_PRINTF2 ("\n========== GO_IF_LEGITIMATE_ADDRESS, %sstrict\n",
1274                   strict ? "" : "not ");
1275       GO_DEBUG_RTX (xinsn);
1276     }
1277
1278   /* Check for constant before stripping off SUBREG, so that we don't
1279      accept (subreg (const_int)) which will fail to reload. */
1280   if (CONSTANT_ADDRESS_P (xinsn)
1281       && ! (mips_split_addresses && mips_check_split (xinsn, mode))
1282       && (! TARGET_MIPS16 || mips16_constant (xinsn, mode, 1, 0)))
1283     return 1;
1284
1285   while (GET_CODE (xinsn) == SUBREG)
1286     xinsn = SUBREG_REG (xinsn);
1287
1288   /* The mips16 can only use the stack pointer as a base register when
1289      loading SImode or DImode values.  */
1290   if (GET_CODE (xinsn) == REG
1291       && mips_reg_mode_ok_for_base_p (xinsn, mode, strict))
1292     return 1;
1293
1294   if (GET_CODE (xinsn) == LO_SUM && mips_split_addresses)
1295     {
1296       register rtx xlow0 = XEXP (xinsn, 0);
1297       register rtx xlow1 = XEXP (xinsn, 1);
1298
1299       while (GET_CODE (xlow0) == SUBREG)
1300         xlow0 = SUBREG_REG (xlow0);
1301       if (GET_CODE (xlow0) == REG
1302           && mips_reg_mode_ok_for_base_p (xlow0, mode, strict)
1303           && mips_check_split (xlow1, mode))
1304         return 1;
1305     }
1306
1307   if (GET_CODE (xinsn) == PLUS)
1308     {
1309       register rtx xplus0 = XEXP (xinsn, 0);
1310       register rtx xplus1 = XEXP (xinsn, 1);
1311       register enum rtx_code code0;
1312       register enum rtx_code code1;
1313
1314       while (GET_CODE (xplus0) == SUBREG)
1315         xplus0 = SUBREG_REG (xplus0);
1316       code0 = GET_CODE (xplus0);
1317
1318       while (GET_CODE (xplus1) == SUBREG)
1319         xplus1 = SUBREG_REG (xplus1);
1320       code1 = GET_CODE (xplus1);
1321
1322       /* The mips16 can only use the stack pointer as a base register
1323          when loading SImode or DImode values.  */
1324       if (code0 == REG
1325           && mips_reg_mode_ok_for_base_p (xplus0, mode, strict))
1326         {
1327           if (code1 == CONST_INT && SMALL_INT (xplus1))
1328             return 1;
1329
1330           /* On the mips16, we represent GP relative offsets in RTL.
1331              These are 16 bit signed values, and can serve as register
1332              offsets.  */
1333           if (TARGET_MIPS16
1334               && mips16_gp_offset_p (xplus1))
1335             return 1;
1336
1337           /* For some code sequences, you actually get better code by
1338              pretending that the MIPS supports an address mode of a
1339              constant address + a register, even though the real
1340              machine doesn't support it.  This is because the
1341              assembler can use $r1 to load just the high 16 bits, add
1342              in the register, and fold the low 16 bits into the memory
1343              reference, whereas the compiler generates a 4 instruction
1344              sequence.  On the other hand, CSE is not as effective.
1345              It would be a win to generate the lui directly, but the
1346              MIPS assembler does not have syntax to generate the
1347              appropriate relocation.  */
1348
1349           /* Also accept CONST_INT addresses here, so no else.  */
1350           /* Reject combining an embedded PIC text segment reference
1351              with a register.  That requires an additional
1352              instruction.  */
1353           /* ??? Reject combining an address with a register for the MIPS
1354              64 bit ABI, because the SGI assembler can not handle this.  */
1355           if (!TARGET_DEBUG_A_MODE
1356               && (mips_abi == ABI_32
1357                   || mips_abi == ABI_O64
1358                   || mips_abi == ABI_EABI)
1359               && CONSTANT_ADDRESS_P (xplus1)
1360               && ! mips_split_addresses
1361               && (!TARGET_EMBEDDED_PIC
1362                   || code1 != CONST
1363                   || GET_CODE (XEXP (xplus1, 0)) != MINUS)
1364               /* When assembling for machines with 64 bit registers,
1365                  the assembler will not sign-extend the constant "foo"
1366                  in "la x, foo(x)" */
1367               && (!TARGET_64BIT || (INTVAL (xplus1) > 0))
1368               && !TARGET_MIPS16)
1369             return 1;
1370         }
1371     }
1372
1373   if (TARGET_DEBUG_B_MODE)
1374     GO_PRINTF ("Not a legitimate address\n");
1375
1376   /* The address was not legitimate.  */
1377   return 0;
1378 }
1379
1380 \f
1381 /* We need a lot of little routines to check constant values on the
1382    mips16.  These are used to figure out how long the instruction will
1383    be.  It would be much better to do this using constraints, but
1384    there aren't nearly enough letters available.  */
1385
1386 static int
1387 m16_check_op (op, low, high, mask)
1388      rtx op;
1389      int low;
1390      int high;
1391      int mask;
1392 {
1393   return (GET_CODE (op) == CONST_INT
1394           && INTVAL (op) >= low
1395           && INTVAL (op) <= high
1396           && (INTVAL (op) & mask) == 0);
1397 }
1398
1399 int
1400 m16_uimm3_b (op, mode)
1401      rtx op;
1402      enum machine_mode mode ATTRIBUTE_UNUSED;
1403 {
1404   return m16_check_op (op, 0x1, 0x8, 0);
1405 }
1406
1407 int
1408 m16_simm4_1 (op, mode)
1409      rtx op;
1410      enum machine_mode mode ATTRIBUTE_UNUSED;
1411 {
1412   return m16_check_op (op, - 0x8, 0x7, 0);
1413 }
1414
1415 int
1416 m16_nsimm4_1 (op, mode)
1417      rtx op;
1418      enum machine_mode mode ATTRIBUTE_UNUSED;
1419 {
1420   return m16_check_op (op, - 0x7, 0x8, 0);
1421 }
1422
1423 int
1424 m16_simm5_1 (op, mode)
1425      rtx op;
1426      enum machine_mode mode ATTRIBUTE_UNUSED;
1427 {
1428   return m16_check_op (op, - 0x10, 0xf, 0);
1429 }
1430
1431 int
1432 m16_nsimm5_1 (op, mode)
1433      rtx op;
1434      enum machine_mode mode ATTRIBUTE_UNUSED;
1435 {
1436   return m16_check_op (op, - 0xf, 0x10, 0);
1437 }
1438
1439 int
1440 m16_uimm5_4 (op, mode)
1441      rtx op;
1442      enum machine_mode mode ATTRIBUTE_UNUSED;
1443 {
1444   return m16_check_op (op, (- 0x10) << 2, 0xf << 2, 3);
1445 }
1446
1447 int
1448 m16_nuimm5_4 (op, mode)
1449      rtx op;
1450      enum machine_mode mode ATTRIBUTE_UNUSED;
1451 {
1452   return m16_check_op (op, (- 0xf) << 2, 0x10 << 2, 3);
1453 }
1454
1455 int
1456 m16_simm8_1 (op, mode)
1457      rtx op;
1458      enum machine_mode mode ATTRIBUTE_UNUSED;
1459 {
1460   return m16_check_op (op, - 0x80, 0x7f, 0);
1461 }
1462
1463 int
1464 m16_nsimm8_1 (op, mode)
1465      rtx op;
1466      enum machine_mode mode ATTRIBUTE_UNUSED;
1467 {
1468   return m16_check_op (op, - 0x7f, 0x80, 0);
1469 }
1470
1471 int
1472 m16_uimm8_1 (op, mode)
1473      rtx op;
1474      enum machine_mode mode ATTRIBUTE_UNUSED;
1475 {
1476   return m16_check_op (op, 0x0, 0xff, 0);
1477 }
1478
1479 int
1480 m16_nuimm8_1 (op, mode)
1481      rtx op;
1482      enum machine_mode mode ATTRIBUTE_UNUSED;
1483 {
1484   return m16_check_op (op, - 0xff, 0x0, 0);
1485 }
1486
1487 int
1488 m16_uimm8_m1_1 (op, mode)
1489      rtx op;
1490      enum machine_mode mode ATTRIBUTE_UNUSED;
1491 {
1492   return m16_check_op (op, - 0x1, 0xfe, 0);
1493 }
1494
1495 int
1496 m16_uimm8_4 (op, mode)
1497      rtx op;
1498      enum machine_mode mode ATTRIBUTE_UNUSED;
1499 {
1500   return m16_check_op (op, 0x0, 0xff << 2, 3);
1501 }
1502
1503 int
1504 m16_nuimm8_4 (op, mode)
1505      rtx op;
1506      enum machine_mode mode ATTRIBUTE_UNUSED;
1507 {
1508   return m16_check_op (op, (- 0xff) << 2, 0x0, 3);
1509 }
1510
1511 int
1512 m16_simm8_8 (op, mode)
1513      rtx op;
1514      enum machine_mode mode ATTRIBUTE_UNUSED;
1515 {
1516   return m16_check_op (op, (- 0x80) << 3, 0x7f << 3, 7);
1517 }
1518
1519 int
1520 m16_nsimm8_8 (op, mode)
1521      rtx op;
1522      enum machine_mode mode ATTRIBUTE_UNUSED;
1523 {
1524   return m16_check_op (op, (- 0x7f) << 3, 0x80 << 3, 7);
1525 }
1526
1527 /* References to the string table on the mips16 only use a small
1528    offset if the function is small.  See the comment in the SYMBOL_REF
1529    case in simple_memory_operand.  We can't check for LABEL_REF here,
1530    because the offset is always large if the label is before the
1531    referencing instruction.  */
1532
1533 int
1534 m16_usym8_4 (op, mode)
1535      rtx op;
1536      enum machine_mode mode ATTRIBUTE_UNUSED;
1537 {
1538   if (GET_CODE (op) == SYMBOL_REF
1539       && SYMBOL_REF_FLAG (op)
1540       && current_frame_info.insns_len > 0
1541       && XSTR (op, 0)[0] == '*'
1542       && strncmp (XSTR (op, 0) + 1, LOCAL_LABEL_PREFIX,
1543                   sizeof LOCAL_LABEL_PREFIX - 1) == 0
1544       && (current_frame_info.insns_len + get_pool_size () + mips_string_length
1545           < 4 * 0x100))
1546     {
1547       struct string_constant *l;
1548
1549       /* Make sure this symbol is on thelist of string constants to be
1550          output for this function.  It is possible that it has already
1551          been output, in which case this requires a large offset.  */
1552       for (l = string_constants; l != NULL; l = l->next)
1553         if (strcmp (l->label, XSTR (op, 0)) == 0)
1554           return 1;
1555     }
1556
1557   return 0;
1558 }
1559
1560 int
1561 m16_usym5_4 (op, mode)
1562      rtx op;
1563      enum machine_mode mode ATTRIBUTE_UNUSED;
1564 {
1565   if (GET_CODE (op) == SYMBOL_REF
1566       && SYMBOL_REF_FLAG (op)
1567       && current_frame_info.insns_len > 0
1568       && XSTR (op, 0)[0] == '*'
1569       && strncmp (XSTR (op, 0) + 1, LOCAL_LABEL_PREFIX,
1570                   sizeof LOCAL_LABEL_PREFIX - 1) == 0
1571       && (current_frame_info.insns_len + get_pool_size () + mips_string_length
1572           < 4 * 0x20))
1573     {
1574       struct string_constant *l;
1575
1576       /* Make sure this symbol is on thelist of string constants to be
1577          output for this function.  It is possible that it has already
1578          been output, in which case this requires a large offset.  */
1579       for (l = string_constants; l != NULL; l = l->next)
1580         if (strcmp (l->label, XSTR (op, 0)) == 0)
1581           return 1;
1582     }
1583
1584   return 0;
1585 }
1586 \f
1587 /* Returns an operand string for the given instruction's delay slot,
1588    after updating filled delay slot statistics.
1589
1590    We assume that operands[0] is the target register that is set.
1591
1592    In order to check the next insn, most of this functionality is moved
1593    to FINAL_PRESCAN_INSN, and we just set the global variables that
1594    it needs.  */
1595
1596 /* ??? This function no longer does anything useful, because final_prescan_insn
1597    now will never emit a nop.  */
1598
1599 const char *
1600 mips_fill_delay_slot (ret, type, operands, cur_insn)
1601      const char *ret;           /* normal string to return */
1602      enum delay_type type;      /* type of delay */
1603      rtx operands[];            /* operands to use */
1604      rtx cur_insn;              /* current insn */
1605 {
1606   register rtx set_reg;
1607   register enum machine_mode mode;
1608   register rtx next_insn = cur_insn ? NEXT_INSN (cur_insn) : NULL_RTX;
1609   register int num_nops;
1610
1611   if (type == DELAY_LOAD || type == DELAY_FCMP)
1612     num_nops = 1;
1613
1614   else if (type == DELAY_HILO)
1615     num_nops = 2;
1616
1617   else
1618     num_nops = 0;
1619
1620   /* Make sure that we don't put nop's after labels.  */
1621   next_insn = NEXT_INSN (cur_insn);
1622   while (next_insn != 0 && GET_CODE (next_insn) == NOTE)
1623     next_insn = NEXT_INSN (next_insn);
1624
1625   dslots_load_total += num_nops;
1626   if (TARGET_DEBUG_F_MODE
1627       || !optimize
1628       || type == DELAY_NONE
1629       || operands == 0
1630       || cur_insn == 0
1631       || next_insn == 0
1632       || GET_CODE (next_insn) == CODE_LABEL
1633       || (set_reg = operands[0]) == 0)
1634     {
1635       dslots_number_nops = 0;
1636       mips_load_reg  = 0;
1637       mips_load_reg2 = 0;
1638       mips_load_reg3 = 0;
1639       mips_load_reg4 = 0;
1640       return ret;
1641     }
1642
1643   set_reg = operands[0];
1644   if (set_reg == 0)
1645     return ret;
1646
1647   while (GET_CODE (set_reg) == SUBREG)
1648     set_reg = SUBREG_REG (set_reg);
1649
1650   mode = GET_MODE (set_reg);
1651   dslots_number_nops = num_nops;
1652   mips_load_reg = set_reg;
1653   if (GET_MODE_SIZE (mode)
1654       > (unsigned) (FP_REG_P (REGNO (set_reg)) ? UNITS_PER_FPREG : UNITS_PER_WORD))
1655     mips_load_reg2 = gen_rtx_REG (SImode, REGNO (set_reg) + 1);
1656   else
1657     mips_load_reg2 = 0;
1658
1659   if (type == DELAY_HILO)
1660     {
1661       mips_load_reg3 = gen_rtx_REG (SImode, MD_REG_FIRST);
1662       mips_load_reg4 = gen_rtx_REG (SImode, MD_REG_FIRST+1);
1663     }
1664   else
1665     {
1666       mips_load_reg3 = 0;
1667       mips_load_reg4 = 0;
1668     }
1669
1670   return ret;
1671 }
1672
1673 \f
1674 /* Determine whether a memory reference takes one (based off of the GP
1675    pointer), two (normal), or three (label + reg) instructions, and bump the
1676    appropriate counter for -mstats.  */
1677
1678 void
1679 mips_count_memory_refs (op, num)
1680      rtx op;
1681      int num;
1682 {
1683   int additional = 0;
1684   int n_words = 0;
1685   rtx addr, plus0, plus1;
1686   enum rtx_code code0, code1;
1687   int looping;
1688
1689   if (TARGET_DEBUG_B_MODE)
1690     {
1691       fprintf (stderr, "\n========== mips_count_memory_refs:\n");
1692       debug_rtx (op);
1693     }
1694
1695   /* Skip MEM if passed, otherwise handle movsi of address.  */
1696   addr = (GET_CODE (op) != MEM) ? op : XEXP (op, 0);
1697
1698   /* Loop, going through the address RTL.  */
1699   do
1700     {
1701       looping = FALSE;
1702       switch (GET_CODE (addr))
1703         {
1704         case REG:
1705         case CONST_INT:
1706         case LO_SUM:
1707           break;
1708
1709         case PLUS:
1710           plus0 = XEXP (addr, 0);
1711           plus1 = XEXP (addr, 1);
1712           code0 = GET_CODE (plus0);
1713           code1 = GET_CODE (plus1);
1714
1715           if (code0 == REG)
1716             {
1717               additional++;
1718               addr = plus1;
1719               looping = 1;
1720               continue;
1721             }
1722
1723           if (code0 == CONST_INT)
1724             {
1725               addr = plus1;
1726               looping = 1;
1727               continue;
1728             }
1729
1730           if (code1 == REG)
1731             {
1732               additional++;
1733               addr = plus0;
1734               looping = 1;
1735               continue;
1736             }
1737
1738           if (code1 == CONST_INT)
1739             {
1740               addr = plus0;
1741               looping = 1;
1742               continue;
1743             }
1744
1745           if (code0 == SYMBOL_REF || code0 == LABEL_REF || code0 == CONST)
1746             {
1747               addr = plus0;
1748               looping = 1;
1749               continue;
1750             }
1751
1752           if (code1 == SYMBOL_REF || code1 == LABEL_REF || code1 == CONST)
1753             {
1754               addr = plus1;
1755               looping = 1;
1756               continue;
1757             }
1758
1759           break;
1760
1761         case LABEL_REF:
1762           n_words = 2;          /* always 2 words */
1763           break;
1764
1765         case CONST:
1766           addr = XEXP (addr, 0);
1767           looping = 1;
1768           continue;
1769
1770         case SYMBOL_REF:
1771           n_words = SYMBOL_REF_FLAG (addr) ? 1 : 2;
1772           break;
1773
1774         default:
1775           break;
1776         }
1777     }
1778   while (looping);
1779
1780   if (n_words == 0)
1781     return;
1782
1783   n_words += additional;
1784   if (n_words > 3)
1785     n_words = 3;
1786
1787   num_refs[n_words-1] += num;
1788 }
1789
1790 \f
1791 /* Return RTL for the offset from the current function to the argument.
1792
1793    ??? Which argument is this?  */
1794
1795 rtx
1796 embedded_pic_offset (x)
1797      rtx x;
1798 {
1799   if (embedded_pic_fnaddr_rtx == NULL)
1800     {
1801       rtx seq;
1802
1803       embedded_pic_fnaddr_rtx = gen_reg_rtx (Pmode);
1804
1805       /* Output code at function start to initialize the pseudo-reg.  */
1806       /* ??? We used to do this in FINALIZE_PIC, but that does not work for
1807          inline functions, because it is called after RTL for the function
1808          has been copied.  The pseudo-reg in embedded_pic_fnaddr_rtx however
1809          does not get copied, and ends up not matching the rest of the RTL.
1810          This solution works, but means that we get unnecessary code to
1811          initialize this value every time a function is inlined into another
1812          function.  */
1813       start_sequence ();
1814       emit_insn (gen_get_fnaddr (embedded_pic_fnaddr_rtx,
1815                                  XEXP (DECL_RTL (current_function_decl), 0)));
1816       seq = gen_sequence ();
1817       end_sequence ();
1818       push_topmost_sequence ();
1819       emit_insn_after (seq, get_insns ());
1820       pop_topmost_sequence ();
1821     }
1822
1823   return
1824     gen_rtx_CONST (Pmode,
1825                    gen_rtx_MINUS (Pmode, x,
1826                                   XEXP (DECL_RTL (current_function_decl), 0)));
1827 }
1828
1829 /* Return the appropriate instructions to move one operand to another.  */
1830
1831 const char *
1832 mips_move_1word (operands, insn, unsignedp)
1833      rtx operands[];
1834      rtx insn;
1835      int unsignedp;
1836 {
1837   const char *ret = 0;
1838   rtx op0 = operands[0];
1839   rtx op1 = operands[1];
1840   enum rtx_code code0 = GET_CODE (op0);
1841   enum rtx_code code1 = GET_CODE (op1);
1842   enum machine_mode mode = GET_MODE (op0);
1843   int subreg_offset0 = 0;
1844   int subreg_offset1 = 0;
1845   enum delay_type delay = DELAY_NONE;
1846
1847   while (code0 == SUBREG)
1848     {
1849       subreg_offset0 += subreg_regno_offset (REGNO (SUBREG_REG (op0)),
1850                                              GET_MODE (SUBREG_REG (op0)),
1851                                              SUBREG_BYTE (op0),
1852                                              GET_MODE (op0));
1853       op0 = SUBREG_REG (op0);
1854       code0 = GET_CODE (op0);
1855     }
1856
1857   while (code1 == SUBREG)
1858     {
1859       subreg_offset1 += subreg_regno_offset (REGNO (SUBREG_REG (op1)),
1860                                              GET_MODE (SUBREG_REG (op1)),
1861                                              SUBREG_BYTE (op1),
1862                                              GET_MODE (op1));
1863       op1 = SUBREG_REG (op1);
1864       code1 = GET_CODE (op1);
1865     }
1866
1867   /* For our purposes, a condition code mode is the same as SImode.  */
1868   if (mode == CCmode)
1869     mode = SImode;
1870
1871   if (code0 == REG)
1872     {
1873       int regno0 = REGNO (op0) + subreg_offset0;
1874
1875       if (code1 == REG)
1876         {
1877           int regno1 = REGNO (op1) + subreg_offset1;
1878
1879           /* Just in case, don't do anything for assigning a register
1880              to itself, unless we are filling a delay slot.  */
1881           if (regno0 == regno1 && set_nomacro == 0)
1882             ret = "";
1883
1884           else if (GP_REG_P (regno0))
1885             {
1886               if (GP_REG_P (regno1))
1887                 ret = "move\t%0,%1";
1888
1889               else if (MD_REG_P (regno1))
1890                 {
1891                   delay = DELAY_HILO;
1892                   if (regno1 != HILO_REGNUM)
1893                     ret = "mf%1\t%0";
1894                   else
1895                     ret = "mflo\t%0";
1896                 }
1897
1898               else if (ST_REG_P (regno1) && ISA_HAS_8CC)
1899                 ret = "li\t%0,1\n\tmovf\t%0,%.,%1";
1900
1901               else
1902                 {
1903                   delay = DELAY_LOAD;
1904                   if (FP_REG_P (regno1))
1905                     ret = "mfc1\t%0,%1";
1906
1907                   else if (regno1 == FPSW_REGNUM && ! ISA_HAS_8CC)
1908                     ret = "cfc1\t%0,$31";
1909                 }
1910             }
1911
1912           else if (FP_REG_P (regno0))
1913             {
1914               if (GP_REG_P (regno1))
1915                 {
1916                   delay = DELAY_LOAD;
1917                   ret = "mtc1\t%1,%0";
1918                 }
1919
1920               if (FP_REG_P (regno1))
1921                 ret = "mov.s\t%0,%1";
1922             }
1923
1924           else if (MD_REG_P (regno0))
1925             {
1926               if (GP_REG_P (regno1))
1927                 {
1928                   delay = DELAY_HILO;
1929                   if (regno0 != HILO_REGNUM && ! TARGET_MIPS16)
1930                     ret = "mt%0\t%1";
1931                 }
1932             }
1933
1934           else if (regno0 == FPSW_REGNUM && ! ISA_HAS_8CC)
1935             {
1936               if (GP_REG_P (regno1))
1937                 {
1938                   delay = DELAY_LOAD;
1939                   ret = "ctc1\t%0,$31";
1940                 }
1941             }
1942         }
1943
1944       else if (code1 == MEM)
1945         {
1946           delay = DELAY_LOAD;
1947
1948           if (TARGET_STATS)
1949             mips_count_memory_refs (op1, 1);
1950
1951           if (GP_REG_P (regno0))
1952             {
1953               /* For loads, use the mode of the memory item, instead of the
1954                  target, so zero/sign extend can use this code as well.  */
1955               switch (GET_MODE (op1))
1956                 {
1957                 default:
1958                   break;
1959                 case SFmode:
1960                   ret = "lw\t%0,%1";
1961                   break;
1962                 case SImode:
1963                 case CCmode:
1964                   ret = ((unsignedp && TARGET_64BIT)
1965                          ? "lwu\t%0,%1"
1966                          : "lw\t%0,%1");
1967                   break;
1968                 case HImode:
1969                   ret = (unsignedp) ? "lhu\t%0,%1" : "lh\t%0,%1";
1970                   break;
1971                 case QImode:
1972                   ret = (unsignedp) ? "lbu\t%0,%1" : "lb\t%0,%1";
1973                   break;
1974                 }
1975             }
1976
1977           else if (FP_REG_P (regno0) && (mode == SImode || mode == SFmode))
1978             ret = "l.s\t%0,%1";
1979
1980           if (ret != (char *)0 && MEM_VOLATILE_P (op1))
1981             {
1982               size_t i = strlen (ret);
1983               if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
1984                 abort ();
1985
1986               sprintf (volatile_buffer, "%%{%s%%}", ret);
1987               ret = volatile_buffer;
1988             }
1989         }
1990
1991       else if (code1 == CONST_INT
1992                || (code1 == CONST_DOUBLE
1993                    && GET_MODE (op1) == VOIDmode))
1994         {
1995           if (code1 == CONST_DOUBLE)
1996             {
1997               /* This can happen when storing constants into long long
1998                  bitfields.  Just store the least significant word of
1999                  the value.  */
2000               operands[1] = op1 = GEN_INT (CONST_DOUBLE_LOW (op1));
2001             }
2002
2003           if (INTVAL (op1) == 0 && ! TARGET_MIPS16)
2004             {
2005               if (GP_REG_P (regno0))
2006                 ret = "move\t%0,%z1";
2007
2008               else if (FP_REG_P (regno0))
2009                 {
2010                   delay = DELAY_LOAD;
2011                   ret = "mtc1\t%z1,%0";
2012                 }
2013
2014               else if (MD_REG_P (regno0))
2015                 {
2016                   delay = DELAY_HILO;
2017                   ret = "mt%0\t%.";
2018                 }
2019             }
2020
2021           else if (GP_REG_P (regno0))
2022             {
2023               /* Don't use X format, because that will give out of
2024                  range numbers for 64 bit host and 32 bit target.  */
2025               if (! TARGET_MIPS16)
2026                 ret = "li\t%0,%1\t\t\t# %X1";
2027               else
2028                 {
2029                   if (INTVAL (op1) >= 0 && INTVAL (op1) <= 0xffff)
2030                     ret = "li\t%0,%1";
2031                   else if (INTVAL (op1) < 0 && INTVAL (op1) >= -0xffff)
2032                     ret = "li\t%0,%n1\n\tneg\t%0";
2033                 }
2034             }
2035         }
2036
2037       else if (code1 == CONST_DOUBLE && mode == SFmode)
2038         {
2039           if (op1 == CONST0_RTX (SFmode))
2040             {
2041               if (GP_REG_P (regno0))
2042                 ret = "move\t%0,%.";
2043
2044               else if (FP_REG_P (regno0))
2045                 {
2046                   delay = DELAY_LOAD;
2047                   ret = "mtc1\t%.,%0";
2048                 }
2049             }
2050
2051           else
2052             {
2053               delay = DELAY_LOAD;
2054               ret = "li.s\t%0,%1";
2055             }
2056         }
2057
2058       else if (code1 == LABEL_REF)
2059         {
2060           if (TARGET_STATS)
2061             mips_count_memory_refs (op1, 1);
2062
2063           ret = "la\t%0,%a1";
2064         }
2065
2066       else if (code1 == SYMBOL_REF || code1 == CONST)
2067         {
2068           if (HALF_PIC_P () && CONSTANT_P (op1) && HALF_PIC_ADDRESS_P (op1))
2069             {
2070               rtx offset = const0_rtx;
2071
2072               if (GET_CODE (op1) == CONST)
2073                 op1 = eliminate_constant_term (XEXP (op1, 0), &offset);
2074
2075               if (GET_CODE (op1) == SYMBOL_REF)
2076                 {
2077                   operands[2] = HALF_PIC_PTR (op1);
2078
2079                   if (TARGET_STATS)
2080                     mips_count_memory_refs (operands[2], 1);
2081
2082                   if (INTVAL (offset) == 0)
2083                     {
2084                       delay = DELAY_LOAD;
2085                       ret = (unsignedp && TARGET_64BIT
2086                              ? "lwu\t%0,%2"
2087                              : "lw\t%0,%2");
2088                     }
2089                   else
2090                     {
2091                       dslots_load_total++;
2092                       operands[3] = offset;
2093                       if (unsignedp && TARGET_64BIT)
2094                         ret = (SMALL_INT (offset)
2095                                ? "lwu\t%0,%2%#\n\tadd\t%0,%0,%3"
2096                                : "lwu\t%0,%2%#\n\t%[li\t%@,%3\n\tadd\t%0,%0,%@%]");
2097                       else
2098                         ret = (SMALL_INT (offset)
2099                                ? "lw\t%0,%2%#\n\tadd\t%0,%0,%3"
2100                                : "lw\t%0,%2%#\n\t%[li\t%@,%3\n\tadd\t%0,%0,%@%]");
2101                     }
2102                 }
2103             }
2104           else if (TARGET_MIPS16
2105                    && code1 == CONST
2106                    && GET_CODE (XEXP (op1, 0)) == REG
2107                    && REGNO (XEXP (op1, 0)) == GP_REG_FIRST + 28)
2108             {
2109               /* This case arises on the mips16; see
2110                  mips16_gp_pseudo_reg.  */
2111               ret = "move\t%0,%+";
2112             }
2113           else if (TARGET_MIPS16
2114                    && code1 == SYMBOL_REF
2115                    && SYMBOL_REF_FLAG (op1)
2116                    && (XSTR (op1, 0)[0] != '*'
2117                        || strncmp (XSTR (op1, 0) + 1,
2118                                    LOCAL_LABEL_PREFIX,
2119                                    sizeof LOCAL_LABEL_PREFIX - 1) != 0))
2120             {
2121               /* This can occur when reloading the address of a GP
2122                  relative symbol on the mips16.  */
2123               ret = "move\t%0,%+\n\taddu\t%0,%%gprel(%a1)";
2124             }
2125           else
2126             {
2127               if (TARGET_STATS)
2128                 mips_count_memory_refs (op1, 1);
2129
2130               ret = "la\t%0,%a1";
2131             }
2132         }
2133
2134       else if (code1 == PLUS)
2135         {
2136           rtx add_op0 = XEXP (op1, 0);
2137           rtx add_op1 = XEXP (op1, 1);
2138
2139           if (GET_CODE (XEXP (op1, 1)) == REG
2140               && GET_CODE (XEXP (op1, 0)) == CONST_INT)
2141             add_op0 = XEXP (op1, 1), add_op1 = XEXP (op1, 0);
2142
2143           operands[2] = add_op0;
2144           operands[3] = add_op1;
2145           ret = "add%:\t%0,%2,%3";
2146         }
2147
2148       else if (code1 == HIGH)
2149         {
2150           operands[1] = XEXP (op1, 0);
2151           ret = "lui\t%0,%%hi(%1)";
2152         }
2153     }
2154
2155   else if (code0 == MEM)
2156     {
2157       if (TARGET_STATS)
2158         mips_count_memory_refs (op0, 1);
2159
2160       if (code1 == REG)
2161         {
2162           int regno1 = REGNO (op1) + subreg_offset1;
2163
2164           if (GP_REG_P (regno1))
2165             {
2166               switch (mode)
2167                 {
2168                 case SFmode: ret = "sw\t%1,%0"; break;
2169                 case SImode: ret = "sw\t%1,%0"; break;
2170                 case HImode: ret = "sh\t%1,%0"; break;
2171                 case QImode: ret = "sb\t%1,%0"; break;
2172                 default: break;
2173                 }
2174             }
2175
2176           else if (FP_REG_P (regno1) && (mode == SImode || mode == SFmode))
2177             ret = "s.s\t%1,%0";
2178         }
2179
2180       else if (code1 == CONST_INT && INTVAL (op1) == 0)
2181         {
2182           switch (mode)
2183             {
2184             case SFmode: ret = "sw\t%z1,%0"; break;
2185             case SImode: ret = "sw\t%z1,%0"; break;
2186             case HImode: ret = "sh\t%z1,%0"; break;
2187             case QImode: ret = "sb\t%z1,%0"; break;
2188             default: break;
2189             }
2190         }
2191
2192       else if (code1 == CONST_DOUBLE && op1 == CONST0_RTX (mode))
2193         {
2194           switch (mode)
2195             {
2196             case SFmode: ret = "sw\t%.,%0"; break;
2197             case SImode: ret = "sw\t%.,%0"; break;
2198             case HImode: ret = "sh\t%.,%0"; break;
2199             case QImode: ret = "sb\t%.,%0"; break;
2200             default: break;
2201             }
2202         }
2203
2204       if (ret != 0 && MEM_VOLATILE_P (op0))
2205         {
2206           size_t i = strlen (ret);
2207
2208           if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
2209             abort ();
2210
2211           sprintf (volatile_buffer, "%%{%s%%}", ret);
2212           ret = volatile_buffer;
2213         }
2214     }
2215
2216   if (ret == 0)
2217     {
2218       abort_with_insn (insn, "Bad move");
2219       return 0;
2220     }
2221
2222   if (delay != DELAY_NONE)
2223     return mips_fill_delay_slot (ret, delay, operands, insn);
2224
2225   return ret;
2226 }
2227
2228 \f
2229 /* Return the appropriate instructions to move 2 words */
2230
2231 const char *
2232 mips_move_2words (operands, insn)
2233      rtx operands[];
2234      rtx insn;
2235 {
2236   const char *ret = 0;
2237   rtx op0 = operands[0];
2238   rtx op1 = operands[1];
2239   enum rtx_code code0 = GET_CODE (operands[0]);
2240   enum rtx_code code1 = GET_CODE (operands[1]);
2241   int subreg_offset0 = 0;
2242   int subreg_offset1 = 0;
2243   enum delay_type delay = DELAY_NONE;
2244
2245   while (code0 == SUBREG)
2246     {
2247       subreg_offset0 += subreg_regno_offset (REGNO (SUBREG_REG (op0)),
2248                                              GET_MODE (SUBREG_REG (op0)),
2249                                              SUBREG_BYTE (op0),
2250                                              GET_MODE (op0));
2251       op0 = SUBREG_REG (op0);
2252       code0 = GET_CODE (op0);
2253     }
2254
2255   if (code1 == SIGN_EXTEND)
2256     {
2257       op1 = XEXP (op1, 0);
2258       code1 = GET_CODE (op1);
2259     }
2260
2261   while (code1 == SUBREG)
2262     {
2263       subreg_offset1 += subreg_regno_offset (REGNO (SUBREG_REG (op1)),
2264                                              GET_MODE (SUBREG_REG (op1)),
2265                                              SUBREG_BYTE (op1),
2266                                              GET_MODE (op1));
2267       op1 = SUBREG_REG (op1);
2268       code1 = GET_CODE (op1);
2269     }
2270
2271   /* Sanity check.  */
2272   if (GET_CODE (operands[1]) == SIGN_EXTEND
2273       && code1 != REG
2274       && code1 != CONST_INT
2275       /* The following three can happen as the result of a questionable
2276          cast.  */
2277       && code1 != LABEL_REF
2278       && code1 != SYMBOL_REF
2279       && code1 != CONST)
2280     abort ();
2281
2282   if (code0 == REG)
2283     {
2284       int regno0 = REGNO (op0) + subreg_offset0;
2285
2286       if (code1 == REG)
2287         {
2288           int regno1 = REGNO (op1) + subreg_offset1;
2289
2290           /* Just in case, don't do anything for assigning a register
2291              to itself, unless we are filling a delay slot.  */
2292           if (regno0 == regno1 && set_nomacro == 0)
2293             ret = "";
2294
2295           else if (FP_REG_P (regno0))
2296             {
2297               if (FP_REG_P (regno1))
2298                 ret = "mov.d\t%0,%1";
2299
2300               else
2301                 {
2302                   delay = DELAY_LOAD;
2303                   if (TARGET_FLOAT64)
2304                     {
2305                       if (!TARGET_64BIT)
2306                         abort_with_insn (insn, "Bad move");
2307
2308 #ifdef TARGET_FP_CALL_32
2309                       if (FP_CALL_GP_REG_P (regno1))
2310                         ret = "dsll\t%1,32\n\tor\t%1,%D1\n\tdmtc1\t%1,%0";
2311                       else
2312 #endif
2313                         ret = "dmtc1\t%1,%0";
2314                     }
2315                   else
2316                     ret = "mtc1\t%L1,%0\n\tmtc1\t%M1,%D0";
2317                 }
2318             }
2319
2320           else if (FP_REG_P (regno1))
2321             {
2322               delay = DELAY_LOAD;
2323               if (TARGET_FLOAT64)
2324                 {
2325                   if (!TARGET_64BIT)
2326                     abort_with_insn (insn, "Bad move");
2327
2328 #ifdef TARGET_FP_CALL_32
2329                   if (FP_CALL_GP_REG_P (regno0))
2330                     ret = "dmfc1\t%0,%1\n\tmfc1\t%D0,%1\n\tdsrl\t%0,32";
2331                   else
2332 #endif
2333                     ret = "dmfc1\t%0,%1";
2334                 }
2335               else
2336                 ret = "mfc1\t%L0,%1\n\tmfc1\t%M0,%D1";
2337             }
2338
2339           else if (MD_REG_P (regno0) && GP_REG_P (regno1) && !TARGET_MIPS16)
2340             {
2341               delay = DELAY_HILO;
2342               if (TARGET_64BIT)
2343                 {
2344                   if (regno0 != HILO_REGNUM)
2345                     ret = "mt%0\t%1";
2346                   else if (regno1 == 0)
2347                     ret = "mtlo\t%.\n\tmthi\t%.";
2348                 }
2349               else
2350                 ret = "mthi\t%M1\n\tmtlo\t%L1";
2351             }
2352
2353           else if (GP_REG_P (regno0) && MD_REG_P (regno1))
2354             {
2355               delay = DELAY_HILO;
2356               if (TARGET_64BIT)
2357                 {
2358                   if (regno1 != HILO_REGNUM)
2359                     ret = "mf%1\t%0";
2360                 }
2361               else
2362                 ret = "mfhi\t%M0\n\tmflo\t%L0";
2363             }
2364
2365           else if (TARGET_64BIT)
2366             ret = "move\t%0,%1";
2367
2368           else if (regno0 != (regno1+1))
2369             ret = "move\t%0,%1\n\tmove\t%D0,%D1";
2370
2371           else
2372             ret = "move\t%D0,%D1\n\tmove\t%0,%1";
2373         }
2374
2375       else if (code1 == CONST_DOUBLE)
2376         {
2377           /* Move zero from $0 unless !TARGET_64BIT and recipient
2378              is 64-bit fp reg, in which case generate a constant.  */
2379           if (op1 != CONST0_RTX (GET_MODE (op1))
2380               || (TARGET_FLOAT64 && !TARGET_64BIT && FP_REG_P (regno0)))
2381             {
2382               if (GET_MODE (op1) == DFmode)
2383                 {
2384                   delay = DELAY_LOAD;
2385
2386 #ifdef TARGET_FP_CALL_32
2387                   if (FP_CALL_GP_REG_P (regno0))
2388                     {
2389                       if (TARGET_FLOAT64 && !TARGET_64BIT)
2390                         {
2391                           split_double (op1, operands + 2, operands + 3);
2392                           ret = "li\t%0,%2\n\tli\t%D0,%3";
2393                         }
2394                       else
2395                         ret = "li.d\t%0,%1\n\tdsll\t%D0,%0,32\n\tdsrl\t%D0,32\n\tdsrl\t%0,32";
2396                     }
2397                   else
2398 #endif
2399                     /* GNU as emits 64-bit code for li.d if the ISA is 3
2400                        or higher.  For !TARGET_64BIT && gp registers we
2401                        need to avoid this by using two li instructions
2402                        instead.  */
2403                     if (ISA_HAS_64BIT_REGS
2404                         && ! TARGET_64BIT
2405                         && ! FP_REG_P (regno0))
2406                       {
2407                         split_double (op1, operands + 2, operands + 3);
2408                         ret = "li\t%0,%2\n\tli\t%D0,%3";
2409                       }
2410                     else
2411                       ret = "li.d\t%0,%1";
2412                 }
2413
2414               else if (TARGET_64BIT)
2415                 {
2416                   if (! TARGET_MIPS16)
2417                     ret = "dli\t%0,%1";
2418                 }
2419
2420               else
2421                 {
2422                   split_double (op1, operands + 2, operands + 3);
2423                   ret = "li\t%0,%2\n\tli\t%D0,%3";
2424                 }
2425             }
2426
2427           else
2428             {
2429               if (GP_REG_P (regno0))
2430                 ret = (TARGET_64BIT
2431 #ifdef TARGET_FP_CALL_32
2432                        && ! FP_CALL_GP_REG_P (regno0)
2433 #endif
2434                        ? "move\t%0,%."
2435                        : "move\t%0,%.\n\tmove\t%D0,%.");
2436
2437               else if (FP_REG_P (regno0))
2438                 {
2439                   delay = DELAY_LOAD;
2440                   ret = (TARGET_64BIT
2441                          ? "dmtc1\t%.,%0"
2442                          : "mtc1\t%.,%0\n\tmtc1\t%.,%D0");
2443                 }
2444             }
2445         }
2446
2447       else if (code1 == CONST_INT && INTVAL (op1) == 0 && ! TARGET_MIPS16)
2448         {
2449           if (GP_REG_P (regno0))
2450             ret = (TARGET_64BIT
2451                    ? "move\t%0,%."
2452                    : "move\t%0,%.\n\tmove\t%D0,%.");
2453
2454           else if (FP_REG_P (regno0))
2455             {
2456               delay = DELAY_LOAD;
2457               ret = (TARGET_64BIT
2458                      ? "dmtc1\t%.,%0"
2459                      : (TARGET_FLOAT64
2460                         ? "li.d\t%0,%1"
2461                         : "mtc1\t%.,%0\n\tmtc1\t%.,%D0"));
2462             }
2463           else if (MD_REG_P (regno0))
2464             {
2465               delay = DELAY_HILO;
2466               ret =  (regno0 == HILO_REGNUM
2467                       ? "mtlo\t%.\n\tmthi\t%."
2468                       : "mt%0\t%.\n");
2469             }
2470         }
2471
2472       else if (code1 == CONST_INT && GET_MODE (op0) == DImode
2473                && GP_REG_P (regno0))
2474         {
2475           if (TARGET_64BIT)
2476             {
2477               if (TARGET_MIPS16)
2478                 {
2479                   if (INTVAL (op1) >= 0 && INTVAL (op1) <= 0xffff)
2480                     ret = "li\t%0,%1";
2481                   else if (INTVAL (op1) < 0 && INTVAL (op1) >= -0xffff)
2482                     ret = "li\t%0,%n1\n\tneg\t%0";
2483                 }
2484               else if (GET_CODE (operands[1]) == SIGN_EXTEND)
2485                 ret = "li\t%0,%1\t\t# %X1";
2486               else if (HOST_BITS_PER_WIDE_INT < 64)
2487                 /* We can't use 'X' for negative numbers, because then we won't
2488                    get the right value for the upper 32 bits.  */
2489                 ret = (INTVAL (op1) < 0
2490                        ? "dli\t%0,%1\t\t\t# %X1"
2491                        : "dli\t%0,%X1\t\t# %1");
2492               else
2493                 /* We must use 'X', because otherwise LONG_MIN will print as
2494                    a number that the assembler won't accept.  */
2495                 ret = "dli\t%0,%X1\t\t# %1";
2496             }
2497           else if (HOST_BITS_PER_WIDE_INT < 64)
2498             {
2499               operands[2] = GEN_INT (INTVAL (operands[1]) >= 0 ? 0 : -1);
2500               if (TARGET_MIPS16)
2501                 {
2502                   if (INTVAL (op1) >= 0 && INTVAL (op1) <= 0xffff)
2503                     ret = "li\t%M0,%2\n\tli\t%L0,%1";
2504                   else if (INTVAL (op1) < 0 && INTVAL (op1) >= -0xffff)
2505                     {
2506                       operands[2] = GEN_INT (1);
2507                       ret = "li\t%M0,%2\n\tneg\t%M0\n\tli\t%L0,%n1\n\tneg\t%L0";
2508                     }
2509                 }
2510               else
2511                 ret = "li\t%M0,%2\n\tli\t%L0,%1";
2512             }
2513           else
2514             {
2515               /* We use multiple shifts here, to avoid warnings about out
2516                  of range shifts on 32 bit hosts.  */
2517               operands[2] = GEN_INT (INTVAL (operands[1]) >> 16 >> 16);
2518               operands[1]
2519                 = GEN_INT (INTVAL (operands[1]) << 16 << 16 >> 16 >> 16);
2520               ret = "li\t%M0,%2\n\tli\t%L0,%1";
2521             }
2522         }
2523
2524       else if (code1 == MEM)
2525         {
2526           delay = DELAY_LOAD;
2527
2528           if (TARGET_STATS)
2529             mips_count_memory_refs (op1, 2);
2530
2531           if (FP_REG_P (regno0))
2532             ret = "l.d\t%0,%1";
2533
2534           else if (TARGET_64BIT)
2535             {
2536
2537 #ifdef TARGET_FP_CALL_32
2538               if (FP_CALL_GP_REG_P (regno0))
2539                 ret = (double_memory_operand (op1, GET_MODE (op1))
2540                        ? "lwu\t%0,%1\n\tlwu\t%D0,4+%1"
2541                        : "ld\t%0,%1\n\tdsll\t%D0,%0,32\n\tdsrl\t%D0,32\n\tdsrl\t%0,32");
2542               else
2543 #endif
2544                 ret = "ld\t%0,%1";
2545             }
2546
2547           else if (double_memory_operand (op1, GET_MODE (op1)))
2548             ret = (reg_mentioned_p (op0, op1)
2549                    ? "lw\t%D0,%D1\n\tlw\t%0,%1"
2550                    : "lw\t%0,%1\n\tlw\t%D0,%D1");
2551
2552           if (ret != 0 && MEM_VOLATILE_P (op1))
2553             {
2554               size_t i = strlen (ret);
2555
2556               if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
2557                 abort ();
2558
2559               sprintf (volatile_buffer, "%%{%s%%}", ret);
2560               ret = volatile_buffer;
2561             }
2562         }
2563
2564       else if (code1 == LABEL_REF)
2565         {
2566           if (TARGET_STATS)
2567             mips_count_memory_refs (op1, 2);
2568
2569           if (GET_CODE (operands[1]) == SIGN_EXTEND)
2570             /* We deliberately remove the 'a' from '%1', so that we don't
2571                have to add SIGN_EXTEND support to print_operand_address.
2572                print_operand will just call print_operand_address in this
2573                case, so there is no problem.  */
2574             ret = "la\t%0,%1";
2575           else
2576             ret = "dla\t%0,%a1";
2577         }
2578       else if (code1 == SYMBOL_REF || code1 == CONST)
2579         {
2580           if (TARGET_MIPS16
2581               && code1 == CONST
2582               && GET_CODE (XEXP (op1, 0)) == REG
2583               && REGNO (XEXP (op1, 0)) == GP_REG_FIRST + 28)
2584             {
2585               /* This case arises on the mips16; see
2586                  mips16_gp_pseudo_reg.  */
2587               ret = "move\t%0,%+";
2588             }
2589           else if (TARGET_MIPS16
2590                    && code1 == SYMBOL_REF
2591                    && SYMBOL_REF_FLAG (op1)
2592                    && (XSTR (op1, 0)[0] != '*'
2593                        || strncmp (XSTR (op1, 0) + 1,
2594                                    LOCAL_LABEL_PREFIX,
2595                                    sizeof LOCAL_LABEL_PREFIX - 1) != 0))
2596             {
2597               /* This can occur when reloading the address of a GP
2598                  relative symbol on the mips16.  */
2599               ret = "move\t%0,%+\n\taddu\t%0,%%gprel(%a1)";
2600             }
2601           else
2602             {
2603               if (TARGET_STATS)
2604                 mips_count_memory_refs (op1, 2);
2605
2606               if (GET_CODE (operands[1]) == SIGN_EXTEND)
2607                 /* We deliberately remove the 'a' from '%1', so that we don't
2608                    have to add SIGN_EXTEND support to print_operand_address.
2609                    print_operand will just call print_operand_address in this
2610                    case, so there is no problem.  */
2611                 ret = "la\t%0,%1";
2612               else
2613                 ret = "dla\t%0,%a1";
2614             }
2615         }
2616     }
2617
2618   else if (code0 == MEM)
2619     {
2620       if (code1 == REG)
2621         {
2622           int regno1 = REGNO (op1) + subreg_offset1;
2623
2624           if (FP_REG_P (regno1))
2625             ret = "s.d\t%1,%0";
2626
2627           else if (TARGET_64BIT)
2628             {
2629
2630 #ifdef TARGET_FP_CALL_32
2631               if (FP_CALL_GP_REG_P (regno1))
2632                 ret = "dsll\t%1,32\n\tor\t%1,%D1\n\tsd\t%1,%0";
2633               else
2634 #endif
2635                 ret = "sd\t%1,%0";
2636             }
2637
2638           else if (double_memory_operand (op0, GET_MODE (op0)))
2639             ret = "sw\t%1,%0\n\tsw\t%D1,%D0";
2640         }
2641
2642       else if (((code1 == CONST_INT && INTVAL (op1) == 0)
2643                 || (code1 == CONST_DOUBLE
2644                     && op1 == CONST0_RTX (GET_MODE (op1))))
2645                && (TARGET_64BIT
2646                    || double_memory_operand (op0, GET_MODE (op0))))
2647         {
2648           if (TARGET_64BIT)
2649             ret = "sd\t%.,%0";
2650           else
2651             ret = "sw\t%.,%0\n\tsw\t%.,%D0";
2652         }
2653
2654       if (TARGET_STATS)
2655         mips_count_memory_refs (op0, 2);
2656
2657       if (ret != 0 && MEM_VOLATILE_P (op0))
2658         {
2659           size_t i = strlen (ret);
2660
2661           if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
2662             abort ();
2663
2664           sprintf (volatile_buffer, "%%{%s%%}", ret);
2665           ret = volatile_buffer;
2666         }
2667     }
2668
2669   if (ret == 0)
2670     {
2671       abort_with_insn (insn, "Bad move");
2672       return 0;
2673     }
2674
2675   if (delay != DELAY_NONE)
2676     return mips_fill_delay_slot (ret, delay, operands, insn);
2677
2678   return ret;
2679 }
2680 \f
2681 /* Provide the costs of an addressing mode that contains ADDR.
2682    If ADDR is not a valid address, its cost is irrelevant.  */
2683
2684 int
2685 mips_address_cost (addr)
2686      rtx addr;
2687 {
2688   switch (GET_CODE (addr))
2689     {
2690     case LO_SUM:
2691       return 1;
2692
2693     case LABEL_REF:
2694       return 2;
2695
2696     case CONST:
2697       {
2698         rtx offset = const0_rtx;
2699         addr = eliminate_constant_term (XEXP (addr, 0), &offset);
2700         if (GET_CODE (addr) == LABEL_REF)
2701           return 2;
2702
2703         if (GET_CODE (addr) != SYMBOL_REF)
2704           return 4;
2705
2706         if (! SMALL_INT (offset))
2707           return 2;
2708       }
2709
2710       /* ... fall through ... */
2711
2712     case SYMBOL_REF:
2713       return SYMBOL_REF_FLAG (addr) ? 1 : 2;
2714
2715     case PLUS:
2716       {
2717         register rtx plus0 = XEXP (addr, 0);
2718         register rtx plus1 = XEXP (addr, 1);
2719
2720         if (GET_CODE (plus0) != REG && GET_CODE (plus1) == REG)
2721           plus0 = XEXP (addr, 1), plus1 = XEXP (addr, 0);
2722
2723         if (GET_CODE (plus0) != REG)
2724           break;
2725
2726         switch (GET_CODE (plus1))
2727           {
2728           case CONST_INT:
2729             return SMALL_INT (plus1) ? 1 : 2;
2730
2731           case CONST:
2732           case SYMBOL_REF:
2733           case LABEL_REF:
2734           case HIGH:
2735           case LO_SUM:
2736             return mips_address_cost (plus1) + 1;
2737
2738           default:
2739             break;
2740           }
2741       }
2742
2743     default:
2744       break;
2745     }
2746
2747   return 4;
2748 }
2749
2750 /* Return nonzero if X is an address which needs a temporary register when
2751    reloaded while generating PIC code.  */
2752
2753 int
2754 pic_address_needs_scratch (x)
2755      rtx x;
2756 {
2757   /* An address which is a symbolic plus a non SMALL_INT needs a temp reg.  */
2758   if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
2759       && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
2760       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2761       && ! SMALL_INT (XEXP (XEXP (x, 0), 1)))
2762     return 1;
2763
2764   return 0;
2765 }
2766 \f
2767 /* Make normal rtx_code into something we can index from an array */
2768
2769 static enum internal_test
2770 map_test_to_internal_test (test_code)
2771      enum rtx_code test_code;
2772 {
2773   enum internal_test test = ITEST_MAX;
2774
2775   switch (test_code)
2776     {
2777     case EQ:  test = ITEST_EQ;  break;
2778     case NE:  test = ITEST_NE;  break;
2779     case GT:  test = ITEST_GT;  break;
2780     case GE:  test = ITEST_GE;  break;
2781     case LT:  test = ITEST_LT;  break;
2782     case LE:  test = ITEST_LE;  break;
2783     case GTU: test = ITEST_GTU; break;
2784     case GEU: test = ITEST_GEU; break;
2785     case LTU: test = ITEST_LTU; break;
2786     case LEU: test = ITEST_LEU; break;
2787     default:                    break;
2788     }
2789
2790   return test;
2791 }
2792
2793 \f
2794 /* Generate the code to compare two integer values.  The return value is:
2795    (reg:SI xx)          The pseudo register the comparison is in
2796    0                    No register, generate a simple branch.
2797
2798    ??? This is called with result nonzero by the Scond patterns in
2799    mips.md.  These patterns are called with a target in the mode of
2800    the Scond instruction pattern.  Since this must be a constant, we
2801    must use SImode.  This means that if RESULT is non-zero, it will
2802    always be an SImode register, even if TARGET_64BIT is true.  We
2803    cope with this by calling convert_move rather than emit_move_insn.
2804    This will sometimes lead to an unnecessary extension of the result;
2805    for example:
2806
2807    long long
2808    foo (long long i)
2809    {
2810      return i < 5;
2811    }
2812
2813    */
2814
2815 rtx
2816 gen_int_relational (test_code, result, cmp0, cmp1, p_invert)
2817      enum rtx_code test_code;   /* relational test (EQ, etc) */
2818      rtx result;                /* result to store comp. or 0 if branch */
2819      rtx cmp0;                  /* first operand to compare */
2820      rtx cmp1;                  /* second operand to compare */
2821      int *p_invert;             /* NULL or ptr to hold whether branch needs */
2822                                 /* to reverse its test */
2823 {
2824   struct cmp_info
2825   {
2826     enum rtx_code test_code;    /* code to use in instruction (LT vs. LTU) */
2827     int const_low;              /* low bound of constant we can accept */
2828     int const_high;             /* high bound of constant we can accept */
2829     int const_add;              /* constant to add (convert LE -> LT) */
2830     int reverse_regs;           /* reverse registers in test */
2831     int invert_const;           /* != 0 if invert value if cmp1 is constant */
2832     int invert_reg;             /* != 0 if invert value if cmp1 is register */
2833     int unsignedp;              /* != 0 for unsigned comparisons.  */
2834   };
2835
2836   static struct cmp_info info[ (int)ITEST_MAX ] = {
2837
2838     { XOR,       0,  65535,  0,  0,  0,  0, 0 },        /* EQ  */
2839     { XOR,       0,  65535,  0,  0,  1,  1, 0 },        /* NE  */
2840     { LT,   -32769,  32766,  1,  1,  1,  0, 0 },        /* GT  */
2841     { LT,   -32768,  32767,  0,  0,  1,  1, 0 },        /* GE  */
2842     { LT,   -32768,  32767,  0,  0,  0,  0, 0 },        /* LT  */
2843     { LT,   -32769,  32766,  1,  1,  0,  1, 0 },        /* LE  */
2844     { LTU,  -32769,  32766,  1,  1,  1,  0, 1 },        /* GTU */
2845     { LTU,  -32768,  32767,  0,  0,  1,  1, 1 },        /* GEU */
2846     { LTU,  -32768,  32767,  0,  0,  0,  0, 1 },        /* LTU */
2847     { LTU,  -32769,  32766,  1,  1,  0,  1, 1 },        /* LEU */
2848   };
2849
2850   enum internal_test test;
2851   enum machine_mode mode;
2852   struct cmp_info *p_info;
2853   int branch_p;
2854   int eqne_p;
2855   int invert;
2856   rtx reg;
2857   rtx reg2;
2858
2859   test = map_test_to_internal_test (test_code);
2860   if (test == ITEST_MAX)
2861     abort ();
2862
2863   p_info = &info[(int) test];
2864   eqne_p = (p_info->test_code == XOR);
2865
2866   mode = GET_MODE (cmp0);
2867   if (mode == VOIDmode)
2868     mode = GET_MODE (cmp1);
2869
2870   /* Eliminate simple branches */
2871   branch_p = (result == 0);
2872   if (branch_p)
2873     {
2874       if (GET_CODE (cmp0) == REG || GET_CODE (cmp0) == SUBREG)
2875         {
2876           /* Comparisons against zero are simple branches */
2877           if (GET_CODE (cmp1) == CONST_INT && INTVAL (cmp1) == 0
2878               && (! TARGET_MIPS16 || eqne_p))
2879             return 0;
2880
2881           /* Test for beq/bne.  */
2882           if (eqne_p && ! TARGET_MIPS16)
2883             return 0;
2884         }
2885
2886       /* allocate a pseudo to calculate the value in.  */
2887       result = gen_reg_rtx (mode);
2888     }
2889
2890   /* Make sure we can handle any constants given to us.  */
2891   if (GET_CODE (cmp0) == CONST_INT)
2892     cmp0 = force_reg (mode, cmp0);
2893
2894   if (GET_CODE (cmp1) == CONST_INT)
2895     {
2896       HOST_WIDE_INT value = INTVAL (cmp1);
2897
2898       if (value < p_info->const_low
2899           || value > p_info->const_high
2900           /* ??? Why?  And why wasn't the similar code below modified too?  */
2901           || (TARGET_64BIT
2902               && HOST_BITS_PER_WIDE_INT < 64
2903               && p_info->const_add != 0
2904               && ((p_info->unsignedp
2905                    ? ((unsigned HOST_WIDE_INT) (value + p_info->const_add)
2906                       > (unsigned HOST_WIDE_INT) INTVAL (cmp1))
2907                    : (value + p_info->const_add) > INTVAL (cmp1))
2908                   != (p_info->const_add > 0))))
2909         cmp1 = force_reg (mode, cmp1);
2910     }
2911
2912   /* See if we need to invert the result.  */
2913   invert = (GET_CODE (cmp1) == CONST_INT
2914             ? p_info->invert_const : p_info->invert_reg);
2915
2916   if (p_invert != (int *)0)
2917     {
2918       *p_invert = invert;
2919       invert = 0;
2920     }
2921
2922   /* Comparison to constants, may involve adding 1 to change a LT into LE.
2923      Comparison between two registers, may involve switching operands.  */
2924   if (GET_CODE (cmp1) == CONST_INT)
2925     {
2926       if (p_info->const_add != 0)
2927         {
2928           HOST_WIDE_INT new = INTVAL (cmp1) + p_info->const_add;
2929
2930           /* If modification of cmp1 caused overflow,
2931              we would get the wrong answer if we follow the usual path;
2932              thus, x > 0xffffffffU would turn into x > 0U.  */
2933           if ((p_info->unsignedp
2934                ? (unsigned HOST_WIDE_INT) new >
2935                (unsigned HOST_WIDE_INT) INTVAL (cmp1)
2936                : new > INTVAL (cmp1))
2937               != (p_info->const_add > 0))
2938             {
2939               /* This test is always true, but if INVERT is true then
2940                  the result of the test needs to be inverted so 0 should
2941                  be returned instead.  */
2942               emit_move_insn (result, invert ? const0_rtx : const_true_rtx);
2943               return result;
2944             }
2945           else
2946             cmp1 = GEN_INT (new);
2947         }
2948     }
2949
2950   else if (p_info->reverse_regs)
2951     {
2952       rtx temp = cmp0;
2953       cmp0 = cmp1;
2954       cmp1 = temp;
2955     }
2956
2957   if (test == ITEST_NE && GET_CODE (cmp1) == CONST_INT && INTVAL (cmp1) == 0)
2958     reg = cmp0;
2959   else
2960     {
2961       reg = (invert || eqne_p) ? gen_reg_rtx (mode) : result;
2962       convert_move (reg, gen_rtx (p_info->test_code, mode, cmp0, cmp1), 0);
2963     }
2964
2965   if (test == ITEST_NE)
2966     {
2967       if (! TARGET_MIPS16)
2968         {
2969           convert_move (result, gen_rtx (GTU, mode, reg, const0_rtx), 0);
2970           if (p_invert != NULL)
2971             *p_invert = 0;
2972           invert = 0;
2973         }
2974       else
2975         {
2976           reg2 = invert ? gen_reg_rtx (mode) : result;
2977           convert_move (reg2, gen_rtx (LTU, mode, reg, const1_rtx), 0);
2978           reg = reg2;
2979         }
2980     }
2981
2982   else if (test == ITEST_EQ)
2983     {
2984       reg2 = invert ? gen_reg_rtx (mode) : result;
2985       convert_move (reg2, gen_rtx_LTU (mode, reg, const1_rtx), 0);
2986       reg = reg2;
2987     }
2988
2989   if (invert)
2990     {
2991       rtx one;
2992
2993       if (! TARGET_MIPS16)
2994         one = const1_rtx;
2995       else
2996         {
2997           /* The value is in $24.  Copy it to another register, so
2998              that reload doesn't think it needs to store the $24 and
2999              the input to the XOR in the same location.  */
3000           reg2 = gen_reg_rtx (mode);
3001           emit_move_insn (reg2, reg);
3002           reg = reg2;
3003           one = force_reg (mode, const1_rtx);
3004         }
3005       convert_move (result, gen_rtx (XOR, mode, reg, one), 0);
3006     }
3007
3008   return result;
3009 }
3010 \f
3011 /* Emit the common code for doing conditional branches.
3012    operand[0] is the label to jump to.
3013    The comparison operands are saved away by cmp{si,di,sf,df}.  */
3014
3015 void
3016 gen_conditional_branch (operands, test_code)
3017      rtx operands[];
3018      enum rtx_code test_code;
3019 {
3020   enum cmp_type type = branch_type;
3021   rtx cmp0 = branch_cmp[0];
3022   rtx cmp1 = branch_cmp[1];
3023   enum machine_mode mode;
3024   rtx reg;
3025   int invert;
3026   rtx label1, label2;
3027
3028   switch (type)
3029     {
3030     case CMP_SI:
3031     case CMP_DI:
3032       mode = type == CMP_SI ? SImode : DImode;
3033       invert = 0;
3034       reg = gen_int_relational (test_code, NULL_RTX, cmp0, cmp1, &invert);
3035
3036       if (reg)
3037         {
3038           cmp0 = reg;
3039           cmp1 = const0_rtx;
3040           test_code = NE;
3041         }
3042       else if (GET_CODE (cmp1) == CONST_INT && INTVAL (cmp1) != 0)
3043         /* We don't want to build a comparison against a non-zero
3044            constant.  */
3045         cmp1 = force_reg (mode, cmp1);
3046
3047       break;
3048
3049     case CMP_SF:
3050     case CMP_DF:
3051       if (! ISA_HAS_8CC)
3052         reg = gen_rtx_REG (CCmode, FPSW_REGNUM);
3053       else
3054         reg = gen_reg_rtx (CCmode);
3055
3056       /* For cmp0 != cmp1, build cmp0 == cmp1, and test for result ==
3057          0 in the instruction built below.  The MIPS FPU handles
3058          inequality testing by testing for equality and looking for a
3059          false result.  */
3060       emit_insn (gen_rtx_SET (VOIDmode, reg,
3061                               gen_rtx (test_code == NE ? EQ : test_code,
3062                                        CCmode, cmp0, cmp1)));
3063
3064       test_code = test_code == NE ? EQ : NE;
3065       mode = CCmode;
3066       cmp0 = reg;
3067       cmp1 = const0_rtx;
3068       invert = 0;
3069       break;
3070
3071     default:
3072       abort_with_insn (gen_rtx (test_code, VOIDmode, cmp0, cmp1), "bad test");
3073     }
3074
3075   /* Generate the branch.  */
3076
3077   label1 = gen_rtx_LABEL_REF (VOIDmode, operands[0]);
3078   label2 = pc_rtx;
3079
3080   if (invert)
3081     {
3082       label2 = label1;
3083       label1 = pc_rtx;
3084     }
3085
3086   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
3087                                gen_rtx_IF_THEN_ELSE (VOIDmode,
3088                                                      gen_rtx (test_code, mode,
3089                                                               cmp0, cmp1),
3090                                                      label1, label2)));
3091 }
3092
3093 /* Emit the common code for conditional moves.  OPERANDS is the array
3094    of operands passed to the conditional move defined_expand.  */
3095
3096 void
3097 gen_conditional_move (operands)
3098      rtx *operands;
3099 {
3100   rtx op0 = branch_cmp[0];
3101   rtx op1 = branch_cmp[1];
3102   enum machine_mode mode = GET_MODE (branch_cmp[0]);
3103   enum rtx_code cmp_code = GET_CODE (operands[1]);
3104   enum rtx_code move_code = NE;
3105   enum machine_mode op_mode = GET_MODE (operands[0]);
3106   enum machine_mode cmp_mode;
3107   rtx cmp_reg;
3108
3109   if (GET_MODE_CLASS (mode) != MODE_FLOAT)
3110     {
3111       switch (cmp_code)
3112         {
3113         case EQ:
3114           cmp_code = XOR;
3115           move_code = EQ;
3116           break;
3117         case NE:
3118           cmp_code = XOR;
3119           break;
3120         case LT:
3121           break;
3122         case GE:
3123           cmp_code = LT;
3124           move_code = EQ;
3125           break;
3126         case GT:
3127           cmp_code = LT;
3128           op0 = force_reg (mode, branch_cmp[1]);
3129           op1 = branch_cmp[0];
3130           break;
3131         case LE:
3132           cmp_code = LT;
3133           op0 = force_reg (mode, branch_cmp[1]);
3134           op1 = branch_cmp[0];
3135           move_code = EQ;
3136           break;
3137         case LTU:
3138           break;
3139         case GEU:
3140           cmp_code = LTU;
3141           move_code = EQ;
3142           break;
3143         case GTU:
3144           cmp_code = LTU;
3145           op0 = force_reg (mode, branch_cmp[1]);
3146           op1 = branch_cmp[0];
3147           break;
3148         case LEU:
3149           cmp_code = LTU;
3150           op0 = force_reg (mode, branch_cmp[1]);
3151           op1 = branch_cmp[0];
3152           move_code = EQ;
3153           break;
3154         default:
3155           abort ();
3156         }
3157     }
3158   else if (cmp_code == NE)
3159     cmp_code = EQ, move_code = EQ;
3160
3161   if (mode == SImode || mode == DImode)
3162     cmp_mode = mode;
3163   else if (mode == SFmode || mode == DFmode)
3164     cmp_mode = CCmode;
3165   else
3166     abort ();
3167
3168   cmp_reg = gen_reg_rtx (cmp_mode);
3169   emit_insn (gen_rtx_SET (cmp_mode, cmp_reg,
3170                           gen_rtx (cmp_code, cmp_mode, op0, op1)));
3171
3172   emit_insn (gen_rtx_SET (op_mode, operands[0],
3173                           gen_rtx_IF_THEN_ELSE (op_mode,
3174                                                 gen_rtx (move_code, VOIDmode,
3175                                                          cmp_reg,
3176                                                          CONST0_RTX (SImode)),
3177                                                 operands[2], operands[3])));
3178 }
3179
3180 /* Emit the common code for conditional moves.  OPERANDS is the array
3181    of operands passed to the conditional move defined_expand.  */
3182
3183 void
3184 mips_gen_conditional_trap (operands)
3185      rtx operands[];
3186 {
3187   rtx op0, op1;
3188   enum rtx_code cmp_code = GET_CODE (operands[0]);
3189   enum machine_mode mode = GET_MODE (branch_cmp[0]);
3190
3191   /* MIPS conditional trap machine instructions don't have GT or LE
3192      flavors, so we must invert the comparison and convert to LT and
3193      GE, respectively.  */
3194   switch (cmp_code)
3195     {
3196     case GT: cmp_code = LT; break;
3197     case LE: cmp_code = GE; break;
3198     case GTU: cmp_code = LTU; break;
3199     case LEU: cmp_code = GEU; break;
3200     default: break;
3201     }
3202   if (cmp_code == GET_CODE (operands[0]))
3203     {
3204       op0 = force_reg (mode, branch_cmp[0]);
3205       op1 = branch_cmp[1];
3206     }
3207   else
3208     {
3209       op0 = force_reg (mode, branch_cmp[1]);
3210       op1 = branch_cmp[0];
3211     }
3212   if (GET_CODE (op1) == CONST_INT && ! SMALL_INT (op1))
3213     op1 = force_reg (mode, op1);
3214
3215   emit_insn (gen_rtx_TRAP_IF (VOIDmode,
3216                               gen_rtx (cmp_code, GET_MODE (operands[0]), op0, op1),
3217                               operands[1]));
3218 }
3219 \f
3220 /* Write a loop to move a constant number of bytes.
3221    Generate load/stores as follows:
3222
3223    do {
3224      temp1 = src[0];
3225      temp2 = src[1];
3226      ...
3227      temp<last> = src[MAX_MOVE_REGS-1];
3228      dest[0] = temp1;
3229      dest[1] = temp2;
3230      ...
3231      dest[MAX_MOVE_REGS-1] = temp<last>;
3232      src += MAX_MOVE_REGS;
3233      dest += MAX_MOVE_REGS;
3234    } while (src != final);
3235
3236    This way, no NOP's are needed, and only MAX_MOVE_REGS+3 temp
3237    registers are needed.
3238
3239    Aligned moves move MAX_MOVE_REGS*4 bytes every (2*MAX_MOVE_REGS)+3
3240    cycles, unaligned moves move MAX_MOVE_REGS*4 bytes every
3241    (4*MAX_MOVE_REGS)+3 cycles, assuming no cache misses.  */
3242
3243 #define MAX_MOVE_REGS 4
3244 #define MAX_MOVE_BYTES (MAX_MOVE_REGS * UNITS_PER_WORD)
3245
3246 static void
3247 block_move_loop (dest_reg, src_reg, bytes, align, orig_dest, orig_src)
3248      rtx dest_reg;              /* register holding destination address */
3249      rtx src_reg;               /* register holding source address */
3250      unsigned int bytes;        /* # bytes to move */
3251      int align;                 /* alignment */
3252      rtx orig_dest;             /* original dest */
3253      rtx orig_src;              /* original source for making a reg note */
3254 {
3255   rtx dest_mem = replace_equiv_address (orig_dest, dest_reg);
3256   rtx src_mem = replace_equiv_address (orig_src, src_reg);
3257   rtx align_rtx = GEN_INT (align);
3258   rtx label;
3259   rtx final_src;
3260   rtx bytes_rtx;
3261   int leftover;
3262
3263   if (bytes < (unsigned)2 * MAX_MOVE_BYTES)
3264     abort ();
3265
3266   leftover = bytes % MAX_MOVE_BYTES;
3267   bytes -= leftover;
3268
3269   label = gen_label_rtx ();
3270   final_src = gen_reg_rtx (Pmode);
3271   bytes_rtx = GEN_INT (bytes);
3272
3273   if (bytes > 0x7fff)
3274     {
3275       if (Pmode == DImode)
3276         {
3277           emit_insn (gen_movdi (final_src, bytes_rtx));
3278           emit_insn (gen_adddi3 (final_src, final_src, src_reg));
3279         }
3280       else
3281         {
3282           emit_insn (gen_movsi (final_src, bytes_rtx));
3283           emit_insn (gen_addsi3 (final_src, final_src, src_reg));
3284         }
3285     }
3286   else
3287     {
3288       if (Pmode == DImode)
3289         emit_insn (gen_adddi3 (final_src, src_reg, bytes_rtx));
3290       else
3291         emit_insn (gen_addsi3 (final_src, src_reg, bytes_rtx));
3292     }
3293
3294   emit_label (label);
3295
3296   bytes_rtx = GEN_INT (MAX_MOVE_BYTES);
3297   emit_insn (gen_movstrsi_internal (dest_mem, src_mem, bytes_rtx, align_rtx));
3298
3299   if (Pmode == DImode)
3300     {
3301       emit_insn (gen_adddi3 (src_reg, src_reg, bytes_rtx));
3302       emit_insn (gen_adddi3 (dest_reg, dest_reg, bytes_rtx));
3303       emit_insn (gen_cmpdi (src_reg, final_src));
3304     }
3305   else
3306     {
3307       emit_insn (gen_addsi3 (src_reg, src_reg, bytes_rtx));
3308       emit_insn (gen_addsi3 (dest_reg, dest_reg, bytes_rtx));
3309       emit_insn (gen_cmpsi (src_reg, final_src));
3310     }
3311
3312   emit_jump_insn (gen_bne (label));
3313
3314   if (leftover)
3315     emit_insn (gen_movstrsi_internal (dest_mem, src_mem, GEN_INT (leftover),
3316                                       align_rtx));
3317 }
3318 \f
3319 /* Use a library function to move some bytes.  */
3320
3321 static void
3322 block_move_call (dest_reg, src_reg, bytes_rtx)
3323      rtx dest_reg;
3324      rtx src_reg;
3325      rtx bytes_rtx;
3326 {
3327   /* We want to pass the size as Pmode, which will normally be SImode
3328      but will be DImode if we are using 64 bit longs and pointers.  */
3329   if (GET_MODE (bytes_rtx) != VOIDmode
3330       && GET_MODE (bytes_rtx) != (unsigned) Pmode)
3331     bytes_rtx = convert_to_mode (Pmode, bytes_rtx, 1);
3332
3333 #ifdef TARGET_MEM_FUNCTIONS
3334   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "memcpy"), 0,
3335                      VOIDmode, 3, dest_reg, Pmode, src_reg, Pmode,
3336                      convert_to_mode (TYPE_MODE (sizetype), bytes_rtx,
3337                                       TREE_UNSIGNED (sizetype)),
3338                      TYPE_MODE (sizetype));
3339 #else
3340   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "bcopy"), 0,
3341                      VOIDmode, 3, src_reg, Pmode, dest_reg, Pmode,
3342                      convert_to_mode (TYPE_MODE (integer_type_node), bytes_rtx,
3343                                       TREE_UNSIGNED (integer_type_node)),
3344                      TYPE_MODE (integer_type_node));
3345 #endif
3346 }
3347 \f
3348 /* Expand string/block move operations.
3349
3350    operands[0] is the pointer to the destination.
3351    operands[1] is the pointer to the source.
3352    operands[2] is the number of bytes to move.
3353    operands[3] is the alignment.  */
3354
3355 void
3356 expand_block_move (operands)
3357      rtx operands[];
3358 {
3359   rtx bytes_rtx = operands[2];
3360   rtx align_rtx = operands[3];
3361   int constp = GET_CODE (bytes_rtx) == CONST_INT;
3362   unsigned HOST_WIDE_INT bytes = constp ? INTVAL (bytes_rtx) : 0;
3363   unsigned int align = INTVAL (align_rtx);
3364   rtx orig_src  = operands[1];
3365   rtx orig_dest = operands[0];
3366   rtx src_reg;
3367   rtx dest_reg;
3368
3369   if (constp && bytes == 0)
3370     return;
3371
3372   if (align > (unsigned) UNITS_PER_WORD)
3373     align = UNITS_PER_WORD;
3374
3375   /* Move the address into scratch registers.  */
3376   dest_reg = copy_addr_to_reg (XEXP (orig_dest, 0));
3377   src_reg  = copy_addr_to_reg (XEXP (orig_src, 0));
3378
3379   if (TARGET_MEMCPY)
3380     block_move_call (dest_reg, src_reg, bytes_rtx);
3381
3382   else if (constp && bytes <= (unsigned)2 * MAX_MOVE_BYTES
3383            && align == (unsigned) UNITS_PER_WORD)
3384     move_by_pieces (orig_dest, orig_src, bytes, align * BITS_PER_WORD);
3385
3386   else if (constp && bytes <= (unsigned)2 * MAX_MOVE_BYTES)
3387     emit_insn (gen_movstrsi_internal (replace_equiv_address (orig_dest,
3388                                                              dest_reg),
3389                                       replace_equiv_address (orig_src,
3390                                                              src_reg),
3391                                       bytes_rtx, align_rtx));
3392
3393   else if (constp && align >= (unsigned) UNITS_PER_WORD && optimize)
3394     block_move_loop (dest_reg, src_reg, bytes, align, orig_dest, orig_src);
3395
3396   else if (constp && optimize)
3397     {
3398       /* If the alignment is not word aligned, generate a test at
3399          runtime, to see whether things wound up aligned, and we
3400          can use the faster lw/sw instead ulw/usw.  */