[unix-history] / usr / src / cmd / pcc / local2.c

# include "mfile2"
/* a lot of the machine dependent parts of the second pass */

# define BITMASK(n) ((1L<<n)-1)

lineid( l, fn ) char *fn; {
	/* identify line l and file fn */
	printf( "/	line %d, file %s\n", l, fn );
	}

eobl2(){
	OFFSZ spoff;	/* offset from stack pointer */

	spoff = maxoff;
	if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
	spoff /= SZCHAR;
	SETOFF(spoff,2);
	printf( "	.F%d = %Ld.\n", ftnno, spoff );
	if( fltused ) {
		fltused = 0;
		printf( "	.globl	fltused\n" );
		}
	}

struct hoptab { int opmask; char * opstring; } ioptab[]= {

	ASG PLUS, "add",
	ASG MINUS, "sub",
	ASG OR,	"bis",
	ASG AND,	"bic",
	ASG ER,	"xor",
	ASG MUL, "mul",
	ASG DIV, "div",
	ASG MOD, "div",
	ASG LS,	"asl",
	ASG RS,	"asr",

	-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 );
			if( f == 'F' ) printf( "f" );
			return;
			}
		}
	cerror( "no hoptab for %s", opst[o] );
	}

char *
rnames[]= {  /* keyed to register number tokens */

	"r0", "r1",
	"r2", "r3", "r4",
	"r5", "sp", "pc",

	"fr0", "fr1", "fr2", "fr3",
	"fr4", "fr5",	/* not accumulators - used for temps */
	};

int rstatus[] = {
	SAREG|STAREG, SAREG|STAREG,
	SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,	/* use as scratch if not reg var */
	SAREG, SAREG, SAREG,

	SBREG|STBREG, SBREG|STBREG, SBREG|STBREG, SBREG|STBREG,
	SBREG, SBREG,
	};

NODE *brnode;
int brcase;

int toff = 0; /* number of stack locations used for args */

zzzcode( p, c ) NODE *p; {
	register m;
	switch( c ){

	case 'B':	/* output b if type is byte */
		if( p->type == CHAR || p->type == UCHAR ) printf( "b" );
		return;

	case 'N':  /* logical ops, turned into 0-1 */
		/* use register given by register 1 */
		cbgen( 0, m=getlab(), 'I' );
		deflab( p->label );
		printf( "	clr	%s\n", rnames[getlr( p, '1' )->rval] );
		if( p->type == LONG || p->type == ULONG )
			printf( "	clr	%s\n", rnames[getlr( p, '1' )->rval + 1] );
		deflab( m );
		return;

	case 'I':
	case 'F':
		cbgen( p->op, p->label, c );
		return;

	case 'A':
	case 'C':
		/* logical operators for longs
		   defer comparisons until branch occurs */

		brnode = tcopy( p );
		brcase = c;
		return;

	case 'H':  /* fix up unsigned shifts */
		{	register NODE *q;
			register r, l;
			TWORD t;

			if( p->op == ASG LS ) return;
			if( p->op != ASG RS ) cerror( "ZH bad" );
			if( p->left->op != REG ) cerror( "SH left bad" );

			r = p->left->rval;
			t = p->left->type;
			l = (t==LONG || t == ULONG );

			if( t != UNSIGNED && t != UCHAR && t != ULONG ) return;  /* signed is ok */

			/* there are three cases:  right side is a constant,
				and has the shift value; right side is
				a temporary reg, and has the - shift value,
				and right side is something else: A1 has the
				- shift value then */

			/* in the case where the value is known (rhs a constant),
				the mask is just computed and put out... */

			if( p->right->op == ICON ){
				int s;
				s = p->right->lval;
				if( l ){
					if( s >= 16 ){
						printf( "	clr	r%d\n", r );
						s -= 16;
						++r;
						}
					}
				if( s >= 16 ) printf( "	clr	r%d\n", r );
				else {
					m = 0100000;
					m >>= s;  /* sign extends... */
					m <<= 1;
					printf( "	bic	$%o,r%d\n", m, r );
					}
				return;
				}

			/* general case */

			if( istnode( p->right ) ) q = p->right;
			else q = getlr( p, '1' );  /* where -shift is stored */

			/* first, we store the shifted value on the stack */
			printf( "	mov	r%d,-(sp)\n", r );
			if( l ) printf( "	mov	r%d,-(sp)\n", r+1 );

			/* now, make a mask */

			printf( "	mov	$100000,r%d\n", r );
			if( l ) printf( "	clr	r%d\n", r+1 );
			
			/* shift (arithmetically ) */
			if( l ) expand( q, RNOP, "	ashc	AR" );
			else expand( q, RNOP, "	ash	AR" );
			printf( ",r%d\n", r );

			if( l ) printf( "	ashc	$1,r%d\n", r );
			else printf( "	asl	r%d\n", r );

			/* now, we have a mask: use it to clear sp, and reload */

			if( l ){
				printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r+1, r+1 );
				}
			printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r, r );
			/* whew! */
			return;
			}

	case 'V':
		/* sign extend or not -- register is one less than the
		   left descendent */

		m = p->left->rval - 1;

		if( ISUNSIGNED(p->type) ){
			printf( "	clr	r%d\n", m );
			}
		else {
			printf( "	sxt	r%d\n", m );
			}
		return;

		/* stack management macros */
	case '-':
		if( toff ++ ) printf( "-" );
		printf( "(sp)" );
		return;

	case '4':
		if( toff == 0 ) ++toff;  /* can't push doubles that way */
		printf( "-(sp)" );
		toff += 4;
		return;

	case '~':
		/* complimented CR */
		p->right->lval = ~p->right->lval;
		conput( getlr( p, 'R' ) );
		p->right->lval = ~p->right->lval;
		return;

	case 'M':
		/* negated CR */
		p->right->lval = -p->right->lval;
		conput( getlr( p, 'R' ) );
		p->right->lval = -p->right->lval;
		return;

	case 'L':  /* INIT for long constants */
		{
			unsigned hi, lo;
			lo = p->left->lval & BITMASK(SZINT);
			hi = ( p->left->lval >> SZINT ) & BITMASK(SZINT);
			printf( "	%o; %o\n", hi, lo );
			return;
		}

	case 'T':
		/* Truncate longs for type conversions:
		    LONG|ULONG -> CHAR|UCHAR|INT|UNSIGNED
		   increment offset to second word */

		m = p->type;
		p = p->left;
		switch( p->op ){
		case NAME:
		case OREG:
			p->lval += SZINT/SZCHAR;
			return;
		case REG:
			rfree( p->rval, p->type );
			p->rval += 1;
			p->type = m;
			rbusy( p->rval, p->type );
			return;
		default:
			cerror( "Illegal ZT type conversion" );
			return;

			}

	case 'U':
		/* same as AL for exp under U* */
		if( p->left->op == UNARY MUL ) {
			adrput( getlr( p->left, 'L' ) );
			return;
			}
		cerror( "Illegal ZU" );
		/* NO RETURN */

	case 'W':	/* structure size */
		if( p->op == STASG )
			printf( "%d", p->stsize);
		else	cerror( "Not a structure" );
		return;

	case 'S':  /* structure assignment */
		{
			register NODE *l, *r;
			register size, count;

			if( p->op == STASG ){
				l = p->left;
				r = p->right;
				}
			else if( p->op == STARG ){  /* store an arg onto the stack */
				r = p->left;
				}
			else cerror( "STASG bad" );

			if( r->op == ICON ) r->op = NAME;
			else if( r->op == REG ) r->op = OREG;
			else if( r->op != OREG ) cerror( "STASG-r" );

			size = p->stsize;
			count = size / 2;

			r->lval += size;
			if( p->op == STASG ) l->lval += size;

			while( count-- ){ /* simple load/store loop */
				r->lval -= 2;
				expand( r, FOREFF, "	mov	AR," );
				if( p->op == STASG ){
					l->lval -= 2;
					expand( l, FOREFF, "AR\n" );
					}
				else {
					printf( "-(sp)\n" );
					}

				}

			if( r->op == NAME ) r->op = ICON;
			else if( r->op == OREG ) r->op = REG;

			}
		break;

	default:
		cerror( "illegal zzzcode" );
		}
	}

rmove( rt, rs, t ) TWORD t; {
	printf( "	%s	%s,%s\n", (t==FLOAT||t==DOUBLE)?"movf":"mov", rnames[rs], rnames[rt] );
	}

struct respref
respref[] = {
	INTAREG|INTBREG,	INTAREG|INTBREG,
	INAREG|INBREG,	INAREG|INBREG|SOREG|STARREG|SNAME|STARNM|SCON,
	INTEMP,	INTEMP,
	FORARG,	FORARG,
	INTAREG,	SOREG|SNAME,
	0,	0 };

setregs(){ /* set up temporary registers */
	register i;

	/* use any unused variable registers as scratch registers */
	fregs = maxtreg>=MINRVAR ? maxtreg + 1 : MINRVAR;
	if( xdebug ){
		/* -x changes number of free regs to 2, -xx to 3, etc. */
		if( (xdebug+1) < fregs ) fregs = xdebug+1;
		}
	/* NOTE: for pdp11 fregs <= 4 for float regs */
	if( fregs > 4 ) fregs = 4;
	for( i=MINRVAR; i<=MAXRVAR; i++ )
		rstatus[i] = i<fregs ? SAREG|STAREG : SAREG;
	}

szty(t) TWORD t; { /* size, in words, needed to hold thing of type t */
	/* really is the number of registers to hold type t */
	switch( t ) {

	case LONG:
	case ULONG:
		return( SZLONG/SZINT );

	default:
		return(1);

		}
	}

rewfld( p ) NODE *p; {
	return(1);
	}

callreg(p) NODE *p; {
	return( (p->type==DOUBLE||p->type==FLOAT) ? FR0 : R0 );
	}

shltype( o, p ) NODE *p; {
	if( o == NAME|| o==REG || o == ICON || o == OREG ) return( 1 );
	return( o==UNARY MUL && shumul(p->left) );
	}

flshape( p ) register NODE *p; {
	register o = p->op;
	if( o==NAME || o==REG || o==ICON || o==OREG ) return( 1 );
	return( o==UNARY MUL && shumul(p->left)==STARNM );
	}

shtemp( p ) register NODE *p; {
	if( p->op == UNARY MUL ) p = p->left;
	if( p->op == REG || p->op == OREG ) return( !istreg( p->rval ) );
	return( p->op == NAME || p->op == ICON );
	}

spsz( t, v ) TWORD t; CONSZ v; {

	/* is v the size to increment something of type t */

	if( !ISPTR(t) ) return( 0 );
	t = DECREF(t);

	if( ISPTR(t) ) return( v == 2 );

	switch( t ){

	case UCHAR:
	case CHAR:
		return( v == 1 );

	case INT:
	case UNSIGNED:
		return( v == 2 );

	case FLOAT:
		return( v == 4 );

	case DOUBLE:
		return( v == 8 );
		}

	return( 0 );
	}

shumul( p ) register NODE *p; {
	register o;

	o = p->op;
	if( o == NAME || o == OREG || o == ICON ) return( STARNM );

	if( ( o == INCR || o == ASG MINUS ) &&
	    ( p->left->op == REG && p->right->op == ICON ) &&
	    p->right->name[0] == '\0' &&
	    spsz( p->left->type, p->right->lval ) )
		return( STARREG );

	return( 0 );
	}

adrcon( val ) CONSZ val; {
	printf( CONFMT, val );
	}

conput( p ) register NODE *p; {
	switch( p->op ){

	case ICON:
		acon( p );
		return;

	case REG:
		printf( "%s", rnames[p->rval] );
		return;

	default:
		cerror( "illegal conput" );
		}
	}

insput( p ) NODE *p; {
	cerror( "insput" );
	}

upput( p ) NODE *p; {
	/* output the address of the second word in the
	   pair pointed to by p (for LONGs)*/
	CONSZ save;

	if( p->op == FLD ){
		p = p->left;
		}

	save = p->lval;
	switch( p->op ){

	case NAME:
		p->lval += SZINT/SZCHAR;
		acon( p );
		break;

	case ICON:
		/* addressable value of the constant */
		p->lval &= BITMASK(SZINT);
		printf( "$" );
		acon( p );
		break;

	case REG:
		printf( "%s", rnames[p->rval+1] );
		break;

	case OREG:
		p->lval += SZINT/SZCHAR;
		if( p->rval == R5 ){  /* in the argument region */
			if( p->name[0] != '\0' ) werror( "bad arg temp" );
			}
		if( p->lval != 0 || p->name[0] != '\0' ) acon( p );
		printf( "(%s)", rnames[p->rval] );
		break;

	default:
		cerror( "illegal upper address" );
		break;

		}
	p->lval = save;

	}

adrput( p ) register NODE *p; {
	/* output an address, with offsets, from p */

	if( p->op == FLD ){
		p = p->left;
		}
	switch( p->op ){

	case NAME:
		acon( p );
		return;

	case ICON:
		/* addressable value of the constant */
		if( szty( p->type ) == 2 ) {
			/* print the high order value */
			CONSZ save;
			save = p->lval;
			p->lval = ( p->lval >> SZINT ) & BITMASK(SZINT);
			printf( "$" );
			acon( p );
			p->lval = save;
			return;
			}
		printf( "$" );
		acon( p );
		return;

	case REG:
		printf( "%s", rnames[p->rval] );
		return;

	case OREG:
		if( p->rval == R5 ){  /* in the argument region */
			if( p->name[0] != '\0' ) werror( "bad arg temp" );
			printf( CONFMT, p->lval );
			printf( ".(r5)" );
			return;
			}
		if( p->lval != 0 || p->name[0] != '\0' ) acon( p );
		printf( "(%s)", rnames[p->rval] );
		return;

	case UNARY MUL:
		/* STARNM or STARREG found */
		if( tshape(p, STARNM) ) {
			printf( "*" );
			adrput( p->left);
			}
		else {	/* STARREG - really auto inc or dec */
			/* turn into OREG so replacement node will
			   reflect the value of the expression */
			register i;
			register NODE *q, *l;

			l = p->left;
			q = l->left;
			p->op = OREG;
			p->rall = q->rall;
			p->lval = q->lval;
			p->rval = q->rval;
			for( i=0; i<NCHNAM; i++ )
				p->name[i] = q->name[i];
			if( l->op == INCR ) {
				adrput( p );
				printf( "+" );
				p->lval -= l->right->lval;
				}
			else {	/* l->op == ASG MINUS */
				printf( "-" );
				adrput( p );
				}
			tfree( l );
		}
		return;

	default:
		cerror( "illegal address" );
		return;

		}

	}

acon( p ) register NODE *p; { /* print out a constant */

	if( p->name[0] == '\0' ){	/* constant only */
		printf( CONFMT, p->lval);
		printf( "." );
		}
	else if( p->lval == 0 ) {	/* name only */
		printf( "%.8s", p->name );
		}
	else {				/* name + offset */
		printf( "%.8s+", p->name );
		printf( CONFMT, p->lval );
		printf( "." );
		}
	}

genscall( p, cookie ) register NODE *p; {
	/* structure valued call */
	return( gencall( p, cookie ) );
	}

gencall( p, cookie ) register NODE *p; {
	/* generate the call given by p */
	register temp;
	register m;

	if( p->right ) temp = argsize( p->right );
	else temp = 0;

	if( p->right ){ /* generate args */
		genargs( p->right );
		}

	if( !shltype( p->left->op, p->left ) ) {
		order( p->left, INAREG|SOREG );
		}

	p->op = UNARY CALL;
	m = match( p, INTAREG|INTBREG );
	popargs( temp );
	return(m != MDONE);
	}

popargs( size ) register size; {
	/* pop arguments from stack */

	toff -= size/2;
	if( toff == 0 && size >= 2 ) size -= 2;
	switch( size ) {
	case 0:
		break;
	case 2:
		printf( "	tst	(sp)+\n" );
		break;
	case 4:
		printf( "	cmp	(sp)+,(sp)+\n" );
		break;
	default:
		printf( "	add	$%d.,sp\n", size);
		}
	}

char *
ccbranches[] = {
	"	jeq	L%d\n",
	"	jne	L%d\n",
	"	jle	L%d\n",
	"	jlt	L%d\n",
	"	jge	L%d\n",
	"	jgt	L%d\n",
	"	jlos	L%d\n",
	"	jlo	L%d\n",
	"	jhis	L%d\n",
	"	jhi	L%d\n",
	};

/*	long branch table

   This table, when indexed by a logical operator,
   selects a set of three logical conditions required
   to generate long comparisons and branches.  A zero
   entry indicates that no branch is required.
   E.G.:  The <= operator would generate:
	cmp	AL,AR
	jlt	lable	/ 1st entry LT -> lable
	jgt	1f	/ 2nd entry GT -> 1f
	cmp	UL,UR
	jlos	lable	/ 3rd entry ULE -> lable
   1:
 */

int lbranches[][3] = {
	/*EQ*/	0,	NE,	EQ,
	/*NE*/	NE,	0,	NE,
	/*LE*/	LT,	GT,	ULE,
	/*LT*/	LT,	GT,	ULT,
	/*GE*/	GT,	LT,	UGE,
	/*GT*/	GT,	LT,	UGT,
	/*ULE*/	ULT,	UGT,	ULE,
	/*ULT*/	ULT,	UGT,	ULT,
	/*UGE*/	UGT,	ULT,	UGE,
	/*UGT*/	UGT,	ULT,	UGT,
	};

/* logical relations when compared in reverse order (cmp R,L) */
extern short revrel[] ;

cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */
	register *plb;
	int lab1f;

	if( o == 0 ) printf( "	jbr	L%d\n", lab );
	else	if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
	else {
		switch( brcase ) {

		case 'A':
		case 'C':
			plb = lbranches[ o-EQ ];
			lab1f = getlab();
			expand( brnode, FORCC, brcase=='C' ? "\tcmp\tAL,AR\n" : "\ttst\tAR\n" );
			if( *plb != 0 )
				printf( ccbranches[*plb-EQ], lab);
			if( *++plb != 0 )
				printf( ccbranches[*plb-EQ], lab1f);
			expand( brnode, FORCC, brcase=='C' ? "\tcmp\tUL,UR\n" : "\ttst\tUR\n" );
			printf( ccbranches[*++plb-EQ], lab);
			deflab( lab1f );
			reclaim( brnode, RNULL, 0 );
			break;

		default:
			if( mode=='F' ) o = revrel[ o-EQ ];
			printf( ccbranches[o-EQ], lab );
			break;
			}

		brcase = 0;
		brnode = 0;
		}
	}

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->op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG );
	return( FORREW );
	}

lastchance( p, cook ) NODE *p; {
	/* forget it! */
	return(0);
	}

struct functbl {
	int fop;
	TWORD ftype;
	char *func;
	} opfunc[] = {
	MUL,		LONG,	"lmul",
	DIV,		LONG,	"ldiv",
	MOD,		LONG,	"lrem",
	ASG MUL,	LONG,	"almul",
	ASG DIV,	LONG,	"aldiv",
	ASG MOD,	LONG,	"alrem",
	MUL,		ULONG,	"lmul",
	DIV,		ULONG,	"uldiv",
	MOD,		ULONG,	"ulrem",
	ASG MUL,	ULONG,	"almul",
	ASG DIV,	ULONG,	"auldiv",
	ASG MOD,	ULONG,	"aulrem",
	0,	0,	0 };

hardops(p)  register NODE *p; {
	/* change hard to do operators into function calls.
	   for pdp11 do long * / %	*/
	register NODE *q;
	register struct functbl *f;
	register o;
	register TWORD t;

	o = p->op;
	t = p->type;
	if( t!=LONG && t!=ULONG ) return;

	for( f=opfunc; f->fop; f++ ) {
		if( o==f->fop && t==f->ftype ) goto convert;
		}
	return;

	/* need address of left node for ASG OP */
	/* WARNING - this won't work for long in a REG */
	convert:
	if( asgop( o ) ) {
		switch( p->left->op ) {

		case UNARY MUL:	/* convert to address */
			p->left->op = FREE;
			p->left = p->left->left;
			break;

		case NAME:	/* convert to ICON pointer */
			p->left->op = ICON;
			p->left->type = INCREF( p->left->type );
			break;

		case OREG:	/* convert OREG to address */
			p->left->op = REG;
			p->left->type = INCREF( p->left->type );
			if( p->left->lval != 0 ) {
				q = talloc();
				q->op = PLUS;
				q->rall = NOPREF;
				q->type = p->left->type;
				q->left = p->left;
				q->right = talloc();

				q->right->op = ICON;
				q->right->rall = NOPREF;
				q->right->type = INT;
				q->right->name[0] = '\0';
				q->right->lval = p->left->lval;
				q->right->rval = 0;

				p->left->lval = 0;
				p->left = q;
				}
			break;

		default:
			cerror( "Bad address for hard ops" );
			/* NO RETURN */

			}
		}

	/* build comma op for args to function */
	q = talloc();
	q->op = CM;
	q->rall = NOPREF;
	q->type = INT;
	q->left = p->left;
	q->right = p->right;
	p->op = CALL;
	p->right = q;

	/* put function name in left node of call */
	p->left = q = talloc();
	q->op = ICON;
	q->rall = NOPREF;
	q->type = INCREF( FTN + p->type );
	strcpy( q->name, f->func );
	q->lval = 0;
	q->rval = 0;

	return;

	}

optim2( p ) register NODE *p; {
	/* do local tree transformations and optimizations */

	register NODE *r;

	switch( p->op ) {

	case AND:
		/* commute L and R to eliminate compliments and constants */
		if( p->left->op==ICON || p->left->op==COMPL ) {
			r = p->left;
			p->left = p->right;
			p->right = r;
			}
	case ASG AND:
		/* change meaning of AND to ~R&L - bic on pdp11 */
		r = p->right;
		if( r->op==ICON ) { /* compliment constant */
			r->lval = ~r->lval;
			}
		else if( r->op==COMPL ) { /* ~~A => A */
			r->op = FREE;
			p->right = r->left;
			}
		else { /* insert complement node */
			p->right = talloc();
			p->right->op = COMPL;
			p->right->rall = NOPREF;
			p->right->type = r->type;
			p->right->left = r;
			p->right->right = NULL;
			}
		break;

		}
	}

myreader(p) register NODE *p; {
	walkf( p, hardops );	/* convert ops to function calls */
	canon( p );		/* expands r-vals for fileds */
	walkf( p, optim2 );
	toff = 0;  /* stack offset swindle */
	}

special( p, shape ) register NODE *p; {
	/* special shape matching routine */

	switch( shape ) {

	case SCCON:
		if( p->op == ICON && p->name[0]=='\0' && p->lval>= -128 && p->lval <=127 ) return( 1 );
		break;

	case SICON:
		if( p->op == ICON && p->name[0]=='\0' && p->lval>= 0 && p->lval <=32767 ) return( 1 );
		break;

	default:
		cerror( "bad special shape" );

		}

	return( 0 );
	}

# ifndef ONEPASS
main( argc, argv ) char *argv[]; {
	return( mainp2( argc, argv ) );
	}
# endif
Commit	Line	Data
3c5d933b SJ	1	# include "mfile2"
	2	/* a lot of the machine dependent parts of the second pass */
	3
	4	# define BITMASK(n) ((1L<<n)-1)
	5
	6	lineid( l, fn ) char *fn; {
	7	/* identify line l and file fn */
	8	printf( "/ line %d, file %s\n", l, fn );
	9	}
	10
	11	eobl2(){
	12	OFFSZ spoff; /* offset from stack pointer */
	13
	14	spoff = maxoff;
	15	if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
	16	spoff /= SZCHAR;
	17	SETOFF(spoff,2);
	18	printf( " .F%d = %Ld.\n", ftnno, spoff );
	19	if( fltused ) {
	20	fltused = 0;
	21	printf( " .globl fltused\n" );
	22	}
	23	}
	24
	25	struct hoptab { int opmask; char * opstring; } ioptab[]= {
	26
	27	ASG PLUS, "add",
	28	ASG MINUS, "sub",
	29	ASG OR, "bis",
	30	ASG AND, "bic",
	31	ASG ER, "xor",
	32	ASG MUL, "mul",
	33	ASG DIV, "div",
	34	ASG MOD, "div",
	35	ASG LS, "asl",
	36	ASG RS, "asr",
	37
	38	-1, "" };
	39
	40	hopcode( f, o ){
	41	/* output the appropriate string from the above table */
	42
	43	register struct hoptab *q;
	44
	45	for( q = ioptab; q->opmask>=0; ++q ){
	46	if( q->opmask == o ){
	47	printf( "%s", q->opstring );
	48	if( f == 'F' ) printf( "f" );
	49	return;
	50	}
	51	}
	52	cerror( "no hoptab for %s", opst[o] );
	53	}
	54
	55	char *
	56	rnames[]= { /* keyed to register number tokens */
	57
	58	"r0", "r1",
	59	"r2", "r3", "r4",
	60	"r5", "sp", "pc",
	61
	62	"fr0", "fr1", "fr2", "fr3",
	63	"fr4", "fr5", /* not accumulators - used for temps */
	64	};
65
66	int rstatus[] = {
67	SAREG\|STAREG, SAREG\|STAREG,
68	SAREG\|STAREG, SAREG\|STAREG, SAREG\|STAREG, /* use as scratch if not reg var */
69	SAREG, SAREG, SAREG,
70
71	SBREG\|STBREG, SBREG\|STBREG, SBREG\|STBREG, SBREG\|STBREG,
72	SBREG, SBREG,
73	};
74
75	NODE *brnode;
76	int brcase;
77
78	int toff = 0; /* number of stack locations used for args */
79
80	zzzcode( p, c ) NODE *p; {
81	register m;
82	switch( c ){
83
84	case 'B': /* output b if type is byte */
85	if( p->type == CHAR \|\| p->type == UCHAR ) printf( "b" );
86	return;
87
88	case 'N': /* logical ops, turned into 0-1 */
89	/* use register given by register 1 */
90	cbgen( 0, m=getlab(), 'I' );
91	deflab( p->label );
92	printf( " clr %s\n", rnames[getlr( p, '1' )->rval] );
93	if( p->type == LONG \|\| p->type == ULONG )
94	printf( " clr %s\n", rnames[getlr( p, '1' )->rval + 1] );
95	deflab( m );
96	return;
97
98	case 'I':
99	case 'F':
100	cbgen( p->op, p->label, c );
101	return;
102
103	case 'A':
104	case 'C':
105	/* logical operators for longs
106	defer comparisons until branch occurs */
107
108	brnode = tcopy( p );
109	brcase = c;
110	return;
111
112	case 'H': /* fix up unsigned shifts */
113	{ register NODE *q;
114	register r, l;
115	TWORD t;
116
117	if( p->op == ASG LS ) return;
118	if( p->op != ASG RS ) cerror( "ZH bad" );
119	if( p->left->op != REG ) cerror( "SH left bad" );
120
121	r = p->left->rval;
122	t = p->left->type;
123	l = (t==LONG \|\| t == ULONG );
124
125	if( t != UNSIGNED && t != UCHAR && t != ULONG ) return; /* signed is ok */
126
127	/* there are three cases: right side is a constant,
128	and has the shift value; right side is
129	a temporary reg, and has the - shift value,
130	and right side is something else: A1 has the
131	- shift value then */
132
133	/* in the case where the value is known (rhs a constant),
134	the mask is just computed and put out... */
135
136	if( p->right->op == ICON ){
137	int s;
138	s = p->right->lval;
139	if( l ){
140	if( s >= 16 ){
141	printf( " clr r%d\n", r );
142	s -= 16;
143	++r;
144	}
145	}
146	if( s >= 16 ) printf( " clr r%d\n", r );
147	else {
148	m = 0100000;
149	m >>= s; /* sign extends... */
150	m <<= 1;
151	printf( " bic $%o,r%d\n", m, r );
152	}
153	return;
154	}
155
156	/* general case */
157
158	if( istnode( p->right ) ) q = p->right;
159	else q = getlr( p, '1' ); /* where -shift is stored */
160
161	/* first, we store the shifted value on the stack */
162	printf( " mov r%d,-(sp)\n", r );
163	if( l ) printf( " mov r%d,-(sp)\n", r+1 );
164
165	/* now, make a mask */
166
167	printf( " mov $100000,r%d\n", r );
168	if( l ) printf( " clr r%d\n", r+1 );
169
170	/* shift (arithmetically ) */
171	if( l ) expand( q, RNOP, " ashc AR" );
172	else expand( q, RNOP, " ash AR" );
173	printf( ",r%d\n", r );
174
175	if( l ) printf( " ashc $1,r%d\n", r );
176	else printf( " asl r%d\n", r );
177
178	/* now, we have a mask: use it to clear sp, and reload */
179
180	if( l ){
181	printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r+1, r+1 );
182	}
183	printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r, r );
184	/* whew! */
185	return;
186	}
187
188	case 'V':
189	/* sign extend or not -- register is one less than the
190	left descendent */
191
192	m = p->left->rval - 1;
193
194	if( ISUNSIGNED(p->type) ){
195	printf( " clr r%d\n", m );
196	}
197	else {
198	printf( " sxt r%d\n", m );
199	}
200	return;
201
202	/* stack management macros */
203	case '-':
204	if( toff ++ ) printf( "-" );
205	printf( "(sp)" );
206	return;
207
208	case '4':
209	if( toff == 0 ) ++toff; /* can't push doubles that way */
210	printf( "-(sp)" );
211	toff += 4;
212	return;
213
214	case '~':
215	/* complimented CR */
216	p->right->lval = ~p->right->lval;
217	conput( getlr( p, 'R' ) );
218	p->right->lval = ~p->right->lval;
219	return;
220
221	case 'M':
222	/* negated CR */
223	p->right->lval = -p->right->lval;
224	conput( getlr( p, 'R' ) );
225	p->right->lval = -p->right->lval;
226	return;
227
228	case 'L': /* INIT for long constants */
229	{
230	unsigned hi, lo;
231	lo = p->left->lval & BITMASK(SZINT);
232	hi = ( p->left->lval >> SZINT ) & BITMASK(SZINT);
233	printf( " %o; %o\n", hi, lo );
234	return;
235	}
236
237	case 'T':
238	/* Truncate longs for type conversions:
239	LONG\|ULONG -> CHAR\|UCHAR\|INT\|UNSIGNED
240	increment offset to second word */
241
242	m = p->type;
243	p = p->left;
244	switch( p->op ){
245	case NAME:
246	case OREG:
247	p->lval += SZINT/SZCHAR;
248	return;
249	case REG:
250	rfree( p->rval, p->type );
251	p->rval += 1;
252	p->type = m;
253	rbusy( p->rval, p->type );
254	return;
255	default:
256	cerror( "Illegal ZT type conversion" );
257	return;
258
259	}
260
261	case 'U':
262	/* same as AL for exp under U* */
263	if( p->left->op == UNARY MUL ) {
264	adrput( getlr( p->left, 'L' ) );
265	return;
266	}
267	cerror( "Illegal ZU" );
268	/* NO RETURN */
269
270	case 'W': /* structure size */
271	if( p->op == STASG )
272	printf( "%d", p->stsize);
273	else cerror( "Not a structure" );
274	return;
275
276	case 'S': /* structure assignment */
277	{
278	register NODE l, r;
279	register size, count;
280
281	if( p->op == STASG ){
282	l = p->left;
283	r = p->right;
284	}
285	else if( p->op == STARG ){ /* store an arg onto the stack */
286	r = p->left;
287	}
288	else cerror( "STASG bad" );
289
290	if( r->op == ICON ) r->op = NAME;
291	else if( r->op == REG ) r->op = OREG;
292	else if( r->op != OREG ) cerror( "STASG-r" );
293
294	size = p->stsize;
295	count = size / 2;
296
297	r->lval += size;
298	if( p->op == STASG ) l->lval += size;
299
300	while( count-- ){ /* simple load/store loop */
301	r->lval -= 2;
302	expand( r, FOREFF, " mov AR," );
303	if( p->op == STASG ){
304	l->lval -= 2;
305	expand( l, FOREFF, "AR\n" );
306	}
307	else {
308	printf( "-(sp)\n" );
309	}
310
311	}
312
313	if( r->op == NAME ) r->op = ICON;
314	else if( r->op == OREG ) r->op = REG;
315
316	}
317	break;
318
319	default:
320	cerror( "illegal zzzcode" );
321	}
322	}
323
324	rmove( rt, rs, t ) TWORD t; {
325	printf( " %s %s,%s\n", (t==FLOAT\|\|t==DOUBLE)?"movf":"mov", rnames[rs], rnames[rt] );
326	}
327
328	struct respref
329	respref[] = {
330	INTAREG\|INTBREG, INTAREG\|INTBREG,
331	INAREG\|INBREG, INAREG\|INBREG\|SOREG\|STARREG\|SNAME\|STARNM\|SCON,
332	INTEMP, INTEMP,
333	FORARG, FORARG,
334	INTAREG, SOREG\|SNAME,
335	0, 0 };
336
337	setregs(){ /* set up temporary registers */
338	register i;
339
340	/* use any unused variable registers as scratch registers */
341	fregs = maxtreg>=MINRVAR ? maxtreg + 1 : MINRVAR;
342	if( xdebug ){
343	/* -x changes number of free regs to 2, -xx to 3, etc. */
344	if( (xdebug+1) < fregs ) fregs = xdebug+1;
345	}
346	/* NOTE: for pdp11 fregs <= 4 for float regs */
347	if( fregs > 4 ) fregs = 4;
348	for( i=MINRVAR; i<=MAXRVAR; i++ )
349	rstatus[i] = i<fregs ? SAREG\|STAREG : SAREG;
350	}
351
352	szty(t) TWORD t; { /* size, in words, needed to hold thing of type t */
353	/* really is the number of registers to hold type t */
354	switch( t ) {
355
356	case LONG:
357	case ULONG:
358	return( SZLONG/SZINT );
359
360	default:
361	return(1);
362
363	}
364	}
365
366	rewfld( p ) NODE *p; {
367	return(1);
368	}
369
370	callreg(p) NODE *p; {
371	return( (p->type==DOUBLE\|\|p->type==FLOAT) ? FR0 : R0 );
372	}
373
374	shltype( o, p ) NODE *p; {
375	if( o == NAME\|\| o==REG \|\| o == ICON \|\| o == OREG ) return( 1 );
376	return( o==UNARY MUL && shumul(p->left) );
377	}
378
379	flshape( p ) register NODE *p; {
380	register o = p->op;
381	if( o==NAME \|\| o==REG \|\| o==ICON \|\| o==OREG ) return( 1 );
382	return( o==UNARY MUL && shumul(p->left)==STARNM );
383	}
384
385	shtemp( p ) register NODE *p; {
386	if( p->op == UNARY MUL ) p = p->left;
387	if( p->op == REG \|\| p->op == OREG ) return( !istreg( p->rval ) );
388	return( p->op == NAME \|\| p->op == ICON );
389	}
390
391	spsz( t, v ) TWORD t; CONSZ v; {
392
393	/* is v the size to increment something of type t */
394
395	if( !ISPTR(t) ) return( 0 );
396	t = DECREF(t);
397
398	if( ISPTR(t) ) return( v == 2 );
399
400	switch( t ){
401
402	case UCHAR:
403	case CHAR:
404	return( v == 1 );
405
406	case INT:
407	case UNSIGNED:
408	return( v == 2 );
409
410	case FLOAT:
411	return( v == 4 );
412
413	case DOUBLE:
414	return( v == 8 );
415	}
416
417	return( 0 );
418	}
419
420	shumul( p ) register NODE *p; {
421	register o;
422
423	o = p->op;
424	if( o == NAME \|\| o == OREG \|\| o == ICON ) return( STARNM );
425
426	if( ( o == INCR \|\| o == ASG MINUS ) &&
427	( p->left->op == REG && p->right->op == ICON ) &&
428	p->right->name[0] == '\0' &&
429	spsz( p->left->type, p->right->lval ) )
430	return( STARREG );
431
432	return( 0 );
433	}
434
435	adrcon( val ) CONSZ val; {
436	printf( CONFMT, val );
437	}
438
439	conput( p ) register NODE *p; {
440	switch( p->op ){
441
442	case ICON:
443	acon( p );
444	return;
445
446	case REG:
447	printf( "%s", rnames[p->rval] );
448	return;
449
450	default:
451	cerror( "illegal conput" );
452	}
453	}
454
455	insput( p ) NODE *p; {
456	cerror( "insput" );
457	}
458
459	upput( p ) NODE *p; {
460	/* output the address of the second word in the
461	pair pointed to by p (for LONGs)*/
462	CONSZ save;
463
464	if( p->op == FLD ){
465	p = p->left;
466	}
467
468	save = p->lval;
469	switch( p->op ){
470
471	case NAME:
472	p->lval += SZINT/SZCHAR;
473	acon( p );
474	break;
475
476	case ICON:
477	/* addressable value of the constant */
478	p->lval &= BITMASK(SZINT);
479	printf( "$" );
480	acon( p );
481	break;
482
483	case REG:
484	printf( "%s", rnames[p->rval+1] );
485	break;
486
487	case OREG:
488	p->lval += SZINT/SZCHAR;
489	if( p->rval == R5 ){ /* in the argument region */
490	if( p->name[0] != '\0' ) werror( "bad arg temp" );
491	}
492	if( p->lval != 0 \|\| p->name[0] != '\0' ) acon( p );
493	printf( "(%s)", rnames[p->rval] );
494	break;
495
496	default:
497	cerror( "illegal upper address" );
498	break;
499
500	}
501	p->lval = save;
502
503	}
504
505	adrput( p ) register NODE *p; {
506	/* output an address, with offsets, from p */
507
508	if( p->op == FLD ){
509	p = p->left;
510	}
511	switch( p->op ){
512
513	case NAME:
514	acon( p );
515	return;
516
517	case ICON:
518	/* addressable value of the constant */
519	if( szty( p->type ) == 2 ) {
520	/* print the high order value */
521	CONSZ save;
522	save = p->lval;
523	p->lval = ( p->lval >> SZINT ) & BITMASK(SZINT);
524	printf( "$" );
525	acon( p );
526	p->lval = save;
527	return;
528	}
529	printf( "$" );
530	acon( p );
531	return;
532
533	case REG:
534	printf( "%s", rnames[p->rval] );
535	return;
536
537	case OREG:
538	if( p->rval == R5 ){ /* in the argument region */
539	if( p->name[0] != '\0' ) werror( "bad arg temp" );
540	printf( CONFMT, p->lval );
541	printf( ".(r5)" );
542	return;
543	}
544	if( p->lval != 0 \|\| p->name[0] != '\0' ) acon( p );
545	printf( "(%s)", rnames[p->rval] );
546	return;
547
548	case UNARY MUL:
549	/* STARNM or STARREG found */
550	if( tshape(p, STARNM) ) {
551	printf( "*" );
552	adrput( p->left);
553	}
554	else { /* STARREG - really auto inc or dec */
555	/* turn into OREG so replacement node will
556	reflect the value of the expression */
557	register i;
558	register NODE q, l;
559
560	l = p->left;
561	q = l->left;
562	p->op = OREG;
563	p->rall = q->rall;
564	p->lval = q->lval;
565	p->rval = q->rval;
566	for( i=0; i<NCHNAM; i++ )
567	p->name[i] = q->name[i];
568	if( l->op == INCR ) {
569	adrput( p );
570	printf( "+" );
571	p->lval -= l->right->lval;
572	}
573	else { /* l->op == ASG MINUS */
574	printf( "-" );
575	adrput( p );
576	}
577	tfree( l );
578	}
579	return;
580
581	default:
582	cerror( "illegal address" );
583	return;
584
585	}
586
587	}
588
589	acon( p ) register NODE p; { / print out a constant */
590
591	if( p->name[0] == '\0' ){ /* constant only */
592	printf( CONFMT, p->lval);
593	printf( "." );
594	}
595	else if( p->lval == 0 ) { /* name only */
596	printf( "%.8s", p->name );
597	}
598	else { /* name + offset */
599	printf( "%.8s+", p->name );
600	printf( CONFMT, p->lval );
601	printf( "." );
602	}
603	}
604
605	genscall( p, cookie ) register NODE *p; {
606	/* structure valued call */
607	return( gencall( p, cookie ) );
608	}
609
610	gencall( p, cookie ) register NODE *p; {
611	/* generate the call given by p */
612	register temp;
613	register m;
614
615	if( p->right ) temp = argsize( p->right );
616	else temp = 0;
617
618	if( p->right ){ /* generate args */
619	genargs( p->right );
620	}
621
622	if( !shltype( p->left->op, p->left ) ) {
623	order( p->left, INAREG\|SOREG );
624	}
625
626	p->op = UNARY CALL;
627	m = match( p, INTAREG\|INTBREG );
628	popargs( temp );
629	return(m != MDONE);
630	}
631
632	popargs( size ) register size; {
633	/* pop arguments from stack */
634
635	toff -= size/2;
636	if( toff == 0 && size >= 2 ) size -= 2;
637	switch( size ) {
638	case 0:
639	break;
640	case 2:
641	printf( " tst (sp)+\n" );
642	break;
643	case 4:
644	printf( " cmp (sp)+,(sp)+\n" );
645	break;
646	default:
647	printf( " add $%d.,sp\n", size);
648	}
649	}
650
651	char *
652	ccbranches[] = {
653	" jeq L%d\n",
654	" jne L%d\n",
655	" jle L%d\n",
656	" jlt L%d\n",
657	" jge L%d\n",
658	" jgt L%d\n",
659	" jlos L%d\n",
660	" jlo L%d\n",
661	" jhis L%d\n",
662	" jhi L%d\n",
663	};
664
665	/* long branch table
666
667	This table, when indexed by a logical operator,
668	selects a set of three logical conditions required
669	to generate long comparisons and branches. A zero
670	entry indicates that no branch is required.
671	E.G.: The <= operator would generate:
672	cmp AL,AR
673	jlt lable / 1st entry LT -> lable
674	jgt 1f / 2nd entry GT -> 1f
675	cmp UL,UR
676	jlos lable / 3rd entry ULE -> lable
677	1:
678	*/
679
680	int lbranches[][3] = {
681	/EQ/ 0, NE, EQ,
682	/NE/ NE, 0, NE,
683	/LE/ LT, GT, ULE,
684	/LT/ LT, GT, ULT,
685	/GE/ GT, LT, UGE,
686	/GT/ GT, LT, UGT,
687	/ULE/ ULT, UGT, ULE,
688	/ULT/ ULT, UGT, ULT,
689	/UGE/ UGT, ULT, UGE,
690	/UGT/ UGT, ULT, UGT,
691	};
692
693	/* logical relations when compared in reverse order (cmp R,L) */
694	extern short revrel[] ;
695
696	cbgen( o, lab, mode ) { /* printf conditional and unconditional branches */
697	register *plb;
698	int lab1f;
699
700	if( o == 0 ) printf( " jbr L%d\n", lab );
701	else if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
702	else {
703	switch( brcase ) {
704
705	case 'A':
706	case 'C':
707	plb = lbranches[ o-EQ ];
708	lab1f = getlab();
709	expand( brnode, FORCC, brcase=='C' ? "\tcmp\tAL,AR\n" : "\ttst\tAR\n" );
710	if( *plb != 0 )
711	printf( ccbranches[*plb-EQ], lab);
712	if( *++plb != 0 )
713	printf( ccbranches[*plb-EQ], lab1f);
714	expand( brnode, FORCC, brcase=='C' ? "\tcmp\tUL,UR\n" : "\ttst\tUR\n" );
715	printf( ccbranches[*++plb-EQ], lab);
716	deflab( lab1f );
717	reclaim( brnode, RNULL, 0 );
718	break;
719
720	default:
721	if( mode=='F' ) o = revrel[ o-EQ ];
722	printf( ccbranches[o-EQ], lab );
723	break;
724	}
725
726	brcase = 0;
727	brnode = 0;
728	}
729	}
730
731	nextcook( p, cookie ) NODE *p; {
732	/* we have failed to match p with cookie; try another */
733	if( cookie == FORREW ) return( 0 ); /* hopeless! */
734	if( !(cookie&(INTAREG\|INTBREG)) ) return( INTAREG\|INTBREG );
735	if( !(cookie&INTEMP) && asgop(p->op) ) return( INTEMP\|INAREG\|INTAREG\|INTBREG\|INBREG );
736	return( FORREW );
737	}
738
739	lastchance( p, cook ) NODE *p; {
740	/* forget it! */
741	return(0);
742	}
743
744	struct functbl {
745	int fop;
746	TWORD ftype;
747	char *func;
748	} opfunc[] = {
749	MUL, LONG, "lmul",
750	DIV, LONG, "ldiv",
751	MOD, LONG, "lrem",
752	ASG MUL, LONG, "almul",
753	ASG DIV, LONG, "aldiv",
754	ASG MOD, LONG, "alrem",
755	MUL, ULONG, "lmul",
756	DIV, ULONG, "uldiv",
757	MOD, ULONG, "ulrem",
758	ASG MUL, ULONG, "almul",
759	ASG DIV, ULONG, "auldiv",
760	ASG MOD, ULONG, "aulrem",
761	0, 0, 0 };
762
763	hardops(p) register NODE *p; {
764	/* change hard to do operators into function calls.
765	for pdp11 do long * / % */
766	register NODE *q;
767	register struct functbl *f;
768	register o;
769	register TWORD t;
770
771	o = p->op;
772	t = p->type;
773	if( t!=LONG && t!=ULONG ) return;
774
775	for( f=opfunc; f->fop; f++ ) {
776	if( o==f->fop && t==f->ftype ) goto convert;
777	}
778	return;
779
780	/* need address of left node for ASG OP */
781	/* WARNING - this won't work for long in a REG */
782	convert:
783	if( asgop( o ) ) {
784	switch( p->left->op ) {
785
786	case UNARY MUL: /* convert to address */
787	p->left->op = FREE;
788	p->left = p->left->left;
789	break;
790
791	case NAME: /* convert to ICON pointer */
792	p->left->op = ICON;
793	p->left->type = INCREF( p->left->type );
794	break;
795
796	case OREG: /* convert OREG to address */
797	p->left->op = REG;
798	p->left->type = INCREF( p->left->type );
799	if( p->left->lval != 0 ) {
800	q = talloc();
801	q->op = PLUS;
802	q->rall = NOPREF;
803	q->type = p->left->type;
804	q->left = p->left;
805	q->right = talloc();
806
807	q->right->op = ICON;
808	q->right->rall = NOPREF;
809	q->right->type = INT;
810	q->right->name[0] = '\0';
811	q->right->lval = p->left->lval;
812	q->right->rval = 0;
813
814	p->left->lval = 0;
815	p->left = q;
816	}
817	break;
818
819	default:
820	cerror( "Bad address for hard ops" );
821	/* NO RETURN */
822
823	}
824	}
825
826	/* build comma op for args to function */
827	q = talloc();
828	q->op = CM;
829	q->rall = NOPREF;
830	q->type = INT;
831	q->left = p->left;
832	q->right = p->right;
833	p->op = CALL;
834	p->right = q;
835
836	/* put function name in left node of call */
837	p->left = q = talloc();
838	q->op = ICON;
839	q->rall = NOPREF;
840	q->type = INCREF( FTN + p->type );
841	strcpy( q->name, f->func );
842	q->lval = 0;
843	q->rval = 0;
844
845	return;
846
847	}
848
849	optim2( p ) register NODE *p; {
850	/* do local tree transformations and optimizations */
851
852	register NODE *r;
853
854	switch( p->op ) {
855
856	case AND:
857	/* commute L and R to eliminate compliments and constants */
858	if( p->left->op==ICON \|\| p->left->op==COMPL ) {
859	r = p->left;
860	p->left = p->right;
861	p->right = r;
862	}
863	case ASG AND:
864	/* change meaning of AND to ~R&L - bic on pdp11 */
865	r = p->right;
866	if( r->op==ICON ) { /* compliment constant */
867	r->lval = ~r->lval;
868	}
869	else if( r->op==COMPL ) { /* ~~A => A */
870	r->op = FREE;
871	p->right = r->left;
872	}
873	else { /* insert complement node */
874	p->right = talloc();
875	p->right->op = COMPL;
876	p->right->rall = NOPREF;
877	p->right->type = r->type;
878	p->right->left = r;
879	p->right->right = NULL;
880	}
881	break;
882
883	}
884	}
885
886	myreader(p) register NODE *p; {
887	walkf( p, hardops ); /* convert ops to function calls */
888	canon( p ); /* expands r-vals for fileds */
889	walkf( p, optim2 );
890	toff = 0; /* stack offset swindle */
891	}
892
893	special( p, shape ) register NODE *p; {
894	/* special shape matching routine */
895
896	switch( shape ) {
897
898	case SCCON:
899	if( p->op == ICON && p->name[0]=='\0' && p->lval>= -128 && p->lval <=127 ) return( 1 );
900	break;
901
902	case SICON:
903	if( p->op == ICON && p->name[0]=='\0' && p->lval>= 0 && p->lval <=32767 ) return( 1 );
904	break;
905
906	default:
907	cerror( "bad special shape" );
908
909	}
910
911	return( 0 );
912	}
913
914	# ifndef ONEPASS
915	main( argc, argv ) char *argv[]; {
916	return( mainp2( argc, argv ) );
917	}
918	# endif