![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to romp.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 romp.c CVS log | Up to [GCC 2.x] / gcc / config |
1.1 root 1: /* Subroutines used for code generation on ROMP.
2: Copyright (C) 1990, 1991 Free Software Foundation, Inc.
3: Contributed by Richard Kenner ([email protected])
4:
5: This file is part of GNU CC.
6:
7: GNU CC is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2, or (at your option)
10: any later version.
11:
12: GNU CC is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with GNU CC; see the file COPYING. If not, write to
19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20:
21:
22: #include <stdio.h>
23: #include "config.h"
24: #include "rtl.h"
25: #include "regs.h"
26: #include "hard-reg-set.h"
27: #include "real.h"
28: #include "insn-config.h"
29: #include "conditions.h"
30: #include "insn-flags.h"
31: #include "output.h"
32: #include "insn-attr.h"
33: #include "flags.h"
34: #include "recog.h"
35: #include "expr.h"
36: #include "obstack.h"
37: #include "tree.h"
38:
39: #define min(A,B) ((A) < (B) ? (A) : (B))
40: #define max(A,B) ((A) > (B) ? (A) : (B))
41:
42: static int unsigned_comparisons_p ();
43: static void output_loadsave_fpregs ();
44: static void output_fpops ();
45: static void init_fpops ();
46:
47: /* Return 1 if the insn using CC0 set by INSN does not contain
48: any unsigned tests applied to the condition codes.
49:
50: Based on `next_insn_tests_no_inequality' in recog.c. */
51:
52: int
53: next_insn_tests_no_unsigned (insn)
54: rtx insn;
55: {
56: register rtx next = next_cc0_user (insn);
57:
58: if (next == 0)
59: {
60: if (find_reg_note (insn, REG_UNUSED, cc0_rtx))
61: return 1;
62: else
63: abort ();
64: }
65:
66: return ((GET_CODE (next) == JUMP_INSN
67: || GET_CODE (next) == INSN
68: || GET_CODE (next) == CALL_INSN)
69: && ! unsigned_comparisons_p (PATTERN (next)));
70: }
71:
72: static int
73: unsigned_comparisons_p (x)
74: rtx x;
75: {
76: register char *fmt;
77: register int len, i;
78: register enum rtx_code code = GET_CODE (x);
79:
80: switch (code)
81: {
82: case REG:
83: case PC:
84: case CC0:
85: case CONST_INT:
86: case CONST_DOUBLE:
87: case CONST:
88: case LABEL_REF:
89: case SYMBOL_REF:
90: return 0;
91:
92: case LTU:
93: case GTU:
94: case LEU:
95: case GEU:
96: return (XEXP (x, 0) == cc0_rtx || XEXP (x, 1) == cc0_rtx);
97: }
98:
99: len = GET_RTX_LENGTH (code);
100: fmt = GET_RTX_FORMAT (code);
101:
102: for (i = 0; i < len; i++)
103: {
104: if (fmt[i] == 'e')
105: {
106: if (unsigned_comparisons_p (XEXP (x, i)))
107: return 1;
108: }
109: else if (fmt[i] == 'E')
110: {
111: register int j;
112: for (j = XVECLEN (x, i) - 1; j >= 0; j--)
113: if (unsigned_comparisons_p (XVECEXP (x, i, j)))
114: return 1;
115: }
116: }
117:
118: return 0;
119: }
120:
121: /* Update the condition code from the insn. Look mostly at the first
122: byte of the machine-specific insn description information.
123:
124: cc_state.value[12] refer to two possible values that might correspond
125: to the CC. We only store register values. */
126:
127: update_cc (body, insn)
128: rtx body;
129: rtx insn;
130: {
131: switch (get_attr_cc (insn))
132: {
133: case CC_NONE:
134: /* Insn does not affect the CC at all. */
135: break;
136:
137: case CC_CHANGE0:
138: /* Insn doesn't affect the CC but does modify operand[0], known to be
139: a register. */
140: if (cc_status.value1 != 0
141: && reg_overlap_mentioned_p (recog_operand[0], cc_status.value1))
142: cc_status.value1 = 0;
143:
144: if (cc_status.value2 != 0
145: && reg_overlap_mentioned_p (recog_operand[0], cc_status.value2))
146: cc_status.value2 = 0;
147:
148: break;
149:
150: case CC_COPY1TO0:
151: /* Insn copies operand[1] to operand[0], both registers, but doesn't
152: affect the CC. */
153: if (cc_status.value1 != 0
154: && reg_overlap_mentioned_p (recog_operand[0], cc_status.value1))
155: cc_status.value1 = 0;
156:
157: if (cc_status.value2 != 0
158: && reg_overlap_mentioned_p (recog_operand[0], cc_status.value2))
159: cc_status.value2 = 0;
160:
161: if (cc_status.value1 != 0
162: && rtx_equal_p (cc_status.value1, recog_operand[1]))
163: cc_status.value2 = recog_operand[0];
164:
165: if (cc_status.value2 != 0
166: && rtx_equal_p (cc_status.value2, recog_operand[1]))
167: cc_status.value1 = recog_operand[0];
168:
169: break;
170:
171: case CC_CLOBBER:
172: /* Insn clobbers CC. */
173: CC_STATUS_INIT;
174: break;
175:
176: case CC_SETS:
177: /* Insn sets CC to recog_operand[0], but overflow is impossible. */
178: CC_STATUS_INIT;
179: cc_status.flags |= CC_NO_OVERFLOW;
180: cc_status.value1 = recog_operand[0];
181: break;
182:
183: case CC_COMPARE:
184: /* Insn is a compare which sets the CC fully. Update CC_STATUS for this
185: compare and mark whether the test will be signed or unsigned. */
186: {
187: register rtx p = PATTERN (insn);
188:
189: CC_STATUS_INIT;
190:
191: if (GET_CODE (p) == PARALLEL)
192: p = XVECEXP (p, 0, 0);
193: cc_status.value1 = SET_SRC (p);
194:
195: if (GET_CODE (SET_SRC (p)) == REG)
196: cc_status.flags |= CC_NO_OVERFLOW;
197: if (! next_insn_tests_no_unsigned (insn))
198: cc_status.flags |= CC_UNSIGNED;
199: }
200: break;
201:
202: case CC_TBIT:
203: /* Insn sets T bit if result is non-zero. Next insn must be branch. */
204: CC_STATUS_INIT;
205: cc_status.flags = CC_IN_TB | CC_NOT_NEGATIVE;
206: break;
207:
208: default:
209: abort ();
210: }
211: }
212:
213: /* Return 1 if a previous compare needs to be re-issued. This will happen
214: if two compares tested the same objects, but one was signed and the
215: other unsigned. OP is the comparison operation being performed. */
216:
217: int
218: restore_compare_p (op)
219: rtx op;
220: {
221: enum rtx_code code = GET_CODE (op);
222:
223: return (((code == GEU || code == LEU || code == GTU || code == LTU)
224: && ! (cc_status.flags & CC_UNSIGNED))
225: || ((code == GE || code == LE || code == GT || code == LT)
226: && (cc_status.flags & CC_UNSIGNED)));
227: }
228:
229: /* Generate the (long) string corresponding to an inline multiply insn.
230: Note that `r10' does not refer to the register r10, but rather to the
231: SCR used as the MQ. */
232: char *
233: output_in_line_mul ()
234: {
235: static char insns[200];
236: int i;
237:
238: strcpy (insns, "s %0,%0\n");
239: strcat (insns, "\tmts r10,%1\n");
240: for (i = 0; i < 16; i++)
241: strcat (insns, "\tm %0,%2\n");
242: strcat (insns, "\tmfs r10,%0");
243:
244: return insns;
245: }
246:
247: /* Returns 1 if OP is a memory reference with an offset from a register within
248: the range specified. The offset must also be a multiple of the size of the
249: mode. */
250:
251: static int
252: memory_offset_in_range_p (op, mode, low, high)
253: register rtx op;
254: enum machine_mode mode;
255: int low, high;
256: {
257: int offset = 0;
258:
259: if (! memory_operand (op, mode))
260: return 0;
261:
262: while (GET_CODE (op) == SUBREG)
263: {
264: offset += SUBREG_WORD (op) * UNITS_PER_WORD;
265: #if BYTES_BIG_ENDIAN
266: offset -= (min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (op)))
267: - min (UNITS_PER_WORD,
268: GET_MODE_SIZE (GET_MODE (SUBREG_REG (op)))));
269: #endif
270: op = SUBREG_REG (op);
271: }
272:
273: /* We must now have either (mem (reg (x)), (mem (plus (reg (x)) (c))),
274: or a constant pool address. */
275: if (GET_CODE (op) != MEM)
276: abort ();
277:
278: /* Now use the actual mode and get the address. */
279: mode = GET_MODE (op);
280: op = XEXP (op, 0);
281: if (GET_CODE (op) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (op))
282: offset = get_pool_offset (op) + 12;
283: else if (GET_CODE (op) == PLUS)
284: {
285: if (GET_CODE (XEXP (op, 1)) != CONST_INT
286: || ! register_operand (XEXP (op, 0), Pmode))
287: return 0;
288:
289: offset += INTVAL (XEXP (op, 1));
290: }
291:
292: else if (! register_operand (op, Pmode))
293: return 0;
294:
295: return (offset >= low && offset <= high
296: && (offset % GET_MODE_SIZE (mode) == 0));
297: }
298:
299: /* Return 1 if OP is a valid operand for a memory reference insn that can
300: only reference indirect through a register. */
301:
302: int
303: zero_memory_operand (op, mode)
304: rtx op;
305: enum machine_mode mode;
306: {
307: return memory_offset_in_range_p (op, mode, 0, 0);
308: }
309:
310: /* Return 1 if OP is a valid operand for a `short' memory reference insn. */
311:
312: int
313: short_memory_operand (op, mode)
314: rtx op;
315: enum machine_mode mode;
316: {
317: if (mode == VOIDmode)
318: mode = GET_MODE (op);
319:
320: return memory_offset_in_range_p (op, mode, 0,
321: 15 * min (UNITS_PER_WORD,
322: GET_MODE_SIZE (mode)));
323: }
324:
325: /* Returns 1 if OP is a memory reference involving a symbolic constant
326: that is not in the constant pool. */
327:
328: int
329: symbolic_memory_operand (op, mode)
330: register rtx op;
331: enum machine_mode mode;
332: {
333: if (! memory_operand (op, mode))
334: return 0;
335:
336: while (GET_CODE (op) == SUBREG)
337: op = SUBREG_REG (op);
338:
339: if (GET_CODE (op) != MEM)
340: abort ();
341:
342: op = XEXP (op, 0);
343: if (constant_pool_address_operand (op, VOIDmode))
344: return 0;
345: else
346: return romp_symbolic_operand (op, Pmode)
347: || (GET_CODE (op) == PLUS && register_operand (XEXP (op, 0), Pmode)
348: && romp_symbolic_operand (XEXP (op, 1), Pmode));
349: }
350:
351:
352: /* Returns 1 if OP is a constant pool reference to the current function. */
353:
354: int
355: current_function_operand (op, mode)
356: rtx op;
357: enum machine_mode mode;
358: {
359: if (GET_CODE (op) != MEM || GET_CODE (XEXP (op, 0)) != SYMBOL_REF
360: || ! CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))
361: return 0;
362:
363: op = get_pool_constant (XEXP (op, 0));
364: return (GET_CODE (op) == SYMBOL_REF
365: && ! strcmp (current_function_name, XSTR (op, 0)));
366: }
367:
368: /* Return non-zero if this function is known to have a null epilogue. */
369:
370: int
371: null_epilogue ()
372: {
373: return (reload_completed
374: && first_reg_to_save () == 16
375: && ! romp_pushes_stack ());
376: }
377:
378: /* Returns 1 if OP is the address of a location in the constant pool. */
379:
380: int
381: constant_pool_address_operand (op, mode)
382: rtx op;
383: enum machine_mode mode;
384: {
385: return ((GET_CODE (op) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (op))
386: || (GET_CODE (op) == CONST && GET_CODE (XEXP (op, 0)) == PLUS
387: && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT
388: && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
389: && CONSTANT_POOL_ADDRESS_P (XEXP (XEXP (op, 0), 0))));
390: }
391:
392: /* Returns 1 if OP is either a symbol reference or a sum of a symbol
393: reference and a constant. */
394:
395: int
396: romp_symbolic_operand (op, mode)
397: register rtx op;
398: enum machine_mode mode;
399: {
400: switch (GET_CODE (op))
401: {
402: case SYMBOL_REF:
403: case LABEL_REF:
404: return ! op->integrated;
405:
406: case CONST:
407: op = XEXP (op, 0);
408: return (GET_CODE (XEXP (op, 0)) == SYMBOL_REF
409: || GET_CODE (XEXP (op, 0)) == LABEL_REF)
410: && GET_CODE (XEXP (op, 1)) == CONST_INT;
411:
412: default:
413: return 0;
414: }
415: }
416:
417: /* Returns 1 if OP is a valid constant for the ROMP. */
418:
419: int
420: constant_operand (op, mode)
421: register rtx op;
422: enum machine_mode mode;
423: {
424: switch (GET_CODE (op))
425: {
426: case LABEL_REF:
427: case SYMBOL_REF:
428: case PLUS:
429: case CONST:
430: return romp_symbolic_operand (op,mode);
431:
432: case CONST_INT:
433: return (unsigned int) (INTVAL (op) + 0x8000) < 0x10000
434: || (INTVAL (op) & 0xffff) == 0 || (INTVAL (op) & 0xffff0000) == 0;
435:
436: default:
437: return 0;
438: }
439: }
440:
441: /* Returns 1 if OP is either a constant integer valid for the ROMP or a
442: register. If a register, it must be in the proper mode unless MODE is
443: VOIDmode. */
444:
445: int
446: reg_or_cint_operand (op, mode)
447: register rtx op;
448: enum machine_mode mode;
449: {
450: if (GET_CODE (op) == CONST_INT)
451: return constant_operand (op, mode);
452:
453: return register_operand (op, mode);
454: }
455:
456: /* Return 1 is the operand is either a register or ANY constant integer. */
457:
458: int
459: reg_or_any_cint_operand (op, mode)
460: register rtx op;
461: enum machine_mode mode;
462: {
463: return GET_CODE (op) == CONST_INT || register_operand (op, mode);
464: }
465:
466: /* Return 1 if the operand is either a register or a valid D-type operand. */
467:
468: int
469: reg_or_D_operand (op, mode)
470: register rtx op;
471: enum machine_mode mode;
472: {
473: if (GET_CODE (op) == CONST_INT)
474: return (unsigned) (INTVAL (op) + 0x8000) < 0x10000;
475:
476: return register_operand (op, mode);
477: }
478:
479: /* Return 1 if the operand is either a register or an item that can be
480: used as the operand of an SI add insn. */
481:
482: int
483: reg_or_add_operand (op, mode)
484: register rtx op;
485: enum machine_mode mode;
486: {
487: return reg_or_D_operand (op, mode) || romp_symbolic_operand (op, mode)
488: || (GET_CODE (op) == CONST_INT && (INTVAL (op) & 0xffff) == 0);
489: }
490:
491: /* Return 1 if the operand is either a register or an item that can be
492: used as the operand of a ROMP logical AND insn. */
493:
494: int
495: reg_or_and_operand (op, mode)
496: register rtx op;
497: enum machine_mode mode;
498: {
499: if (reg_or_cint_operand (op, mode))
500: return 1;
501:
502: if (GET_CODE (op) != CONST_INT)
503: return 0;
504:
505: return (INTVAL (op) & 0xffff) == 0xffff
506: || (INTVAL (op) & 0xffff0000) == 0xffff0000;
507: }
508:
509: /* Return 1 if the operand is a register or memory operand. */
510:
511: int
512: reg_or_mem_operand (op, mode)
513: register rtx op;
514: register enum machine_mode mode;
515: {
516: return register_operand (op, mode) || memory_operand (op, mode);
517: }
518:
519: /* Return 1 if the operand is either a register or a memory operand that is
520: not symbolic. */
521:
522: int
523: reg_or_nonsymb_mem_operand (op, mode)
524: register rtx op;
525: enum machine_mode mode;
526: {
527: if (register_operand (op, mode))
528: return 1;
529:
530: if (memory_operand (op, mode) && ! symbolic_memory_operand (op, mode))
531: return 1;
532:
533: return 0;
534: }
535:
536: /* Return 1 if this operand is valid for the ROMP. This is any operand except
537: certain constant integers. */
538:
539: int
540: romp_operand (op, mode)
541: register rtx op;
542: enum machine_mode mode;
543: {
544: if (GET_CODE (op) == CONST_INT)
545: return constant_operand (op, mode);
546:
547: return general_operand (op, mode);
548: }
549:
550: /* Return 1 if the operand is (reg:mode 0). */
551:
552: int
553: reg_0_operand (op, mode)
554: rtx op;
555: enum machine_mode mode;
556: {
557: return ((mode == VOIDmode || mode == GET_MODE (op))
558: && GET_CODE (op) == REG && REGNO (op) == 0);
559: }
560:
561: /* Return 1 if the operand is (reg:mode 15). */
562:
563: int
564: reg_15_operand (op, mode)
565: rtx op;
566: enum machine_mode mode;
567: {
568: return ((mode == VOIDmode || mode == GET_MODE (op))
569: && GET_CODE (op) == REG && REGNO (op) == 15);
570: }
571:
572: /* Return 1 if this is a binary floating-point operation. */
573:
574: int
575: float_binary (op, mode)
576: register rtx op;
577: enum machine_mode mode;
578: {
579: if (mode != VOIDmode && mode != GET_MODE (op))
580: return 0;
581:
582: if (GET_MODE (op) != SFmode && GET_MODE (op) != DFmode)
583: return 0;
584:
585: switch (GET_CODE (op))
586: {
587: case PLUS:
588: case MINUS:
589: case MULT:
590: case DIV:
591: return GET_MODE (XEXP (op, 0)) == GET_MODE (op)
592: && GET_MODE (XEXP (op, 1)) == GET_MODE (op);
593:
594: default:
595: return 0;
596: }
597: }
598:
599: /* Return 1 if this is a unary floating-point operation. */
600:
601: int
602: float_unary (op, mode)
603: register rtx op;
604: enum machine_mode mode;
605: {
606: if (mode != VOIDmode && mode != GET_MODE (op))
607: return 0;
608:
609: if (GET_MODE (op) != SFmode && GET_MODE (op) != DFmode)
610: return 0;
611:
612: return (GET_CODE (op) == NEG || GET_CODE (op) == ABS)
613: && GET_MODE (XEXP (op, 0)) == GET_MODE (op);
614: }
615:
616: /* Return 1 if this is a valid floating-point converstion that can be done
617: as part of an operation by the RT floating-point routines. */
618:
619: int
620: float_conversion (op, mode)
621: register rtx op;
622: enum machine_mode mode;
623: {
624: if (mode != VOIDmode && mode != GET_MODE (op))
625: return 0;
626:
627: switch (GET_CODE (op))
628: {
629: case FLOAT_TRUNCATE:
630: return GET_MODE (op) == SFmode && GET_MODE (XEXP (op, 0)) == DFmode;
631:
632: case FLOAT_EXTEND:
633: return GET_MODE (op) == DFmode && GET_MODE (XEXP (op, 0)) == SFmode;
634:
635: case FLOAT:
636: return ((GET_MODE (XEXP (op, 0)) == SImode
637: || GET_CODE (XEXP (op, 0)) == CONST_INT)
638: && (GET_MODE (op) == SFmode || GET_MODE (op) == DFmode));
639:
640: case FIX:
641: return ((GET_MODE (op) == SImode
642: || GET_CODE (XEXP (op, 0)) == CONST_INT)
643: && (GET_MODE (XEXP (op, 0)) == SFmode
644: || GET_MODE (XEXP (op, 0)) == DFmode));
645:
646: default:
647: return 0;
648: }
649: }
650:
651: /* Print an operand. Recognize special options, documented below. */
652:
653: void
654: print_operand (file, x, code)
655: FILE *file;
656: rtx x;
657: char code;
658: {
659: int i;
660:
661: switch (code)
662: {
663: case 'B':
664: /* Byte number (const/8) */
665: if (GET_CODE (x) != CONST_INT)
666: output_operand_lossage ("invalid %%B value");
667:
668: fprintf (file, "%d", INTVAL (x) / 8);
669: break;
670:
671: case 'L':
672: /* Low order 16 bits of constant. */
673: if (GET_CODE (x) != CONST_INT)
674: output_operand_lossage ("invalid %%L value");
675:
676: fprintf (file, "%d", INTVAL (x) & 0xffff);
677: break;
678:
679: case 's':
680: /* Null or "16" depending on whether the constant is greater than 16. */
681: if (GET_CODE (x) != CONST_INT)
682: output_operand_lossage ("invalid %%s value");
683:
684: if (INTVAL (x) >= 16)
685: fprintf (file, "16");
686:
687: break;
688:
689: case 'S':
690: /* For shifts: 's' will have given the half. Just give the amount
691: within 16. */
692: if (GET_CODE (x) != CONST_INT)
693: output_operand_lossage ("invalid %%S value");
694:
695: fprintf (file, "%d", INTVAL (x) & 15);
696: break;
697:
698: case 'b':
699: /* The number of a single bit set or cleared, mod 16. Note that the ROMP
700: numbers bits with the high-order bit 31. */
701: if (GET_CODE (x) != CONST_INT)
702: output_operand_lossage ("invalid %%b value");
703:
704: if ((i = exact_log2 (INTVAL (x))) >= 0)
705: fprintf (file, "%d", (31 - i) % 16);
706: else if ((i = exact_log2 (~ INTVAL (x))) >= 0)
707: fprintf (file, "%d", (31 - i) % 16);
708: else
709: output_operand_lossage ("invalid %%b value");
710:
711: break;
712:
713: case 'h':
714: /* "l" or "u" depending on which half of the constant is zero. */
715: if (GET_CODE (x) != CONST_INT)
716: output_operand_lossage ("invalid %%h value");
717:
718: if ((INTVAL (x) & 0xffff0000) == 0)
719: fprintf (file, "l");
720: else if ((INTVAL (x) & 0xffff) == 0)
721: fprintf (file, "u");
722: else
723: output_operand_lossage ("invalid %%h value");
724:
725: break;
726:
727: case 'H':
728: /* Upper or lower half, depending on which half is zero. */
729: if (GET_CODE (x) != CONST_INT)
730: output_operand_lossage ("invalid %%H value");
731:
732: if ((INTVAL (x) & 0xffff0000) == 0)
733: fprintf (file, "%d", INTVAL (x) & 0xffff);
734: else if ((INTVAL (x) & 0xffff) == 0)
735: fprintf (file, "%d", (INTVAL (x) >> 16) & 0xffff);
736: else
737: output_operand_lossage ("invalid %%H value");
738:
739: break;
740:
741: case 'z':
742: /* Write two characters:
743: 'lo' if the high order part is all ones
744: 'lz' if the high order part is all zeros
745: 'uo' if the low order part is all ones
746: 'uz' if the low order part is all zeros
747: */
748: if (GET_CODE (x) != CONST_INT)
749: output_operand_lossage ("invalid %%z value");
750:
751: if ((INTVAL (x) & 0xffff0000) == 0)
752: fprintf (file, "lz");
753: else if ((INTVAL (x) & 0xffff0000) == 0xffff0000)
754: fprintf (file, "lo");
755: else if ((INTVAL (x) & 0xffff) == 0)
756: fprintf (file, "uz");
757: else if ((INTVAL (x) & 0xffff) == 0xffff)
758: fprintf (file, "uo");
759: else
760: output_operand_lossage ("invalid %%z value");
761:
762: break;
763:
764: case 'Z':
765: /* Upper or lower half, depending on which is non-zero or not
766: all ones. Must be consistent with 'z' above. */
767: if (GET_CODE (x) != CONST_INT)
768: output_operand_lossage ("invalid %%Z value");
769:
770: if ((INTVAL (x) & 0xffff0000) == 0
771: || (INTVAL (x) & 0xffff0000) == 0xffff0000)
772: fprintf (file, "%d", INTVAL (x) & 0xffff);
773: else if ((INTVAL (x) & 0xffff) == 0 || (INTVAL (x) & 0xffff) == 0xffff)
774: fprintf (file, "%d", (INTVAL (x) >> 16) & 0xffff);
775: else
776: output_operand_lossage ("invalid %%Z value");
777:
778: break;
779:
780: case 'k':
781: /* Same as 'z', except the trailing 'o' or 'z' is not written. */
782: if (GET_CODE (x) != CONST_INT)
783: output_operand_lossage ("invalid %%k value");
784:
785: if ((INTVAL (x) & 0xffff0000) == 0
786: || (INTVAL (x) & 0xffff0000) == 0xffff0000)
787: fprintf (file, "l");
788: else if ((INTVAL (x) & 0xffff) == 0
789: || (INTVAL (x) & 0xffff) == 0xffff)
790: fprintf (file, "u");
791: else
792: output_operand_lossage ("invalid %%k value");
793:
794: break;
795:
796: case 't':
797: /* Similar to 's', except that we write 'h' or 'u'. */
798: if (GET_CODE (x) != CONST_INT)
799: output_operand_lossage ("invalid %%k value");
800:
801: if (INTVAL (x) < 16)
802: fprintf (file, "u");
803: else
804: fprintf (file, "l");
805: break;
806:
807: case 'M':
808: /* For memory operations, write 's' if the operand is a short
809: memory operand. */
810: if (short_memory_operand (x, VOIDmode))
811: fprintf (file, "s");
812: break;
813:
814: case 'N':
815: /* Like 'M', but check for zero memory offset. */
816: if (zero_memory_operand (x, VOIDmode))
817: fprintf (file, "s");
818: break;
819:
820: case 'O':
821: /* Write low-order part of DImode or DFmode. Supported for MEM
822: and REG only. */
823: if (GET_CODE (x) == REG)
824: fprintf (file, "%s", reg_names[REGNO (x) + 1]);
825: else if (GET_CODE (x) == MEM)
826: print_operand (file, gen_rtx (MEM, GET_MODE (x),
827: plus_constant (XEXP (x, 0), 4)), 0);
828: else
829: abort ();
830: break;
831:
832: case 'C':
833: /* Offset in constant pool for constant pool address. */
834: if (! constant_pool_address_operand (x, VOIDmode))
835: abort ();
836: if (GET_CODE (x) == SYMBOL_REF)
837: fprintf (file, "%d", get_pool_offset (x) + 12);
838: else
839: /* Must be (const (plus (symbol_ref) (const_int))) */
840: fprintf (file, "%d",
841: (get_pool_offset (XEXP (XEXP (x, 0), 0)) + 12
842: + INTVAL (XEXP (XEXP (x, 0), 1))));
843: break;
844:
845: case 'j':
846: /* Branch opcode. Check for condition in test bit for eq/ne. */
847: switch (GET_CODE (x))
848: {
849: case EQ:
850: if (cc_status.flags & CC_IN_TB)
851: fprintf (file, "ntb");
852: else
853: fprintf (file, "eq");
854: break;
855:
856: case NE:
857: if (cc_status.flags & CC_IN_TB)
858: fprintf (file, "tb");
859: else
860: fprintf (file, "ne");
861: break;
862:
863: case GT:
864: case GTU:
865: fprintf (file, "h");
866: break;
867:
868: case LT:
869: case LTU:
870: fprintf (file, "l");
871: break;
872:
873: case GE:
874: case GEU:
875: fprintf (file, "he");
876: break;
877:
878: case LE:
879: case LEU:
880: fprintf (file, "le");
881: break;
882:
883: default:
884: output_operand_lossage ("invalid %%j value");
885: }
886: break;
887:
888: case 'J':
889: /* Reversed branch opcode. */
890: switch (GET_CODE (x))
891: {
892: case EQ:
893: if (cc_status.flags & CC_IN_TB)
894: fprintf (file, "tb");
895: else
896: fprintf (file, "ne");
897: break;
898:
899: case NE:
900: if (cc_status.flags & CC_IN_TB)
901: fprintf (file, "ntb");
902: else
903: fprintf (file, "eq");
904: break;
905:
906: case GT:
907: case GTU:
908: fprintf (file, "le");
909: break;
910:
911: case LT:
912: case LTU:
913: fprintf (file, "he");
914: break;
915:
916: case GE:
917: case GEU:
918: fprintf (file, "l");
919: break;
920:
921: case LE:
922: case LEU:
923: fprintf (file, "h");
924: break;
925:
926: default:
927: output_operand_lossage ("invalid %%j value");
928: }
929: break;
930:
931: case '.':
932: /* Output nothing. Used as delimeter in, e.g., "mc%B1%.3 " */
933: break;
934:
935: case '#':
936: /* Output 'x' if this insn has a delay slot, else nothing. */
937: if (dbr_sequence_length ())
938: fprintf (file, "x");
939: break;
940:
941: case 0:
942: if (GET_CODE (x) == REG)
943: fprintf (file, "%s", reg_names[REGNO (x)]);
944: else if (GET_CODE (x) == MEM)
945: {
946: if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
947: && current_function_operand (x, Pmode))
948: fprintf (file, "r14");
949: else
950: output_address (XEXP (x, 0));
951: }
952: else
953: output_addr_const (file, x);
954: break;
955:
956: default:
957: output_operand_lossage ("invalid %%xn code");
958: }
959: }
960:
961: /* This page contains routines that are used to determine what the function
962: prologue and epilogue code will do and write them out. */
963:
964: /* Return the first register that is required to be saved. 16 if none. */
965:
966: int
967: first_reg_to_save()
968: {
969: int first_reg;
970:
971: /* Find lowest numbered live register. */
972: for (first_reg = 6; first_reg <= 15; first_reg++)
973: if (regs_ever_live[first_reg])
974: break;
975:
976: /* If we think that we do not have to save r14, see if it will be used
977: to be sure. */
978: if (first_reg > 14 && romp_using_r14 ())
979: first_reg = 14;
980:
981: return first_reg;
982: }
983:
984: /* Compute the size of the save area in the stack, including the space for
985: the first four incoming arguments. */
986:
987: int
988: romp_sa_size ()
989: {
990: int size;
991: int i;
992:
993: /* We have the 4 words corresponding to the arguments passed in registers,
994: 4 reserved words, space for static chain, general register save area,
995: and floating-point save area. */
996: size = 4 + 4 + 1 + (16 - first_reg_to_save ());
997:
998: /* The documentation says we have to leave 18 words in the save area if
999: any floating-point registers at all are saved, not the three words
1000: per register you might otherwise expect. */
1001: for (i = 2 + (TARGET_FP_REGS != 0); i <= 7; i++)
1002: if (regs_ever_live[i + 17])
1003: {
1004: size += 18;
1005: break;
1006: }
1007:
1008: return size * 4;
1009: }
1010:
1011: /* Return non-zero if this function makes calls or has fp operations
1012: (which are really calls). */
1013:
1014: int
1015: romp_makes_calls ()
1016: {
1017: rtx insn;
1018:
1019: for (insn = get_insns (); insn; insn = next_insn (insn))
1020: {
1021: if (GET_CODE (insn) == CALL_INSN)
1022: return 1;
1023: else if (GET_CODE (insn) == INSN)
1024: {
1025: rtx body = PATTERN (insn);
1026:
1027: if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER
1028: && GET_CODE (body) != ADDR_VEC
1029: && GET_CODE (body) != ADDR_DIFF_VEC
1030: && get_attr_type (insn) == TYPE_FP)
1031: return 1;
1032: }
1033: }
1034:
1035: return 0;
1036: }
1037:
1038: /* Return non-zero if this function will use r14 as a pointer to its
1039: constant pool. */
1040:
1041: int
1042: romp_using_r14 ()
1043: {
1044: /* If we are debugging, profiling, have a non-empty constant pool, or
1045: call a function, we need r14. */
1046: return (write_symbols != NO_DEBUG || profile_flag || get_pool_size () != 0
1047: || romp_makes_calls ());
1048: }
1049:
1050: /* Return non-zero if this function needs to push space on the stack. */
1051:
1052: int
1053: romp_pushes_stack ()
1054: {
1055: /* We need to push the stack if a frame pointer is needed (because the
1056: stack might be dynamically adjusted), if we are debugging, if the
1057: total required size is more than 100 bytes, or if we make calls. */
1058:
1059: return (frame_pointer_needed || write_symbols != NO_DEBUG
1060: || (romp_sa_size () + get_frame_size ()) > 100
1061: || romp_makes_calls ());
1062: }
1063:
1064: /* Write function prologue.
1065:
1066: We compute the size of the fixed area required as follows:
1067:
1068: We always allocate 4 words for incoming arguments, 4 word reserved, 1
1069: word for static link, as many words as required for general register
1070: save area, plus 2 words for each FP reg 2-7 that must be saved. */
1071:
1072: void
1073: output_prolog (file, size)
1074: FILE *file;
1075: int size;
1076: {
1077: int first_reg;
1078: int reg_save_offset;
1079: rtx insn;
1080: int fp_save = size + current_function_outgoing_args_size;
1081:
1082: init_fpops ();
1083:
1084: /* Add in fixed size plus output argument area. */
1085: size += romp_sa_size () + current_function_outgoing_args_size;
1086:
1087: /* Compute first register to save and perform the save operation if anything
1088: needs to be saved. */
1089: first_reg = first_reg_to_save();
1090: reg_save_offset = - (4 + 4 + 1 + (16 - first_reg)) * 4;
1091: if (first_reg == 15)
1092: fprintf (file, "\tst r15,%d(r1)\n", reg_save_offset);
1093: else if (first_reg < 16)
1094: fprintf (file, "\tstm r%d,%d(r1)\n", first_reg, reg_save_offset);
1095:
1096: /* Set up pointer to data area if it is needed. */
1097: if (romp_using_r14 ())
1098: fprintf (file, "\tcas r14,r0,r0\n");
1099:
1100: /* Set up frame pointer if needed. */
1101: if (frame_pointer_needed)
1102: fprintf (file, "\tcal r13,-%d(r1)\n", romp_sa_size () + 64);
1103:
1104: /* Push stack if neeeded. There are a couple of ways of doing this. */
1105: if (romp_pushes_stack ())
1106: {
1107: if (size >= 32768)
1108: {
1109: if (size >= 65536)
1110: {
1111: fprintf (file, "\tcau r0,%d(r0)\n", size >> 16);
1112: fprintf (file, "\toil r0,r0,%d\n", size & 0xffff);
1113: }
1114: else
1115: fprintf (file, "\tcal16 r0,%d(r0)\n", size);
1116: fprintf (file, "\ts r1,r0\n");
1117: }
1118: else
1119: fprintf (file, "\tcal r1,-%d(r1)\n", size);
1120: }
1121:
1122: /* Save floating-point registers. */
1123: output_loadsave_fpregs (file, USE,
1124: plus_constant (stack_pointer_rtx, fp_save));
1125: }
1126:
1127: /* Write function epilogue. */
1128:
1129: void
1130: output_epilog (file, size)
1131: FILE *file;
1132: int size;
1133: {
1134: int first_reg = first_reg_to_save();
1135: int pushes_stack = romp_pushes_stack ();
1136: int reg_save_offset = - ((16 - first_reg) + 1 + 4 + 4) * 4;
1137: int total_size = (size + romp_sa_size ()
1138: + current_function_outgoing_args_size);
1139: int fp_save = size + current_function_outgoing_args_size;
1140: int long_frame = total_size >= 32768;
1141: rtx insn = get_last_insn ();
1142: int write_code = 1;
1143:
1144: int nargs = 0; /* words of arguments */
1145: tree argptr;
1146:
1147: for (argptr = DECL_ARGUMENTS (current_function_decl);
1148: argptr; argptr = TREE_CHAIN (argptr))
1149: nargs += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (argptr)))
1150: + BITS_PER_WORD - 1) / BITS_PER_WORD);
1151:
1152: /* If the last insn was a BARRIER, we don't have to write anything except
1153: the trace table. */
1154: if (GET_CODE (insn) == NOTE)
1155: insn = prev_nonnote_insn (insn);
1156: if (insn && GET_CODE (insn) == BARRIER)
1157: write_code = 0;
1158:
1159: /* Restore floating-point registers. */
1160: if (write_code)
1161: output_loadsave_fpregs (file, CLOBBER,
1162: gen_rtx (PLUS, Pmode, gen_rtx (REG, Pmode, 1),
1163: gen_rtx (CONST_INT, VOIDmode, fp_save)));
1164:
1165: /* If we push the stack and do not have size > 32K, adjust the register
1166: save location to the current position of sp. Otherwise, if long frame,
1167: restore sp from fp. */
1168: if (pushes_stack && ! long_frame)
1169: reg_save_offset += total_size;
1170: else if (long_frame && write_code)
1171: fprintf (file, "\tcal r1,%d(r13)\n", romp_sa_size () + 64);
1172:
1173: /* Restore registers. */
1174: if (first_reg == 15 && write_code)
1175: fprintf (file, "\tl r15,%d(r1)\n", reg_save_offset);
1176: else if (first_reg < 16 && write_code)
1177: fprintf (file, "\tlm r%d,%d(r1)\n", first_reg, reg_save_offset);
1178: if (first_reg == 16) first_reg = 0;
1179:
1180: /* Handle popping stack, if needed and write debug table entry. */
1181: if (pushes_stack)
1182: {
1183: if (write_code)
1184: {
1185: if (long_frame)
1186: fprintf (file, "\tbr r15\n");
1187: else
1188: fprintf (file, "\tbrx r15\n\tcal r1,%d(r1)\n", total_size);
1189: }
1190: fprintf (file, "\t.long 0x%x\n", 0xdf07df08 + first_reg * 0x10);
1191:
1192: if (nargs > 15) nargs = 15;
1193: if (frame_pointer_needed)
1194: fprintf (file, "\t.byte 0x%xd, 53\n", nargs);
1195: else
1196: fprintf (file, "\t.short 0x%x100\n", nargs);
1197: }
1198: else
1199: {
1200: if (write_code)
1201: fprintf (file, "\tbr r15\n");
1202: fprintf (file, "\t.long 0xdf02df00\n");
1203: }
1204:
1205: /* Output any pending floating-point operations. */
1206: if (write_code)
1207: output_fpops (file);
1208: }
1209:
1210: /* For the ROMP we need to make new SYMBOL_REFs for the actual name of a
1211: called routine. To keep them unique we maintain a hash table of all
1212: that have been created so far. */
1213:
1214: struct symref_hashent {
1215: rtx symref; /* Created SYMBOL_REF rtx. */
1216: struct symref_hashent *next; /* Next with same hash code. */
1217: };
1218:
1219: #define SYMHASHSIZE 151
1220: #define HASHBITS 65535
1221:
1222: /* Define the hash table itself. */
1223:
1224: static struct symref_hashent *symref_hash_table[SYMHASHSIZE];
1225:
1226: /* Given a name (allocatable in temporary storage), return a SYMBOL_REF
1227: for the name. The rtx is allocated from the current rtl_obstack, while
1228: the name string is allocated from the permanent obstack. */
1229: rtx
1230: get_symref (name)
1231: register char *name;
1232: {
1233: extern struct obstack permanent_obstack;
1234: register char *sp = name;
1235: unsigned int hash = 0;
1236: struct symref_hashent *p, **last_p;
1237:
1238: /* Compute the hash code for the string. */
1239: while (*sp)
1240: hash = (hash << 4) + *sp++;
1241:
1242: /* Search for a matching entry in the hash table, keeping track of the
1243: insertion location as we do so. */
1244: hash = (hash & HASHBITS) % SYMHASHSIZE;
1245: for (last_p = &symref_hash_table[hash], p = *last_p;
1246: p; last_p = &p->next, p = *last_p)
1247: if (strcmp (name, XSTR (p->symref, 0)) == 0)
1248: break;
1249:
1250: /* If couldn't find matching SYMBOL_REF, make a new one. */
1251: if (p == 0)
1252: {
1253: /* Ensure SYMBOL_REF will stay around. */
1254: end_temporary_allocation ();
1255: p = *last_p = (struct symref_hashent *)
1256: permalloc (sizeof (struct symref_hashent));
1257: p->symref = gen_rtx (SYMBOL_REF, Pmode,
1258: obstack_copy0 (&permanent_obstack,
1259: name, strlen (name)));
1260: p->next = 0;
1261: resume_temporary_allocation ();
1262: }
1263:
1264: return p->symref;
1265: }
1266:
1267: /* Validate the precision of a floating-point operation.
1268:
1269: We merge conversions from integers and between floating-point modes into
1270: the insn. However, this must not effect the desired precision of the
1271: insn. The RT floating-point system uses the widest of the operand modes.
1272: If this should be a double-precision insn, ensure that one operand
1273: passed to the floating-point processor has double mode.
1274:
1275: Note that since we don't check anything if the mode is single precision,
1276: it, strictly speaking, isn't necessary to call this for those insns.
1277: However, we do so in case something else needs to be checked in the
1278: future.
1279:
1280: This routine returns 1 if the operation is OK. */
1281:
1282: int
1283: check_precision (opmode, op1, op2)
1284: enum machine_mode opmode;
1285: rtx op1, op2;
1286: {
1287: if (opmode == SFmode)
1288: return 1;
1289:
1290: /* If operand is not a conversion from an integer mode or an extension from
1291: single-precision, it must be a double-precision value. */
1292: if (GET_CODE (op1) != FLOAT && GET_CODE (op1) != FLOAT_EXTEND)
1293: return 1;
1294:
1295: if (op2 && GET_CODE (op2) != FLOAT && GET_CODE (op2) != FLOAT_EXTEND)
1296: return 1;
1297:
1298: return 0;
1299: }
1300:
1301: /* Floating-point on the RT is done by creating an operation block in the data
1302: area that describes the operation. If two floating-point operations are the
1303: same in a single function, they can use the same block.
1304:
1305: These routines are responsible for managing these blocks. */
1306:
1307: /* Structure to describe a floating-point operation. */
1308:
1309: struct fp_op {
1310: struct fp_op *next_same_hash; /* Next op with same hash code. */
1311: struct fp_op *next_in_mem; /* Next op in memory. */
1312: int mem_offset; /* Offset from data area. */
1313: short size; /* Size of block in bytes. */
1314: short noperands; /* Number of operands in block. */
1315: rtx ops[3]; /* RTL for operands. */
1316: enum rtx_code opcode; /* Operation being performed. */
1317: };
1318:
1319: /* Size of hash table. */
1320: #define FP_HASH_SIZE 101
1321:
1322: /* Hash table of floating-point operation blocks. */
1323: static struct fp_op *fp_hash_table[FP_HASH_SIZE];
1324:
1325: /* First floating-point block in data area. */
1326: static struct fp_op *first_fpop;
1327:
1328: /* Last block in data area so far. */
1329: static struct fp_op *last_fpop_in_mem;
1330:
1331: /* Subroutine number in file, to get unique "LF" labels. */
1332: static int subr_number = 0;
1333:
1334: /* Current word offset in data area (includes header and any constant pool). */
1335: int data_offset;
1336:
1337: /* Compute hash code for an RTX used in floating-point. */
1338:
1339: static unsigned int
1340: hash_rtx (x)
1341: register rtx x;
1342: {
1343: register unsigned int hash = (((int) GET_CODE (x) << 10)
1344: + ((int) GET_MODE (x) << 20));
1345: register int i;
1346: register char *fmt = GET_RTX_FORMAT (GET_CODE (x));
1347:
1348: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
1349: if (fmt[i] == 'e')
1350: hash += hash_rtx (XEXP (x, i));
1351: else if (fmt[i] == 'u')
1352: hash += (int) XEXP (x, i);
1353: else if (fmt[i] == 'i')
1354: hash += XINT (x, i);
1355: else if (fmt[i] == 's')
1356: hash += (int) XSTR (x, i);
1357:
1358: return hash;
1359: }
1360:
1361: /* Given an operation code and up to three operands, return a character string
1362: corresponding to the code to emit to branch to a floating-point operation
1363: block. INSN is provided to see if the delay slot has been filled or not.
1364:
1365: A new floating-point operation block is created if this operation has not
1366: been seen before. */
1367:
1368: char *
1369: output_fpop (code, op0, op1, op2, insn)
1370: enum rtx_code code;
1371: rtx op0, op1, op2;
1372: rtx insn;
1373: {
1374: static char outbuf[40];
1375: unsigned int hash, hash0, hash1, hash2;
1376: int size, i;
1377: register struct fp_op *fpop, *last_fpop;
1378: int dyadic = (op2 != 0);
1379: enum machine_mode opmode;
1380: int noperands;
1381: rtx tem;
1382: unsigned int tem_hash;
1383: int fr0_avail = 0;
1384:
1385: /* Compute hash code for each operand. If the operation is commutative,
1386: put the one with the smaller hash code first. This will make us see
1387: more operations as identical. */
1388: hash0 = op0 ? hash_rtx (op0) : 0;
1389: hash1 = op1 ? hash_rtx (op1) : 0;
1390: hash2 = op2 ? hash_rtx (op2) : 0;
1391:
1392: if (hash0 > hash1 && code == EQ)
1393: {
1394: tem = op0; op0 = op1; op1 = tem;
1395: tem_hash = hash0; hash0 = hash1; hash1 = tem_hash;
1396: }
1397: else if (hash1 > hash2 && (code == PLUS || code == MULT))
1398: {
1399: tem = op1; op1 = op2; op2 = tem;
1400: tem_hash = hash1; hash1 = hash2; hash2 = tem_hash;
1401: }
1402:
1403: /* If operation is commutative and the first and third operands are equal,
1404: swap the second and third operands. Note that we must consider two
1405: operands equal if they are the same register even if different modes. */
1406: if (op2 && (code == PLUS || code == MULT)
1407: && (rtx_equal_p (op0, op2)
1408: || (GET_CODE (op0) == REG && GET_CODE (op2) == REG
1409: && REGNO (op0) == REGNO (op2))))
1410: {
1411: tem = op1; op1 = op2; op2 = tem;
1412: tem_hash = hash1; hash1 = hash2; hash2 = tem_hash;
1413: }
1414:
1415: /* If the first and second operands are the same, merge them. Don't do this
1416: for SFmode in general registers because this triggers a bug in the RT fp
1417: code. */
1418: if (op1 && rtx_equal_p (op0, op1)
1419: && code != EQ && code != GE && code != SET
1420: && (GET_MODE (op1) != SFmode || GET_CODE (op0) != REG
1421: || FP_REGNO_P (REGNO (op0))))
1422: {
1423: op1 = op2;
1424: op2 = 0;
1425: }
1426:
1427: noperands = 1 + (op1 != 0) + (op2 != 0);
1428:
1429: /* Compute hash code for entire expression and see if operation block
1430: already exists. */
1431: hash = ((int) code << 13) + (hash0 << 2) + (hash1 << 1) + hash2;
1432:
1433: hash %= FP_HASH_SIZE;
1434: for (fpop = fp_hash_table[hash], last_fpop = 0;
1435: fpop;
1436: last_fpop = fpop, fpop = fpop->next_same_hash)
1437: if (fpop->opcode == code && noperands == fpop->noperands
1438: && (op0 == 0 || rtx_equal_p (op0, fpop->ops[0]))
1439: && (op1 == 0 || rtx_equal_p (op1, fpop->ops[1]))
1440: && (op2 == 0 || rtx_equal_p (op2, fpop->ops[2])))
1441: goto win;
1442:
1443: /* We have never seen this operation before. */
1444: fpop = (struct fp_op *) oballoc (sizeof (struct fp_op));
1445: fpop->mem_offset = data_offset;
1446: fpop->opcode = code;
1447: fpop->noperands = noperands;
1448: fpop->ops[0] = op0;
1449: fpop->ops[1] = op1;
1450: fpop->ops[2] = op2;
1451:
1452: /* Compute the size using the rules in Appendix A of the RT Linkage
1453: Convention (4.3/RT-PSD:5) manual. These rules are a bit ambiguous,
1454: but if we guess wrong, it will effect only efficiency, not correctness. */
1455:
1456: /* Size = 24 + 32 for each non-fp (or fr7) */
1457: size = 24;
1458: if (op0 && (GET_CODE (op0) != REG
1459: || ! FP_REGNO_P (REGNO (op0)) || REGNO (op0) == 23))
1460: size += 32;
1461:
1462: if (op1 && (GET_CODE (op1) != REG
1463: || ! FP_REGNO_P (REGNO (op1)) || REGNO (op1) == 23))
1464: size += 32;
1465:
1466: if (op2 && (GET_CODE (op2) != REG
1467: || ! FP_REGNO_P (REGNO (op2)) || REGNO (op2) == 23))
1468: size += 32;
1469:
1470: /* Size + 12 for each conversion. First get operation mode. */
1471: if ((op0 && GET_MODE (op0) == DFmode)
1472: || (op1 && GET_MODE (op1) == DFmode)
1473: || (op2 && GET_MODE (op2) == DFmode))
1474: opmode = DFmode;
1475: else
1476: opmode = SFmode;
1477:
1478: if (op0 && GET_MODE (op0) != opmode)
1479: size += 12;
1480: if (op1 && GET_MODE (op1) != opmode)
1481: size += 12;
1482: if (op2 && GET_MODE (op2) != opmode)
1483: size += 12;
1484:
1485: /* 12 more if first and third operand types not the same. */
1486: if (op2 && GET_MODE (op0) != GET_MODE (op2))
1487: size += 12;
1488:
1489: /* CMP and CMPT need additional. Also, compute size of save/restore here. */
1490: if (code == EQ)
1491: size += 32;
1492: else if (code == GE)
1493: size += 64;
1494: else if (code == USE || code == CLOBBER)
1495: {
1496: /* 34 + 24 for each additional register plus 8 if fr7 saved. (We
1497: call it 36 because we need to keep the block length a multiple
1498: of four. */
1499: size = 36 - 24;
1500: for (i = 0; i <= 7; i++)
1501: if (INTVAL (op0) & (1 << (7-i)))
1502: size += 24 + 8 * (i == 7);
1503: }
1504:
1505: /* We provide no general-purpose scratch registers. */
1506: size +=16;
1507:
1508: /* No floating-point scratch registers are provided. Compute extra
1509: length due to this. This logic is that shown in the referenced
1510: appendix. */
1511:
1512: i = 0;
1513: if (op0 && GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0)))
1514: i++;
1515: if (op1 && GET_CODE (op1) == REG && FP_REGNO_P (REGNO (op1)))
1516: i++;
1517: if (op2 && GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1518: i++;
1519:
1520: if ((op0 == 0 || GET_CODE (op0) != REG || REGNO(op0) != 17)
1521: && (op1 == 0 || GET_CODE (op1) != REG || REGNO(op1) != 17)
1522: && (op2 == 0 || GET_CODE (op2) != REG || REGNO(op2) != 17))
1523: fr0_avail = 1;
1524:
1525: if (dyadic)
1526: {
1527: if (i == 0)
1528: size += fr0_avail ? 64 : 112;
1529: else if (fpop->noperands == 2 && i == 1)
1530: size += fr0_avail ? 0 : 64;
1531: else if (fpop->noperands == 3)
1532: {
1533: if (GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0))
1534: && GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1535: {
1536: if (REGNO (op0) == REGNO (op2))
1537: #if 1
1538: /* This triggers a bug on the RT. */
1539: abort ();
1540: #else
1541: size += fr0_avail ? 0 : 64;
1542: #endif
1543: }
1544: else
1545: {
1546: i = 0;
1547: if (GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0)))
1548: i++;
1549: if (GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1550: i++;
1551: if (i == 0)
1552: size += fr0_avail ? 64 : 112;
1553: else if (i == 1)
1554: size += fr0_avail ? 0 : 64;
1555: }
1556: }
1557: }
1558: else if (code != USE && code != CLOBBER
1559: && (GET_CODE (op0) != REG || ! FP_REGNO_P (REGNO (op0))))
1560: size += 64;
1561:
1562: if (! TARGET_FULL_FP_BLOCKS)
1563: {
1564: /* If we are not to pad the blocks, just compute its actual length. */
1565: size = 12; /* Header + opcode */
1566: if (code == USE || code == CLOBBER)
1567: size += 2;
1568: else
1569: {
1570: if (op0) size += 2;
1571: if (op1) size += 2;
1572: if (op2) size += 2;
1573: }
1574:
1575: /* If in the middle of a word, round. */
1576: if (size % UNITS_PER_WORD)
1577: size += 2;
1578:
1579: /* Handle any immediates. */
1580: if (code != USE && code != CLOBBER && op0 && GET_CODE (op0) != REG)
1581: size += 4;
1582: if (op1 && GET_CODE (op1) != REG)
1583: size += 4;
1584: if (op2 && GET_CODE (op2) != REG)
1585: size += 4;
1586:
1587: if (code != USE && code != CLOBBER &&
1588: op0 && GET_CODE (op0) == CONST_DOUBLE && GET_MODE (op0) == DFmode)
1589: size += 4;
1590: if (op1 && GET_CODE (op1) == CONST_DOUBLE && GET_MODE (op1) == DFmode)
1591: size += 4;
1592: if (op2 && GET_CODE (op2) == CONST_DOUBLE && GET_MODE (op2) == DFmode)
1593: size += 4;
1594: }
1595:
1596: /* Done with size computation! Chain this in. */
1597: fpop->size = size;
1598: data_offset += size / UNITS_PER_WORD;
1599: fpop->next_in_mem = 0;
1600: fpop->next_same_hash = 0;
1601:
1602: if (last_fpop_in_mem)
1603: last_fpop_in_mem->next_in_mem = fpop;
1604: else
1605: first_fpop = fpop;
1606: last_fpop_in_mem = fpop;
1607:
1608: if (last_fpop)
1609: last_fpop->next_same_hash = fpop;
1610: else
1611: fp_hash_table[hash] = fpop;
1612:
1613: win:
1614: /* FPOP describes the operation to be performed. Return a string to branch
1615: to it. */
1616: if (fpop->mem_offset < 32768 / UNITS_PER_WORD)
1617: sprintf (outbuf, "cal r15,%d(r14)\n\tbalr%s r15,r15",
1618: fpop->mem_offset * UNITS_PER_WORD,
1619: dbr_sequence_length () ? "x" : "");
1620: else
1621: sprintf (outbuf, "get r15,$L%dF%d\n\tbalr%s r15,r15",
1622: subr_number, fpop->mem_offset * UNITS_PER_WORD,
1623: dbr_sequence_length () ? "x" : "");
1624: return outbuf;
1625: }
1626:
1627: /* If necessary, output a floating-point operation to save or restore all
1628: floating-point registers.
1629:
1630: file is the file to write the operation to, CODE is USE for save, CLOBBER
1631: for restore, and ADDR is the address of the same area, as RTL. */
1632:
1633: static void
1634: output_loadsave_fpregs (file, code, addr)
1635: FILE *file;
1636: enum rtx_code code;
1637: rtx addr;
1638: {
1639: register int i;
1640: register int mask = 0;
1641:
1642: for (i = 2 + (TARGET_FP_REGS != 0); i <= 7; i++)
1643: if (regs_ever_live[i + 17])
1644: mask |= 1 << (7 - i);
1645:
1646: if (mask)
1647: fprintf (file, "\t%s\n",
1648: output_fpop (code, gen_rtx (CONST_INT, VOIDmode, mask),
1649: gen_rtx (MEM, Pmode, addr),
1650: 0, const0_rtx));
1651:
1652: }
1653:
1654: /* Output any floating-point operations at the end of the routine. */
1655:
1656: static void
1657: output_fpops (file)
1658: FILE *file;
1659: {
1660: register struct fp_op *fpop;
1661: register int size_so_far;
1662: register int i;
1663: rtx immed[3];
1664:
1665: if (first_fpop == 0)
1666: return;
1667:
1668: data_section ();
1669:
1670: ASM_OUTPUT_ALIGN (file, 2);
1671:
1672: for (fpop = first_fpop; fpop; fpop = fpop->next_in_mem)
1673: {
1674: if (fpop->mem_offset < 32768 / UNITS_PER_WORD)
1675: fprintf (file, "# data area offset = %d\n",
1676: fpop->mem_offset * UNITS_PER_WORD);
1677: else
1678: fprintf (file, "L%dF%d:\n",
1679: subr_number, fpop->mem_offset * UNITS_PER_WORD);
1680:
1681: fprintf (file, "\tcas r0,r15,r0\n");
1682: fprintf (file, "\t.long FPGLUE\n");
1683: switch (fpop->opcode)
1684: {
1685: case USE:
1686: fprintf (file, "\t.byte 0x1d\t# STOREM\n");
1687: break;
1688: case CLOBBER:
1689: fprintf (file, "\t.byte 0x0f\t# LOADM\n");
1690: break;
1691: case ABS:
1692: fprintf (file, "\t.byte 0x00\t# ABS\n");
1693: break;
1694: case PLUS:
1695: fprintf (file, "\t.byte 0x02\t# ADD\n");
1696: break;
1697: case EQ:
1698: fprintf (file, "\t.byte 0x07\t# CMP\n");
1699: break;
1700: case GE:
1701: fprintf (file, "\t.byte 0x08\t# CMPT\n");
1702: break;
1703: case DIV:
1704: fprintf (file, "\t.byte 0x0c\t# DIV\n");
1705: break;
1706: case SET:
1707: fprintf (file, "\t.byte 0x14\t# MOVE\n");
1708: break;
1709: case MULT:
1710: fprintf (file, "\t.byte 0x15\t# MUL\n");
1711: break;
1712: case NEG:
1713: fprintf (file, "\t.byte 0x16\t# NEG\n");
1714: break;
1715: case SQRT:
1716: fprintf (file, "\t.byte 0x1c\t# SQRT\n");
1717: break;
1718: case MINUS:
1719: fprintf (file, "\t.byte 0x1e\t# SUB\n");
1720: break;
1721: default:
1722: abort ();
1723: }
1724:
1725: fprintf (file, "\t.byte %d\n", fpop->noperands);
1726: fprintf (file, "\t.short 0x8001\n");
1727:
1728: if ((fpop->ops[0] == 0
1729: || GET_CODE (fpop->ops[0]) != REG || REGNO(fpop->ops[0]) != 17)
1730: && (fpop->ops[1] == 0 || GET_CODE (fpop->ops[1]) != REG
1731: || REGNO(fpop->ops[1]) != 17)
1732: && (fpop->ops[2] == 0 || GET_CODE (fpop->ops[2]) != REG
1733: || REGNO(fpop->ops[2]) != 17))
1734: fprintf (file, "\t.byte %d, 0x80\n", fpop->size);
1735: else
1736: fprintf (file, "\t.byte %d, 0\n", fpop->size);
1737: size_so_far = 12;
1738: for (i = 0; i < fpop->noperands; i++)
1739: {
1740: register int type;
1741: register int opbyte;
1742: register char *desc0;
1743: char desc1[50];
1744:
1745: immed[i] = 0;
1746: switch (GET_MODE (fpop->ops[i]))
1747: {
1748: case SImode:
1749: case VOIDmode:
1750: desc0 = "int";
1751: type = 0;
1752: break;
1753: case SFmode:
1754: desc0 = "float";
1755: type = 2;
1756: break;
1757: case DFmode:
1758: desc0 = "double";
1759: type = 3;
1760: break;
1761: default:
1762: abort ();
1763: }
1764:
1765: switch (GET_CODE (fpop->ops[i]))
1766: {
1767: case REG:
1768: strcpy(desc1, reg_names[REGNO (fpop->ops[i])]);
1769: if (FP_REGNO_P (REGNO (fpop->ops[i])))
1770: {
1771: type += 0x10;
1772: opbyte = REGNO (fpop->ops[i]) - 17;
1773: }
1774: else
1775: {
1776: type += 0x00;
1777: opbyte = REGNO (fpop->ops[i]);
1778: if (type == 3)
1779: opbyte = (opbyte << 4) + opbyte + 1;
1780: }
1781: break;
1782:
1783: case MEM:
1784: type += 0x30;
1785: if (GET_CODE (XEXP (fpop->ops[i], 0)) == PLUS)
1786: {
1787: immed[i] = XEXP (XEXP (fpop->ops[i], 0), 1);
1788: opbyte = REGNO (XEXP (XEXP (fpop->ops[i], 0), 0));
1789: if (GET_CODE (immed[i]) == CONST_INT)
1790: sprintf (desc1, "%d(%s)", INTVAL (immed[i]),
1791: reg_names[opbyte]);
1792: else
1793: sprintf (desc1, "<memory> (%s)", reg_names[opbyte]);
1794: }
1795: else if (GET_CODE (XEXP (fpop->ops[i], 0)) == REG)
1796: {
1797: opbyte = REGNO (XEXP (fpop->ops[i], 0));
1798: immed[i] = const0_rtx;
1799: sprintf (desc1, "(%s)", reg_names[opbyte]);
1800: }
1801: else
1802: {
1803: immed[i] = XEXP (fpop->ops[i], 0);
1804: opbyte = 0;
1805: sprintf(desc1, "<memory>");
1806: }
1807: break;
1808:
1809: case CONST_INT:
1810: case CONST_DOUBLE:
1811: case CONST:
1812: type += 0x20;
1813: opbyte = 0;
1814: immed[i] = fpop->ops[i];
1815: desc1[0] = '$';
1816: desc1[1] = '\0';
1817: break;
1818:
1819: default:
1820: abort ();
1821: }
1822:
1823: /* Save/restore is special. */
1824: if (i == 0 && (fpop->opcode == USE || fpop->opcode == CLOBBER))
1825: type = 0xff, opbyte = INTVAL (fpop->ops[0]), immed[i] = 0;
1826:
1827: fprintf (file, "\t.byte 0x%x,0x%x # (%s) %s\n",
1828: type, opbyte, desc0, desc1);
1829:
1830: size_so_far += 2;
1831: }
1832:
1833: /* If in the middle of a word, round. */
1834: if (size_so_far % UNITS_PER_WORD)
1835: {
1836: fprintf (file, "\t.space 2\n");
1837: size_so_far += 2;
1838: }
1839:
1840: for (i = 0; i < fpop->noperands; i++)
1841: if (immed[i])
1842: switch (GET_MODE (immed[i]))
1843: {
1844: case SImode:
1845: case VOIDmode:
1846: size_so_far += 4;
1847: fprintf (file, "\t.long ");
1848: output_addr_const (file, immed[i]);
1849: fprintf (file, "\n");
1850: break;
1851:
1852: case DFmode:
1853: size_so_far += 4;
1854: case SFmode:
1855: size_so_far += 4;
1856: if (GET_CODE (immed[i]) == CONST_DOUBLE)
1857: {
1858: union real_extract u;
1859:
1860: bcopy (&CONST_DOUBLE_LOW (immed[i]), &u, sizeof u);
1861: if (GET_MODE (immed[i]) == DFmode)
1862: ASM_OUTPUT_DOUBLE (file, u.d);
1863: else
1864: ASM_OUTPUT_FLOAT (file, u.d);
1865: }
1866: else
1867: abort ();
1868: break;
1869:
1870: default:
1871: abort ();
1872: }
1873:
1874: if (size_so_far != fpop->size)
1875: {
1876: if (TARGET_FULL_FP_BLOCKS)
1877: fprintf (file, "\t.space %d\n", fpop->size - size_so_far);
1878: else
1879: abort ();
1880: }
1881: }
1882:
1883: /* Update for next subroutine. */
1884: subr_number++;
1885: text_section ();
1886: }
1887:
1888: /* Initialize floating-point operation table. */
1889:
1890: static void
1891: init_fpops()
1892: {
1893: register int i;
1894:
1895: first_fpop = last_fpop_in_mem = 0;
1896: for (i = 0; i < FP_HASH_SIZE; i++)
1897: fp_hash_table[i] = 0;
1898: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.