OSDN Git Service

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