order.c

unix v7是最后一个广泛发布的研究型UNIX版本

			p->right->rall = R3|MUSTDO;
			mkrall( p->right, R3|MUSTDO );
			}
		return;

	case MUL:
	case DIV:
	case MOD:
		rallo( p->left, R1|MUSTDO );

		if( fregs == 2 ){
			rallo( p->right, NOPREF );
			return;
			}
		/* compute addresses, stay away from (r0,r1) */

		p->right->rall = (fregs==3) ? R2|MUSTDO : R3|MUSTDO ;
		mkrall( p->right, R2|MUSTDO );
		return;

	case CALL:
	case STASG:
	case EQ:
	case NE:
	case GT:
	case GE:
	case LT:
	case LE:
	case NOT:
	case ANDAND:
	case OROR:
		down1 = NOPREF;
		break;

	case FORCE:	
		down1 = R0|MUSTDO;
		break;

		}

	if( ty != LTYPE ) rallo( p->left, down1 );
	if( ty == BITYPE ) rallo( p->right, down2 );

	}

offstar( p ) register NODE *p; {
	/* handle indirections */

	if( p->op == UNARY MUL ) p = p->left;

	if( p->op == PLUS || p->op == MINUS ){
		if( p->right->op == ICON ){
			order( p->left , INTAREG|INAREG );
			return;
			}
		}
	order( p, INTAREG|INAREG );
	}

setincr( p ) NODE *p; {
	return( 0 );	/* for the moment, don't bother */
	}

niceuty( p ) register NODE *p; {
	register TWORD t;

	return( p->op == UNARY MUL && (t=p->type)!=CHAR &&
		t!= UCHAR && t!= FLOAT &&
		shumul( p->left) != STARREG );
	}
setbin( p ) register NODE *p; {
	register NODE *r, *l;

	r = p->right;
	l = p->left;

	if( p->right->su == 0 ){ /* rhs is addressable */
		if( logop( p->op ) ){
			if( l->op == UNARY MUL && l->type != FLOAT && shumul( l->left ) != STARREG ) offstar( l->left );
			else order( l, INAREG|INTAREG|INBREG|INTBREG|INTEMP );
			return( 1 );
			}
		if( !istnode( l ) ){
			order( l, INTAREG|INTBREG );
			return( 1 );
			}
		/* rewrite */
		return( 0 );
		}
	/* now, rhs is complicated: must do both sides into registers */
	/* do the harder side first */

	if( logop( p->op ) ){
		/* relational: do both sides into regs if need be */

		if( r->su > l->su ){
			if( niceuty(r) ){
				offstar( r->left );
				return( 1 );
				}
			else if( !istnode( r ) ){
				order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );
				return( 1 );
				}
			}
		if( niceuty(l) ){
			offstar( l->left );
			return( 1 );
			}
		else if( niceuty(r) ){
			offstar( r->left );
			return( 1 );
			}
		else if( !istnode( l ) ){
			order( l, INTAREG|INAREG|INTBREG|INBREG|INTEMP );
			return( 1 );
			}
		if( !istnode( r ) ){
			order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );
			return( 1 );
			}
		cerror( "setbin can't deal with %s", opst[p->op] );
		}

	/* ordinary operator */

	if( !istnode(r) && r->su > l->su ){
		/* if there is a chance of making it addressable, try it... */
		if( niceuty(r) ){
			offstar( r->left );
			return( 1 );  /* hopefully, it is addressable by now */
			}
		order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );  /* anything goes on rhs */
		return( 1 );
		}
	else {
		if( !istnode( l ) ){
			order( l, INTAREG|INTBREG );
			return( 1 );
			}
		/* rewrite */
		return( 0 );
		}
	}

setstr( p ) register NODE *p; { /* structure assignment */
	if( p->right->op != REG ){
		order( p->right, INTAREG );
		return(1);
		}
	p = p->left;
	if( p->op != NAME && p->op != OREG ){
		if( p->op != UNARY MUL ) cerror( "bad setstr" );
		order( p->left, INTAREG );
		return( 1 );
		}
	return( 0 );
	}

setasg( p ) register NODE *p; {
	/* setup for assignment operator */

	if( p->right->su != 0 && p->right->op != REG ) {
		if( p->right->op == UNARY MUL )
			offstar( p->right->left );
		else
			order( p->right, INAREG|INBREG|SOREG|SNAME|SCON );
		return(1);
		}
	if( p->right->op != REG && ( p->type == FLOAT || p->type == DOUBLE ) ) {
		order( p->right, INBREG );
		return(1);
		}
	if( p->left->op == UNARY MUL && !tshape( p->left, STARREG|STARNM ) ){
		offstar( p->left->left );
		return(1);
		}
	if( p->left->op == FLD && p->left->left->op == UNARY MUL ){
		offstar( p->left->left->left );
		return(1);
		}
	/* if things are really strange, get rhs into a register */
	if( p->right->op != REG ){
		order( p->right, INAREG|INBREG );
		return( 1 );
		}
	return(0);
	}

setasop( p ) register NODE *p; {
	/* setup for =ops */
	register sul, sur;
	register NODE *q, *p2;

	sul = p->left->su;
	sur = p->right->su;

	switch( p->op ){

	case ASG PLUS:
	case ASG OR:
	case ASG MINUS:
		if( p->type != INT && p->type != UNSIGNED && !ISPTR(p->type) ) break;
		if( p->right->type == CHAR || p->right->type == UCHAR ){
			order( p->right, INAREG );
			return( 1 );
			}
		break;

	case ASG ER:
		if( sul == 0 || p->left->op == REG ){
			if( p->left->type == CHAR || p->left->type == UCHAR ) goto rew;  /* rewrite */
			order( p->right, INAREG|INBREG );
			return( 1 );
			}
		goto leftadr;
		}

	if( sur == 0 ){

	leftadr:
		/* easy case: if addressable, do left value, op, store */
		if( sul == 0 ) goto rew;  /* rewrite */

		/* harder; make aleft address, val, op, and store */

		if( p->left->op == UNARY MUL ){
			offstar( p->left->left );
			return( 1 );
			}
		if( p->left->op == FLD && p->left->left->op == UNARY MUL ){
			offstar( p->left->left->left );
			return( 1 );
			}
	rew:	/* rewrite, accounting for autoincrement and autodecrement */

		q = p->left;
		if( q->op == FLD ) q = q->left;
		if( q->op != UNARY MUL || shumul(q->left) != STARREG ) return(0); /* let reader.c do it */

		/* mimic code from reader.c */

		p2 = tcopy( p );
		p->op = ASSIGN;
		reclaim( p->right, RNULL, 0 );
		p->right = p2;

		/* now, zap INCR on right, ASG MINUS on left */

		if( q->left->op == INCR ){
			q = p2->left;
			if( q->op == FLD ) q = q->left;
			if( q->left->op != INCR ) cerror( "bad incr rewrite" );
			}
		else if( q->left->op != ASG MINUS )  cerror( " bad -= rewrite" );

		q->left->right->op = FREE;
		q->left->op = FREE;
		q->left = q->left->left;

		/* now, resume reader.c rewriting code */

		canon(p);
		rallo( p, p->rall );
		order( p2->left, INTBREG|INTAREG );
		order( p2, INTBREG|INTAREG );
		return( 1 );
		}

	/* harder case: do right, left address, left value, op, store */

	if( p->right->op == UNARY MUL ){
		offstar( p->right->left );
		return( 1 );
		}
	/* sur> 0, since otherwise, done above */
	if( p->right->op == REG ) goto leftadr;  /* make lhs addressable */
	order( p->right, INAREG|INBREG );
	return( 1 );
	}

int crslab = 10000;

getlab(){
	return( crslab++ );
	}

deflab( l ){
	printf( "L%d:\n", l );
	}

genargs( p) register NODE *p; {
	register size;

	/* generate code for the arguments */

	/*  first, do the arguments on the right (last->first) */
	while( p->op == CM ){
		genargs( p->right );
		p->op = FREE;
		p = p->left;
		}

	if( p->op == STARG ){ /* structure valued argument */

		size = p->stsize;
		if( p->left->op == ICON ){
			/* make into a name node */
			p->op = FREE;
			p= p->left;
			p->op = NAME;
			}
		else {
			/* make it look beautiful... */
			p->op = UNARY MUL;
			canon( p );  /* turn it into an oreg */
			if( p->op != OREG ){
				offstar( p->left );
				canon( p );
				if( p->op != OREG ) cerror( "stuck starg" );
				}
			}

		p->lval += size;  /* end of structure */
		/* put on stack backwards */
		for( ; size>0; size -= 2 ){
			p->lval -= 2;
			expand( p, RNOP, "	mov	AR,Z-\n" );
			}
		reclaim( p, RNULL, 0 );
		return;
		}

	/* ordinary case */

	order( p, FORARG );
	}

argsize( p ) register NODE *p; {
	register t;
	t = 0;
	if( p->op == CM ){
		t = argsize( p->left );
		p = p->right;
		}
	if( p->type == DOUBLE || p->type == FLOAT ){
		SETOFF( t, 2 );
		return( t+8 );
		}
	else if( p->type == LONG || p->type == ULONG ) {
		SETOFF( t, 2);
		return( t+4 );
		}
	else if( p->op == STARG ){
		SETOFF( t, p->stalign );  /* alignment */
		return( t + p->stsize );  /* size */
		}
	else {
		SETOFF( t, 2 );
		return( t+2 );
		}
	}