![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / pcc|
Return to local.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / pcc |
1.1 root 1: #ifndef lint
2: static char *sccsid ="@(#)local.c 1.8 (Berkeley) 8/23/85";
3: #endif lint
4:
5: # include "pass1.h"
6:
7: /* this file contains code which is dependent on the target machine */
8:
9: NODE *
10: cast( p, t ) register NODE *p; TWORD t; {
11: /* cast node p to type t */
12:
13: p = buildtree( CAST, block( NAME, NIL, NIL, t, 0, (int)t ), p );
14: p->in.left->in.op = FREE;
15: p->in.op = FREE;
16: return( p->in.right );
17: }
18:
19: NODE *
20: clocal(p) NODE *p; {
21:
22: /* this is called to do local transformations on
23: an expression tree preparitory to its being
24: written out in intermediate code.
25: */
26:
27: /* the major essential job is rewriting the
28: automatic variables and arguments in terms of
29: REG and OREG nodes */
30: /* conversion ops which are not necessary are also clobbered here */
31: /* in addition, any special features (such as rewriting
32: exclusive or) are easily handled here as well */
33:
34: register struct symtab *q;
35: register NODE *r;
36: register o;
37: register m, ml;
38:
39: switch( o = p->in.op ){
40:
41: case NAME:
42: if( p->tn.rval < 0 ) { /* already processed; ignore... */
43: return(p);
44: }
45: q = &stab[p->tn.rval];
46: switch( q->sclass ){
47:
48: case AUTO:
49: case PARAM:
50: /* fake up a structure reference */
51: r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 );
52: r->tn.lval = 0;
53: r->tn.rval = (q->sclass==AUTO?STKREG:ARGREG);
54: p = stref( block( STREF, r, p, 0, 0, 0 ) );
55: break;
56:
57: case ULABEL:
58: case LABEL:
59: case STATIC:
60: if( q->slevel == 0 ) break;
61: p->tn.lval = 0;
62: p->tn.rval = -q->offset;
63: break;
64:
65: case REGISTER:
66: p->in.op = REG;
67: p->tn.lval = 0;
68: p->tn.rval = q->offset;
69: break;
70:
71: }
72: break;
73:
74: case PCONV:
75: /* do pointer conversions for char and longs */
76: ml = p->in.left->in.type;
77: if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->in.left->in.op != ICON ) break;
78:
79: /* pointers all have the same representation; the type is inherited */
80:
81: p->in.left->in.type = p->in.type;
82: p->in.left->fn.cdim = p->fn.cdim;
83: p->in.left->fn.csiz = p->fn.csiz;
84: p->in.op = FREE;
85: return( p->in.left );
86:
87: case SCONV:
88: m = (p->in.type == FLOAT || p->in.type == DOUBLE );
89: ml = (p->in.left->in.type == FLOAT || p->in.left->in.type == DOUBLE );
90: o = p->in.left->in.op;
91: if( (o == FCON || o == DCON) && ml && !m ) {
92: /* float type to int type */
93: r = block( ICON, (NODE *)NULL, (NODE *)NULL, INT, 0, 0 );
94: if( o == FCON )
95: r->tn.lval = (int) p->in.left->fpn.fval;
96: else
97: r->tn.lval = (int) p->in.left->dpn.dval;
98: r->tn.rval = NONAME;
99: p->in.left->in.op = FREE;
100: p->in.left = r;
101: }
102: else
103: #ifdef SPRECC
104: if ( ml || m )
105: #else
106: if ( ml != m )
107: #endif
108: break;
109:
110: /* now, look for conversions downwards */
111:
112: m = p->in.type;
113: ml = p->in.left->in.type;
114: if( p->in.left->in.op == ICON ){ /* simulate the conversion here */
115: CONSZ val;
116: val = p->in.left->tn.lval;
117: switch( m ){
118: case CHAR:
119: p->in.left->tn.lval = (char) val;
120: break;
121: case UCHAR:
122: p->in.left->tn.lval = val & 0XFF;
123: break;
124: case USHORT:
125: p->in.left->tn.lval = val & 0XFFFFL;
126: break;
127: case SHORT:
128: p->in.left->tn.lval = (short)val;
129: break;
130: case UNSIGNED:
131: p->in.left->tn.lval = val & 0xFFFFFFFFL;
132: break;
133: case INT:
134: p->in.left->tn.lval = (int)val;
135: break;
136: }
137: p->in.left->in.type = m;
138: }
139: else if( m != FLOAT && m != DOUBLE )
140: break;
141:
142: /* clobber conversion */
143: p->in.op = FREE;
144: return( p->in.left ); /* conversion gets clobbered */
145:
146: case PVCONV:
147: case PMCONV:
148: if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0);
149: p->in.op = FREE;
150: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) );
151:
152: case RS:
153: case ASG RS:
154: /* convert >> to << with negative shift count */
155: /* only if type of left operand is not unsigned */
156:
157: if( ISUNSIGNED(p->in.left->in.type) ) break;
158: if( p->in.right->in.op != UNARY MINUS )
159: p->in.right = buildtree( UNARY MINUS, p->in.right, NIL );
160: else {
161: r = p->in.right;
162: p->in.right = p->in.right->in.left;
163: r->in.op = FREE;
164: }
165: if( p->in.op == RS ) p->in.op = LS;
166: else p->in.op = ASG LS;
167: break;
168:
169: case FLD:
170: /* make sure that the second pass does not make the
171: descendant of a FLD operator into a doubly indexed OREG */
172:
173: if( p->in.left->in.op == UNARY MUL
174: && (r=p->in.left->in.left)->in.op == PCONV)
175: if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS )
176: if( ISPTR(r->in.type) ) {
177: if( ISUNSIGNED(p->in.left->in.type) )
178: p->in.left->in.type = UCHAR;
179: else
180: p->in.left->in.type = CHAR;
181: }
182: break;
183: }
184:
185: return(p);
186: }
187:
188: andable( p ) NODE *p; {
189: return(1); /* all names can have & taken on them */
190: }
191:
192: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
193: autooff = AUTOINIT;
194: }
195:
196: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
197:
198: #ifdef TRUST_REG_CHAR_AND_REG_SHORT
199: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */
200: || t==CHAR || t==UCHAR || t==SHORT /* tbl */
201: || t==USHORT || ISPTR(t)) return(1); /* tbl */
202: #else
203: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* wnj */
204: #ifdef SPRECC
205: || t==FLOAT
206: #endif
207: || ISPTR(t)) return (1); /* wnj */
208: #endif
209: return(0);
210: }
211:
212: NODE *
213: offcon( off, t, d, s ) OFFSZ off; TWORD t; {
214:
215: /* return a node, for structure references, which is suitable for
216: being added to a pointer of type t, in order to be off bits offset
217: into a structure */
218:
219: register NODE *p;
220:
221: /* t, d, and s are the type, dimension offset, and sizeoffset */
222: /* in general they are necessary for offcon, but not on H'well */
223:
224: p = bcon(0);
225: p->tn.lval = off/SZCHAR;
226: return(p);
227:
228: }
229:
230:
231: static inwd /* current bit offsed in word */;
232: static word /* word being built from fields */;
233:
234: incode( p, sz ) register NODE *p; {
235:
236: /* generate initialization code for assigning a constant c
237: to a field of width sz */
238: /* we assume that the proper alignment has been obtained */
239: /* inoff is updated to have the proper final value */
240: /* we also assume sz < SZINT */
241:
242: if((sz+inwd) > SZINT) cerror("incode: field > int");
243: word |= ((unsigned)(p->tn.lval<<(32-sz))) >> (32-sz-inwd);
244: inwd += sz;
245: inoff += sz;
246: if(inoff%SZINT == 0) {
247: printf( " .long 0x%x\n", word);
248: word = inwd = 0;
249: }
250: }
251:
252: fincode( d, sz ) double d; {
253: /* output code to initialize space of size sz to the value d */
254: /* the proper alignment has been obtained */
255: /* inoff is updated to have the proper final value */
256: /* on the target machine, write it out in octal! */
257:
258:
259: printf(" %s 0%c%.20e\n", sz == SZDOUBLE ? ".double" : ".float",
260: sz == SZDOUBLE ? 'd' : 'f', d);
261: inoff += sz;
262: }
263:
264: cinit( p, sz ) NODE *p; {
265: NODE *l;
266:
267: /*
268: * as a favor (?) to people who want to write
269: * int i = 9600/134.5;
270: * we will, under the proper circumstances, do
271: * a coersion here.
272: */
273: switch (p->in.type) {
274: case INT:
275: case UNSIGNED:
276: l = p->in.left;
277: if (l->in.op != SCONV ||
278: (l->in.left->tn.op != DCON && l->in.left->tn.op != FCON))
279: break;
280: l->in.op = FREE;
281: l = l->in.left;
282: l->tn.lval = l->tn.op == DCON ? (long)(l->dpn.dval) :
283: (long)(l->fpn.fval);
284: l->tn.rval = NONAME;
285: l->tn.op = ICON;
286: l->tn.type = INT;
287: p->in.left = l;
288: break;
289: }
290: /* arrange for the initialization of p into a space of size sz */
291: /* the proper alignment has been opbtained */
292: /* inoff is updated to have the proper final value */
293: ecode( p );
294: inoff += sz;
295: }
296:
297: vfdzero( n ){ /* define n bits of zeros in a vfd */
298:
299: if( n <= 0 ) return;
300:
301: inwd += n;
302: inoff += n;
303: if( inoff%ALINT ==0 ) {
304: printf( " .long 0x%x\n", word );
305: word = inwd = 0;
306: }
307: }
308:
309: char *
310: exname( p ) char *p; {
311: /* make a name look like an external name in the local machine */
312:
313: #ifndef FLEXNAMES
314: static char text[NCHNAM+1];
315: #else
316: static char text[BUFSIZ+1];
317: #endif
318:
319: register i;
320:
321: text[0] = '_';
322: #ifndef FLEXNAMES
323: for( i=1; *p&&i<NCHNAM; ++i )
324: #else
325: for( i=1; *p; ++i )
326: #endif
327: text[i] = *p++;
328:
329: text[i] = '\0';
330: #ifndef FLEXNAMES
331: text[NCHNAM] = '\0'; /* truncate */
332: #endif
333:
334: return( text );
335: }
336:
337: ctype( type ) TWORD type;
338: { /* map types which are not defined on the local machine */
339: switch( BTYPE(type) ){
340:
341: case LONG:
342: MODTYPE(type,INT);
343: break;
344:
345: case ULONG:
346: MODTYPE(type,UNSIGNED);
347: }
348: return( type );
349: }
350:
351: noinit() { /* curid is a variable which is defined but
352: is not initialized (and not a function );
353: This routine returns the stroage class for an uninitialized declaration */
354:
355: return(EXTERN);
356:
357: }
358:
359: commdec( id ){ /* make a common declaration for id, if reasonable */
360: register struct symtab *q;
361: OFFSZ off, tsize();
362:
363: q = &stab[id];
364: printf( " .comm %s,", exname( q->sname ) );
365: off = tsize( q->stype, q->dimoff, q->sizoff );
366: printf( CONFMT, off/SZCHAR );
367: printf( "\n" );
368: }
369:
370: isitlong( cb, ce ){ /* is lastcon to be long or short */
371: /* cb is the first character of the representation, ce the last */
372:
373: if( ce == 'l' || ce == 'L' ||
374: lastcon >= (1L << (SZINT-1) ) ) return (1);
375: return(0);
376: }
377:
378:
379: isitfloat( s ) char *s; {
380: union cvt {
381: double d;
382: int n[2];
383: } cvt;
384: double atof();
385:
386: /* avoid floating point exception for double -> float conversions */
387: dcon = cvt.d = atof(s);
388: if( cvt.n[1] == 0 ){
389: fcon = dcon;
390: return( FCON );
391: }
392: return( DCON );
393: }
394:
395: ecode( p ) NODE *p; {
396:
397: /* walk the tree and write out the nodes.. */
398:
399: if( nerrors ) return;
400: p2tree( p );
401: p2compile( p );
402: }
403:
404: #ifndef ONEPASS
405: tlen(p) NODE *p;
406: {
407: switch(p->in.type) {
408: case CHAR:
409: case UCHAR:
410: return(1);
411:
412: case SHORT:
413: case USHORT:
414: return(2);
415:
416: case DOUBLE:
417: return(8);
418:
419: default:
420: return(4);
421: }
422: }
423: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.