![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to convex.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 convex.c CVS log | Up to [GCC 2.x] / gcc / config |
1.1 root 1: /* Subroutines for insn-output.c for Convex.
2: Copyright (C) 1989,1991 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: #include "config.h"
21: #include "rtl.h"
22: #include "regs.h"
23: #include "hard-reg-set.h"
24: #include "real.h"
25: #include "insn-config.h"
26: #include "conditions.h"
27: #include "insn-flags.h"
28: #include "output.h"
29: #include "insn-attr.h"
30:
31: /* Boolean to keep track of whether the current section is .text or not.
32: Used by .align handler in convex.h. */
33:
34: int current_section_is_text;
35:
36: /* set_cmp saves the operands of a "cmp" insn, along with the type character
37: * to be used in the compare instruction.
38: *
39: * gen_cmp finds out what comparison is to be performed and outputs the
40: * necessary instructions, e.g.
41: * "eq.w a1,a2\;jbra.t L5"
42: * for (cmpsi a1 a2) (beq L5) */
43:
44: static rtx xop0, xop1;
45: static char typech, regch;
46:
47: char *
48: set_cmp (op0, op1, typechr)
49: rtx op0, op1;
50: char typechr;
51: {
52: xop0 = op0;
53: xop1 = op1;
54: typech = typechr;
55: if (GET_CODE (op0) == REG)
56: regch = A_REGNO_P (REGNO (op0)) ? 'a' : 's';
57: else if (GET_CODE (op1) == REG)
58: regch = A_REGNO_P (REGNO (op1)) ? 'a' : 's';
59: else abort ();
60: return "";
61: }
62:
63: char *
64: gen_cmp (label, cmpop, tf)
65: rtx label;
66: char *cmpop;
67: char tf;
68: {
69: char buf[80];
70: char revop[4];
71: rtx ops[3];
72:
73: ops[2] = label;
74:
75: /* Constant must be first; swap operands if necessary.
76: If lt, le, ltu, leu are swapped, change to le, lt, leu, ltu
77: and reverse the sense of the jump. */
78:
79: if (CONSTANT_P (xop1))
80: {
81: ops[0] = xop1;
82: ops[1] = xop0;
83: if (cmpop[0] == 'l')
84: {
85: bcopy (cmpop, revop, sizeof revop);
86: revop[1] ^= 'e' ^ 't';
87: tf ^= 't' ^ 'f';
88: cmpop = revop;
89: }
90: }
91: else
92: {
93: ops[0] = xop0;
94: ops[1] = xop1;
95: }
96:
97: sprintf (buf, "%s.%c %%0,%%1\n\tjbr%c.%c %%l2", cmpop, typech, regch, tf);
98: output_asm_insn (buf, ops);
99: return "";
100: }
101:
102: /* Routines to separate CONST_DOUBLEs into component parts. */
103:
104: int
105: const_double_high_int (x)
106: rtx x;
107: {
108: if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
109: return CONST_DOUBLE_LOW (x);
110: else
111: return CONST_DOUBLE_HIGH (x);
112: }
113:
114: int
115: const_double_low_int (x)
116: rtx x;
117: {
118: if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
119: return CONST_DOUBLE_HIGH (x);
120: else
121: return CONST_DOUBLE_LOW (x);
122: }
123:
124: /* Return the number of args in the call insn X. */
125:
126: static int
127: call_num_args (x)
128: rtx x;
129: {
130: if (GET_CODE (x) == CALL)
131: return INTVAL (x->fld[1].rtx);
132: if (GET_CODE (x) == SET)
133: return call_num_args (SET_SRC (x));
134: abort ();
135: }
136:
137: /* Scan forward from a call to decide whether we need to reload AP
138: from 12(FP) after it. We need to if there can be a reference to
139: arg_pointer_rtx before the next call, which will clobber AP.
140: Look forward in the instruction list until encountering a call
141: (don't need the load), or a reference to AP (do need it), or
142: a jump (don't know, do the load). */
143:
144: static int
145: ap_reload_needed (insn)
146: rtx insn;
147: {
148: for (;;)
149: {
150: insn = NEXT_INSN (insn);
151: switch (GET_CODE (insn))
152: {
153: case JUMP_INSN:
154: /* Basic block ends. If return, no AP needed, else assume it is. */
155: return GET_CODE (PATTERN (insn)) != RETURN;
156: case CALL_INSN:
157: /* A subsequent call. AP isn't needed unless the call itself
158: requires it. But zero-arg calls don't clobber AP, so
159: don't terminate the search in that case. */
160: if (reg_mentioned_p (arg_pointer_rtx, PATTERN (insn)))
161: return 1;
162: if (! TARGET_ARGCOUNT && call_num_args (PATTERN (insn)) == 0)
163: break;
164: return 0;
165: case BARRIER:
166: /* Barrier, don't need AP. */
167: return 0;
168: case INSN:
169: /* Other insn may need AP; if not, keep looking. */
170: if (reg_mentioned_p (arg_pointer_rtx, PATTERN (insn)))
171: return 1;
172: }
173: }
174: }
175:
176: /* Output the insns needed to do a call. */
177:
178: char *
179: output_call (insn, address, argcount)
180: rtx insn, address, argcount;
181: {
182: int set_ap = TARGET_ARGCOUNT || argcount != const0_rtx;
183:
184: /* If AP is used by the call address, evaluate the address into a temp. */
185: if (reg_mentioned_p (arg_pointer_rtx, address))
186: if (set_ap)
187: {
188: address = XEXP (address, 0);
189: output_asm_insn ("ld.w %0,a1", &address);
190: address = gen_rtx (MEM, QImode, gen_rtx (REG, Pmode, 9));
191: }
192:
193: /* If there are args, point AP to them. */
194: if (set_ap)
195: output_asm_insn ("mov sp,ap");
196:
197: /* If we are passing an arg count, convert it to words and push it. */
198: if (TARGET_ARGCOUNT)
199: {
200: argcount = gen_rtx (CONST_INT, VOIDmode, (INTVAL (argcount) + 3) / 4);
201: output_asm_insn ("pshea %a0", &argcount);
202: }
203:
204: /* The call. */
205: output_asm_insn ("calls %0", &address);
206:
207: /* If we clobbered AP, reload it if it is live. */
208: if (set_ap)
209: if (ap_reload_needed (insn))
210: output_asm_insn ("ld.w 12(fp),ap");
211:
212: /* If we pushed an arg count, pop it and the args. */
213: if (TARGET_ARGCOUNT)
214: {
215: argcount = gen_rtx (CONST_INT, VOIDmode, INTVAL (argcount) * 4 + 4);
216: output_asm_insn ("add.w %0,sp", &argcount);
217: }
218:
219: return "";
220: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.