![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / gen2|
Return to gen.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / gen2 |
1.1 root 1: /* C compiler: machine-independent back-end support routines */
2:
3: #include "c.h"
4:
5: unsigned freemask[3];
6: int savebase[3];
7: unsigned savemask[3];
8: unsigned tempmask[3];
9: unsigned usedmask[3];
10: unsigned eemask[3];
11: unsigned tmask[3];
12: unsigned vmask[3];
13:
14: char **asmstr[MAXINTS];
15: int nregsets;
16: Node last;
17: int maxoffset;
18: int ncalls;
19: int offset;
20: int argoffset;
21: int argbuildsize;
22: int bflag, dflag, kflag, pflag, rflag;
23: char **opcodes;
24: Symbol regs;
25: Symbol regvars;
26: Symbol rmap[8];
27: int dalign, salign;
28: int genx = 2;
29:
30: static int cseg;
31: static Node curhead;
32:
33: dclproto(static Node *findxnext,(Node));
34: dclproto(static void freereg,(Symbol));
35: dclproto(static void genreload,(Node*, Symbol, int, Symbol));
36: dclproto(static void genreloads,(Node, Symbol, int, Symbol));
37: dclproto(static Symbol genspill,(Symbol, int, Node *));
38: dclproto(static Symbol getreg,(Symbol, Node, unsigned, int));
39: dclproto(static void linearize,(Node, Node *, Node));
40: dclproto(static Node *lin1,(Node, Node *));
41: dclproto(static Symbol mkreg,(char *, int, int, int, int, Symbol));
42: dclproto(static void mvregvar,(Symbol, unsigned));
43: dclproto(static int ntob,(Symbol));
44: dclproto(static int overlaps,(Symbol, Symbol));
45: dclproto(static void ralloc,(Node));
46: dclproto(static int rmember,(Regnode, Symbol));
47: dclproto(static Symbol spillee,(Symbol, Node, unsigned));
48: dclproto(static void spillr,(Symbol, Node));
49: dclproto(static int uses,(Node, Symbol));
50:
51: /* aset - record that p and any right ADD+P descendants are address calculations */
52: int aset(p, n) Node p; {
53: p = p->kids[n];
54: p->x.loadaddr = 1;
55: while (p->op == ADD+P) {
56: p = p->kids[1];
57: p->x.loadaddr = 1;
58: }
59: return 1;
60: }
61:
62: /* bitcount - count number of 1 bits in mask */
63: int bitcount(mask) unsigned mask; {
64: unsigned i, n = 0;
65:
66: for (i = 1; i; i <<= 1)
67: if (mask&i)
68: n++;
69: return n;
70: }
71:
72: /* blkcopy - emit code to copy size bytes from sreg+soff to dreg+doff using tmp regs */
73: void blkcopy(dreg, doff, sreg, soff, size, tmp) int tmp[]; {
74: if (size <= 0)
75: return;
76: else if (size <= 1) {
77: blkunroll(1, dreg, doff, sreg, soff, size, tmp);
78: } else if (size <= 3) {
79: blkunroll(2, dreg, doff, sreg, soff, 2, tmp);
80: blkcopy(dreg, doff+(size&~(2-1)), sreg, soff+(size&~(2-1)), size&(2-1), tmp);
81: } else if (size <= 16) {
82: blkunroll(4, dreg, doff, sreg, soff, size&~(4-1), tmp);
83: blkcopy(dreg, doff+(size&~(4-1)), sreg, soff+(size&~(4-1)), size&(4-1), tmp);
84: } else
85: (*IR->x.blkloop)(dreg, doff, sreg, soff, size, tmp);
86: }
87:
88: /* blkunroll - blkcopy as an unrolled loop using k-byte chunks */
89: void blkunroll(k, dreg, doff, sreg, soff, size, tmp) int tmp[]; {
90: int i;
91:
92: assert(IR->x.maxunalignedload);
93: if ((salign < k || dalign < k) && k > IR->x.maxunalignedload)
94: k = IR->x.maxunalignedload;
95: (*IR->x.blkfetch)(k, soff, sreg, tmp[0]);
96: for (i = k; i <= size - k; i += k) {
97: (*IR->x.blkfetch)(k, i+soff, sreg, tmp[(i&k)==k]);
98: (*IR->x.blkstore)(k, i+doff-k, dreg, tmp[(i&k)!=k]);
99: }
100: (*IR->x.blkstore)(k, i+doff-k, dreg, tmp[((i-k)&k)==k]);
101: }
102:
103: /* blockbeg - begin a compound statement */
104: void blockbeg(e) Env *e; {
105: int i;
106:
107: e->off = offset;
108: for (i = 0; i < nregsets; i++)
109: e->freemask[i] = freemask[i];
110: }
111:
112: /* blockend - end a compound statement */
113: void blockend(e) Env *e; {
114: int i;
115:
116: if (offset > maxoffset)
117: maxoffset = offset;
118: offset = e->off;
119: for (i = 0; i < nregsets; i++)
120: freemask[i] = e->freemask[i];
121: }
122:
123: /* docall - finalize a call */
124: void docall(p) Node p; {
125: if (argoffset > argbuildsize)
126: argbuildsize = argoffset;
127: p->syms[0] = intconst(argoffset);
128: argoffset = 0;
129: }
130:
131: /* dumpregs - trace register allocation */
132: void dumpregs(msg, a, b) char *a, *b, *msg; {
133: int i;
134:
135: fprint(2, msg, a, b);
136: for (i = 0; i < nregsets; i++)
137: fprint(2, "(free[%d]=%x)\n", i, freemask[i]);
138: }
139:
140: /* dumptree1 - emit debugging image of dag p, indented n, with kid# k */
141: void dumptree1(p, op, k, n) Node p; {
142: int i;
143: char *s;
144: extern char **opcodes;
145:
146: if (dflag == 0 || p == 0)
147: return;
148: for (i = 0; i < n; i++)
149: fprint(2, " ");
150: if (k < 0)
151: fprint(2, "(root=%x ", p);
152: else
153: fprint(2, "(kid%d=%x ", k, p);
154: s = opname(op);
155: if (*s >= '0' && *s <= '9')
156: s = opcodes[op];
157: fprint(2, "op=%s ", s);
158: for (i = 0; i < MAXINTS; i++)
159: if (p->x.ints[i])
160: fprint(2, "I%d=%s ", i, asmstr[i][p->x.ints[i]]);
161: for (i = 0; i < MAXSYMS; i++)
162: if (p->syms[i])
163: fprint(2, "S%d=%s ", i, p->syms[i]->x.name);
164: fprint(2, "count=%d)\n", p->count);
165: if (p->x.registered == 0)
166: for (i = 0; i < MAXKIDS; i++)
167: if (p->kids[i])
168: dumptree1(p->kids[i], p->kids[i]->op, i, n+1);
169: if (k == -1)
170: fprint(2, "\n");
171: }
172:
173: void export(p) Symbol p; {
174: if (!bflag)
175: print(IR->x.exportfmt, p->x.name);
176: }
177:
178: /* findxnext - return the address of the pointer to p in the linearized chain */
179: static Node *findxnext(p) Node p; {
180: Node *q;
181:
182: for (q = &curhead; *q; q = &(*q)->x.next)
183: if (*q == p)
184: return q;
185: assert(0);
186: return 0;
187: }
188:
189: /* freereg - free register p */
190: static void freereg(p) Symbol p; {
191: assert(p->x.regnode);
192: p->x.regnode->count = 0;
193: freemask[p->x.regnode->regset] |= p->x.regnode->mask;
194: debug(rflag, dumpregs("(freeing %s)\n", p->x.name, 0));
195: }
196:
197: /* freeregvars - free register variables */
198: void freeregvars() {
199: Symbol p;
200:
201: for (p = regvars; p; p = p->x.nextregvar) {
202: Regnode r = p->x.regvar->x.regnode;
203: usedmask[r->regset] |= r->mask;
204: freereg(p->x.regvar);
205: }
206: }
207:
208: /* gen - drive nodelist from front end through all back-end phases */
209: Node gen(nodelist) Node nodelist; {
210: int i;
211: Node p, q = 0;
212:
213: curhead = nodelist;
214: last = 0;
215: for (p = nodelist; p; p = p->link) {
216: switch (generic(p->op)) {
217: case CALL:
218: p->x.sideeffect = 1;
219: p->x.iscall = 1;
220: p->x.args = q;
221: q = 0;
222: (*IR->x.docall)(p);
223: break;
224: case ARG:
225: p->x.isarg = 1;
226: p->x.args = q;
227: q = p;
228: (*IR->x.doarg)(p);
229: /* fall through */
230: case ASGN: case JUMP: case LABEL: case RET:
231: case EQ: case GE: case GT: case LE: case LT: case NE:
232: assert(p->count == 0);
233: p->x.sideeffect = 1;
234: break;
235: case INDIR:
236: p->x.unavailable = 1;
237: assert(p->count);
238: break;
239: case DIV: case MOD: case MUL:
240: if (IR->mulops_are_calls && (optype(p->op) == I || optype(p->op) == U))
241: break;
242: /* else fall through */
243: default:
244: assert(0);
245: }
246: (*IR->x.rewrite)(p);
247: last = p;
248: debug(dflag, fprint(2, "(last=%x)\n", last));
249: }
250: last = 0;
251: linearize(curhead, &curhead, 0);
252: for (p = curhead; p; p = p->x.next) {
253: assert(p->x.sideeffect || p->count);
254: if (p->x.registered == 0) {
255: if (p->x.iscall)
256: for (q = p->x.args; q; q = q->x.args)
257: if (q->syms[RX] && q->syms[RX]->x.regnode)
258: freereg(q->syms[RX]);
259: ralloc(p);
260: if (p->x.isarg && p->syms[RX] && p->syms[RX]->x.regnode)
261: p->syms[RX]->x.regnode->count = -1;
262: else if (p->x.listed && p->count == 0 && p->syms[RX] && p->syms[RX]->x.regnode && p->syms[RX]->x.regnode->count >= 0)
263: freereg(p->syms[RX]);
264: last = p;
265: } else
266: last = 0;
267: }
268: for (i = 0; i < nregsets; i++) {
269: freemask[i] |= tempmask[i];
270: tempmask[i] = 0;
271: }
272: return curhead;
273: }
274:
275: /* genascii - emit ascii string str */
276: void genascii(ascii, byte, len, str) char *ascii, *byte, *str; {
277: char *s = str;
278: int m, n;
279:
280: for (n = 5, m = 9; s < str + len; s++) {
281: if (*s == '"' || *s == '\\')
282: m += 2;
283: else
284: m += *s < ' ' || *s >= 0177 ? 4 : 1;
285: n += *s < 10 ? 2 : *s < 100 ? 3 : 4;
286: }
287: s = str;
288: if (ascii == 0 || n < m) {
289: print("%s %d", byte, (*s++)&0xff);
290: for (n = 0; s < str + len; n++)
291: if (n > 10) {
292: n = 0;
293: print("\n%s %d", byte, (*s++)&0xff);
294: } else
295: print(",%d", (*s++)&0xff);
296: outs("\n");
297: } else {
298: n = 0;
299: print("%s \"", ascii);
300: for (s = str; s < str + len; s++) {
301: if (n >= 64) {
302: print("\"\n%s \"", ascii);
303: n = 0;
304: }
305: if (*s == '"' || *s == '\\') {
306: print("\\%c", *s);
307: n += 2;
308: } else if (*s >= ' ' && *s < 0177) {
309: *bp++ = *s;
310: n += 1;
311: } else {
312: print("\\%d%d%d", (*s>>6)&3, (*s>>3)&7, *s&7);
313: n += 4;
314: }
315: }
316: outs("\"\n");
317: }
318: }
319:
320: /* genreload - make *pp use reloads instead of r */
321: static void genreload(pp, temp, ty, r) Node *pp; Symbol r, temp; {
322: int i;
323: Node p = *pp;
324:
325: for (i = 0; i < MAXKIDS; i++)
326: if (p->kids[i] && p->kids[i]->syms[RX] == r && p->kids[i]->x.registered) {
327: Symbol target = p->kids[i]->x.rtarget;
328: p->kids[i] = newnode(INDIR + ty, newnode(ADDRL+P, 0, 0, temp), 0, 0);
329: p->kids[i]->count = 1;
330: (*IR->x.rewrite)(p->kids[i]);
331: if (target)
332: rtarget(p, i, target);
333: (*IR->x.rewrite)(p);
334: linearize(p->kids[i], pp, *pp);
335: if (p->kids[i])
336: pp = &p->kids[i]->x.next;
337: }
338: }
339:
340: /* genreloads - make the nodes after dot use reloads instead of r */
341: static void genreloads(dot, temp, ty, r) Node dot; Symbol r, temp; {
342: Node p, *pp;
343:
344: if (IR->x.twoop && dot->x.zap0) {
345: pp = findxnext(dot);
346: genreload(pp, temp, ty, r);
347: for (p = *pp; p != dot; p = p->x.next)
348: ralloc(*pp);
349: }
350: for (pp = &dot->x.next; dot = *pp; pp = &dot->x.next)
351: genreload(pp, temp, ty, r);
352: }
353:
354: /* genspill - generate code to spill r and return the temp used */
355: static Symbol genspill(r, ty, last) Symbol r; Node *last; {
356: Node p, q;
357: Symbol s, tmp;
358: static struct symbol z;
359: unsigned i, savemask[(sizeof freemask)/(sizeof freemask[0])];
360:
361: for (i = 0; i < nregsets; i++) {
362: savemask[i] = vmask[i];
363: vmask[i] &= ~usedmask[i];
364: }
365: tmp = newtemp(REGISTER, ty);
366: for (i = 0; i < nregsets; i++)
367: vmask[i] = savemask[i];
368: debug(rflag, fprint(2, "(spilling %s to symbol %s=%s)\n", r->x.name, tmp->name, tmp->x.name));
369: s = (Symbol) talloc(sizeof *s);
370: *s = z;
371: s->sclass = REGISTER;
372: s->x.name = r->x.name;
373: symeaddr(s) = symeaddr(r);
374: s->x.regvar = r;
375: q = newnode(ADDRL+P, 0, 0, s);
376: q = newnode(INDIR + ty, q, 0, 0);
377: p = newnode(ADDRL+P, 0, 0, tmp);
378: p = newnode(ASGN + ty, p, q, 0);
379: p->x.sideeffect = 1;
380: (*IR->x.rewrite)(p);
381: q = *last;
382: linearize(p, last, q);
383: for (p = *last; p != q; p = p->x.next)
384: ralloc(p);
385: return tmp;
386: }
387:
388: /* getint - return value of signed integer constant */
389: int getint(p) Symbol p; {
390: switch (ttob(p->type)) {
391: case C: return p->u.c.v.sc;
392: case S: return p->u.c.v.ss;
393: default: return p->u.c.v.i;
394: }
395: }
396:
397: /* getreg - assign a register from set rs to node p */
398: static Symbol getreg(rs, p, rmask, count) Symbol rs; Node p; unsigned rmask; {
399: Regnode rn;
400: Symbol r;
401:
402: if (rs->x.regnode->link == 0)
403: rmask = -1;
404: for (r = rs; r; r = rn->link) {
405: rn = r->x.regnode;
406: assert(rn);
407: if ((rn->mask&~(freemask[rn->regset]&rmask)) == 0) {
408: freemask[rn->regset] &= ~rn->mask;
409: r->x.regnode->node = p;
410: r->x.regnode->count = count;
411: return r;
412: }
413: }
414: if (p == 0) /* register variable */
415: return 0;
416: r = spillee(rs, p, rmask);
417: spill(r->x.regnode->mask, r->x.regnode->regset, p);
418: r = getreg(rs, p, rmask, count);
419: assert(r);
420: return r;
421: }
422:
423: /* getregnode - return regnode for register variable or codegen temp */
424: Regnode getregnode(p) Symbol p; {
425: assert(p);
426: if (p->x.regvar) {
427: assert(!p->x.regnode);
428: assert(p->x.regvar->x.regnode);
429: return p->x.regvar->x.regnode;
430: } else {
431: assert(p->x.regnode);
432: return p->x.regnode;
433: }
434: }
435:
436: /* getregset - return index of the register set to which p's been allocated */
437: int getregset(p) Symbol p; {
438: if (p->sclass == REGISTER) {
439: assert(p->x.regvar);
440: return getregnode(p)->regset;
441: } else
442: return -1;
443: }
444:
445: /* getregvar - assign variable p to a register if possible */
446: int getregvar(p, reglist) Symbol p, reglist; {
447: Symbol reg;
448:
449: assert(p && p->type);
450: if (reglist && isscalar(p->type) && isregvar(p) && (reg = getreg(reglist, 0, vmask[reglist->x.regnode->regset], -1))) {
451: p->x.regvar = reg;
452: p->x.name = reg->x.name;
453: symeaddr(p) = symeaddr(reg);
454: p->x.nextregvar = regvars;
455: regvars = p;
456: debug(rflag, dumpregs("(allocating %s to symbol %s)\n", p->x.name, p->name));
457: if (p->temporary)
458: tempmask[reg->x.regnode->regset] |= reg->x.regnode->mask;
459: return 1;
460: } else {
461: p->sclass = AUTO;
462: return 0;
463: }
464: }
465:
466: /* getunsigned - return value of unsigned integer constant */
467: unsigned getunsigned(p) Symbol p; {
468: switch (ttob(p->type)) {
469: case C: return p->u.c.v.uc;
470: case S: return p->u.c.v.us;
471: default: return p->u.c.v.u;
472: }
473: }
474:
475: /* initfunc - common function initialization */
476: void initfunc(a, b, c) {
477: int i;
478:
479: offset = b;
480: maxoffset = 0;
481: argbuildsize = c;
482: ncalls = a;
483: regvars = 0;
484: for (i = 0; i < nregsets; i++) {
485: usedmask[i] = 0;
486: freemask[i] = -1;
487: }
488: }
489:
490: /* linearize - linearize nodelist p */
491: static void linearize(p, last, next) Node *last, next, p; {
492: for (; p; p = p->link)
493: if (p->x.sideeffect || p->count > 0) {
494: last = lin1(p, last);
495: p->x.listed = 1;
496: }
497: *last = next;
498: }
499:
500: /* lin1 - linearize dag p */
501: static Node *lin1(p, last) Node p, *last; {
502: int i;
503:
504: if (p->x.linearized)
505: return last;
506: for (i = 0; i < MAXKIDS; i++)
507: if (p->kids[i])
508: last = lin1(p->kids[i], last);
509: p->x.linearized = 1;
510: *last = p;
511: debug(rflag, fprint(2, "(listing %x)\n", p));
512: return &p->x.next;
513: }
514:
515: /* lop - p->syms[i] &= mask */
516: int lop(p, i, size) Node p; {
517: unsigned before = getunsigned(p->syms[i]);
518: unsigned after = before&((1<<size) - 1);
519:
520: if (before == after)
521: return 0;
522: else {
523: Value v;
524: v.u = after;
525: p->syms[i] = constant(p->syms[i]->type, v);
526: return 1;
527: }
528: }
529:
530: /* mkactual - make next frame offset */
531: int mkactual(prealign, size, postalign) {
532: int n = roundup(argoffset, prealign);
533: argoffset = roundup(n + size, postalign);
534: return n;
535: }
536:
537: /* mkauto - make next local */
538: int mkauto(p, align) Symbol p; {
539: offset = roundup(offset + p->type->size, align);
540: p->x.offset = -offset;
541: return -offset;
542: }
543:
544: /* mkreg - create register s with given mask, regset, and link */
545: static Symbol mkreg(s, n, mask, regset, regtype, link) char *s; Symbol link; {
546: static struct symbol zs;
547: static struct regnode zr;
548: Symbol q = (Symbol)alloc(sizeof *q);
549:
550: *q = zs;
551: q->x.name = string(s);
552: symeaddr(q) = atoi(s);
553: q->x.regnode = (Regnode)alloc(sizeof *q->x.regnode);
554: *q->x.regnode = zr;
555: q->x.regnode->regnum = n;
556: q->x.regnode->mask = mask;
557: q->x.regnode->link = link;
558: q->x.regnode->regset = regset;
559: q->x.regnode->regtype = regtype;
560: q->x.regnode->next = regs;
561: regs = q;
562: return q;
563: }
564:
565: /* mkregs - create registers lo to hi by inc with given mask and type */
566: Symbol mkregs(fmt, lo, hi, inc, mask, regset, regtype, p) char *fmt; Symbol p; {
567: for (; lo*inc <= hi*inc; lo += inc)
568: p = mkreg(stringf(fmt, lo), lo, mask << lo, regset, regtype, p);
569: return p;
570: }
571:
572: /* mvregvar - move register variable */
573: static void mvregvar(p, mask) Symbol p; unsigned mask; {
574: Symbol reg;
575:
576: if (reg = getreg(rmap[ttob(p->type)], 0, ~mask, -1)) {
577: freereg(p->x.regvar);
578: p->x.regvar = reg;
579: p->x.name = reg->x.name;
580: symeaddr(p) = symeaddr(reg);
581: debug(rflag, dumpregs("(moving register variable %s to %s)\n", p->name, p->x.name));
582: }
583: }
584:
585: /* mvregvars - move register variables to reduce callee saves */
586: void mvregvars() {
587: Symbol p;
588:
589: if (ncalls == 0) {
590: unsigned i, mask[(sizeof usedmask)/(sizeof usedmask[0])];
591: for (i = 0; i < nregsets; i++)
592: mask[i] = usedmask[i] | eemask[i];
593: for (p = regvars; p; p = p->x.nextregvar) {
594: Regnode r = p->x.regvar->x.regnode;
595: mask[r->regset] |= r->mask;
596: }
597: for (p = regvars; p; p = p->x.nextregvar) {
598: Regnode r = p->x.regvar->x.regnode;
599: if (r->mask&eemask[r->regset])
600: mvregvar(p, mask[r->regset]);
601: }
602: }
603: freeregvars();
604: }
605:
606: /* ntob - infer type suffix from register set for register p */
607: static int ntob(p) Symbol p; {
608: Regnode r = getregnode(p);
609: assert(r->regtype);
610: return r->regtype;
611: }
612:
613: /* overlaps - do registers x and y overlap? */
614: static int overlaps(x, y) Symbol x, y; {
615: Regnode rx = getregnode(x), ry = getregnode(y);
616: return rx->regset == ry->regset && rx->mask&ry->mask;
617: }
618:
619: /* parseflags - parse back end flags */
620: void parseflags(argc, argv) char *argv[]; {
621: for (++argv; --argc > 0; ++argv)
622: if (strcmp(*argv, "-d") == 0)
623: dflag++;
624: else if (strcmp(*argv, "-p") == 0 || strcmp(*argv, "-pg") == 0)
625: pflag++;
626: else if (strcmp(*argv, "-r") == 0)
627: rflag++;
628: else if (strcmp(*argv, "-k") == 0)
629: kflag++;
630: }
631:
632: void progend() {}
633:
634: /* ralloc - assign registers for p */
635: static void ralloc(p) Node p; {
636: Symbol s;
637: int i, n;
638:
639: assert(p && p->x.registered == 0);
640: n = IR->x.twoop && p->x.zap0 ? 1 : MAXKIDS;
641: for (i = 0; i < n; i++)
642: if (p->kids[i]) {
643: assert(p->kids[i]->x.registered);
644: s = p->kids[i]->syms[RX];
645: if (s == 0) {
646: debug(rflag, fprint(2, "(%x->kids[%d]=%x has no register allocated)\n", p, i, p->kids[i]));
647: assert(s);
648: }
649: if (s->x.regnode && s->x.regnode->count >= 0 && --s->x.regnode->count == 0)
650: freereg(s);
651: }
652: s = p->syms[RX];
653: if (s && s->x.regnode) {
654: p->syms[RX] = getreg(s, p, tmask[s->x.regnode->regset], p->count);
655: usedmask[p->syms[RX]->x.regnode->regset] |= p->syms[RX]->x.regnode->mask;
656: debug(rflag, dumpregs("(allocating %s to node %x)\n", p->syms[RX]->x.name, (char *) p));
657: }
658: for (i = n; i < MAXKIDS; i++)
659: if (p->kids[i]) {
660: assert(p->kids[i]->x.registered);
661: s = p->kids[i]->syms[RX];
662: assert(s);
663: if (s->x.regnode && s->x.regnode->count >= 0 && --s->x.regnode->count == 0)
664: freereg(s);
665: }
666: p->x.registered = 1;
667: (*IR->x.final)(p);
668: }
669:
670: /* range - does signed k fit in n bits? */
671: int range(k, n) {
672: return k >= -(1<<(n - 1)) && k < (1<<(n - 1));
673: }
674:
675: /* regchain - does this binary instruction overwrite its left operand? */
676: regchain(a) Node a; {
677: return a->kids[0] == 0 || a->kids[0]->syms[RX] == a->syms[RX];
678: }
679:
680: /* regloc - return "id" for p's register */
681: unsigned regloc(p) Symbol p; {
682: assert(p && p->sclass == REGISTER && p->x.regvar && p->x.regvar->x.regnode);
683: return p->x.regvar->x.regnode->regset<<8 | p->x.regvar->x.regnode->regnum;
684: }
685:
686: /* rmcopy - remove the register-to-register copy in node a? */
687: int rmcopy(a) Node a; {
688: return !isregvar(a->syms[RX]) && !a->x.unavailable;
689: }
690:
691: /* rmember - is regnode r in register class s? */
692: static int rmember(r, s) Regnode r; Symbol s; {
693: assert(r && s->x.regnode);
694: for (; s; s = s->x.regnode->link)
695: if (r->regset == s->x.regnode->regset && r->mask == s->x.regnode->mask)
696: return 1;
697: return 0;
698: }
699:
700: /* rtarget - evaluate p->kids[n] into register r */
701: void rtarget(p, n, r) Node p; Symbol r; {
702: Node q;
703: Regnode regnode;
704: Symbol s;
705:
706: assert(p && r);
707: q = p->kids[n];
708: assert(q && r);
709: regnode = getregnode(r);
710: assert(r->x.regvar || regnode->link == 0);
711: s = q->syms[RX];
712: assert(s);
713: if (!isregvar(s) && rmember(regnode, s)) {
714: debug(rflag, fprint(2, "(targeting %x to %s)\n", q, r->x.name));
715: q->syms[RX] = q->x.rtarget = r;
716: } else {
717: debug(rflag, fprint(2, "(moving %x to %s)\n", q, r->x.name));
718: q->count--;
719: p->kids[n] = q = newnode(LOAD + ntob(q->syms[RX]), q, 0, q->syms[0]?q->syms[0]:p->syms[0]);
720: q->count++;
721: q->syms[RX] = q->x.rtarget = r;
722: (*IR->x.rewrite)(q);
723: }
724: }
725:
726: /* setseg - switch to logical segment n (1..5) */
727: void setseg(n) {
728: assert(n >= 0 && n < sizeof IR->x.segnames/sizeof IR->x.segnames[0]);
729: cseg = n;
730: if (IR->x.segnames[n-1])
731: print("%s\n", IR->x.segnames[n-1]);
732: }
733:
734: /* spacen - allocate n bytes of space in the current segment */
735: void spacen(n, prefix) char *prefix; {
736: if (cseg != BSS)
737: print("%s ", prefix);
738: print("%d\n", n);
739: }
740:
741: /* spill - spill all busy registers in regset n that overlap mask */
742: void spill(mask, n, dot) unsigned mask; Node dot; {
743: Symbol r;
744:
745: if (mask&~freemask[n])
746: for (r = regs; r; r = r->x.regnode->next)
747: if (n == r->x.regnode->regset && mask&r->x.regnode->mask && r->x.regnode->count)
748: spillr(r, dot);
749: usedmask[n] |= mask;
750: }
751:
752: /* spillee - identify most-distantly-used register in register class r */
753: static Symbol spillee(r, dot, rmask) Node dot; Symbol r; unsigned rmask; {
754: int bestdist = -1;
755: Symbol bestreg = 0;
756:
757: for (; r; r = r->x.regnode->link)
758: if ((r->x.regnode->mask&~rmask) == 0 && r->x.regnode->count >= 0) {
759: Node q;
760: int dist = 0;
761: for (q = dot; q && !uses(q, r); q = q->x.next)
762: dist++;
763: if (q && dist > bestdist) { /* no local use => reg vbl */
764: bestdist = dist;
765: bestreg = r;
766: }
767: }
768: assert(bestreg);
769: return bestreg;
770: }
771:
772: /* spillr - spill register r */
773: static void spillr(r, dot) Symbol r; Node dot; {
774: int ty = ntob(r);
775: if (r->x.regnode->count < 0) {
776: Node p = newnode(LOAD+ty,
777: newnode(INDIR+ty,
778: newnode(ADDRL+P, 0, 0,
779: genspill(r, ty, findxnext(dot))), 0, 0), 0, 0);
780: p->syms[RX] = r;
781: p->x.sideeffect = 1;
782: (*IR->x.rewrite)(p);
783: linearize(p, &dot->x.next, dot->x.next);
784: p->x.registered = 1;
785: } else if (dot->x.registered && r == dot->syms[RX]) {
786: /* dot can't have set it yet, so no spill is needed */
787: } else {
788: genreloads(dot, genspill(r, ty, &r->x.regnode->node->x.next), ty, r);
789: freereg(r);
790: }
791: }
792:
793: /* uses - does node p read register r? */
794: static int uses(p, r) Node p; Symbol r; {
795: int i;
796:
797: for (i = 0; i < MAXKIDS; i++)
798: if (
799: p->kids[i] &&
800: p->kids[i]->x.registered &&
801: overlaps(r, p->kids[i]->syms[RX])
802: )
803: return 1;
804: return 0;
805: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.