![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mips.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config|
Return to mips.c CVS log | Up to [GCC 2.x] / gcc / config |
1.1 root 1: /* Subroutines for insn-output.c for MIPS
2: Contributed by A. Lichnewsky, [email protected].
3: Changes by Michael Meissner, [email protected].
4: Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 2, or (at your option)
11: any later version.
12:
13: GNU CC is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22: #include "config.h"
23: #include "rtl.h"
24: #include "regs.h"
25: #include "hard-reg-set.h"
26: #include "real.h"
27: #include "insn-config.h"
28: #include "conditions.h"
29: #include "insn-flags.h"
30: #include "insn-attr.h"
31: #include "insn-codes.h"
32: #include "recog.h"
33: #include "output.h"
34:
35: #undef MAX /* sys/param.h may also define these */
36: #undef MIN
37:
38: #include <stdio.h>
39: #include <signal.h>
40: #include <sys/types.h>
41: #include <sys/file.h>
42: #include <ctype.h>
43: #include "tree.h"
44: #include "expr.h"
45: #include "flags.h"
46:
47: #ifndef R_OK
48: #define R_OK 4
49: #define W_OK 2
50: #define X_OK 1
51: #endif
52:
53: #ifdef USG
54: #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
55: #else
56: #include <stab.h> /* On BSD, use the system's stab.h. */
57: #endif /* not USG */
58:
59: #ifdef __GNU_STAB__
60: #define STAB_CODE_TYPE enum __stab_debug_code
61: #else
62: #define STAB_CODE_TYPE int
63: #endif
64:
65: extern char *getenv ();
66:
67: extern char *permalloc ();
68: extern void debug_rtx ();
69: extern void abort_with_insn ();
70: extern rtx copy_to_reg ();
71: extern rtx adj_offsettable_operand ();
72: extern int offsettable_address_p ();
73: extern tree lookup_name ();
74:
75: extern rtx gen_movqi ();
76: extern rtx gen_movhi ();
77: extern rtx gen_movsi ();
78: extern rtx gen_movsi_ulw ();
79: extern rtx gen_movsi_usw ();
80: extern rtx gen_addsi3 ();
81: extern rtx gen_iorsi3 ();
82: extern rtx gen_andsi3 ();
83: extern rtx gen_bne ();
84: extern rtx gen_beq ();
85: extern rtx gen_cmpsi ();
86: extern rtx gen_jump ();
87:
88: extern char call_used_regs[];
89: extern char *asm_file_name;
90: extern FILE *asm_out_file;
91: extern tree current_function_decl;
92: extern char **save_argv;
93: extern char *version_string;
94: extern char *language_string;
95:
96: /* Global variables for machine-dependent things. */
97:
98: /* Threshold for data being put into the small data/bss area, instead
99: of the normal data area (references to the small data/bss area take
100: 1 instruction, and use the global pointer, references to the normal
101: data area takes 2 instructions). */
102: int mips_section_threshold = -1;
103:
104: /* Count the number of .file directives, so that .loc is up to date. */
105: int num_source_filenames = 0;
106:
107: /* Count of the number of functions created so far, in order to make
108: unique labels for omitting the frame pointer. */
109: int number_functions_processed = 0;
110:
111: /* Count the number of sdb related labels are generated (to find block
112: start and end boundaries). */
113: int sdb_label_count = 0;
114:
115: /* Next label # for each statment for Silicon Graphics IRIS systems. */
116: int sym_lineno = 0;
117:
118: /* Non-zero if inside of a function, because the stupid MIPS asm can't
119: handle .files inside of functions. */
120: int inside_function = 0;
121:
122: /* Files to separate the text and the data output, so that all of the data
123: can be emitted before the text, which will mean that the assembler will
124: generate smaller code, based on the global pointer. */
125: FILE *asm_out_data_file;
126: FILE *asm_out_text_file;
127:
128: /* Linked list of all externals that are to be emitted when optimizing
129: for the global pointer if they haven't been declared by the end of
130: the program with an appropriate .comm or initialization. */
131:
132: struct extern_list {
133: struct extern_list *next; /* next external */
134: char *name; /* name of the external */
135: int size; /* size in bytes */
136: } *extern_head = 0;
137:
138: /* Name of the current function. */
139: char *current_function_name;
140:
141: /* Name of the file containing the current function. */
142: char *current_function_file = "";
143:
144: /* Warning given that Mips ECOFF can't support changing files
145: within a function. */
146: int file_in_function_warning = FALSE;
147:
148: /* Whether to supress issuing .loc's because the user attempted
149: to change the filename within a function. */
150: int ignore_line_number = FALSE;
151:
152: /* Number of nested .set noreorder, noat, nomacro, and volatile requests. */
153: int set_noreorder;
154: int set_noat;
155: int set_nomacro;
156: int set_volatile;
157:
158: /* The next branch instruction is a branch likely, not branch normal. */
159: int mips_branch_likely;
160:
161: /* Count of delay slots and how many are filled. */
162: int dslots_load_total;
163: int dslots_load_filled;
164: int dslots_jump_total;
165: int dslots_jump_filled;
166:
167: /* # of nops needed by previous insn */
168: int dslots_number_nops;
169:
170: /* Number of 1/2/3 word references to data items (ie, not jal's). */
171: int num_refs[3];
172:
173: /* registers to check for load delay */
174: rtx mips_load_reg, mips_load_reg2, mips_load_reg3, mips_load_reg4;
175:
176: /* Cached operands, and operator to compare for use in set/branch on
177: condition codes. */
178: rtx branch_cmp[2];
179:
180: /* what type of branch to use */
181: enum cmp_type branch_type;
182:
183: /* which cpu are we scheduling for */
184: enum processor_type mips_cpu;
185:
186: /* which instruction set architecture to use. */
187: int mips_isa;
188:
189: /* Strings to hold which cpu and instruction set architecture to use. */
190: char *mips_cpu_string; /* for -mcpu=<xxx> */
191: char *mips_isa_string; /* for -mips{1,2,3} */
192:
193: /* Array to RTX class classification. At present, we care about
194: whether the operator is an add-type operator, or a divide/modulus,
195: and if divide/modulus, whether it is unsigned. This is for the
196: peephole code. */
197: char mips_rtx_classify[NUM_RTX_CODE];
198:
199: /* Array giving truth value on whether or not a given hard register
200: can support a given mode. */
201: char mips_hard_regno_mode_ok[(int)MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
202:
203: /* Current frame information calculated by compute_frame_size. */
204: struct mips_frame_info current_frame_info;
205:
206: /* Zero structure to initialize current_frame_info. */
207: struct mips_frame_info zero_frame_info;
208:
209: /* Temporary filename used to buffer .text until end of program
210: for -mgpopt. */
211: static char *temp_filename;
212:
213: /* List of all MIPS punctuation characters used by print_operand. */
214: char mips_print_operand_punct[256];
215:
216: /* Map GCC register number to debugger register number. */
217: int mips_dbx_regno[FIRST_PSEUDO_REGISTER];
218:
219: /* Buffer to use to enclose a load/store operation with %{ %} to
220: turn on .set volatile. */
221: static char volatile_buffer[60];
222:
223: /* Hardware names for the registers. If -mrnames is used, this
224: will be overwritten with mips_sw_reg_names. */
225:
226: char mips_reg_names[][8] =
227: {
228: "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
229: "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
230: "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
231: "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
232: "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
233: "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
234: "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
235: "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
236: "hi", "lo", "$fcr31"
237: };
238:
239: /* Mips software names for the registers, used to overwrite the
240: mips_reg_names array. */
241:
242: char mips_sw_reg_names[][8] =
243: {
244: "$0", "at", "v0", "v1", "a0", "a1", "a2", "a3",
245: "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
246: "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
247: "t8", "t9", "k0", "k1", "gp", "sp", "$fp", "ra",
248: "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
249: "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
250: "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
251: "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
252: "hi", "lo", "$fcr31"
253: };
254:
255: /* Map hard register number to register class */
256: enum reg_class mips_regno_to_class[] =
257: {
258: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
259: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
260: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
261: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
262: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
263: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
264: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
265: GR_REGS, GR_REGS, GR_REGS, GR_REGS,
266: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
267: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
268: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
269: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
270: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
271: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
272: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
273: FP_REGS, FP_REGS, FP_REGS, FP_REGS,
274: HI_REG, LO_REG, ST_REGS
275: };
276:
277: /* Map register constraint character to register class. */
278: enum reg_class mips_char_to_class[256] =
279: {
280: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
281: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
282: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
283: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
284: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
285: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
286: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
287: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
288: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
289: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
290: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
291: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
292: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
293: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
294: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
295: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
296: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
297: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
298: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
299: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
300: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
301: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
302: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
303: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
304: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
305: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
306: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
307: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
308: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
309: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
310: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
311: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
312: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
313: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
314: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
315: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
316: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
317: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
318: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
319: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
320: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
321: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
322: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
323: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
324: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
325: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
326: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
327: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
328: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
329: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
330: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
331: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
332: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
333: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
334: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
335: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
336: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
337: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
338: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
339: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
340: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
341: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
342: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
343: NO_REGS, NO_REGS, NO_REGS, NO_REGS,
344: };
345:
346:
347: /* Return truth value of whether OP can be used as an operands
348: where a register or 16 bit unsigned integer is needed. */
349:
350: int
351: uns_arith_operand (op, mode)
352: rtx op;
353: enum machine_mode mode;
354: {
355: if (GET_CODE (op) == CONST_INT && SMALL_INT_UNSIGNED (op))
356: return TRUE;
357:
358: return register_operand (op, mode);
359: }
360:
361: /* Return truth value of whether OP can be used as an operands
362: where a 16 bit integer is needed */
363:
364: int
365: arith_operand (op, mode)
366: rtx op;
367: enum machine_mode mode;
368: {
369: if (GET_CODE (op) == CONST_INT && SMALL_INT (op))
370: return TRUE;
371:
372: return register_operand (op, mode);
373: }
374:
375: /* Return truth value of whether OP can be used as an operand in a two
376: address arithmetic insn (such as set 123456,%o4) of mode MODE. */
377:
378: int
379: arith32_operand (op, mode)
380: rtx op;
381: enum machine_mode mode;
382: {
383: if (GET_CODE (op) == CONST_INT)
384: return TRUE;
385:
386: return register_operand (op, mode);
387: }
388:
389: /* Return truth value of whether OP is a integer which fits in 16 bits */
390:
391: int
392: small_int (op, mode)
393: rtx op;
394: enum machine_mode mode;
395: {
396: return (GET_CODE (op) == CONST_INT && SMALL_INT (op));
397: }
398:
399: /* Return truth value of whether OP is an integer which is too big to
400: be loaded with one instruction. */
401:
402: int
403: large_int (op, mode)
404: rtx op;
405: enum machine_mode mode;
406: {
407: long value;
408:
409: if (GET_CODE (op) != CONST_INT)
410: return FALSE;
411:
412: value = INTVAL (op);
413: if ((value & 0xffff0000) == 0) /* ior reg,$r0,value */
414: return FALSE;
415:
416: if ((value & 0xffff0000) == 0xffff0000) /* subu reg,$r0,value */
417: return FALSE;
418:
419: if ((value & 0x0000ffff) == 0) /* lui reg,value>>16 */
420: return FALSE;
421:
422: return TRUE;
423: }
424:
425: /* Return truth value of whether OP is a register or the constant 0. */
426:
427: int
428: reg_or_0_operand (op, mode)
429: rtx op;
430: enum machine_mode mode;
431: {
432: switch (GET_CODE (op))
433: {
434: case CONST_INT:
435: return (INTVAL (op) == 0);
436:
437: case CONST_DOUBLE:
438: if (CONST_DOUBLE_HIGH (op) != 0 || CONST_DOUBLE_LOW (op) != 0)
439: return FALSE;
440:
441: return TRUE;
442:
443: case REG:
444: case SUBREG:
445: return register_operand (op, mode);
446: }
447:
448: return FALSE;
449: }
450:
451: /* Return truth value of whether OP is one of the special multiply/divide
452: registers (hi, lo). */
453:
454: int
455: md_register_operand (op, mode)
456: rtx op;
457: enum machine_mode mode;
458: {
459: return (GET_MODE_CLASS (mode) == MODE_INT
460: && GET_CODE (op) == REG
461: && MD_REG_P (REGNO (op)));
462: }
463:
464: /* Return truth value if a CONST_DOUBLE is ok to be a legitimate constant. */
465:
466: int
467: mips_const_double_ok (op, mode)
468: rtx op;
469: enum machine_mode mode;
470: {
471: if (GET_CODE (op) != CONST_DOUBLE)
472: return FALSE;
473:
474: if (mode == DImode)
475: return TRUE;
476:
477: if (mode != SFmode && mode != DFmode)
478: return FALSE;
479:
480: if (CONST_DOUBLE_HIGH (op) == 0 && CONST_DOUBLE_LOW (op) == 0)
481: return TRUE;
482:
483: #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
484: if (TARGET_MIPS_AS) /* gas doesn't like li.d/li.s yet */
485: {
486: union { double d; int i[2]; } u;
487: double d;
488:
489: u.i[0] = CONST_DOUBLE_LOW (op);
490: u.i[1] = CONST_DOUBLE_HIGH (op);
491: d = u.d;
492:
493: if (d != d)
494: return FALSE; /* NAN */
495:
496: if (d < 0.0)
497: d = - d;
498:
499: /* Rather than trying to get the accuracy down to the last bit,
500: just use approximate ranges. */
501:
502: if (mode == DFmode && d > 1.0e-300 && d < 1.0e300)
503: return TRUE;
504:
505: if (mode == SFmode && d > 1.0e-38 && d < 1.0e+38)
506: return TRUE;
507: }
508: #endif
509:
510: return FALSE;
511: }
512:
513: /* Return truth value if a memory operand fits in a single instruction
514: (ie, register + small offset). */
515:
516: int
517: simple_memory_operand (op, mode)
518: rtx op;
519: enum machine_mode mode;
520: {
521: rtx addr, plus0, plus1;
522: int offset = 0;
523:
524: /* Eliminate non-memory operations */
525: if (GET_CODE (op) != MEM)
526: return FALSE;
527:
528: /* dword operations really put out 2 instructions, so eliminate them. */
529: if (GET_MODE_SIZE (GET_MODE (op)) > (HAVE_64BIT_P () ? 8 : 4))
530: return FALSE;
531:
532: /* Decode the address now. */
533: addr = XEXP (op, 0);
534: switch (GET_CODE (addr))
535: {
536: case REG:
537: return TRUE;
538:
539: case CONST_INT:
540: return SMALL_INT (op);
541:
542: case PLUS:
543: plus0 = XEXP (addr, 0);
544: plus1 = XEXP (addr, 1);
545: if (GET_CODE (plus0) == REG
546: && GET_CODE (plus1) == CONST_INT
547: && SMALL_INT (plus1))
548: return TRUE;
549:
550: else if (GET_CODE (plus1) == REG
551: && GET_CODE (plus0) == CONST_INT
552: && SMALL_INT (plus0))
553: return TRUE;
554:
555: else
556: return FALSE;
557:
558: #if 0
559: /* We used to allow small symbol refs here (ie, stuff in .sdata
560: or .sbss), but this causes some bugs in G++. Also, it won't
561: interfere if the MIPS linker rewrites the store instruction
562: because the function is PIC. */
563:
564: case LABEL_REF: /* never gp relative */
565: break;
566:
567: case CONST:
568: /* If -G 0, we can never have a GP relative memory operation.
569: Also, save some time if not optimizing. */
570: if (mips_section_threshold == 0 || !optimize || !TARGET_GP_OPT)
571: return FALSE;
572:
573: addr = eliminate_constant_term (addr, &offset);
574: if (GET_CODE (op) != SYMBOL_REF)
575: return FALSE;
576:
577: /* fall through */
578:
579: case SYMBOL_REF:
580: /* let's be paranoid.... */
581: if (offset < 0 || offset > 0xffff)
582: return FALSE;
583:
584: return SYMBOL_REF_FLAG (addr);
585: #endif
586: }
587:
588: return FALSE;
589: }
590:
591: /* Return true if the address is suitable for function call. */
592:
593: int
594: call_memory_operand (op, mode)
595: rtx op;
596: enum machine_mode mode;
597: {
598: rtx addr;
599: enum rtx_code code;
600:
601: if (GET_CODE (op) != MEM)
602: return FALSE;
603:
604: addr = XEXP (op, 0);
605: code = GET_CODE (addr);
606:
607: if (GET_MODE (addr) != FUNCTION_MODE)
608: return FALSE;
609:
610: if (code == REG || code == SUBREG)
611: return TRUE;
612:
613: if (CONSTANT_ADDRESS_P (addr))
614: return TRUE;
615:
616: return FALSE;
617: }
618:
619: /* Return true if the code of this rtx pattern is EQ or NE. */
620:
621: int
622: equality_op (op, mode)
623: rtx op;
624: enum machine_mode mode;
625: {
626: if (mode != GET_MODE (op))
627: return FALSE;
628:
629: return (classify_op (op, mode) & CLASS_EQUALITY_OP) != 0;
630: }
631:
632: /* Return true if the code is a relational operations (EQ, LE, etc.) */
633:
634: int
635: cmp_op (op, mode)
636: rtx op;
637: enum machine_mode mode;
638: {
639: if (mode != GET_MODE (op))
640: return FALSE;
641:
642: return (classify_op (op, mode) & CLASS_CMP_OP) != 0;
643: }
644:
645:
646: /* Genrecog does not take the type of match_operator into consideration,
647: and would complain about two patterns being the same if the same
648: function is used, so make it believe they are different. */
649:
650: int
651: cmp2_op (op, mode)
652: rtx op;
653: enum machine_mode mode;
654: {
655: if (mode != GET_MODE (op))
656: return FALSE;
657:
658: return (classify_op (op, mode) & CLASS_CMP_OP) != 0;
659: }
660:
661: /* Return true if the code is an unsigned relational operations (LEU, etc.) */
662:
663: int
664: uns_cmp_op (op,mode)
665: rtx op;
666: enum machine_mode mode;
667: {
668: if (mode != GET_MODE (op))
669: return FALSE;
670:
671: return (classify_op (op, mode) & CLASS_UNS_CMP_OP) == CLASS_UNS_CMP_OP;
672: }
673:
674: /* Return true if the code is a relational operation FP can use. */
675:
676: int
677: fcmp_op (op, mode)
678: rtx op;
679: enum machine_mode mode;
680: {
681: if (mode != GET_MODE (op))
682: return FALSE;
683:
684: return (classify_op (op, mode) & CLASS_FCMP_OP) != 0;
685: }
686:
687:
688: /* Return an operand string if the given instruction's delay slot or
689: wrap it in a .set noreorder section. This is for filling delay
690: slots on load type instructions under GAS, which does no reordering
691: on its own. For the MIPS assembler, all we do is update the filled
692: delay slot statistics.
693:
694: We assume that operands[0] is the target register that is set.
695:
696: In order to check the next insn, most of this functionality is moved
697: to FINAL_PRESCAN_INSN, and we just set the global variables that
698: it needs. */
699:
700: char *
701: mips_fill_delay_slot (ret, type, operands, cur_insn)
702: char *ret; /* normal string to return */
703: enum delay_type type; /* type of delay */
704: rtx operands[]; /* operands to use */
705: rtx cur_insn; /* current insn */
706: {
707: register rtx set_reg;
708: register enum machine_mode mode;
709: register rtx next_insn = (cur_insn) ? NEXT_INSN (cur_insn) : (rtx)0;
710: register int num_nops;
711:
712: if (type == DELAY_LOAD)
713: num_nops = 1;
714:
715: else if (type == DELAY_HILO)
716: num_nops = 2;
717:
718: else
719: num_nops = 0;
720:
721: /* Make sure that we don't put nop's after labels. */
722: next_insn = NEXT_INSN (cur_insn);
723: while (next_insn != (rtx)0 && GET_CODE (next_insn) == NOTE)
724: next_insn = NEXT_INSN (next_insn);
725:
726: dslots_load_total += num_nops;
727: if (TARGET_DEBUG_F_MODE
728: || !optimize
729: || type == DELAY_NONE
730: || operands == (rtx *)0
731: || cur_insn == (rtx)0
732: || next_insn == (rtx)0
733: || GET_CODE (next_insn) == CODE_LABEL
734: || (set_reg = operands[0]) == (rtx)0)
735: {
736: dslots_number_nops = 0;
737: mips_load_reg = (rtx)0;
738: mips_load_reg2 = (rtx)0;
739: mips_load_reg3 = (rtx)0;
740: mips_load_reg4 = (rtx)0;
741: return ret;
742: }
743:
744: set_reg = operands[0];
745: if (set_reg == (rtx)0)
746: return ret;
747:
748: while (GET_CODE (set_reg) == SUBREG)
749: set_reg = SUBREG_REG (set_reg);
750:
751: mode = GET_MODE (set_reg);
752: dslots_number_nops = num_nops;
753: mips_load_reg = set_reg;
754: mips_load_reg2 = (mode == DImode || mode == DFmode)
755: ? gen_rtx (REG, SImode, REGNO (set_reg) + 1)
756: : (rtx)0;
757:
758: if (type == DELAY_HILO)
759: {
760: mips_load_reg3 = gen_rtx (REG, SImode, MD_REG_FIRST);
761: mips_load_reg4 = gen_rtx (REG, SImode, MD_REG_FIRST+1);
762: }
763: else
764: {
765: mips_load_reg3 = 0;
766: mips_load_reg4 = 0;
767: }
768:
769: if (TARGET_GAS && set_noreorder++ == 0)
770: fputs ("\t.set\tnoreorder\n", asm_out_file);
771:
772: return ret;
773: }
774:
775:
776: /* Determine whether a memory reference takes one (based off of the GP pointer),
777: two (normal), or three (label + reg) instructins, and bump the appropriate
778: counter for -mstats. */
779:
780: void
781: mips_count_memory_refs (op, num)
782: rtx op;
783: int num;
784: {
785: int additional = 0;
786: int n_words = 0;
787: rtx addr, plus0, plus1;
788: enum rtx_code code0, code1;
789: int looping;
790:
791: if (TARGET_DEBUG_B_MODE)
792: {
793: fprintf (stderr, "\n========== mips_count_memory_refs:\n");
794: debug_rtx (op);
795: }
796:
797: /* Skip MEM if passed, otherwise handle movsi of address. */
798: addr = (GET_CODE (op) != MEM) ? op : XEXP (op, 0);
799:
800: /* Loop, going through the address RTL */
801: do
802: {
803: looping = FALSE;
804: switch (GET_CODE (addr))
805: {
806: case REG:
807: case CONST_INT:
808: break;
809:
810: case PLUS:
811: plus0 = XEXP (addr, 0);
812: plus1 = XEXP (addr, 1);
813: code0 = GET_CODE (plus0);
814: code1 = GET_CODE (plus1);
815:
816: if (code0 == REG)
817: {
818: additional++;
819: addr = plus1;
820: looping = TRUE;
821: continue;
822: }
823:
824: if (code0 == CONST_INT)
825: {
826: addr = plus1;
827: looping = TRUE;
828: continue;
829: }
830:
831: if (code1 == REG)
832: {
833: additional++;
834: addr = plus0;
835: looping = TRUE;
836: continue;
837: }
838:
839: if (code1 == CONST_INT)
840: {
841: addr = plus0;
842: looping = TRUE;
843: continue;
844: }
845:
846: if (code0 == SYMBOL_REF || code0 == LABEL_REF || code0 == CONST)
847: {
848: addr = plus0;
849: looping = TRUE;
850: continue;
851: }
852:
853: if (code1 == SYMBOL_REF || code1 == LABEL_REF || code1 == CONST)
854: {
855: addr = plus1;
856: looping = TRUE;
857: continue;
858: }
859:
860: break;
861:
862: case LABEL_REF:
863: n_words = 2; /* always 2 words */
864: break;
865:
866: case CONST:
867: addr = XEXP (addr, 0);
868: looping = TRUE;
869: continue;
870:
871: case SYMBOL_REF:
872: n_words = SYMBOL_REF_FLAG (addr) ? 1 : 2;
873: break;
874: }
875: }
876: while (looping);
877:
878: if (n_words == 0)
879: return;
880:
881: n_words += additional;
882: if (n_words > 3)
883: n_words = 3;
884:
885: num_refs[n_words-1] += num;
886: }
887:
888:
889: /* Return the appropriate instructions to move one operand to another. */
890:
891: char *
892: mips_move_1word (operands, insn, unsignedp)
893: rtx operands[];
894: rtx insn;
895: int unsignedp;
896: {
897: char *ret = 0;
898: rtx op0 = operands[0];
899: rtx op1 = operands[1];
900: enum rtx_code code0 = GET_CODE (op0);
901: enum rtx_code code1 = GET_CODE (op1);
902: enum machine_mode mode = GET_MODE (op0);
903: int subreg_word0 = 0;
904: int subreg_word1 = 0;
905: enum delay_type delay = DELAY_NONE;
906:
907: while (code0 == SUBREG)
908: {
909: subreg_word0 += SUBREG_WORD (op0);
910: op0 = SUBREG_REG (op0);
911: code0 = GET_CODE (op0);
912: }
913:
914: while (code1 == SUBREG)
915: {
916: subreg_word1 += SUBREG_WORD (op1);
917: op1 = SUBREG_REG (op1);
918: code1 = GET_CODE (op1);
919: }
920:
921: if (code0 == REG)
922: {
923: int regno0 = REGNO (op0) + subreg_word0;
924:
925: if (code1 == REG)
926: {
927: int regno1 = REGNO (op1) + subreg_word1;
928:
929: /* Just in case, don't do anything for assigning a register
930: to itself, unless we are filling a delay slot. */
931: if (regno0 == regno1 && set_nomacro == 0)
932: ret = "";
933:
934: else if (GP_REG_P (regno0))
935: {
936: if (GP_REG_P (regno1))
937: ret = "move\t%0,%1";
938:
939: else if (MD_REG_P (regno1))
940: {
941: delay = DELAY_HILO;
942: ret = "mf%1\t%0";
943: }
944:
945: else
946: {
947: delay = DELAY_LOAD;
948: if (FP_REG_P (regno1))
949: ret = "mfc1\t%0,%1";
950:
951: else if (regno1 == FPSW_REGNUM)
952: ret = "cfc1\t%0,$31";
953: }
954: }
955:
956: else if (FP_REG_P (regno0))
957: {
958: if (GP_REG_P (regno1))
959: {
960: delay = DELAY_LOAD;
961: ret = "mtc1\t%1,%0";
962: }
963:
964: if (FP_REG_P (regno1))
965: ret = "mov.s\t%0,%1";
966: }
967:
968: else if (MD_REG_P (regno0))
969: {
970: if (GP_REG_P (regno1))
971: {
972: delay = DELAY_HILO;
973: ret = "mt%0\t%1";
974: }
975: }
976:
977: else if (regno0 == FPSW_REGNUM)
978: {
979: if (GP_REG_P (regno1))
980: {
981: delay = DELAY_LOAD;
982: ret = "ctc1\t%0,$31";
983: }
984: }
985: }
986:
987: else if (code1 == MEM)
988: {
989: delay = DELAY_LOAD;
990:
991: if (TARGET_STATS)
992: mips_count_memory_refs (op1, 1);
993:
994: if (GP_REG_P (regno0))
995: {
996: /* For loads, use the mode of the memory item, instead of the
997: target, so zero/sign extend can use this code as well. */
998: switch (GET_MODE (op1))
999: {
1000: case SFmode: ret = "lw\t%0,%1"; break;
1001: case SImode: ret = "lw\t%0,%1"; break;
1002: case HImode: ret = (unsignedp) ? "lhu\t%0,%1" : "lh\t%0,%1"; break;
1003: case QImode: ret = (unsignedp) ? "lbu\t%0,%1" : "lb\t%0,%1"; break;
1004: }
1005: }
1006:
1007: else if (FP_REG_P (regno0) && (mode == SImode || mode == SFmode))
1008: ret = "l.s\t%0,%1";
1009:
1010: if (ret != (char *)0 && MEM_VOLATILE_P (op1))
1011: {
1012: int i = strlen (ret);
1013: if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
1014: abort ();
1015:
1016: sprintf (volatile_buffer, "%%{%s%%}", ret);
1017: ret = volatile_buffer;
1018: }
1019: }
1020:
1021: else if (code1 == CONST_INT)
1022: {
1023: if (INTVAL (op1) == 0)
1024: {
1025: if (GP_REG_P (regno0))
1026: ret = "move\t%0,%z1";
1027:
1028: else if (FP_REG_P (regno0))
1029: {
1030: delay = DELAY_LOAD;
1031: return "mtc1\t%z1,%0";
1032: }
1033: }
1034:
1035: else if (GP_REG_P (regno0))
1036: {
1037: if ((INTVAL (operands[1]) & 0x0000ffff) == 0)
1038: ret = "lui\t%0,(%X1)>>16";
1039: else
1040: ret = "li\t%0,%1";
1041: }
1042: }
1043:
1044: else if (code1 == CONST_DOUBLE && mode == SFmode)
1045: {
1046: if (CONST_DOUBLE_HIGH (op1) == 0 && CONST_DOUBLE_LOW (op1) == 0)
1047: {
1048: if (GP_REG_P (regno0))
1049: ret = "move\t%0,%.";
1050:
1051: else if (FP_REG_P (regno0))
1052: {
1053: delay = DELAY_LOAD;
1054: ret = "mtc1\t%.,%0";
1055: }
1056: }
1057:
1058: else
1059: {
1060: delay = DELAY_LOAD;
1061: ret = "li.s\t%0,%1";
1062: }
1063: }
1064:
1065: else if (code1 == LABEL_REF)
1066: ret = "la\t%0,%a1";
1067:
1068: else if (code1 == SYMBOL_REF || code1 == CONST)
1069: {
1070: if (TARGET_STATS)
1071: mips_count_memory_refs (op1, 1);
1072:
1073: if (HALF_PIC_P () && CONSTANT_P (op1) && HALF_PIC_ADDRESS_P (op1))
1074: {
1075: delay = DELAY_LOAD;
1076: ret = "la\t%0,%a1\t\t# pic reference";
1077: }
1078: else
1079: ret = "la\t%0,%a1";
1080: }
1081:
1082: else if (code1 == PLUS)
1083: {
1084: rtx add_op0 = XEXP (op1, 0);
1085: rtx add_op1 = XEXP (op1, 1);
1086:
1087: if (GET_CODE (XEXP (op1, 1)) == REG && GET_CODE (XEXP (op1, 0)) == CONST_INT)
1088: {
1089: add_op0 = XEXP (op1, 1); /* reverse operands */
1090: add_op1 = XEXP (op1, 0);
1091: }
1092:
1093: operands[2] = add_op0;
1094: operands[3] = add_op1;
1095: ret = "add%:\t%0,%2,%3";
1096: }
1097: }
1098:
1099: else if (code0 == MEM)
1100: {
1101: if (TARGET_STATS)
1102: mips_count_memory_refs (op0, 1);
1103:
1104: if (code1 == REG)
1105: {
1106: int regno1 = REGNO (op1) + subreg_word1;
1107:
1108: if (GP_REG_P (regno1))
1109: {
1110: switch (mode)
1111: {
1112: case SFmode: ret = "sw\t%1,%0"; break;
1113: case SImode: ret = "sw\t%1,%0"; break;
1114: case HImode: ret = "sh\t%1,%0"; break;
1115: case QImode: ret = "sb\t%1,%0"; break;
1116: }
1117: }
1118:
1119: else if (FP_REG_P (regno1) && (mode == SImode || mode == SFmode))
1120: ret = "s.s\t%1,%0";
1121: }
1122:
1123: else if (code1 == CONST_INT && INTVAL (op1) == 0)
1124: {
1125: switch (mode)
1126: {
1127: case SFmode: ret = "sw\t%z1,%0"; break;
1128: case SImode: ret = "sw\t%z1,%0"; break;
1129: case HImode: ret = "sh\t%z1,%0"; break;
1130: case QImode: ret = "sb\t%z1,%0"; break;
1131: }
1132: }
1133:
1134: else if (code1 == CONST_DOUBLE && CONST_DOUBLE_HIGH (op1) == 0 && CONST_DOUBLE_LOW (op1) == 0)
1135: {
1136: switch (mode)
1137: {
1138: case SFmode: ret = "sw\t%.,%0"; break;
1139: case SImode: ret = "sw\t%.,%0"; break;
1140: case HImode: ret = "sh\t%.,%0"; break;
1141: case QImode: ret = "sb\t%.,%0"; break;
1142: }
1143: }
1144:
1145: if (ret != (char *)0 && MEM_VOLATILE_P (op0))
1146: {
1147: int i = strlen (ret);
1148: if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
1149: abort ();
1150:
1151: sprintf (volatile_buffer, "%%{%s%%}", ret);
1152: ret = volatile_buffer;
1153: }
1154: }
1155:
1156: if (ret == (char *)0)
1157: {
1158: abort_with_insn (insn, "Bad move");
1159: return 0;
1160: }
1161:
1162: if (delay != DELAY_NONE)
1163: return mips_fill_delay_slot (ret, delay, operands, insn);
1164:
1165: return ret;
1166: }
1167:
1168:
1169: /* Return the appropriate instructions to move 2 words */
1170:
1171: char *
1172: mips_move_2words (operands, insn)
1173: rtx operands[];
1174: rtx insn;
1175: {
1176: char *ret = 0;
1177: rtx op0 = operands[0];
1178: rtx op1 = operands[1];
1179: enum rtx_code code0 = GET_CODE (operands[0]);
1180: enum rtx_code code1 = GET_CODE (operands[1]);
1181: int subreg_word0 = 0;
1182: int subreg_word1 = 0;
1183: enum delay_type delay = DELAY_NONE;
1184:
1185: while (code0 == SUBREG)
1186: {
1187: subreg_word0 += SUBREG_WORD (op0);
1188: op0 = SUBREG_REG (op0);
1189: code0 = GET_CODE (op0);
1190: }
1191:
1192: while (code1 == SUBREG)
1193: {
1194: subreg_word1 += SUBREG_WORD (op1);
1195: op1 = SUBREG_REG (op1);
1196: code1 = GET_CODE (op1);
1197: }
1198:
1199: if (code0 == REG)
1200: {
1201: int regno0 = REGNO (op0) + subreg_word0;
1202:
1203: if (code1 == REG)
1204: {
1205: int regno1 = REGNO (op1) + subreg_word1;
1206:
1207: /* Just in case, don't do anything for assigning a register
1208: to itself, unless we are filling a delay slot. */
1209: if (regno0 == regno1 && set_nomacro == 0)
1210: ret = "";
1211:
1212: else if (FP_REG_P (regno0))
1213: {
1214: if (FP_REG_P (regno1))
1215: ret = "mov.d\t%0,%1";
1216:
1217: else
1218: {
1219: delay = DELAY_LOAD;
1220: ret = (TARGET_FLOAT64)
1221: ? "dmtc1\t%1,%0"
1222: : "mtc1\t%L1,%0\n\tmtc1\t%M1,%D0";
1223: }
1224: }
1225:
1226: else if (FP_REG_P (regno1))
1227: {
1228: delay = DELAY_LOAD;
1229: ret = (TARGET_FLOAT64)
1230: ? "dmfc1\t%0,%1"
1231: : "mfc1\t%L0,%1\n\tmfc1\t%M0,%D1";
1232: }
1233:
1234: else if (MD_REG_P (regno0) && GP_REG_P (regno1))
1235: {
1236: delay = DELAY_HILO;
1237: ret = "mthi\t%M1\n\tmtlo\t%L1";
1238: }
1239:
1240: else if (GP_REG_P (regno0) && MD_REG_P (regno1))
1241: {
1242: delay = DELAY_HILO;
1243: ret = "mfhi\t%M0\n\tmflo\t%L0";
1244: }
1245:
1246: else if (regno0 != (regno1+1))
1247: ret = "move\t%0,%1\n\tmove\t%D0,%D1";
1248:
1249: else
1250: ret = "move\t%D0,%D1\n\tmove\t%0,%1";
1251: }
1252:
1253: else if (code1 == CONST_DOUBLE)
1254: {
1255: if (CONST_DOUBLE_HIGH (op1) != 0 || CONST_DOUBLE_LOW (op1) != 0)
1256: {
1257: if (GET_MODE (op1) == DFmode)
1258: {
1259: delay = DELAY_LOAD;
1260: ret = "li.d\t%0,%1";
1261: }
1262:
1263: else
1264: {
1265: operands[2] = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_LOW (op1));
1266: operands[3] = gen_rtx (CONST_INT, VOIDmode, CONST_DOUBLE_HIGH (op1));
1267: ret = "li\t%M0,%3\n\tli\t%L0,%2";
1268: }
1269: }
1270:
1271: else
1272: {
1273: if (GP_REG_P (regno0))
1274: ret = "move\t%0,%.\n\tmove\t%D0,%.";
1275:
1276: else if (FP_REG_P (regno0))
1277: {
1278: delay = DELAY_LOAD;
1279: ret = (TARGET_FLOAT64)
1280: ? "dmtc1\t%.,%0"
1281: : "mtc1\t%.,%0\n\tmtc1\t%.,%D0";
1282: }
1283: }
1284: }
1285:
1286: else if (code1 == CONST_INT && INTVAL (op1) == 0)
1287: {
1288: if (GP_REG_P (regno0))
1289: ret = "move\t%0,%.\n\tmove\t%D0,%.";
1290:
1291: else if (FP_REG_P (regno0))
1292: {
1293: delay = DELAY_LOAD;
1294: ret = (TARGET_FLOAT64)
1295: ? "dmtc1\t%.,%0"
1296: : "mtc1\t%.,%0\n\tmtc1\t%.,%D0";
1297: }
1298: }
1299:
1300: else if (code1 == CONST_INT && GET_MODE (op0) == DImode && GP_REG_P (regno0))
1301: {
1302: operands[2] = gen_rtx (CONST_INT, VOIDmode, INTVAL (operands[1]) >= 0 ? 0 : -1);
1303: ret = "li\t%M0,%2\n\tli\t%L0,%1";
1304: }
1305:
1306: else if (code1 == MEM)
1307: {
1308: delay = DELAY_LOAD;
1309:
1310: if (TARGET_STATS)
1311: mips_count_memory_refs (op1, 2);
1312:
1313: if (FP_REG_P (regno0))
1314: ret = "l.d\t%0,%1";
1315:
1316: else if (offsettable_address_p (1, DFmode, XEXP (op1, 0)))
1317: {
1318: operands[2] = adj_offsettable_operand (op1, 4);
1319: if (reg_mentioned_p (op0, op1))
1320: ret = "lw\t%D0,%2\n\tlw\t%0,%1";
1321: else
1322: ret = "lw\t%0,%1\n\tlw\t%D0,%2";
1323: }
1324:
1325: if (ret != (char *)0 && MEM_VOLATILE_P (op1))
1326: {
1327: int i = strlen (ret);
1328: if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
1329: abort ();
1330:
1331: sprintf (volatile_buffer, "%%{%s%%}", ret);
1332: ret = volatile_buffer;
1333: }
1334: }
1335: }
1336:
1337: else if (code0 == MEM)
1338: {
1339: if (code1 == REG)
1340: {
1341: int regno1 = REGNO (op1) + subreg_word1;
1342:
1343: if (FP_REG_P (regno1))
1344: ret = "s.d\t%1,%0";
1345:
1346: else if (offsettable_address_p (1, DFmode, XEXP (op0, 0)))
1347: {
1348: operands[2] = adj_offsettable_operand (op0, 4);
1349: ret = "sw\t%1,%0\n\tsw\t%D1,%2";
1350: }
1351: }
1352:
1353: else if (code1 == CONST_DOUBLE
1354: && CONST_DOUBLE_HIGH (op1) == 0
1355: && CONST_DOUBLE_LOW (op1) == 0
1356: && offsettable_address_p (1, DFmode, XEXP (op0, 0)))
1357: {
1358: if (TARGET_FLOAT64)
1359: ret = "sd\t%.,%0";
1360: else
1361: {
1362: operands[2] = adj_offsettable_operand (op0, 4);
1363: ret = "sw\t%.,%0\n\tsw\t%.,%2";
1364: }
1365: }
1366:
1367: if (TARGET_STATS)
1368: mips_count_memory_refs (op0, 2);
1369:
1370: if (ret != (char *)0 && MEM_VOLATILE_P (op0))
1371: {
1372: int i = strlen (ret);
1373: if (i > sizeof (volatile_buffer) - sizeof ("%{%}"))
1374: abort ();
1375:
1376: sprintf (volatile_buffer, "%%{%s%%}", ret);
1377: ret = volatile_buffer;
1378: }
1379: }
1380:
1381: if (ret == (char *)0)
1382: {
1383: abort_with_insn (insn, "Bad move");
1384: return 0;
1385: }
1386:
1387: if (delay != DELAY_NONE)
1388: return mips_fill_delay_slot (ret, delay, operands, insn);
1389:
1390: return ret;
1391: }
1392:
1393:
1394: /* Provide the costs of an addressing mode that contains ADDR.
1395: If ADDR is not a valid address, its cost is irrelavent. */
1396:
1397: int
1398: mips_address_cost (addr)
1399: rtx addr;
1400: {
1401: int offset;
1402:
1403: switch (GET_CODE (addr))
1404: {
1405: case LO_SUM:
1406: case HIGH:
1407: return 1;
1408:
1409: case LABEL_REF:
1410: return 2;
1411:
1412: case CONST:
1413: offset = 0;
1414: addr = eliminate_constant_term (addr, &offset);
1415: if (GET_CODE (addr) == LABEL_REF)
1416: return 2;
1417:
1418: if (GET_CODE (addr) != SYMBOL_REF)
1419: return 4;
1420:
1421: if (offset < -32768 || offset > 32767)
1422: return 2;
1423:
1424: /* fall through */
1425:
1426: case SYMBOL_REF:
1427: return SYMBOL_REF_FLAG (addr) ? 1 : 2;
1428:
1429: case PLUS:
1430: {
1431: register rtx plus0 = XEXP (addr, 0);
1432: register rtx plus1 = XEXP (addr, 1);
1433:
1434: if (GET_CODE (plus0) != REG && GET_CODE (plus1) == REG)
1435: {
1436: plus0 = XEXP (addr, 1);
1437: plus1 = XEXP (addr, 0);
1438: }
1439:
1440: if (GET_CODE (plus0) != REG)
1441: break;
1442:
1443: switch (GET_CODE (plus1))
1444: {
1445: case CONST_INT:
1446: {
1447: int value = INTVAL (plus1);
1448: return (value < -32768 || value > 32767) ? 2 : 1;
1449: }
1450:
1451: case CONST:
1452: case SYMBOL_REF:
1453: case LABEL_REF:
1454: case HIGH:
1455: case LO_SUM:
1456: return mips_address_cost (plus1) + 1;
1457: }
1458: }
1459: }
1460:
1461: return 4;
1462: }
1463:
1464:
1465: /* Emit the common code for doing conditional branches.
1466: operand[0] is the label to jump to.
1467: The comparison operands are saved away by cmp{si,sf,df}. */
1468:
1469: void
1470: gen_conditional_branch (operands, test_code)
1471: rtx operands[];
1472: enum rtx_code test_code;
1473: {
1474: enum {
1475: I_EQ,
1476: I_NE,
1477: I_GT,
1478: I_GE,
1479: I_LT,
1480: I_LE,
1481: I_GTU,
1482: I_GEU,
1483: I_LTU,
1484: I_LEU,
1485: I_MAX
1486: } test = I_MAX;
1487:
1488: static enum machine_mode mode_map[(int)CMP_MAX][(int)I_MAX] = {
1489: { /* CMP_SI */
1490: CC_EQmode, /* eq */
1491: CC_EQmode, /* ne */
1492: CCmode, /* gt */
1493: CCmode, /* ge */
1494: CCmode, /* lt */
1495: CCmode, /* le */
1496: CCmode, /* gtu */
1497: CCmode, /* geu */
1498: CCmode, /* ltu */
1499: CCmode, /* leu */
1500: },
1501: { /* CMP_SF */
1502: CC_FPmode, /* eq */
1503: CC_FPmode, /* ne */
1504: CC_FPmode, /* gt */
1505: CC_FPmode, /* ge */
1506: CC_FPmode, /* lt */
1507: CC_FPmode, /* le */
1508: VOIDmode, /* gtu */
1509: VOIDmode, /* geu */
1510: VOIDmode, /* ltu */
1511: VOIDmode, /* leu */
1512: },
1513: { /* CMP_DF */
1514: CC_FPmode, /* eq */
1515: CC_FPmode, /* ne */
1516: CC_FPmode, /* gt */
1517: CC_FPmode, /* ge */
1518: CC_FPmode, /* lt */
1519: CC_FPmode, /* le */
1520: VOIDmode, /* gtu */
1521: VOIDmode, /* geu */
1522: VOIDmode, /* ltu */
1523: VOIDmode, /* leu */
1524: },
1525: };
1526:
1527: enum machine_mode mode;
1528: enum cmp_type type = branch_type;
1529: rtx cmp0 = branch_cmp[0];
1530: rtx cmp1 = branch_cmp[1];
1531: rtx label = gen_rtx (LABEL_REF, VOIDmode, operands[0]);
1532:
1533: /* Make normal rtx_code into something we can index from an array */
1534: switch (test_code)
1535: {
1536: case EQ: test = I_EQ; break;
1537: case NE: test = I_NE; break;
1538: case GT: test = I_GT; break;
1539: case GE: test = I_GE; break;
1540: case LT: test = I_LT; break;
1541: case LE: test = I_LE; break;
1542: case GTU: test = I_GTU; break;
1543: case GEU: test = I_GEU; break;
1544: case LTU: test = I_LTU; break;
1545: case LEU: test = I_LEU; break;
1546: }
1547:
1548: if (test == I_MAX)
1549: {
1550: mode = CCmode;
1551: goto fail;
1552: }
1553:
1554: /* Get the machine mode to use (CCmode, CC_EQmode, or CC_FPmode). */
1555: mode = mode_map[(int)type][(int)test];
1556: if (mode == VOIDmode)
1557: goto fail;
1558:
1559: switch (branch_type)
1560: {
1561: default:
1562: goto fail;
1563:
1564: case CMP_SI:
1565: /* Change >, >=, <, <= tests against 0 to use CC_0mode, since we have
1566: special instructions to do these tests directly. */
1567:
1568: if (mode == CCmode && GET_CODE (cmp1) == CONST_INT && INTVAL (cmp1) == 0)
1569: {
1570: emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, cmp0));
1571: mode = CC_0mode;
1572: }
1573:
1574: else if (mode == CCmode && GET_CODE (cmp0) == CONST_INT && INTVAL (cmp0) == 0)
1575: {
1576: emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, cmp1));
1577: test_code = reverse_condition (test_code);
1578: mode = CC_0mode;
1579: }
1580:
1581: else
1582: {
1583: /* force args to register for equality comparisons. */
1584: if (mode == CC_EQmode && GET_CODE (cmp1) == CONST_INT && INTVAL (cmp1) != 0)
1585: cmp1 = force_reg (SImode, cmp1);
1586:
1587: emit_insn (gen_rtx (SET, VOIDmode,
1588: cc0_rtx,
1589: gen_rtx (COMPARE, mode, cmp0, cmp1)));
1590: }
1591: break;
1592:
1593: case CMP_DF:
1594: emit_insn (gen_cmpdf_internal (cmp0, cmp1));
1595: break;
1596:
1597: case CMP_SF:
1598: emit_insn (gen_cmpsf_internal (cmp0, cmp1));
1599: break;
1600: }
1601:
1602: /* Generate the jump */
1603: emit_jump_insn (gen_rtx (SET, VOIDmode,
1604: pc_rtx,
1605: gen_rtx (IF_THEN_ELSE, VOIDmode,
1606: gen_rtx (test_code, mode, cc0_rtx, const0_rtx),
1607: label,
1608: pc_rtx)));
1609: return;
1610:
1611: fail:
1612: abort_with_insn (gen_rtx (test_code, mode, cmp0, cmp1), "bad test");
1613: }
1614:
1615:
1616: #define UNITS_PER_SHORT (SHORT_TYPE_SIZE / BITS_PER_UNIT)
1617:
1618: /* Internal code to generate the load and store of one word/short/byte.
1619: The load is emitted directly, and the store insn is returned. */
1620:
1621: static rtx
1622: block_move_load_store (dest_reg, src_reg, p_bytes, p_offset, align)
1623: rtx src_reg; /* register holding source memory addresss */
1624: rtx dest_reg; /* register holding dest. memory addresss */
1625: int *p_bytes; /* pointer to # bytes remaining */
1626: int *p_offset; /* pointer to current offset */
1627: int align; /* alignment */
1628: {
1629: int bytes; /* # bytes remaining */
1630: int offset; /* offset to use */
1631: int size; /* size in bytes of load/store */
1632: enum machine_mode mode; /* mode to use for load/store */
1633: rtx reg; /* temporary register */
1634: rtx src_addr; /* source address */
1635: rtx dest_addr; /* destintation address */
1636: rtx (*load_func)(); /* function to generate load insn */
1637: rtx (*store_func)(); /* function to generate destination insn */
1638:
1639: bytes = *p_bytes;
1640: if (bytes <= 0 || align <= 0)
1641: abort ();
1642:
1643: if (bytes >= UNITS_PER_WORD && align >= UNITS_PER_WORD)
1644: {
1645: mode = SImode;
1646: size = UNITS_PER_WORD;
1647: load_func = gen_movsi;
1648: store_func = gen_movsi;
1649: }
1650:
1651: else if (bytes >= UNITS_PER_WORD)
1652: {
1653: mode = SImode;
1654: size = UNITS_PER_WORD;
1655: load_func = gen_movsi_ulw;
1656: store_func = gen_movsi_usw;
1657: }
1658:
1659: else if (bytes >= UNITS_PER_SHORT && align >= UNITS_PER_SHORT)
1660: {
1661: mode = HImode;
1662: size = UNITS_PER_SHORT;
1663: load_func = gen_movhi;
1664: store_func = gen_movhi;
1665: }
1666:
1667: else
1668: {
1669: mode = QImode;
1670: size = 1;
1671: load_func = gen_movqi;
1672: store_func = gen_movqi;
1673: }
1674:
1675: offset = *p_offset;
1676: *p_offset = offset + size;
1677: *p_bytes = bytes - size;
1678:
1679: if (offset == 0)
1680: {
1681: src_addr = src_reg;
1682: dest_addr = dest_reg;
1683: }
1684: else
1685: {
1686: src_addr = gen_rtx (PLUS, Pmode, src_reg, gen_rtx (CONST_INT, VOIDmode, offset));
1687: dest_addr = gen_rtx (PLUS, Pmode, dest_reg, gen_rtx (CONST_INT, VOIDmode, offset));
1688: }
1689:
1690: reg = gen_reg_rtx (mode);
1691: emit_insn ((*load_func) (reg, gen_rtx (MEM, mode, src_addr)));
1692: return (*store_func) (gen_rtx (MEM, mode, dest_addr), reg);
1693: }
1694:
1695:
1696: /* Write a series of loads/stores to move some bytes. Generate load/stores as follows:
1697:
1698: load 1
1699: load 2
1700: load 3
1701: store 1
1702: load 4
1703: store 2
1704: load 5
1705: store 3
1706: ...
1707:
1708: This way, no NOP's are needed, except at the end, and only
1709: two temp registers are needed. Two delay slots are used
1710: in deference to the R4000. */
1711:
1712: static void
1713: block_move_sequence (dest_reg, src_reg, bytes, align)
1714: rtx dest_reg; /* register holding destination address */
1715: rtx src_reg; /* register holding source address */
1716: int bytes; /* # bytes to move */
1717: int align; /* max alignment to assume */
1718: {
1719: int offset = 0;
1720: rtx prev2_store = (rtx)0;
1721: rtx prev_store = (rtx)0;
1722: rtx cur_store = (rtx)0;
1723:
1724: while (bytes > 0)
1725: {
1726: /* Is there a store to do? */
1727: if (prev2_store)
1728: emit_insn (prev2_store);
1729:
1730: prev2_store = prev_store;
1731: prev_store = cur_store;
1732: cur_store = block_move_load_store (dest_reg, src_reg, &bytes, &offset, align);
1733: }
1734:
1735: /* Finish up last three stores. */
1736: if (prev2_store)
1737: emit_insn (prev2_store);
1738:
1739: if (prev_store)
1740: emit_insn (prev_store);
1741:
1742: if (cur_store)
1743: emit_insn (cur_store);
1744: }
1745:
1746:
1747: /* Write a loop to move a constant number of bytes. Generate load/stores as follows:
1748:
1749: do {
1750: temp1 = src[0];
1751: temp2 = src[1];
1752: ...
1753: temp<last> = src[MAX_MOVE_REGS-1];
1754: src += MAX_MOVE_REGS;
1755: dest[0] = temp1;
1756: dest[1] = temp2;
1757: ...
1758: dest[MAX_MOVE_REGS-1] = temp<last>;
1759: dest += MAX_MOVE_REGS;
1760: } while (src != final);
1761:
1762: This way, no NOP's are needed, and only MAX_MOVE_REGS+3 temp
1763: registers are needed.
1764:
1765: Aligned moves move MAX_MOVE_REGS*4 bytes every (2*MAX_MOVE_REGS)+3
1766: cycles, unaligned moves move MAX_MOVE_REGS*4 bytes every
1767: (4*MAX_MOVE_REGS)+3 cycles, assuming no cache misses. */
1768:
1769: #define MAX_MOVE_REGS 4
1770: #define MAX_MOVE_BYTES (MAX_MOVE_REGS * UNITS_PER_WORD)
1771:
1772: static void
1773: block_move_loop (dest_reg, src_reg, bytes, align)
1774: rtx dest_reg; /* register holding destination address */
1775: rtx src_reg; /* register holding source address */
1776: int bytes; /* # bytes to move */
1777: int align; /* alignment */
1778: {
1779: rtx stores[MAX_MOVE_REGS];
1780: rtx label;
1781: rtx final_src;
1782: rtx bytes_rtx;
1783: int i;
1784: int leftover;
1785: int offset;
1786:
1787: if (bytes < 2*MAX_MOVE_BYTES)
1788: abort ();
1789:
1790: leftover = bytes % MAX_MOVE_BYTES;
1791: bytes -= leftover;
1792:
1793: label = gen_label_rtx ();
1794: final_src = gen_reg_rtx (Pmode);
1795: bytes_rtx = gen_rtx (CONST_INT, VOIDmode, bytes);
1796:
1797: if (bytes > 0x7fff)
1798: {
1799: emit_insn (gen_movsi (final_src, bytes_rtx));
1800: emit_insn (gen_addsi3 (final_src, final_src, src_reg));
1801: }
1802: else
1803: emit_insn (gen_addsi3 (final_src, src_reg, bytes_rtx));
1804:
1805: emit_label (label);
1806:
1807: offset = 0;
1808: for (i = 0; i < MAX_MOVE_REGS; i++)
1809: stores[i] = block_move_load_store (dest_reg, src_reg, &bytes, &offset, align);
1810:
1811: emit_insn (gen_addsi3 (src_reg, src_reg, gen_rtx (CONST_INT, VOIDmode, MAX_MOVE_BYTES)));
1812: for (i = 0; i < MAX_MOVE_REGS; i++)
1813: emit_insn (stores[i]);
1814:
1815: emit_insn (gen_addsi3 (dest_reg, dest_reg, gen_rtx (CONST_INT, VOIDmode, MAX_MOVE_BYTES)));
1816: emit_insn (gen_cmpsi (src_reg, final_src));
1817: emit_jump_insn (gen_bne (label));
1818:
1819: if (leftover)
1820: block_move_sequence (dest_reg, src_reg, leftover, align);
1821: }
1822:
1823:
1824: /* Use a library function to move some bytes. */
1825:
1826: static void
1827: block_move_call (dest_reg, src_reg, bytes_rtx)
1828: rtx dest_reg;
1829: rtx src_reg;
1830: rtx bytes_rtx;
1831: {
1832: #ifdef TARGET_MEM_FUNCTIONS
1833: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "memcpy"), 0,
1834: VOIDmode, 3,
1835: dest_reg, Pmode,
1836: src_reg, Pmode,
1837: bytes_rtx, SImode);
1838: #else
1839: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "bcopy"), 0,
1840: VOIDmode, 3,
1841: src_reg, Pmode,
1842: dest_reg, Pmode,
1843: bytes_rtx, SImode);
1844: #endif
1845: }
1846:
1847:
1848: /* Expand string/block move operations.
1849:
1850: operands[0] is the pointer to the destination.
1851: operands[1] is the pointer to the source.
1852: operands[2] is the number of bytes to move.
1853: operands[3] is the alignment. */
1854:
1855: void
1856: expand_block_move (operands)
1857: rtx operands[];
1858: {
1859: rtx bytes_rtx = operands[2];
1860: int constp = (GET_CODE (bytes_rtx) == CONST_INT);
1861: int bytes = (constp ? INTVAL (bytes_rtx) : 0);
1862: int align = INTVAL (operands[3]);
1863: rtx src_reg;
1864: rtx dest_reg;
1865:
1866: if (constp && bytes <= 0)
1867: return;
1868:
1869: /* Move the address into scratch registers. */
1870: dest_reg = copy_addr_to_reg (XEXP (operands[0], 0));
1871: src_reg = copy_addr_to_reg (XEXP (operands[1], 0));
1872:
1873: if (TARGET_MEMCPY)
1874: block_move_call (dest_reg, src_reg, bytes_rtx);
1875:
1876: else if (constp && bytes <= 2*MAX_MOVE_BYTES)
1877: block_move_sequence (dest_reg, src_reg, bytes, align);
1878:
1879: else if (constp && align >= UNITS_PER_WORD && optimize)
1880: block_move_loop (dest_reg, src_reg, bytes, align);
1881:
1882: else if (constp && optimize)
1883: {
1884: /* If the alignment is not word aligned, generate a test at
1885: runtime, to see whether things wound up aligned, and we
1886: can use the faster lw/sw instead ulw/usw. */
1887:
1888: rtx temp = gen_reg_rtx (Pmode);
1889: rtx aligned_label = gen_label_rtx ();
1890: rtx join_label = gen_label_rtx ();
1891: int leftover = bytes % MAX_MOVE_BYTES;
1892:
1893: bytes -= leftover;
1894:
1895: emit_insn (gen_iorsi3 (temp, src_reg, dest_reg));
1896: emit_insn (gen_andsi3 (temp, temp, gen_rtx (CONST_INT, VOIDmode, UNITS_PER_WORD-1)));
1897: emit_insn (gen_cmpsi (temp, const0_rtx));
1898: emit_jump_insn (gen_beq (aligned_label));
1899:
1900: /* Unaligned loop. */
1901: block_move_loop (dest_reg, src_reg, bytes, 1);
1902: emit_jump_insn (gen_jump (join_label));
1903: emit_barrier ();
1904:
1905: /* Aligned loop. */
1906: emit_label (aligned_label);
1907: block_move_loop (dest_reg, src_reg, bytes, UNITS_PER_WORD);
1908: emit_label (join_label);
1909:
1910: /* Bytes at the end of the loop. */
1911: if (leftover)
1912: block_move_sequence (dest_reg, src_reg, leftover, align);
1913: }
1914:
1915: else
1916: block_move_call (dest_reg, src_reg, bytes_rtx);
1917: }
1918:
1919:
1920: /* Argument support functions. */
1921:
1922: /* Initialize CUMULATIVE_ARGS for a function. */
1923:
1924: void
1925: init_cumulative_args (cum, fntype, libname)
1926: CUMULATIVE_ARGS *cum; /* argument info to initialize */
1927: tree fntype; /* tree ptr for function decl */
1928: rtx libname; /* SYMBOL_REF of library name or 0 */
1929: {
1930: tree param, next_param;
1931:
1932: if (TARGET_DEBUG_E_MODE)
1933: fprintf (stderr, "\ninit_cumulative_args\n");
1934:
1935: cum->gp_reg_found = 0;
1936: cum->arg_number = 0;
1937: cum->arg_words = 0;
1938:
1939: /* Determine if this function has variable arguments. This is
1940: indicated by the last argument being 'void_type_mode' if there
1941: are no variable arguments. The standard MIPS calling sequence
1942: passes all arguments in the general purpose registers in this
1943: case. */
1944:
1945: for (param = (fntype) ? TYPE_ARG_TYPES (fntype) : 0;
1946: param != (tree)0;
1947: param = next_param)
1948: {
1949: next_param = TREE_CHAIN (param);
1950: if (next_param == (tree)0 && TREE_VALUE (param) != void_type_node)
1951: cum->gp_reg_found = 1;
1952: }
1953:
1954: /* Determine if the function is returning a structure, if so,
1955: advance by one argument. */
1956:
1957: if (fntype
1958: && (TREE_CODE (fntype) == FUNCTION_TYPE || TREE_CODE (fntype) == METHOD_TYPE)
1959: && TREE_TYPE (fntype) != 0)
1960: {
1961: tree ret_type = TREE_TYPE (fntype);
1962: enum tree_code ret_code = TREE_CODE (ret_type);
1963:
1964: if (ret_code == RECORD_TYPE || ret_code == UNION_TYPE)
1965: {
1966: cum->gp_reg_found = 1;
1967: cum->arg_number = 1;
1968: cum->arg_words = 1;
1969: }
1970: }
1971: }
1972:
1973: /* Advance the argument to the next argument position. */
1974:
1975: void
1976: function_arg_advance (cum, mode, type, named)
1977: CUMULATIVE_ARGS *cum; /* current arg information */
1978: enum machine_mode mode; /* current arg mode */
1979: tree type; /* type of the argument or 0 if lib support */
1980: {
1981: if (TARGET_DEBUG_E_MODE)
1982: fprintf (stderr,
1983: "function_adv( {gp reg found = %d, arg # = %2d, words = %2d}, %4s, 0x%.8x, %d )\n",
1984: cum->gp_reg_found, cum->arg_number, cum->arg_words, GET_MODE_NAME (mode),
1985: type, named);
1986:
1987: cum->arg_number++;
1988: switch (mode)
1989: {
1990: default:
1991: error ("Illegal mode given to function_arg_advance");
1992: break;
1993:
1994: case VOIDmode:
1995: break;
1996:
1997: case BLKmode:
1998: cum->gp_reg_found = 1;
1999: cum->arg_words += (int_size_in_bytes (type) + 3) / 4;
2000: break;
2001:
2002: case SFmode:
2003: cum->arg_words++;
2004: break;
2005:
2006: case DFmode:
2007: cum->arg_words += 2;
2008: break;
2009:
2010: case DImode:
2011: cum->gp_reg_found = 1;
2012: cum->arg_words += 2;
2013: break;
2014:
2015: case QImode:
2016: case HImode:
2017: case SImode:
2018: cum->gp_reg_found = 1;
2019: cum->arg_words++;
2020: break;
2021: }
2022: }
2023:
2024: /* Return a RTL expression containing the register for the given mode,
2025: or 0 if the argument is too be passed on the stack. */
2026:
2027: struct rtx_def *
2028: function_arg (cum, mode, type, named)
2029: CUMULATIVE_ARGS *cum; /* current arg information */
2030: enum machine_mode mode; /* current arg mode */
2031: tree type; /* type of the argument or 0 if lib support */
2032: int named; /* != 0 for normal args, == 0 for ... args */
2033: {
2034: int regbase = -1;
2035: int bias = 0;
2036:
2037: if (TARGET_DEBUG_E_MODE)
2038: fprintf (stderr,
2039: "function_arg( {gp reg found = %d, arg # = %2d, words = %2d}, %4s, 0x%.8x, %d ) = ",
2040: cum->gp_reg_found, cum->arg_number, cum->arg_words, GET_MODE_NAME (mode),
2041: type, named);
2042:
2043: switch (mode)
2044: {
2045: default:
2046: error ("Illegal mode given to function_arg");
2047: break;
2048:
2049: case SFmode:
2050: if (cum->gp_reg_found || cum->arg_number >= 2)
2051: regbase = GP_ARG_FIRST;
2052: else {
2053: regbase = (TARGET_SOFT_FLOAT) ? GP_ARG_FIRST : FP_ARG_FIRST;
2054: if (cum->arg_words == 1) /* first arg was float */
2055: bias = 1; /* use correct reg */
2056: }
2057:
2058: break;
2059:
2060: case DFmode:
2061: cum->arg_words += (cum->arg_words & 1);
2062: regbase = (cum->gp_reg_found || TARGET_SOFT_FLOAT)
2063: ? GP_ARG_FIRST
2064: : FP_ARG_FIRST;
2065: break;
2066:
2067: case VOIDmode:
2068: case BLKmode:
2069: case QImode:
2070: case HImode:
2071: case SImode:
2072: regbase = GP_ARG_FIRST;
2073: break;
2074:
2075: case DImode:
2076: cum->arg_words += (cum->arg_words & 1);
2077: regbase = GP_ARG_FIRST;
2078: }
2079:
2080: if (cum->arg_words >= MAX_ARGS_IN_REGISTERS)
2081: {
2082: if (TARGET_DEBUG_E_MODE)
2083: fprintf (stderr, "<stack>\n");
2084:
2085: return 0;
2086: }
2087:
2088: if (regbase == -1)
2089: abort ();
2090:
2091: if (TARGET_DEBUG_E_MODE)
2092: fprintf (stderr, "%s\n", reg_names[regbase + cum->arg_words + bias]);
2093:
2094: return gen_rtx (REG, mode, regbase + cum->arg_words + bias);
2095: }
2096:
2097:
2098: int
2099: function_arg_partial_nregs (cum, mode, type, named)
2100: CUMULATIVE_ARGS *cum; /* current arg information */
2101: enum machine_mode mode; /* current arg mode */
2102: tree type; /* type of the argument or 0 if lib support */
2103: int named; /* != 0 for normal args, == 0 for ... args */
2104: {
2105: if (mode == BLKmode && cum->arg_words < MAX_ARGS_IN_REGISTERS)
2106: {
2107: int words = (int_size_in_bytes (type) + 3) / 4;
2108:
2109: if (words + cum->arg_words < MAX_ARGS_IN_REGISTERS)
2110: return 0; /* structure fits in registers */
2111:
2112: if (TARGET_DEBUG_E_MODE)
2113: fprintf (stderr, "function_arg_partial_nregs = %d\n",
2114: MAX_ARGS_IN_REGISTERS - cum->arg_words);
2115:
2116: return MAX_ARGS_IN_REGISTERS - cum->arg_words;
2117: }
2118:
2119: else if (mode == DImode && cum->arg_words == MAX_ARGS_IN_REGISTERS-1)
2120: {
2121: if (TARGET_DEBUG_E_MODE)
2122: fprintf (stderr, "function_arg_partial_nregs = 1\n");
2123:
2124: return 1;
2125: }
2126:
2127: return 0;
2128: }
2129:
2130:
2131: /* Print the options used in the assembly file. */
2132:
2133: static struct {char *name; int value;} target_switches []
2134: = TARGET_SWITCHES;
2135:
2136: void
2137: print_options (out)
2138: FILE *out;
2139: {
2140: int line_len;
2141: int len;
2142: int j;
2143: char **p;
2144: int mask = TARGET_DEFAULT;
2145:
2146: /* Allow assembly language comparisons with -mdebug eliminating the
2147: compiler version number and switch lists. */
2148:
2149: if (TARGET_DEBUG_MODE)
2150: return;
2151:
2152: fprintf (out, "\n # %s %s", language_string, version_string);
2153: #ifdef TARGET_VERSION_INTERNAL
2154: TARGET_VERSION_INTERNAL (out);
2155: #endif
2156: #ifdef __GNUC__
2157: fprintf (out, " compiled by GNU C\n\n");
2158: #else
2159: fprintf (out, " compiled by CC\n\n");
2160: #endif
2161:
2162: fprintf (out, " # Cc1 defaults:");
2163: line_len = 32767;
2164: for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
2165: {
2166: if (target_switches[j].name[0] != '\0'
2167: && target_switches[j].value > 0
2168: && (target_switches[j].value & mask) == target_switches[j].value)
2169: {
2170: mask &= ~ target_switches[j].value;
2171: len = strlen (target_switches[j].name) + 1;
2172: if (len + line_len > 79)
2173: {
2174: line_len = 2;
2175: fputs ("\n #", out);
2176: }
2177: fprintf (out, " -m%s", target_switches[j].name);
2178: line_len += len;
2179: }
2180: }
2181:
2182: fprintf (out, "\n\n # Cc1 arguments (-G value = %d, Cpu = %s, ISA = %d):",
2183: mips_section_threshold, mips_cpu_string, mips_isa);
2184:
2185: line_len = 32767;
2186: for (p = &save_argv[1]; *p != (char *)0; p++)
2187: {
2188: char *arg = *p;
2189: if (*arg == '-')
2190: {
2191: len = strlen (arg) + 1;
2192: if (len + line_len > 79)
2193: {
2194: line_len = 2;
2195: fputs ("\n #", out);
2196: }
2197: fprintf (out, " %s", *p);
2198: line_len += len;
2199: }
2200: }
2201:
2202: fputs ("\n\n", out);
2203: }
2204:
2205:
2206: /* Abort after printing out a specific insn. */
2207:
2208: void
2209: abort_with_insn (insn, reason)
2210: rtx insn;
2211: char *reason;
2212: {
2213: error (reason);
2214: debug_rtx (insn);
2215: abort ();
2216: }
2217:
2218: /* Write a message to stderr (for use in macros expanded in files that do not
2219: include stdio.h). */
2220:
2221: void
2222: trace (s, s1, s2)
2223: char *s, *s1, *s2;
2224: {
2225: fprintf (stderr, s, s1, s2);
2226: }
2227:
2228:
2229: #ifdef SIGINFO
2230:
2231: #include <sys/wait.h>
2232:
2233: static void
2234: siginfo (signo)
2235: int signo;
2236: {
2237: char print_pid[50];
2238: char *argv[4];
2239: pid_t pid;
2240: int status;
2241:
2242: fprintf (stderr, "compiling '%s' in '%s'\n",
2243: (current_function_name != (char *)0) ? current_function_name : "<toplevel>",
2244: (current_function_file != (char *)0) ? current_function_file : "<no file>");
2245:
2246: /* Spawn a ps to tell about current memory usage, etc. */
2247: sprintf (print_pid, "-p%d,%d", getpid (), getppid ());
2248: argv[0] = "ps";
2249: argv[1] = print_pid;
2250: argv[2] = "-ouser,state,pid,pri,nice,wchan,tt,start,usertime,systime,pcpu,cp,inblock,oublock,vsize,rss,pmem,ucomm";
2251: argv[3] = (char *)0;
2252:
2253: pid = vfork ();
2254: if (pid == 0) /* child context */
2255: {
2256: execv ("/usr/bin/ps", argv);
2257: execv ("/usr/sbin/ps", argv);
2258: execvp ("ps", argv);
2259: perror ("ps");
2260: _exit (1);
2261: }
2262:
2263: else if (pid > 0) /* parent context */
2264: {
2265: void (*sigint)(int) = signal (SIGINT, SIG_IGN);
2266: void (*sigquit)(int) = signal (SIGQUIT, SIG_IGN);
2267:
2268: (void) waitpid (pid, &status, 0);
2269:
2270: (void) signal (SIGINT, sigint);
2271: (void) signal (SIGQUIT, sigquit);
2272: }
2273:
2274: signal (SIGINFO, siginfo);
2275: }
2276:
2277: #endif /* SIGINFO */
2278:
2279:
2280: /* Set up the threshold for data to go into the small data area, instead
2281: of the normal data area, and detect any conflicts in the switches. */
2282:
2283: void
2284: override_options ()
2285: {
2286: register int i, start;
2287: register int regno;
2288: register enum machine_mode mode;
2289:
2290: if (g_switch_set)
2291: mips_section_threshold = g_switch_value;
2292:
2293: else
2294: mips_section_threshold = (TARGET_MIPS_AS) ? 8 : 0;
2295:
2296: /* Identify the processor type */
2297: if (mips_cpu_string == (char *)0
2298: || !strcmp (mips_cpu_string, "default")
2299: || !strcmp (mips_cpu_string, "DEFAULT"))
2300: {
2301: mips_cpu_string = "default";
2302: mips_cpu = PROCESSOR_DEFAULT;
2303: }
2304:
2305: else
2306: {
2307: char *p = mips_cpu_string;
2308:
2309: if (*p == 'r' || *p == 'R')
2310: p++;
2311:
2312: /* Since there is no difference between a R2000 and R3000 in
2313: terms of the scheduler, we collapse them into just an R3000. */
2314:
2315: mips_cpu = PROCESSOR_DEFAULT;
2316: switch (*p)
2317: {
2318: case '2':
2319: if (!strcmp (p, "2000") || !strcmp (p, "2k") || !strcmp (p, "2K"))
2320: mips_cpu = PROCESSOR_R3000;
2321: break;
2322:
2323: case '3':
2324: if (!strcmp (p, "3000") || !strcmp (p, "3k") || !strcmp (p, "3K"))
2325: mips_cpu = PROCESSOR_R3000;
2326: break;
2327:
2328: case '4':
2329: if (!strcmp (p, "4000") || !strcmp (p, "4k") || !strcmp (p, "4K"))
2330: mips_cpu = PROCESSOR_R4000;
2331: break;
2332:
2333: case '6':
2334: if (!strcmp (p, "6000") || !strcmp (p, "6k") || !strcmp (p, "6K"))
2335: mips_cpu = PROCESSOR_R6000;
2336: break;
2337: }
2338:
2339: if (mips_cpu == PROCESSOR_DEFAULT)
2340: {
2341: error ("bad value (%s) for -mcpu= switch", mips_cpu_string);
2342: mips_cpu_string = "default";
2343: }
2344: }
2345:
2346: /* Now get the architectural level. */
2347: if (mips_isa_string == (char *)0)
2348: mips_isa = 1;
2349:
2350: else if (isdigit (*mips_isa_string))
2351: mips_isa = atoi (mips_isa_string);
2352:
2353: else
2354: {
2355: error ("bad value (%s) for -mips switch", mips_isa_string);
2356: mips_isa = 1;
2357: }
2358:
2359: if (mips_isa < 0 || mips_isa > 3)
2360: error ("-mips%d not supported", mips_isa);
2361:
2362: else if (mips_isa > 1
2363: && (mips_cpu == PROCESSOR_DEFAULT || mips_cpu == PROCESSOR_R3000))
2364: error ("-mcpu=%s does not support -mips%d", mips_cpu_string, mips_isa);
2365:
2366: else if (mips_cpu == PROCESSOR_R6000 && mips_isa > 2)
2367: error ("-mcpu=%s does not support -mips%d", mips_cpu_string, mips_isa);
2368:
2369: /* make sure sizes of ints/longs/etc. are ok */
2370: if (mips_isa < 3)
2371: {
2372: if (TARGET_INT64)
2373: fatal ("Only the r4000 can support 64 bit ints");
2374:
2375: else if (TARGET_LONG64)
2376: fatal ("Only the r4000 can support 64 bit longs");
2377:
2378: else if (TARGET_LLONG128)
2379: fatal ("Only the r4000 can support 128 bit long longs");
2380:
2381: else if (TARGET_FLOAT64)
2382: fatal ("Only the r4000 can support 64 bit fp registers");
2383: }
2384: else if (TARGET_INT64 || TARGET_LONG64 || TARGET_LLONG128 || TARGET_FLOAT64)
2385: warning ("r4000 64/128 bit types not yet supported");
2386:
2387: /* Tell halfpic.c that we have half-pic code if we do. */
2388: if (TARGET_HALF_PIC)
2389: HALF_PIC_INIT ();
2390:
2391: /* -mrnames says to use the MIPS software convention for register
2392: names instead of the hardware names (ie, a0 instead of $4).
2393: We do this by switching the names in mips_reg_names, which the
2394: reg_names points into via the REGISTER_NAMES macro. */
2395:
2396: if (TARGET_NAME_REGS)
2397: {
2398: if (TARGET_GAS)
2399: {
2400: target_flags &= ~ MASK_NAME_REGS;
2401: error ("Gas does not support the MIPS software register name convention.");
2402: }
2403: else
2404: bcopy ((char *) mips_sw_reg_names, (char *) mips_reg_names, sizeof (mips_reg_names));
2405: }
2406:
2407: /* If this is OSF/1, set up a SIGINFO handler so we can see what function
2408: is currently being compiled. */
2409: #ifdef SIGINFO
2410: if (getenv ("GCC_SIGINFO") != (char *)0)
2411: {
2412: struct sigaction action;
2413: action.sa_handler = siginfo;
2414: action.sa_mask = 0;
2415: action.sa_flags = SA_RESTART;
2416: sigaction (SIGINFO, &action, (struct sigaction *)0);
2417: }
2418: #endif
2419:
2420: /* Set up the classificaiton arrays now. */
2421: mips_rtx_classify[(int)PLUS] = CLASS_ADD_OP;
2422: mips_rtx_classify[(int)MINUS] = CLASS_ADD_OP;
2423: mips_rtx_classify[(int)DIV] = CLASS_DIVMOD_OP;
2424: mips_rtx_classify[(int)MOD] = CLASS_DIVMOD_OP;
2425: mips_rtx_classify[(int)UDIV] = CLASS_DIVMOD_OP | CLASS_UNSIGNED_OP;
2426: mips_rtx_classify[(int)UMOD] = CLASS_DIVMOD_OP | CLASS_UNSIGNED_OP;
2427: mips_rtx_classify[(int)EQ] = CLASS_CMP_OP | CLASS_EQUALITY_OP | CLASS_FCMP_OP;
2428: mips_rtx_classify[(int)NE] = CLASS_CMP_OP | CLASS_EQUALITY_OP | CLASS_FCMP_OP;
2429: mips_rtx_classify[(int)GT] = CLASS_CMP_OP | CLASS_FCMP_OP;
2430: mips_rtx_classify[(int)GE] = CLASS_CMP_OP | CLASS_FCMP_OP;
2431: mips_rtx_classify[(int)LT] = CLASS_CMP_OP | CLASS_FCMP_OP;
2432: mips_rtx_classify[(int)LE] = CLASS_CMP_OP | CLASS_FCMP_OP;
2433: mips_rtx_classify[(int)GTU] = CLASS_CMP_OP | CLASS_UNSIGNED_OP;
2434: mips_rtx_classify[(int)GEU] = CLASS_CMP_OP | CLASS_UNSIGNED_OP;
2435: mips_rtx_classify[(int)LTU] = CLASS_CMP_OP | CLASS_UNSIGNED_OP;
2436: mips_rtx_classify[(int)LEU] = CLASS_CMP_OP | CLASS_UNSIGNED_OP;
2437:
2438: mips_print_operand_punct['?'] = TRUE;
2439: mips_print_operand_punct['#'] = TRUE;
2440: mips_print_operand_punct['&'] = TRUE;
2441: mips_print_operand_punct['!'] = TRUE;
2442: mips_print_operand_punct['*'] = TRUE;
2443: mips_print_operand_punct['@'] = TRUE;
2444: mips_print_operand_punct['.'] = TRUE;
2445: mips_print_operand_punct['('] = TRUE;
2446: mips_print_operand_punct[')'] = TRUE;
2447: mips_print_operand_punct['['] = TRUE;
2448: mips_print_operand_punct[']'] = TRUE;
2449: mips_print_operand_punct['<'] = TRUE;
2450: mips_print_operand_punct['>'] = TRUE;
2451: mips_print_operand_punct['{'] = TRUE;
2452: mips_print_operand_punct['}'] = TRUE;
2453:
2454: mips_char_to_class['d'] = GR_REGS;
2455: mips_char_to_class['f'] = ((TARGET_HARD_FLOAT) ? FP_REGS : NO_REGS);
2456: mips_char_to_class['h'] = HI_REG;
2457: mips_char_to_class['l'] = LO_REG;
2458: mips_char_to_class['s'] = ST_REGS;
2459: mips_char_to_class['x'] = MD_REGS;
2460: mips_char_to_class['y'] = GR_REGS;
2461:
2462: /* Set up array to map GCC register number to debug register number.
2463: Ignore the special purpose register numbers. */
2464:
2465: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2466: mips_dbx_regno[i] = -1;
2467:
2468: start = GP_DBX_FIRST - GP_REG_FIRST;
2469: for (i = GP_REG_FIRST; i <= GP_REG_LAST; i++)
2470: mips_dbx_regno[i] = i + start;
2471:
2472: start = FP_DBX_FIRST - FP_REG_FIRST;
2473: for (i = FP_REG_FIRST; i <= FP_REG_LAST; i++)
2474: mips_dbx_regno[i] = i + start;
2475:
2476: /* Set up array giving whether a given register can hold a given mode.
2477: At present, restrict ints from being in FP registers, because reload
2478: is a little enthusiastic about storing extra values in FP registers,
2479: and this is not good for things like OS kernels. Also, due to the
2480: manditory delay, it is as fast to load from cached memory as to move
2481: from the FP register. */
2482:
2483: for (mode = VOIDmode;
2484: mode != MAX_MACHINE_MODE;
2485: mode = (enum machine_mode)((int)mode + 1))
2486: {
2487: register int size = GET_MODE_SIZE (mode);
2488: register enum mode_class class = GET_MODE_CLASS (mode);
2489:
2490: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
2491: {
2492: register int temp = FALSE;
2493:
2494: if (GP_REG_P (regno))
2495: temp = ((regno & 1) == 0 || (size <= UNITS_PER_WORD));
2496:
2497: else if (FP_REG_P (regno))
2498: temp = ((TARGET_FLOAT64 || ((regno & 1) == 0))
2499: && (TARGET_DEBUG_H_MODE
2500: || class == MODE_FLOAT
2501: || class == MODE_COMPLEX_FLOAT));
2502:
2503: else if (MD_REG_P (regno))
2504: temp = (mode == SImode || (regno == MD_REG_FIRST && mode == DImode));
2505:
2506: else if (ST_REG_P (regno))
2507: temp = ((mode == SImode) || (class == MODE_CC));
2508:
2509: mips_hard_regno_mode_ok[(int)mode][regno] = temp;
2510: }
2511: }
2512: }
2513:
2514:
2515: /*
2516: * If the frame pointer has been eliminated, the offset for an auto
2517: * or argument will be based on the stack pointer. But this is not
2518: * what the debugger expects--it needs to find an offset off of the
2519: * frame pointer (whether it exists or not). So here we turn all
2520: * offsets into those based on the (possibly virtual) frame pointer.
2521: */
2522:
2523: int
2524: mips_debugger_offset (addr, offset)
2525: rtx addr;
2526: int offset;
2527: {
2528: int offset2 = 0;
2529: rtx reg = eliminate_constant_term (addr, &offset2);
2530:
2531: if (!offset)
2532: offset = offset2;
2533:
2534: if (reg == stack_pointer_rtx)
2535: {
2536: int frame_size = (!current_frame_info.initialized)
2537: ? compute_frame_size (get_frame_size ())
2538: : current_frame_info.total_size;
2539:
2540: offset = offset - frame_size;
2541: }
2542:
2543: /* Any other register is, we hope, either the frame pointer,
2544: or a pseudo equivalent to the frame pointer. (Assign_parms
2545: copies the arg pointer to a pseudo if ARG_POINTER_REGNUM is
2546: equal to FRAME_POINTER_REGNUM, so references off of the
2547: arg pointer are all off a pseudo.) Seems like all we can
2548: do is to just return OFFSET and hope for the best. */
2549:
2550: return offset;
2551: }
2552:
2553: /* A C compound statement to output to stdio stream STREAM the
2554: assembler syntax for an instruction operand X. X is an RTL
2555: expression.
2556:
2557: CODE is a value that can be used to specify one of several ways
2558: of printing the operand. It is used when identical operands
2559: must be printed differently depending on the context. CODE
2560: comes from the `%' specification that was used to request
2561: printing of the operand. If the specification was just `%DIGIT'
2562: then CODE is 0; if the specification was `%LTR DIGIT' then CODE
2563: is the ASCII code for LTR.
2564:
2565: If X is a register, this macro should print the register's name.
2566: The names can be found in an array `reg_names' whose type is
2567: `char *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
2568:
2569: When the machine description has a specification `%PUNCT' (a `%'
2570: followed by a punctuation character), this macro is called with
2571: a null pointer for X and the punctuation character for CODE.
2572:
2573: The MIPS specific codes are:
2574:
2575: 'X' X is CONST_INT, prints 32 bits in hexadecimal format = "0x%08x",
2576: 'x' X is CONST_INT, prints 16 bits in hexadecimal format = "0x%04x",
2577: 'd' output integer constant in decimal,
2578: 'z' if the operand is 0, use $0 instead of normal operand.
2579: 'D' print second register of double-word register operand.
2580: 'L' print low-order register of double-word register operand.
2581: 'M' print high-order register of double-word register operand.
2582: 'C' print part of opcode for a branch condition.
2583: 'N' print part of opcode for a branch condition, inverted.
2584: '(' Turn on .set noreorder
2585: ')' Turn on .set reorder
2586: '[' Turn on .set noat
2587: ']' Turn on .set at
2588: '<' Turn on .set nomacro
2589: '>' Turn on .set macro
2590: '{' Turn on .set volatile (not GAS)
2591: '}' Turn on .set novolatile (not GAS)
2592: '&' Turn on .set noreorder if filling delay slots
2593: '*' Turn on both .set noreorder and .set nomacro if filling delay slots
2594: '!' Turn on .set nomacro if filling delay slots
2595: '#' Print nop if in a .set noreorder section.
2596: '?' Print 'l' if we are to use a branch likely instead of normal branch.
2597: '@' Print the name of the assembler temporary register (at or $1).
2598: '.' Print the name of the register with a hard-wired zero (zero or $0). */
2599:
2600: void
2601: print_operand (file, op, letter)
2602: FILE *file; /* file to write to */
2603: rtx op; /* operand to print */
2604: int letter; /* %<letter> or 0 */
2605: {
2606: register enum rtx_code code;
2607:
2608: if (PRINT_OPERAND_PUNCT_VALID_P (letter))
2609: {
2610: switch (letter)
2611: {
2612: default:
2613: error ("PRINT_OPERAND: Unknown punctuation '%c'", letter);
2614: break;
2615:
2616: case '?':
2617: if (mips_branch_likely)
2618: putc ('l', file);
2619: break;
2620:
2621: case '@':
2622: fputs (reg_names [GP_REG_FIRST + 1], file);
2623: break;
2624:
2625: case '.':
2626: fputs (reg_names [GP_REG_FIRST + 0], file);
2627: break;
2628:
2629: case '&':
2630: if (final_sequence != 0 && set_noreorder++ == 0)
2631: fputs (".set\tnoreorder\n\t", file);
2632: break;
2633:
2634: case '*':
2635: if (final_sequence != 0)
2636: {
2637: if (set_noreorder++ == 0)
2638: fputs (".set\tnoreorder\n\t", file);
2639:
2640: if (set_nomacro++ == 0)
2641: fputs (".set\tnomacro\n\t", file);
2642: }
2643: break;
2644:
2645: case '!':
2646: if (final_sequence != 0 && set_nomacro++ == 0)
2647: fputs ("\n\t.set\tnomacro", file);
2648: break;
2649:
2650: case '#':
2651: if (set_noreorder != 0)
2652: fputs ("\n\tnop", file);
2653:
2654: else if (TARGET_GAS || TARGET_STATS)
2655: fputs ("\n\t#nop", file);
2656:
2657: break;
2658:
2659: case '(':
2660: if (set_noreorder++ == 0)
2661: fputs (".set\tnoreorder\n\t", file);
2662: break;
2663:
2664: case ')':
2665: if (set_noreorder == 0)
2666: error ("internal error: %%) found without a %%( in assembler pattern");
2667:
2668: else if (--set_noreorder == 0)
2669: fputs ("\n\t.set\treorder", file);
2670:
2671: break;
2672:
2673: case '[':
2674: if (set_noat++ == 0)
2675: fputs (".set\tnoat\n\t", file);
2676: break;
2677:
2678: case ']':
2679: if (set_noat == 0)
2680: error ("internal error: %%] found without a %%[ in assembler pattern");
2681:
2682: else if (--set_noat == 0)
2683: fputs ("\n\t.set\tat", file);
2684:
2685: break;
2686:
2687: case '<':
2688: if (set_nomacro++ == 0)
2689: fputs (".set\tnomacro\n\t", file);
2690: break;
2691:
2692: case '>':
2693: if (set_nomacro == 0)
2694: error ("internal error: %%> found without a %%< in assembler pattern");
2695:
2696: else if (--set_nomacro == 0)
2697: fputs ("\n\t.set\tmacro", file);
2698:
2699: break;
2700:
2701: case '{':
2702: if (set_volatile++ == 0)
2703: fprintf (file, "%s.set\tvolatile\n\t", (TARGET_MIPS_AS) ? "" : "#");
2704: break;
2705:
2706: case '}':
2707: if (set_volatile == 0)
2708: error ("internal error: %%} found without a %%{ in assembler pattern");
2709:
2710: else if (--set_volatile == 0)
2711: fprintf (file, "\n\t%s.set\tnovolatile", (TARGET_MIPS_AS) ? "" : "#");
2712:
2713: break;
2714: }
2715: return;
2716: }
2717:
2718: if (! op)
2719: {
2720: error ("PRINT_OPERAND null pointer");
2721: return;
2722: }
2723:
2724: code = GET_CODE (op);
2725: if (letter == 'C')
2726: switch (code)
2727: {
2728: case EQ: fputs ("eq", file); break;
2729: case NE: fputs ("ne", file); break;
2730: case GT: fputs ("gt", file); break;
2731: case GE: fputs ("ge", file); break;
2732: case LT: fputs ("lt", file); break;
2733: case LE: fputs ("le", file); break;
2734: case GTU: fputs ("gtu", file); break;
2735: case GEU: fputs ("geu", file); break;
2736: case LTU: fputs ("ltu", file); break;
2737: case LEU: fputs ("leu", file); break;
2738:
2739: default:
2740: abort_with_insn (op, "PRINT_OPERAND, illegal insn for %%C");
2741: }
2742:
2743: else if (letter == 'N')
2744: switch (code)
2745: {
2746: case EQ: fputs ("ne", file); break;
2747: case NE: fputs ("eq", file); break;
2748: case GT: fputs ("le", file); break;
2749: case GE: fputs ("lt", file); break;
2750: case LT: fputs ("ge", file); break;
2751: case LE: fputs ("gt", file); break;
2752: case GTU: fputs ("leu", file); break;
2753: case GEU: fputs ("ltu", file); break;
2754: case LTU: fputs ("geu", file); break;
2755: case LEU: fputs ("gtu", file); break;
2756:
2757: default:
2758: abort_with_insn (op, "PRINT_OPERAND, illegal insn for %%N");
2759: }
2760:
2761: else if (code == REG)
2762: {
2763: register int regnum = REGNO (op);
2764:
2765: if (letter == 'M')
2766: regnum += MOST_SIGNIFICANT_WORD;
2767:
2768: else if (letter == 'L')
2769: regnum += LEAST_SIGNIFICANT_WORD;
2770:
2771: else if (letter == 'D')
2772: regnum++;
2773:
2774: fprintf (file, "%s", reg_names[regnum]);
2775: }
2776:
2777: else if (code == MEM)
2778: output_address (XEXP (op, 0));
2779:
2780: else if (code == CONST_DOUBLE)
2781: {
2782: #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
2783: union { double d; int i[2]; } u;
2784: u.i[0] = CONST_DOUBLE_LOW (op);
2785: u.i[1] = CONST_DOUBLE_HIGH (op);
2786: if (GET_MODE (op) == SFmode)
2787: {
2788: float f;
2789: f = u.d;
2790: u.d = f;
2791: }
2792: fprintf (file, "%.20e", u.d);
2793: #else
2794: fatal ("CONST_DOUBLE found in cross compilation");
2795: #endif
2796: }
2797:
2798: else if ((letter == 'x') && (GET_CODE(op) == CONST_INT))
2799: fprintf (file, "0x%04x", 0xffff & (INTVAL(op)));
2800:
2801: else if ((letter == 'X') && (GET_CODE(op) == CONST_INT))
2802: fprintf (file, "0x%08x", INTVAL(op));
2803:
2804: else if ((letter == 'd') && (GET_CODE(op) == CONST_INT))
2805: fprintf (file, "%d", (INTVAL(op)));
2806:
2807: else if (letter == 'z'
2808: && (GET_CODE (op) == CONST_INT)
2809: && INTVAL (op) == 0)
2810: fputs (reg_names[GP_REG_FIRST], file);
2811:
2812: else if (letter == 'd' || letter == 'x' || letter == 'X')
2813: fatal ("PRINT_OPERAND: letter %c was found & insn was not CONST_INT", letter);
2814:
2815: else
2816: output_addr_const (file, op);
2817: }
2818:
2819:
2820: /* A C compound statement to output to stdio stream STREAM the
2821: assembler syntax for an instruction operand that is a memory
2822: reference whose address is ADDR. ADDR is an RTL expression.
2823:
2824: On some machines, the syntax for a symbolic address depends on
2825: the section that the address refers to. On these machines,
2826: define the macro `ENCODE_SECTION_INFO' to store the information
2827: into the `symbol_ref', and then check for it here. */
2828:
2829: void
2830: print_operand_address (file, addr)
2831: FILE *file;
2832: rtx addr;
2833: {
2834: if (!addr)
2835: error ("PRINT_OPERAND_ADDRESS, null pointer");
2836:
2837: else
2838: switch (GET_CODE (addr))
2839: {
2840: default:
2841: abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, illegal insn #1");
2842: break;
2843:
2844: case REG:
2845: fprintf (file, "0(%s)", reg_names [REGNO (addr)]);
2846: break;
2847:
2848: case PLUS:
2849: {
2850: register rtx reg = (rtx)0;
2851: register rtx offset = (rtx)0;
2852: register rtx arg0 = XEXP (addr, 0);
2853: register rtx arg1 = XEXP (addr, 1);
2854:
2855: if (GET_CODE (arg0) == REG)
2856: {
2857: reg = arg0;
2858: offset = arg1;
2859: if (GET_CODE (offset) == REG)
2860: abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, 2 regs");
2861: }
2862: else if (GET_CODE (arg1) == REG)
2863: {
2864: reg = arg1;
2865: offset = arg0;
2866: }
2867: else if (CONSTANT_P (arg0) && CONSTANT_P (arg1))
2868: {
2869: output_addr_const (file, addr);
2870: break;
2871: }
2872: else
2873: abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, no regs");
2874:
2875: if (!CONSTANT_P (offset))
2876: abort_with_insn (addr, "PRINT_OPERAND_ADDRESS, illegal insn #2");
2877:
2878: output_addr_const (file, offset);
2879: fprintf (file, "(%s)", reg_names [REGNO (reg)]);
2880: }
2881: break;
2882:
2883: case LABEL_REF:
2884: case SYMBOL_REF:
2885: case CONST_INT:
2886: case CONST:
2887: output_addr_const (file, addr);
2888: break;
2889: }
2890: }
2891:
2892:
2893: /* If optimizing for the global pointer, keep track of all of
2894: the externs, so that at the end of the file, we can emit
2895: the appropriate .extern declaration for them, before writing
2896: out the text section. We assume that all names passed to
2897: us are in the permanent obstack, so that they will be valid
2898: at the end of the compilation.
2899:
2900: If we have -G 0, or the extern size is unknown, don't bother
2901: emitting the .externs. */
2902:
2903: int
2904: mips_output_external (file, decl, name)
2905: FILE *file;
2906: tree decl;
2907: char *name;
2908: {
2909: register struct extern_list *p;
2910: int len;
2911:
2912: if (TARGET_GP_OPT
2913: && mips_section_threshold != 0
2914: && ((TREE_CODE (decl)) != FUNCTION_DECL)
2915: && ((len = int_size_in_bytes (TREE_TYPE (decl))) > 0))
2916: {
2917: p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list));
2918: p->next = extern_head;
2919: p->name = name;
2920: p->size = len;
2921: extern_head = p;
2922: }
2923: return 0;
2924: }
2925:
2926:
2927: /* Compute a string to use as a temporary file name. */
2928:
2929: static FILE *
2930: make_temp_file ()
2931: {
2932: FILE *stream;
2933: char *base = getenv ("TMPDIR");
2934: int len;
2935:
2936: if (base == (char *)0)
2937: {
2938: #ifdef P_tmpdir
2939: if (access (P_tmpdir, R_OK | W_OK) == 0)
2940: base = P_tmpdir;
2941: else
2942: #endif
2943: if (access ("/usr/tmp", R_OK | W_OK) == 0)
2944: base = "/usr/tmp/";
2945: else
2946: base = "/tmp/";
2947: }
2948:
2949: len = strlen (base);
2950: temp_filename = (char *) alloca (len + sizeof("/ccXXXXXX"));
2951: strcpy (temp_filename, base);
2952: if (len > 0 && temp_filename[len-1] != '/')
2953: temp_filename[len++] = '/';
2954:
2955: strcpy (temp_filename + len, "ccXXXXXX");
2956: mktemp (temp_filename);
2957:
2958: stream = fopen (temp_filename, "w+");
2959: if (!stream)
2960: pfatal_with_name (temp_filename);
2961:
2962: unlink (temp_filename);
2963: return stream;
2964: }
2965:
2966:
2967: /* Emit a new filename to a stream. If this is MIPS ECOFF, watch out
2968: for .file's that start within a function. If we are smuggling stabs, try to
2969: put out a MIPS ECOFF file and a stab. */
2970:
2971: void
2972: mips_output_filename (stream, name)
2973: FILE *stream;
2974: char *name;
2975: {
2976: static int first_time = TRUE;
2977: char ltext_label_name[100];
2978:
2979: if (first_time)
2980: {
2981: first_time = FALSE;
2982: SET_FILE_NUMBER ();
2983: current_function_file = name;
2984: fprintf (stream, "\t.file\t%d \"%s\"\n", num_source_filenames, name);
2985: }
2986:
2987: else if (!TARGET_GAS && write_symbols == DBX_DEBUG)
2988: {
2989: ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
2990: fprintf (stream, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP,
2991: name, N_SOL, <ext_label_name[1]);
2992: }
2993:
2994: else if (name != current_function_file
2995: && strcmp (name, current_function_file) != 0)
2996: {
2997: if (inside_function && !TARGET_GAS)
2998: {
2999: if (!file_in_function_warning)
3000: {
3001: file_in_function_warning = TRUE;
3002: ignore_line_number = TRUE;
3003: warning ("MIPS ECOFF format does not allow changing filenames within functions with #line");
3004: }
3005:
3006: fprintf (stream, "\t#.file\t%d \"%s\"\n", num_source_filenames, name);
3007: }
3008:
3009: else
3010: {
3011: SET_FILE_NUMBER ();
3012: current_function_file = name;
3013: fprintf (stream, "\t.file\t%d \"%s\"\n", num_source_filenames, name);
3014: }
3015: }
3016: }
3017:
3018:
3019: /* Emit a linenumber. For encapsulated stabs, we need to put out a stab
3020: as well as a .loc, since it is possible that MIPS ECOFF might not be
3021: able to represent the location for inlines that come from a different
3022: file. */
3023:
3024: void
3025: mips_output_lineno (stream, line)
3026: FILE *stream;
3027: int line;
3028: {
3029: if (!TARGET_GAS && write_symbols == DBX_DEBUG)
3030: {
3031: ++sym_lineno;
3032: fprintf (stream, "$LM%d:\n\t%s %d,0,%d,$LM%d\n",
3033: sym_lineno, ASM_STABN_OP, N_SLINE, line, sym_lineno);
3034: }
3035:
3036: else
3037: {
3038: fprintf (stream, "\n\t%s.loc\t%d %d\n",
3039: (ignore_line_number) ? "#" : "",
3040: num_source_filenames, line);
3041:
3042: LABEL_AFTER_LOC (stream);
3043: }
3044: }
3045:
3046:
3047: /* Output at beginning of assembler file.
3048: If we are optimizing to use the global pointer, create a temporary
3049: file to hold all of the text stuff, and write it out to the end.
3050: This is needed because the MIPS assembler is evidently one pass,
3051: and if it hasn't seen the relevant .comm/.lcomm/.extern/.sdata
3052: declaration when the code is processed, it generates a two
3053: instruction sequence. */
3054:
3055: void
3056: mips_asm_file_start (stream)
3057: FILE *stream;
3058: {
3059: ASM_OUTPUT_SOURCE_FILENAME (stream, main_input_filename);
3060:
3061: /* Versions of the MIPS assembler before 2.20 generate errors
3062: if a branch inside of a .set noreorder section jumps to a
3063: label outside of the .set noreorder section. Revision 2.20
3064: just set nobopt silently rather than fixing the bug. */
3065:
3066: if (TARGET_MIPS_AS && optimize && flag_delayed_branch)
3067: fprintf (stream, "\t.set\tnobopt\n");
3068:
3069: /* Generate the pseudo ops that the Pyramid based System V.4 wants. */
3070: if (TARGET_ABICALLS)
3071: fprintf (stream, "\t.abicalls\n");
3072:
3073: /* put gcc_compiled. in data, not text */
3074: data_section ();
3075:
3076: if (TARGET_GP_OPT)
3077: {
3078: asm_out_data_file = stream;
3079: asm_out_text_file = make_temp_file ();
3080: }
3081: else
3082: asm_out_data_file = asm_out_text_file = stream;
3083:
3084: if (TARGET_NAME_REGS)
3085: fprintf (asm_out_file, "#include <regdef.h>\n");
3086:
3087: print_options (stream);
3088: }
3089:
3090:
3091: /* If we are optimizing the global pointer, emit the text section now
3092: and any small externs which did not have .comm, etc that are
3093: needed. Also, give a warning if the data area is more than 32K and
3094: -pic because 3 instructions are needed to reference the data
3095: pointers. */
3096:
3097: void
3098: mips_asm_file_end (file)
3099: FILE *file;
3100: {
3101: char buffer[8192];
3102: tree name_tree;
3103: struct extern_list *p;
3104: int len;
3105:
3106: if (TARGET_GP_OPT)
3107: {
3108: if (extern_head)
3109: fputs ("\n", file);
3110:
3111: for (p = extern_head; p != 0; p = p->next)
3112: {
3113: name_tree = get_identifier (p->name);
3114: if (!TREE_ADDRESSABLE (name_tree))
3115: {
3116: TREE_ADDRESSABLE (name_tree) = 1;
3117: fputs ("\t.extern\t", file);
3118: assemble_name (file, p->name);
3119: fprintf (file, ", %d\n", p->size);
3120: }
3121: }
3122:
3123: fprintf (file, "\n\t.text\n");
3124: rewind (asm_out_text_file);
3125: if (ferror (asm_out_text_file))
3126: fatal_io_error (temp_filename);
3127:
3128: while ((len = fread (buffer, 1, sizeof (buffer), asm_out_text_file)) > 0)
3129: if (fwrite (buffer, 1, len, file) != len)
3130: pfatal_with_name (asm_file_name);
3131:
3132: if (len < 0)
3133: pfatal_with_name (temp_filename);
3134:
3135: if (fclose (asm_out_text_file) != 0)
3136: pfatal_with_name (temp_filename);
3137: }
3138: }
3139:
3140:
3141: /* Return the bytes needed to compute the frame pointer from the current
3142: stack pointer.
3143:
3144: Mips stack frames look like:
3145:
3146: Before call After call
3147: +-----------------------+ +-----------------------+
3148: high | | | |
3149: mem. | | | |
3150: | caller's temps. | | caller's temps. |
3151: | | | |
3152: +-----------------------+ +-----------------------+
3153: | | | |
3154: | arguments on stack. | | arguments on stack. |
3155: | | | |
3156: +-----------------------+ +-----------------------+
3157: | 4 words to save | | 4 words to save |
3158: | arguments passed | | arguments passed |
3159: | in registers, even | | in registers, even |
3160: SP->| if not passed. | FP->| if not passed. |
3161: +-----------------------+ +-----------------------+
3162: | |
3163: | GP save for V.4 abi |
3164: | |
3165: +-----------------------+
3166: | |
3167: | local variables |
3168: | |
3169: +-----------------------+
3170: | |
3171: | fp register save |
3172: | |
3173: +-----------------------+
3174: | |
3175: | gp register save |
3176: | |
3177: +-----------------------+
3178: | |
3179: | alloca allocations |
3180: | |
3181: +-----------------------+
3182: | |
3183: | arguments on stack |
3184: | |
3185: +-----------------------+
3186: | 4 words to save |
3187: | arguments passed |
3188: | in registers, even |
3189: low SP->| if not passed. |
3190: memory +-----------------------+
3191:
3192: */
3193:
3194: unsigned long
3195: compute_frame_size (size)
3196: int size; /* # of var. bytes allocated */
3197: {
3198: int regno;
3199: unsigned long total_size; /* # bytes that the entire frame takes up */
3200: unsigned long var_size; /* # bytes that variables take up */
3201: unsigned long args_size; /* # bytes that outgoing arguments take up */
3202: unsigned long extra_size; /* # extra bytes */
3203: unsigned int gp_reg_rounded; /* # bytes needed to store gp after rounding */
3204: unsigned int gp_reg_size; /* # bytes needed to store gp regs */
3205: unsigned int fp_reg_size; /* # bytes needed to store fp regs */
3206: unsigned long mask; /* mask of saved gp registers */
3207: unsigned long fmask; /* mask of saved fp registers */
3208: int fp_inc; /* 1 or 2 depending on the size of fp regs */
3209: int fp_bits; /* bitmask to use for each fp register */
3210:
3211: extra_size = MIPS_STACK_ALIGN (((TARGET_ABICALLS) ? UNITS_PER_WORD : 0)
3212: -STARTING_FRAME_OFFSET);
3213:
3214: var_size = MIPS_STACK_ALIGN (size);
3215: args_size = MIPS_STACK_ALIGN (current_function_outgoing_args_size);
3216: total_size = var_size + args_size + extra_size;
3217: gp_reg_size = 0;
3218: fp_reg_size = 0;
3219: mask = 0;
3220: fmask = 0;
3221:
3222: /* Calculate space needed for gp registers. */
3223: for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
3224: {
3225: if (MUST_SAVE_REGISTER (regno))
3226: {
3227: gp_reg_size += UNITS_PER_WORD;
3228: mask |= 1 << (regno - GP_REG_FIRST);
3229: }
3230: }
3231:
3232: /* Calculate space needed for fp registers. */
3233: if (TARGET_FLOAT64)
3234: {
3235: fp_inc = 1;
3236: fp_bits = 1;
3237: }
3238: else
3239: {
3240: fp_inc = 2;
3241: fp_bits = 3;
3242: }
3243:
3244: for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno += fp_inc)
3245: {
3246: if (regs_ever_live[regno] && !call_used_regs[regno])
3247: {
3248: fp_reg_size += 2*UNITS_PER_WORD;
3249: fmask |= fp_bits << (regno - FP_REG_FIRST);
3250: }
3251: }
3252:
3253: gp_reg_rounded = MIPS_STACK_ALIGN (gp_reg_size);
3254: total_size += gp_reg_rounded + fp_reg_size;
3255:
3256: if (total_size == extra_size)
3257: total_size = extra_size = 0;
3258:
3259: /* Save other computed information. */
3260: current_frame_info.total_size = total_size;
3261: current_frame_info.var_size = var_size;
3262: current_frame_info.args_size = args_size;
3263: current_frame_info.extra_size = extra_size;
3264: current_frame_info.gp_reg_size = gp_reg_size;
3265: current_frame_info.fp_reg_size = fp_reg_size;
3266: current_frame_info.mask = mask;
3267: current_frame_info.fmask = fmask;
3268: current_frame_info.initialized = reload_completed;
3269:
3270: if (mask)
3271: {
3272: unsigned long offset = args_size + gp_reg_size - UNITS_PER_WORD;
3273: current_frame_info.gp_sp_offset = offset;
3274: current_frame_info.gp_save_offset = offset - total_size;
3275: }
3276:
3277: if (fmask)
3278: {
3279: unsigned long offset = args_size + gp_reg_rounded + fp_reg_size - 2*UNITS_PER_WORD;
3280: current_frame_info.fp_sp_offset = offset;
3281: current_frame_info.fp_save_offset = offset - total_size + UNITS_PER_WORD;
3282: }
3283:
3284: /* Ok, we're done. */
3285: return total_size;
3286: }
3287:
3288:
3289: /* Common code to save/restore registers. */
3290:
3291: void
3292: save_restore (file, gp_op, gp_2word_op, fp_op)
3293: FILE *file; /* stream to write to */
3294: char *gp_op; /* operation to do on gp registers */
3295: char *gp_2word_op; /* 2 word op to do on gp registers */
3296: char *fp_op; /* operation to do on fp registers */
3297: {
3298: int regno;
3299: unsigned long mask = current_frame_info.mask;
3300: unsigned long fmask = current_frame_info.fmask;
3301: unsigned long gp_offset;
3302: unsigned long fp_offset;
3303: unsigned long max_offset;
3304: char *base_reg;
3305:
3306: if (mask == 0 && fmask == 0)
3307: return;
3308:
3309: base_reg = reg_names[STACK_POINTER_REGNUM];
3310: gp_offset = current_frame_info.gp_sp_offset;
3311: fp_offset = current_frame_info.fp_sp_offset;
3312: max_offset = (gp_offset > fp_offset) ? gp_offset : fp_offset;
3313:
3314: /* Deal with calling functions with a large structure. */
3315: if (max_offset >= 32768)
3316: {
3317: char *temp = reg_names[MIPS_TEMP2_REGNUM];
3318: fprintf (file, "\tli\t%s,%ld\n", temp, max_offset);
3319: fprintf (file, "\taddu\t%s,%s,%s\n", temp, temp, base_reg);
3320: base_reg = temp;
3321: gp_offset = max_offset - gp_offset;
3322: fp_offset = max_offset - fp_offset;
3323: }
3324:
3325: /* Save registers starting from high to low. The debuggers prefer
3326: at least the return register be stored at func+4, and also it
3327: allows us not to need a nop in the epilog if at least one
3328: register is reloaded in addition to return address. */
3329:
3330: if (mask || frame_pointer_needed)
3331: {
3332: for (regno = GP_REG_LAST; regno >= GP_REG_FIRST; regno--)
3333: {
3334: if ((mask & (1L << (regno - GP_REG_FIRST))) != 0
3335: || (regno == FRAME_POINTER_REGNUM && frame_pointer_needed))
3336: {
3337: fprintf (file, "\t%s\t%s,%d(%s)\n",
3338: gp_op, reg_names[regno],
3339: gp_offset, base_reg);
3340:
3341: gp_offset -= UNITS_PER_WORD;
3342: }
3343: }
3344: }
3345:
3346: if (fmask)
3347: {
3348: int fp_inc = (TARGET_FLOAT64) ? 1 : 2;
3349:
3350: for (regno = FP_REG_LAST-1; regno >= FP_REG_FIRST; regno -= fp_inc)
3351: {
3352: if ((fmask & (1L << (regno - FP_REG_FIRST))) != 0)
3353: {
3354: fprintf (file, "\t%s\t%s,%d(%s)\n",
3355: fp_op, reg_names[regno], fp_offset, base_reg);
3356:
3357: fp_offset -= 2*UNITS_PER_WORD;
3358: }
3359: }
3360: }
3361: }
3362:
3363:
3364: /* Set up the stack and frame (if desired) for the function. */
3365:
3366: void
3367: function_prologue (file, size)
3368: FILE *file;
3369: int size;
3370: {
3371: int regno;
3372: int tsize;
3373: char *sp_str = reg_names[STACK_POINTER_REGNUM];
3374: char *fp_str = (!frame_pointer_needed)
3375: ? sp_str
3376: : reg_names[FRAME_POINTER_REGNUM];
3377: tree fndecl = current_function_decl; /* current... is tooo long */
3378: tree fntype = TREE_TYPE (fndecl);
3379: tree fnargs = (TREE_CODE (fntype) != METHOD_TYPE)
3380: ? DECL_ARGUMENTS (fndecl)
3381: : 0;
3382: tree next_arg;
3383: tree cur_arg;
3384: char *arg_name = (char *)0;
3385: CUMULATIVE_ARGS args_so_far;
3386:
3387: ASM_OUTPUT_SOURCE_FILENAME (file, DECL_SOURCE_FILE (current_function_decl));
3388: ASM_OUTPUT_SOURCE_LINE (file, DECL_SOURCE_LINE (current_function_decl));
3389:
3390: inside_function = 1;
3391: fputs ("\t.ent\t", file);
3392: assemble_name (file, current_function_name);
3393: fputs ("\n", file);
3394: assemble_name (file, current_function_name);
3395: fputs (":\n", file);
3396:
3397: if (TARGET_ABICALLS)
3398: fprintf (file,
3399: "\t.set\tnoreorder\n\t.cpload\t%s\n\t.set\treorder\n",
3400: reg_names[ GP_REG_FIRST + 25 ]);
3401:
3402: /* Determine the last argument, and get its name. */
3403: for (cur_arg = fnargs; cur_arg != (tree)0; cur_arg = next_arg)
3404: {
3405: next_arg = TREE_CHAIN (cur_arg);
3406: if (next_arg == (tree)0)
3407: {
3408: if (DECL_NAME (cur_arg))
3409: arg_name = IDENTIFIER_POINTER (DECL_NAME (cur_arg));
3410:
3411: break;
3412: }
3413: }
3414:
3415: /* If this function is a varargs function, store any registers that
3416: would normally hold arguments ($4 - $7) on the stack. */
3417: if ((TYPE_ARG_TYPES (fntype) != 0
3418: && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) != void_type_node))
3419: || (arg_name
3420: && (strcmp (arg_name, "__builtin_va_alist") == 0
3421: || strcmp (arg_name, "va_alist") == 0)))
3422: {
3423: tree parm;
3424:
3425: regno = GP_ARG_FIRST;
3426: INIT_CUMULATIVE_ARGS (args_so_far, fntype, (rtx)0);
3427:
3428: for (parm = fnargs; (parm && (regno <= GP_ARG_LAST)); parm = TREE_CHAIN (parm))
3429: {
3430: rtx entry_parm;
3431: enum machine_mode passed_mode;
3432: tree type;
3433:
3434: type = DECL_ARG_TYPE (parm);
3435: passed_mode = TYPE_MODE (type);
3436: entry_parm = FUNCTION_ARG (args_so_far, passed_mode,
3437: DECL_ARG_TYPE (parm), 1);
3438:
3439: if (entry_parm)
3440: {
3441: int words;
3442:
3443: /* passed in a register, so will get homed automatically */
3444: if (GET_MODE (entry_parm) == BLKmode)
3445: words = (int_size_in_bytes (type) + 3) / 4;
3446: else
3447: words = (GET_MODE_SIZE (GET_MODE (entry_parm)) + 3) / 4;
3448:
3449: regno = REGNO (entry_parm) + words - 1;
3450: }
3451: else
3452: {
3453: regno = GP_ARG_LAST+1;
3454: break;
3455: }
3456:
3457: FUNCTION_ARG_ADVANCE (args_so_far, passed_mode,
3458: DECL_ARG_TYPE (parm), 1);
3459: }
3460:
3461: if (regno <= GP_ARG_LAST && (regno & 1) != 0)
3462: {
3463: fprintf (file, "\tsw\t%s,%d(%s)\t\t# varargs home register\n",
3464: reg_names[regno], (regno - 4) * 4, sp_str);
3465: regno++;
3466: }
3467:
3468: for (; regno <= GP_ARG_LAST; regno += 2)
3469: {
3470: fprintf (file, "\tsd\t%s,%d(%s)\t\t# varargs home register\n",
3471: reg_names[regno], (regno - 4) * 4, sp_str);
3472: }
3473: }
3474:
3475: size = MIPS_STACK_ALIGN (size);
3476: tsize = (!current_frame_info.initialized)
3477: ? compute_frame_size (size)
3478: : current_frame_info.total_size;
3479:
3480: if (tsize > 0)
3481: {
3482: if (tsize <= 32767)
3483: fprintf (file,
3484: "\tsubu\t%s,%s,%d\t\t# vars= %d, regs= %d/%d, args = %d, extra= %d\n",
3485: sp_str, sp_str, tsize, current_frame_info.var_size,
3486: current_frame_info.gp_reg_size / 4,
3487: current_frame_info.fp_reg_size / 8,
3488: current_function_outgoing_args_size,
3489: current_frame_info.extra_size);
3490: else
3491: fprintf (file,
3492: "\tli\t%s,%d\n\tsubu\t%s,%s,%s\t\t# vars= %d, regs= %d/%d, args = %d, sfo= %d\n",
3493: reg_names[MIPS_TEMP1_REGNUM], tsize, sp_str, sp_str,
3494: reg_names[MIPS_TEMP1_REGNUM], current_frame_info.var_size,
3495: current_frame_info.gp_reg_size / 4,
3496: current_frame_info.fp_reg_size / 8,
3497: current_function_outgoing_args_size,
3498: current_frame_info.extra_size);
3499: }
3500:
3501: if (TARGET_ABICALLS)
3502: fprintf (file, "\t.cprestore %d\n", tsize + STARTING_FRAME_OFFSET);
3503:
3504: fprintf (file, "\t.frame\t%s,%d,%s\n\t.mask\t0x%08lx,%d\n\t.fmask\t0x%08lx,%d\n",
3505: fp_str,
3506: (frame_pointer_needed) ? 0 : tsize,
3507: reg_names[31 + GP_REG_FIRST],
3508: current_frame_info.mask,
3509: current_frame_info.gp_save_offset,
3510: current_frame_info.fmask,
3511: current_frame_info.fp_save_offset);
3512:
3513: save_restore (file, "sw", "sd", "s.d");
3514:
3515: if (frame_pointer_needed)
3516: {
3517: if (tsize <= 32767)
3518: fprintf (file, "\taddu\t%s,%s,%d\t# set up frame pointer\n", fp_str, sp_str, tsize);
3519:
3520: else
3521: fprintf (file, "\taddu\t%s,%s,%s\t# set up frame pointer\n", fp_str, sp_str,
3522: reg_names[MIPS_TEMP1_REGNUM]);
3523: }
3524: }
3525:
3526:
3527: /* Do any necessary cleanup after a function to restore stack, frame, and regs. */
3528:
3529: void
3530: function_epilogue (file, size)
3531: FILE *file;
3532: int size;
3533: {
3534: int tsize;
3535: char *sp_str = reg_names[STACK_POINTER_REGNUM];
3536: char *t1_str = reg_names[MIPS_TEMP1_REGNUM];
3537: rtx epilogue_delay = current_function_epilogue_delay_list;
3538: int noreorder = !TARGET_MIPS_AS || (epilogue_delay != 0);
3539: int noepilogue = FALSE;
3540: int load_nop = FALSE;
3541: int load_only_r31;
3542:
3543: /* The epilogue does not depend on any registers, but the stack
3544: registers, so we assume that if we have 1 pending nop, it can be
3545: ignored, and 2 it must be filled (2 nops occur for integer
3546: multiply and divide). */
3547:
3548: if (dslots_number_nops > 0)
3549: {
3550: if (dslots_number_nops == 1)
3551: {
3552: dslots_number_nops = 0;
3553: dslots_load_filled++;
3554: }
3555: else
3556: {
3557: while (--dslots_number_nops > 0)
3558: fputs ((set_noreorder) ? "\tnop\n" : "\t#nop\n", asm_out_file);
3559: }
3560:
3561: if (set_noreorder > 0 && --set_noreorder == 0)
3562: fputs ("\t.set\treorder\n", file);
3563: }
3564:
3565: if (set_noat != 0)
3566: {
3567: set_noat = 0;
3568: fputs ("\t.set\tat\n", file);
3569: error ("internal gcc error: .set noat left on in epilogue");
3570: }
3571:
3572: if (set_nomacro != 0)
3573: {
3574: set_nomacro = 0;
3575: fputs ("\t.set\tmacro\n", file);
3576: error ("internal gcc error: .set nomacro left on in epilogue");
3577: }
3578:
3579: if (set_noreorder != 0)
3580: {
3581: set_noreorder = 0;
3582: fputs ("\t.set\treorder\n", file);
3583: error ("internal gcc error: .set noreorder left on in epilogue");
3584: }
3585:
3586: if (set_volatile != 0)
3587: {
3588: set_volatile = 0;
3589: fprintf (file, "\t#.set\tnovolatile\n", (TARGET_MIPS_AS) ? "" : "#");
3590: error ("internal gcc error: .set volatile left on in epilogue");
3591: }
3592:
3593: size = MIPS_STACK_ALIGN (size);
3594: tsize = (!current_frame_info.initialized)
3595: ? compute_frame_size (size)
3596: : current_frame_info.total_size;
3597:
3598: if (tsize == 0 && epilogue_delay == 0)
3599: {
3600: rtx insn = get_last_insn ();
3601:
3602: /* If the last insn was a BARRIER, we don't have to write any code
3603: because a jump (aka return) was put there. */
3604: if (GET_CODE (insn) == NOTE)
3605: insn = prev_nonnote_insn (insn);
3606: if (insn && GET_CODE (insn) == BARRIER)
3607: noepilogue = TRUE;
3608:
3609: noreorder = FALSE;
3610: }
3611:
3612: if (!noepilogue)
3613: {
3614: /* In the reload sequence, we don't need to fill the load delay
3615: slots for most of the loads, also see if we can fill the final
3616: delay slot if not otherwise filled by the reload sequence. */
3617:
3618: if (noreorder)
3619: fprintf (file, "\t.set\tnoreorder\n");
3620:
3621: if (tsize > 32767)
3622: fprintf (file, "\tli\t%s,%d\n", t1_str, tsize);
3623:
3624: if (frame_pointer_needed)
3625: {
3626: char *fp_str = reg_names[FRAME_POINTER_REGNUM];
3627: if (tsize > 32767)
3628: fprintf (file,"\tsubu\t%s,%s,%s\t\t# sp not trusted here\n",
3629: sp_str, fp_str, t1_str);
3630: else
3631: fprintf (file,"\tsubu\t%s,%s,%d\t\t# sp not trusted here\n",
3632: sp_str, fp_str, tsize);
3633: }
3634:
3635: save_restore (file, "lw", "ld", "l.d");
3636:
3637: load_only_r31 = (current_frame_info.mask == (1 << 31)
3638: && current_frame_info.fmask == 0);
3639:
3640: if (noreorder)
3641: {
3642: /* If the only register saved is the return address, we need a
3643: nop, unless we have an instruction to put into it. Otherwise
3644: we don't since reloading multiple registers doesn't reference
3645: the register being loaded. */
3646:
3647: if (load_only_r31)
3648: {
3649: if (epilogue_delay)
3650: final_scan_insn (XEXP (epilogue_delay, 0),
3651: file,
3652: 1, /* optimize */
3653: -2, /* prescan */
3654: 1); /* nopeepholes */
3655: else
3656: {
3657: fprintf (file, "\tnop\n");
3658: load_nop = TRUE;
3659: }
3660: }
3661:
3662: fprintf (file, "\tj\t%s\n", reg_names[GP_REG_FIRST + 31]);
3663:
3664: if (tsize > 32767)
3665: fprintf (file, "\taddu\t%s,%s,%s\n", sp_str, sp_str, t1_str);
3666:
3667: else if (tsize > 0)
3668: fprintf (file, "\taddu\t%s,%s,%d\n", sp_str, sp_str, tsize);
3669:
3670: else if (!load_only_r31 && epilogue_delay != 0)
3671: final_scan_insn (XEXP (epilogue_delay, 0),
3672: file,
3673: 1, /* optimize */
3674: -2, /* prescan */
3675: 1); /* nopeepholes */
3676:
3677: fprintf (file, "\t.set\treorder\n");
3678: }
3679:
3680: else
3681: {
3682: if (tsize > 32767)
3683: fprintf (file, "\taddu\t%s,%s,%s\n", sp_str, sp_str, t1_str);
3684:
3685: else if (tsize > 0)
3686: fprintf (file, "\taddu\t%s,%s,%d\n", sp_str, sp_str, tsize);
3687:
3688: fprintf (file, "\tj\t%s\n", reg_names[GP_REG_FIRST + 31]);
3689: }
3690: }
3691:
3692: fputs ("\t.end\t", file);
3693: assemble_name (file, current_function_name);
3694: fputs ("\n", file);
3695:
3696: if (TARGET_STATS)
3697: {
3698: int num_gp_regs = current_frame_info.gp_reg_size / 4;
3699: int num_fp_regs = current_frame_info.fp_reg_size / 8;
3700: int num_regs = num_gp_regs + num_fp_regs;
3701:
3702: dslots_load_total += num_regs;
3703:
3704: if (!noepilogue)
3705: dslots_jump_total++;
3706:
3707: if (noreorder)
3708: {
3709: dslots_load_filled += num_regs;
3710:
3711: /* If the only register saved is the return register, we
3712: can't fill this register's delay slot. */
3713:
3714: if (load_only_r31 && epilogue_delay == 0)
3715: dslots_load_filled--;
3716:
3717: if (tsize > 0 || (!load_only_r31 && epilogue_delay != 0))
3718: dslots_jump_filled++;
3719: }
3720:
3721: fprintf (stderr,
3722: "%-20s fp=%c leaf=%c alloca=%c setjmp=%c stack=%4ld arg=%3ld reg=%2d/%d delay=%3d/%3dL %3d/%3dJ refs=%3d/%3d/%3d\n",
3723: current_function_name,
3724: (frame_pointer_needed) ? 'y' : 'n',
3725: ((current_frame_info.mask & (1 << 31)) != 0) ? 'n' : 'y',
3726: (current_function_calls_alloca) ? 'y' : 'n',
3727: (current_function_calls_setjmp) ? 'y' : 'n',
3728: (long)current_frame_info.total_size,
3729: (long)current_function_outgoing_args_size,
3730: num_gp_regs, num_fp_regs,
3731: dslots_load_total, dslots_load_filled,
3732: dslots_jump_total, dslots_jump_filled,
3733: num_refs[0], num_refs[1], num_refs[2]);
3734: }
3735:
3736: /* Reset state info for each function. */
3737: inside_function = FALSE;
3738: ignore_line_number = FALSE;
3739: dslots_load_total = 0;
3740: dslots_jump_total = 0;
3741: dslots_load_filled = 0;
3742: dslots_jump_filled = 0;
3743: num_refs[0] = 0;
3744: num_refs[1] = 0;
3745: num_refs[2] = 0;
3746: mips_load_reg = (rtx)0;
3747: mips_load_reg2 = (rtx)0;
3748: number_functions_processed++;
3749: current_frame_info = zero_frame_info;
3750:
3751: /* Restore the output file if optimizing the GP (optimizing the GP causes
3752: the text to be diverted to a tempfile, so that data decls come before
3753: references to the data). */
3754:
3755: if (TARGET_GP_OPT)
3756: asm_out_file = asm_out_data_file;
3757: }
3758:
3759:
3760: /* Define the number of delay slots needed for the function epilogue.
3761:
3762: On the mips, we need a slot if either no stack has been allocated,
3763: or the only register saved is the return register. */
3764:
3765: int
3766: mips_epilogue_delay_slots ()
3767: {
3768: if (!current_frame_info.initialized)
3769: (void) compute_frame_size (get_frame_size ());
3770:
3771: if (current_frame_info.total_size == 0)
3772: return 1;
3773:
3774: if (current_frame_info.mask == (1 << 31) && current_frame_info.fmask == 0)
3775: return 1;
3776:
3777: return 0;
3778: }
3779:
3780:
3781: /* Return true if this function is known to have a null epilogue.
3782: This allows the optimizer to omit jumps to jumps if no stack
3783: was created. */
3784:
3785: int
3786: null_epilogue ()
3787: {
3788: if (!reload_completed)
3789: return 0;
3790:
3791: if (current_frame_info.initialized)
3792: return current_frame_info.total_size == 0;
3793:
3794: return (compute_frame_size (get_frame_size ())) == 0;
3795: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.