From 231d5cc1f98f18c559746af1a50bd71fc5fd6854 Mon Sep 17 00:00:00 2001 From: Bill Joy Date: Thu, 13 Nov 1980 00:59:11 -0800 Subject: [PATCH] BSD 4 development Work on file usr/src/cmd/pcc/makefile Work on file usr/src/cmd/pcc/UClocal2.c Work on file usr/src/cmd/pcc/UCtable.c Synthesized-from: CSRG//cd1/4.0 --- usr/src/cmd/pcc/UClocal2.c | 1151 ++++++++++++++++++++++++++++++++++++ usr/src/cmd/pcc/UCtable.c | 837 ++++++++++++++++++++++++++ usr/src/cmd/pcc/makefile | 91 +++ 3 files changed, 2079 insertions(+) create mode 100644 usr/src/cmd/pcc/UClocal2.c create mode 100644 usr/src/cmd/pcc/UCtable.c create mode 100644 usr/src/cmd/pcc/makefile diff --git a/usr/src/cmd/pcc/UClocal2.c b/usr/src/cmd/pcc/UClocal2.c new file mode 100644 index 0000000000..f0b8520d8d --- /dev/null +++ b/usr/src/cmd/pcc/UClocal2.c @@ -0,0 +1,1151 @@ +static char *sccsid ="%W% (Berkeley) %G%"; +# include "mfile2" +# include "ctype.h" +# ifdef FORT +int ftlab1, ftlab2; +/* a lot of the machine dependent parts of the second pass */ + +# define BITMASK(n) ((1L<= AUTOINIT ) spoff -= AUTOINIT; + spoff /= SZCHAR; + SETOFF(spoff,4); +#ifndef FLEXNAMES + printf( " .set .F%d,%ld\n", ftnno, spoff ); +#else + /* SHOULD BE L%d ... ftnno but must change pc/f77 */ + printf( " .set LF%d,%ld\n", ftnno, spoff ); +#endif +#else + extern int ftlab1, ftlab2; + + spoff = maxoff; + if( spoff >= AUTOINIT ) spoff -= AUTOINIT; + spoff /= SZCHAR; + SETOFF(spoff,4); + printf( "L%d:\n", ftlab1); + if( spoff!=0 ) + if( spoff < 64 ) + printf( " subl2 $%ld,sp\n", spoff); + else + printf( " movab -%ld(sp),sp\n", spoff); + printf( " jbr L%d\n", ftlab2); +#endif + maxargs = -1; + } + +struct hoptab { int opmask; char * opstring; } ioptab[] = { + + ASG PLUS, "add", + ASG MINUS, "sub", + ASG MUL, "mul", + ASG DIV, "div", + ASG OR, "bis", + ASG ER, "xor", + ASG AND, "bic", + PLUS, "add", + MINUS, "sub", + MUL, "mul", + DIV, "div", + OR, "bis", + ER, "xor", + AND, "bic", + -1, "" }; + +hopcode( f, o ){ + /* output the appropriate string from the above table */ + + register struct hoptab *q; + + for( q = ioptab; q->opmask>=0; ++q ){ + if( q->opmask == o ){ + printf( "%s", q->opstring ); +/* tbl + if( f == 'F' ) printf( "e" ); + else if( f == 'D' ) printf( "d" ); + tbl */ +/* tbl */ + switch( f ) { + case 'L': + case 'W': + case 'B': + case 'D': + case 'F': + printf("%c", tolower(f)); + break; + + } +/* tbl */ + return; + } + } + cerror( "no hoptab for %s", opst[o] ); + } + +char * +rnames[] = { /* keyed to register number tokens */ + + "r0", "r1", + "r2", "r3", "r4", "r5", + "r6", "r7", "r8", "r9", "r10", "r11", + "ap", "fp", "sp", "pc", + + }; + +int rstatus[] = { + SAREG|STAREG, SAREG|STAREG, + SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, + SAREG, SAREG, SAREG, SAREG, SAREG, SAREG, + SAREG, SAREG, SAREG, SAREG, + + }; + +tlen(p) NODE *p; +{ + switch(p->in.type) { + case CHAR: + case UCHAR: + return(1); + + case SHORT: + case USHORT: + return(2); + + case DOUBLE: + return(8); + + default: + return(4); + } +} + +mixtypes(p, q) NODE *p, *q; +{ + register tp, tq; + + tp = p->in.type; + tq = q->in.type; + + return( (tp==FLOAT || tp==DOUBLE) != + (tq==FLOAT || tq==DOUBLE) ); +} + +prtype(n) NODE *n; +{ + switch (n->in.type) + { + case DOUBLE: + printf("d"); + return; + + case FLOAT: + printf("f"); + return; + + case LONG: + case ULONG: + case INT: + case UNSIGNED: + printf("l"); + return; + + case SHORT: + case USHORT: + printf("w"); + return; + + case CHAR: + case UCHAR: + printf("b"); + return; + + default: + if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type"); + else { + printf("l"); + return; + } + } +} + +zzzcode( p, c ) register NODE *p; { + register m; + CONSZ val; + switch( c ){ + + case 'N': /* logical ops, turned into 0-1 */ + /* use register given by register 1 */ + cbgen( 0, m=getlab(), 'I' ); + deflab( p->bn.label ); + printf( " clrl %s\n", rnames[getlr( p, '1' )->tn.rval] ); + deflab( m ); + return; + + case 'I': + case 'P': + cbgen( p->in.op, p->bn.label, c ); + return; + + case 'A': + { + register NODE *l, *r; + + if (xdebug) eprint(p, 0, &val, &val); + r = getlr(p, 'R'); + if (optype(p->in.op) == LTYPE || p->in.op == UNARY MUL) + { + l = resc; + l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? DOUBLE : INT); + } + else + l = getlr(p, 'L'); + if (r->in.op == ICON) + if(r->in.name[0] == '\0') + { + if (r->tn.lval == 0) + { + printf("clr"); + prtype(l); + printf(" "); + adrput(l); + return; + } + if (r->tn.lval < 0 && r->tn.lval >= -63) + { + printf("mneg"); + prtype(l); + r->tn.lval = -r->tn.lval; + goto ops; + } + r->in.type = (r->tn.lval < 0 ? + (r->tn.lval >= -128 ? CHAR + : (r->tn.lval >= -32768 ? SHORT + : INT )) : r->in.type); + r->in.type = (r->tn.lval >= 0 ? + (r->tn.lval <= 63 ? INT + : ( r->tn.lval <= 127 ? CHAR + : (r->tn.lval <= 255 ? UCHAR + : (r->tn.lval <= 32767 ? SHORT + : (r->tn.lval <= 65535 ? USHORT + : INT ))))) : r->in.type ); + } + else + { + printf("moval"); + printf(" "); + acon(r); + printf(","); + adrput(l); + return; + } + + if (l->in.op == REG && l->in.type != FLOAT && l->in.type != DOUBLE) + { + if( tlen(l) < tlen(r) ) + { + if (!mixtypes(l,r)) + { + !ISUNSIGNED(l->in.type)? + printf("cvt"): + printf("movz"); + prtype(l); + printf("l"); + goto ops; + } + else + { + printf("cvt"); + prtype(r); + prtype(l); + printf(" "); + adrput(r); + printf(","); + adrput(l); + printf("cvt"); + prtype(l); + printf("l"); + printf(" "); + adrput(l); + printf(","); + adrput(l); + return; + } + } + else + { + l->in.type = INT; + } + } + if (!mixtypes(l,r)) + { + if (tlen(l) == tlen(r)) + { + int x = r->in.type; + printf("mov"); + if (BTYPE(x)==STRTY && !ISPTR(x)) + printf("a"); + prtype(l); + goto ops; + } + else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type)) + { + printf("movz"); + } + else + { + printf("cvt"); + } + } + else + { + printf("cvt"); + } + prtype(r); + prtype(l); + ops: + printf(" "); + adrput(r); + printf(","); + adrput(l); + return; + } + + case 'B': /* get oreg value in temp register for left shift */ + { + register NODE *r; + if (xdebug) eprint(p, 0, &val, &val); + r = p->in.right; + if( tlen(r) == sizeof(int) && r->in.type != FLOAT ) + printf("movl"); + else { + printf("cvt"); + prtype(r); + printf("l"); + } + return; + } + + case 'C': /* num words pushed on arg stack */ + { + extern int gc_numbytes; + extern int xdebug; + + if (xdebug) printf("->%d<-",gc_numbytes); + + printf("$%d", gc_numbytes/(SZLONG/SZCHAR) ); + return; + } + + case 'D': /* INCR and DECR */ + zzzcode(p->in.left, 'A'); + printf("\n "); + + case 'E': /* INCR and DECR, FOREFF */ + if (p->in.right->tn.lval == 1) + { + printf("%s", (p->in.op == INCR ? "inc" : "dec") ); + prtype(p->in.left); + printf(" "); + adrput(p->in.left); + return; + } + printf("%s", (p->in.op == INCR ? "add" : "sub") ); + prtype(p->in.left); + printf("2 "); + adrput(p->in.right); + printf(","); + adrput(p->in.left); + return; + + case 'F': /* register type of right operand */ + { + register NODE *n; + extern int xdebug; + register int ty; + + n = getlr( p, 'R' ); + ty = n->in.type; + + if (xdebug) printf("->%d<-", ty); + + if ( ty==DOUBLE) printf("d"); + else if ( ty==FLOAT ) printf("f"); + else printf("l"); + return; + } + + case 'L': /* type of left operand */ + case 'R': /* type of right operand */ + { + register NODE *n; + extern int xdebug; + + n = getlr ( p, c); + if (xdebug) printf("->%d<-", n->in.type); + + prtype(n); + return; + } + + case 'Z': /* complement mask for bit instr */ + printf("$%ld", ~p->in.right->tn.lval); + return; + + case 'U': /* 32 - n, for unsigned right shifts */ + printf("$%d", 32 - p->in.right->tn.lval ); + return; + + case 'T': /* rounded structure length for arguments */ + { + int size; + + size = p->stn.stsize; + SETOFF( size, 4); + printf("$%d", size); + return; + } + + case 'S': /* structure assignment */ + { + register NODE *l, *r; + register size; + + if( p->in.op == STASG ){ + l = p->in.left; + r = p->in.right; + + } + else if( p->in.op == STARG ){ /* store an arg into a temporary */ + l = getlr( p, '3' ); + r = p->in.left; + } + else cerror( "STASG bad" ); + + if( r->in.op == ICON ) r->in.op = NAME; + else if( r->in.op == REG ) r->in.op = OREG; + else if( r->in.op != OREG ) cerror( "STASG-r" ); + + size = p->stn.stsize; + + if( size <= 0 || size > 65535 ) + cerror("structure size <0=0 or >65535"); + + switch(size) { + case 1: + printf(" movb "); + break; + case 2: + printf(" movw "); + break; + case 4: + printf(" movl "); + break; + case 8: + printf(" movq "); + break; + default: + printf(" movc3 $%d,", size); + break; + } + adrput(r); + printf(","); + adrput(l); + printf("\n"); + + if( r->in.op == NAME ) r->in.op = ICON; + else if( r->in.op == OREG ) r->in.op = REG; + + } + break; + + default: + cerror( "illegal zzzcode" ); + } + } + +rmove( rt, rs, t ){ + printf( " %s %s,%s\n", + (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), + rnames[rs], rnames[rt] ); + } + +struct respref +respref[] = { + INTAREG|INTBREG, INTAREG|INTBREG, + INAREG|INBREG, INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON, + INTEMP, INTEMP, + FORARG, FORARG, + INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM, + 0, 0 }; + +setregs(){ /* set up temporary registers */ + fregs = 6; /* tbl- 6 free regs on VAX (0-5) */ + ; + } + +szty(t){ /* size, in registers, needed to hold thing of type t */ + return( (t==DOUBLE||t==FLOAT) ? 2 : 1 ); + } + +rewfld( p ) NODE *p; { + return(1); + } + +callreg(p) NODE *p; { + return( R0 ); + } + +base( p ) register NODE *p; { + register int o = p->in.op; + + if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */ + if( o==REG ) return( p->tn.rval ); + if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON) + return( p->in.left->tn.rval ); + if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) + return( p->tn.rval + 0200*1 ); + if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 ); + if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 ); + if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG + && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) + return( p->in.left->in.left->tn.rval + 0200*(1+2) ); + return( -1 ); + } + +offset( p, tyl ) register NODE *p; int tyl; { + + if( tyl==1 && p->in.op==REG && (p->in.type==INT || p->in.type==UNSIGNED) ) return( p->tn.rval ); + if( (p->in.op==LS && p->in.left->in.op==REG && (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) && + (p->in.right->in.op==ICON && p->in.right->in.name[0]=='\0') + && (1<in.right->tn.lval)==tyl)) + return( p->in.left->tn.rval ); + return( -1 ); + } + +makeor2( p, q, b, o) register NODE *p, *q; register int b, o; { + register NODE *t; + register int i; + NODE *f; + + p->in.op = OREG; + f = p->in.left; /* have to free this subtree later */ + + /* init base */ + switch (q->in.op) { + case ICON: + case REG: + case OREG: + t = q; + break; + + case MINUS: + q->in.right->tn.lval = -q->in.right->tn.lval; + case PLUS: + t = q->in.right; + break; + + case INCR: + case ASG MINUS: + t = q->in.left; + break; + + case UNARY MUL: + t = q->in.left->in.left; + break; + + default: + cerror("illegal makeor2"); + } + + p->tn.lval = t->tn.lval; +#ifndef FLEXNAMES + for(i=0; iin.name[i] = t->in.name[i]; +#else + p->in.name = t->in.name; +#endif + + /* init offset */ + p->tn.rval = R2PACK( (b & 0177), o, (b>>7) ); + + tfree(f); + return; + } + +canaddr( p ) NODE *p; { + register int o = p->in.op; + + if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1); + return(0); + } + +shltype( o, p ) register NODE *p; { + return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->in.left)) ); + } + +flshape( p ) register NODE *p; { + return( p->in.op == REG || p->in.op == NAME || p->in.op == ICON || + (p->in.op == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) ); + } + +shtemp( p ) register NODE *p; { + if( p->in.op == STARG ) p = p->in.left; + return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) ); + } + +shumul( p ) register NODE *p; { + register o; + extern int xdebug; + + if (xdebug) { + printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op); + printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval); + } + + + o = p->in.op; + if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM ); + + if( ( o == INCR || o == ASG MINUS ) && + ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) && + p->in.right->in.name[0] == '\0' ) + { + switch (p->in.left->in.type) + { + case CHAR|PTR: + case UCHAR|PTR: + o = 1; + break; + + case SHORT|PTR: + case USHORT|PTR: + o = 2; + break; + + case INT|PTR: + case UNSIGNED|PTR: + case LONG|PTR: + case ULONG|PTR: + case FLOAT|PTR: + o = 4; + break; + + case DOUBLE|PTR: + o = 8; + break; + + default: + if ( ISPTR(p->in.left->in.type) ) { + o = 4; + break; + } + else return(0); + } + return( p->in.right->tn.lval == o ? STARREG : 0); + } + + return( 0 ); + } + +adrcon( val ) CONSZ val; { + printf( "$" ); + printf( CONFMT, val ); + } + +conput( p ) register NODE *p; { + switch( p->in.op ){ + + case ICON: + acon( p ); + return; + + case REG: + printf( "%s", rnames[p->tn.rval] ); + return; + + default: + cerror( "illegal conput" ); + } + } + +insput( p ) register NODE *p; { + cerror( "insput" ); + } + +upput( p ) register NODE *p; { + cerror( "upput" ); + } + +adrput( p ) register NODE *p; { + register int r; + /* output an address, with offsets, from p */ + + if( p->in.op == FLD ){ + p = p->in.left; + } + switch( p->in.op ){ + + case NAME: + acon( p ); + return; + + case ICON: + /* addressable value of the constant */ + printf( "$" ); + acon( p ); + return; + + case REG: + printf( "%s", rnames[p->tn.rval] ); + return; + + case OREG: + r = p->tn.rval; + if( R2TEST(r) ){ /* double indexing */ + register int flags; + + flags = R2UPK3(r); + if( flags & 1 ) printf("*"); + if( flags & 4 ) printf("-"); + if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p); + if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] ); + if( flags & 2 ) printf("+"); + printf( "[%s]", rnames[R2UPK2(r)] ); + return; + } + if( r == AP ){ /* in the argument region */ + if( p->tn.lval <= 0 || p->in.name[0] != '\0' ) werror( "bad arg temp" ); + printf( CONFMT, p->tn.lval ); + printf( "(ap)" ); + return; + } + if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p ); + printf( "(%s)", rnames[p->tn.rval] ); + return; + + case UNARY MUL: + /* STARNM or STARREG found */ + if( tshape(p, STARNM) ) { + printf( "*" ); + adrput( p->in.left); + } + else { /* STARREG - really auto inc or dec */ + register NODE *q; + +/* tbl + p = p->in.left; + p->in.left->in.op = OREG; + if( p->in.op == INCR ) { + adrput( p->in.left ); + printf( "+" ); + } + else { + printf( "-" ); + adrput( p->in.left ); + } + tbl */ + printf("%s(%s)%s", (p->in.left->in.op==INCR ? "" : "-"), + rnames[p->in.left->in.left->tn.rval], + (p->in.left->in.op==INCR ? "+" : "") ); + p->in.op = OREG; + p->tn.rval = p->in.left->in.left->tn.rval; + q = p->in.left; + p->tn.lval = (p->in.left->in.op == INCR ? -p->in.left->in.right->tn.lval : 0); +#ifndef FLEXNAMES + p->in.name[0] = '\0'; +#else + p->in.name = ""; +#endif + tfree(q); + } + return; + + default: + cerror( "illegal address" ); + return; + + } + + } + +acon( p ) register NODE *p; { /* print out a constant */ + + if( p->in.name[0] == '\0' ){ + printf( CONFMT, p->tn.lval); + } + else if( p->tn.lval == 0 ) { +#ifndef FLEXNAMES + printf( "%.8s", p->in.name ); +#else + printf( "%s", p->in.name ); +#endif + } + else { +#ifndef FLEXNAMES + printf( "%.8s+", p->in.name ); +#else + printf( "%s+", p->in.name ); +#endif + printf( CONFMT, p->tn.lval ); + } + } + +/* +aacon( p ) register NODE *p; { /* print out a constant */ +/* + + if( p->in.name[0] == '\0' ){ + printf( CONFMT, p->tn.lval); + return( 0 ); + } + else if( p->tn.lval == 0 ) { +#ifndef FLEXNAMES + printf( "$%.8s", p->in.name ); +#else + printf( "$%s", p->in.name ); +#endif + return( 1 ); + } + else { + printf( "$(" ); + printf( CONFMT, p->tn.lval ); + printf( "+" ); +#ifndef FLEXNAMES + printf( "%.8s)", p->in.name ); +#else + printf( "%s)", p->in.name ); +#endif + return(1); + } + } + */ + +genscall( p, cookie ) register NODE *p; { + /* structure valued call */ + return( gencall( p, cookie ) ); + } + +/* tbl */ +int gc_numbytes; +/* tbl */ + +gencall( p, cookie ) register NODE *p; { + /* generate the call given by p */ + register NODE *p1, *ptemp; + register temp, temp1; + register m; + + if( p->in.right ) temp = argsize( p->in.right ); + else temp = 0; + + if( p->in.op == STCALL || p->in.op == UNARY STCALL ){ + /* set aside room for structure return */ + + if( p->stn.stsize > temp ) temp1 = p->stn.stsize; + else temp1 = temp; + } + + if( temp > maxargs ) maxargs = temp; + SETOFF(temp1,4); + + if( p->in.right ){ /* make temp node, put offset in, and generate args */ + ptemp = talloc(); + ptemp->in.op = OREG; + ptemp->tn.lval = -1; + ptemp->tn.rval = SP; +#ifndef FLEXNAMES + ptemp->in.name[0] = '\0'; +#else + ptemp->in.name = ""; +#endif + ptemp->in.rall = NOPREF; + ptemp->in.su = 0; + genargs( p->in.right, ptemp ); + ptemp->in.op = FREE; + } + + p1 = p->in.left; + if( p1->in.op != ICON ){ + if( p1->in.op != REG ){ + if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){ + if( p1->in.op != NAME ){ + order( p1, INAREG ); + } + } + } + } + +/* + if( p1->in.op == REG && p->tn.rval == R5 ){ + cerror( "call register overwrite" ); + } + */ +/* tbl + setup gc_numbytes so reference to ZC works */ + + gc_numbytes = temp; +/* tbl */ + + p->in.op = UNARY CALL; + m = match( p, INTAREG|INTBREG ); +/* tbl + switch( temp ) { + case 0: + break; + case 2: + printf( " tst (sp)+\n" ); + break; + case 4: + printf( " cmp (sp)+,(sp)+\n" ); + break; + default: + printf( " add $%d,sp\n", temp); + } + tbl */ + return(m != MDONE); + } + +/* tbl */ +char * +ccbranches[] = { + " jeql L%d\n", + " jneq L%d\n", + " jleq L%d\n", + " jlss L%d\n", + " jgeq L%d\n", + " jgtr L%d\n", + " jlequ L%d\n", + " jlssu L%d\n", + " jgequ L%d\n", + " jgtru L%d\n", + }; +/* tbl */ + +cbgen( o, lab, mode ) { /* printf conditional and unconditional branches */ + +/* tbl */ + if( o == 0 ) printf( " jbr L%d\n", lab ); +/* tbl */ + else { + if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] ); + printf( ccbranches[o-EQ], lab ); + } + } + +nextcook( p, cookie ) NODE *p; { + /* we have failed to match p with cookie; try another */ + if( cookie == FORREW ) return( 0 ); /* hopeless! */ + if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG ); + if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG ); + return( FORREW ); + } + +lastchance( p, cook ) NODE *p; { + /* forget it! */ + return(0); + } + +optim2( p ) register NODE *p; { + /* do local tree transformations and optimizations */ + + register NODE *r; + + switch( p->in.op ) { + + case AND: + /* commute L and R to eliminate compliments and constants */ + if( (p->in.left->in.op==ICON&&p->in.left->in.name[0]==0) || p->in.left->in.op==COMPL ) { + r = p->in.left; + p->in.left = p->in.right; + p->in.right = r; + } + case ASG AND: + /* change meaning of AND to ~R&L - bic on pdp11 */ + r = p->in.right; + if( r->in.op==ICON && r->in.name[0]==0 ) { /* compliment constant */ + r->tn.lval = ~r->tn.lval; + } + else if( r->in.op==COMPL ) { /* ~~A => A */ + r->in.op = FREE; + p->in.right = r->in.left; + } + else { /* insert complement node */ + p->in.right = talloc(); + p->in.right->in.op = COMPL; + p->in.right->in.rall = NOPREF; + p->in.right->in.type = r->in.type; + p->in.right->in.left = r; + p->in.right->in.right = NULL; + } + break; + + } + } + +NODE * addroreg(l) + /* OREG was built in clocal() + * for an auto or formal parameter + * now its address is being taken + * local code must unwind it + * back to PLUS/MINUS REG ICON + * according to local conventions + */ +{ + cerror("address of OREG taken"); +} + + + +# ifndef ONEPASS +main( argc, argv ) char *argv[]; { + return( mainp2( argc, argv ) ); + } +# endif + + +/* added by jwf */ +struct functbl { + int fop; + TWORD ftype; + char *func; + } opfunc[] = { + DIV, TANY, "udiv", + MOD, TANY, "urem", + ASG DIV, TANY, "udiv", + ASG MOD, TANY, "urem", + 0, 0, 0 }; + +hardops(p) register NODE *p; { + /* change hard to do operators into function calls. */ + register NODE *q; + register struct functbl *f; + register o; + register TWORD t; + + o = p->in.op; + t = p->in.type; + if( t!=UNSIGNED && t!=ULONG ) return; + + for( f=opfunc; f->fop; f++ ) { + if( o==f->fop ) goto convert; + } + return; + + /* need to rewrite tree for ASG OP */ + /* must change ASG OP to a simple OP */ + convert: + if( asgop( o ) ) { + q = talloc(); + switch( p->in.op ) { + case ASG DIV: + q->in.op = DIV; + break; + case ASG MOD: + q->in.op = MOD; + break; + } + q->in.rall = NOPREF; + q->in.type = p->in.type; + q->in.left = tcopy(p->in.left); + q->in.right = p->in.right; + p->in.op = ASSIGN; + p->in.right = q; + zappost(q->in.left); /* remove post-INCR(DECR) from new node */ + fixpre(q->in.left); /* change pre-INCR(DECR) to +/- */ + p = q; + + } + + /* build comma op for args to function */ + q = talloc(); + q->in.op = CM; + q->in.rall = NOPREF; + q->in.type = INT; + q->in.left = p->in.left; + q->in.right = p->in.right; + p->in.op = CALL; + p->in.right = q; + + /* put function name in left node of call */ + p->in.left = q = talloc(); + q->in.op = ICON; + q->in.rall = NOPREF; + q->in.type = INCREF( FTN + p->in.type ); +#ifndef FLEXNAMES + strcpy( q->in.name, f->func ); +#else + q->in.name = f->func; +#endif + q->tn.lval = 0; + q->tn.rval = 0; + + return; + + } + +zappost(p) NODE *p; { + /* look for ++ and -- operators and remove them */ + + register o, ty; + register NODE *q; + o = p->in.op; + ty = optype( o ); + + switch( o ){ + + case INCR: + case DECR: + q = p->in.left; + p->in.right->in.op = FREE; /* zap constant */ + ncopy( p, q ); + q->in.op = FREE; + return; + + } + + if( ty == BITYPE ) zappost( p->in.right ); + if( ty != LTYPE ) zappost( p->in.left ); +} + +fixpre(p) NODE *p; { + + register o, ty; + o = p->in.op; + ty = optype( o ); + + switch( o ){ + + case ASG PLUS: + p->in.op = PLUS; + break; + case ASG MINUS: + p->in.op = MINUS; + break; + } + + if( ty == BITYPE ) fixpre( p->in.right ); + if( ty != LTYPE ) fixpre( p->in.left ); +} + +myreader(p) register NODE *p; { + walkf( p, hardops ); /* convert ops to function calls */ + canon( p ); /* expands r-vals for fileds */ + walkf( p, optim2 ); + /* jwf toff = 0; /* stack offset swindle */ + } + + diff --git a/usr/src/cmd/pcc/UCtable.c b/usr/src/cmd/pcc/UCtable.c new file mode 100644 index 0000000000..a9c71304b3 --- /dev/null +++ b/usr/src/cmd/pcc/UCtable.c @@ -0,0 +1,837 @@ +static char *sccsid ="%W% (Berkeley) %G%"; +# include "mfile2" + +# define WPTR TPTRTO|TINT|TLONG|TFLOAT|TDOUBLE|TPOINT|TUNSIGNED|TULONG +# define AWD SNAME|SOREG|SCON|STARNM|STARREG +/* tbl */ +# define ANYSIGNED TPOINT|TINT|TLONG|TSHORT|TCHAR +# define ANYUSIGNED TUNSIGNED|TULONG|TUSHORT|TUCHAR +# define ANYFIXED ANYSIGNED|ANYUSIGNED +# define TWORD TINT|TUNSIGNED|TPOINT|TLONG|TULONG +# define NIAWD SNAME|SCON|STARNM +/* tbl */ + +struct optab table[] = { + +PCONV, INAREG|INTAREG, + SAREG|AWD, TCHAR|TSHORT, + SANY, TPOINT, + NAREG|NASL, RESC1, + " cvtZLl AL,A1\n", + +PCONV, INAREG|INTAREG, + SAREG|AWD, TUCHAR|TUSHORT, + SANY, TPOINT, + NAREG|NASL, RESC1, + " movzZLl AL,A1\n", + + /* the following entry is to fix a problem with + the manner that the first pass handles the + type of a shift expression */ +PCONV, INAREG|INTAREG, + SAREG|AWD, TINT|TUNSIGNED, + SANY, TPOINT, + NAREG|NASL, RLEFT, + "", + +SCONV, INTAREG|FORCC, + SAREG, TDOUBLE, + SANY, TDOUBLE, + 0, RLEFT, + "", + +#ifdef FORT +SCONV, INTAREG|FORCC, + SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, + SANY, TFLOAT, + NAREG|NASL, RESC1|RESCC, + " cvtZLf AL,TA1\n", + +SCONV, INTAREG|FORCC, + SAREG|AWD, TUCHAR|TUSHORT, + SANY, TFLOAT, + NAREG|NASL, RESC1|RESCC, + " movzZLl AL,A1\n cvtlf A1,TA1\n", +#endif + +SCONV, INTAREG|FORCC, + SAREG|AWD, ANYSIGNED|TUNSIGNED|TULONG|TFLOAT, + SANY, TFLOAT|TDOUBLE, + NAREG|NASL, RESC1|RESCC, + " cvtZLd AL,A1\n", + +SCONV, INTAREG|FORCC, + SAREG|AWD, TUCHAR|TUSHORT, + SANY, TFLOAT|TDOUBLE, + NAREG|NASL, RESC1|RESCC, + " movzZLl AL,A1\n cvtld A1,A1\n", + +SCONV, INTAREG|FORCC, + SAREG|AWD, TFLOAT|TDOUBLE, + SANY, ANYFIXED, + NAREG|NASL, RESC1|RESCC, + " cvtZLZF AL,A1\n", + +SCONV, INTAREG|FORCC, + SAREG|SNAME|SCON|STARNM, TANY, + SANY, ANYUSIGNED, + NAREG|NASL, RESC1|RESCC, + " movzZRl AL,A1\n", + +SCONV, INTAREG|FORCC, + SSOREG, TANY, + SANY, ANYUSIGNED, + NAREG|NASL, RESC1|RESCC, + " movzZRl AL,A1\n", + +SCONV, INTAREG|FORCC, + SAREG|SNAME|SCON|STARNM, TANY, + SANY, TANY, + NAREG|NASL, RESC1|RESCC, + " cvtZRl AL,A1\n", + +SCONV, INTAREG|FORCC, + SSOREG, TANY, + SANY, TANY, + NAREG|NASL, RESC1|RESCC, + " cvtZRl AL,A1\n", + + +INIT, FOREFF, + SCON, TANY, + SANY, TWORD, + 0, RNOP, + " .long CL\n", + +INIT, FOREFF, + SCON, TANY, + SANY, TSHORT|TUSHORT, + 0, RNOP, + " .word CL\n", + +INIT, FOREFF, + SCON, TANY, + SANY, TCHAR|TUCHAR, + 0, RNOP, + " .byte CL\n", + + /* for the use of fortran only */ + +GOTO, FOREFF, + SCON, TANY, + SANY, TANY, + 0, RNOP, + " jbr CL\n", + +GOTO, FOREFF, + AWD, TANY, + SANY, TANY, + 0, RNOP, + " jmp *AL\n", + +GOTO, FOREFF, + SAREG, TANY, + SANY, TANY, + 0, RNOP, + " jmp (AL)\n", + +STARG, FORARG, + SCON|SOREG, TANY, + SANY, TANY, + NTEMP+2*NAREG, RESC3, + "ZS", + +STARG, INTEMP, + SAREG, TANY, + SANY, TANY, + NTEMP+2*NAREG, RESC3, + "ZS", + +STASG, FORARG, + SNAME|SOREG, TANY, + SCON|SAREG, TANY, + 0, RNULL, + " subl2 ZT,sp\nZS", + +STASG, FOREFF, + SNAME|SOREG, TANY, + SCON|SAREG, TANY, + 0, RNOP, + "ZS", + +STASG, INAREG, + SNAME|SOREG, TANY, + SCON, TANY, + NAREG, RESC1, + "ZS movl AR,A1\n", + +STASG, INAREG, + SNAME|SOREG, TANY, + SAREG, TANY, + 0, RRIGHT, + " pushl AR\nZS movl (sp)+,AR\n", + +FLD, INAREG|INTAREG, + SANY, TANY, + SFLD, ANYSIGNED, + NAREG|NASR, RESC1, + " extv $H,$S,AR,A1\n", + +FLD, INAREG|INTAREG, + SANY, TANY, + SFLD, ANYUSIGNED, + NAREG|NASR, RESC1, + " extzv $H,$S,AR,A1\n", + +FLD, FORARG, + SANY, TANY, + SFLD, ANYSIGNED, + 0, RNULL, + " extv $H,$S,AR,-(sp)\n", + +FLD, FORARG, + SANY, TANY, + SFLD, ANYUSIGNED, + 0, RNULL, + " extzv $H,$S,AR,-(sp)\n", + +OPLOG, FORCC, + SAREG|AWD, TWORD, + SAREG|AWD, TWORD, + 0, RESCC, + " cmpl AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TSHORT|TUSHORT, + SAREG|AWD, TSHORT|TUSHORT, + 0, RESCC, + " cmpw AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TCHAR|TUCHAR, + SAREG|AWD, TCHAR|TUCHAR, + 0, RESCC, + " cmpb AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TSHORT|TUSHORT, + SSCON, TANY, + 0, RESCC, + " cmpw AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TCHAR|TUCHAR, + SCCON, TANY, + 0, RESCC, + " cmpb AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TDOUBLE, + 0, RESCC, + " cmpd AL,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TFLOAT, + NAREG|NASR, RESCC, + " cvtfd AR,A1\n cmpd AL,A1\nZP", + +OPLOG, FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TDOUBLE, + NAREG|NASL, RESCC, + " cvtfd AL,A1\n cmpd A1,AR\nZP", + +OPLOG, FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TFLOAT, + 0, RESCC, + " cmpf AL,AR\nZP", + +CCODES, INAREG|INTAREG, + SANY, TANY, + SANY, TANY, + NAREG, RESC1, + " movl $1,A1\nZN", + +UNARY CALL, INTAREG, + SCON, TANY, + SANY, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT|TFLOAT|TDOUBLE, + NAREG|NASL, RESC1, /* should be register 0 */ + " calls ZC,CL\n", + +UNARY CALL, INTAREG, + SAREG, TANY, + SANY, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT|TFLOAT|TDOUBLE, + NAREG|NASL, RESC1, /* should be 0 */ + " calls ZC,(AL)\n", + +UNARY CALL, INAREG|INTAREG, + SNAME, TANY, + SANY, TANY, + NAREG|NASL, RESC1, /* really reg 0 */ + " calls ZC,*AL\n", + +UNARY CALL, INAREG|INTAREG, + SSOREG, TANY, + SANY, TANY, + NAREG|NASL, RESC1, /* really reg 0 */ + " calls ZC,*AL\n", + +ASG RS, INAREG|FOREFF|FORCC, + SAREG, TWORD, + SCON, TINT, + 0, RLEFT|RESCC, + " extzv AR,ZU,AL,AL\n", + +ASG RS, INAREG|FOREFF|FORCC, + SAREG, TWORD, + SAREG, ANYFIXED, + NAREG, RLEFT|RESCC, + " subl3 AR,$32,A1\n extzv AR,A1,AL,AL\n", + +ASG RS, INAREG|FOREFF|FORCC, + SAREG, TWORD, + SAREG|AWD, TWORD, + NAREG, RLEFT|RESCC, + " subl3 AR,$32,A1\n extzv AR,A1,AL,AL\n", + +RS, INAREG|INTAREG|FORCC, + SAREG, TWORD, + SCON, TINT, + NAREG|NASL, RESC1|RESCC, + " extzv AR,ZU,AL,A1\n", + +ASG LS, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SAREG|NIAWD, ANYSIGNED|ANYUSIGNED, + 0, RLEFT|RESCC, + " ashl AR,AL,AL\n", + +ASG LS, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SSOREG, ANYSIGNED|ANYUSIGNED, + 0, RLEFT|RESCC, + " ashl AR,AL,AL\n", + +ASG LS, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SOREG, ANYSIGNED|ANYUSIGNED, + NAREG, RLEFT|RESCC, + " ZB AR,A1\n ashl A1,AL,AL\n", + +LS, INAREG|INTAREG|FORCC, + SAREG|AWD, TWORD, + SAREG|NIAWD, ANYSIGNED|ANYUSIGNED, + NAREG|NASL|NASR, RESC1|RESCC, + " ashl AR,AL,A1\n", + +LS, INAREG|INTAREG|FORCC, + SAREG|AWD, TWORD, + SSOREG, ANYSIGNED|ANYUSIGNED, + NAREG|NASL|NASR, RESC1|RESCC, + " ashl AR,AL,A1\n", + +LS, INAREG|INTAREG|FORCC, + SAREG|AWD, TWORD, + SOREG, ANYSIGNED|ANYUSIGNED, + NAREG|NASR, RESC1|RESCC, + " ZB AR,A1\n ashl A1,AL,A1\n", + +INCR, FOREFF, + AWD, TANY, + SCON, TANY, + 0, RLEFT, + " ZE\n", + +DECR, FOREFF, + AWD, TANY, + SCON, TANY, + 0, RLEFT, + " ZE\n", + +INCR, FOREFF, + SAREG, TWORD, + SCON, TANY, + 0, RLEFT, + " ZE\n", + +DECR, FOREFF, + SAREG, TWORD, + SCON, TANY, + 0, RLEFT, + " ZE\n", + +/* jwf INCR and DECR for SAREG TCHAR|TSHORT matched by ASG PLUS etc */ + +INCR, INAREG|INTAREG, + AWD, TANY, + SCON, TANY, + NAREG, RESC1, + " ZD\n", + +DECR, INAREG|INTAREG, + AWD, TANY, + SCON, TANY, + NAREG, RESC1, + " ZD\n", + +INCR, INAREG|INTAREG, + SAREG, TWORD, + SCON, TANY, + NAREG, RESC1, + " ZD\n", + +DECR, INAREG|INTAREG, + SAREG, TWORD, + SCON, TANY, + NAREG, RESC1, + " ZD\n", + +ASSIGN, INAREG|FOREFF|FORCC, + SAREG|AWD, TANY, + SAREG|AWD, TANY, + 0, RLEFT|RRIGHT|RESCC, + " ZA\n", + +ASSIGN, INAREG|FOREFF, + SFLD, TANY, + SAREG|AWD, TWORD, + 0, RRIGHT, + " insv AR,$H,$S,AL\n", + +ASSIGN, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SFLD, ANYSIGNED, + 0, RLEFT|RESCC, + " extv $H,$S,AR,AL\n", + +ASSIGN, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SFLD, ANYUSIGNED, + 0, RLEFT|RESCC, + " extzv $H,$S,AR,AL\n", + +/* dummy UNARY MUL entry to get U* to possibly match OPLTYPE */ +UNARY MUL, FOREFF, + SCC, TANY, + SCC, TANY, + 0, RNULL, + " HELP HELP HELP\n", + +REG, INTEMP, + SANY, TANY, + SAREG, TDOUBLE, + 2*NTEMP, RESC1, + " movd AR,A1\n", + +REG, INTEMP, + SANY, TANY, + SAREG, TANY, + NTEMP, RESC1, + " movZF AR,A1\n", + +#ifdef FORT + REG, FORARG, + SANY, TANY, + SAREG, TFLOAT, + 0, RNULL, + " cvtfd AR,-(sp)\n", + +REG, FORARG, + SANY, TANY, + SAREG, TDOUBLE, + 0, RNULL, + " movZR AR,-(sp)\n", +#endif + +OPLEAF, FOREFF, + SANY, TANY, + SAREG|AWD, TANY, + 0, RLEFT, + "", + +OPLTYPE, INAREG|INTAREG, + SANY, TANY, + SANY, TFLOAT|TDOUBLE, + 2*NAREG|NASR, RESC1, + " ZA\n", + +OPLTYPE, INAREG|INTAREG, + SANY, TANY, + SANY, TANY, + NAREG|NASR, RESC1, + " ZA\n", + +OPLTYPE, FORCC, + SANY, TANY, + SANY, TANY, + 0, RESCC, + " tstZR AR\n", + +OPLTYPE, FORARG, + SANY, TANY, + SANY, TWORD, + 0, RNULL, + " pushl AR\n", + +OPLTYPE, FORARG, + SANY, TANY, + SANY, TCHAR|TSHORT, + 0, RNULL, + " cvtZRl AR,-(sp)\n", + +OPLTYPE, FORARG, + SANY, TANY, + SANY, TUCHAR|TUSHORT, + 0, RNULL, + " movzZRl AR,-(sp)\n", + +OPLTYPE, FORARG, + SANY, TANY, + SANY, TDOUBLE, + 0, RNULL, + " movd AR,-(sp)\n", + +OPLTYPE, FORARG, + SANY, TANY, + SANY, TFLOAT, + 0, RNULL, + " cvtfd AR,-(sp)\n", + +UNARY MINUS, INTAREG|FORCC, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG|TDOUBLE, + SANY, TANY, + NAREG|NASL, RESC1|RESCC, + " mnegZL AL,A1\n", + +COMPL, INTAREG|FORCC, + SAREG|AWD, TINT|TUNSIGNED, + SANY, TANY, + NAREG|NASL, RESC1|RESCC, + " mcomZL AL,A1\n", + +COMPL, INTAREG|FORCC, + SAREG|AWD, ANYSIGNED|ANYUSIGNED, + SANY, TANY, + NAREG|NASL, RESC1|RESCC, + " cvtZLl AL,A1\n mcoml A1,A1\n", + +AND, FORCC, + SAREG|AWD, TWORD, + SCON, TWORD, + 0, RESCC, + " bitl ZZ,AL\n", + +AND, FORCC, + SAREG|AWD, TSHORT|TUSHORT, + SSCON, TWORD, + 0, RESCC, + " bitw ZZ,AL\n", + +AND, FORCC, + SAREG|AWD, TCHAR|TUCHAR, + SCCON, TWORD, + 0, RESCC, + " bitb ZZ,AL\n", + +ASG AND, INAREG|FOREFF|FORCC, + SAREG, TWORD, + SCON, TWORD, + 0, RLEFT|RESCC, + " bicl2 AR,AL\n", + +ASG OPMUL, INAREG|FOREFF|FORCC, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + 0, RLEFT|RESCC, + " OL2 AR,AL\n", + +OPMUL, INAREG|INTAREG|FORCC, + STAREG, TINT|TUNSIGNED|TLONG|TULONG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + 0, RLEFT|RESCC, + " OL2 AR,AL\n", + +OPMUL, INAREG|INTAREG|FORCC, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + NAREG|NASL|NASR, RESC1|RESCC, + " OL3 AR,AL,A1\n", + +ASG MOD, INAREG|INTAREG|FOREFF|FORCC, + SAREG, TINT|TUNSIGNED|TLONG|TULONG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + NAREG, RLEFT|RESCC, + " divl3 AR,AL,A1\n mull2 AR,A1\n subl2 A1,AL\n", + +MOD, INAREG|INTAREG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + SAREG|AWD, TINT|TUNSIGNED|TLONG|TULONG, + NAREG, RESC1, + " divl3 AR,AL,A1\n mull2 AR,A1\n subl3 A1,AL,A1\n", + +ASG PLUS, INAREG|FOREFF|FORCC, + SAREG, TPOINT|TINT|TLONG|TUNSIGNED|TULONG, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " incZL AL\n", + +ASG PLUS, INAREG|FOREFF|FORCC, + AWD, ANYSIGNED|ANYUSIGNED, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " incZL AL\n", + +ASG PLUS, INAREG|FOREFF|FORCC, + SAREG, TSHORT|TCHAR, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " incZL AL\n cvtZLl AL,AL\n", + +ASG PLUS, INAREG|FOREFF|FORCC, + SAREG, TUSHORT|TUCHAR, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " incZL AL\n movzZLl AL,AL\n", + +ASG MINUS, INAREG|FOREFF|FORCC, + SAREG, TPOINT|TINT|TLONG|TUNSIGNED|TULONG, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " decZL AL\n", + +ASG MINUS, INAREG|FOREFF|FORCC, + AWD, ANYSIGNED|ANYUSIGNED, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " decZL AL\n", + +ASG MINUS, INAREG|FOREFF|FORCC, + SAREG, TSHORT|TCHAR, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " decZL AL\n cvtZLl AL,AL\n", + +ASG MINUS, INAREG|FOREFF|FORCC, + SAREG, TUSHORT|TUCHAR, + SONE, TINT|TLONG, + 0, RLEFT|RESCC, + " decZL AL\n movzZLl AL,AL\n", + +PLUS, INAREG|INTAREG|FORCC, + STAREG, TWORD, + SONE, TWORD, + 0, RLEFT|RESCC, + " incZL AL\n", + +PLUS, INAREG|INTAREG|FORCC, + STAREG, TSHORT|TCHAR, + SONE, TWORD, + 0, RLEFT|RESCC, + " incZL AL\n cvtZLl AL,AL\n", + +PLUS, INAREG|INTAREG|FORCC, + STAREG, TUSHORT|TUCHAR, + SONE, TWORD, + 0, RLEFT|RESCC, + " incZL AL\n movzZLl AL,AL\n", + +MINUS, INAREG|INTAREG|FORCC, + STAREG, TWORD, + SONE, TWORD, + 0, RLEFT|RESCC, + " decZL AL\n", + +MINUS, INAREG|INTAREG|FORCC, + STAREG, TSHORT|TCHAR, + SONE, TWORD, + 0, RLEFT|RESCC, + " decZL AL\n cvtZLl AL,AL\n", + +MINUS, INAREG|INTAREG|FORCC, + STAREG, TUSHORT|TUCHAR, + SONE, TWORD, + 0, RLEFT|RESCC, + " decZL AL\n movzZLl AL,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG|AWD, TWORD, + SAREG|AWD, TWORD, + 0, RLEFT|RESCC, + " OL2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG, TWORD, + SAREG, TSHORT|TUSHORT|TCHAR|TUCHAR, + 0, RLEFT|RESCC, + " OL2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + AWD, TSHORT|TUSHORT, + SAREG|AWD, TSHORT|TUSHORT, + 0, RLEFT|RESCC, + " OW2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + AWD, TSHORT|TUSHORT, + SSCON, TWORD, + 0, RLEFT|RESCC, + " OW2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + AWD, TCHAR|TUCHAR, + SAREG|AWD, TCHAR|TUCHAR, + 0, RLEFT|RESCC, + " OB2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + AWD, TCHAR|TUCHAR, + SCCON, TWORD, + 0, RLEFT|RESCC, + " OB2 AR,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG, TSHORT, + SAREG|AWD, ANYFIXED, + 0, RLEFT|RESCC, + " OW2 AR,AL\n cvtZLl AL,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG, TUSHORT, + SAREG|AWD, ANYFIXED, + 0, RLEFT|RESCC, + " OW2 AR,AL\n movzZLl AL,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG, TCHAR, + SAREG|AWD, ANYFIXED, + 0, RLEFT|RESCC, + " OB2 AR,AL\n cvtZLl AL,AL\n", + +ASG OPSIMP, INAREG|FOREFF|FORCC, + SAREG, TUCHAR, + SAREG|AWD, ANYFIXED, + 0, RLEFT|RESCC, + " OB2 AR,AL\n movzZLl AL,AL\n", + +OPSIMP, INAREG|INTAREG|FORCC, + STAREG, ANYFIXED, + SAREG|AWD, TWORD, + 0, RLEFT|RESCC, + " OL2 AR,AL\n", + +OPSIMP, INAREG|INTAREG|FORCC, + SAREG|AWD, TWORD, + SAREG|AWD, TWORD, + NAREG|NASL|NASR, RESC1|RESCC, + " OL3 AR,AL,A1\n", + +ASG OPFLOAT, INAREG|FOREFF|FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TDOUBLE, + 0, RLEFT|RESCC, + " OD2 AR,AL\n", + +ASG OPFLOAT, INAREG|FOREFF|FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TFLOAT, + 0, RLEFT|RESCC, + " OF2 AR,AL\n", + +ASG OPFLOAT, INAREG|FOREFF|FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TFLOAT, + NAREG|NASR, RLEFT|RESCC, + " cvtfd AR,A1\n OD2 A1,AL\n", + +ASG OPFLOAT, INAREG|INTAREG|FOREFF|FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TDOUBLE, + NAREG, RLEFT|RESC1|RESCC, + " cvtfd AL,A1\n OD2 AR,A1\n cvtdf A1,AL\n", + +OPFLOAT, INAREG|INTAREG|FORCC, + STAREG, TDOUBLE, + SAREG|AWD, TDOUBLE, + 0, RLEFT|RESCC, + " OD2 AR,AL\n", + +OPFLOAT, INAREG|INTAREG|FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TDOUBLE, + NAREG|NASL|NASR, RESC1|RESCC, + " OD3 AR,AL,A1\n", + +OPFLOAT, INAREG|INTAREG|FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TDOUBLE, + NAREG|NASL, RESC1|RESCC, + " cvtfd AL,A1\n OD2 AR,A1\n", + +OPFLOAT, INAREG|INTAREG|FORCC, + SAREG|AWD, TDOUBLE, + SAREG|AWD, TFLOAT, + NAREG|NASR, RESC1|RESCC, + " cvtfd AR,A1\n OD3 A1,AL,A1\n", + +#ifdef FLOAT +OPFLOAT, INAREG|INTAREG|FORCC, + STAREG, TFLOAT, + SAREG|AWD, TFLOAT, + 0, RLEFT|RESCC, + " OF2 TAR,AL\n", + +OPFLOAT, INAREG|INTAREG|FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TFLOAT, + NAREG|NASL|NASR, RESC1|RESCC, + " OF3 AR,AL,TA1\n", + +#else +OPFLOAT, INAREG|INTAREG|FORCC, + SAREG|AWD, TFLOAT, + SAREG|AWD, TFLOAT, + NAREG|NASL|NASR, RESC1|RESCC, + " OF3 AR,AL,A1\n cvtfd A1,A1\n", +#endif + + /* Default actions for hard trees ... */ + +# define DF(x) FORREW,SANY,TANY,SANY,TANY,REWRITE,x,"" + +UNARY MUL, DF( UNARY MUL ), + +INCR, DF(INCR), + +DECR, DF(INCR), + +ASSIGN, DF(ASSIGN), + +STASG, DF(STASG), + +FLD, DF(FLD), + +OPLEAF, DF(NAME), + +OPLOG, FORCC, + SANY, TANY, + SANY, TANY, + REWRITE, BITYPE, + "", + +OPLOG, DF(NOT), + +COMOP, DF(COMOP), + +INIT, DF(INIT), + +OPUNARY, DF(UNARY MINUS), + + +ASG OPANY, DF(ASG PLUS), + +OPANY, DF(BITYPE), + +FREE, FREE, FREE, FREE, FREE, FREE, FREE, FREE, "help; I'm in trouble\n" }; diff --git a/usr/src/cmd/pcc/makefile b/usr/src/cmd/pcc/makefile new file mode 100644 index 0000000000..b207e63844 --- /dev/null +++ b/usr/src/cmd/pcc/makefile @@ -0,0 +1,91 @@ +TESTDIR = . +FRC = +CFLAGS = -O -DASSTRINGS -DSTABDOT -DLCOMM -DBUFSTDERR -DFLEXNAMES +M=../mip +all: comp fort +comp: rodata.o cgram.o xdefs.o scan.o pftn.o trees.o optim.o code.o local.o \ + reader.o local2.o order.o match.o allo.o comm1.o table.o + $(CC) $(LDFLAGS) -z rodata.o cgram.o xdefs.o scan.o pftn.o trees.o \ + optim.o code.o local.o reader.o local2.o order.o match.o \ + allo.o comm1.o table.o -o $(TESTDIR)/comp +trees.o: $M/manifest macdefs $M/mfile1 $M/trees.c + $(CC) -c $(CFLAGS) -I$M -I. $M/trees.c +optim.o: $M/manifest macdefs $M/mfile1 $M/optim.c + $(CC) -c $(CFLAGS) -I$M -I. $M/optim.c +pftn.o: $M/manifest macdefs $M/mfile1 $M/pftn.c + $(CC) -c $(CFLAGS) -I$M -I. $M/pftn.c +code.o: $M/manifest macdefs $M/mfile1 + $(CC) -c $(CFLAGS) -I$M -I. code.c +local.o: $M/manifest macdefs $M/mfile1 + $(CC) -c $(CFLAGS) -I$M -I. local.c +scan.o: $M/manifest macdefs $M/mfile1 $M/scan.c + $(CC) -c $(CFLAGS) -I$M -I. $M/scan.c +xdefs.o: $M/manifest $M/mfile1 macdefs $M/xdefs.c + $(CC) -c $(CFLAGS) -I$M -I. $M/xdefs.c +cgram.o: $M/manifest $M/mfile1 macdefs cgram.c + $(CC) -c $(CFLAGS) -I$M -I. cgram.c +rodata.o: rodata.c + $(CC) $(CFLAGS) -S rodata.c + ./:rofix rodata.s + $(AS) -o rodata.o rodata.s + rm -f rodata.s +rodata.c cgram.c: $M/cgram.y + $(YACC) $M/cgram.y + rm -f rodata.c + ./:yyfix yyexca yyact yypact yypgo yyr1 yyr2 yychk yydef + mv y.tab.c cgram.c +comm1.o: $M/manifest $M/mfile1 $M/common macdefs $M/comm1.c + $(CC) -c $(CFLAGS) -I$M -I. $M/comm1.c +table.o: $M/manifest $M/mfile2 mac2defs macdefs table.c + $(CC) $(CFLAGS) -S -I$M -I. table.c + ./:rofix table.s + $(AS) -o table.o table.s + rm -f table.s +reader.o: $M/manifest $M/mfile2 mac2defs macdefs $M/reader.c + $(CC) -c $(CFLAGS) -I$M -I. $M/reader.c +local2.o: $M/manifest $M/mfile2 mac2defs macdefs + $(CC) -c $(CFLAGS) -I$M -I. local2.c +order.o: $M/manifest $M/mfile2 mac2defs macdefs + $(CC) -c $(CFLAGS) -I$M -I. order.c +match.o: $M/manifest $M/mfile2 mac2defs macdefs $M/match.c + $(CC) -c $(CFLAGS) -I$M -I. $M/match.c +allo.o: $M/manifest $M/mfile2 mac2defs macdefs $M/allo.c + $(CC) -c $(CFLAGS) -I$M -I. $M/allo.c +shrink: + rm *.o comp +clean: + rm -f *.o comp fort cgram.c rodata.c +lintall: + lint -hpv -I. -I$M $M/cgram.c $M/xdefs.c $M/scan.c $M/pftn.c \ + $M/trees.c $M/optim.c code.c local.c $M/reader \ + local2.c order.c $M/match.c $M/allo.c $M/comm1.c table.c +fort: comp fort.o freader.o fallo.o fmatch.o ftable.o forder.o flocal2.o \ + fcomm2.o + $(CC) -z $(CFLAGS) fort.o freader.o fallo.o fmatch.o ftable.o \ + forder.o flocal2.o fcomm2.o -o $(TESTDIR)/fort +fort.o: fort.h $M/fort.c + $(CC) -c $(CFLAGS) -I$M -I. $M/fort.c +freader.o: reader.o + $(CC) -c $(CFLAGS) -I$M -I. $M/freader.c +fallo.o: allo.o + $(CC) -c $(CFLAGS) -I$M -I. $M/fallo.c +fmatch.o: match.o + $(CC) -c $(CFLAGS) -I$M -I. $M/fmatch.c +ftable.o: UCtable.c + $(CC) -c -R $(CFLAGS) -DFORT -I$M -I. UCtable.c + mv UCtable.o ftable.o +forder.o: order.o + $(CC) -c $(CFLAGS) -I$M -I. $M/forder.c +flocal2.o: UClocal2.c + $(CC) -c $(CFLAGS) -DFORT -I$M -I. UClocal2.c + mv UClocal2.o flocal2.o +fcomm2.o: $M/common + $(CC) -c $(CFLAGS) -I$M -I. $M/fcomm2.c +fort.o freader.o fallo.o fmatch.o ftable.o forder.o flocal2.o fcomm2.o: \ + $M/mfile2 $M/manifest macdefs mac2defs +install: all + strip fort comp + rm -f ${DESTDIR}/lib/ccom + cp comp ${DESTDIR}/lib/ccom + rm -f ${DESTDIR}/lib/f1 + cp fort ${DESTDIR}/lib/f1 -- 2.20.1