![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gencode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to gencode.c CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 root 1: #include "gencode.h"
2: #define fieldbotch(p) if(p->left->op == Fld) {rewritefld(p); longjmp(back, 1);}
3: jmp_buf back;
4: int acnt, Pflag, bbcnt;
5: NODE *svq; /* just for printing at FAIL */
6:
7: gencode(p)
8: NODE *p;
9: { mnod *q;
10: ret s;
11: int svtemp, svregvar, i, svbb;
12: extern int bothdebug;
13: svtemp = tmpoff;
14: svregvar = regvar;
15: svbb = ++bbcnt;
16: svq = p;
17: if(setjmp(back)) {
18: pr("#\treg\t%d\n", ++acnt) /*,prtree(q), putchar('\n')*/;
19: if(acnt > 20) {
20: prtree(q);
21: outpr();
22: tmpoff = svtemp;
23: bbcnt = svbb;
24: uerror("expression too complicated");
25: return;
26: }
27: }
28: else
29: q = copytree(p);
30: buf = bufs[1];
31: prptr = prbuf;
32: if(Pflag && q->op != Init) {
33: pr("#\tincl\tlocprof+%d\n", 4*(svbb+3));
34: }
35: s = doit(q, 0, 0, REGMASK);
36: if(s.flag & FAIL)
37: uerror("codegen failed at top level");
38: acnt = ntree = 0;
39: if(Pflag && q->op != Init)
40: printx("#%d ", svbb), prtree(q), printx("\n");
41: outpr();
42: tmpoff = svtemp;
43: regvar = svregvar;
44: }
45:
46: ret
47: doit(p, flag, dest, regmask)
48: mnod *p;
49: ret dest;
50: { ret s, t, x, y;
51: char *pp;
52: mnod snode, *q;
53: int i, j, svmask = regmask;
54: switch(p->op) {
55: default:
56: pr("#\tweird??? %d\n", p->op);
57: return(dest);
58: case Andeq:
59: fieldbotch(p)
60: if(dest.ans && p->left->op == Star)
61: longjmp(back, mediumstar(p));
62: flag |= DESTISLEFT;
63: flag &= ~CC;
64: case And:
65: if((flag & CC)) { /* short b; reg int *c; if(b & *c++); */
66: if(p->left->op == Conv && incrsize(p->left->left) < 4)
67: p->left = p->left->left;
68: if(p->right->op == Conv
69: && incrsize(p->right->left) < 4)
70: p->right = p->right->left;
71: }
72: t = doit(p->left, VALUE|USED, 0, regmask);
73: if(t.flag & FAIL)
74: return(t);
75: regmask &= ~t.regmask;
76: s = doit(p->right, VALUE|USED, 0, regmask);
77: if(s.flag & FAIL)
78: goto binfail;
79: if(flag & CC) {
80: if(incrsize(p->left) == incrsize(p->right))
81: i = type(p->right);
82: else if(incrsize(p->left) < incrsize(p->right)) {
83: if(s.flag & INDEX) {
84: totemp(p, RIGHT);
85: longjmp(back, 1);
86: }
87: i = childtype(p);
88: }
89: else {
90: if(t.flag & INDEX) {
91: totemp(p, LEFT);
92: longjmp(back, 1);
93: }
94: i = type(p->right);
95: }
96: pr("#\tbit%c\t%s,%s\n", i, str(s), str(t));
97: dest.ans = 0;
98: dest.flag = CC;
99: dest.regmask = 0;
100: return(dest);
101: }
102: regmask &= ~s.regmask;
103: /* p->right->op == Compl is a useful special case */
104: if((flag & DESTISLEFT) && dest.ans == 0)
105: dest = x = t;
106: if(dest.ans == 0)
107: if(s.flag & SCRATCH)
108: dest = x = s;
109: else if(t.flag & SCRATCH) {
110: dest = t;
111: x = allocreg(p, regmask);
112: }
113: else
114: dest = x = allocreg(p, regmask);
115: else
116: x = allocreg(p, regmask);
117: if(p->right->op == Icon) {
118: x = tostack(); /* to get a buf */
119: sprintx(str(x), "$%d", -p->right->lval - 1);
120: }
121: else
122: pr("#\tmcom%c\t%s,%s\n", childtype(p), str(s), str(x));
123: if(strcmp(str(t), str(dest)) == 0)
124: pr("#\tbic%c2\t%s,%s\n", childtype(p), str(x), str(dest));
125: else if(flag & DESTISLEFT) {
126: pr("#\tbic%c2\t%s,%s\n", childtype(p), str(x), str(t));
127: if(strcmp(str(t), str(dest))) {
128: x = t;
129: goto movexdest;
130: }
131: }
132: else
133: pr("#\tbic%c3\t%s,%s,%s\n", childtype(p), str(x),
134: str(t), str(dest));
135: if(flag & ASADDR)
136: goto toaddr;
137: dest.flag |= CC;
138: return(dest);
139: case Call:
140: call:
141: s.flag = funargs(p->right, regmask);
142: if(s.flag & FAIL)
143: return(s);
144: i = p->argsize/32;
145: if(i > 255)
146: uerror("%d arguments is too many", i);
147: called:
148: s = doit(p->left, VALUE|ASADDR|USED, 0, regmask);
149: pp = str(s);
150: aftercall:
151: if(svmask != REGMASK) {
152: debugpr("#FAIL aftercall ");
153: s.flag = FAIL;
154: return(s);
155: }
156: x = specialreg(p, regmask);
157: pr("#\tcalls\t$%d,%s\n", i, pp);
158: if(flag & ASADDR) {
159: strcat(str(x), ")");
160: strshift(str(x), 1);
161: str(x)[0] = '(';
162: }
163: if(dest.ans == 0)
164: if(flag & DESTISLEFT)
165: dest = doit(p->left->op == Conv?
166: p->left->left:
167: p->left, 0/* ? */, 0, regmask & ~x.regmask);
168: else
169: return(x);
170: movexdest: /* type(p), not childtype, for a = a % b */
171: if(strcmp(str(x), str(dest)) == 0)
172: return(x);
173: if((flag & TOSTACK) && incrsize(p) == 4)
174: pr("#\tpush%c\t%s\n", type(p), str(x));
175: else if(x.flag & ICON0)
176: pr("#\tclr%c\t%s\n", type(p), str(dest));
177: else if(isfloat(p) != isfloat(p->left)
178: && p->op != Call && p->op != Ucall)
179: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p), str(x), str(dest));
180: else if((flag & TOSTACK) && (incrsize(p) != 8))
181: pr("#\tcvt%cl\t%s,-(sp)\n", type(p), str(x));
182: else {
183: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest));
184: dest = simpler(x, dest);
185: }
186: dest.flag |= CC;
187: return(dest);
188: case Cmp:
189: if(p->left->op == Conv && p->right->op == Conv
190: && childtype(p->left) == childtype(p->right)
191: && !isfloat(p->left->left)) { /* bogus? */
192: p->left = p->left->left;
193: p->right = p->right->left;
194: }
195: else if(p->left->op == Conv && p->right->op == Icon
196: && p->right->lval >= 0
197: && ((incrsize(p->left->left) == 1
198: && p->right->lval < 128)
199: || (incrsize(p->left->left) == 2
200: && p->right->lval < 32768)))
201: p->left = p->left->left;
202: /* the above rewriting depends on childype being of p->left */
203: s = doit(p->left, VALUE|USED, 0, regmask);
204: if(s.flag & FAIL)
205: return(s);
206: regmask &= ~s.regmask;
207: t = doit(p->right, VALUE|USED, 0, regmask);
208: if(t.flag & FAIL) {
209: t = doit(p->right, VALUE|USED, 0, REGMASK);
210: if(!(t.flag & FAIL) && svmask != REGMASK)
211: return(t.flag = FAIL, t);
212: totemp(p, LEFT);
213: longjmp(back, 1);
214: }
215: pr("#\tcmp%c\t%s,%s\n", childtype(p), str(s), str(t));
216: dest.ans = dest.regmask = 0;
217: dest.flag = CC;
218: return(dest);
219: case Comop: /* qnodes lurking underneath */
220: if(p->left->op == Genlab && hasqnode(p->right)) {
221: if(dest.ans == 0) {
222: dest = allocreg(p, regmask);
223: }
224: t = doit(p->left, VALUE|(flag & CC), dest, regmask);
225: }
226: else
227: t = doit(p->left, 0, 0, regmask);
228: if(t.flag & FAIL)
229: return(t);
230: s = doit(p->right, VALUE|(flag & (USED|CC)), dest, regmask);
231: if(s.flag & FAIL)
232: return(s);
233: if(flag & ASADDR) {
234: dest.ans = 0;
235: i = (s.flag & (ISREG|CANINDIR|SCRATCH));
236: j = s.regmask;
237: buf = str(s);
238: goto convbuf;
239: }
240: return(s);
241: case Compl:
242: s = doit(p->left, VALUE|USED, 0, regmask);
243: if(s.flag & FAIL)
244: return(s);
245: if(dest.ans == 0)
246: if(s.flag & SCRATCH)
247: dest = s;
248: else
249: dest = allocreg(p, regmask & ~s.regmask);
250: pr("#\tmcom%c\t%s,%s\n", childtype(p), str(s), str(dest));
251: dest.flag |= CC;
252: return(dest);
253: case Conv:
254: if(p->left->op == Asg && p->left->left->op == Star) {
255: if(dest.ans == 0) {
256: dest = allocreg(p, regmask);
257: s = doit(p->left, VALUE|USED, dest, regmask);
258: }
259: else {
260: x = allocreg(p, regmask);
261: s = doit(p->left, VALUE|USED, x, regmask & ~x.regmask);
262: }
263: if(s.flag & FAIL) {
264: asgwrite(p->left);
265: longjmp(back, 1);
266: }
267: }
268: else
269: s = doit(p->left, VALUE|USED, 0, regmask);
270: if(childtype(p) == type(p) && dest.ans == 0)
271: return(s);
272: if(s.flag & FAIL)
273: return(s);
274: if(dest.ans == 0)
275: if(s.flag & SCRATCH)
276: dest = checksize(p, s, regmask);
277: else
278: dest = allocreg(p, regmask);
279: if(isunsigned(p->left) && incrsize(p) > incrsize(p->left)) {
280: if(type(p) != 'f' && type(p) != 'd')
281: pp = "movz";
282: else { /* uns to float or double */
283: rewriteconv(p);
284: longjmp(back, 1);
285: }
286: }
287: else
288: pp = "cvt";
289: if(isfloat(p) != isfloat(p->left))
290: goto cvtop;
291: if(incrsize(p) < incrsize(p->left)) {
292: if(isfloat(p))
293: goto cvtop;
294: pr("#\tmov%c\t%s,%s\n", type(p), str(s), str(dest));
295: dest = simpler(s, dest);
296: }
297: else if(incrsize(p) > incrsize(p->left))
298: cvtop:
299: pr("#\t%s%c%c\t%s,%s\n", pp, childtype(p), type(p), str(s), str(dest));
300: else { /* types were the same, but dest.ans != 0 */
301: pr("#\tmov%c\t%s,%s\n", type(p), str(s), str(dest));
302: dest = simpler(s, dest);
303: }
304: dest.flag |= CC;
305: return(dest);
306: case Decr:
307: i = -1;
308: pp = "sub";
309: incrop:
310: if(p->type == Tfloat)
311: uerror("no float ++/--");
312: fieldbotch(p)
313: /* if the dest uses regs, it may be from a qnode, so that reg
314: * shouldn't be used (i?*a->b++:x()) where b has offset > 0
315: */
316: s = doit(p->left, USED, 0, dest.ans? regmask & ~dest.regmask: regmask);
317: if(s.flag & FAIL)
318: return(s);
319: t = doit(p->right, 0, 0, 0);
320: if(flag & VALUE) {
321: if(dest.ans == 0)
322: dest = allocreg(p, regmask & ~s.regmask);
323: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(dest));
324: if(t.flag & ICON1) {
325: if(i == 1)
326: pp = "inc";
327: else
328: pp = "dec";
329: pr("#\t%s%c\t%s\n", pp, childtype(p), str(s));
330: }
331: else
332: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p),
333: str(t), str(s));
334: toaddr:
335: if(flag & ASADDR) {
336: if(dest.flag & ISREG) {
337: sprintx(buf, "(%s)", str(dest));
338: done(dest, CANINDIR, dest.regmask);
339: }
340: if(dest.flag & CANINDIR) {
341: sprintx(buf, "*%s", str(dest));
342: done(dest, 0, dest.regmask);
343: }
344: uerror("weird asaddr in incrop");
345: }
346: dest.flag &= ~CC;
347: return(dest);
348: }
349: if(t.flag & ICON1) {
350: if(i == 1)
351: pp = "inc";
352: else
353: pp = "dec";
354: pr("#\t%s%c\t%s\n", pp, childtype(p), str(s));
355: }
356: else
357: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), str(t), str(s));
358: if(dest.ans) {
359: x = s;
360: goto movexdest;
361: }
362: s.flag &= ~CC;
363: return(s);
364: case Diveq:
365: fieldbotch(p)
366: if(rewriteasgop(p))
367: goto assign;
368: flag |= DESTISLEFT;
369: case Div:
370: /* trees wrong: uns/=int and int/=uns */
371: if(!isunsigned(p->right) && !isunsigned(p->left)) {
372: pp = "div";
373: goto binop;
374: }
375: pp = "udiv";
376: unsdiv:
377: /* *p++ /= uns is hard */
378: if(p->left->op == Star && fixuns(p))
379: longjmp(back, 1); /* *A op= B => (T=A, *T op= B) */
380: if(incrsize(p->right) != 4) {
381: snode.op = Conv;
382: snode.left = p->right;
383: snode.type = Tulong;
384: s = doit(&snode, VALUE|TOSTACK, tostack(), regmask);
385: }
386: else
387: s = doit(p->right, TOSTACK, tostack(), regmask);
388: if(s.flag & FAIL)
389: return(s);
390: regmask &= ~s.regmask;
391: if(incrsize(p->left) != 4) {
392: snode.op = Conv;
393: snode.left = p->left;
394: snode.type = Tulong;
395: t = doit(&snode, VALUE|TOSTACK, tostack(), regmask);
396: }
397: else
398: t = doit(p->left, VALUE|TOSTACK, tostack(), regmask);
399: if(t.flag & FAIL) {
400: if(dest.ans || svmask != REGMASK) {
401: t = doit(p->left, VALUE|TOSTACK, tostack(), svmask);
402: if(t.flag & FAIL)
403: return(t);
404: }
405: totemp(p, RIGHT);
406: longjmp(back, 1);
407: }
408: i = 2;
409: goto aftercall;
410: case Xoreq:
411: fieldbotch(p)
412: flag |= DESTISLEFT;
413: case Xor:
414: pp = "xor";
415: binop:
416: if((flag & DESTISLEFT) && dest.ans && p->left->op == Star)
417: longjmp(back, mediumstar(p));
418: t = doit(p->left, VALUE|USED, 0, regmask);
419: if(t.flag & FAIL) {
420: return(t);
421: }
422: regmask &= ~t.regmask;
423: s = doit(p->right, VALUE|USED, 0, regmask);
424: if(s.flag & FAIL) {
425: binfail:
426: if(dest.ans || svmask != REGMASK) {
427: s = doit(p->right, VALUE|USED, 0, svmask);
428: if(s.flag & FAIL)
429: return(s);
430: }
431: /* *foo op= expr requires care */
432: if((flag & DESTISLEFT) && p->left->op == Star)
433: totemp(p->left, LEFT);
434: else
435: totemp(p, LEFT);
436: longjmp(back, 1);
437: }
438: if(type(p) != childtype(p)) {
439: x = allocreg(p, regmask);
440: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), str(s),
441: str(t), str(x));
442: if(dest.ans == 0)
443: if(flag & DESTISLEFT)
444: dest = t;
445: else
446: dest = x;
447: if(!isfloat(p) && !isfloat(p->left)
448: && incrsize(p) < incrsize(p->left)) {
449: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest));
450: dest = simpler(x, dest);
451: }
452: else
453: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p),
454: str(x), str(dest));
455: dest.flag |= CC;
456: return(dest);
457: }
458: if(dest.ans == 0)
459: if((t.flag & SCRATCH) || (flag & DESTISLEFT)) {
460: twoop:
461: dest = t;
462: if(*pp == 'a' && (s.flag & ICON1))
463: pr("#\tinc%c\t%s\n", childtype(p), str(t));
464: else if(*pp == 's' && (s.flag & ICON1))
465: pr("#\tdec%c\t%s\n", childtype(p), str(t));
466: else
467: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p),
468: str(s), str(t));
469: if(flag & ASADDR)
470: goto binopaddr;
471: if(flag & TOSTACK)
472: pr("#\tpush%c\t%s\n", type(p), str(t));
473: dest.flag |= CC;
474: return(dest);
475: }
476: else if(s.flag & SCRATCH)
477: dest = s;
478: else
479: dest = allocreg(p, regmask);
480: if(dest.ans && (flag & DESTISLEFT)) {
481: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), str(s), str(t));
482: x = t;
483: goto movexdest;
484: }
485: if(commutes(p->op) && strcmp(str(s), str(dest)) == 0) {
486: dest = s;
487: s = t;
488: t = dest;
489: goto twoop;
490: }
491: if(strcmp(str(t), str(dest)) == 0)
492: goto twoop;
493:
494: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), str(s), str(t), str(dest));
495: binopaddr:
496: if(flag & ASADDR) {
497: if(dest.flag & ISREG) {
498: strcat(str(dest), ")");
499: strshift(str(dest), 1);
500: str(dest)[0] = '(';
501: return(dest);
502: }
503: if(dest.flag & CANINDIR) {
504: strshift(str(dest), 1);
505: str(dest)[0] = '*';
506: dest.flag &= ~CANINDIR;
507: return(dest);
508: }
509: debugpr("#FAIL doubtful ");
510: dest.flag = FAIL; /* doubtful */
511: return(dest);
512: }
513: dest.flag |= CC;
514: return(dest);
515: case Fld:
516: /* this is rvalues */
517: s = doit(p->left, USED, 0, regmask);
518: if(s.flag & FAIL)
519: return(s);
520: if(dest.ans == 0)
521: dest = allocreg(p, regmask);
522: if((s.flag & INDEX) && p->left->op == Star
523: && incrsize(p->left) != 1) {
524: /* over-enthusiastic use of index mode */
525: if(dest.flag & SCRATCH)
526: x = dest;
527: else
528: x = allocreg(p, regmask);
529: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(x));
530: s = x;
531: }
532: pr("#\text%sv\t$%d,$%d,%s,%s\n", isunsigned(p->left)? "z": "",
533: p->rval/64, p->rval%64, str(s), str(dest));
534: dest.flag |= CC;
535: return(dest);
536: case Genbr:
537: if(p->left->op == Conv)
538: s = doit(p->left->left, CC|VALUE|USED, 0, regmask);
539: /*else if(p->left->op == And && pow2(p->left->right->lval) > 0) {
540: s = doit(p->left->left, CC|VALUE, 0, regmask);
541: pp = genjbc(p->lop);
542: pr("#\t%s\t$%d,%s,L%d\n", pp, pow2(p->left->right->lval),
543: str(s), p->label);
544: goto genbr0;
545: } not a win on 8550 */
546: else
547: s = doit(p->left, CC|VALUE|USED, 0, regmask);
548: pp = genjmp(p->lop);
549: if(s.flag & CC)
550: if(p->left->op != Conv || p->left->type >= Tint)
551: pr("#\t%s\t", pp);
552: else
553: pr("#\ttst%c\t%s\n\t%s\t", childtype(p),
554: str(s), pp);
555: else if(p->left->op == Conv)
556: pr("#\ttst%c\t%s\n#\t%s\t", childtype(p->left), str(s), pp);
557: else
558: pr("#\ttst%c\t%s\n#\t%s\t", childtype(p), str(s), pp);
559: pr("L%d\n", p->label);
560: genbr0:
561: s.flag |= CC; /* ?? */
562: if(Pflag) {
563: ++bbcnt;
564: pr("#\tincl\tlocprof+%d\n", 4*(bbcnt+3));
565: }
566: return(s);
567: case Genlab:
568: s = doit(p->left, flag, dest, regmask);
569: pr("#L%d:\n", p->label);
570: if(Pflag) {
571: ++bbcnt;
572: pr("#\tincl\tlocprof+%d\n", 4*(bbcnt+3));
573: }
574: return(s);
575: case Genubr:
576: s = doit(p->left, flag & CC, dest, regmask);
577: if((flag & CC) && !(s.flag & CC))
578: pr("#\ttst%c\t%s\n", childtype(p), str(s));
579: pr("#\tjbr\tL%d\n", p->label);
580: return(s);
581: case Icon:
582: if(p->name)
583: if(p->lval)
584: sprintx(buf, "%s+%d", p->name, p->lval);
585: else
586: sprintx(buf, "%s", p->name);
587: else
588: sprintx(buf, "%d", p->lval);
589: if(!(flag & ASADDR)) {
590: strshift(buf, 1);;
591: buf[0] = '$';
592: }
593: i = 0;
594: if(p->name == 0)
595: if(p->lval == 0)
596: i = ICON0;
597: else if(p->lval == 1)
598: i = ICON1;
599: j = 0;
600: convbuf: /* the cookie is in buf */
601: if(dest.ans == 0 && !(flag & TOSTACK)) {
602: if(p->op == Icon || !(flag & ASADDR)) {
603: done(s, i, j);
604: }
605: if(i & CANINDIR) {
606: strshift(buf, 1);
607: buf[0] = '*';
608: done(s, i & ~CANINDIR, j);
609: }
610: if(i & ISREG) {
611: strcat(buf, ")");
612: strshift(buf, 1);
613: buf[0] = '(';
614: done(s, i, j);
615: }
616: pp = buf;
617: buf += BUF;
618: s = allocreg(p, regmask);
619: pr("#\tmov%c\t%s,%s\n", type(p), pp, str(s));
620: flag &= ~ASADDR;
621: goto inreg;
622: }
623: if(flag & TOSTACK)
624: if(incrsize(p) == 4)
625: pr("#\tpushl\t%s\n", buf);
626: else if(incrsize(p) == 8)
627: pr("#\tmovd\t%s,%s\n", buf, str(dest));
628: else
629: pr("#\tcvt%cl\t%s,%s\n", type(p), buf, str(dest));
630: else if(i & ICON0)
631: pr("#\tclr%c\t%s\n", type(p), str(dest));
632: else {
633: pr("#\tmov%c\t%s,%s\n", type(p), buf, str(dest));
634: if(!(dest.flag & INDEX) || !index(str(dest), '+')
635: && !index(str(dest), '-'))
636: ;
637: else if(!(i & INDEX) || !index(buf, '+')
638: && !index(buf, '-')) {
639: done(s, (i|CC), j);
640: }
641: else
642: dest.flag |= USED;
643: }
644: dest.flag |= CC;
645: return(dest);
646: case Incr:
647: i = 1;
648: pp = "add";
649: goto incrop;
650: case Init: /* knows it is ICON */
651: s = doit(p->left, ASADDR, 0, 0);
652: pr("#\t.long\t%s\n", str(s));
653: return(dest);
654: case Lseq:
655: if(incrsize(p) != 4)
656: lsconv(p);
657: if(rewriteasgop(p))
658: goto assign;
659: fieldbotch(p)
660: flag |= DESTISLEFT;
661: if(dest.ans && p->left->op == Star)
662: longjmp(back, mediumstar(p));
663: case Ls: /* stupid vax */
664: if(incrsize(p) != 4)
665: lsconv(p);
666: s = doit(p->left, VALUE|USED, 0, regmask);
667: if(s.flag & FAIL)
668: return(s);
669: regmask &= ~s.regmask;
670: t = doit(p->right, VALUE|USED, 0, regmask);
671: if(t.flag & FAIL)
672: goto binfail;
673: if((t.flag & INDEX) && p->right->op == Star
674: && incrsize(p->right) != 1) {
675: /* over-enthusiastic use of index mode */
676: if(dest.flag & SCRATCH)
677: x = dest;
678: else
679: x = allocreg(p, regmask);
680: pr("#\tmov%c\t%s,%s\n", childtype(p), str(t), str(x));
681: t = x;
682: }
683: if(dest.ans == 0)
684: if((s.flag & SCRATCH) || (flag & DESTISLEFT))
685: dest = s;
686: else
687: dest = allocreg(p, regmask);
688: if(incrsize(p) != 4) { /* stupid vax */
689: x = allocreg(p, regmask);
690: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(x));
691: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest));
692: if(flag & DESTISLEFT)
693: pr("#\tmovl\t%s,%s\n", str(x), str(s));
694: dest.flag |= CC;
695: return(dest);
696: }
697: if(p->right->op == Icon && (i = p->right->lval) <= 4
698: && (dest.flag & ISREG) && !(s.flag&AUTO)) {
699: if(strcmp(str(s), str(dest))) {
700: i--;
701: pr("#\taddl3\t%s,%s,%s\n", str(s), str(s), str(dest));
702: }
703: while(i-- > 0)
704: pr("#\taddl2\t%s,%s\n", str(dest), str(dest));
705: }
706: else if(flag & DESTISLEFT)
707: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(s));
708: else
709: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(dest));
710: if((flag & DESTISLEFT) && strcmp(str(dest), str(s)))
711: pr("#\tmovl\t%s,%s\n", str(s), str(dest));
712: dest.flag |= CC;
713: return(dest);
714: case Minuseq:
715: fieldbotch(p)
716: if(rewriteasgop(p))
717: goto assign;
718: flag |= DESTISLEFT;
719: case Minus:
720: pp = "sub";
721: /* you won't believe this: type x[], *y where type is shorter than
722: * int, generates subx $_x,y which the assembler barfs on.
723: * instead, generate crummy code (stupid assembler)
724: */
725: if(incrsize(p) < 4) {
726: if(p->left->op == Icon && p->left->name) {
727: p->left->type = Tint;
728: totemp(p, LEFT);
729: }
730: if(p->right->op == Icon && p->right->name) {
731: p->right->type = Tint;
732: totemp(p, RIGHT);
733: }
734: }
735: goto binop;
736: case Modeq:
737: fieldbotch(p)
738: if(rewriteasgop(p))
739: goto assign;
740: if(dest.ans && p->left->op == Star)
741: longjmp(back, mediumstar(p));
742: flag |= DESTISLEFT;
743: case Mod:
744: if(isunsigned(p->right) || isunsigned(p->left)) {
745: pp = "urem";
746: goto unsdiv;
747: }
748: s = doit(p->left, VALUE|USED, 0, regmask);
749: if(s.flag & FAIL)
750: return(s);
751: regmask &= ~s.regmask;
752: t = doit(p->right, VALUE|USED, 0, regmask);
753: if(t.flag & FAIL)
754: goto binfail;
755: regmask &= ~t.regmask;
756: x = allocreg(p, regmask);
757: pr("#\tdiv%c3\t%s,%s,%s\n", childtype(p), str(t), str(s), str(x));
758: pr("#\tmul%c2\t%s,%s\n", childtype(p), str(t), str(x));
759: pr("#\tsub%c3\t%s,%s,%s\n", childtype(p), str(x), str(s), str(x));
760: if(dest.ans)
761: goto movexdest;
762: if(flag & DESTISLEFT) {
763: dest = s;
764: goto movexdest;
765: }
766: x.flag |= CC;
767: return(x);
768: case Muleq:
769: fieldbotch(p)
770: if(rewriteasgop(p))
771: goto assign;
772: flag |= DESTISLEFT;
773: case Mul:
774: pp = "mul";
775: goto binop;
776: case Name: /* ASADDR? */
777: if(p->lval && p->name)
778: sprintx(buf, "%s+%d", p->name, p->lval);
779: else if(p->name)
780: sprintx(buf, "%s", p->name);
781: else if(p->lval)
782: sprintf(buf, "%d", p->lval);
783: else
784: sprintx(buf, "0");
785: j = 0;
786: i = CANINDIR;
787: goto convbuf;
788: case Oreq:
789: fieldbotch(p)
790: flag |= DESTISLEFT;
791: case Or:
792: pp = "bis";
793: goto binop;
794: case Pluseq:
795: fieldbotch(p)
796: if(rewriteasgop(p))
797: goto assign;
798: flag |= DESTISLEFT;
799: case Plus:
800: pp = "add";
801: goto binop;
802: case Reg:
803: sprintx(buf, "%s", regnames[p->rval]);
804: j = 0;
805: i = ISREG;
806: if(p->lval == 1)
807: i |= SCRATCH;
808: goto convbuf;
809: case Rnode: case Snode:
810: x = specialreg(p, 3);
811: x.regmask = 0;
812: if(dest.ans)
813: goto movexdest;
814: return(x);
815: case Qnode:
816: return(specialreg(p, regmask));
817: case Rseq:
818: fieldbotch(p)
819: if(incrsize(p) != 4)
820: lsconv(p);
821: if(rewriteasgop(p))
822: goto assign;
823: flag |= DESTISLEFT;
824: case Rs: /* all right shifts are unsigned */
825: if(incrsize(p->left) != 4) /* shifting funny objects */
826: lsconv(p);
827: s = doit(p->left, VALUE|USED, 0, regmask);
828: if(s.flag & FAIL)
829: return(s);
830: if(p->left->op == Icon ||
831: (s.flag & INDEX) && p->left->op == Star
832: && incrsize(p->left) != 1 ||
833: (s.flag & AUTO) && incrsize(p->left) != 1) {
834: /* over-enthusiastic use of index mode */
835: /* 12 >> i generates a byte immediate */
836: if((s.flag & INDEX) && (flag & DESTISLEFT)) {/* *a++ >>= 1 */
837: lsconv(p); /* not best */
838: longjmp(back, 1);
839: }
840: if((flag & DESTISLEFT) && dest.ans == 0) {
841: dest = s;
842: regmask &= ~s.regmask;
843: }
844: if(dest.flag & SCRATCH)
845: x = dest;
846: else
847: x = allocreg(p, regmask);
848: pr("#\tmovl\t%s,%s\n", str(s), str(x));
849: s = x;
850: }
851: regmask &= ~s.regmask;
852: if(dest.ans == 0)
853: if((flag & DESTISLEFT) || (s.flag & SCRATCH))
854: dest = s;
855: else
856: dest = allocreg(p, regmask);
857: dest.flag |= CC;
858: regmask &= ~dest.regmask;
859: if(incrsize(p) != 4)
860: x = allocreg(p, regmask);
861: else if(flag & DESTISLEFT)
862: x = s;
863: else
864: x = dest;
865: if(p->right->op == Icon && (i = p->right->lval) >= 0) {
866: pr("#\textzv\t$%d,$%d,%s,%s\n", i, 32 - i, str(s), str(x));
867: goto movexdest;
868: }
869: t = doit(p->right, VALUE|USED, 0, regmask);
870: if(t.flag & FAIL)
871: goto binfail;
872: y = allocreg(p, regmask & ~t.regmask);
873: pr("#\tsubl3\t%s,$32,%s\n", str(t), str(y));
874: pr("#\textzv\t%s,%s,%s,%s\n", str(t), str(y), str(s), str(x));
875: goto movexdest;
876: case Star:
877: switch(p->left->op) {
878: case Icon: /* as in foo((a, a)), where a is a struct */
879: s = doit(p->left, VALUE, 0, regmask);
880: sprintx(buf, "%s", str(s)+1);
881: i = j = 0;
882: goto convbuf;
883: case Auto:
884: case Param:
885: case Name:
886: s = doit(p->left, VALUE, 0, regmask);
887: sprintx(buf, "*%s", str(s));
888: j = i = 0;
889: goto convbuf;
890: case Reg:
891: s = doit(p->left, VALUE, 0, regmask);
892: inreg:
893: if(s.flag & ISREG) {
894: sprintx(buf, "(%s)", str(s));
895: j = s.regmask;
896: i = CANINDIR;
897: goto convbuf;
898: }
899: else if(s.flag & CANINDIR) {
900: sprintx(buf, "*%s", str(s));
901: j = s.regmask;
902: i = 0;
903: goto convbuf;
904: }
905: else {
906: debugpr("#FAIL STAR REG ");
907: s.flag = FAIL;
908: return(s);
909: }
910: }
911: q = p->left;
912: if(q->op == Incr && !(flag & INDEX)
913: && q->right->op == Icon && q->left->op == Reg
914: && incrsize(p) == (int) q->right->lval) {
915: s = doit(q->left, VALUE, 0, regmask);
916: sprintx(buf, "(%s)+", str(s));
917: i = INDEX|AUTO;
918: j = s.regmask;
919: goto convbuf;
920: }
921: if(q->op == Plus && q->left->op == Ls
922: && !(flag & INDEX)
923: && q->left->right->op == Icon
924: && shiftsize(p) == (int) q->left->right->lval) {
925: s = doit(q->left->left, VALUE|USED, 0, regmask);
926: if(s.flag & FAIL)
927: return(s);
928: regmask &= ~s.regmask;
929: if(!(s.flag & ISREG)) {
930: x = allocreg(p, regmask);
931: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x));
932: regmask |= s.regmask;
933: regmask &= ~x.regmask;
934: s = x;
935: if(!(s.flag & ISREG)) {
936: debugpr("#FAIL a[b] ");
937: s.flag = FAIL;
938: return(s);
939: }
940: }
941: t = doit(q->right, ASADDR|USED|VALUE, 0, regmask);
942: if(t.flag & FAIL) {
943: totemp(q, LEFT);
944: longjmp(back, 1);
945: }
946: sprintx(buf, "%s[%s]", str(t), str(s));
947: i = INDEX;
948: j = s.regmask | t.regmask;
949: goto convbuf;
950: }
951: if(q->op == Plus && q->right->op == Icon) {
952: s = doit(q->left, VALUE|USED, 0, regmask);
953: if(s.flag & FAIL)
954: return(s);
955: if(!(s.flag & ISREG)) {
956: x = allocreg(p, regmask);
957: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x));
958: s = x;
959: if(!(s.flag & ISREG)) {
960: debugpr("#FAIL a(b) ");
961: s.flag = FAIL;
962: return(s);
963: }
964: }
965: regmask &= ~s.regmask;
966: t = doit(q->right, ASADDR|USED, 0, regmask);
967: sprintx(buf, "%s(%s)", str(t), str(s));
968: i = CANINDIR;
969: j = s.regmask;
970: goto convbuf;
971: }
972: if(q->op == Minus && q->right->op == Icon) {
973: s = doit(q->left, VALUE|USED, 0, regmask);
974: if(s.flag & FAIL)
975: return(s);
976: if(!(s.flag & ISREG)) {
977: x = allocreg(p, regmask);
978: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x));
979: s = x;
980: if(!(s.flag & ISREG)) {
981: debugpr("#FAIL %d(a) ");
982: s.flag = FAIL;
983: return(s);
984: }
985: }
986: regmask &= ~s.regmask;
987: sprintx(buf, "%d(%s)", -q->right->lval, str(s));
988: i = CANINDIR;
989: j = s.regmask;
990: goto convbuf;
991: }
992: if(q->op == Minuseq && !(flag & (INDEX|USED))
993: && q->right->op == Icon && q->left->op == Reg
994: && incrsize(p) == (int) q->right->lval) {
995: s = doit(q->left, VALUE, 0, regmask);
996: sprintx(buf, "-(%s)", str(s));
997: i = INDEX|AUTO;
998: j = s.regmask;
999: goto convbuf;
1000: }
1001: if(q->op == Plus && q->left->op == Reg
1002: && !(flag & INDEX) && q->right->op == Reg
1003: && incrsize(p) == 1) {
1004: sprintx(buf, "(r%d)[r%d]", q->right->rval,
1005: q->left->rval);
1006: i = INDEX;
1007: j = 0;
1008: goto convbuf;
1009: }
1010: s = doit(p->left, VALUE|USED, 0, regmask);
1011: if(s.flag & FAIL)
1012: return(s);
1013: regmask &= ~s.regmask;
1014: if(s.flag & CANINDIR) {
1015: sprintx(buf, "*%s", str(s));
1016: i = 0;
1017: j = s.regmask;
1018: goto convbuf;
1019: }
1020: if(!(s.flag & ISREG)) {
1021: x = allocreg(p, regmask);
1022: pr("#\tmov%c\t%s,%s\n", type(q), str(s), str(x));
1023: regmask |= s.regmask;
1024: regmask &= ~x.regmask;
1025: s = x;
1026: }
1027: if(!(s.flag & ISREG)) {
1028: debugpr("#FAIL STAR ");
1029: s.flag = FAIL;
1030: return(s);
1031: }
1032: sprintx(buf, "(%s)", str(s));
1033: i = 0;
1034: j = s.regmask;
1035: goto convbuf;
1036: case Stasg:
1037: if(p->stsize/8 == 4) {
1038: i = 'l';
1039: stasg:
1040: s = doit(p->left, VALUE|ASADDR|USED|FSTASG, 0, regmask);
1041: if(s.flag & FAIL)
1042: return(s);
1043: regmask &= ~s.regmask;
1044: t = doit(p->right, VALUE|ASADDR|USED|FSTASG, 0, regmask);
1045: if(t.flag & FAIL) {
1046: t = doit(p->right, VALUE|ASADDR|USED|FSTASG, 0, REGMASK);
1047: if(!(t.flag & FAIL) && svmask != REGMASK)
1048: return(t.flag = FAIL, t);
1049: totemp(p, LEFT);
1050: longjmp(back, 1);
1051: }
1052: pr("#\tmov%c\t%s,%s\n", i, str(t), str(s));
1053: if(!(flag & FSTASG))
1054: s = addrsimp(s, t);
1055: return(s);
1056: }
1057: else if(p->stsize/8 == 8) {
1058: i = 'q';
1059: goto stasg;
1060: }
1061: if(regmask != REGMASK) {
1062: debugpr("#FAIL stasg ");
1063: s.flag = FAIL;
1064: return(s);
1065: }
1066: s = doit(p->right, VALUE|USED|FSTASG, 0, regmask);
1067: if(s.flag & INDEX) {
1068: /* over-enthusiastic use of index mode */
1069: x = allocreg(p, regmask);
1070: pr("#\tmovl\t%s,%s\n", str(s), str(x));
1071: s = x;
1072: }
1073: regmask &= ~s.regmask;
1074: t = doit(p->left, VALUE|USED|FSTASG, 0, regmask);
1075: if(t.flag & FAIL) {
1076: totemp(p, RIGHT);
1077: longjmp(back, 1);
1078: }
1079: if(t.flag & INDEX) {
1080: /* over-enthusiastic use of index mode */
1081: x = allocreg(p, regmask);
1082: pr("#\tmovl\t%s,%s\n", str(t), str(x));
1083: t = x;
1084: }
1085: t = indirit(t);
1086: if(t.flag & FAIL) {
1087: if(p->left->op != Star)
1088: cerror("codegen failure in struct asg");
1089: totemp(p->left, LEFT);
1090: longjmp(back, 1);
1091: }
1092: s = indirit(s);
1093: if(s.flag & FAIL) {
1094: if(p->right->op != Star)
1095: cerror("codgen fail in stasg");
1096: totemp(p->right, LEFT);
1097: longjmp(back, 1);
1098: }
1099: pr("#\tmovc3\t$%d,%s,%s\n", p->stsize/8, str(s), str(t));
1100: if(flag & USED) {
1101: t = specialreg(p, REGMASK);
1102: pr("#\tsubl3\t$%d,r3,r0\n", p->stsize/8);
1103: }
1104: else
1105: t.flag = 0;
1106: return(t);
1107: case Stcall:
1108: goto call;
1109: case Auto:
1110: sprintx(buf, "%d(%s)", p->lval, frameptr);
1111: j = 0;
1112: i = CANINDIR;
1113: goto convbuf;
1114: case Param:
1115: sprintx(buf, "%d(%s)", p->lval, argptr);
1116: j = 0;
1117: i = CANINDIR;
1118: goto convbuf;
1119: case Addr:
1120: s = doit(p->left, USED, 0, regmask);
1121: if(s.flag & FAIL)
1122: return(s);
1123: regmask &= ~s.regmask;
1124: if(dest.ans == 0) {
1125: dest = allocreg(p, regmask);
1126: }
1127: if(s.flag & ISREG) {
1128: x = alloctmp(p);
1129: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(x));
1130: s = x;
1131: }
1132: if(flag & TOSTACK)
1133: pr("#\tpushal\t%s\n", str(s));
1134: else
1135: pr("#\tmova%c\t%s,%s\n", type(p), str(s), str(dest));
1136: if(flag & ASADDR) {
1137: if(dest.flag & ISREG) {
1138: strcat(str(dest), ")");
1139: strshift(str(dest), 1);
1140: str(dest)[0] = '(';
1141: }
1142: else {
1143: strshift(str(dest), 1);
1144: str(dest)[0] = '*';
1145: }
1146: }
1147: return(dest);
1148: case Ucall:
1149: i = 0;
1150: goto called;
1151: case Uminus:
1152: s = doit(p->left, VALUE|USED, 0, regmask);
1153: if(s.flag & FAIL)
1154: return(s);
1155: if(dest.ans == 0)
1156: if(s.flag & SCRATCH)
1157: dest = s;
1158: else
1159: dest = allocreg(p, regmask & ~s.regmask);
1160: pr("#\tmneg%c\t%s,%s\n", childtype(p), str(s), str(dest));
1161: dest.flag |= CC;
1162: return(dest);
1163: case Ustcall:
1164: i = 0;
1165: goto called;
1166: case Asg:
1167: assign:
1168: if(p->left->op == Qnode && dest.ans) {
1169: s = doit(p->right, VALUE|(flag&USED? USED: 0),
1170: dest, regmask);
1171: return(s);
1172: }
1173: if(p->left->op == Rnode || p->left->op == Snode) {
1174: s = doit(p->right, VALUE|(flag&USED? USED: 0),
1175: dest, regmask);
1176: if(s.flag & FAIL)
1177: return(s);
1178: x = s;
1179: dest = doit(p->left, USED, 0, 0);
1180: goto movexdest;
1181: }
1182: if(p->left->op == Fld) {
1183: s = doit(p->left->left, INDEX, 0, regmask);
1184: regmask &= ~s.regmask;
1185: if(p->right->op == Asg) {
1186: x = allocreg(p->right, regmask);
1187: t = doit(p->right, VALUE|USED, x, regmask & ~x.regmask);
1188: }
1189: else
1190: t = doit(p->right, VALUE|USED, 0, regmask);
1191: if(t.flag & FAIL) { /* was fldstar */
1192: totemp(p->left->left, LEFT);
1193: totemp(p, RIGHT);
1194: longjmp(back, 1);
1195: }
1196: i = '$';
1197: pr("#\tinsv\t%s,%c%d,%c%d,%s\n", str(t), i,
1198: p->left->rval/64, i,
1199: p->left->rval % 64, str(s));
1200: if(dest.ans) {
1201: pr("#\tmovl\t%s,%s\n", str(t), str(dest));
1202: t.flag |= CC;
1203: }
1204: return(t);
1205: }
1206: if(dest.ans && p->left->op == Star) {
1207: if(dest.flag & SCRATCH)
1208: x = dest;
1209: else
1210: x = allocreg(p, regmask);
1211: s = doit(p->right, VALUE|USED, x, regmask);
1212: if(s.flag & FAIL)
1213: return(s);
1214: regmask &= ~s.regmask;
1215: t = doit(p->left, USED, 0, regmask);
1216: if(t.flag & FAIL) {
1217: /* did we fail because of a dest, or was it us? */
1218: if(dest.ans || svmask != REGMASK) {
1219: t = doit(p->left, USED, 0, svmask);
1220: if(t.flag & FAIL) {
1221: return(t);
1222: }
1223: starasg(p);
1224: }
1225: else
1226: asgwrite(p);
1227: longjmp(back, 1);
1228: }
1229: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(t));
1230: if(strcmp(str(x), str(dest)) == 0) {
1231: dest.flag |= CC;
1232: return(dest);
1233: }
1234: goto movexdest;
1235: }
1236: if(p->right->op == Fld && incrsize(p) != 4) {
1237: /* ext sets whole word */
1238: asgwrite(p);
1239: p->left->type = isunsigned(p)? Tuint: Tint;
1240: longjmp(back, 1);
1241: }
1242: t = doit(p->left, USED, 0, regmask);
1243: regmask &= ~t.regmask;
1244: if(p->right->op == Genlab || p->right->op == Comop)
1245: extracheck(p); /* slightly worse code in usual case */
1246: s = doit(p->right, VALUE, t, regmask); /* VALUE is't right:
1247: register char *a, *b; return((*a++ = *b++ | 40) != 3); */
1248: if(s.flag & NOGOOD) {
1249: /* did we fail because of a dest, or was it us? */
1250: if(s.flag & FAIL) {
1251: if(dest.ans || svmask != REGMASK) {
1252: s = doit(p->right, VALUE, t, svmask);
1253: if(s.flag & FAIL) {
1254: return(s);
1255: }
1256: }
1257: asgwrite(p);
1258: longjmp(back, 1);
1259: }
1260: else if((flag & USED) && !((flag & CC) && (s.flag & CC))) {
1261: /* presumably USED as in *p++=*q++ */
1262: totemp(p, RIGHT);
1263: longjmp(back, 1);
1264: }
1265: }
1266: if(dest.ans) {
1267: x = s;
1268: goto movexdest;
1269: }
1270: else if(flag & ASADDR) {
1271: i = (s.flag & (ISREG|CANINDIR|SCRATCH));
1272: j = s.regmask;
1273: buf = str(s);
1274: goto convbuf;
1275: }
1276: return(s);
1277: }
1278: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.