[unix-history] / usr / 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:
		case SSCON:
		case SCCON:
			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 if( p->lval > -257 && p->lval < 256 && shape == SCCON ) return(1);
			else if( p->lval > -32769 && p->lval < 32768 && shape == SSCON ) return(1);
			else return(0);

		case SSOREG:	/* non-indexed OREG */
			if( o == OREG && !R2TEST(p->rval) ) 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);
	}

expand( p, cookie, cp ) NODE *p;  register char *cp; {
	/* generate code by interpreting table entry */

	CONSZ val;

	for( ; *cp; ++cp ){
		switch( *cp ){

		default:
			PUTCHAR( *cp );
			continue;  /* this is the usual case... */

		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 */
	}
Commit	Line	Data
5a7128e9 BJ	1	# include "mfile2"
	2
	3
	4	int fldsz, fldshf;
	5
	6	static int mamask[] = { /* masks for matching dope with shapes */
	7	SIMPFLG, /* OPSIMP */
	8	SIMPFLG\|ASGFLG, /* ASG OPSIMP */
	9	COMMFLG, /* OPCOMM */
	10	COMMFLG\|ASGFLG, /* ASG OPCOMM */
	11	MULFLG, /* OPMUL */
	12	MULFLG\|ASGFLG, /* ASG OPMUL */
	13	DIVFLG, /* OPDIV */
	14	DIVFLG\|ASGFLG, /* ASG OPDIV */
	15	UTYPE, /* OPUNARY */
	16	TYFLG, /* ASG OPUNARY is senseless */
	17	LTYPE, /* OPLEAF */
	18	TYFLG, /* ASG OPLEAF is senseless */
	19	0, /* OPANY */
	20	ASGOPFLG\|ASGFLG, /* ASG OPANY */
	21	LOGFLG, /* OPLOG */
	22	TYFLG, /* ASG OPLOG is senseless */
	23	FLOFLG, /* OPFLOAT */
	24	FLOFLG\|ASGFLG, /* ASG OPFLOAT */
	25	SHFFLG, /* OPSHFT */
	26	SHFFLG\|ASGFLG, /* ASG OPSHIFT */
	27	SPFLG, /* OPLTYPE */
	28	TYFLG, /* ASG OPLTYPE is senseless */
	29	};
	30
	31	int sdebug = 0;
	32
	33	tshape( p, shape ) NODE *p; {
	34	/* return true if shape is appropriate for the node p
	35	side effect for SFLD is to set up fldsz,etc */
	36	register o, mask;
	37
	38	o = p->op;
	39
	40	if( sdebug ){
	41	printf( "tshape( %o, %o), op = %d\n", p, shape, o );
	42	}
	43
	44	if( shape & SPECIAL ){
	45
	46	switch( shape ){
	47
	48	case SZERO:
	49	case SONE:
	50	case SMONE:
	51	case SSCON:
	52	case SCCON:
	53	if( o != ICON \|\| p->name[0] ) return(0);
	54	if( p->lval == 0 && shape == SZERO ) return(1);
	55	else if( p->lval == 1 && shape == SONE ) return(1);
	56	else if( p->lval == -1 && shape == SMONE ) return(1);
	57	else if( p->lval > -257 && p->lval < 256 && shape == SCCON ) return(1);
	58	else if( p->lval > -32769 && p->lval < 32768 && shape == SSCON ) return(1);
	59	else return(0);
	60
	61	case SSOREG: /* non-indexed OREG */
	62	if( o == OREG && !R2TEST(p->rval) ) return(1);
	63	else return(0);
	64
65	default:
66	return( special( p, shape ) );
67	}
68	}
69
70	if( shape & SANY ) return(1);
71
72	if( (shape&INTEMP) && shtemp(p) ) return(1);
73
74	if( (shape&SWADD) && (o==NAME\|\|o==OREG) ){
75	if( BYTEOFF(p->lval) ) return(0);
76	}
77
78	switch( o ){
79
80	case NAME:
81	return( shape&SNAME );
82	case ICON:
83	mask = SCON;
84	return( shape & mask );
85
86	case FLD:
87	if( shape & SFLD ){
88	if( !flshape( p->left ) ) return(0);
89	/* it is a FIELD shape; make side-effects */
90	o = p->rval;
91	fldsz = UPKFSZ(o);
92	# ifdef RTOLBYTES
93	fldshf = UPKFOFF(o);
94	# else
95	fldshf = SZINT - fldsz - UPKFOFF(o);
96	# endif
97	return(1);
98	}
99	return(0);
100
101	case CCODES:
102	return( shape&SCC );
103
104	case REG:
105	/* distinctions:
106	SAREG any scalar register
107	STAREG any temporary scalar register
108	SBREG any lvalue (index) register
109	STBREG any temporary lvalue register
110	*/
111	mask = isbreg( p->rval ) ? SBREG : SAREG;
112	if( istreg( p->rval ) && busy[p->rval]<=1 ) mask \|= mask==SAREG ? STAREG : STBREG;
113	return( shape & mask );
114
115	case OREG:
116	return( shape & SOREG );
117
118	case UNARY MUL:
119	/* return STARNM or STARREG or 0 */
120	return( shumul(p->left) & shape );
121
122	}
123
124	return(0);
125	}
126
127	int tdebug = 0;
128
129	ttype( t, tword ) TWORD t; {
130	/* does the type t match tword */
131
132	if( tword & TANY ) return(1);
133
134	if( tdebug ){
135	printf( "ttype( %o, %o )\n", t, tword );
136	}
137	if( ISPTR(t) && (tword&TPTRTO) ) {
138	do {
139	t = DECREF(t);
140	} while ( ISARY(t) );
141	/* arrays that are left are usually only
142	in structure references... */
143	return( ttype( t, tword&(~TPTRTO) ) );
144	}
145	if( t != BTYPE(t) ) return( tword & TPOINT ); /* TPOINT means not simple! */
146	if( tword & TPTRTO ) return(0);
147
148	switch( t ){
149
150	case CHAR:
151	return( tword & TCHAR );
152	case SHORT:
153	return( tword & TSHORT );
154	case STRTY:
155	case UNIONTY:
156	return( tword & TSTRUCT );
157	case INT:
158	return( tword & TINT );
159	case UNSIGNED:
160	return( tword & TUNSIGNED );
161	case USHORT:
162	return( tword & TUSHORT );
163	case UCHAR:
164	return( tword & TUCHAR );
165	case ULONG:
166	return( tword & TULONG );
167	case LONG:
168	return( tword & TLONG );
169	case FLOAT:
170	return( tword & TFLOAT );
171	case DOUBLE:
172	return( tword & TDOUBLE );
173	}
174
175	return(0);
176	}
177
178	struct optab *rwtable;
179
180	struct optab *opptr[DSIZE];
181
182	setrew(){
183	/* set rwtable to first value which allows rewrite */
184	register struct optab *q;
185	register int i;
186
187	for( q = table; q->op != FREE; ++q ){
188	if( q->needs == REWRITE ){
189	rwtable = q;
190	goto more;
191	}
192	}
193	cerror( "bad setrew" );
194
195
196	more:
197	for( i=0; i<DSIZE; ++i ){
198	if( dope[i] ){ /* there is an op... */
199	for( q=table; q->op != FREE; ++q ){
200	/* beware; things like LTYPE that match
201	multiple things in the tree must
202	not try to look at the NIL at this
203	stage of things! Put something else
204	first in table.c */
205	/* at one point, the operator matching was 15% of the
206	total comile time; thus, the function
207	call that was here was removed...
208	*/
209
210	if( q->op < OPSIMP ){
211	if( q->op==i ) break;
212	}
213	else {
214	register opmtemp;
215	if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){
216	if( i==NAME \|\| i==ICON \|\| i==OREG ) break;
217	else if( shltype( i, NIL ) ) break;
218	}
219	else if( (dope[i]&(opmtemp\|ASGFLG)) == opmtemp ) break;
220	}
221	}
222	opptr[i] = q;
223	}
224	}
225	}
226
227	match( p, cookie ) NODE *p; {
228	/* called by: order, gencall
229	look for match in table and generate code if found unless
230	entry specified REWRITE.
231	returns MDONE, MNOPE, or rewrite specification from table */
232
233	register struct optab *q;
234	register NODE *r;
235
236	rcount();
237	if( cookie == FORREW ) q = rwtable;
238	else q = opptr[p->op];
239
240	for( ; q->op != FREE; ++q ){
241
242	/* at one point the call that was here was over 15% of the total time;
243	thus the function call was expanded inline */
244	if( q->op < OPSIMP ){
245	if( q->op!=p->op ) continue;
246	}
247	else {
248	register opmtemp;
249	if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){
250	if( p->op!=NAME && p->op!=ICON && p->op!= OREG &&
251	! shltype( p->op, p ) ) continue;
252	}
253	else if( (dope[p->op]&(opmtemp\|ASGFLG)) != opmtemp ) continue;
254	}
255
256	if( !(q->visit & cookie ) ) continue;
257	r = getlr( p, 'L' ); /* see if left child matches */
258	if( !tshape( r, q->lshape ) ) continue;
259	if( !ttype( r->type, q->ltype ) ) continue;
260	r = getlr( p, 'R' ); /* see if right child matches */
261	if( !tshape( r, q->rshape ) ) continue;
262	if( !ttype( r->type, q->rtype ) ) continue;
263
264	/* REWRITE means no code from this match but go ahead
265	and rewrite node to help future match */
266	if( q->needs & REWRITE ) return( q->rewrite );
267	if( !allo( p, q ) ) continue; /* if can't generate code, skip entry */
268
269	/* resources are available */
270
271	expand( p, cookie, q->cstring ); /* generate code */
272	reclaim( p, q->rewrite, cookie );
273
274	return(MDONE);
275
276	}
277
278	return(MNOPE);
279	}
280
281	expand( p, cookie, cp ) NODE p; register char cp; {
282	/* generate code by interpreting table entry */
283
284	CONSZ val;
285
286	for( ; *cp; ++cp ){
287	switch( *cp ){
288
289	default:
290	PUTCHAR( *cp );
291	continue; /* this is the usual case... */
292
293	case 'Z': /* special machine dependent operations */
294	zzzcode( p, *++cp );
295	continue;
296
297	case 'F': /* this line deleted if FOREFF is active */
298	if( cookie & FOREFF ) while( ++cp != '\n' ) ; / VOID */
299	continue;
300
301	case 'S': /* field size */
302	printf( "$%d", fldsz );
303	continue;
304
305	case 'H': /* field shift */
306	printf( "$%d", fldshf );
307	continue;
308
309	case 'M': /* field mask */
310	case 'N': /* complement of field mask */
311	val = 1;
312	val <<= fldsz;
313	--val;
314	val <<= fldshf;
315	adrcon( *cp=='M' ? val : ~val );
316	continue;
317
318	case 'L': /* output special label field */
319	printf( "%d", p->label );
320	continue;
321
322	case 'O': /* opcode string */
323	hopcode( *++cp, p->op );
324	continue;
325
326	case 'B': /* byte offset in word */
327	val = getlr(p,*++cp)->lval;
328	val = BYTEOFF(val);
329	printf( CONFMT, val );
330	continue;
331
332	case 'C': /* for constant value only */
333	conput( getlr( p, *++cp ) );
334	continue;
335
336	case 'I': /* in instruction */
337	insput( getlr( p, *++cp ) );
338	continue;
339
340	case 'A': /* address of */
341	adrput( getlr( p, *++cp ) );
342	continue;
343
344	case 'U': /* for upper half of address, only */
345	upput( getlr( p, *++cp ) );
346	continue;
347
348	}
349
350	}
351
352	}
353
354	NODE *
355	getlr( p, c ) NODE *p; {
356
357	/* return the pointer to the left or right side of p, or p itself,
358	depending on the optype of p */
359
360	switch( c ) {
361
362	case '1':
363	case '2':
364	case '3':
365	return( &resc[c-'1'] );
366
367	case 'L':
368	return( optype( p->op ) == LTYPE ? p : p->left );
369
370	case 'R':
371	return( optype( p->op ) != BITYPE ? p : p->right );
372
373	}
374	cerror( "bad getlr: %c", c );
375	/* NOTREACHED */
376	}