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