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