![[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 / pico|
Return to gen.c CVS log | Up to [Research Unix] / researchv10no / cmd / pico |
1.1 root 1: #include <stdio.h>
2: #include "pico.h"
3:
4: #define NJTAB 1000
5: #define NGTAB 40
6: #define NPTAB 200
7:
8: static char *jtab[NJTAB];
9: static int jtabi;
10: static int ninstr;
11: static int spoff;
12:
13: #define LJ 1
14: #define CJ 2
15: #define INF 100
16:
17: struct ptab
18: {
19: char *at;
20: char *to;
21: short del;
22: short flag;
23: };
24:
25: static struct ptab ptab[NPTAB];
26: static int ptabi;
27:
28: #define TO 1
29: #define AT 2
30: struct gtab
31: {
32: long name;
33: char *ato;
34: short flag;
35: };
36:
37: static struct gtab gtab[NGTAB];
38: static int gtabi;
39:
40: static char *p;
41:
42: #define MAXJ 0x7F
43: Node zero =
44: {
45: CONST
46: };
47: Node one =
48: {
49: CONST
50: };
51:
52: /*
53: * Addressing modes
54: */
55: #define _SP 0x7E /* -(sp) */
56: #define SPPLUS 0x8E /* (sp)+ */
57: #define OSP 0xAE /* x(SP) */
58: #define STARPC 0x9F /* *(pc)+ */
59: #define R0 0x50
60: #define I0 0x40
61: #define SHORTIM(c) c
62: #define LONGIM 0x8F /* 32 bit immediate */
63: #define R(x) (R0|(x))/* register var */
64: #define I(x) (I0|(x))/* indexed var */
65: /*
66: * Instructions
67: */
68: #define ADDL2 0xC0
69: #define ADDL3 0xC1
70: #define ASHL 0x78
71: #define BEQL 0x13
72: #define BICL2 0xCA
73: #define BICL3 0xCB
74: #define BGEQ 0x18
75: #define BGTR 0x14
76: #define BISL2 0xC8
77: #define BISL3 0xC9
78: #define BLEQ 0x15
79: #define BLSS 0x19
80: #define BNEQ 0x12
81: #define BRB 0x11
82: #define BRW 0x31
83: #define JSB 0x16
84: #define CALLS 0xFB
85: #define CLRL 0xD4
86: #define CMPL 0xD1
87: #define BITL 0xD3
88: #define MCOML 0xD2
89: #define MNEGL 0xCE
90: #define MOVL 0xD0
91: #define MOVW 0xB0
92: #define MOVB 0x90
93: #define MOVZBL 0x9A
94: #define CLRB 0x94
95: #define MULL2 0xC4
96: #define MULL3 0xC5
97: #define PUSHL 0xDD
98: #define RSB 0x05
99: #define SUBL2 0xC2
100: #define SUBL3 0xC3
101: #define TSTL 0xD5
102: #define XORL2 0xCC
103: #define XORL3 0xCD
104: #define DIVL2 0xC6
105: #define DIVL3 0xC7
106: #define JMP 0x17
107:
108: #define stufflong(c) *((int *)p)=(c), p+=sizeof(long)
109: #define stuffword(c) *((short *)p)=(c), p+=sizeof(short)
110:
111: #define TOOMANY 6 /* r6 is not available for scratch */
112:
113: char *program;
114: extern char seetree, optim;
115:
116: compile(n, progr)
117: Node *n;
118: char *progr;
119: {
120: register fd;
121:
122: program = progr;
123: one.arg = 1;
124: if (seetree && n) ptree(n, "ORIGINAL");
125: if (optim)
126: { rewrite(n, 1);
127: if (seetree) ptree(n, "OPTIMIZED");
128: }
129: gencode(n);
130: if((fd=creat("/tmp/pico.code", 0666))>=0)
131: { write(fd, program, p-program);
132: close(fd);
133: }
134: }
135:
136: gencode(n)
137: Node *n;
138: {
139: spoff = 0;
140: ninstr = 0;
141: jtabi = 0;
142: ptabi = 0;
143: gtabi = 0;
144: p = program;
145: codegen(n, 0, 1, 0);
146: emitins(RSB);
147: addptab();
148: if(spoff != 0)
149: yyerror("phase error in spoff");
150: }
151:
152: testgen(n, used, dest, true)
153: Node *n;
154: {
155: int j;
156:
157: j = BNEQ;
158: if(!true)
159: j = BEQL;
160: switch(n->type) {
161: default:
162: codegen(n, used, dest, 0);
163: break;
164:
165: case OCALL:
166: case CCALL:
167: codegen(n, used, dest, 0);
168: if(dest == 1) {
169: emitins(TSTL);
170: emitreg(dest);
171: }
172: break;
173:
174: case CONST:
175: case VAR:
176: case REG:
177: case OARG:
178: emitins(TSTL);
179: codegen(n, used, 0, 0);
180: break;
181:
182: case CONDI:
183: markj(0);
184: testgen(n->other, used, dest, 1);
185: markj(0);
186: testgen(n->right, used, dest, true);
187: markj(0);
188: markj(BRB);
189: patchj(2);
190: markj(0);
191: testgen(n->left, used, dest, true);
192: patchj(1);
193: combj(0);
194: combj(1);
195: return;
196:
197: case ONE:
198: case OLE:
199: case OGE:
200: case OEQ:
201: case OLT:
202: case OGT:
203: case OAND:
204: j = compareop(n, used, dest, true);
205: break;
206:
207: case ONOT:
208: testgen(n->left, used, dest, !true);
209: return;
210:
211: case OANDAND:
212: case OOROR:
213: if((n->type==OANDAND) ^ true) {
214: testgen(n->left, used, dest, true);
215: testgen(n->right, used, dest, true);
216: return;
217: }
218: markj(0);
219: testgen(n->left, used, dest, !true);
220: markj(0);
221: testgen(n->right, used, dest, true);
222: patchj(1);
223: combj(0);
224: return;
225:
226: case OCOMMA:
227: codegen(n->left, used, dest, 0);
228: testgen(n->right, used, dest, true);
229: return;
230: }
231: markj(j);
232: }
233:
234: patchj(bn)
235: { int i, l;
236:
237: jtab[jtabi] = 0;
238: l = jbn(bn);
239: for(i=l+1; jtab[i]; i++) {
240: ptab[ptabi].at = jtab[i];
241: ptab[ptabi].to = p;
242: ptab[ptabi].del = 0;
243: ptab[ptabi].flag = 0;
244: if(jtab[i][-1] != BRB)
245: ptab[ptabi].flag |= CJ;
246: ptabi++;
247: if(ptabi >= NPTAB)
248: yyerror("NPTAB too small");
249: }
250: while(i < jtabi)
251: jtab[l++] = jtab[i++];
252: jtabi = l;
253: }
254:
255: pcmp(p1, p2)
256: struct ptab *p1, *p2;
257: {
258: return(p1->at - p2->at);
259: }
260:
261: addptab()
262: { char *q;
263: int i, j, f, d;
264:
265: for(i=0; i<gtabi; i++)
266: if(gtab[i].flag & AT)
267: { gtab[i].flag = 0;
268: for(j=0; j<gtabi; j++)
269: if(gtab[j].flag & TO && gtab[i].name == gtab[j].name)
270: { ptab[ptabi].at = gtab[i].ato;
271: ptab[ptabi].to = gtab[j].ato;
272: ptab[ptabi].del = 0;
273: ptab[ptabi].flag = 0;
274: ptabi++;
275: if(ptabi >= NPTAB)
276: yyerror("NPTAB too small");
277: break;
278: }
279: if (j == gtabi)
280: yyerror("label not declared");
281: }
282:
283: ptab[ptabi].at = program;
284: ptab[ptabi].to = p;
285: ptab[ptabi].del = 0;
286: ptab[ptabi].flag = LJ;
287: ptabi++;
288: qsort(ptab, ptabi, sizeof ptab[0], pcmp);
289: loop:
290: f = 0;
291: for(i=0; i<ptabi; i++) {
292: if(ptab[i].flag & LJ)
293: continue;
294: d = ptab[i].to - ptab[i].at - 1;
295: if(d < 0)
296: d = -d;
297: d += ptab[i].del;
298: if(d >= MAXJ) {
299: f++;
300: ptab[i].flag |= LJ;
301: for(j=0; j<ptabi; j++)
302: if(betwn(ptab[i].at, ptab[j])) {
303: ptab[j].del += 1;
304: if(ptab[i].flag & CJ)
305: ptab[j].del += 2;
306: }
307: }
308: }
309: if(f)
310: goto loop;
311: q = p;
312: p += ptab[0].del;
313: for(;;) {
314: *--p = *--q;
315: if(q > ptab[ptabi-1].at)
316: continue;
317: if(q <= program)
318: break;
319: ptabi--;
320: d = ptab[ptabi].to - ptab[ptabi].at - 1;
321: if(ptab[ptabi].to > ptab[ptabi].at)
322: d += ptab[ptabi].del;
323: else
324: d -= ptab[ptabi].del;
325: f = ptab[ptabi].flag;
326: if((f & LJ) == 0) {
327: *p = d;
328: continue;
329: }
330: p--; q--;
331: *(short *)p = d;
332: *--p = BRW;
333: if((f & CJ) == 0)
334: continue;
335: *--p = 3;
336: *--p = invrbr(*q & 0xFF);
337: ninstr++;
338: }
339: if(p != q)
340: yyerror("long jump phase error");
341: p = ptab[0].to + ptab[0].del;
342: }
343:
344: betwn(p, j)
345: char *p;
346: struct ptab j;
347: {
348:
349: if(j.to > j.at) {
350: if(p > j.at && p < j.to)
351: return 1;
352: return 0;
353: }
354: if(p >= j.to && p <= j.at)
355: return 1;
356: return 0;
357: }
358:
359: combj(bn)
360: {
361: int i, l;
362:
363: l = jbn(bn);
364: i = l+1;
365: while(i < jtabi)
366: jtab[l++] = jtab[i++];
367: jtabi = l;
368: }
369:
370: jbn(bn)
371: {
372: int i;
373:
374: i = jtabi;
375: while(bn >= 0) {
376: for(i--; jtab[i]; i--)
377: ;
378: bn--;
379: }
380: return i;
381: }
382:
383: markj(j)
384: {
385:
386: if(jtabi >= NJTAB)
387: yyerror("NJTAB too small");
388: if(j == 0) {
389: jtab[jtabi++] = 0;
390: return;
391: }
392: emitins(j);
393: jtab[jtabi++] = p;
394: *p++ = 0;
395: }
396:
397: codegen(n, used, dest, brgen)
398: Node *n;
399: {
400: long c;
401: int o;
402:
403: markj(0);
404: if(p-program > NPROG-10)
405: yyerror("NPROG too small");
406:
407: if(n)
408: switch(n->type)
409: {
410: default:
411: printf("unknown type = %d\n", n->type);
412: yyerror("unknown opcode in codegen");
413: break;
414:
415: case LABL:
416: if(gtabi >= NGTAB)
417: yyerror("NGTAB too small");
418: gtab[gtabi].name = n->arg;
419: gtab[gtabi].ato = p;
420: gtab[gtabi].flag = TO;
421: gtabi++;
422: codegen(n->left, used, dest, brgen);
423: break;
424:
425: case GOTO:
426: emitins(BRB);
427: if(gtabi >= NGTAB)
428: yyerror("NGTAB too small");
429: gtab[gtabi].name = n->arg;
430: gtab[gtabi].ato = p;
431: gtab[gtabi].flag = AT;
432: gtabi++;
433: *p++ = 0;
434: break;
435:
436: case CONSTB:
437: if(n->arg & ~63)
438: if(!dest) {
439: *p++ = LONGIM;
440: *p++ = n->arg;
441: break;
442: }
443: case CONST:
444: if(dest) {
445: if(n->arg == 0) {
446: emitins(CLRL);
447: emitreg(dest);
448: break;
449: }
450: emitins(MOVL);
451: codegen(n, used, 0, 0);
452: emitreg(dest);
453: break;
454: }
455: emitcon(n->arg);
456: break;
457:
458: case VAR:
459: if(dest) {
460: emitins(MOVL);
461: codegen(n, used, 0, 0);
462: emitreg(dest);
463: break;
464: }
465: emitabs(n->arg);
466: break;
467:
468: case OARG:
469: if(dest) {
470: emitins(MOVL);
471: codegen(n, used, 0, 0);
472: emitreg(dest);
473: break;
474: }
475: *p++ = OSP;
476: emitcon((n->arg+1)*4 + spoff);
477: break;
478:
479: case REG:
480: if(dest) {
481: emitins(MOVL);
482: codegen(n, used, 0, 0);
483: emitreg(dest);
484: break;
485: }
486: *p++ = R(n->arg);
487: break;
488:
489: case CCALL:
490: case OCALL:
491: for(o=0; o<used; o++) {
492: emitins(MOVL);
493: *p++ = R(o);
494: *p++ = _SP;
495: spoff += 4;
496: }
497: c = pushargs(n->left);
498: if(n->type == CCALL) {
499: emitins(CALLS);
500: emitcon(c);
501: emitabs(n->arg);
502: } else {
503: emitins(JSB);
504: emitabs(n->arg);
505: if(c) {
506: emitins(ADDL2);
507: emitcon(c*4);
508: *p++ = R(0XE);
509: }
510: }
511: spoff -= 4*c;
512: if(dest != 1) {
513: emitins(MOVL);
514: *p++ = R(0);
515: *p++ = R(dest-1);
516: }
517: for(o=used-1; o>=0; o--) {
518: emitins(MOVL);
519: *p++ = SPPLUS;
520: *p++ = R(o);
521: spoff -= 4;
522: }
523: break;
524:
525: case CONDI:
526: markj(0);
527: if(!n->left) {
528: testgen(n->other, used, dest, 1);
529: codegen(n->right, used, dest, 0);
530: combj(0);
531: break;
532: }
533: if(!n->right) {
534: testgen(n->other, used, dest, 0);
535: codegen(n->left, used, dest, 0);
536: combj(0);
537: break;
538: }
539: testgen(n->other, used, dest, 1);
540: codegen(n->right, used, dest, 1);
541: patchj(1);
542: codegen(n->left, used, dest, 0);
543: combj(0);
544: break;
545:
546: case OADD:
547: binop(1, ADDL3, ADDL2, n, used, dest);
548: break;
549:
550: case OMUL:
551: if(n->right->type == CONST) {
552: c = n->right->arg;
553: if(c >= 2 && c <= 4) {
554: if(n->left->type == REG) {
555: emitins(ADDL3);
556: codegen(n->left, used, 0, 0);
557: codegen(n->left, used, 0, 0);
558: } else {
559: codegen(n->left, used, dest, 0);
560: emitins(ADDL3);
561: emitreg(dest);
562: emitreg(dest);
563: }
564: if(c == 3) {
565: *p++ = _SP;
566: emitins(ADDL3);
567: *p++ = SPPLUS;
568: if(n->left->type == REG)
569: codegen(n->left, used, 0, 0);
570: else
571: emitreg(dest);
572: }
573: if(c == 4) {
574: emitreg(dest);
575: emitins(ADDL3);
576: emitreg(dest);
577: emitreg(dest);
578: }
579: emitreg(dest);
580: break;
581: }
582: }
583: binop(1, MULL3, MULL2, n, used, dest);
584: break;
585:
586: case OPOW:
587: if(n->right->type == CONST) {
588: c = n->right->arg;
589: if(c >= 2 && c <= 4) {
590: if(n->left->type == REG) {
591: emitins(MULL3);
592: codegen(n->left, used, 0, 0);
593: codegen(n->left, used, 0, 0);
594: } else {
595: codegen(n->left, used, dest, 0);
596: emitins(MULL3);
597: emitreg(dest);
598: emitreg(dest);
599: }
600: if(c == 3) {
601: *p++ = _SP;
602: emitins(MULL2);
603: *p++ = SPPLUS;
604: }
605: if(c == 4) {
606: emitreg(dest);
607: emitins(MULL3);
608: emitreg(dest);
609: emitreg(dest);
610: }
611: emitreg(dest);
612: break;
613: }
614: }
615: yyerror("POW not implemented");
616: break;
617:
618: case OXOR:
619: binop(1, XORL3, XORL2, n, used, dest);
620: break;
621:
622: case OOR:
623: binop(1, BISL3, BISL2, n, used, dest);
624: break;
625:
626: case OISUB:
627: invert(n, OSUB);
628: case OSUB:
629: binop(0, SUBL3, SUBL2, n, used, dest);
630: break;
631:
632: case OIDIV:
633: invert(n, ODIV);
634: case ODIV:
635: binop(0, DIVL3, DIVL2, n, used, dest);
636: break;
637:
638: case OBIC:
639: binop(0, BICL3, BICL2, n, used, dest);
640: break;
641:
642: case OAND:
643: binop(2, BICL3, BICL2, n, used, dest);
644: break;
645:
646: case ONEG:
647: unop(MCOML, n->left, used, dest);
648: break;
649:
650: case OMINUS:
651: unop(MNEGL, n->left, used, dest);
652: break;
653:
654: case OLSH:
655: if(n->right->type == CONST) {
656: c = n->right->arg;
657: if(c >= 1 && c <= 2) {
658: if(n->left->type == REG) {
659: emitins(ADDL3);
660: codegen(n->left, used, 0, 0);
661: codegen(n->left, used, 0, 0);
662: } else {
663: codegen(n->left, used, dest, 0);
664: emitins(ADDL3);
665: emitreg(dest);
666: emitreg(dest);
667: }
668: if(c == 2) {
669: emitreg(dest);
670: emitins(ADDL3);
671: emitreg(dest);
672: emitreg(dest);
673: }
674: emitreg(dest);
675: break;
676: }
677: n->right->type = CONSTB;
678: binop(0, ASHL, 0, n, used, dest);
679: n->right->type = CONST;
680: break;
681: }
682: binop(0, ASHL, 0, n, used, dest);
683: break;
684:
685: case OCOMMA:
686: codegen(n->left, used, dest, 0);
687: codegen(n->right, used, dest, 0);
688: break;
689:
690: case OLT:
691: case OLE:
692: case OEQ:
693: case ONE:
694: case OGT:
695: case OGE:
696: case ONOT:
697: case OOROR:
698: case OANDAND:
699: markj(0);
700: testgen(n, used, dest, 1);
701: codegen(&zero, used, dest, 1);
702: patchj(1);
703: codegen(&one, used, dest, 0);
704: combj(0);
705: break;
706:
707: case ORETURN:
708: codegen(n->left, 0, 1, 0);
709: emitins(RSB);
710: break;
711:
712: case OASS:
713: if(complex(n->left) == 0) {
714: codegen(n->right, used, dest, 0);
715: emitins(MOVL);
716: emitreg(dest);
717: codegen(n->left, used, 0, 0);
718: break;
719: }
720: o = n->left->type;
721: if(o != DEREFB && o != DEREFL && o != DEREFS)
722: { fprintf(stderr, "o == %d -> %d: ", OASS, o);
723: yyerror("assignment to non-lvalue");
724: }
725: if(complex(n->left->left))
726: yyerror("index of non-lvalue");
727: if(o == DEREFB)
728: o = MOVB;
729: else if (o == DEREFL)
730: o = MOVL;
731: else
732: o = MOVW;
733: codegen(n->right, used, dest, 0);
734: if(n->left->right) {
735: if(n->left->right->type == REG) {
736: emitins(o);
737: emitreg(dest);
738: *p++ = I(n->left->right->arg);
739: } else {
740: codegen(n->left->right, used+1, used+2, 0);
741: emitins(o);
742: emitreg(dest);
743: *p++ = I(used+2-1);
744: }
745: codegen(n->left->left, used, 0, 0);
746: break;
747: }
748: emitins(o);
749: emitreg(dest);
750: codegen(n->left->left, used, 0, 0);
751: break;
752:
753: case DEREFL:
754: case DEREFS:
755: case DEREFB:
756: o = n->type;
757: if(o == DEREFB)
758: o = MOVZBL;
759: else if (o == DEREFL)
760: o = MOVL;
761: else
762: o = MOVW;
763: if(complex(n->left))
764: yyerror("index of non-lvalue");
765: if(n->right) {
766: if(n->right->type == REG) {
767: emitins(o);
768: *p++ = I(n->right->arg);
769: } else {
770: codegen(n->right, used, dest, 0);
771: emitins(o);
772: *p++ = I(dest-1);
773: }
774: } else {
775: emitins(o);
776: }
777: codegen(n->left, used, 0, 0);
778: emitreg(dest);
779: break;
780:
781: case COMP:
782: switch(listcount(n->left)) {
783: case 1:
784: movsp((Node *)0, 1, used, dest);
785: movsp(n->left, 3, used, dest);
786: break;
787: case 2:
788: movsp(n->left->right, 1, used, dest);
789: movsp(n->left->left, 3, used, dest);
790: break;
791: case 3:
792: movsp((Node *)0, 1, used, dest);
793: movsp(n->left->right->right, 1, used, dest);
794: movsp(n->left->right->left, 1, used, dest);
795: movsp(n->left->left, 1, used, dest);
796: break;
797: case 4:
798: movsp(n->left->right->right->right, 1, used, dest);
799: movsp(n->left->right->right->left, 1, used, dest);
800: movsp(n->left->right->left, 1, used, dest);
801: movsp(n->left->left, 1, used, dest);
802: break;
803: default:
804: yyerror("[] must have 1<=n<=4 args");
805: }
806: emitins(MOVL);
807: *p++ = SPPLUS;
808: emitreg(dest);
809: spoff -= 4;
810: break;
811: }
812: if(brgen)
813: markj(BRB);
814: else
815: patchj(0);
816: }
817:
818: emitcon(c)
819: {
820:
821: if((c & ~63) == 0) {
822: *p++ = SHORTIM(c);
823: return;
824: }
825: *p++ = LONGIM;
826: stufflong(c);
827: }
828:
829: emitabs(c)
830: {
831:
832: *p++ = STARPC;
833: stufflong(c);
834: }
835:
836: pushargs(n)
837: Node *n;
838: {
839: register c;
840:
841: if(!n)
842: return 0;
843: if(n->type == ACOMMA) {
844: c = pushargs(n->right);
845: c += pushargs(n->left);
846: return c;
847: }
848: if(complex(n)) {
849: codegen(n, 0, 1, 0);
850: emitins(MOVL);
851: *p++ = R(0);
852: } else {
853: emitins(MOVL);
854: codegen(n, 0, 0, 0);
855: }
856: *p++ = _SP;
857: spoff += 4;
858: return 1;
859: }
860:
861: invert(n, o)
862: Node *n;
863: {
864: n->other = n->right;
865: n->right = n->left;
866: n->left = n->other;
867: n->other = 0;
868: n->type = o;
869: }
870:
871: listcount(n)
872: Node *n;
873: {
874: register i;
875: for(i=1; n->type==ACOMMA; i++, n=n->right)
876: ;
877: return i;
878: }
879:
880: movsp(n, count, used, dest)
881: Node *n;
882: {
883: register i, c;
884: if(n==0) { /* push 255 */
885: emitins(MOVB);
886: *p++ = LONGIM;
887: *p++ = 255;
888: *p++ = _SP;
889: spoff += 1;
890: return;
891: }
892: c = complex(n);
893: for(i=0; i<count; i++) {
894: if(c == 0) {
895: if(n->type == CONST) {
896: if(n->arg == 0) {
897: emitins(CLRB);
898: *p++ = _SP;
899: spoff += 1;
900: continue;
901: }
902: n->type = CONSTB;
903: }
904: emitins(MOVB);
905: codegen(n, used, 0, 0);
906: *p++ = _SP;
907: spoff += 1;
908: continue;
909: }
910: if(i == 0)
911: codegen(n, used, dest, 0);
912: emitins(MOVB);
913: emitreg(dest);
914: *p++ = _SP;
915: spoff += 1;
916: }
917: }
918:
919: binop(comm, threeaddr, twoaddr, n, used, dest)
920: Node *n;
921: {
922: int cl, cr;
923:
924: cl = complex(n->left);
925: cr = complex(n->right);
926: if(cl == 0 && cr == 0)
927: if(comm != 2 && threeaddr) {
928: emitins(threeaddr);
929: codegen(n->right, used, 0, 0);
930: codegen(n->left, used, 0, 0);
931: emitreg(dest);
932: return;
933: }
934: if(cr == 0) {
935: if(comm == 2) { /* OAND hack */
936: unop(MCOML, n->left, used, dest);
937: emitins(threeaddr);
938: emitreg(dest);
939: codegen(n->right, used, 0, 0);
940: emitreg(dest);
941: return;
942: }
943: codegen(n->left, used, dest, 0);
944: if(twoaddr) {
945: emitins(twoaddr);
946: codegen(n->right, used, 0, 0);
947: } else {
948: emitins(threeaddr);
949: codegen(n->right, used, 0, 0);
950: emitreg(dest);
951: }
952: emitreg(dest);
953: return;
954: }
955: if(cl == 0) {
956: if(comm == 2) { /* OAND hack */
957: unop(MCOML, n->right, used, dest);
958: emitins(threeaddr);
959: emitreg(dest);
960: codegen(n->left, used, 0, 0);
961: emitreg(dest);
962: return;
963: }
964: codegen(n->right, used, dest, 0);
965: if(comm && twoaddr) {
966: emitins(twoaddr);
967: } else {
968: emitins(threeaddr);
969: emitreg(dest);
970: }
971: codegen(n->left, used, 0, 0);
972: emitreg(dest);
973: return;
974: }
975: if(cl >= cr) {
976: codegen(n->left, used, dest, 0);
977: codegen(n->right, used+1, used+2, 0);
978: if(comm == 2) { /* OAND hack */
979: emitins(MCOML);
980: emitreg(used+2);
981: emitreg(used+2);
982: }
983: if(twoaddr) {
984: emitins(twoaddr);
985: emitreg(used+2);
986: } else {
987: emitins(threeaddr);
988: emitreg(used+2);
989: emitreg(dest);
990: }
991: emitreg(dest);
992: return;
993: }
994: codegen(n->right, used, dest, 0);
995: codegen(n->left, used+1, used+2, 0);
996: if(comm == 2) { /* OAND hack */
997: emitins(MCOML);
998: emitreg(used+2);
999: emitreg(used+2);
1000: }
1001: if(comm && twoaddr) {
1002: emitins(twoaddr);
1003: } else {
1004: emitins(threeaddr);
1005: emitreg(dest);
1006: }
1007: emitreg(used+2);
1008: emitreg(dest);
1009: }
1010:
1011: compareop(n, used, dest, true)
1012: Node *n;
1013: {
1014: int o;
1015: int cl, cr;
1016:
1017: cl = complex(n->left);
1018: if(n->right == Z) {
1019: if(cl == 0) {
1020: emitins(TSTL);
1021: codegen(n->left, used, 0, 0);
1022: goto out;
1023: }
1024: codegen(n->left, used, dest, 0);
1025: o = n->left->type;
1026: if(o == OCALL || o == CCALL)
1027: if(dest == 1) {
1028: emitins(TSTL);
1029: emitreg(dest);
1030: }
1031: goto out;
1032: }
1033: cr = complex(n->right);
1034: o = CMPL;
1035: if(n->type == OAND)
1036: o = BITL;
1037: if(cl == 0 && cr == 0) {
1038: emitins(o);
1039: codegen(n->left, used, 0, 0);
1040: codegen(n->right, used, 0, 0);
1041: goto out;
1042: }
1043: if(cr == 0) {
1044: codegen(n->left, used, dest, 0);
1045: emitins(o);
1046: emitreg(dest);
1047: codegen(n->right, used, 0, 0);
1048: goto out;
1049: }
1050: if(cl == 0) {
1051: codegen(n->right, used, dest, 0);
1052: emitins(o);
1053: codegen(n->left, used, 0, 0);
1054: emitreg(dest);
1055: goto out;
1056: }
1057: if(cl >= cr) {
1058: codegen(n->left, used, dest, 0);
1059: codegen(n->right, used+1, used+2, 0);
1060: emitins(o);
1061: emitreg(dest);
1062: emitreg(used+2);
1063: goto out;
1064: }
1065: codegen(n->right, used, dest, 0);
1066: codegen(n->left, used+1, used+2, 0);
1067: emitins(o);
1068: emitreg(used+2);
1069: emitreg(dest);
1070:
1071: out:
1072: switch(n->type)
1073: {
1074: case ONE:
1075: case OAND: o = BNEQ; break;
1076: case OEQ: o = BEQL; break;
1077: case OLT: o = BLSS; break;
1078: case OLE: o = BLEQ; break;
1079: case OGE: o = BGEQ; break;
1080: case OGT: o = BGTR; break;
1081: default: yyerror("unknown compare");
1082: }
1083: if(!true)
1084: o = invrbr(o);
1085: return o;
1086: }
1087:
1088: invrbr(o)
1089: {
1090: switch(o)
1091: {
1092: case BNEQ: o = BEQL; break;
1093: case BEQL: o = BNEQ; break;
1094: case BLSS: o = BGEQ; break;
1095: case BLEQ: o = BGTR; break;
1096: case BGEQ: o = BLSS; break;
1097: case BGTR: o = BLEQ; break;
1098: case BRB: o = BRW; break;
1099: default: yyerror("unknown branch");
1100: }
1101: return o;
1102: }
1103:
1104: unop(inst, n, used, dest)
1105: Node *n;
1106: {
1107: int c;
1108: c = complex(n);
1109: if(c == 0) {
1110: emitins(inst);
1111: codegen(n, used, 0, 0);
1112: emitreg(dest);
1113: return;
1114: }
1115: codegen(n, used, dest, 0);
1116: emitins(inst);
1117: emitreg(dest);
1118: emitreg(dest);
1119: }
1120:
1121: complex(n)
1122: Node *n;
1123: {
1124: int cl, cr;
1125:
1126: switch(n->type) {
1127: case CONST:
1128: case CONSTB:
1129: case VAR:
1130: case REG:
1131: case OARG:
1132: case GOTO:
1133: return 0;
1134:
1135: case OCALL:
1136: case CCALL:
1137: return INF;
1138:
1139: case OADD:
1140: case OMUL:
1141: case OPOW:
1142: case OXOR:
1143: case OOR:
1144: case OSUB:
1145: case OISUB:
1146: case OBIC:
1147: case OAND:
1148: case OIDIV:
1149: case ODIV:
1150: case OLT:
1151: case OLE:
1152: case OEQ:
1153: case ONE:
1154: case OGT:
1155: case OGE:
1156: case OLSH:
1157: case DEREFB:
1158: case DEREFS:
1159: case DEREFL:
1160: cl = complex(n->left);
1161: cr = 0;
1162: if(n->right)
1163: cr = complex(n->right);
1164: if(cl == cr)
1165: return cl+1;
1166: if(cl > cr)
1167: return cl;
1168: return cr;
1169:
1170: case LABL:
1171: case ORETURN:
1172: cl = complex(n->left);
1173: if(cl == 0)
1174: cl++;
1175: return cl;
1176:
1177: case OASS:
1178: cl = complex(n->left);
1179: cr = complex(n->right);
1180: if(cl >= cr)
1181: return cl+1;
1182: return cr;
1183:
1184: case CONDI:
1185: cl = complex(n->left);
1186: cr = complex(n->right);
1187: if(cl < cr)
1188: cl = cr;
1189: cr = complex(n->other);
1190: if(cl < cr)
1191: cl = cr;
1192: if(cl == 0)
1193: cl++;
1194: return cl;
1195:
1196: case OANDAND:
1197: case OOROR:
1198: case OCOMMA:
1199: case ACOMMA:
1200: cl = complex(n->left);
1201: cr = complex(n->right);
1202: if(cl < cr)
1203: cl = cr;
1204: if(cl == 0)
1205: cl++;
1206: return cl;
1207:
1208: case ONEG:
1209: case ONOT:
1210: case OMINUS:
1211: case COMP:
1212: cl = complex(n->left);
1213: if(cl == 0)
1214: cl++;
1215: return cl;
1216: }
1217: yyerror("unknown operator in complex");
1218: return 0;
1219: }
1220:
1221: emitins(o)
1222: {
1223: *p++ = o;
1224: ninstr++;
1225: }
1226:
1227: emitreg(dest)
1228: {
1229: if(dest>=TOOMANY)
1230: yyerror("TOOMANY too small");
1231: *p++ = R(dest-1);
1232: }
1233:
1234: ptree(n, s)
1235: Node *n;
1236: char *s;
1237: {
1238: printf("== %s ==\n", s);
1239: prtree(n, 1, 0);
1240: }
1241:
1242: prtree(n, f, d)
1243: Node *n;
1244: { int i;
1245:
1246: if (f)
1247: for(i=0; i<d; i++)
1248: printf(" ");
1249: f = 0;
1250: d++;
1251: switch(n->type) {
1252: case LABL: printf("Lb%d\n", n->arg); break;
1253: case GOTO: printf("Gt%d\n", n->arg); return;
1254: case OCALL:
1255: case CCALL: printf("()%d\n", n->arg); f = 1; break;
1256: case REG: printf("R%d\n", n->arg); return;
1257: case VAR: printf("V%d\n", n->arg); return;
1258: case OARG: printf("A%d\n", n->arg); return;
1259: case CONST: printf("C%d\n", n->arg); return;
1260: case CONDI: printf("? "); prtree(n->other, f, d); f = 1; break;
1261: case COMP: printf("[]"); break;
1262: case ORETURN: printf("rt"); break;
1263: case DEREFB: printf("b*"); break;
1264: case DEREFS: printf("s*"); break;
1265: case DEREFL: printf("l*"); break;
1266: case OADD: printf("+ "); break;
1267: case OAND: printf("& "); break;
1268: case OANDAND: printf("&&"); break;
1269: case OASS: printf(":="); break;
1270: case OBIC: printf("&~"); break;
1271: case ACOMMA: printf(", "); break;
1272: case OCOMMA: printf("; "); break;
1273: case ODIV: printf("/ "); break;
1274: case OEQ: printf("=="); break;
1275: case OGE: printf(">="); break;
1276: case OGT: printf("> "); break;
1277: case OLE: printf("<="); break;
1278: case OLSH: printf("<<"); break;
1279: case OLT: printf("< "); break;
1280: case OMINUS: printf("u-"); break;
1281: case OMUL: printf("* "); break;
1282: case ONE: printf("!="); break;
1283: case ONEG: printf("~ "); break;
1284: case ONOT: printf("! "); break;
1285: case OOR: printf("| "); break;
1286: case OOROR: printf("||"); break;
1287: case OPOW: printf("**"); break;
1288: case OSUB: printf("- "); break;
1289: case OISUB: printf("-i"); break;
1290: case OXOR: printf("^ "); break;
1291: default: printf("@"); break;
1292: }
1293: if (n->left) { prtree(n->left, f, d); f = 1; }
1294: if (n->right) { prtree(n->right, f, d); f = 1; }
1295: if (!f) printf("\n");
1296: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.