![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genaux.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / ccom / vax|
Return to genaux.c CVS log | Up to [Research Unix] / researchv8dc / cmd / ccom / vax |
1.1 root 1: #include "gencode.h"
2: #define NDNUM 400
3: NODE myt[NDNUM];
4: int ntree;
5: extern int bothdebug, nosharp;
6: #if M32 == 1
7: char *regnames[] = {"%r0", "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7",
8: "%r8", "%fp", "%ap", "%r11", "%sp", "%r13", "%r14", "%pc"};
9: char *frameptr = "%fp";
10: char *argptr = "%ap";
11: char *jeq = "je";
12: char *jne = "jne";
13: char *jgt = "jg";
14: char *jge = "jge";
15: char *jlt = "jl";
16: char *jle = "jle";
17: char *jugt = "jgu";
18: char *juge = "jgeu";
19: char *jult = "jlu";
20: char *jule = "jleu";
21: #define CHARCHAR 'b'
22: #define SHORTCHAR 'h'
23: #define LONGCHAR 'w'
24: #define FLOATCHAR 's'
25: #define DOUBLECHAR 'd'
26: #else if VAX == 1
27: char *regnames[] = {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8",
28: "r9", "r10", "r11", "r12", "r13", "r14", "r15"};
29: char *frameptr = "fp";
30: char *argptr = "ap";
31: char *jeq = "jeql";
32: char *jne = "jneq";
33: char *jgt = "jgtr";
34: char *jge = "jgeq";
35: char *jlt = "jlss";
36: char *jle = "jleq";
37: char *jugt = "jgtru";
38: char *juge = "jgequ";
39: char *jult = "jlssu";
40: char *jule = "jlequ";
41: #define CHARCHAR 'b'
42: #define SHORTCHAR 'w'
43: #define LONGCHAR 'l'
44: #define FLOATCHAR 'f'
45: #define DOUBLECHAR 'd'
46: #endif
47: char *bufend = (char *)bufs + sizeof(bufs);
48: pr(fmt, list)
49: char *fmt; long list;
50: {
51: char *sprintxl();
52: nosharp = !bothdebug;
53: prptr = sprintxl(prptr, fmt, &list);
54: if(prptr > prbuf + sizeof(prbuf))
55: cerror("prbuf overflow");
56: nosharp = 0;
57: }
58:
59: outpr()
60: {
61: *prptr = 0;
62: printbuf(prbuf, prptr-prbuf);
63: }
64: NODE *
65: gimmenode()
66: { NODE *p;
67: p = myt + ntree++;
68: if(ntree > NDNUM)
69: cerror("out of temporary trees");
70: return(p);
71: }
72:
73: NODE *
74: tempnode(p, flag)
75: NODE *p;
76: { NODE *x, *q = p->in.left;
77: int n;
78: extern int minrvar;
79: if(p->in.op == CONV)
80: q = p; /* CONV to double of float, versus (CMP double double) */
81: x = gimmenode();
82: x->in.type = q->in.type;
83: n = incrsize(q) == 8? 2: 1;
84: if(!(flag & ASADDR) && regvar >= REGVAR - 1 + n) {
85: x->in.op = REG;
86: x->tn.rval = regvar + 1 - n;
87: x->tn.lval = 1; /* SCRATCH marker !!!!! */
88: regvar -= n;
89: if(minrvar > regvar)
90: minrvar = regvar; /* in case current routine recursive */
91: return(x);
92: }
93: x->in.op = VAUTO;
94: x->tn.lval = gimmetemp(n);
95: /* scratch marker? */
96: return(x);
97: }
98: ret
99: alloctmp(p)
100: NODE *p;
101: { ret s;
102: sprintf(buf, "%d(%s)", gimmetemp(incrsize(p) == 8? 2: 1), frameptr);
103: done(s, CANINDIR|SCRATCH, 0);
104: }
105: ret
106: checksize(p, s, regmask)
107: NODE *p;
108: ret s;
109: { ret t;
110: if(p->in.type != TDOUBLE)
111: return(s);
112: regmask |= s.regmask;
113: t = allocreg(p, regmask);
114: return(t);
115: }
116:
117: ret
118: allocreg(p, regmask)
119: NODE *p;
120: { int i, n;
121: ret s;
122: NODE *x;
123: if(p->in.type == TDOUBLE)
124: n = 2;
125: else
126: n = 1;
127: for(i = 0; i < REGVAR; i++) {
128: if(!(regmask & (1 << i)))
129: continue;
130: if(n == 2 & !(regmask & (1 << (1+i))))
131: continue;
132: sprintx(buf, "%s", regnames[i]);
133: regmask = (1 << i);
134: if(n == 2)
135: regmask |= (1 << (i+1));
136: done(s, SCRATCH|ISREG, regmask);
137: }
138: x = tempnode(p, 0);
139: if(x->in.op == REG) {
140: sprintx(buf, "%s", regnames[x->tn.rval]);
141: done(s, SCRATCH|ISREG, 0);
142: }
143: sprintx(buf, "%d(%s)", x->tn.lval, frameptr);
144: done(s, SCRATCH|CANINDIR, 0);
145: }
146:
147: gimmetemp(n)
148: {
149: if(VAX)
150: return(freetemp(n)/8 - maxboff/SZCHAR);
151: else
152: return(freetemp(n)/8 + maxboff/SZCHAR);
153: }
154:
155: isfloat(p)
156: NODE *p;
157: {
158: return(p->in.type == TFLOAT || p->in.type == TDOUBLE);
159: }
160:
161: childtype(p)
162: NODE *p;
163: {
164: return(type(p->in.left));
165: }
166:
167: type(p)
168: NODE *p;
169: { int n = p->in.type;
170: switch(n) {
171: default:
172: return('?');
173: case TCHAR: case TUCHAR:
174: return(CHARCHAR);
175: case TSHORT: case TUSHORT:
176: return(SHORTCHAR);
177: case TINT: case TUNSIGNED: case TLONG: case TULONG:
178: case TPOINT: case TSTRUCT:
179: return(LONGCHAR);
180: case TFLOAT:
181: return(FLOATCHAR);
182: case TDOUBLE:
183: return(DOUBLECHAR);
184: }
185: }
186:
187: shiftsize(p)
188: NODE *p;
189: {
190: switch(p->in.type) {
191: default:
192: return(0); /* 0 can't occur in an ICON under shift */
193: case TCHAR: case TUCHAR:
194: return(0);
195: case TSHORT: case TUSHORT:
196: return(1);
197: case TINT: case TUNSIGNED: case TLONG: case TULONG: case TPOINT:
198: case TFLOAT:
199: return(2);
200: case TDOUBLE:
201: return(3);
202: }
203: }
204:
205: incrsize(p)
206: NODE *p;
207: {
208: switch(p->in.type) {
209: default:
210: return(0); /* 0 can't occur in an icon under incrop */
211: case TCHAR: case TUCHAR:
212: return(1);
213: case TSHORT: case TUSHORT:
214: return(2);
215: case TINT: case TUNSIGNED: case TLONG: case TULONG: case TPOINT:
216: case TFLOAT:
217: return(4);
218: case TDOUBLE:
219: return(8);
220: }
221: }
222:
223: isunsigned(p)
224: NODE *p;
225: {
226: switch(p->in.type) {
227: #if VAX==1
228: case TCHAR:
229: #endif
230: case TSHORT: case TINT: case TLONG: case TFLOAT: case TDOUBLE:
231: return(0);
232: #if M32==1
233: case TCHAR:
234: #endif
235: default:
236: return(1);
237: }
238: }
239:
240: NODE *
241: copytree(p)
242: NODE *p;
243: { NODE *a, *b, *c;
244: switch(p->in.op) {
245: case ASG AND: case AND: case CALL: case CMP: case COMOP:
246: case DECR: case ASG DIV: case DIV: case ASG ER: case ER:
247: case INCR: case ASG LS: case LS: case ASG MINUS: case MINUS:
248: case ASG MOD: case MOD: case ASG MUL: case MUL: case ASG OR:
249: case OR: case ASG PLUS: case PLUS: case ASG RS: case RS:
250: case STASG: case STCALL: case ASSIGN: case CM:
251: a = copytree(p->in.left);
252: b = copytree(p->in.right);
253: c = gimmenode();
254: *c = *p;
255: c->in.left = a;
256: c->in.right = b;
257: return(c);
258: case COMPL: case CONV: case FLD: case GENBR: case GENLAB:
259: case GENUBR: case STAR: case UNARY AND: case UNARY CALL:
260: case UNARY MINUS: case UNARY STCALL: case INIT: case FUNARG:
261: case STARG:
262: a = copytree(p->in.left);
263: c = gimmenode();
264: *c = *p;
265: c->in.left = a;
266: return(c);
267: case VAUTO: case REG: case NAME: case VPARAM: case ICON:
268: case SNODE: case RNODE: case QNODE:
269: c = gimmenode();
270: *c = *p;
271: return(c);
272: default:
273: cerror("unk node in copytree");
274: }
275: }
276: /* rewrit A op B into (T = A, T) op B or A op (T = B, T) */
277: totemp(p, flag)
278: NODE *p;
279: { NODE *a, *b, *c;
280: a = gimmenode();
281: b = tempnode(p, flag);
282: c = gimmenode();
283: if(flag & LEFT)
284: *a = *p->in.left;
285: else
286: *a = *p->in.right;
287: a->in.op = ASSIGN;
288: a->in.left = b;
289: if(flag & LEFT)
290: a->in.right = p->in.left;
291: else
292: a->in.right = p->in.right;
293: c->in.op = COMOP;
294: c->in.left = a;
295: c->in.right = b;
296: c->in.type = a->in.type;
297: if(flag & LEFT)
298: p->in.left = c;
299: else
300: p->in.right = c;
301: }
302:
303: funargs(p, regmask)
304: NODE *p;
305: { ret s, t;
306: int i;
307: switch(p->in.op) {
308: case CM: /* order depends on way stack grows */
309: #ifdef LTORARGS
310: i = funargs(p->in.left, regmask);
311: i |= funargs(p->in.right, regmask);
312: #else
313: i = funargs(p->in.right, regmask);
314: i |= funargs(p->in.left, regmask);
315: #endif
316: return(i);
317: case FUNARG:
318: #if VAX==1
319: t = tostack();
320: s = doit(p->in.left, VALUE|TOSTACK, t, regmask);
321: #else if M32==1
322: s = doit(p->in.left, VALUE|TOSTACK, 0, regmask);
323: #endif
324: return(s.flag & FAIL);
325: case STARG:
326: /* this has to have same cases as STASG */
327: if(regmask != REGMASK)
328: return(FAILX);
329: s = doit(p->in.left, VAX?(ASADDR|VALUE):VALUE, 0, regmask);
330: /* this generates expensive code for small structures */
331: i = p->stn.stsize / 8;
332: if(p->in.left->in.op == STASG) {
333: if(VAX && i != 4 && i != 8) {
334: pr("#\tsubl2\t$%d,sp\n", i);
335: pr("#\tsubl2\t$%d,r3\n", i);
336: pr("#\tmovc3\t$%d,(r3),(sp)\n", p->stn.stsize/8);
337: return(0);
338: }
339: else if(M32 && i >= 7 * 4) {
340: pr("#\taddw2\t&%d,%%sp\n", i);
341: pr("#\tsubw2\t&%d,%%r0\n", i/4);
342: goto moveit;
343: }
344: }
345: if(VAX) {
346: if(i == 4)
347: pr("#\tpushl\t%s\n", str(s));
348: else if(i == 8)
349: pr("#\tmovq\t%s,-(sp)\n", str(s));
350: else {
351: pr("#\tsubl2\t$%d,sp\n", i);
352: pr("#\tmovc3\t$%d,%s,(sp)\n", p->stn.stsize/8, str(s));
353: }
354: }
355: else if(M32) {
356: pr("#\taddw2\t&%d,%%sp\n", i);
357: if(strcmp(str(s), "%r0"))
358: pr("#\tmovw\t%s,%r0\n", str(s));
359: moveit:
360: pr("#\tmovaw\t-%d(%%sp),%r1\n", p->stn.stsize/8);
361: i = p->stn.stsize/32;
362: if(i >= 7) {
363: pr("#\tmovw\t&%d,%%r2\n", i);
364: pr("#\tMOVBLW\n");
365: }
366: else
367: while(--i >= 0)
368: pr("#\tmovw\t%d(%r0),%d(%r1)\n", 4*i, 4*i);
369: }
370: return(s.flag & FAIL);
371: }
372: }
373:
374: strshift(s, n)
375: char *s;
376: { int i, j;
377: i = strlen(s);
378: if(n > 0)
379: for(j = i; j >= 0; j--)
380: s[j + n] = s[j];
381: else
382: for(j = -n; j <= i; j++)
383: s[j + n] = s[j];
384: }
385:
386: ret
387: tostack()
388: { ret s;
389: sprintx(buf, "-(sp)");
390: done(s, 0, 0);
391: }
392:
393: ret
394: specialreg(p, regmask)
395: NODE *p;
396: { ret s;
397: int n, i;
398: n = p ->in.type == TDOUBLE? 2: 1;
399: i = 1;
400: if(n == 2)
401: i = 3;
402: sprintx(buf, "%s", regnames[0]);
403: if(i & ~regmask)
404: pr("#\specialreg not free\n");
405: done(s, SCRATCH|ISREG, i);
406: }
407: /* these guys rewrite a1 = a2 = ... an = x
408: * as t = x; an = t; an-1 = an */
409: NODE *
410: fromtemp(p, temp)
411: NODE *p, *temp;
412: { NODE *q;
413: q = gimmenode();
414: *q = *p;
415: q->in.left = p;
416: q->in.op = ASSIGN;
417: q->in.right = temp;
418: return(q);
419: }
420:
421: NODE *
422: to(p, temp)
423: NODE *p, *temp;
424: { NODE *q;
425: q = gimmenode();
426: *q = *p;
427: q->in.right = p;
428: q->in.op = ASSIGN;
429: q->in.left = temp;
430: return(q);
431: }
432:
433: NODE *
434: comnode(a, p)
435: NODE *a, *p;
436: { NODE *q;
437: q = gimmenode();
438: *q = *p;
439: q->in.op = COMOP;
440: q->in.right = p;
441: q->in.left = a;
442: return(q);
443: }
444:
445: asgwrite(p)
446: NODE *p;
447: { NODE *q, *a, *temp;
448: temp = tempnode(p, 0);
449: a = fromtemp(p->in.left, temp);
450: for(q = p->in.right; q->in.op == ASSIGN; q = q->in.right)
451: a = comnode(fromtemp(q->in.left, temp), a);
452: a = comnode(to(q, temp), a);
453: *p = *a;
454: }
455:
456: char *
457: genjmp(n)
458: {
459: switch(n) {
460: default:
461: return("jweird");
462: case EQ:
463: return(jeq);
464: case NE:
465: return(jne);
466: case GT:
467: return(jgt);
468: case GE:
469: return(jge);
470: case LT:
471: return(jlt);
472: case LE:
473: return(jle);
474: case UGT:
475: return(jugt);
476: case UGE:
477: return(juge);
478: case ULT:
479: return(jult);
480: case ULE:
481: return(jule);
482: }
483: }
484:
485: lsconv(p)
486: NODE *p;
487: { NODE *lft, *right;
488: lft = gimmenode();
489: right = gimmenode();
490: lft->in.op = right->in.op = CONV;
491: lft->in.type = right->in.type = TLONG;
492: lft->in.left = p->in.left;
493: right->in.left = p->in.right;
494: if(p->in.left->in.op != ICON) /* ICONS are longs anyway (see RS) */
495: p->in.left = lft;
496: p->in.right = right;
497: }
498: /* only some ops have to be rewritten (addb and addl are the same at the bottom) */
499: rewriteasgop(p)
500: NODE *p;
501: { NODE *a, *newop;
502: if(p->in.left->in.op != CONV)
503: return(0);
504: if(p->in.left->in.left->in.op == STAR)
505: longjmp(back, awfulstar(p));
506: newop = gimmenode();
507: *newop = *p;
508: switch(p->in.op) {
509: case ASG DIV:
510: newop->in.op = DIV;
511: break;
512: case ASG LS:
513: newop->in.op = LS;
514: break;
515: case ASG MOD:
516: newop->in.op = MOD;
517: break;
518: case ASG RS:
519: newop->in.op = RS;
520: break;
521: case ASG PLUS:
522: if(incrsize(p->in.left) != 8)
523: return(0);
524: newop->in.op = PLUS;
525: break;
526: case ASG MINUS:
527: if(incrsize(p->in.left) != 8)
528: return(0);
529: newop->in.op = MINUS;
530: break;
531: case ASG MUL:
532: if(incrsize(p->in.left) != 8)
533: return(0);
534: newop->in.op = MUL;
535: break;
536:
537: default:
538: cerror("codegen: rewriting asgop");
539: }
540: a = gimmenode();
541: *a = *p->in.left->in.left;
542: p->in.op = ASSIGN;
543: p->in.left = a;
544: p->in.right = newop;
545: return(1);
546: }
547:
548: rewriteconv(p) /* uns to float or double */
549: NODE *p;
550: { NODE *a;
551: a = gimmenode();
552: *a = *p;
553: a->in.type = TLONG;
554: p->in.left = a;
555: }
556:
557: mediumstar(p)
558: NODE *p;
559: { NODE *newtop, *tmp, *x, *y;
560: newtop = gimmenode();
561: newtop->in.op = COMOP;
562: newtop->in.type = p->in.type;
563: x = gimmenode();
564: x->in.op = ASSIGN;
565: x->in.type = TPOINT;
566: x->in.right = p->in.left->in.left;
567: newtop->in.left = x;
568: tmp = tempnode(newtop, 0);
569: tmp->in.type = TPOINT;
570: x->in.left = tmp;
571: y = gimmenode();
572: y->in.op = COMOP;
573: y->in.type = p->in.type;
574: x = gimmenode();
575: *x = *p;
576: newtop->in.right = y;
577: y->in.left = x;
578: y->in.right = x->in.left;
579: x->in.left->in.left = tmp;
580: *p = *newtop;
581: return(1);
582: }
583:
584: awfulstar(p)
585: NODE *p;
586: { NODE *newtop, *doleft, *x, *op, *equals;
587: newtop = gimmenode();
588: newtop->in.op = COMOP;
589: newtop->in.type = p->in.type;
590: doleft = gimmenode();
591: doleft->in.op = ASSIGN;
592: doleft->in.type = TPOINT;
593: doleft->in.right = p->in.left->in.left->in.left;
594: x = tempnode(doleft, 0);
595: doleft->in.left = x;
596: op = gimmenode();
597: *op = *p;
598: op->in.op -= (ASG 0); /* crap for crap */
599: op->in.left->in.left->in.left = x; /* so it's a dag, but x is harmless */
600: equals = gimmenode();
601: *equals = *p;
602: equals->in.right = op;
603: equals->in.left = p->in.left->in.left;
604: equals->in.op = ASSIGN;
605: *p = *newtop;
606: p->in.left = doleft;
607: p->in.right = equals;
608: return(1);
609: }
610: rewritefld(p)
611: NODE *p;
612: { NODE *q, *tmp, *left, *comop;
613: if((q = p->in.left->in.left)->in.op != STAR) {
614: rewfld(p);
615: return;
616: }
617: q = q->in.left;
618: tmp = tempnode(q, 0);
619: left = gimmenode();
620: left->in.type = q->in.type;
621: left->in.op = ASSIGN;
622: left->in.left = tmp;
623: left->in.right = gimmenode();
624: left->in.right = copytree(q);
625: *q = *tmp;
626: comop = gimmenode();
627: comop->in.op = COMOP;
628: comop->in.left = left;
629: comop->in.right = copytree(p);
630: *p = *comop;
631: rewfld(p->in.right);
632: longjmp(back, 1);
633: }
634: rewfld(p)
635: NODE *p;
636: { NODE *x, *y, *z;
637: x = gimmenode();
638: *x = *copytree(p);
639: y = gimmenode();
640: *y = *copytree(p);
641: z = gimmenode();
642: *z = *p;
643: z->in.left = x;
644: x->in.op = ASSIGN;
645: x->in.right = y;
646: if(p->in.op == DECR || p->in.op == ASG MINUS)
647: z->in.op = PLUS;
648: else
649: z->in.op = MINUS;
650: if(p->in.op == DECR)
651: y->in.op = MINUS;
652: else if(p->in.op == INCR)
653: y->in.op = PLUS;
654: else
655: y->in.op -= (ASG 0); /* good grief */
656: if(p->in.op == DECR || p->in.op == INCR)
657: *p = *z;
658: else
659: *p = *x;
660: }
661:
662: ret
663: indirit(s)
664: ret s;
665: {
666: if(s.flag & ISREG) {
667: strcat(str(s), ")");
668: strshift(str(s), 1);
669: str(s)[0] = '(';
670: return(s);
671: }
672: if(s.flag & CANINDIR) {
673: strshift(str(s), 1);
674: str(s)[0] = '*';
675: return(s);
676: }
677: if(VAX && str(s)[0] == '(') { /* (r3)[r11] */
678: strshift(str(s), 1);
679: str(s)[0] = '*';
680: return(s);
681: }
682: if(VAX && str(s)[0] == '$') { /* an icon for structure returns */
683: strshift(str(s), -1);
684: return(s);
685: }
686: s.flag = FAIL;
687: return(s);
688: }
689: /* not int = (...? int exprs) have a bogus tree */
690: extracheck(p)
691: NODE *p;
692: { NODE *a;
693: if(p->in.right->in.op != GENLAB)
694: return;
695: a = gimmenode();
696: *a = *p;
697: a->in.left = p->in.right;
698: a->in.op = CONV;
699: p->in.right = a;
700: }
701:
702: starasg(p)
703: NODE *p;
704: { NODE *tmp, *asg, *x;
705: tmp = tempnode(p->in.left->in.left, 0);
706: x = gimmenode();
707: *x = *p;
708: asg = gimmenode();
709: *asg = *p->in.left->in.left;
710: asg->in.op = ASSIGN;
711: asg->in.left = tmp;
712: asg->in.right = p->in.left->in.left;
713: x->in.left->in.left = tmp;
714: p->in.op = COMOP;
715: p->in.left = asg;
716: p->in.right = x;
717: }
718: stasgrewrite(p)
719: NODE *p;
720: { NODE *qa, *qb, *n, *left, *right;
721: if(VAX) {
722: totemp(p, RIGHT);
723: longjmp(back, 1);
724: }
725: if(M32) {
726: qa = tempnode(p->in.right, 0);
727: qb = tempnode(p->in.left, 0);
728: right = to(p->in.right, qa);
729: left = to(p->in.left, qb);
730: p->in.right = qa;
731: p->in.left = qb;
732: qa = gimmenode();
733: qb = gimmenode();
734: qa->in.op = qb->in.op = COMOP;
735: qa->in.left = left;
736: qa->in.right = qb;
737: qb->in.left = right;
738: n = gimmenode();
739: *n = *p;
740: qb->in.right = n;
741: *p = *qa;
742: longjmp(back, 1);
743: }
744: }
745: ret
746: simpler(a, b) /* returns b (as dest) preferentially */
747: ret a, b;
748: {
749: if(b.flag & ISREG)
750: return(b);
751: if(a.flag & ISREG)
752: return(a);
753: if(b.flag & SCRATCH)
754: return(b);
755: if(a.flag & SCRATCH)
756: return(a);
757: if(!(b.flag & INDEX))
758: return(b);
759: if(!(a.flag & INDEX))
760: return(a);
761: /* disallow *p++ = *q++ but not p[i]=q[i]*/
762: if(!index(str(b), '-') && !index(str(b), '+'))
763: return(b);
764: if(!index(str(a), '-') && !index(str(a), '+'))
765: return(a);
766: b.flag |= USED;
767: return(b);
768: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.