OSDN Git Service

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