![[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 [Apple XNU] / GNUtools / cc / config / romp|
Return to romp.c CVS log | Up to [Apple XNU] / GNUtools / cc / config / romp |
1.1 root 1: /* Subroutines used for code generation on ROMP.
2: Copyright (C) 1990, 1991, 1992, 1993 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 conversion 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 delimiter 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: int fp_save = size + current_function_outgoing_args_size;
1080:
1081: init_fpops ();
1082:
1083: /* Add in fixed size plus output argument area. */
1084: size += romp_sa_size () + current_function_outgoing_args_size;
1085:
1086: /* Compute first register to save and perform the save operation if anything
1087: needs to be saved. */
1088: first_reg = first_reg_to_save();
1089: reg_save_offset = - (4 + 4 + 1 + (16 - first_reg)) * 4;
1090: if (first_reg == 15)
1091: fprintf (file, "\tst r15,%d(r1)\n", reg_save_offset);
1092: else if (first_reg < 16)
1093: fprintf (file, "\tstm r%d,%d(r1)\n", first_reg, reg_save_offset);
1094:
1095: /* Set up pointer to data area if it is needed. */
1096: if (romp_using_r14 ())
1097: fprintf (file, "\tcas r14,r0,r0\n");
1098:
1099: /* Set up frame pointer if needed. */
1100: if (frame_pointer_needed)
1101: fprintf (file, "\tcal r13,-%d(r1)\n", romp_sa_size () + 64);
1102:
1103: /* Push stack if neeeded. There are a couple of ways of doing this. */
1104: if (romp_pushes_stack ())
1105: {
1106: if (size >= 32768)
1107: {
1108: if (size >= 65536)
1109: {
1110: fprintf (file, "\tcau r0,%d(r0)\n", size >> 16);
1111: fprintf (file, "\toil r0,r0,%d\n", size & 0xffff);
1112: }
1113: else
1114: fprintf (file, "\tcal16 r0,%d(r0)\n", size);
1115: fprintf (file, "\ts r1,r0\n");
1116: }
1117: else
1118: fprintf (file, "\tcal r1,-%d(r1)\n", size);
1119: }
1120:
1121: /* Save floating-point registers. */
1122: output_loadsave_fpregs (file, USE,
1123: plus_constant (stack_pointer_rtx, fp_save));
1124: }
1125:
1126: /* Output the offset information used by debuggers.
1127: This is the exactly the total_size value of output_epilog
1128: which is added to the frame pointer. However the value in the debug
1129: table is encoded in a space-saving way as follows:
1130:
1131: The first byte contains two fields: a 2-bit size field and the first
1132: 6 bits of an offset value. The 2-bit size field is in the high-order
1133: position and specifies how many subsequent bytes follow after
1134: this one. An offset value is at most 4-bytes long.
1135:
1136: The last 6 bits of the first byte initialize the offset value. In many
1137: cases where procedures have small local storage, this is enough and, in
1138: this case, the high-order size field is zero so the byte can (almost) be
1139: used as is (see below). Thus, the byte value of 0x0d is encodes a offset
1140: size of 13 words, or 52 bytes.
1141:
1142: For procedures with a local space larger than 60 bytes, the 6 bits
1143: are the high-order 6 bits. The remaining bytes follow as necessary,
1144: in Big Endian order. Thus, the short value of 16907 (= 16384+523)
1145: encodes an offset of 2092 bytes (523 words).
1146:
1147: The total offset value is in words (not bytes), so the final value has to
1148: be multiplied by 4 before it can be used in address computations by a
1149: debugger. */
1150:
1151: void
1152: output_encoded_offset (file, reg_offset)
1153: FILE *file;
1154: unsigned reg_offset;
1155: {
1156: /* Convert the offset value to 4-byte words rather than bytes. */
1157: reg_offset = (reg_offset + 3) / 4;
1158:
1159: /* Now output 1-4 bytes in encoded form. */
1160: if (reg_offset < (1 << 6))
1161: /* Fits into one byte */
1162: fprintf (file, "\t.byte %d\n", reg_offset);
1163: else if (reg_offset < (1 << (6 + 8)))
1164: /* Fits into two bytes */
1165: fprintf (file, "\t.short %d\n", (1 << (6 + 8)) + reg_offset);
1166: else if (reg_offset < (1 << (6 + 8 + 8)))
1167: {
1168: /* Fits in three bytes */
1169: fprintf (file, "\t.byte %d\n", (2 << 6) + (reg_offset >> ( 6+ 8)));
1170: fprintf (file, "\t.short %d\n", reg_offset % (1 << (6 + 8)));
1171: }
1172: else
1173: {
1174: /* Use 4 bytes. */
1175: fprintf (file, "\t.short %d", (3 << (6 + 8)) + (reg_offset >> (6 + 8)));
1176: fprintf (file, "\t.short %d\n", reg_offset % (1 << (6 + 8)));
1177: }
1178: }
1179:
1180: /* Write function epilogue. */
1181:
1182: void
1183: output_epilog (file, size)
1184: FILE *file;
1185: int size;
1186: {
1187: int first_reg = first_reg_to_save();
1188: int pushes_stack = romp_pushes_stack ();
1189: int reg_save_offset = - ((16 - first_reg) + 1 + 4 + 4) * 4;
1190: int total_size = (size + romp_sa_size ()
1191: + current_function_outgoing_args_size);
1192: int fp_save = size + current_function_outgoing_args_size;
1193: int long_frame = total_size >= 32768;
1194: rtx insn = get_last_insn ();
1195: int write_code = 1;
1196:
1197: int nargs = 0; /* words of arguments */
1198: tree argptr;
1199:
1200: /* Compute the number of words of arguments. Since this is just for
1201: the traceback table, we ignore arguments that don't have a size or
1202: don't have a fixed size. */
1203:
1204: for (argptr = DECL_ARGUMENTS (current_function_decl);
1205: argptr; argptr = TREE_CHAIN (argptr))
1206: {
1207: int this_size = int_size_in_bytes (TREE_TYPE (argptr));
1208:
1209: if (this_size > 0)
1210: nargs += (this_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1211: }
1212:
1213: /* If the last insn was a BARRIER, we don't have to write anything except
1214: the trace table. */
1215: if (GET_CODE (insn) == NOTE)
1216: insn = prev_nonnote_insn (insn);
1217: if (insn && GET_CODE (insn) == BARRIER)
1218: write_code = 0;
1219:
1220: /* Restore floating-point registers. */
1221: if (write_code)
1222: output_loadsave_fpregs (file, CLOBBER,
1223: gen_rtx (PLUS, Pmode, gen_rtx (REG, Pmode, 1),
1224: gen_rtx (CONST_INT, VOIDmode, fp_save)));
1225:
1226: /* If we push the stack and do not have size > 32K, adjust the register
1227: save location to the current position of sp. Otherwise, if long frame,
1228: restore sp from fp. */
1229: if (pushes_stack && ! long_frame)
1230: reg_save_offset += total_size;
1231: else if (long_frame && write_code)
1232: fprintf (file, "\tcal r1,%d(r13)\n", romp_sa_size () + 64);
1233:
1234: /* Restore registers. */
1235: if (first_reg == 15 && write_code)
1236: fprintf (file, "\tl r15,%d(r1)\n", reg_save_offset);
1237: else if (first_reg < 16 && write_code)
1238: fprintf (file, "\tlm r%d,%d(r1)\n", first_reg, reg_save_offset);
1239: if (first_reg == 16) first_reg = 0;
1240:
1241: /* Handle popping stack, if needed and write debug table entry. */
1242: if (pushes_stack)
1243: {
1244: if (write_code)
1245: {
1246: if (long_frame)
1247: fprintf (file, "\tbr r15\n");
1248: else
1249: fprintf (file, "\tbrx r15\n\tcal r1,%d(r1)\n", total_size);
1250: }
1251:
1252: /* Table header (0xdf), usual-type stack frame (0x07),
1253: table header (0xdf), and first register saved.
1254:
1255: The final 0x08 means that there is a byte following this one
1256: describing the number of parameter words and the register used as
1257: stack pointer.
1258:
1259: If GCC passed floating-point parameters in floating-point registers,
1260: it would be necessary to change the final byte from 0x08 to 0x0c.
1261: Also an additional entry byte would be need to be emitted to specify
1262: the first floating-point register.
1263:
1264: (See also Section 11 (Trace Tables) in ``IBM/4.3 Linkage Convention,''
1265: pages IBM/4.3-PSD:5-7 of Volume III of the IBM Academic Operating
1266: System Manual dated July 1987.) */
1267:
1268: fprintf (file, "\t.long 0x%x\n", 0xdf07df08 + first_reg * 0x10);
1269:
1270: if (nargs > 15) nargs = 15;
1271:
1272: /* The number of parameter words and the register used as the stack
1273: pointer (encoded here as r1).
1274:
1275: Note: The MetWare Hich C Compiler R2.1y actually gets this wrong;
1276: it erroneously lists r13 but uses r1 as the stack too. But a bug in
1277: dbx 1.5 nullifies this mistake---most of the time.
1278: (Dbx retrieves the value of r13 saved on the stack which is often
1279: the value of r1 before the call.) */
1280:
1281: fprintf (file, "\t.byte 0x%x1\n", nargs);
1282: output_encoded_offset (file, total_size);
1283: }
1284: else
1285: {
1286: if (write_code)
1287: fprintf (file, "\tbr r15\n");
1288:
1289: /* Table header (0xdf), no stack frame (0x02),
1290: table header (0xdf) and no parameters saved (0x00).
1291:
1292: If GCC passed floating-point parameters in floating-point registers,
1293: it might be necessary to change the final byte from 0x00 to 0x04.
1294: Also a byte would be needed to specify the first floating-point
1295: register. */
1296: fprintf (file, "\t.long 0xdf02df00\n");
1297: }
1298:
1299: /* Output any pending floating-point operations. */
1300: output_fpops (file);
1301: }
1302:
1303: /* For the ROMP we need to make new SYMBOL_REFs for the actual name of a
1304: called routine. To keep them unique we maintain a hash table of all
1305: that have been created so far. */
1306:
1307: struct symref_hashent {
1308: rtx symref; /* Created SYMBOL_REF rtx. */
1309: struct symref_hashent *next; /* Next with same hash code. */
1310: };
1311:
1312: #define SYMHASHSIZE 151
1313: #define HASHBITS 65535
1314:
1315: /* Define the hash table itself. */
1316:
1317: static struct symref_hashent *symref_hash_table[SYMHASHSIZE];
1318:
1319: /* Given a name (allocatable in temporary storage), return a SYMBOL_REF
1320: for the name. The rtx is allocated from the current rtl_obstack, while
1321: the name string is allocated from the permanent obstack. */
1322: rtx
1323: get_symref (name)
1324: register char *name;
1325: {
1326: extern struct obstack permanent_obstack;
1327: register char *sp = name;
1328: unsigned int hash = 0;
1329: struct symref_hashent *p, **last_p;
1330:
1331: /* Compute the hash code for the string. */
1332: while (*sp)
1333: hash = (hash << 4) + *sp++;
1334:
1335: /* Search for a matching entry in the hash table, keeping track of the
1336: insertion location as we do so. */
1337: hash = (hash & HASHBITS) % SYMHASHSIZE;
1338: for (last_p = &symref_hash_table[hash], p = *last_p;
1339: p; last_p = &p->next, p = *last_p)
1340: if (strcmp (name, XSTR (p->symref, 0)) == 0)
1341: break;
1342:
1343: /* If couldn't find matching SYMBOL_REF, make a new one. */
1344: if (p == 0)
1345: {
1346: /* Ensure SYMBOL_REF will stay around. */
1347: end_temporary_allocation ();
1348: p = *last_p = (struct symref_hashent *)
1349: permalloc (sizeof (struct symref_hashent));
1350: p->symref = gen_rtx (SYMBOL_REF, Pmode,
1351: obstack_copy0 (&permanent_obstack,
1352: name, strlen (name)));
1353: p->next = 0;
1354: resume_temporary_allocation ();
1355: }
1356:
1357: return p->symref;
1358: }
1359:
1360: /* Validate the precision of a floating-point operation.
1361:
1362: We merge conversions from integers and between floating-point modes into
1363: the insn. However, this must not effect the desired precision of the
1364: insn. The RT floating-point system uses the widest of the operand modes.
1365: If this should be a double-precision insn, ensure that one operand
1366: passed to the floating-point processor has double mode.
1367:
1368: Note that since we don't check anything if the mode is single precision,
1369: it, strictly speaking, isn't necessary to call this for those insns.
1370: However, we do so in case something else needs to be checked in the
1371: future.
1372:
1373: This routine returns 1 if the operation is OK. */
1374:
1375: int
1376: check_precision (opmode, op1, op2)
1377: enum machine_mode opmode;
1378: rtx op1, op2;
1379: {
1380: if (opmode == SFmode)
1381: return 1;
1382:
1383: /* If operand is not a conversion from an integer mode or an extension from
1384: single-precision, it must be a double-precision value. */
1385: if (GET_CODE (op1) != FLOAT && GET_CODE (op1) != FLOAT_EXTEND)
1386: return 1;
1387:
1388: if (op2 && GET_CODE (op2) != FLOAT && GET_CODE (op2) != FLOAT_EXTEND)
1389: return 1;
1390:
1391: return 0;
1392: }
1393:
1394: /* Floating-point on the RT is done by creating an operation block in the data
1395: area that describes the operation. If two floating-point operations are the
1396: same in a single function, they can use the same block.
1397:
1398: These routines are responsible for managing these blocks. */
1399:
1400: /* Structure to describe a floating-point operation. */
1401:
1402: struct fp_op {
1403: struct fp_op *next_same_hash; /* Next op with same hash code. */
1404: struct fp_op *next_in_mem; /* Next op in memory. */
1405: int mem_offset; /* Offset from data area. */
1406: short size; /* Size of block in bytes. */
1407: short noperands; /* Number of operands in block. */
1408: rtx ops[3]; /* RTL for operands. */
1409: enum rtx_code opcode; /* Operation being performed. */
1410: };
1411:
1412: /* Size of hash table. */
1413: #define FP_HASH_SIZE 101
1414:
1415: /* Hash table of floating-point operation blocks. */
1416: static struct fp_op *fp_hash_table[FP_HASH_SIZE];
1417:
1418: /* First floating-point block in data area. */
1419: static struct fp_op *first_fpop;
1420:
1421: /* Last block in data area so far. */
1422: static struct fp_op *last_fpop_in_mem;
1423:
1424: /* Subroutine number in file, to get unique "LF" labels. */
1425: static int subr_number = 0;
1426:
1427: /* Current word offset in data area (includes header and any constant pool). */
1428: int data_offset;
1429:
1430: /* Compute hash code for an RTX used in floating-point. */
1431:
1432: static unsigned int
1433: hash_rtx (x)
1434: register rtx x;
1435: {
1436: register unsigned int hash = (((int) GET_CODE (x) << 10)
1437: + ((int) GET_MODE (x) << 20));
1438: register int i;
1439: register char *fmt = GET_RTX_FORMAT (GET_CODE (x));
1440:
1441: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
1442: if (fmt[i] == 'e')
1443: hash += hash_rtx (XEXP (x, i));
1444: else if (fmt[i] == 'u')
1445: hash += (int) XEXP (x, i);
1446: else if (fmt[i] == 'i')
1447: hash += XINT (x, i);
1448: else if (fmt[i] == 's')
1449: hash += (int) XSTR (x, i);
1450:
1451: return hash;
1452: }
1453:
1454: /* Given an operation code and up to three operands, return a character string
1455: corresponding to the code to emit to branch to a floating-point operation
1456: block. INSN is provided to see if the delay slot has been filled or not.
1457:
1458: A new floating-point operation block is created if this operation has not
1459: been seen before. */
1460:
1461: char *
1462: output_fpop (code, op0, op1, op2, insn)
1463: enum rtx_code code;
1464: rtx op0, op1, op2;
1465: rtx insn;
1466: {
1467: static char outbuf[40];
1468: unsigned int hash, hash0, hash1, hash2;
1469: int size, i;
1470: register struct fp_op *fpop, *last_fpop;
1471: int dyadic = (op2 != 0);
1472: enum machine_mode opmode;
1473: int noperands;
1474: rtx tem;
1475: unsigned int tem_hash;
1476: int fr0_avail = 0;
1477:
1478: /* Compute hash code for each operand. If the operation is commutative,
1479: put the one with the smaller hash code first. This will make us see
1480: more operations as identical. */
1481: hash0 = op0 ? hash_rtx (op0) : 0;
1482: hash1 = op1 ? hash_rtx (op1) : 0;
1483: hash2 = op2 ? hash_rtx (op2) : 0;
1484:
1485: if (hash0 > hash1 && code == EQ)
1486: {
1487: tem = op0; op0 = op1; op1 = tem;
1488: tem_hash = hash0; hash0 = hash1; hash1 = tem_hash;
1489: }
1490: else if (hash1 > hash2 && (code == PLUS || code == MULT))
1491: {
1492: tem = op1; op1 = op2; op2 = tem;
1493: tem_hash = hash1; hash1 = hash2; hash2 = tem_hash;
1494: }
1495:
1496: /* If operation is commutative and the first and third operands are equal,
1497: swap the second and third operands. Note that we must consider two
1498: operands equal if they are the same register even if different modes. */
1499: if (op2 && (code == PLUS || code == MULT)
1500: && (rtx_equal_p (op0, op2)
1501: || (GET_CODE (op0) == REG && GET_CODE (op2) == REG
1502: && REGNO (op0) == REGNO (op2))))
1503: {
1504: tem = op1; op1 = op2; op2 = tem;
1505: tem_hash = hash1; hash1 = hash2; hash2 = tem_hash;
1506: }
1507:
1508: /* If the first and second operands are the same, merge them. Don't do this
1509: for SFmode or SImode in general registers because this triggers a bug in
1510: the RT fp code. */
1511: if (op1 && rtx_equal_p (op0, op1)
1512: && code != EQ && code != GE && code != SET
1513: && ((GET_MODE (op1) != SFmode && GET_MODE (op1) != SImode)
1514: || GET_CODE (op0) != REG || FP_REGNO_P (REGNO (op0))))
1515: {
1516: op1 = op2;
1517: op2 = 0;
1518: }
1519:
1520: noperands = 1 + (op1 != 0) + (op2 != 0);
1521:
1522: /* Compute hash code for entire expression and see if operation block
1523: already exists. */
1524: hash = ((int) code << 13) + (hash0 << 2) + (hash1 << 1) + hash2;
1525:
1526: hash %= FP_HASH_SIZE;
1527: for (fpop = fp_hash_table[hash], last_fpop = 0;
1528: fpop;
1529: last_fpop = fpop, fpop = fpop->next_same_hash)
1530: if (fpop->opcode == code && noperands == fpop->noperands
1531: && (op0 == 0 || rtx_equal_p (op0, fpop->ops[0]))
1532: && (op1 == 0 || rtx_equal_p (op1, fpop->ops[1]))
1533: && (op2 == 0 || rtx_equal_p (op2, fpop->ops[2])))
1534: goto win;
1535:
1536: /* We have never seen this operation before. */
1537: fpop = (struct fp_op *) oballoc (sizeof (struct fp_op));
1538: fpop->mem_offset = data_offset;
1539: fpop->opcode = code;
1540: fpop->noperands = noperands;
1541: fpop->ops[0] = op0;
1542: fpop->ops[1] = op1;
1543: fpop->ops[2] = op2;
1544:
1545: /* Compute the size using the rules in Appendix A of the RT Linkage
1546: Convention (4.3/RT-PSD:5) manual. These rules are a bit ambiguous,
1547: but if we guess wrong, it will effect only efficiency, not correctness. */
1548:
1549: /* Size = 24 + 32 for each non-fp (or fr7) */
1550: size = 24;
1551: if (op0 && (GET_CODE (op0) != REG
1552: || ! FP_REGNO_P (REGNO (op0)) || REGNO (op0) == 23))
1553: size += 32;
1554:
1555: if (op1 && (GET_CODE (op1) != REG
1556: || ! FP_REGNO_P (REGNO (op1)) || REGNO (op1) == 23))
1557: size += 32;
1558:
1559: if (op2 && (GET_CODE (op2) != REG
1560: || ! FP_REGNO_P (REGNO (op2)) || REGNO (op2) == 23))
1561: size += 32;
1562:
1563: /* Size + 12 for each conversion. First get operation mode. */
1564: if ((op0 && GET_MODE (op0) == DFmode)
1565: || (op1 && GET_MODE (op1) == DFmode)
1566: || (op2 && GET_MODE (op2) == DFmode))
1567: opmode = DFmode;
1568: else
1569: opmode = SFmode;
1570:
1571: if (op0 && GET_MODE (op0) != opmode)
1572: size += 12;
1573: if (op1 && GET_MODE (op1) != opmode)
1574: size += 12;
1575: if (op2 && GET_MODE (op2) != opmode)
1576: size += 12;
1577:
1578: /* 12 more if first and third operand types not the same. */
1579: if (op2 && GET_MODE (op0) != GET_MODE (op2))
1580: size += 12;
1581:
1582: /* CMP and CMPT need additional. Also, compute size of save/restore here. */
1583: if (code == EQ)
1584: size += 32;
1585: else if (code == GE)
1586: size += 64;
1587: else if (code == USE || code == CLOBBER)
1588: {
1589: /* 34 + 24 for each additional register plus 8 if fr7 saved. (We
1590: call it 36 because we need to keep the block length a multiple
1591: of four. */
1592: size = 36 - 24;
1593: for (i = 0; i <= 7; i++)
1594: if (INTVAL (op0) & (1 << (7-i)))
1595: size += 24 + 8 * (i == 7);
1596: }
1597:
1598: /* We provide no general-purpose scratch registers. */
1599: size +=16;
1600:
1601: /* No floating-point scratch registers are provided. Compute extra
1602: length due to this. This logic is that shown in the referenced
1603: appendix. */
1604:
1605: i = 0;
1606: if (op0 && GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0)))
1607: i++;
1608: if (op1 && GET_CODE (op1) == REG && FP_REGNO_P (REGNO (op1)))
1609: i++;
1610: if (op2 && GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1611: i++;
1612:
1613: if ((op0 == 0 || GET_CODE (op0) != REG || REGNO(op0) != 17)
1614: && (op1 == 0 || GET_CODE (op1) != REG || REGNO(op1) != 17)
1615: && (op2 == 0 || GET_CODE (op2) != REG || REGNO(op2) != 17))
1616: fr0_avail = 1;
1617:
1618: if (dyadic)
1619: {
1620: if (i == 0)
1621: size += fr0_avail ? 64 : 112;
1622: else if (fpop->noperands == 2 && i == 1)
1623: size += fr0_avail ? 0 : 64;
1624: else if (fpop->noperands == 3)
1625: {
1626: if (GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0))
1627: && GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1628: {
1629: if (REGNO (op0) == REGNO (op2))
1630: #if 1
1631: /* This triggers a bug on the RT. */
1632: abort ();
1633: #else
1634: size += fr0_avail ? 0 : 64;
1635: #endif
1636: }
1637: else
1638: {
1639: i = 0;
1640: if (GET_CODE (op0) == REG && FP_REGNO_P (REGNO (op0)))
1641: i++;
1642: if (GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)))
1643: i++;
1644: if (i == 0)
1645: size += fr0_avail ? 64 : 112;
1646: else if (i == 1)
1647: size += fr0_avail ? 0 : 64;
1648: }
1649: }
1650: }
1651: else if (code != USE && code != CLOBBER
1652: && (GET_CODE (op0) != REG || ! FP_REGNO_P (REGNO (op0))))
1653: size += 64;
1654:
1655: if (! TARGET_FULL_FP_BLOCKS)
1656: {
1657: /* If we are not to pad the blocks, just compute its actual length. */
1658: size = 12; /* Header + opcode */
1659: if (code == USE || code == CLOBBER)
1660: size += 2;
1661: else
1662: {
1663: if (op0) size += 2;
1664: if (op1) size += 2;
1665: if (op2) size += 2;
1666: }
1667:
1668: /* If in the middle of a word, round. */
1669: if (size % UNITS_PER_WORD)
1670: size += 2;
1671:
1672: /* Handle any immediates. */
1673: if (code != USE && code != CLOBBER && op0 && GET_CODE (op0) != REG)
1674: size += 4;
1675: if (op1 && GET_CODE (op1) != REG)
1676: size += 4;
1677: if (op2 && GET_CODE (op2) != REG)
1678: size += 4;
1679:
1680: if (code != USE && code != CLOBBER &&
1681: op0 && GET_CODE (op0) == CONST_DOUBLE && GET_MODE (op0) == DFmode)
1682: size += 4;
1683: if (op1 && GET_CODE (op1) == CONST_DOUBLE && GET_MODE (op1) == DFmode)
1684: size += 4;
1685: if (op2 && GET_CODE (op2) == CONST_DOUBLE && GET_MODE (op2) == DFmode)
1686: size += 4;
1687: }
1688:
1689: /* Done with size computation! Chain this in. */
1690: fpop->size = size;
1691: data_offset += size / UNITS_PER_WORD;
1692: fpop->next_in_mem = 0;
1693: fpop->next_same_hash = 0;
1694:
1695: if (last_fpop_in_mem)
1696: last_fpop_in_mem->next_in_mem = fpop;
1697: else
1698: first_fpop = fpop;
1699: last_fpop_in_mem = fpop;
1700:
1701: if (last_fpop)
1702: last_fpop->next_same_hash = fpop;
1703: else
1704: fp_hash_table[hash] = fpop;
1705:
1706: win:
1707: /* FPOP describes the operation to be performed. Return a string to branch
1708: to it. */
1709: if (fpop->mem_offset < 32768 / UNITS_PER_WORD)
1710: sprintf (outbuf, "cal r15,%d(r14)\n\tbalr%s r15,r15",
1711: fpop->mem_offset * UNITS_PER_WORD,
1712: dbr_sequence_length () ? "x" : "");
1713: else
1714: sprintf (outbuf, "get r15,$L%dF%d\n\tbalr%s r15,r15",
1715: subr_number, fpop->mem_offset * UNITS_PER_WORD,
1716: dbr_sequence_length () ? "x" : "");
1717: return outbuf;
1718: }
1719:
1720: /* If necessary, output a floating-point operation to save or restore all
1721: floating-point registers.
1722:
1723: file is the file to write the operation to, CODE is USE for save, CLOBBER
1724: for restore, and ADDR is the address of the same area, as RTL. */
1725:
1726: static void
1727: output_loadsave_fpregs (file, code, addr)
1728: FILE *file;
1729: enum rtx_code code;
1730: rtx addr;
1731: {
1732: register int i;
1733: register int mask = 0;
1734:
1735: for (i = 2 + (TARGET_FP_REGS != 0); i <= 7; i++)
1736: if (regs_ever_live[i + 17])
1737: mask |= 1 << (7 - i);
1738:
1739: if (mask)
1740: fprintf (file, "\t%s\n",
1741: output_fpop (code, gen_rtx (CONST_INT, VOIDmode, mask),
1742: gen_rtx (MEM, Pmode, addr),
1743: 0, const0_rtx));
1744:
1745: }
1746:
1747: /* Output any floating-point operations at the end of the routine. */
1748:
1749: static void
1750: output_fpops (file)
1751: FILE *file;
1752: {
1753: register struct fp_op *fpop;
1754: register int size_so_far;
1755: register int i;
1756: rtx immed[3];
1757:
1758: if (first_fpop == 0)
1759: return;
1760:
1761: data_section ();
1762:
1763: ASM_OUTPUT_ALIGN (file, 2);
1764:
1765: for (fpop = first_fpop; fpop; fpop = fpop->next_in_mem)
1766: {
1767: if (fpop->mem_offset < 32768 / UNITS_PER_WORD)
1768: fprintf (file, "# data area offset = %d\n",
1769: fpop->mem_offset * UNITS_PER_WORD);
1770: else
1771: fprintf (file, "L%dF%d:\n",
1772: subr_number, fpop->mem_offset * UNITS_PER_WORD);
1773:
1774: fprintf (file, "\tcas r0,r15,r0\n");
1775: fprintf (file, "\t.long FPGLUE\n");
1776: switch (fpop->opcode)
1777: {
1778: case USE:
1779: fprintf (file, "\t.byte 0x1d\t# STOREM\n");
1780: break;
1781: case CLOBBER:
1782: fprintf (file, "\t.byte 0x0f\t# LOADM\n");
1783: break;
1784: case ABS:
1785: fprintf (file, "\t.byte 0x00\t# ABS\n");
1786: break;
1787: case PLUS:
1788: fprintf (file, "\t.byte 0x02\t# ADD\n");
1789: break;
1790: case EQ:
1791: fprintf (file, "\t.byte 0x07\t# CMP\n");
1792: break;
1793: case GE:
1794: fprintf (file, "\t.byte 0x08\t# CMPT\n");
1795: break;
1796: case DIV:
1797: fprintf (file, "\t.byte 0x0c\t# DIV\n");
1798: break;
1799: case SET:
1800: fprintf (file, "\t.byte 0x14\t# MOVE\n");
1801: break;
1802: case MULT:
1803: fprintf (file, "\t.byte 0x15\t# MUL\n");
1804: break;
1805: case NEG:
1806: fprintf (file, "\t.byte 0x16\t# NEG\n");
1807: break;
1808: case SQRT:
1809: fprintf (file, "\t.byte 0x1c\t# SQRT\n");
1810: break;
1811: case MINUS:
1812: fprintf (file, "\t.byte 0x1e\t# SUB\n");
1813: break;
1814: default:
1815: abort ();
1816: }
1817:
1818: fprintf (file, "\t.byte %d\n", fpop->noperands);
1819: fprintf (file, "\t.short 0x8001\n");
1820:
1821: if ((fpop->ops[0] == 0
1822: || GET_CODE (fpop->ops[0]) != REG || REGNO(fpop->ops[0]) != 17)
1823: && (fpop->ops[1] == 0 || GET_CODE (fpop->ops[1]) != REG
1824: || REGNO(fpop->ops[1]) != 17)
1825: && (fpop->ops[2] == 0 || GET_CODE (fpop->ops[2]) != REG
1826: || REGNO(fpop->ops[2]) != 17))
1827: fprintf (file, "\t.byte %d, 0x80\n", fpop->size);
1828: else
1829: fprintf (file, "\t.byte %d, 0\n", fpop->size);
1830: size_so_far = 12;
1831: for (i = 0; i < fpop->noperands; i++)
1832: {
1833: register int type;
1834: register int opbyte;
1835: register char *desc0;
1836: char desc1[50];
1837:
1838: immed[i] = 0;
1839: switch (GET_MODE (fpop->ops[i]))
1840: {
1841: case SImode:
1842: case VOIDmode:
1843: desc0 = "int";
1844: type = 0;
1845: break;
1846: case SFmode:
1847: desc0 = "float";
1848: type = 2;
1849: break;
1850: case DFmode:
1851: desc0 = "double";
1852: type = 3;
1853: break;
1854: default:
1855: abort ();
1856: }
1857:
1858: switch (GET_CODE (fpop->ops[i]))
1859: {
1860: case REG:
1861: strcpy(desc1, reg_names[REGNO (fpop->ops[i])]);
1862: if (FP_REGNO_P (REGNO (fpop->ops[i])))
1863: {
1864: type += 0x10;
1865: opbyte = REGNO (fpop->ops[i]) - 17;
1866: }
1867: else
1868: {
1869: type += 0x00;
1870: opbyte = REGNO (fpop->ops[i]);
1871: if (type == 3)
1872: opbyte = (opbyte << 4) + opbyte + 1;
1873: }
1874: break;
1875:
1876: case MEM:
1877: type += 0x30;
1878: if (GET_CODE (XEXP (fpop->ops[i], 0)) == PLUS)
1879: {
1880: immed[i] = XEXP (XEXP (fpop->ops[i], 0), 1);
1881: opbyte = REGNO (XEXP (XEXP (fpop->ops[i], 0), 0));
1882: if (GET_CODE (immed[i]) == CONST_INT)
1883: sprintf (desc1, "%d(%s)", INTVAL (immed[i]),
1884: reg_names[opbyte]);
1885: else
1886: sprintf (desc1, "<memory> (%s)", reg_names[opbyte]);
1887: }
1888: else if (GET_CODE (XEXP (fpop->ops[i], 0)) == REG)
1889: {
1890: opbyte = REGNO (XEXP (fpop->ops[i], 0));
1891: immed[i] = const0_rtx;
1892: sprintf (desc1, "(%s)", reg_names[opbyte]);
1893: }
1894: else
1895: {
1896: immed[i] = XEXP (fpop->ops[i], 0);
1897: opbyte = 0;
1898: sprintf(desc1, "<memory>");
1899: }
1900: break;
1901:
1902: case CONST_INT:
1903: case CONST_DOUBLE:
1904: case CONST:
1905: case SYMBOL_REF:
1906: case LABEL_REF:
1907: type += 0x20;
1908: opbyte = 0;
1909: immed[i] = fpop->ops[i];
1910: desc1[0] = '$';
1911: desc1[1] = '\0';
1912: break;
1913:
1914: default:
1915: abort ();
1916: }
1917:
1918: /* Save/restore is special. */
1919: if (i == 0 && (fpop->opcode == USE || fpop->opcode == CLOBBER))
1920: type = 0xff, opbyte = INTVAL (fpop->ops[0]), immed[i] = 0;
1921:
1922: fprintf (file, "\t.byte 0x%x,0x%x # (%s) %s\n",
1923: type, opbyte, desc0, desc1);
1924:
1925: size_so_far += 2;
1926: }
1927:
1928: /* If in the middle of a word, round. */
1929: if (size_so_far % UNITS_PER_WORD)
1930: {
1931: fprintf (file, "\t.space 2\n");
1932: size_so_far += 2;
1933: }
1934:
1935: for (i = 0; i < fpop->noperands; i++)
1936: if (immed[i])
1937: switch (GET_MODE (immed[i]))
1938: {
1939: case SImode:
1940: case VOIDmode:
1941: size_so_far += 4;
1942: fprintf (file, "\t.long ");
1943: output_addr_const (file, immed[i]);
1944: fprintf (file, "\n");
1945: break;
1946:
1947: case DFmode:
1948: size_so_far += 4;
1949: case SFmode:
1950: size_so_far += 4;
1951: if (GET_CODE (immed[i]) == CONST_DOUBLE)
1952: {
1953: union real_extract u;
1954:
1955: bcopy (&CONST_DOUBLE_LOW (immed[i]), &u, sizeof u);
1956: if (GET_MODE (immed[i]) == DFmode)
1957: ASM_OUTPUT_DOUBLE (file, u.d);
1958: else
1959: ASM_OUTPUT_FLOAT (file, u.d);
1960: }
1961: else
1962: abort ();
1963: break;
1964:
1965: default:
1966: abort ();
1967: }
1968:
1969: if (size_so_far != fpop->size)
1970: {
1971: if (TARGET_FULL_FP_BLOCKS)
1972: fprintf (file, "\t.space %d\n", fpop->size - size_so_far);
1973: else
1974: abort ();
1975: }
1976: }
1977:
1978: /* Update for next subroutine. */
1979: subr_number++;
1980: text_section ();
1981: }
1982:
1983: /* Initialize floating-point operation table. */
1984:
1985: static void
1986: init_fpops()
1987: {
1988: register int i;
1989:
1990: first_fpop = last_fpop_in_mem = 0;
1991: for (i = 0; i < FP_HASH_SIZE; i++)
1992: fp_hash_table[i] = 0;
1993: }
1994:
1995: /* Return the offset value of an automatic variable (N_LSYM) having
1996: the given offset. Basically, we correct by going from a frame pointer to
1997: stack pointer value.
1998: */
1999:
2000: int
2001: romp_debugger_auto_correction(offset)
2002: int offset;
2003: {
2004: int fp_to_sp;
2005:
2006: /* We really want to go from STACK_POINTER_REGNUM to
2007: FRAME_POINTER_REGNUM, but this isn't defined. So go the other
2008: direction and negate. */
2009: INITIAL_ELIMINATION_OFFSET (FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM,
2010: fp_to_sp);
2011:
2012: /* The offset value points somewhere between the frame pointer and
2013: the stack pointer. What is up from the frame pointer is down from the
2014: stack pointer. Therefore the negation in the offset value too. */
2015:
2016: return -(offset+fp_to_sp+4);
2017: }
2018:
2019: /* Return the offset value of an argument having
2020: the given offset. Basically, we correct by going from a arg pointer to
2021: stack pointer value. */
2022:
2023: int
2024: romp_debugger_arg_correction (offset)
2025: int offset;
2026: {
2027: int fp_to_argp;
2028:
2029: INITIAL_ELIMINATION_OFFSET (ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM,
2030: fp_to_argp);
2031:
2032: /* Actually, something different happens if offset is from a floating-point
2033: register argument, but we don't handle it here. */
2034:
2035: return (offset - fp_to_argp);
2036: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.