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