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