![[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] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe|
Return to local2.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)local2.c 1.11 (Berkeley) 6/4/87";
3: #endif
4:
5: # include "pass2.h"
6: # include <ctype.h>
7:
8: # define putstr(s) fputs((s), stdout)
9: # define ISCHAR(p) (p->in.type == UCHAR || p->in.type == CHAR)
10:
11: # ifdef FORT
12: int ftlab1, ftlab2;
13: # endif
14: /* a lot of the machine dependent parts of the second pass */
15:
16: # define BITMASK(n) ((1L<<n)-1)
17:
18: # ifndef ONEPASS
19: where(c){
20: fprintf( stderr, "%s, line %d: ", filename, lineno );
21: }
22: # endif
23:
24: lineid( l, fn ) char *fn; {
25: /* identify line l and file fn */
26: printf( "# line %d, file %s\n", l, fn );
27: }
28:
29: int ent_mask;
30:
31: eobl2(){
32: register OFFSZ spoff; /* offset from stack pointer */
33: #ifndef FORT
34: extern int ftlab1, ftlab2;
35: #endif
36:
37: spoff = maxoff;
38: spoff /= SZCHAR;
39: SETOFF(spoff,4);
40: #ifdef FORT
41: #ifndef FLEXNAMES
42: printf( " .set .F%d,%d\n", ftnno, spoff );
43: #else
44: /* SHOULD BE L%d ... ftnno but must change pc/f77 */
45: printf( " .set LF%d,%d\n", ftnno, spoff );
46: #endif
47: printf( " .set LWM%d,0x%x\n", ftnno, ent_mask&0x1ffc|0x1000);
48: #else
49: printf( " .set L%d,0x%x\n", ftnno, ent_mask&0x1ffc);
50: printf( "L%d:\n", ftlab1);
51: if( maxoff > AUTOINIT )
52: printf( " subl3 $%d,fp,sp\n", spoff);
53: printf( " jbr L%d\n", ftlab2);
54: #endif
55: ent_mask = 0;
56: maxargs = -1;
57: }
58:
59: struct hoptab { int opmask; char * opstring; } ioptab[] = {
60:
61: PLUS, "add",
62: MINUS, "sub",
63: MUL, "mul",
64: DIV, "div",
65: MOD, "div",
66: OR, "or",
67: ER, "xor",
68: AND, "and",
69: -1, "" };
70:
71: hopcode( f, o ){
72: /* output the appropriate string from the above table */
73:
74: register struct hoptab *q;
75:
76: if(asgop(o))
77: o = NOASG o;
78: for( q = ioptab; q->opmask>=0; ++q ){
79: if( q->opmask == o ){
80: if(f == 'E')
81: printf( "e%s", q->opstring);
82: else
83: printf( "%s%c", q->opstring, tolower(f));
84: return;
85: }
86: }
87: cerror( "no hoptab for %s", opst[o] );
88: }
89:
90: char *
91: rnames[] = { /* keyed to register number tokens */
92:
93: "r0", "r1",
94: "r2", "r3", "r4", "r5",
95: "r6", "r7", "r8", "r9", "r10", "r11",
96: "r12", "fp", "sp", "pc",
97: };
98:
99: /* output register name and update entry mask */
100: char *
101: rname(r)
102: register int r;
103: {
104:
105: ent_mask |= 1<<r;
106: return(rnames[r]);
107: }
108:
109: int rstatus[] = {
110: SAREG|STAREG, SAREG|STAREG,
111: SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
112: SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
113: SAREG, SAREG, SAREG, SAREG,
114: };
115:
116: tlen(p) NODE *p;
117: {
118: switch(p->in.type) {
119: case CHAR:
120: case UCHAR:
121: return(1);
122:
123: case SHORT:
124: case USHORT:
125: return(2);
126:
127: case DOUBLE:
128: return(8);
129:
130: default:
131: return(4);
132: }
133: }
134:
135: anyfloat(p, q)
136: NODE *p, *q;
137: {
138: register TWORD tp, tq;
139:
140: tp = p->in.type;
141: tq = q->in.type;
142: return (tp == FLOAT || tp == DOUBLE || tq == FLOAT || tq == DOUBLE);
143: }
144:
145: prtype(n) NODE *n;
146: {
147: switch (n->in.type)
148: {
149:
150: case DOUBLE:
151: putchar('d');
152: return;
153:
154: case FLOAT:
155: putchar('f');
156: return;
157:
158: case INT:
159: case UNSIGNED:
160: putchar('l');
161: return;
162:
163: case SHORT:
164: case USHORT:
165: putchar('w');
166: return;
167:
168: case CHAR:
169: case UCHAR:
170: putchar('b');
171: return;
172:
173: default:
174: if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type");
175: else {
176: putchar('l');
177: return;
178: }
179: }
180: }
181:
182: zzzcode( p, c ) register NODE *p; {
183: register int m;
184: int val;
185: switch( c ){
186:
187: case 'N': /* logical ops, turned into 0-1 */
188: /* use register given by register 1 */
189: cbgen( 0, m=getlab(), 'I' );
190: deflab( p->bn.label );
191: printf( " clrl %s\n", rname(getlr( p, '1' )->tn.rval) );
192: deflab( m );
193: return;
194:
195: case 'P':
196: cbgen( p->in.op, p->bn.label, c );
197: return;
198:
199: case 'A': /* assignment and load (integer only) */
200: {
201: register NODE *l, *r;
202:
203: if (xdebug) eprint(p, 0, &val, &val);
204: r = getlr(p, 'R');
205: if (optype(p->in.op) == LTYPE || p->in.op == UNARY MUL) {
206: l = resc;
207: l->in.type = INT;
208: } else
209: l = getlr(p, 'L');
210: if(r->in.type==FLOAT || r->in.type==DOUBLE
211: || l->in.type==FLOAT || l->in.type==DOUBLE)
212: cerror("float in ZA");
213: if (r->in.op == ICON)
214: if(r->in.name[0] == '\0') {
215: if (r->tn.lval == 0) {
216: putstr("clr");
217: prtype(l);
218: putchar('\t');
219: adrput(l);
220: return;
221: }
222: if (r->tn.lval < 0 && r->tn.lval >= -63) {
223: putstr("mneg");
224: prtype(l);
225: r->tn.lval = -r->tn.lval;
226: goto ops;
227: }
228: #ifdef MOVAFASTER
229: } else {
230: putstr("movab\t");
231: acon(r);
232: putchar(',');
233: adrput(l);
234: return;
235: #endif MOVAFASTER
236: }
237:
238: if (l->in.op == REG) {
239: if( tlen(l) < tlen(r) ) {
240: putstr(!ISUNSIGNED(l->in.type)?
241: "cvt": "movz");
242: prtype(l);
243: putchar('l');
244: goto ops;
245: } else
246: l->in.type = INT;
247: }
248: if (tlen(l) == tlen(r)) {
249: putstr("mov");
250: prtype(l);
251: goto ops;
252: } else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type))
253: putstr("movz");
254: else
255: putstr("cvt");
256: prtype(r);
257: prtype(l);
258: ops:
259: putchar('\t');
260: adrput(r);
261: putchar(',');
262: adrput(l);
263: return;
264: }
265:
266: case 'B': /* get oreg value in temp register for shift */
267: {
268: register NODE *r;
269: if (xdebug) eprint(p, 0, &val, &val);
270: r = p->in.right;
271: if( tlen(r) == sizeof(int) && r->in.type != FLOAT )
272: putstr("movl");
273: else {
274: putstr(ISUNSIGNED(r->in.type) ? "movz" : "cvt");
275: prtype(r);
276: putchar('l');
277: }
278: return;
279: }
280:
281: case 'C': /* num bytes pushed on arg stack */
282: {
283: extern int gc_numbytes;
284: extern int xdebug;
285:
286: if (xdebug) printf("->%d<-",gc_numbytes);
287:
288: printf("call%c $%d",
289: (p->in.left->in.op==ICON && gc_numbytes<60)?'f':'s',
290: gc_numbytes+4);
291: /* dont change to double (here's the only place to catch it) */
292: if(p->in.type == FLOAT)
293: rtyflg = 1;
294: return;
295: }
296:
297: case 'D': /* INCR and DECR */
298: zzzcode(p->in.left, 'A');
299: putstr("\n ");
300:
301: case 'E': /* INCR and DECR, FOREFF */
302: if (p->in.right->tn.lval == 1)
303: {
304: putstr(p->in.op == INCR ? "inc" : "dec");
305: prtype(p->in.left);
306: putchar('\t');
307: adrput(p->in.left);
308: return;
309: }
310: putstr(p->in.op == INCR ? "add" : "sub");
311: prtype(p->in.left);
312: putstr("2 ");
313: adrput(p->in.right);
314: putchar(',');
315: adrput(p->in.left);
316: return;
317:
318: case 'F': /* masked constant for fields */
319: printf(ACONFMT, (p->in.right->tn.lval&((1<<fldsz)-1))<<fldshf);
320: return;
321:
322: case 'H': /* opcode for shift */
323: if(p->in.op == LS || p->in.op == ASG LS)
324: putstr("shll");
325: else if(ISUNSIGNED(p->in.left->in.type))
326: putstr("shrl");
327: else
328: putstr("shar");
329: return;
330:
331: case 'L': /* type of left operand */
332: case 'R': /* type of right operand */
333: {
334: register NODE *n;
335: extern int xdebug;
336:
337: n = getlr ( p, c);
338: if (xdebug) printf("->%d<-", n->in.type);
339:
340: prtype(n);
341: return;
342: }
343:
344: case 'M': { /* initiate ediv for mod and unsigned div */
345: register char *r;
346: m = getlr(p, '1')->tn.rval;
347: r = rname(m);
348: printf("\tclrl\t%s\n\tmovl\t", r);
349: adrput(p->in.left);
350: printf(",%s\n", rname(m+1));
351: if(!ISUNSIGNED(p->in.type)) { /* should be MOD */
352: m = getlab();
353: printf("\tjgeq\tL%d\n\tmnegl\t$1,%s\n", m, r);
354: deflab(m);
355: }
356: return;
357: }
358:
359: case 'T': { /* rounded structure length for arguments */
360: int size = p->stn.stsize;
361: SETOFF( size, 4);
362: printf("movab -%d(sp),sp", size);
363: return;
364: }
365:
366: case 'S': /* structure assignment */
367: stasg(p);
368: break;
369:
370: case 'X': /* multiplication for short and char */
371: if (ISUNSIGNED(p->in.left->in.type))
372: printf("\tmovz");
373: else
374: printf("\tcvt");
375: zzzcode(p, 'L');
376: printf("l\t");
377: adrput(p->in.left);
378: printf(",");
379: adrput(&resc[0]);
380: printf("\n");
381: if (ISUNSIGNED(p->in.right->in.type))
382: printf("\tmovz");
383: else
384: printf("\tcvt");
385: zzzcode(p, 'R');
386: printf("l\t");
387: adrput(p->in.right);
388: printf(",");
389: adrput(&resc[1]);
390: printf("\n");
391: return;
392:
393: case 'U': /* SCONV */
394: case 'V': /* SCONV with FORCC */
395: sconv(p, c == 'V');
396: break;
397:
398: case 'Z':
399: p = p->in.right;
400: switch (p->in.type) {
401: case SHORT: {
402: short w = p->tn.lval;
403: p->tn.lval = w;
404: break;
405: }
406: case CHAR: {
407: char c = p->tn.lval;
408: p->tn.lval = c;
409: break;
410: }
411: }
412: printf("$%d", p->tn.lval);
413: break;
414:
415: default:
416: cerror( "illegal zzzcode" );
417: }
418: }
419:
420: #define MOVB(dst, src, off) { \
421: putstr("\tmovb\t"); upput(src, off); putchar(','); \
422: upput(dst, off); putchar('\n'); \
423: }
424: #define MOVW(dst, src, off) { \
425: putstr("\tmovw\t"); upput(src, off); putchar(','); \
426: upput(dst, off); putchar('\n'); \
427: }
428: #define MOVL(dst, src, off) { \
429: putstr("\tmovl\t"); upput(src, off); putchar(','); \
430: upput(dst, off); putchar('\n'); \
431: }
432: /*
433: * Generate code for a structure assignment.
434: */
435: stasg(p)
436: register NODE *p;
437: {
438: register NODE *l, *r;
439: register int size;
440:
441: switch (p->in.op) {
442: case STASG: /* regular assignment */
443: l = p->in.left;
444: r = p->in.right;
445: break;
446: case STARG: /* place arg on the stack */
447: l = getlr(p, '3');
448: r = p->in.left;
449: break;
450: default:
451: cerror("STASG bad");
452: /*NOTREACHED*/
453: }
454: /*
455: * Pun source for use in code generation.
456: */
457: switch (r->in.op) {
458: case ICON:
459: r->in.op = NAME;
460: break;
461: case REG:
462: r->in.op = OREG;
463: break;
464: default:
465: cerror( "STASG-r" );
466: /*NOTREACHED*/
467: }
468: size = p->stn.stsize;
469: if (size <= 0 || size > 65535)
470: cerror("structure size out of range");
471: /*
472: * Generate optimized code based on structure size
473: * and alignment properties....
474: */
475: switch (size) {
476:
477: case 1:
478: putstr("\tmovb\t");
479: optimized:
480: adrput(r);
481: putchar(',');
482: adrput(l);
483: putchar('\n');
484: break;
485:
486: case 2:
487: if (p->stn.stalign != 2) {
488: MOVB(l, r, SZCHAR);
489: putstr("\tmovb\t");
490: } else
491: putstr("\tmovw\t");
492: goto optimized;
493:
494: case 4:
495: if (p->stn.stalign != 4) {
496: if (p->stn.stalign != 2) {
497: MOVB(l, r, 3*SZCHAR);
498: MOVB(l, r, 2*SZCHAR);
499: MOVB(l, r, 1*SZCHAR);
500: putstr("\tmovb\t");
501: } else {
502: MOVW(l, r, SZSHORT);
503: putstr("\tmovw\t");
504: }
505: } else
506: putstr("\tmovl\t");
507: goto optimized;
508:
509: case 6:
510: if (p->stn.stalign != 2)
511: goto movblk;
512: MOVW(l, r, 2*SZSHORT);
513: MOVW(l, r, 1*SZSHORT);
514: putstr("\tmovw\t");
515: goto optimized;
516:
517: case 8:
518: if (p->stn.stalign == 4) {
519: MOVL(l, r, SZLONG);
520: putstr("\tmovl\t");
521: goto optimized;
522: }
523: /* fall thru...*/
524:
525: default:
526: movblk:
527: /*
528: * Can we ever get a register conflict with R1 here?
529: */
530: putstr("\tmovab\t");
531: if(r->in.op == OREG && r->tn.rval == R1)
532: {
533: adrput(r);
534: printf(",r0\n\tmovab\t");
535: adrput(l);
536: putstr(",r1\n");
537: }
538: else
539: {
540: adrput(l);
541: putstr(",r1\n\tmovab\t");
542: adrput(r);
543: printf(",r0\n");
544: }
545: printf("\tmovl\t$%d,r2\n\tmovblk\n", size);
546: rname(R2);
547: break;
548: }
549: /*
550: * Reverse above pun for reclaim.
551: */
552: if (r->in.op == NAME)
553: r->in.op = ICON;
554: else if (r->in.op == OREG)
555: r->in.op = REG;
556: }
557:
558: /*
559: * Output the address of the second item in the
560: * pair pointed to by p.
561: */
562: upput(p, size)
563: register NODE *p;
564: {
565: CONSZ save;
566:
567: if (p->in.op == FLD)
568: p = p->in.left;
569: switch (p->in.op) {
570:
571: case NAME:
572: case OREG:
573: save = p->tn.lval;
574: p->tn.lval += size/SZCHAR;
575: adrput(p);
576: p->tn.lval = save;
577: break;
578:
579: case REG:
580: if (size == SZLONG) {
581: putstr(rname(p->tn.rval+1));
582: break;
583: }
584: /* fall thru... */
585:
586: default:
587: cerror("illegal upper address op %s size %d",
588: opst[p->tn.op], size);
589: /*NOTREACHED*/
590: }
591: }
592:
593: /*
594: * Generate code for storage conversions.
595: */
596: sconv(p, forcc)
597: NODE *p;
598: {
599: register NODE *l, *r;
600: register wfrom, wto;
601: int oltype;
602:
603: l = getlr(p, '1');
604: oltype = l->in.type, l->in.type = r->in.type;
605: r = getlr(p, 'L');
606: wfrom = tlen(r), wto = tlen(l);
607: if (wfrom == wto) /* e.g. int -> unsigned */
608: goto done;
609: /*
610: * Conversion in registers requires care
611: * as cvt and movz instruction don't work
612: * as expected (they end up as plain mov's).
613: */
614: if (l->in.op == REG && r->in.op == REG) {
615: if ((wfrom < wto && ISUNSIGNED(r->in.type)) ||
616: (wto < wfrom && ISUNSIGNED(l->in.type))) {
617: /* unsigned, mask */
618: if (r->tn.rval != l->tn.rval) {
619: printf("\tandl3\t$%d,", (1<<(wto*SZCHAR))-1);
620: adrput(r);
621: putchar(',');
622: } else
623: printf("\tandl2\t$%d,", (1<<(wto*SZCHAR))-1);
624: adrput(l);
625: } else { /* effect sign-extend */
626: printf("\tpushl\t"); adrput(r);
627: printf("\n\tcvt"); prtype(l);
628: printf("l\t%d(sp),", sizeof (int) - wto); adrput(l);
629: printf("\n\tmovab\t4(sp),sp");
630: }
631: /*
632: * If condition codes are required then we must generate a
633: * test of the appropriate type.
634: */
635: if (forcc) {
636: printf("\n\tcmp");
637: prtype(l);
638: putchar('\t');
639: adrput(l);
640: printf(",$0");
641: }
642: } else {
643: /*
644: * Conversion with at least one parameter in memory.
645: */
646: if (wfrom < wto) { /* expanding datum */
647: if (ISUNSIGNED(r->in.type)) {
648: printf("\tmovz");
649: prtype(r);
650: /*
651: * If target is a register, generate
652: * movz?l so optimizer can compress
653: * argument pushes.
654: */
655: if (l->in.op == REG)
656: putchar('l');
657: else
658: prtype(l);
659: } else {
660: printf("\tcvt");
661: prtype(r), prtype(l);
662: }
663: putchar('\t');
664: adrput(r);
665: } else { /* shrinking dataum */
666: int off = wfrom - wto;
667: if (l->in.op == REG) {
668: printf("\tmovz");
669: prtype(l);
670: putchar('l');
671: } else {
672: printf("\tcvt");
673: prtype(l), prtype(r);
674: }
675: putchar('\t');
676: switch (r->in.op) {
677: case NAME: case OREG:
678: r->tn.lval += off;
679: adrput(r);
680: r->tn.lval -= off;
681: break;
682: case REG: case ICON: case UNARY MUL:
683: adrput(r);
684: break;
685: default:
686: cerror("sconv: bad shrink op");
687: /*NOTREACHED*/
688: }
689: }
690: putchar(',');
691: adrput(l);
692: }
693: putchar('\n');
694: done:
695: l->in.type = oltype;
696: }
697:
698: rmove( rt, rs, t ) TWORD t;{
699: printf( " movl %s,%s\n", rname(rs), rname(rt) );
700: if(t==DOUBLE)
701: printf( " movl %s,%s\n", rname(rs+1), rname(rt+1) );
702: }
703:
704: struct respref
705: respref[] = {
706: INTAREG|INTBREG, INTAREG|INTBREG,
707: INAREG|INBREG, INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,
708: INTEMP, INTEMP,
709: FORARG, FORARG,
710: INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,
711: 0, 0 };
712:
713: setregs(){ /* set up temporary registers */
714: fregs = 6; /* tbl- 6 free regs on Tahoe (0-5) */
715: }
716:
717: #ifndef szty
718: szty(t) TWORD t;{ /* size, in registers, needed to hold thing of type t */
719: return(t==DOUBLE ? 2 : 1 );
720: }
721: #endif
722:
723: rewfld( p ) NODE *p; {
724: return(1);
725: }
726:
727: callreg(p) NODE *p; {
728: return( R0 );
729: }
730:
731: base( p ) register NODE *p; {
732: register int o = p->in.op;
733:
734: if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */
735: if( o==REG ) return( p->tn.rval );
736: if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON)
737: return( p->in.left->tn.rval );
738: if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) )
739: return( p->tn.rval + 0200*1 );
740: return( -1 );
741: }
742:
743: offset( p, tyl ) register NODE *p; int tyl; {
744:
745: if(tyl > 8) return( -1 );
746: if( tyl==1 && p->in.op==REG && (p->in.type==INT || p->in.type==UNSIGNED) ) return( p->tn.rval );
747: if( (p->in.op==LS && p->in.left->in.op==REG && (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) &&
748: (p->in.right->in.op==ICON && p->in.right->in.name[0]=='\0')
749: && (1<<p->in.right->tn.lval)==tyl))
750: return( p->in.left->tn.rval );
751: return( -1 );
752: }
753:
754: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
755: register NODE *t;
756: register int i;
757: NODE *f;
758:
759: p->in.op = OREG;
760: f = p->in.left; /* have to free this subtree later */
761:
762: /* init base */
763: switch (q->in.op) {
764: case ICON:
765: case REG:
766: case OREG:
767: t = q;
768: break;
769:
770: case MINUS:
771: q->in.right->tn.lval = -q->in.right->tn.lval;
772: case PLUS:
773: t = q->in.right;
774: break;
775:
776: case UNARY MUL:
777: t = q->in.left->in.left;
778: break;
779:
780: default:
781: cerror("illegal makeor2");
782: }
783:
784: p->tn.lval = t->tn.lval;
785: #ifndef FLEXNAMES
786: for(i=0; i<NCHNAM; ++i)
787: p->in.name[i] = t->in.name[i];
788: #else
789: p->in.name = t->in.name;
790: #endif
791:
792: /* init offset */
793: p->tn.rval = R2PACK( (b & 0177), o, (b>>7) );
794:
795: tfree(f);
796: return;
797: }
798:
799: canaddr( p ) NODE *p; {
800: register int o = p->in.op;
801:
802: if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
803: return(0);
804: }
805:
806: #ifndef shltype
807: shltype( o, p ) register NODE *p; {
808: return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->in.left)) );
809: }
810: #endif
811:
812: flshape( p ) NODE *p; {
813: register int o = p->in.op;
814:
815: if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1);
816: return(0);
817: }
818:
819: shtemp( p ) register NODE *p; {
820: if( p->in.op == STARG ) p = p->in.left;
821: return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) );
822: }
823:
824: shumul( p ) register NODE *p; {
825: register int o;
826: extern int xdebug;
827:
828: if (xdebug) {
829: printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op);
830: printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval);
831: }
832:
833: o = p->in.op;
834: if(( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON )
835: && p->in.type != PTR+DOUBLE)
836: return( STARNM );
837:
838: return( 0 );
839: }
840:
841: special( p, shape ) register NODE *p; {
842: if( shape==SIREG && p->in.op == OREG && R2TEST(p->tn.rval) ) return(1);
843: else return(0);
844: }
845:
846: adrcon( val ) CONSZ val; {
847: printf(ACONFMT, val);
848: }
849:
850: conput( p ) register NODE *p; {
851: switch( p->in.op ){
852:
853: case ICON:
854: acon( p );
855: return;
856:
857: case REG:
858: putstr(rname(p->tn.rval));
859: return;
860:
861: default:
862: cerror( "illegal conput" );
863: }
864: }
865:
866: insput( p ) NODE *p; {
867: cerror( "insput" );
868: }
869:
870: adrput( p ) register NODE *p; {
871: register int r;
872: /* output an address, with offsets, from p */
873:
874: if( p->in.op == FLD ){
875: p = p->in.left;
876: }
877: switch( p->in.op ){
878:
879: case NAME:
880: acon( p );
881: return;
882:
883: case ICON:
884: /* addressable value of the constant */
885: putchar('$');
886: acon( p );
887: return;
888:
889: case REG:
890: putstr(rname(p->tn.rval));
891: if(p->in.type == DOUBLE) /* for entry mask */
892: (void) rname(p->tn.rval+1);
893: return;
894:
895: case OREG:
896: r = p->tn.rval;
897: if( R2TEST(r) ){ /* double indexing */
898: register int flags;
899:
900: flags = R2UPK3(r);
901: if( flags & 1 ) putchar('*');
902: if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p);
903: if( R2UPK1(r) != 100) printf( "(%s)", rname(R2UPK1(r)) );
904: printf( "[%s]", rname(R2UPK2(r)) );
905: return;
906: }
907: if( r == FP && p->tn.lval > 0 ){ /* in the argument region */
908: if( p->in.name[0] != '\0' ) werror( "bad arg temp" );
909: printf( CONFMT, p->tn.lval );
910: putstr( "(fp)" );
911: return;
912: }
913: if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p );
914: printf( "(%s)", rname(p->tn.rval) );
915: return;
916:
917: case UNARY MUL:
918: /* STARNM or STARREG found */
919: if( tshape(p, STARNM) ) {
920: putchar( '*' );
921: adrput( p->in.left);
922: }
923: return;
924:
925: default:
926: cerror( "illegal address" );
927: return;
928:
929: }
930:
931: }
932:
933: acon( p ) register NODE *p; { /* print out a constant */
934:
935: if( p->in.name[0] == '\0' ){
936: printf( CONFMT, p->tn.lval);
937: return;
938: } else {
939: #ifndef FLEXNAMES
940: printf( "%.8s", p->in.name );
941: #else
942: putstr(p->in.name);
943: #endif
944: if (p->tn.lval != 0) {
945: putchar('+');
946: printf(CONFMT, p->tn.lval);
947: }
948: }
949: }
950:
951: genscall( p, cookie ) register NODE *p; {
952: /* structure valued call */
953: return( gencall( p, cookie ) );
954: }
955:
956: genfcall( p, cookie ) register NODE *p; {
957: register NODE *p1;
958: register int m;
959: static char *funcops[6] = {
960: "sin", "cos", "sqrt", "exp", "log", "atan"
961: };
962:
963: /* generate function opcodes */
964: if(p->in.op==UNARY FORTCALL && p->in.type==FLOAT &&
965: (p1 = p->in.left)->in.op==ICON &&
966: p1->tn.lval==0 && p1->in.type==INCREF(FTN|FLOAT)) {
967: #ifdef FLEXNAMES
968: p1->in.name++;
969: #else
970: strcpy(p1->in.name, p1->in.name[1]);
971: #endif
972: for(m=0; m<6; m++)
973: if(!strcmp(p1->in.name, funcops[m]))
974: break;
975: if(m >= 6)
976: uerror("no opcode for fortarn function %s", p1->in.name);
977: } else
978: uerror("illegal type of fortarn function");
979: p1 = p->in.right;
980: p->in.op = FORTCALL;
981: if(!canaddr(p1))
982: order( p1, INAREG|INBREG|SOREG|STARREG|STARNM );
983: m = match( p, INTAREG|INTBREG );
984: return(m != MDONE);
985: }
986:
987: /* tbl */
988: int gc_numbytes;
989: /* tbl */
990:
991: gencall( p, cookie ) register NODE *p; {
992: /* generate the call given by p */
993: register NODE *p1, *ptemp;
994: register int temp, temp1;
995: register int m;
996:
997: if( p->in.right ) temp = argsize( p->in.right );
998: else temp = 0;
999:
1000: if( p->in.op == STCALL || p->in.op == UNARY STCALL ){
1001: /* set aside room for structure return */
1002:
1003: if( p->stn.stsize > temp ) temp1 = p->stn.stsize;
1004: else temp1 = temp;
1005: }
1006:
1007: if( temp > maxargs ) maxargs = temp;
1008: SETOFF(temp1,4);
1009:
1010: if( p->in.right ){ /* make temp node, put offset in, and generate args */
1011: ptemp = talloc();
1012: ptemp->in.op = OREG;
1013: ptemp->tn.lval = -1;
1014: ptemp->tn.rval = SP;
1015: #ifndef FLEXNAMES
1016: ptemp->in.name[0] = '\0';
1017: #else
1018: ptemp->in.name = "";
1019: #endif
1020: ptemp->in.rall = NOPREF;
1021: ptemp->in.su = 0;
1022: genargs( p->in.right, ptemp );
1023: ptemp->in.op = FREE;
1024: }
1025:
1026: p1 = p->in.left;
1027: if( p1->in.op != ICON ){
1028: if( p1->in.op != REG ){
1029: if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){
1030: if( p1->in.op != NAME ){
1031: order( p1, INAREG );
1032: }
1033: }
1034: }
1035: }
1036:
1037: /* tbl
1038: setup gc_numbytes so reference to ZC works */
1039:
1040: gc_numbytes = temp&(0x3ff);
1041:
1042: p->in.op = UNARY CALL;
1043: m = match( p, INTAREG|INTBREG );
1044:
1045: return(m != MDONE);
1046: }
1047:
1048: /* tbl */
1049: char *
1050: ccbranches[] = {
1051: "eql",
1052: "neq",
1053: "leq",
1054: "lss",
1055: "geq",
1056: "gtr",
1057: "lequ",
1058: "lssu",
1059: "gequ",
1060: "gtru",
1061: };
1062: /* tbl */
1063:
1064: cbgen( o, lab, mode ) { /* printf conditional and unconditional branches */
1065:
1066: if(o != 0 && (o < EQ || o > UGT ))
1067: cerror( "bad conditional branch: %s", opst[o] );
1068: printf( " j%s L%d\n",
1069: o == 0 ? "br" : ccbranches[o-EQ], lab );
1070: }
1071:
1072: nextcook( p, cookie ) NODE *p; {
1073: /* we have failed to match p with cookie; try another */
1074: if( cookie == FORREW ) return( 0 ); /* hopeless! */
1075: if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG );
1076: if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
1077: return( FORREW );
1078: }
1079:
1080: lastchance( p, cook ) NODE *p; {
1081: /* forget it! */
1082: return(0);
1083: }
1084:
1085: optim2( p ) register NODE *p; {
1086: # ifdef ONEPASS
1087: /* do local tree transformations and optimizations */
1088: # define RV(p) p->in.right->tn.lval
1089: # define nncon(p) ((p)->in.op == ICON && (p)->in.name[0] == 0)
1090: register int o, i;
1091: register NODE *l, *r;
1092:
1093: switch (o = p->in.op) {
1094:
1095: case DIV: case ASG DIV:
1096: case MOD: case ASG MOD:
1097: /*
1098: * Change unsigned mods and divs to
1099: * logicals (mul is done in mip & c2)
1100: */
1101: if (ISUNSIGNED(p->in.left->in.type) && nncon(p->in.right) &&
1102: (i = ispow2(RV(p))) >= 0) {
1103: if (o == DIV || o == ASG DIV) {
1104: p->in.op = RS;
1105: RV(p) = i;
1106: } else {
1107: p->in.op = AND;
1108: RV(p)--;
1109: }
1110: if (asgop(o))
1111: p->in.op = ASG p->in.op;
1112: }
1113: return;
1114:
1115: case SCONV:
1116: l = p->in.left;
1117: /* clobber conversions w/o side effects */
1118: if (!anyfloat(p, l) && l->in.op != PCONV &&
1119: tlen(p) == tlen(l)) {
1120: if (l->in.op != FLD)
1121: l->in.type = p->in.type;
1122: ncopy(p, l);
1123: l->in.op = FREE;
1124: }
1125: return;
1126:
1127: case ASSIGN:
1128: /*
1129: * Try to zap storage conversions of non-float items.
1130: */
1131: r = p->in.right;
1132: if (r->in.op == SCONV && !anyfloat(r->in.left, r)) {
1133: int wdest, wconv, wsrc;
1134: wdest = tlen(p->in.left);
1135: wconv = tlen(r);
1136: /*
1137: * If size doesn't change across assignment or
1138: * conversion expands src before shrinking again
1139: * due to the assignment, delete conversion so
1140: * code generator can create optimal code.
1141: */
1142: if (wdest == wconv ||
1143: (wdest == (wsrc = tlen(r->in.left)) && wconv > wsrc)) {
1144: p->in.right = r->in.left;
1145: r->in.op = FREE;
1146: }
1147: }
1148: return;
1149: }
1150: # endif
1151: }
1152:
1153: struct functbl {
1154: int fop;
1155: char *func;
1156: } opfunc[] = {
1157: DIV, "udiv",
1158: ASG DIV, "udiv",
1159: 0
1160: };
1161:
1162: hardops(p) register NODE *p; {
1163: /* change hard to do operators into function calls. */
1164: register NODE *q;
1165: register struct functbl *f;
1166: register int o;
1167: register TWORD t, t1, t2;
1168:
1169: o = p->in.op;
1170:
1171: for( f=opfunc; f->fop; f++ ) {
1172: if( o==f->fop ) goto convert;
1173: }
1174: return;
1175:
1176: convert:
1177: t = p->in.type;
1178: t1 = p->in.left->in.type;
1179: t2 = p->in.right->in.type;
1180:
1181: if (!((ISUNSIGNED(t1) && !(ISUNSIGNED(t2))) ||
1182: ( t2 == UNSIGNED))) return;
1183:
1184: /* need to rewrite tree for ASG OP */
1185: /* must change ASG OP to a simple OP */
1186: if( asgop( o ) ) {
1187: q = talloc();
1188: q->in.op = NOASG ( o );
1189: q->in.rall = NOPREF;
1190: q->in.type = p->in.type;
1191: q->in.left = tcopy(p->in.left);
1192: q->in.right = p->in.right;
1193: p->in.op = ASSIGN;
1194: p->in.right = q;
1195: zappost(q->in.left); /* remove post-INCR(DECR) from new node */
1196: fixpre(q->in.left); /* change pre-INCR(DECR) to +/- */
1197: p = q;
1198:
1199: }
1200: /* turn logicals to compare 0 */
1201: else if( logop( o ) ) {
1202: ncopy(q = talloc(), p);
1203: p->in.left = q;
1204: p->in.right = q = talloc();
1205: q->in.op = ICON;
1206: q->in.type = INT;
1207: #ifndef FLEXNAMES
1208: q->in.name[0] = '\0';
1209: #else
1210: q->in.name = "";
1211: #endif
1212: q->tn.lval = 0;
1213: q->tn.rval = 0;
1214: p = p->in.left;
1215: }
1216:
1217: /* build comma op for args to function */
1218: t1 = p->in.left->in.type;
1219: t2 = 0;
1220: if ( optype(p->in.op) == BITYPE) {
1221: q = talloc();
1222: q->in.op = CM;
1223: q->in.rall = NOPREF;
1224: q->in.type = INT;
1225: q->in.left = p->in.left;
1226: q->in.right = p->in.right;
1227: t2 = p->in.right->in.type;
1228: } else
1229: q = p->in.left;
1230:
1231: p->in.op = CALL;
1232: p->in.right = q;
1233:
1234: /* put function name in left node of call */
1235: p->in.left = q = talloc();
1236: q->in.op = ICON;
1237: q->in.rall = NOPREF;
1238: q->in.type = INCREF( FTN + p->in.type );
1239: #ifndef FLEXNAMES
1240: strcpy( q->in.name, f->func );
1241: #else
1242: q->in.name = f->func;
1243: #endif
1244: q->tn.lval = 0;
1245: q->tn.rval = 0;
1246:
1247: }
1248:
1249: zappost(p) NODE *p; {
1250: /* look for ++ and -- operators and remove them */
1251:
1252: register int o, ty;
1253: register NODE *q;
1254: o = p->in.op;
1255: ty = optype( o );
1256:
1257: switch( o ){
1258:
1259: case INCR:
1260: case DECR:
1261: q = p->in.left;
1262: p->in.right->in.op = FREE; /* zap constant */
1263: ncopy( p, q );
1264: q->in.op = FREE;
1265: return;
1266:
1267: }
1268:
1269: if( ty == BITYPE ) zappost( p->in.right );
1270: if( ty != LTYPE ) zappost( p->in.left );
1271: }
1272:
1273: fixpre(p) NODE *p; {
1274:
1275: register int o, ty;
1276: o = p->in.op;
1277: ty = optype( o );
1278:
1279: switch( o ){
1280:
1281: case ASG PLUS:
1282: p->in.op = PLUS;
1283: break;
1284: case ASG MINUS:
1285: p->in.op = MINUS;
1286: break;
1287: }
1288:
1289: if( ty == BITYPE ) fixpre( p->in.right );
1290: if( ty != LTYPE ) fixpre( p->in.left );
1291: }
1292:
1293: NODE * addroreg(l) NODE *l;
1294: /* OREG was built in clocal()
1295: * for an auto or formal parameter
1296: * now its address is being taken
1297: * local code must unwind it
1298: * back to PLUS/MINUS REG ICON
1299: * according to local conventions
1300: */
1301: {
1302: cerror("address of OREG taken");
1303: }
1304:
1305: # ifndef ONEPASS
1306: main( argc, argv ) char *argv[]; {
1307: return( mainp2( argc, argv ) );
1308: }
1309: # endif
1310:
1311: strip(p) register NODE *p; {
1312: NODE *q;
1313:
1314: /* strip nodes off the top when no side effects occur */
1315: for( ; ; ) {
1316: switch( p->in.op ) {
1317: case SCONV: /* remove lint tidbits */
1318: q = p->in.left;
1319: ncopy( p, q );
1320: q->in.op = FREE;
1321: break;
1322: /* could probably add a few more here */
1323: default:
1324: return;
1325: }
1326: }
1327: }
1328:
1329: myreader(p) register NODE *p; {
1330: strip( p ); /* strip off operations with no side effects */
1331: walkf( p, hardops ); /* convert ops to function calls */
1332: canon( p ); /* expands r-vals for fileds */
1333: walkf( p, optim2 );
1334: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.