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

# include "mfile1"


/*	this file contains code which is dependent on the target machine */

NODE *
cast( p, t ) register NODE *p; TWORD t; {
	/* cast node p to type t */

	p = buildtree( CAST, block( NAME, NIL, NIL, t, 0, (int)t ), p );
	p->left->op = FREE;
	p->op = FREE;
	return( p->right );
	}

NODE *
clocal(p) NODE *p; {

	/* this is called to do local transformations on
	   an expression tree preparitory to its being
	   written out in intermediate code.
	*/

	/* the major essential job is rewriting the
	   automatic variables and arguments in terms of
	   REG and OREG nodes */
	/* conversion ops which are not necessary are also clobbered here */
	/* in addition, any special features (such as rewriting
	   exclusive or) are easily handled here as well */

	register struct symtab *q;
	register NODE *r;
	register o;
	register m, ml;

	switch( o = p->op ){

	case NAME:
		if( p->rval < 0 ) { /* already processed; ignore... */
			return(p);
			}
		q = &stab[p->rval];
		switch( q->sclass ){

		case AUTO:
		case PARAM:
			/* fake up a structure reference */
			r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 );
			r->lval = 0;
			r->rval = (q->sclass==AUTO?STKREG:ARGREG);
			p = stref( block( STREF, r, p, 0, 0, 0 ) );
			break;

		case ULABEL:
		case LABEL:
		case STATIC:
			if( q->slevel == 0 ) break;
			p->lval = 0;
			p->rval = -q->offset;
			break;

		case REGISTER:
			p->op = REG;
			p->lval = 0;
			p->rval = q->offset;
			break;

			}
		break;
	case LT:
	case LE:
	case GT:
	case GE:
		if( ISPTR( p->left->type ) || ISPTR( p->right->type ) ){
			p->op += (ULT-LT);
			}
		break;

	case PCONV:
		/* do pointer conversions for char and longs */
		ml = p->left->type;
		if( ( ml==CHAR || ml==UCHAR || ml==LONG || ml==ULONG ) && p->left->op != ICON ) break;

		/* pointers all have the same representation; the type is inherited */
		p->left->type = p->type;
		p->left->cdim = p->cdim;
		p->left->csiz = p->csiz;
		p->op = FREE;
		return( p->left );

	case SCONV:
		m = (p->type == FLOAT || p->type == DOUBLE );
		ml = (p->left->type == FLOAT || p->left->type == DOUBLE );
		if( m != ml ) break;

		/* now, look for conversions downwards */

		m = p->type;
		ml = p->left->type;
		if( p->left->op == ICON ){ /* simulate the conversion here */
			CONSZ val;
			val = p->left->lval;
			switch( m ){
			case CHAR:
				p->left->lval = (char) val;
				break;
			case UCHAR:
				p->left->lval = val & 0XFF;
				break;
			case UNSIGNED:
				p->left->lval = val & 0XFFFFL;
				break;
			case INT:
				p->left->lval = (int)val;
				break;
				}
			p->left->type = m;
			}
		else {
			/* meaningful ones are conversion of int to char, int to short,
			   and short to char, and unsigned version of them */
			if( m==CHAR || m==UCHAR ){
				if( ml==LONG || ml==ULONG ) break;
				}
			else if( m==INT || m==UNSIGNED ){
				if( ml==LONG || ml==ULONG ) break;
				}
			else if( m==LONG || m==ULONG ){
				if( ml!=LONG && ml!= ULONG ) break;
				}
			}

		/* clobber conversion */
		p->op = FREE;
		return( p->left );  /* conversion gets clobbered */

	case ASSIGN:
		/* get rid of SCONV for assignments
		   from LONG -> CHAR|INT	*/
		if( p->right->op == SCONV ) {
			m = p->right->type;
			ml = p->right->left->type;
			if( ( m==LONG || m==ULONG ) &&
			    ml!=FLOAT && ml!=DOUBLE ) {
				p->right->op = FREE;
				p->right = p->right->left;
				}
			}
		break;

	case PVCONV:
	case PMCONV:
		if( p->right->op != ICON ) cerror( "bad conversion", 0);
		p->op = FREE;
		return( buildtree( o==PMCONV?MUL:DIV, p->left, p->right ) );

	case PLUS:
	case MINUS:
	case LS:
	case MUL:
		/* optimize address calculations with long indexes */
		if( ISPTR( p->type ) || ISARY( p->type ) ) {
			if( p->left->type==LONG || p->left->type==ULONG )
				p->left = cast( p->left, INT );
			if( p->right->type==LONG || p->right->type==ULONG )
				p->right = cast( p->right, INT );
			}
		break;

		}

	return(p);
	}

andable( p ) NODE *p; {
	return(1);  /* all names can have & taken on them */
	}

cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
	autooff = AUTOINIT;
	}

cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */

	if( t==INT || t==UNSIGNED || ISPTR(t) ) return(1);
	return(0);
	}

NODE *
offcon( off, t, d, s ) OFFSZ off; TWORD t; {

	/* return a node, for structure references, which is suitable for
	   being added to a pointer of type t, in order to be off bits offset
	   into a structure */

	register NODE *p;

	/* t, d, and s are the type, dimension offset, and sizeoffset */
	/* in general they  are necessary for offcon, but not on H'well */

	p = bcon(0);
	p->lval = off/SZCHAR;
	return(p);

	}

static inwd	/* current bit offsed in word */;
static word	/* word being built from fields */;

incode( p, sz ) register NODE *p; {

	/* generate initialization code for assigning a constant c
		to a field of width sz */
	/* we assume that the proper alignment has been obtained */
	/* inoff is updated to have the proper final value */
	/* we also assume sz  < SZINT */

	if((sz+inwd) > SZINT) cerror("incode: field > int");
	word |= p->lval<<inwd;
	inwd += sz;
	inoff += sz;
	if(inoff%SZINT == 0) {
		printf( "	%o\n", word);
		word = inwd = 0;
		}
	}

fincode( d, sz ) double d; {
	/* output code to initialize space of size sz to the value d */
	/* the proper alignment has been obtained */
	/* inoff is updated to have the proper final value */
	/* on the target machine, write it out in octal! */

	register int *mi = (int *)&d;

	if( sz==SZDOUBLE )
		printf( "	%o; %o; %o; %o\n", mi[0], mi[1], mi[2], mi[3] );
	else
		printf( "	%o; %o\n", mi[0], mi[1] );
	inoff += sz;
	}

cinit( p, sz ) NODE *p; {
	/* arrange for the initialization of p into a space of
	size sz */
	/* the proper alignment has been opbtained */
	/* inoff is updated to have the proper final value */
	ecode( p );
	inoff += sz;
	}

vfdzero( n ){ /* define n bits of zeros in a vfd */

	if( n <= 0 ) return;

	inwd += n;
	inoff += n;
	if( inoff%ALINT ==0 ) {
		printf( "	%o\n", word );
		word = inwd = 0;
		}
	}


char *
exname( p ) char *p; {
	/* make a name look like an external name in the local machine */

	static char text[NCHNAM+1];

	register i;

	text[0] = '_';
	for( i=1; *p&&i<NCHNAM; ++i ){
		text[i] = *p++;
		}

	text[i] = '\0';
	text[NCHNAM] = '\0';  /* truncate */

	return( text );
	}

ctype( type ) TWORD type; { /* map types which are not defined on the local machine */
	switch( BTYPE(type) ){
	case SHORT:
		MODTYPE(type,INT);
		break;
	case USHORT:
		MODTYPE(type,UNSIGNED);
		}
	return( type );
	}

noinit() { /* curid is a variable which is defined but
	is not initialized (and not a function );
	This routine returns the stroage class for an uninitialized declaration */

	return(EXTERN);

	}

commdec( id ){ /* make a common declaration for id, if reasonable */
	register struct symtab *q;
	OFFSZ off;

	q = &stab[id];
	printf( "	.comm	%s,", exname( q->sname ) );
	off = tsize( q->stype, q->dimoff, q->sizoff );
	printf( CONFMT, off/SZCHAR );
	printf( ".\n" );
	}

isitlong( cb, ce ){ /* is lastcon to be long or short */
	/* cb is the first character of the representation, ce the last */

	if( ce == 'l' || ce == 'L' ||
		lastcon >= (1L << (SZINT-1) ) ) return (1);
	return(0);
	}


isitfloat( s ) char *s; {
	double atof();
	dcon = atof(s);
	return( FCON );
	}

ecode( p ) NODE *p; {

	/* walk the tree and write out the nodes.. */

	if( nerrors ) return;
	p2tree( p );
	p2compile( p );
	}
Commit	Line	Data
3c5d933b SJ	1	# include "mfile1"
	2
	3
	4	/* this file contains code which is dependent on the target machine */
	5
	6	NODE *
	7	cast( p, t ) register NODE *p; TWORD t; {
	8	/* cast node p to type t */
	9
	10	p = buildtree( CAST, block( NAME, NIL, NIL, t, 0, (int)t ), p );
	11	p->left->op = FREE;
	12	p->op = FREE;
	13	return( p->right );
	14	}
	15
	16	NODE *
	17	clocal(p) NODE *p; {
	18
	19	/* this is called to do local transformations on
	20	an expression tree preparitory to its being
	21	written out in intermediate code.
	22	*/
	23
	24	/* the major essential job is rewriting the
	25	automatic variables and arguments in terms of
	26	REG and OREG nodes */
	27	/* conversion ops which are not necessary are also clobbered here */
	28	/* in addition, any special features (such as rewriting
	29	exclusive or) are easily handled here as well */
	30
	31	register struct symtab *q;
	32	register NODE *r;
	33	register o;
	34	register m, ml;
	35
	36	switch( o = p->op ){
	37
	38	case NAME:
	39	if( p->rval < 0 ) { /* already processed; ignore... */
	40	return(p);
	41	}
	42	q = &stab[p->rval];
	43	switch( q->sclass ){
	44
	45	case AUTO:
	46	case PARAM:
	47	/* fake up a structure reference */
	48	r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 );
	49	r->lval = 0;
	50	r->rval = (q->sclass==AUTO?STKREG:ARGREG);
	51	p = stref( block( STREF, r, p, 0, 0, 0 ) );
	52	break;
	53
	54	case ULABEL:
	55	case LABEL:
	56	case STATIC:
	57	if( q->slevel == 0 ) break;
	58	p->lval = 0;
	59	p->rval = -q->offset;
	60	break;
	61
	62	case REGISTER:
	63	p->op = REG;
	64	p->lval = 0;
65	p->rval = q->offset;
66	break;
67
68	}
69	break;
70	case LT:
71	case LE:
72	case GT:
73	case GE:
74	if( ISPTR( p->left->type ) \|\| ISPTR( p->right->type ) ){
75	p->op += (ULT-LT);
76	}
77	break;
78
79	case PCONV:
80	/* do pointer conversions for char and longs */
81	ml = p->left->type;
82	if( ( ml==CHAR \|\| ml==UCHAR \|\| ml==LONG \|\| ml==ULONG ) && p->left->op != ICON ) break;
83
84	/* pointers all have the same representation; the type is inherited */
85	p->left->type = p->type;
86	p->left->cdim = p->cdim;
87	p->left->csiz = p->csiz;
88	p->op = FREE;
89	return( p->left );
90
91	case SCONV:
92	m = (p->type == FLOAT \|\| p->type == DOUBLE );
93	ml = (p->left->type == FLOAT \|\| p->left->type == DOUBLE );
94	if( m != ml ) break;
95
96	/* now, look for conversions downwards */
97
98	m = p->type;
99	ml = p->left->type;
100	if( p->left->op == ICON ){ /* simulate the conversion here */
101	CONSZ val;
102	val = p->left->lval;
103	switch( m ){
104	case CHAR:
105	p->left->lval = (char) val;
106	break;
107	case UCHAR:
108	p->left->lval = val & 0XFF;
109	break;
110	case UNSIGNED:
111	p->left->lval = val & 0XFFFFL;
112	break;
113	case INT:
114	p->left->lval = (int)val;
115	break;
116	}
117	p->left->type = m;
118	}
119	else {
120	/* meaningful ones are conversion of int to char, int to short,
121	and short to char, and unsigned version of them */
122	if( m==CHAR \|\| m==UCHAR ){
123	if( ml==LONG \|\| ml==ULONG ) break;
124	}
125	else if( m==INT \|\| m==UNSIGNED ){
126	if( ml==LONG \|\| ml==ULONG ) break;
127	}
128	else if( m==LONG \|\| m==ULONG ){
129	if( ml!=LONG && ml!= ULONG ) break;
130	}
131	}
132
133	/* clobber conversion */
134	p->op = FREE;
135	return( p->left ); /* conversion gets clobbered */
136
137	case ASSIGN:
138	/* get rid of SCONV for assignments
139	from LONG -> CHAR\|INT */
140	if( p->right->op == SCONV ) {
141	m = p->right->type;
142	ml = p->right->left->type;
143	if( ( m==LONG \|\| m==ULONG ) &&
144	ml!=FLOAT && ml!=DOUBLE ) {
145	p->right->op = FREE;
146	p->right = p->right->left;
147	}
148	}
149	break;
150
151	case PVCONV:
152	case PMCONV:
153	if( p->right->op != ICON ) cerror( "bad conversion", 0);
154	p->op = FREE;
155	return( buildtree( o==PMCONV?MUL:DIV, p->left, p->right ) );
156
157	case PLUS:
158	case MINUS:
159	case LS:
160	case MUL:
161	/* optimize address calculations with long indexes */
162	if( ISPTR( p->type ) \|\| ISARY( p->type ) ) {
163	if( p->left->type==LONG \|\| p->left->type==ULONG )
164	p->left = cast( p->left, INT );
165	if( p->right->type==LONG \|\| p->right->type==ULONG )
166	p->right = cast( p->right, INT );
167	}
168	break;
169
170	}
171
172	return(p);
173	}
174
175	andable( p ) NODE *p; {
176	return(1); /* all names can have & taken on them */
177	}
178
179	cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
180	autooff = AUTOINIT;
181	}
182
183	cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
184
185	if( t==INT \|\| t==UNSIGNED \|\| ISPTR(t) ) return(1);
186	return(0);
187	}
188
189	NODE *
190	offcon( off, t, d, s ) OFFSZ off; TWORD t; {
191
192	/* return a node, for structure references, which is suitable for
193	being added to a pointer of type t, in order to be off bits offset
194	into a structure */
195
196	register NODE *p;
197
198	/* t, d, and s are the type, dimension offset, and sizeoffset */
199	/* in general they are necessary for offcon, but not on H'well */
200
201	p = bcon(0);
202	p->lval = off/SZCHAR;
203	return(p);
204
205	}
206
207	static inwd /* current bit offsed in word */;
208	static word /* word being built from fields */;
209
210	incode( p, sz ) register NODE *p; {
211
212	/* generate initialization code for assigning a constant c
213	to a field of width sz */
214	/* we assume that the proper alignment has been obtained */
215	/* inoff is updated to have the proper final value */
216	/* we also assume sz < SZINT */
217
218	if((sz+inwd) > SZINT) cerror("incode: field > int");
219	word \|= p->lval<<inwd;
220	inwd += sz;
221	inoff += sz;
222	if(inoff%SZINT == 0) {
223	printf( " %o\n", word);
224	word = inwd = 0;
225	}
226	}
227
228	fincode( d, sz ) double d; {
229	/* output code to initialize space of size sz to the value d */
230	/* the proper alignment has been obtained */
231	/* inoff is updated to have the proper final value */
232	/* on the target machine, write it out in octal! */
233
234	register int mi = (int )&d;
235
236	if( sz==SZDOUBLE )
237	printf( " %o; %o; %o; %o\n", mi[0], mi[1], mi[2], mi[3] );
238	else
239	printf( " %o; %o\n", mi[0], mi[1] );
240	inoff += sz;
241	}
242
243	cinit( p, sz ) NODE *p; {
244	/* arrange for the initialization of p into a space of
245	size sz */
246	/* the proper alignment has been opbtained */
247	/* inoff is updated to have the proper final value */
248	ecode( p );
249	inoff += sz;
250	}
251
252	vfdzero( n ){ /* define n bits of zeros in a vfd */
253
254	if( n <= 0 ) return;
255
256	inwd += n;
257	inoff += n;
258	if( inoff%ALINT ==0 ) {
259	printf( " %o\n", word );
260	word = inwd = 0;
261	}
262	}
263
264
265	char *
266	exname( p ) char *p; {
267	/* make a name look like an external name in the local machine */
268
269	static char text[NCHNAM+1];
270
271	register i;
272
273	text[0] = '_';
274	for( i=1; *p&&i<NCHNAM; ++i ){
275	text[i] = *p++;
276	}
277
278	text[i] = '\0';
279	text[NCHNAM] = '\0'; /* truncate */
280
281	return( text );
282	}
283
284	ctype( type ) TWORD type; { /* map types which are not defined on the local machine */
285	switch( BTYPE(type) ){
286	case SHORT:
287	MODTYPE(type,INT);
288	break;
289	case USHORT:
290	MODTYPE(type,UNSIGNED);
291	}
292	return( type );
293	}
294
295	noinit() { /* curid is a variable which is defined but
296	is not initialized (and not a function );
297	This routine returns the stroage class for an uninitialized declaration */
298
299	return(EXTERN);
300
301	}
302
303	commdec( id ){ /* make a common declaration for id, if reasonable */
304	register struct symtab *q;
305	OFFSZ off;
306
307	q = &stab[id];
308	printf( " .comm %s,", exname( q->sname ) );
309	off = tsize( q->stype, q->dimoff, q->sizoff );
310	printf( CONFMT, off/SZCHAR );
311	printf( ".\n" );
312	}
313
314	isitlong( cb, ce ){ /* is lastcon to be long or short */
315	/* cb is the first character of the representation, ce the last */
316
317	if( ce == 'l' \|\| ce == 'L' \|\|
318	lastcon >= (1L << (SZINT-1) ) ) return (1);
319	return(0);
320	}
321
322
323	isitfloat( s ) char *s; {
324	double atof();
325	dcon = atof(s);
326	return( FCON );
327	}
328
329	ecode( p ) NODE *p; {
330
331	/* walk the tree and write out the nodes.. */
332
333	if( nerrors ) return;
334	p2tree( p );
335	p2compile( p );
336	}
337