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