![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 41BSD / cmd / pcc|
Return to local2.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / pcc |
1.1 root 1: static char *sccsid ="%W% (Berkeley) %G%";
2: # include "mfile2"
3: # include "ctype.h"
4: /* a lot of the machine dependent parts of the second pass */
5:
6: # define BITMASK(n) ((1L<<n)-1)
7:
8: where(c){
9: fprintf( stderr, "%s, line %d: ", filename, lineno );
10: }
11:
12: lineid( l, fn ) char *fn; {
13: /* identify line l and file fn */
14: printf( "# line %d, file %s\n", l, fn );
15: }
16:
17:
18: eobl2(){
19: OFFSZ spoff; /* offset from stack pointer */
20: #ifdef FORT
21: spoff = maxoff;
22: if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
23: spoff /= SZCHAR;
24: SETOFF(spoff,4);
25: #ifndef FLEXNAMES
26: printf( " .set .F%d,%ld\n", ftnno, spoff );
27: #else
28: /* SHOULD BE L%d ... ftnno but must change pc/f77 */
29: printf( " .set LF%d,%ld\n", ftnno, spoff );
30: #endif
31: #else
32: extern int ftlab1, ftlab2;
33:
34: spoff = maxoff;
35: if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
36: spoff /= SZCHAR;
37: SETOFF(spoff,4);
38: printf( "L%d:\n", ftlab1);
39: if( spoff!=0 )
40: if( spoff < 64 )
41: printf( " subl2 $%ld,sp\n", spoff);
42: else
43: printf( " movab -%ld(sp),sp\n", spoff);
44: printf( " jbr L%d\n", ftlab2);
45: #endif
46: maxargs = -1;
47: }
48:
49: struct hoptab { int opmask; char * opstring; } ioptab[] = {
50:
51: ASG PLUS, "add",
52: ASG MINUS, "sub",
53: ASG MUL, "mul",
54: ASG DIV, "div",
55: ASG OR, "bis",
56: ASG ER, "xor",
57: ASG AND, "bic",
58: PLUS, "add",
59: MINUS, "sub",
60: MUL, "mul",
61: DIV, "div",
62: OR, "bis",
63: ER, "xor",
64: AND, "bic",
65: -1, "" };
66:
67: hopcode( f, o ){
68: /* output the appropriate string from the above table */
69:
70: register struct hoptab *q;
71:
72: for( q = ioptab; q->opmask>=0; ++q ){
73: if( q->opmask == o ){
74: printf( "%s", q->opstring );
75: /* tbl
76: if( f == 'F' ) printf( "e" );
77: else if( f == 'D' ) printf( "d" );
78: tbl */
79: /* tbl */
80: switch( f ) {
81: case 'L':
82: case 'W':
83: case 'B':
84: case 'D':
85: case 'F':
86: printf("%c", tolower(f));
87: break;
88:
89: }
90: /* tbl */
91: return;
92: }
93: }
94: cerror( "no hoptab for %s", opst[o] );
95: }
96:
97: char *
98: rnames[] = { /* keyed to register number tokens */
99:
100: "r0", "r1",
101: "r2", "r3", "r4", "r5",
102: "r6", "r7", "r8", "r9", "r10", "r11",
103: "ap", "fp", "sp", "pc",
104:
105: };
106:
107: int rstatus[] = {
108: SAREG|STAREG, SAREG|STAREG,
109: SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
110: SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
111: SAREG, SAREG, SAREG, SAREG,
112:
113: };
114:
115: tlen(p) NODE *p;
116: {
117: switch(p->in.type) {
118: case CHAR:
119: case UCHAR:
120: return(1);
121:
122: case SHORT:
123: case USHORT:
124: return(2);
125:
126: case DOUBLE:
127: return(8);
128:
129: default:
130: return(4);
131: }
132: }
133:
134: mixtypes(p, q) NODE *p, *q;
135: {
136: register tp, tq;
137:
138: tp = p->in.type;
139: tq = q->in.type;
140:
141: return( (tp==FLOAT || tp==DOUBLE) !=
142: (tq==FLOAT || tq==DOUBLE) );
143: }
144:
145: prtype(n) NODE *n;
146: {
147: switch (n->in.type)
148: {
149: case DOUBLE:
150: printf("d");
151: return;
152:
153: case FLOAT:
154: printf("f");
155: return;
156:
157: case LONG:
158: case ULONG:
159: case INT:
160: case UNSIGNED:
161: printf("l");
162: return;
163:
164: case SHORT:
165: case USHORT:
166: printf("w");
167: return;
168:
169: case CHAR:
170: case UCHAR:
171: printf("b");
172: return;
173:
174: default:
175: if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type");
176: else {
177: printf("l");
178: return;
179: }
180: }
181: }
182:
183: zzzcode( p, c ) register NODE *p; {
184: register m;
185: CONSZ val;
186: switch( c ){
187:
188: case 'N': /* logical ops, turned into 0-1 */
189: /* use register given by register 1 */
190: cbgen( 0, m=getlab(), 'I' );
191: deflab( p->bn.label );
192: printf( " clrl %s\n", rnames[getlr( p, '1' )->tn.rval] );
193: deflab( m );
194: return;
195:
196: case 'I':
197: case 'P':
198: cbgen( p->in.op, p->bn.label, c );
199: return;
200:
201: case 'A':
202: {
203: register NODE *l, *r;
204:
205: if (xdebug) eprint(p, 0, &val, &val);
206: r = getlr(p, 'R');
207: if (optype(p->in.op) == LTYPE || p->in.op == UNARY MUL)
208: {
209: l = resc;
210: l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? DOUBLE : INT);
211: }
212: else
213: l = getlr(p, 'L');
214: if (r->in.op == ICON)
215: if(r->in.name[0] == '\0')
216: {
217: if (r->tn.lval == 0)
218: {
219: printf("clr");
220: prtype(l);
221: printf(" ");
222: adrput(l);
223: return;
224: }
225: if (r->tn.lval < 0 && r->tn.lval >= -63)
226: {
227: printf("mneg");
228: prtype(l);
229: r->tn.lval = -r->tn.lval;
230: goto ops;
231: }
232: r->in.type = (r->tn.lval < 0 ?
233: (r->tn.lval >= -128 ? CHAR
234: : (r->tn.lval >= -32768 ? SHORT
235: : INT )) : r->in.type);
236: r->in.type = (r->tn.lval >= 0 ?
237: (r->tn.lval <= 63 ? INT
238: : ( r->tn.lval <= 127 ? CHAR
239: : (r->tn.lval <= 255 ? UCHAR
240: : (r->tn.lval <= 32767 ? SHORT
241: : (r->tn.lval <= 65535 ? USHORT
242: : INT ))))) : r->in.type );
243: }
244: else
245: {
246: printf("moval");
247: printf(" ");
248: acon(r);
249: printf(",");
250: adrput(l);
251: return;
252: }
253:
254: if (l->in.op == REG && l->in.type != FLOAT && l->in.type != DOUBLE)
255: {
256: if( tlen(l) < tlen(r) )
257: {
258: if (!mixtypes(l,r))
259: {
260: !ISUNSIGNED(l->in.type)?
261: printf("cvt"):
262: printf("movz");
263: prtype(l);
264: printf("l");
265: goto ops;
266: }
267: else
268: {
269: printf("cvt");
270: prtype(r);
271: prtype(l);
272: printf(" ");
273: adrput(r);
274: printf(",");
275: adrput(l);
276: printf("cvt");
277: prtype(l);
278: printf("l");
279: printf(" ");
280: adrput(l);
281: printf(",");
282: adrput(l);
283: return;
284: }
285: }
286: else
287: {
288: l->in.type = INT;
289: }
290: }
291: if (!mixtypes(l,r))
292: {
293: if (tlen(l) == tlen(r))
294: {
295: printf("mov");
296: prtype(l);
297: goto ops;
298: }
299: else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type))
300: {
301: printf("movz");
302: }
303: else
304: {
305: printf("cvt");
306: }
307: }
308: else
309: {
310: printf("cvt");
311: }
312: prtype(r);
313: prtype(l);
314: ops:
315: printf(" ");
316: adrput(r);
317: printf(",");
318: adrput(l);
319: return;
320: }
321:
322: case 'B': /* get oreg value in temp register for left shift */
323: {
324: register NODE *r;
325: if (xdebug) eprint(p, 0, &val, &val);
326: r = p->in.right;
327: if( tlen(r) == sizeof(int) && r->in.type != FLOAT )
328: printf("movl");
329: else {
330: printf("cvt");
331: prtype(r);
332: printf("l");
333: }
334: return;
335: }
336:
337: case 'C': /* num words pushed on arg stack */
338: {
339: extern int gc_numbytes;
340: extern int xdebug;
341:
342: if (xdebug) printf("->%d<-",gc_numbytes);
343:
344: printf("$%d", gc_numbytes/(SZLONG/SZCHAR) );
345: return;
346: }
347:
348: case 'D': /* INCR and DECR */
349: zzzcode(p->in.left, 'A');
350: printf("\n ");
351:
352: case 'E': /* INCR and DECR, FOREFF */
353: if (p->in.right->tn.lval == 1)
354: {
355: printf("%s", (p->in.op == INCR ? "inc" : "dec") );
356: prtype(p->in.left);
357: printf(" ");
358: adrput(p->in.left);
359: return;
360: }
361: printf("%s", (p->in.op == INCR ? "add" : "sub") );
362: prtype(p->in.left);
363: printf("2 ");
364: adrput(p->in.right);
365: printf(",");
366: adrput(p->in.left);
367: return;
368:
369: case 'F': /* register type of right operand */
370: {
371: register NODE *n;
372: extern int xdebug;
373: register int ty;
374:
375: n = getlr( p, 'R' );
376: ty = n->in.type;
377:
378: if (xdebug) printf("->%d<-", ty);
379:
380: if ( ty==DOUBLE) printf("d");
381: else if ( ty==FLOAT ) printf("f");
382: else printf("l");
383: return;
384: }
385:
386: case 'L': /* type of left operand */
387: case 'R': /* type of right operand */
388: {
389: register NODE *n;
390: extern int xdebug;
391:
392: n = getlr ( p, c);
393: if (xdebug) printf("->%d<-", n->in.type);
394:
395: prtype(n);
396: return;
397: }
398:
399: case 'Z': /* complement mask for bit instr */
400: printf("$%ld", ~p->in.right->tn.lval);
401: return;
402:
403: case 'U': /* 32 - n, for unsigned right shifts */
404: printf("$%d", 32 - p->in.right->tn.lval );
405: return;
406:
407: case 'T': /* rounded structure length for arguments */
408: {
409: int size;
410:
411: size = p->stn.stsize;
412: SETOFF( size, 4);
413: printf("$%d", size);
414: return;
415: }
416:
417: case 'S': /* structure assignment */
418: {
419: register NODE *l, *r;
420: register size;
421:
422: if( p->in.op == STASG ){
423: l = p->in.left;
424: r = p->in.right;
425:
426: }
427: else if( p->in.op == STARG ){ /* store an arg into a temporary */
428: l = getlr( p, '3' );
429: r = p->in.left;
430: }
431: else cerror( "STASG bad" );
432:
433: if( r->in.op == ICON ) r->in.op = NAME;
434: else if( r->in.op == REG ) r->in.op = OREG;
435: else if( r->in.op != OREG ) cerror( "STASG-r" );
436:
437: size = p->stn.stsize;
438:
439: if( size <= 0 || size > 65535 )
440: cerror("structure size <0=0 or >65535");
441:
442: switch(size) {
443: case 1:
444: printf(" movb ");
445: break;
446: case 2:
447: printf(" movw ");
448: break;
449: case 4:
450: printf(" movl ");
451: break;
452: case 8:
453: printf(" movq ");
454: break;
455: default:
456: printf(" movc3 $%d,", size);
457: break;
458: }
459: adrput(r);
460: printf(",");
461: adrput(l);
462: printf("\n");
463:
464: if( r->in.op == NAME ) r->in.op = ICON;
465: else if( r->in.op == OREG ) r->in.op = REG;
466:
467: }
468: break;
469:
470: default:
471: cerror( "illegal zzzcode" );
472: }
473: }
474:
475: rmove( rt, rs, t ){
476: printf( " %s %s,%s\n",
477: (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")),
478: rnames[rs], rnames[rt] );
479: }
480:
481: struct respref
482: respref[] = {
483: INTAREG|INTBREG, INTAREG|INTBREG,
484: INAREG|INBREG, INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,
485: INTEMP, INTEMP,
486: FORARG, FORARG,
487: INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,
488: 0, 0 };
489:
490: setregs(){ /* set up temporary registers */
491: fregs = 6; /* tbl- 6 free regs on VAX (0-5) */
492: ;
493: }
494:
495: szty(t){ /* size, in registers, needed to hold thing of type t */
496: return( (t==DOUBLE||t==FLOAT) ? 2 : 1 );
497: }
498:
499: rewfld( p ) NODE *p; {
500: return(1);
501: }
502:
503: callreg(p) NODE *p; {
504: return( R0 );
505: }
506:
507: base( p ) register NODE *p; {
508: register int o = p->in.op;
509:
510: if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */
511: if( o==REG ) return( p->tn.rval );
512: if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON)
513: return( p->in.left->tn.rval );
514: if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
515: return( p->tn.rval + 0200*1 );
516: if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 );
517: if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 );
518: if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG
519: && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
520: return( p->in.left->in.left->tn.rval + 0200*(1+2) );
521: return( -1 );
522: }
523:
524: offset( p, tyl ) register NODE *p; int tyl; {
525:
526: if( tyl==1 && p->in.op==REG && (p->in.type==INT || p->in.type==UNSIGNED) ) return( p->tn.rval );
527: if( (p->in.op==LS && p->in.left->in.op==REG && (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
528: (p->in.right->in.op==ICON && p->in.right->in.name[0]=='\0')
529: && (1<<p->in.right->tn.lval)==tyl))
530: return( p->in.left->tn.rval );
531: return( -1 );
532: }
533:
534: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
535: register NODE *t;
536: register int i;
537: NODE *f;
538:
539: p->in.op = OREG;
540: f = p->in.left; /* have to free this subtree later */
541:
542: /* init base */
543: switch (q->in.op) {
544: case ICON:
545: case REG:
546: case OREG:
547: t = q;
548: break;
549:
550: case MINUS:
551: q->in.right->tn.lval = -q->in.right->tn.lval;
552: case PLUS:
553: t = q->in.right;
554: break;
555:
556: case INCR:
557: case ASG MINUS:
558: t = q->in.left;
559: break;
560:
561: case UNARY MUL:
562: t = q->in.left->in.left;
563: break;
564:
565: default:
566: cerror("illegal makeor2");
567: }
568:
569: p->tn.lval = t->tn.lval;
570: #ifndef FLEXNAMES
571: for(i=0; i<NCHNAM; ++i)
572: p->in.name[i] = t->in.name[i];
573: #else
574: p->in.name = t->in.name;
575: #endif
576:
577: /* init offset */
578: p->tn.rval = R2PACK( (b & 0177), o, (b>>7) );
579:
580: tfree(f);
581: return;
582: }
583:
584: canaddr( p ) NODE *p; {
585: register int o = p->in.op;
586:
587: if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
588: return(0);
589: }
590:
591: shltype( o, p ) register NODE *p; {
592: return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->in.left)) );
593: }
594:
595: flshape( p ) register NODE *p; {
596: return( p->in.op == REG || p->in.op == NAME || p->in.op == ICON ||
597: (p->in.op == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) );
598: }
599:
600: shtemp( p ) register NODE *p; {
601: if( p->in.op == STARG ) p = p->in.left;
602: return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) );
603: }
604:
605: shumul( p ) register NODE *p; {
606: register o;
607: extern int xdebug;
608:
609: if (xdebug) {
610: printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op);
611: printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval);
612: }
613:
614:
615: o = p->in.op;
616: if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM );
617:
618: if( ( o == INCR || o == ASG MINUS ) &&
619: ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) &&
620: p->in.right->in.name[0] == '\0' )
621: {
622: switch (p->in.left->in.type)
623: {
624: case CHAR|PTR:
625: case UCHAR|PTR:
626: o = 1;
627: break;
628:
629: case SHORT|PTR:
630: case USHORT|PTR:
631: o = 2;
632: break;
633:
634: case INT|PTR:
635: case UNSIGNED|PTR:
636: case LONG|PTR:
637: case ULONG|PTR:
638: case FLOAT|PTR:
639: o = 4;
640: break;
641:
642: case DOUBLE|PTR:
643: o = 8;
644: break;
645:
646: default:
647: if ( ISPTR(p->in.left->in.type) ) {
648: o = 4;
649: break;
650: }
651: else return(0);
652: }
653: return( p->in.right->tn.lval == o ? STARREG : 0);
654: }
655:
656: return( 0 );
657: }
658:
659: adrcon( val ) CONSZ val; {
660: printf( "$" );
661: printf( CONFMT, val );
662: }
663:
664: conput( p ) register NODE *p; {
665: switch( p->in.op ){
666:
667: case ICON:
668: acon( p );
669: return;
670:
671: case REG:
672: printf( "%s", rnames[p->tn.rval] );
673: return;
674:
675: default:
676: cerror( "illegal conput" );
677: }
678: }
679:
680: insput( p ) register NODE *p; {
681: cerror( "insput" );
682: }
683:
684: upput( p ) register NODE *p; {
685: cerror( "upput" );
686: }
687:
688: adrput( p ) register NODE *p; {
689: register int r;
690: /* output an address, with offsets, from p */
691:
692: if( p->in.op == FLD ){
693: p = p->in.left;
694: }
695: switch( p->in.op ){
696:
697: case NAME:
698: acon( p );
699: return;
700:
701: case ICON:
702: /* addressable value of the constant */
703: printf( "$" );
704: acon( p );
705: return;
706:
707: case REG:
708: printf( "%s", rnames[p->tn.rval] );
709: return;
710:
711: case OREG:
712: r = p->tn.rval;
713: if( R2TEST(r) ){ /* double indexing */
714: register int flags;
715:
716: flags = R2UPK3(r);
717: if( flags & 1 ) printf("*");
718: if( flags & 4 ) printf("-");
719: if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p);
720: if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] );
721: if( flags & 2 ) printf("+");
722: printf( "[%s]", rnames[R2UPK2(r)] );
723: return;
724: }
725: if( r == AP ){ /* in the argument region */
726: if( p->tn.lval <= 0 || p->in.name[0] != '\0' ) werror( "bad arg temp" );
727: printf( CONFMT, p->tn.lval );
728: printf( "(ap)" );
729: return;
730: }
731: if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p );
732: printf( "(%s)", rnames[p->tn.rval] );
733: return;
734:
735: case UNARY MUL:
736: /* STARNM or STARREG found */
737: if( tshape(p, STARNM) ) {
738: printf( "*" );
739: adrput( p->in.left);
740: }
741: else { /* STARREG - really auto inc or dec */
742: register NODE *q;
743:
744: /* tbl
745: p = p->in.left;
746: p->in.left->in.op = OREG;
747: if( p->in.op == INCR ) {
748: adrput( p->in.left );
749: printf( "+" );
750: }
751: else {
752: printf( "-" );
753: adrput( p->in.left );
754: }
755: tbl */
756: printf("%s(%s)%s", (p->in.left->in.op==INCR ? "" : "-"),
757: rnames[p->in.left->in.left->tn.rval],
758: (p->in.left->in.op==INCR ? "+" : "") );
759: p->in.op = OREG;
760: p->tn.rval = p->in.left->in.left->tn.rval;
761: q = p->in.left;
762: p->tn.lval = (p->in.left->in.op == INCR ? -p->in.left->in.right->tn.lval : 0);
763: #ifndef FLEXNAMES
764: p->in.name[0] = '\0';
765: #else
766: p->in.name = "";
767: #endif
768: tfree(q);
769: }
770: return;
771:
772: default:
773: cerror( "illegal address" );
774: return;
775:
776: }
777:
778: }
779:
780: acon( p ) register NODE *p; { /* print out a constant */
781:
782: if( p->in.name[0] == '\0' ){
783: printf( CONFMT, p->tn.lval);
784: }
785: else if( p->tn.lval == 0 ) {
786: #ifndef FLEXNAMES
787: printf( "%.8s", p->in.name );
788: #else
789: printf( "%s", p->in.name );
790: #endif
791: }
792: else {
793: #ifndef FLEXNAMES
794: printf( "%.8s+", p->in.name );
795: #else
796: printf( "%s+", p->in.name );
797: #endif
798: printf( CONFMT, p->tn.lval );
799: }
800: }
801:
802: /*
803: aacon( p ) register NODE *p; { /* print out a constant */
804: /*
805:
806: if( p->in.name[0] == '\0' ){
807: printf( CONFMT, p->tn.lval);
808: return( 0 );
809: }
810: else if( p->tn.lval == 0 ) {
811: #ifndef FLEXNAMES
812: printf( "$%.8s", p->in.name );
813: #else
814: printf( "$%s", p->in.name );
815: #endif
816: return( 1 );
817: }
818: else {
819: printf( "$(" );
820: printf( CONFMT, p->tn.lval );
821: printf( "+" );
822: #ifndef FLEXNAMES
823: printf( "%.8s)", p->in.name );
824: #else
825: printf( "%s)", p->in.name );
826: #endif
827: return(1);
828: }
829: }
830: */
831:
832: genscall( p, cookie ) register NODE *p; {
833: /* structure valued call */
834: return( gencall( p, cookie ) );
835: }
836:
837: /* tbl */
838: int gc_numbytes;
839: /* tbl */
840:
841: gencall( p, cookie ) register NODE *p; {
842: /* generate the call given by p */
843: register NODE *p1, *ptemp;
844: register temp, temp1;
845: register m;
846:
847: if( p->in.right ) temp = argsize( p->in.right );
848: else temp = 0;
849:
850: if( p->in.op == STCALL || p->in.op == UNARY STCALL ){
851: /* set aside room for structure return */
852:
853: if( p->stn.stsize > temp ) temp1 = p->stn.stsize;
854: else temp1 = temp;
855: }
856:
857: if( temp > maxargs ) maxargs = temp;
858: SETOFF(temp1,4);
859:
860: if( p->in.right ){ /* make temp node, put offset in, and generate args */
861: ptemp = talloc();
862: ptemp->in.op = OREG;
863: ptemp->tn.lval = -1;
864: ptemp->tn.rval = SP;
865: #ifndef FLEXNAMES
866: ptemp->in.name[0] = '\0';
867: #else
868: ptemp->in.name = "";
869: #endif
870: ptemp->in.rall = NOPREF;
871: ptemp->in.su = 0;
872: genargs( p->in.right, ptemp );
873: ptemp->in.op = FREE;
874: }
875:
876: p1 = p->in.left;
877: if( p1->in.op != ICON ){
878: if( p1->in.op != REG ){
879: if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){
880: if( p1->in.op != NAME ){
881: order( p1, INAREG );
882: }
883: }
884: }
885: }
886:
887: /*
888: if( p1->in.op == REG && p->tn.rval == R5 ){
889: cerror( "call register overwrite" );
890: }
891: */
892: /* tbl
893: setup gc_numbytes so reference to ZC works */
894:
895: gc_numbytes = temp;
896: /* tbl */
897:
898: p->in.op = UNARY CALL;
899: m = match( p, INTAREG|INTBREG );
900: /* tbl
901: switch( temp ) {
902: case 0:
903: break;
904: case 2:
905: printf( " tst (sp)+\n" );
906: break;
907: case 4:
908: printf( " cmp (sp)+,(sp)+\n" );
909: break;
910: default:
911: printf( " add $%d,sp\n", temp);
912: }
913: tbl */
914: return(m != MDONE);
915: }
916:
917: /* tbl */
918: char *
919: ccbranches[] = {
920: " jeql L%d\n",
921: " jneq L%d\n",
922: " jleq L%d\n",
923: " jlss L%d\n",
924: " jgeq L%d\n",
925: " jgtr L%d\n",
926: " jlequ L%d\n",
927: " jlssu L%d\n",
928: " jgequ L%d\n",
929: " jgtru L%d\n",
930: };
931: /* tbl */
932:
933: cbgen( o, lab, mode ) { /* printf conditional and unconditional branches */
934:
935: /* tbl */
936: if( o == 0 ) printf( " jbr L%d\n", lab );
937: /* tbl */
938: else {
939: if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
940: printf( ccbranches[o-EQ], lab );
941: }
942: }
943:
944: nextcook( p, cookie ) NODE *p; {
945: /* we have failed to match p with cookie; try another */
946: if( cookie == FORREW ) return( 0 ); /* hopeless! */
947: if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG );
948: if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
949: return( FORREW );
950: }
951:
952: lastchance( p, cook ) NODE *p; {
953: /* forget it! */
954: return(0);
955: }
956:
957: optim2( p ) register NODE *p; {
958: /* do local tree transformations and optimizations */
959:
960: register NODE *r;
961:
962: switch( p->in.op ) {
963:
964: case AND:
965: /* commute L and R to eliminate compliments and constants */
966: if( (p->in.left->in.op==ICON&&p->in.left->in.name[0]==0) || p->in.left->in.op==COMPL ) {
967: r = p->in.left;
968: p->in.left = p->in.right;
969: p->in.right = r;
970: }
971: case ASG AND:
972: /* change meaning of AND to ~R&L - bic on pdp11 */
973: r = p->in.right;
974: if( r->in.op==ICON && r->in.name[0]==0 ) { /* compliment constant */
975: r->tn.lval = ~r->tn.lval;
976: }
977: else if( r->in.op==COMPL ) { /* ~~A => A */
978: r->in.op = FREE;
979: p->in.right = r->in.left;
980: }
981: else { /* insert complement node */
982: p->in.right = talloc();
983: p->in.right->in.op = COMPL;
984: p->in.right->in.rall = NOPREF;
985: p->in.right->in.type = r->in.type;
986: p->in.right->in.left = r;
987: p->in.right->in.right = NULL;
988: }
989: break;
990:
991: }
992: }
993:
994: NODE * addroreg(l)
995: /* OREG was built in clocal()
996: * for an auto or formal parameter
997: * now its address is being taken
998: * local code must unwind it
999: * back to PLUS/MINUS REG ICON
1000: * according to local conventions
1001: */
1002: {
1003: cerror("address of OREG taken");
1004: }
1005:
1006:
1007:
1008: # ifndef ONEPASS
1009: main( argc, argv ) char *argv[]; {
1010: return( mainp2( argc, argv ) );
1011: }
1012: # endif
1013:
1014:
1015: /* added by jwf */
1016: struct functbl {
1017: int fop;
1018: TWORD ftype;
1019: char *func;
1020: } opfunc[] = {
1021: DIV, TANY, "udiv",
1022: MOD, TANY, "urem",
1023: ASG DIV, TANY, "udiv",
1024: ASG MOD, TANY, "urem",
1025: 0, 0, 0 };
1026:
1027: hardops(p) register NODE *p; {
1028: /* change hard to do operators into function calls. */
1029: register NODE *q;
1030: register struct functbl *f;
1031: register o;
1032: register TWORD t;
1033:
1034: o = p->in.op;
1035: t = p->in.type;
1036: if( t!=UNSIGNED && t!=ULONG ) return;
1037:
1038: for( f=opfunc; f->fop; f++ ) {
1039: if( o==f->fop ) goto convert;
1040: }
1041: return;
1042:
1043: /* need to rewrite tree for ASG OP */
1044: /* must change ASG OP to a simple OP */
1045: convert:
1046: if( asgop( o ) ) {
1047: q = talloc();
1048: switch( p->in.op ) {
1049: case ASG DIV:
1050: q->in.op = DIV;
1051: break;
1052: case ASG MOD:
1053: q->in.op = MOD;
1054: break;
1055: }
1056: q->in.rall = NOPREF;
1057: q->in.type = p->in.type;
1058: q->in.left = tcopy(p->in.left);
1059: q->in.right = p->in.right;
1060: p->in.op = ASSIGN;
1061: p->in.right = q;
1062: zappost(q->in.left); /* remove post-INCR(DECR) from new node */
1063: fixpre(q->in.left); /* change pre-INCR(DECR) to +/- */
1064: p = q;
1065:
1066: }
1067:
1068: /* build comma op for args to function */
1069: q = talloc();
1070: q->in.op = CM;
1071: q->in.rall = NOPREF;
1072: q->in.type = INT;
1073: q->in.left = p->in.left;
1074: q->in.right = p->in.right;
1075: p->in.op = CALL;
1076: p->in.right = q;
1077:
1078: /* put function name in left node of call */
1079: p->in.left = q = talloc();
1080: q->in.op = ICON;
1081: q->in.rall = NOPREF;
1082: q->in.type = INCREF( FTN + p->in.type );
1083: #ifndef FLEXNAMES
1084: strcpy( q->in.name, f->func );
1085: #else
1086: q->in.name = f->func;
1087: #endif
1088: q->tn.lval = 0;
1089: q->tn.rval = 0;
1090:
1091: return;
1092:
1093: }
1094:
1095: zappost(p) NODE *p; {
1096: /* look for ++ and -- operators and remove them */
1097:
1098: register o, ty;
1099: register NODE *q;
1100: o = p->in.op;
1101: ty = optype( o );
1102:
1103: switch( o ){
1104:
1105: case INCR:
1106: case DECR:
1107: q = p->in.left;
1108: p->in.right->in.op = FREE; /* zap constant */
1109: ncopy( p, q );
1110: q->in.op = FREE;
1111: return;
1112:
1113: }
1114:
1115: if( ty == BITYPE ) zappost( p->in.right );
1116: if( ty != LTYPE ) zappost( p->in.left );
1117: }
1118:
1119: fixpre(p) NODE *p; {
1120:
1121: register o, ty;
1122: o = p->in.op;
1123: ty = optype( o );
1124:
1125: switch( o ){
1126:
1127: case ASG PLUS:
1128: p->in.op = PLUS;
1129: break;
1130: case ASG MINUS:
1131: p->in.op = MINUS;
1132: break;
1133: }
1134:
1135: if( ty == BITYPE ) fixpre( p->in.right );
1136: if( ty != LTYPE ) fixpre( p->in.left );
1137: }
1138:
1139: myreader(p) register NODE *p; {
1140: walkf( p, hardops ); /* convert ops to function calls */
1141: canon( p ); /* expands r-vals for fileds */
1142: walkf( p, optim2 );
1143: /* jwf toff = 0; /* stack offset swindle */
1144: }
1145:
1146:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.