![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 8.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 8.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: /* gencode.c */
2: extern struct _iobuf {
3: int _cnt;
4: unsigned char *_ptr;
5: unsigned char *_base;
6: short _flag;
7: char _file;
8: } _iob[20];
9: struct _iobuf *fopen();
10: struct _iobuf *fdopen();
11: struct _iobuf *freopen();
12: long ftell();
13: char *fgets();
14: char *hash();
15: char *savestr();
16: char *tstr();
17: extern int tstrused;
18: extern char *tstrbuf[];
19: extern char **curtstr;
20: extern int nerrors;
21: typedef union ndu NODE;
22: typedef unsigned int TWORD;
23: typedef long CONSZ;
24: extern int dope[];
25: extern char *opst[];
26: union ndu {
27: struct {
28: int op;
29: int goal;
30: TWORD type;
31: int cst[(6+4)];
32: char * name;
33: char pad[8 -sizeof(char *)];
34: NODE *left;
35: NODE *right;
36: }in;
37:
38: struct {
39: int op;
40: int goal;
41: TWORD type;
42: int cst[(6+4)];
43: char * name;
44: char pad[8 -sizeof(char *)];
45: CONSZ lval;
46: int rval;
47: }tn;
48:
49: struct {
50: int op;
51: int goal;
52: TWORD type;
53: int cst[(6+4)];
54: int label;
55: int lop;
56: }bn;
57: struct {
58: int op;
59: int goal;
60: TWORD type;
61: int cst[(6+4)];
62: int stsize;
63: short stalign;
64: short argsize;
65: }stn;
66: struct {
67: int op;
68: int goal;
69: TWORD type;
70: int cdim;
71: int csiz;
72: }fn;
73:
74: struct {
75:
76: int op;
77: int goal;
78: TWORD type;
79: int cdim;
80: int csiz;
81: double dval;
82: }fpn;
83: };
84: extern int busy[];
85: extern NODE node[];
86: typedef struct shape SHAPE;
87:
88: extern struct shape {
89: int op;
90: SHAPE *sl;
91: SHAPE *sr;
92: int sh;
93: int sc;
94: } shapes[];
95: extern SHAPE *pshape[];
96: typedef struct optab OPTAB;
97: struct optab {
98: int op;
99: int tyop;
100: OPTAB *nextop;
101: SHAPE **lshape;
102: int ltype;
103: SHAPE **rshape;
104: int rtype;
105: int needs;
106: int rewrite;
107: char *cstring;
108: int cost;
109: int lcount;
110: int rcount;
111: int stinline;
112: };
113: extern OPTAB
114: *match(),
115: *ophead[],
116: table[];
117: extern NODE resc[];
118: extern int tmpoff;
119: extern int maxboff;
120: extern int maxtemp;
121: extern int maxarg;
122: extern int ftnno;
123: extern int sideff;
124: extern NODE
125: *talloc(),
126: *ind2type(),
127: *tcopy(),
128: *getadr(),
129: *getlr();
130: extern CONSZ rdin();
131: extern char *rnames[];
132: extern int lineno;
133: extern char ftitle[];
134: extern int fldshf, fldsz;
135: extern int lflag, udebug, e2debug, odebug, rdebug, radebug, sdebug;
136: extern int fast;
137: typedef struct inst INST;
138: struct inst {
139: NODE *p;
140: OPTAB *q;
141: int goal;
142: };
143: extern INST inst[300];
144: extern nins;
145: typedef SHAPE *SHTABLE[2][20];
146: extern SHTABLE sha;
147: typedef struct {
148: unsigned char ans;
149: unsigned char regmask;
150: unsigned short flag;
151: } ret;
152: ret doit(), allocreg(), reg0(), indir(), tostack();
153: char *genjmp();
154: char bufs[128][64];
155: char *buf;
156: char prbuf[10240];
157: char *prptr;
158: NODE *copytree(), *gimmenode();
159: extern int ntree;
160: typedef int jmp_buf[10];
161: jmp_buf back;
162: int acnt;
163: gencode(p)
164: NODE *p;
165: { NODE *q;
166: if(setjmp(back)) {
167: pr("#\treg\t%d\n", ++acnt);
168: if(acnt > 20) {
169: prtree(q);
170: outpr();
171: return;
172: }
173: }
174: else
175: q = copytree(p);
176: buf = bufs[1];
177: prptr = prbuf;
178: (void) doit(q, 0, 0, 0x3f);
179: acnt = ntree = 0;
180: outpr();
181: }
182: ret
183: doit(p, flag, dest, regmask)
184: NODE *p;
185: ret dest;
186: { ret s, t, x;
187: char *pp;
188: NODE snode, *q;
189: int i, j;
190: switch(p->in.op) {
191: default:
192: pr("#\tweird??? %d\n", p->in.op);
193: return(dest);
194: case 1+ 14:
195: flag |= 256;
196: flag &= ~1;
197: case 14:
198:
199: t = doit(p->in.left, 2, 0, regmask);
200: regmask &= ~t.regmask;
201: s = doit(p->in.right, 2, 0, regmask);
202: if(s.flag & 1024) {
203: totemp(p, 0);
204: longjmp(back, 1);
205: }
206: regmask &= ~s.regmask;
207: if(flag & 1) {
208: pr("#\tbit%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[t.ans]);
209: dest.ans = 0;
210: dest.flag = 1;
211: dest.regmask = 0;
212: return(dest);
213: }
214: if(flag & 256)
215: dest = x = t;
216: if(dest.ans == 0)
217: if(s.flag & 16)
218: dest = x = s;
219: else if(t.flag & 16)
220: dest = x = t;
221: else
222: dest = x = allocreg(p, regmask);
223: else
224: x = allocreg(p, regmask);
225: if(p->in.right->in.op == 4) {
226: x = tostack();
227: sprintf( bufs[x.ans], "$%d", -p->in.right->tn.lval - 1);
228: }
229: else
230: pr("#\tmcom%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[x.ans]);
231: if(strcmp( bufs[t.ans], bufs[dest.ans]) == 0)
232: pr("#\tbic%c2\t%s,%s\n", childtype(p), bufs[x.ans], bufs[dest.ans]);
233: else
234: pr("#\tbic%c3\t%s,%s,%s\n", childtype(p), bufs[x.ans],
235: bufs[t.ans], bufs[dest.ans]);
236: dest.flag |= 1;
237: return(dest);
238: case 70:
239: call:
240: funargs(p->in.right, regmask);
241: i = p->stn.argsize/32;
242: called:
243: s = doit(p->in.left, 2|8, 0, regmask & ~3);
244: pp = bufs[s.ans];
245: aftercall:
246: if(regmask != 0x3f) {
247: s.flag = 1024;
248: return(s);
249: }
250: x = reg0(p, regmask);
251: pr("#\tcalls\t$%d,%s\n", i, pp);
252: if(p->in.op == 100 || p->in.op == 2+ 100 || (flag & 8)) {
253: strcat( bufs[x.ans], ")");
254: strshift( bufs[x.ans], 1);
255: bufs[x.ans][0] = '(';
256: }
257: if(dest.ans == 0)
258: if(flag & 256)
259: dest = doit(p->in.left->in.op == 104?
260: p->in.left->in.left:
261: p->in.left, 0, 0, regmask & ~x.regmask);
262: else
263: return(x);
264: movexdest:
265: if(strcmp( bufs[x.ans], bufs[dest.ans]) == 0)
266: return(x);
267: if(flag & 4)
268: pr("#\tpush%c\t%s\n", type(p), bufs[x.ans]);
269: else
270: pr("#\tmov%c\t%s,%s\n", type(p), bufs[x.ans], bufs[dest.ans]);
271: dest.flag |= 1;
272: return(dest);
273: case 111:
274: s = doit(p->in.left, 2, 0, regmask);
275: regmask &= ~s.regmask;
276: t = doit(p->in.right, 2, 0, regmask);
277: if(t.flag & 1024) {
278: totemp(p, 0);
279: longjmp(back, 1);
280: }
281: pr("#\tcmp%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[t.ans]);
282: dest.ans = dest.regmask = 0;
283: dest.flag = 1;
284: return(dest);
285: case 59:
286: if(p->in.left->in.op == 108) {
287: if(dest.ans == 0) {
288: dest = allocreg(p, regmask);
289: }
290: (void) doit(p->in.left, 2, dest, regmask);
291: }
292: else
293: (void) doit(p->in.left, 0, 0, regmask);
294: s = doit(p->in.right, 2, dest, regmask);
295: if(flag & 8) {
296: dest.ans = 0;
297: i = (s.flag & (128|512|16));
298: j = s.regmask;
299: buf = bufs[s.ans];
300: goto convbuf;
301: }
302: return(s);
303: case 77:
304: s = doit(p->in.left, 2, 0, regmask);
305: if(dest.ans == 0)
306: if(s.flag & 16)
307: dest = s;
308: else
309: dest = allocreg(p, regmask & ~s.regmask);
310: pr("#\tmcom%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]);
311: dest.flag |= 1;
312: return(dest);
313: case 104:
314: if(p->in.left->in.op == 58 && p->in.left->in.left->in.op == (2+ 11)) {
315: if(dest.ans == 0) {
316: dest = allocreg(p, regmask);
317: s = doit(p->in.left, 2, dest, regmask);
318: }
319: else {
320: x = allocreg(p, regmask);
321: s = doit(p->in.left, 2, x, regmask & ~x.regmask);
322: }
323: }
324: else
325: s = doit(p->in.left, 2, 0, regmask);
326: regmask &= ~s.regmask;
327: if(childtype(p) == type(p))
328: return(s);
329: if(dest.ans == 0)
330: if(s.flag & 16)
331: dest = s;
332: else
333: dest = allocreg(p, regmask);
334: if(isunsigned(p->in.left) && incrsize(p) > incrsize(p->in.left)
335: && type(p) != 'f' && type(p) != 'd')
336: pp = "movz";
337: else
338: pp = "cvt";
339: pr("#\t%s%c%c\t%s,%s\n", pp, childtype(p), type(p), bufs[s.ans], bufs[dest.ans]);
340: dest.flag |= 1;
341: return(dest);
342: case 79:
343: i = -1;
344: pp = "sub";
345: incrop:
346: if(p->in.right->in.op != 4)
347: fflush((&_iob[1])), cerror("codegen! incrop not with ICON");
348: s = doit(p->in.left, 0, 0, regmask);
349: t = doit(p->in.right, 0, 0, 0);
350: if(flag & 2) {
351: if(dest.ans == 0)
352: dest = allocreg(p, regmask & ~s.regmask);
353: pr("#\tmov%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]);
354: if(t.flag & 64) {
355: if(i == 1)
356: pp = "inc";
357: else
358: pp = "dec";
359: pr("#\t%s%c\t%s\n", pp, childtype(p), bufs[s.ans]);
360: }
361: else
362: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p),
363: bufs[t.ans], bufs[s.ans]);
364: if(flag & 8) {
365: s = dest;
366: goto inreg;
367: }
368: dest.flag &= ~1;
369: return(dest);
370: }
371: if(t.flag & 64) {
372: if(i == 1)
373: pp = "inc";
374: else
375: pp = "dec";
376: pr("#\t%s%c\t%s\n", pp, childtype(p), bufs[s.ans]);
377: }
378: else
379: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), bufs[t.ans], bufs[s.ans]);
380: if(dest.ans) {
381: x = s;
382: goto movexdest;
383: }
384: s.flag |= 1;
385: return(s);
386: case 1+ 60:
387: flag |= 256;
388: case 60:
389:
390: if(!isunsigned(p->in.left)) {
391: if(p->in.left->in.op == 104 && type(p) == childtype(p->in.left)) {
392: p->in.left = p->in.left->in.left;
393: }
394: if(p->in.right->in.op == 104 && type(p) == childtype(p->in.right)) {
395: p->in.right = p->in.right->in.left;
396: }
397: pp = "div";
398: goto binop;
399: }
400: pp = "udiv";
401: unsdiv:
402: if(incrsize(p->in.right) != 4) {
403: snode.in.op = 104;
404: snode.in.left = p->in.right;
405: snode.in.type = 01000;
406: s = doit(&snode, 2|4, tostack(), regmask);
407: }
408: else
409: s = doit(p->in.right, 4, tostack(), regmask);
410: regmask &= ~s.regmask;
411: if(incrsize(p->in.left) != 4) {
412: snode.in.op = 104;
413: snode.in.left = p->in.left;
414: snode.in.type = 01000;
415: t = doit(&snode, 2|4, tostack(), regmask);
416: }
417: else
418: t = doit(p->in.left, 4, tostack(), regmask);
419: if(t.flag & 1024) {
420: totemp(p, 1);
421: longjmp(back, 1);
422: }
423: i = 2;
424: goto aftercall;
425: case 1+ 19:
426: flag |= 256;
427: case 19:
428: pp = "xor";
429: binop:
430: t = doit(p->in.left, 2, 0, regmask);
431: regmask &= ~t.regmask;
432: s = doit(p->in.right, 2, 0, regmask);
433: if(s.flag & 1024) {
434: totemp(p, 0);
435: longjmp(back, 1);
436: }
437: regmask &= ~s.regmask;
438: if(type(p) != childtype(p)) {
439: x = allocreg(p, regmask);
440: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), bufs[s.ans],
441: bufs[t.ans], bufs[x.ans]);
442: if(dest.ans == 0)
443: dest = x;
444: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p),
445: bufs[x.ans], bufs[dest.ans]);
446: dest.flag |= 1;
447: return(dest);
448: }
449: if(dest.ans == 0)
450: if((t.flag & 16) || (flag & 256)) {
451: twoop:
452: dest = t;
453: if(*pp == 'a' && (s.flag & 64))
454: pr("#\tinc%c\t%s\n", childtype(p), bufs[t.ans]);
455: else if(*pp == 's' && (s.flag & 64))
456: pr("#\tdec%c\t%s\n", childtype(p), bufs[t.ans]);
457: else
458: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p),
459: bufs[s.ans], bufs[t.ans]);
460: if(flag & 8)
461: goto binopaddr;
462: dest.flag |= 1;
463: return(dest);
464: }
465: else if(s.flag & 16)
466: dest = s;
467: else
468: dest = allocreg(p, regmask);
469: if((*pp == 'a' || *pp == 'm' || *pp == 'x' || *pp == 'b')
470: && strcmp( bufs[s.ans], bufs[dest.ans]) == 0) {
471: dest = s;
472: s = t;
473: t = dest;
474: goto twoop;
475: }
476: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), bufs[s.ans], bufs[t.ans], bufs[dest.ans]);
477: binopaddr:
478: if(flag & 8) {
479: if(dest.flag & 128) {
480: strcat( bufs[dest.ans], ")");
481: strshift( bufs[dest.ans], 1);
482: bufs[dest.ans][0] = '(';
483: return(dest);
484: }
485: if(dest.flag & 512) {
486: strshift( bufs[dest.ans], 1);
487: bufs[dest.ans][0] = '*';
488: dest.flag &= ~512;
489: return(dest);
490: }
491: dest.flag = 1024;
492: return(dest);
493: }
494: dest.flag |= 1;
495: return(dest);
496: case 103:
497:
498: s = doit(p->in.left, 0, 0, regmask);
499: if(dest.ans == 0)
500: dest = allocreg(p, regmask & ~s.regmask);
501: pr("#\text%sv\t$%d,$%d,%s,%s\n", isunsigned(p->in.left)? "z": "",
502: p->tn.rval/64, p->tn.rval%64, bufs[s.ans], bufs[dest.ans]);
503: dest.flag |= 1;
504: return(dest);
505: case 110:
506: s = doit(p->in.left, 1|2, 0, regmask);
507: pp = genjmp(p->bn.lop);
508: if(s.flag & 1)
509: pr("#\t%s\tL%d\n", pp, p->bn.label);
510: else
511: pr("#\ttst%c\t%s\n#\t%s\tL%d\n", childtype(p), bufs[s.ans],
512: pp, p->bn.label);
513: s.flag |= 1;
514: return(s);
515: case 108:
516: s = doit(p->in.left, flag, dest, regmask);
517: pr("#L%d:\n", p->bn.label);
518: return(s);
519: case 112:
520: (void) doit(p->in.left, 0, dest, regmask);
521: pr("#\tjbr\tL%d\n", p->bn.label);
522: s.ans = s.regmask = s.flag = 0;
523: return(s);
524: case 4:
525: if(p->tn.name)
526: if(p->tn.lval)
527: sprintf(buf, "%s+%d", p->tn.name, p->tn.lval);
528: else
529: sprintf(buf, "%s", p->tn.name);
530: else
531: sprintf(buf, "%d", p->tn.lval);
532: if(!(flag & 8)) {
533: strshift(buf, 1);;
534: buf[0] = '$';
535: }
536: i = 0;
537: if(p->tn.name == 0)
538: if(p->tn.lval == 0)
539: i = 32;
540: else if(p->tn.lval == 1)
541: i = 64;
542: j = 0;
543: convbuf:
544: if(dest.ans == 0) {
545: if(p->in.op == 4 || !(flag & 8)) {
546: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i; s.regmask = j; return(s);
547: }
548: if(i & 512) {
549: strshift(buf, 1);
550: buf[0] = '*';
551: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i & ~512; s.regmask = j; return(s);
552: }
553: if(i & 128) {
554: strcat(buf, ")");
555: strshift(buf, 1);
556: buf[0] = '(';
557: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i; s.regmask = j; return(s);
558: }
559: pp = buf;
560: buf += 64;
561: s = allocreg(p, regmask);
562: pr("#\tmov%c\t%s,%s\n", type(p), pp, bufs[s.ans]);
563: flag &= ~8;
564: goto inreg;
565: }
566: if(flag & 4)
567: if(p->in.type != 040)
568: pr("#\tpushl\t%s\n", buf);
569: else
570: pr("#\tmovd\t%s,%s\n", buf, bufs[dest.ans]);
571: else if(i & 32)
572: pr("#\tclr%c\t%s\n", type(p), bufs[dest.ans]);
573: else
574: pr("#\tmov%c\t%s,%s\n", type(p), buf, bufs[dest.ans]);
575: dest.flag |= 1;
576: return(dest);
577: case 78:
578: i = 1;
579: pp = "add";
580: goto incrop;
581: case 113:
582: s = doit(p->in.left, 8, 0, 0);
583: pr("#\t.long\t%s\n", bufs[s.ans]);
584: return(dest);
585: case 1+ 64:
586: flag |= 256;
587: case 64:
588: s = doit(p->in.left, 2, 0, regmask);
589: regmask &= ~s.flag;
590: t = doit(p->in.right, 2, 0, regmask);
591: if(t.flag & 1024) {
592: totemp(p, 0);
593: longjmp(back, 1);
594: }
595: regmask &= ~t.regmask;
596: if(dest.ans == 0)
597: if((s.flag & 16) || (flag & 256))
598: dest = s;
599: else
600: dest = allocreg(p, regmask);
601: pr("#\tashl\t%s,%s,%s\n", bufs[t.ans], bufs[s.ans], bufs[dest.ans]);
602: dest.flag |= 1;
603: return(dest);
604: case 1+ 8:
605: if(p->in.right->in.op == 4) {
606: i = -1;
607: pp = "sub";
608: flag &= ~2;
609: goto incrop;
610: }
611: flag |= 256;
612: case 8:
613: pp = "sub";
614: goto binop;
615: case 1+ 62:
616: flag |= 256;
617: if(p->in.left->in.op == 104 && !isunsigned(p)) {
618: snode = *p;
619: snode.in.left = p->in.left->in.left;
620: p = &snode;
621: }
622: case 62:
623: if(isunsigned(p)) {
624: pp = "urem";
625: goto unsdiv;
626: }
627: s = doit(p->in.left, 2, 0, regmask);
628: regmask &= ~s.regmask;
629: t = doit(p->in.right, 2, 0, regmask);
630: regmask &= ~t.regmask;
631: x = allocreg(p, regmask);
632: pr("#\tdiv%c3\t%s,%s,%s\n", childtype(p), bufs[t.ans], bufs[s.ans], bufs[x.ans]);
633: pr("#\tmul%c2\t%s,%s\n", childtype(p), bufs[t.ans], bufs[x.ans]);
634: pr("#\tsub%c3\t%s,%s,%s\n", childtype(p), bufs[x.ans], bufs[s.ans], bufs[x.ans]);
635: if(dest.ans)
636: goto movexdest;
637: if(flag & 256) {
638: dest = s;
639: goto movexdest;
640: }
641: x.flag |= 1;
642: return(x);
643: case 1+ 11:
644: flag |= 256;
645: case 11:
646: pp = "mul";
647: goto binop;
648: case 2:
649: if(p->tn.lval)
650: sprintf(buf, "%s+%d", p->tn.name, p->tn.lval);
651: else if(p->tn.name)
652: sprintf(buf, "%s", p->tn.name);
653: else
654: sprintf(buf, "0");
655: j = 0;
656: i = 512;
657: goto convbuf;
658: case 1+ 17:
659: flag |= 256;
660: case 17:
661: pp = "bis";
662: goto binop;
663: case 1+ 6:
664: if(p->in.right->in.op == 4) {
665: i = 1;
666: pp = "add";
667: flag &= ~2;
668: goto incrop;
669: }
670: flag |= 256;
671: case 6:
672: pp = "add";
673: goto binop;
674: case 94:
675: sprintf(buf, "r%d", p->tn.rval);
676: j = 0;
677: i = 128;
678: goto convbuf;
679: case 118: case 119:
680: x = reg0(p, 3);
681: x.regmask = 0;
682: if(dest.ans)
683: goto movexdest;
684: return(x);
685: case 120:
686: return(reg0(p, regmask));
687: case 1+ 66:
688: flag |= 256;
689: case 66:
690: s = doit(p->in.left, 2, 0, regmask);
691: regmask &= ~s.regmask;
692: if(dest.ans == 0)
693: if((flag & 256) || (s.flag & 16))
694: dest = s;
695: else
696: dest = allocreg(p, regmask);
697: dest.flag |= 1;
698: regmask &= ~dest.regmask;
699: if(p->in.right->in.op == 4 && (i = p->in.right->tn.lval) >= 0) {
700: pr("#\textv\t$%d,$%d,%s,%s\n", i, 32 - i, bufs[s.ans], bufs[dest.ans]);
701: return(dest);
702: }
703: t = doit(p->in.right, 2, 0, regmask);
704: regmask &= ~t.regmask;
705: x = allocreg(p, regmask);
706: pr("#\tmnegl\t%s,%s\n", bufs[t.ans], bufs[x.ans]);
707: pr("#\tashl\t%s,%s,%s\n", bufs[x.ans], bufs[s.ans], bufs[dest.ans]);
708: return(dest);
709: case (2+ 11):
710: switch(p->in.left->in.op) {
711: case 116:
712: case 117:
713: case 2:
714: s = doit(p->in.left, 2, 0, regmask);
715: sprintf(buf, "*%s", bufs[s.ans]);
716: j = i = 0;
717: goto convbuf;
718: case 94:
719: s = doit(p->in.left, 2, 0, regmask);
720: inreg:
721: if(s.flag & 128) {
722: sprintf(buf, "(%s)", bufs[s.ans]);
723: j = 0;
724: i = 512;
725: goto convbuf;
726: }
727: else if(s.flag & 512) {
728: sprintf(buf, "*%s", bufs[s.ans]);
729: j = 0;
730: i = 0;
731: goto convbuf;
732: }
733: else {
734: s.flag = 1024;
735: return(s);
736: }
737: }
738: q = p->in.left;
739: if(q->in.op == 78
740: && q->in.right->in.op == 4 && q->in.left->in.op == 94
741: && incrsize(p) == (int) q->in.right->tn.lval) {
742: s = doit(q->in.left, 2, 0, regmask);
743: sprintf(buf, "(%s)+", bufs[s.ans]);
744: i = 0;
745: j = s.regmask;
746: goto convbuf;
747: }
748: if(q->in.op == 6 && q->in.left->in.op == 64
749: && q->in.left->in.right->in.op == 4
750: && shiftsize(p) == (int) q->in.left->in.right->tn.lval) {
751: s = doit(q->in.left->in.left, 2, 0, regmask);
752: regmask &= ~s.regmask;
753: if(!(s.flag & 128)) {
754: x = allocreg(p, regmask);
755: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]);
756: regmask |= s.regmask;
757: regmask &= ~x.regmask;
758: s = x;
759: }
760: t = doit(q->in.right, 8, 0, regmask);
761: sprintf(buf, "%s[%s]", bufs[t.ans], bufs[s.ans]);
762: i = 0;
763: j = s.regmask;
764: goto convbuf;
765: }
766: if(q->in.op == 6
767: && (q->in.right->in.op == 4 || q->in.right->in.op == 2)) {
768: s = doit(q->in.left, 2, 0, regmask);
769: regmask &= ~s.regmask;
770: if(!(s.flag & 128)) {
771: x = allocreg(p, regmask);
772: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]);
773: regmask |= s.regmask;
774: regmask &= ~x.regmask;
775: s = x;
776: }
777: t = doit(q->in.right, 8, 0, regmask);
778: sprintf(buf, "%s(%s)", bufs[t.ans], bufs[s.ans]);
779: i = 512;
780: j = s.regmask;
781: goto convbuf;
782: }
783: if(q->in.op == 8 && q->in.right->in.op == 4) {
784: s = doit(q->in.left, 2, 0, regmask);
785: regmask &= ~s.regmask;
786: if(!(s.flag & 128)) {
787: x = allocreg(p, regmask);
788: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]);
789: regmask |= s.regmask;
790: regmask &= ~x.regmask;
791: s = x;
792: if(!(s.flag & 128)) {
793: s.flag = 1024;
794: return(s);
795: }
796: }
797: sprintf(buf, "%d(%s)", -q->in.right->tn.lval, bufs[s.ans]);
798: i = 512;
799: j = s.regmask;
800: goto convbuf;
801: }
802: if(q->in.op == 1+ 8
803: && q->in.right->in.op == 4 && q->in.left->in.op == 94
804: && incrsize(p) == (int) q->in.right->tn.lval) {
805: s = doit(q->in.left, 2, 0, regmask);
806: sprintf(buf, "-(%s)", bufs[s.ans]);
807: i = 0;
808: j = s.regmask;
809: goto convbuf;
810: }
811: if(q->in.op == 6 && q->in.left->in.op == 94
812: && q->in.right->in.op == 94) {
813: sprintf(buf, "(r%d)[r%d]", q->in.right->tn.rval,
814: q->in.left->tn.rval);
815: i = 0;
816: j = 0;
817: goto convbuf;
818: }
819: s = doit(p->in.left, 2, 0, regmask);
820: if(s.flag & 1024)
821: return(s);
822: regmask &= ~s.regmask;
823: if(s.flag & 512) {
824: sprintf(buf, "*%s", bufs[s.ans]);
825: i = 0;
826: j = s.regmask;
827: goto convbuf;
828: }
829: if(!(s.flag & 128)) {
830: x = allocreg(p, regmask);
831: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]);
832: regmask |= s.regmask;
833: regmask &= ~x.regmask;
834: s = x;
835: }
836: if(!(s.flag & 128)) {
837: s.flag = 1024;
838: return(s);
839: }
840: sprintf(buf, "(%s)", bufs[s.ans]);
841: i = 0;
842: j = s.regmask;
843: goto convbuf;
844: case 98:
845: if(p->stn.stsize/8 == 4) {
846: i = 'l';
847: stasg:
848: s = doit(p->in.right, 2|8, 0, regmask);
849: regmask &= ~s.regmask;
850: t = doit(p->in.left, 2|8, 0, regmask);
851: pr("#\tmov%c\t%s,%s\n", i, bufs[s.ans], bufs[t.ans]);
852: s.regmask = s.flag = 0;
853: return(s);
854: }
855: else if(p->stn.stsize/8 == 8) {
856: i = 'q';
857: goto stasg;
858: }
859: if(regmask != 0x3f) {
860: s.flag = 1024;
861: return(s);
862: }
863: s = doit(p->in.right, 2|8, 0, regmask);
864: regmask &= ~s.regmask;
865: t = doit(p->in.left, 2|8, 0, regmask);
866: pr("#\tmovc3\t$%d,%s,%s\n", p->stn.stsize/8, bufs[s.ans], bufs[t.ans]);
867: s.regmask = s.flag = 0;
868: return(s);
869: case 100:
870: goto call;
871: case 116:
872: sprintf(buf, "%d(fp)", p->tn.lval);
873: j = 0;
874: i = 512;
875: goto convbuf;
876: case 117:
877: sprintf(buf, "%d(ap)", p->tn.lval);
878: j = 0;
879: i = 512;
880: goto convbuf;
881: case 2+ 14:
882: s = doit(p->in.left, 0, 0, regmask);
883: regmask &= ~s.regmask;
884: if(dest.ans == 0) {
885: dest = allocreg(p, regmask);
886: }
887: if(flag & 4)
888: pr("#\tpushal\t%s\n", bufs[s.ans]);
889: else {
890: pr("#\tmova%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]);
891: }
892: if(flag & 8) {
893: if(dest.flag & 128) {
894: strcat( bufs[dest.ans], ")");
895: strshift( bufs[dest.ans], 1);
896: bufs[dest.ans][0] = '(';
897: }
898: else {
899: strshift( bufs[dest.ans], 1);
900: bufs[dest.ans][0] = '*';
901: }
902: }
903: return(dest);
904: case 2+ 70:
905: i = 0;
906: goto called;
907: case 2+ 8:
908: s = doit(p->in.left, 2, 0, regmask);
909: if(dest.ans == 0)
910: if(s.flag & 16)
911: dest = s;
912: else
913: dest = allocreg(p, regmask & ~s.regmask);
914: pr("#\tmneg%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]);
915: dest.flag |= 1;
916: return(dest);
917: case 2+ 100:
918: i = 0;
919: goto called;
920: case 58:
921: if(p->in.left->in.op == 120 && dest.ans) {
922: s = doit(p->in.right, 2, dest, regmask);
923: return(s);
924: }
925: if(p->in.left->in.op == 103) {
926: s = doit(p->in.left->in.left, 0, 0, regmask);
927: regmask &= ~s.regmask;
928: if(p->in.right->in.op == 58) {
929: x = allocreg(p->in.right, regmask);
930: t = doit(p->in.right, 2, x, regmask & ~x.regmask);
931: }
932: else
933: t = doit(p->in.right, 2, 0, regmask);
934: if(t.flag & 1024) {
935: totemp(p->in.left, 0);
936: longjmp(back, 1);
937: }
938: pr("#\tinsv\t%s,$%d,$%d,%s\n", bufs[t.ans], p->in.left->tn.rval/64,
939: p->in.left->tn.rval % 64, bufs[s.ans]);
940: t.flag |= 1;
941: return(t);
942: }
943: if(dest.ans && p->in.left->in.op == (2+ 11)) {
944: if(dest.flag & 16)
945: x = dest;
946: else
947: x = allocreg(p, regmask);
948: s = doit(p->in.right, 2, x, regmask);
949: regmask &= ~s.regmask;
950: assignit:
951: t = doit(p->in.left, 0, 0, regmask);
952: pr("#\tmov%c\t%s,%s\n", type(p), bufs[x.ans], bufs[t.ans]);
953: if(strcmp( bufs[x.ans], bufs[dest.ans]) == 0) {
954: dest.flag |= 1;
955: return(dest);
956: }
957: goto movexdest;
958: }
959: if(p->in.right->in.op == 119)
960: t = doit(p->in.left, 0, 0, regmask & ~3);
961: else
962: t = doit(p->in.left, 0, 0, regmask);
963: regmask &= ~t.regmask;
964: s = doit(p->in.right, 2, t, regmask);
965: if(s.flag & 1024) {
966:
967: if(dest.ans) {
968: regmask |= t.regmask;
969: s = doit(p->in.right, 2, t, regmask);
970: if(s.flag & 1024)
971: return(s);
972: }
973: asgwrite(p);
974: longjmp(back, 1);
975: }
976: if(dest.ans) {
977: x = s;
978: goto movexdest;
979: }
980: else if(flag & 8) {
981: i = (s.flag & (128|512|16));
982: j = s.regmask;
983: buf = bufs[s.ans];
984: goto convbuf;
985: }
986: s.flag |= 1;
987: return(s);
988: }
989: }
990: char *
991: genjmp(n)
992: {
993: switch(n) {
994: default:
995: return("jweird");
996: case 80:
997: return("jeql");
998: case 81:
999: return("jneq");
1000: case 85:
1001: return("jgtr");
1002: case 84:
1003: return("jgeq");
1004: case 83:
1005: return("jlss");
1006: case 82:
1007: return("jleq");
1008: case 89:
1009: return("jgtru");
1010: case 88:
1011: return("jgequ");
1012: case 87:
1013: return("jlssu");
1014: case 86:
1015: return("jlequ");
1016: }
1017: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.