![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / alef / k|
Return to reg.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / alef / k |
1.1 root 1: #include <u.h>
2: #include <libc.h>
3: #include <bio.h>
4: #include <ctype.h>
5: #define Extern extern
6: #include "parl.h"
7: #include "globl.h"
8:
9: int regmap[65];
10:
11: void
12: reginit(void)
13: {
14: regmap[Retfreg]++;
15: regmap[Retireg]++;
16: regmap[Reglink]++;
17: regmap[Regtmp]++;
18:
19: privreg = Pregs;
20: }
21:
22: void
23: regcheck(void)
24: {
25: int r, e;
26:
27: e = 0;
28: for(r = Ireg; r < Maxireg; r++)
29: if(regmap[r]) {
30: switch(r) {
31: default:
32: print("R%d still used\n", r);
33: e++;
34: break;
35: case Retfreg:
36: case Retireg:
37: case Reglink:
38: case Regtmp:
39: break;
40: }
41: }
42:
43: for(r = Freg; r < Maxfreg; r++)
44: if(regmap[r] && (r != Retfreg || regmap[Retfreg] != 1)) {
45: print("F%d still used\n", r);
46: e++;
47: }
48: if(e)
49: fatal("regcheck %P", curfunc);
50: }
51:
52: void
53: reg(Node *n, Type *t, Node *use)
54: {
55: int r, j;
56: static int ireg;
57:
58: switch(t->type) {
59: default:
60: fatal("reg: bad type %T", t);
61:
62: case TINT:
63: case TUINT:
64: case TSINT:
65: case TSUINT:
66: case TCHAR:
67: case TIND:
68: case TCHANNEL:
69: if(use && use->type == OREGISTER && use->reg < Freg) {
70: r = use->reg;
71: break;
72: }
73: j = ireg+Ireg;
74: for(r = Ireg; r < Maxireg; r++) {
75: if(j >= Maxireg)
76: j = Ireg;
77: if(regmap[j] == 0) {
78: r = j;
79: break;
80: }
81: j++;
82: }
83: if(r >= Maxireg)
84: fatal("No int registers");
85: break;
86:
87: case TFLOAT:
88: if(use && use->type == OREGISTER && use->reg >= Freg) {
89: r = use->reg;
90: break;
91: }
92:
93: j = ireg*2+Freg;
94: for(r = Freg; r < Maxfreg; r += 2) {
95: if(j >= Maxfreg)
96: j = Ireg;
97: if(regmap[j] == 0) {
98: r = j;
99: break;
100: }
101: j += 2;
102: }
103: if(r >= Maxfreg)
104: fatal("No float registers");
105: break;
106: }
107: ireg++;
108: if(ireg > 5)
109: ireg = 0;
110: regmap[r]++;
111: n->reg = r;
112: n->type = OREGISTER;
113: n->islval = 11;
114: n->sun = 0;
115: n->t = t;
116: }
117:
118: Node*
119: regtmp(void)
120: {
121: Node *n;
122: int r;
123:
124: n = an(OREGISTER, ZeroN, ZeroN);
125: n->t = builtype[TINT];
126: n->islval = 11;
127: n->sun = 0;
128:
129: for(r = Ireg; r < Maxireg; r++)
130: if(regmap[r] == 0) {
131: n->reg = r;
132: regmap[r]++;
133: return n;
134: }
135: fatal("No int registers");
136: return ZeroN;
137: }
138:
139: Node*
140: regn(int nr)
141: {
142: Node *n;
143:
144: n = an(OREGISTER, ZeroN, ZeroN);
145: if(nr >= Freg)
146: n->t = builtype[TFLOAT];
147: else
148: n->t = builtype[TINT];
149: n->islval = 11;
150: n->sun = 0;
151: n->reg = nr;
152: return n;
153: }
154:
155: void
156: regret(Node *n, Type*t)
157: {
158: int r;
159:
160: switch(t->type) {
161: default:
162: fatal("regret: bad type %T", t);
163:
164: case TINT:
165: case TUINT:
166: case TSINT:
167: case TSUINT:
168: case TCHAR:
169: case TIND:
170: case TCHANNEL:
171: r = Retireg;
172: break;
173:
174: case TFLOAT:
175: r = Retfreg;
176: break;
177: }
178: regmap[r]++;
179: n->reg = r;
180: n->type = OREGISTER;
181: n->t = t;
182: }
183:
184: void
185: regfree(Node *n)
186: {
187: if(regmap[n->reg] <= 0)
188: fatal("regfree");
189:
190: regmap[n->reg]--;
191: }
192:
193: /*
194: * look for a constant which fits in a sparc immediate
195: */
196: int
197: immed(Node *n)
198: {
199: long ival;
200:
201: if(n->type != OCONST || n->t->type == TFLOAT)
202: return 0;
203:
204: ival = n->ival;
205: if(ival >= -(1<<12) && ival < (1<<12))
206: return 1;
207:
208: return 0;
209: }
210:
211: /*
212: * Return the name of an activation argument
213: */
214: Node*
215: atvnode(Type *t)
216: {
217: int o;
218: Node *n;
219:
220: n = an(OREGISTER, ZeroN, ZeroN);
221: n->reg = ratv.reg;
222: n->ival = 0;
223: n->t = at(TIND, t);
224:
225: o = align(ratv.ival, builtype[TINT]);
226: ratv.ival = o+t->size;
227: if(ratv.ival > maxframe)
228: maxframe = ratv.ival;
229:
230: /* Adjust offset within int for smaller types */
231: switch(t->type) {
232: case TSINT:
233: case TSUINT:
234: o += Shortfoff;
235: break;
236:
237: case TCHAR:
238: o += Charfoff;
239: break;
240: }
241:
242: n = an(OADD, n, con(o));
243: n->t = n->left->t;
244: n = an(OIND, n, ZeroN);
245: n->t = t;
246:
247: sucalc(n);
248: return n;
249: }
250:
251: /*
252: * Make a node to alias an argument
253: */
254: Node*
255: argnode(Type *t)
256: {
257: Node *n;
258: int o;
259:
260: if(atv)
261: return atvnode(t);
262:
263: n = an(ONAME, ZeroN, ZeroN);
264: n->t = t;
265: n->ti = ati(t, Argument);
266: args = align(args, builtype[TINT]);
267: o = args;
268:
269: /* Adjust offset within int for smaller types */
270: switch(t->type) {
271: case TSINT:
272: case TSUINT:
273: o += Shortfoff;
274: break;
275:
276: case TCHAR:
277: o += Charfoff;
278: break;
279: }
280:
281: n->ti->offset = o;
282: args += t->size;
283:
284: sucalc(n);
285: return n;
286: }
287:
288: Node*
289: paramnode(Type *t)
290: {
291: Node *n;
292:
293: USED(t);
294:
295: while(tip->class != Parameter)
296: tip = tip->dcllist;
297:
298: n = an(ONAME, ZeroN, ZeroN);
299: n->sym = tip->s;
300: n->ti = tip;
301: n->t = tip->t;
302:
303: /* for next time */
304: tip = tip->dcllist;
305:
306: sucalc(n);
307: return n;
308: }
309:
310: /*
311: * Make a stack temporary node and allocate space in the frame
312: */
313: Node*
314: stknode(Type *o)
315: {
316: Node *n;
317: char buf[10];
318:
319: n = an(ONAME, ZeroN, ZeroN);
320: n->sym = malloc(sizeof(Sym));
321: n->ti = ati(o, Automatic);
322: n->t = o;
323:
324: sprint(buf, ".t%d", stmp++);
325: n->sym->name = strdup(buf);
326:
327: /* Allocate the space */
328: frame = align(frame, o);
329: frame += o->size;
330:
331: n->ti->offset = -frame;
332: sucalc(n);
333: return n;
334: }
335:
336: Node*
337: internnode(Type *o)
338: {
339: Node *n;
340: char buf[10];
341:
342: n = an(ONAME, ZeroN, ZeroN);
343: n->sym = malloc(sizeof(Sym));
344: n->t = at(o->type, 0);
345: n->t->class = Internal;
346: n->ti = ati(n->t, Internal);
347:
348: sprint(buf, ".i%d", stmp++);
349: n->sym->name = strdup(buf);
350:
351: n->ti->offset = 0;
352: sucalc(n);
353:
354: n->init = ZeroN;
355: gendata(n);
356:
357: return n;
358: }
359:
360: Node*
361: con(int i)
362: {
363: Node *c;
364:
365: c = an(OCONST, ZeroN, ZeroN);
366: c->t = builtype[TINT];
367: c->ival = i;
368:
369: return c;
370: }
371:
372: Node*
373: conf(double d)
374: {
375: Node *c;
376:
377: c = an(OCONST, ZeroN, ZeroN);
378: c->t = builtype[TFLOAT];
379: c->fval = d;
380:
381: return c;
382: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.