V7M/src/cmd/mip/match.c
# include "mfile2"
int fldsz, fldshf;
static int mamask[] = { /* masks for matching dope with shapes */
SIMPFLG, /* OPSIMP */
SIMPFLG|ASGFLG, /* ASG OPSIMP */
COMMFLG, /* OPCOMM */
COMMFLG|ASGFLG, /* ASG OPCOMM */
MULFLG, /* OPMUL */
MULFLG|ASGFLG, /* ASG OPMUL */
DIVFLG, /* OPDIV */
DIVFLG|ASGFLG, /* ASG OPDIV */
UTYPE, /* OPUNARY */
TYFLG, /* ASG OPUNARY is senseless */
LTYPE, /* OPLEAF */
TYFLG, /* ASG OPLEAF is senseless */
0, /* OPANY */
ASGOPFLG|ASGFLG, /* ASG OPANY */
LOGFLG, /* OPLOG */
TYFLG, /* ASG OPLOG is senseless */
FLOFLG, /* OPFLOAT */
FLOFLG|ASGFLG, /* ASG OPFLOAT */
SHFFLG, /* OPSHFT */
SHFFLG|ASGFLG, /* ASG OPSHIFT */
SPFLG, /* OPLTYPE */
TYFLG, /* ASG OPLTYPE is senseless */
};
int sdebug = 0;
tshape( p, shape ) NODE *p; {
/* return true if shape is appropriate for the node p
side effect for SFLD is to set up fldsz,etc */
register o, mask;
o = p->op;
if( sdebug ){
printf( "tshape( %o, %o), op = %d\n", p, shape, o );
}
if( shape & SPECIAL ){
switch( shape ){
case SZERO:
case SONE:
case SMONE:
if( o != ICON || p->name[0] ) return(0);
if( p->lval == 0 && shape == SZERO ) return(1);
else if( p->lval == 1 && shape == SONE ) return(1);
else if( p->lval == -1 && shape == SMONE ) return(1);
else return(0);
default:
return( special( p, shape ) );
}
}
if( shape & SANY ) return(1);
if( (shape&INTEMP) && shtemp(p) ) return(1);
if( (shape&SWADD) && (o==NAME||o==OREG) ){
if( BYTEOFF(p->lval) ) return(0);
}
switch( o ){
case NAME:
return( shape&SNAME );
case ICON:
mask = SCON;
return( shape & mask );
case FLD:
if( shape & SFLD ){
if( !flshape( p->left ) ) return(0);
/* it is a FIELD shape; make side-effects */
o = p->rval;
fldsz = UPKFSZ(o);
# ifdef RTOLBYTES
fldshf = UPKFOFF(o);
# else
fldshf = SZINT - fldsz - UPKFOFF(o);
# endif
return(1);
}
return(0);
case CCODES:
return( shape&SCC );
case REG:
/* distinctions:
SAREG any scalar register
STAREG any temporary scalar register
SBREG any lvalue (index) register
STBREG any temporary lvalue register
*/
mask = isbreg( p->rval ) ? SBREG : SAREG;
if( istreg( p->rval ) && busy[p->rval]<=1 ) mask |= mask==SAREG ? STAREG : STBREG;
return( shape & mask );
case OREG:
return( shape & SOREG );
case UNARY MUL:
/* return STARNM or STARREG or 0 */
return( shumul(p->left) & shape );
}
return(0);
}
int tdebug = 0;
ttype( t, tword ) TWORD t; {
/* does the type t match tword */
if( tword & TANY ) return(1);
if( tdebug ){
printf( "ttype( %o, %o )\n", t, tword );
}
if( ISPTR(t) && (tword&TPTRTO) ) {
do {
t = DECREF(t);
} while ( ISARY(t) );
/* arrays that are left are usually only
in structure references... */
return( ttype( t, tword&(~TPTRTO) ) );
}
if( t != BTYPE(t) ) return( tword & TPOINT ); /* TPOINT means not simple! */
if( tword & TPTRTO ) return(0);
switch( t ){
case CHAR:
return( tword & TCHAR );
case SHORT:
return( tword & TSHORT );
case STRTY:
case UNIONTY:
return( tword & TSTRUCT );
case INT:
return( tword & TINT );
case UNSIGNED:
return( tword & TUNSIGNED );
case USHORT:
return( tword & TUSHORT );
case UCHAR:
return( tword & TUCHAR );
case ULONG:
return( tword & TULONG );
case LONG:
return( tword & TLONG );
case FLOAT:
return( tword & TFLOAT );
case DOUBLE:
return( tword & TDOUBLE );
}
return(0);
}
struct optab *rwtable;
struct optab *opptr[DSIZE];
setrew(){
/* set rwtable to first value which allows rewrite */
register struct optab *q;
register int i;
for( q = table; q->op != FREE; ++q ){
if( q->needs == REWRITE ){
rwtable = q;
goto more;
}
}
cerror( "bad setrew" );
more:
for( i=0; i<DSIZE; ++i ){
if( dope[i] ){ /* there is an op... */
for( q=table; q->op != FREE; ++q ){
/* beware; things like LTYPE that match
multiple things in the tree must
not try to look at the NIL at this
stage of things! Put something else
first in table.c */
/* at one point, the operator matching was 15% of the
total comile time; thus, the function
call that was here was removed...
*/
if( q->op < OPSIMP ){
if( q->op==i ) break;
}
else {
register opmtemp;
if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){
if( i==NAME || i==ICON || i==OREG ) break;
else if( shltype( i, NIL ) ) break;
}
else if( (dope[i]&(opmtemp|ASGFLG)) == opmtemp ) break;
}
}
opptr[i] = q;
}
}
}
match( p, cookie ) NODE *p; {
/* called by: order, gencall
look for match in table and generate code if found unless
entry specified REWRITE.
returns MDONE, MNOPE, or rewrite specification from table */
register struct optab *q;
register NODE *r;
rcount();
if( cookie == FORREW ) q = rwtable;
else q = opptr[p->op];
for( ; q->op != FREE; ++q ){
/* at one point the call that was here was over 15% of the total time;
thus the function call was expanded inline */
if( q->op < OPSIMP ){
if( q->op!=p->op ) continue;
}
else {
register opmtemp;
if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){
if( p->op!=NAME && p->op!=ICON && p->op!= OREG &&
! shltype( p->op, p ) ) continue;
}
else if( (dope[p->op]&(opmtemp|ASGFLG)) != opmtemp ) continue;
}
if( !(q->visit & cookie ) ) continue;
r = getlr( p, 'L' ); /* see if left child matches */
if( !tshape( r, q->lshape ) ) continue;
if( !ttype( r->type, q->ltype ) ) continue;
r = getlr( p, 'R' ); /* see if right child matches */
if( !tshape( r, q->rshape ) ) continue;
if( !ttype( r->type, q->rtype ) ) continue;
/* REWRITE means no code from this match but go ahead
and rewrite node to help future match */
if( q->needs & REWRITE ) return( q->rewrite );
if( !allo( p, q ) ) continue; /* if can't generate code, skip entry */
/* resources are available */
expand( p, cookie, q->cstring ); /* generate code */
reclaim( p, q->rewrite, cookie );
return(MDONE);
}
return(MNOPE);
}
int rtyflg = 0;
expand( p, cookie, cp ) NODE *p; register char *cp; {
/* generate code by interpreting table entry */
CONSZ val;
rtyflg = 0;
for( ; *cp; ++cp ){
switch( *cp ){
default:
PUTCHAR( *cp );
continue; /* this is the usual case... */
case 'T':
/* rewrite register type is suppressed */
rtyflg = 1;
continue;
case 'Z': /* special machine dependent operations */
zzzcode( p, *++cp );
continue;
case 'F': /* this line deleted if FOREFF is active */
if( cookie & FOREFF ) while( *++cp != '\n' ) ; /* VOID */
continue;
case 'S': /* field size */
printf( "%d", fldsz );
continue;
case 'H': /* field shift */
printf( "%d", fldshf );
continue;
case 'M': /* field mask */
case 'N': /* complement of field mask */
val = 1;
val <<= fldsz;
--val;
val <<= fldshf;
adrcon( *cp=='M' ? val : ~val );
continue;
case 'L': /* output special label field */
printf( "%d", p->label );
continue;
case 'O': /* opcode string */
hopcode( *++cp, p->op );
continue;
case 'B': /* byte offset in word */
val = getlr(p,*++cp)->lval;
val = BYTEOFF(val);
printf( CONFMT, val );
continue;
case 'C': /* for constant value only */
conput( getlr( p, *++cp ) );
continue;
case 'I': /* in instruction */
insput( getlr( p, *++cp ) );
continue;
case 'A': /* address of */
adrput( getlr( p, *++cp ) );
continue;
case 'U': /* for upper half of address, only */
upput( getlr( p, *++cp ) );
continue;
}
}
}
NODE *
getlr( p, c ) NODE *p; {
/* return the pointer to the left or right side of p, or p itself,
depending on the optype of p */
switch( c ) {
case '1':
case '2':
case '3':
return( &resc[c-'1'] );
case 'L':
return( optype( p->op ) == LTYPE ? p : p->left );
case 'R':
return( optype( p->op ) != BITYPE ? p : p->right );
}
cerror( "bad getlr: %c", c );
/* NOTREACHED */
}