![[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] / 42BSD / lib / pcc|
Return to local.c CVS log | Up to [CSRG BSD Unix] / 42BSD / lib / pcc |
1.1 root 1: static char *sccsid ="@(#)local.c 1.2 (Berkeley) 12/18/82";
2: # include "mfile1"
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->in.left->in.op = FREE;
12: p->in.op = FREE;
13: return( p->in.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->in.op ){
37:
38: case NAME:
39: if( p->tn.rval < 0 ) { /* already processed; ignore... */
40: return(p);
41: }
42: q = &stab[p->tn.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->tn.lval = 0;
50: r->tn.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->tn.lval = 0;
59: p->tn.rval = -q->offset;
60: break;
61:
62: case REGISTER:
63: p->in.op = REG;
64: p->tn.lval = 0;
65: p->tn.rval = q->offset;
66: break;
67:
68: }
69: break;
70:
71: case PCONV:
72: /* do pointer conversions for char and longs */
73: ml = p->in.left->in.type;
74: if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->in.left->in.op != ICON ) break;
75:
76: /* pointers all have the same representation; the type is inherited */
77:
78: inherit:
79: p->in.left->in.type = p->in.type;
80: p->in.left->fn.cdim = p->fn.cdim;
81: p->in.left->fn.csiz = p->fn.csiz;
82: p->in.op = FREE;
83: return( p->in.left );
84:
85: case SCONV:
86: m = (p->in.type == FLOAT || p->in.type == DOUBLE );
87: ml = (p->in.left->in.type == FLOAT || p->in.left->in.type == DOUBLE );
88: if( m != ml ) break;
89:
90: /* now, look for conversions downwards */
91:
92: m = p->in.type;
93: ml = p->in.left->in.type;
94: if( p->in.left->in.op == ICON ){ /* simulate the conversion here */
95: CONSZ val;
96: val = p->in.left->tn.lval;
97: switch( m ){
98: case CHAR:
99: p->in.left->tn.lval = (char) val;
100: break;
101: case UCHAR:
102: p->in.left->tn.lval = val & 0XFF;
103: break;
104: case USHORT:
105: p->in.left->tn.lval = val & 0XFFFFL;
106: break;
107: case SHORT:
108: p->in.left->tn.lval = (short)val;
109: break;
110: case UNSIGNED:
111: p->in.left->tn.lval = val & 0xFFFFFFFFL;
112: break;
113: case INT:
114: p->in.left->tn.lval = (int)val;
115: break;
116: }
117: p->in.left->in.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!=CHAR && ml!= UCHAR ) break;
124: }
125: else if( m==SHORT || m==USHORT ){
126: if( ml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break;
127: }
128: }
129:
130: /* clobber conversion */
131: if( tlen(p) == tlen(p->in.left) ) goto inherit;
132: p->in.op = FREE;
133: return( p->in.left ); /* conversion gets clobbered */
134:
135: case PVCONV:
136: case PMCONV:
137: if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0);
138: p->in.op = FREE;
139: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) );
140:
141: case RS:
142: case ASG RS:
143: /* convert >> to << with negative shift count */
144: /* only if type of left operand is not unsigned */
145:
146: if( ISUNSIGNED(p->in.left->in.type) ) break;
147: p->in.right = buildtree( UNARY MINUS, p->in.right, NIL );
148: if( p->in.op == RS ) p->in.op = LS;
149: else p->in.op = ASG LS;
150: break;
151:
152: case FLD:
153: /* make sure that the second pass does not make the
154: descendant of a FLD operator into a doubly indexed OREG */
155:
156: if( p->in.left->in.op == UNARY MUL
157: && (r=p->in.left->in.left)->in.op == PCONV)
158: if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS )
159: if( ISPTR(r->in.type) ) {
160: if( ISUNSIGNED(p->in.left->in.type) )
161: p->in.left->in.type = UCHAR;
162: else
163: p->in.left->in.type = CHAR;
164: }
165: break;
166: }
167:
168: return(p);
169: }
170:
171: andable( p ) NODE *p; {
172: return(1); /* all names can have & taken on them */
173: }
174:
175: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
176: autooff = AUTOINIT;
177: }
178:
179: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
180:
181: #ifdef TRUST_REG_CHAR_AND_REG_SHORT
182: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */
183: || t==CHAR || t==UCHAR || t==SHORT /* tbl */
184: || t==USHORT || ISPTR(t)) return(1); /* tbl */
185: #else
186: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* wnj */
187: || ISPTR(t)) return (1); /* wnj */
188: #endif
189: return(0);
190: }
191:
192: NODE *
193: offcon( off, t, d, s ) OFFSZ off; TWORD t; {
194:
195: /* return a node, for structure references, which is suitable for
196: being added to a pointer of type t, in order to be off bits offset
197: into a structure */
198:
199: register NODE *p;
200:
201: /* t, d, and s are the type, dimension offset, and sizeoffset */
202: /* in general they are necessary for offcon, but not on H'well */
203:
204: p = bcon(0);
205: p->tn.lval = off/SZCHAR;
206: return(p);
207:
208: }
209:
210:
211: static inwd /* current bit offsed in word */;
212: static word /* word being built from fields */;
213:
214: incode( p, sz ) register NODE *p; {
215:
216: /* generate initialization code for assigning a constant c
217: to a field of width sz */
218: /* we assume that the proper alignment has been obtained */
219: /* inoff is updated to have the proper final value */
220: /* we also assume sz < SZINT */
221:
222: if((sz+inwd) > SZINT) cerror("incode: field > int");
223: word |= ((unsigned)(p->tn.lval<<(32-sz))) >> (32-sz-inwd);
224: inwd += sz;
225: inoff += sz;
226: if(inoff%SZINT == 0) {
227: printf( " .long 0x%x\n", word);
228: word = inwd = 0;
229: }
230: }
231:
232: fincode( d, sz ) double d; {
233: /* output code to initialize space of size sz to the value d */
234: /* the proper alignment has been obtained */
235: /* inoff is updated to have the proper final value */
236: /* on the target machine, write it out in octal! */
237:
238:
239: printf(" %s 0%c%.20e\n", sz == SZDOUBLE ? ".double" : ".float",
240: sz == SZDOUBLE ? 'd' : 'f', d);
241: inoff += sz;
242: }
243:
244: cinit( p, sz ) NODE *p; {
245: /* arrange for the initialization of p into a space of
246: size sz */
247: /* the proper alignment has been opbtained */
248: /* inoff is updated to have the proper final value */
249: ecode( p );
250: inoff += sz;
251: }
252:
253: vfdzero( n ){ /* define n bits of zeros in a vfd */
254:
255: if( n <= 0 ) return;
256:
257: inwd += n;
258: inoff += n;
259: if( inoff%ALINT ==0 ) {
260: printf( " .long 0x%x\n", word );
261: word = inwd = 0;
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: #ifndef FLEXNAMES
270: static char text[NCHNAM+1];
271: #else
272: static char text[BUFSIZ+1];
273: #endif
274:
275: register i;
276:
277: text[0] = '_';
278: #ifndef FLEXNAMES
279: for( i=1; *p&&i<NCHNAM; ++i ){
280: #else
281: for( i=1; *p; ++i ){
282: #endif
283: text[i] = *p++;
284: }
285:
286: text[i] = '\0';
287: #ifndef FLEXNAMES
288: text[NCHNAM] = '\0'; /* truncate */
289: #endif
290:
291: return( text );
292: }
293:
294: ctype( type ){ /* map types which are not defined on the local machine */
295: switch( BTYPE(type) ){
296:
297: case LONG:
298: MODTYPE(type,INT);
299: break;
300:
301: case ULONG:
302: MODTYPE(type,UNSIGNED);
303: }
304: return( type );
305: }
306:
307: noinit( t ) { /* curid is a variable which is defined but
308: is not initialized (and not a function );
309: This routine returns the stroage class for an uninitialized declaration */
310:
311: return(EXTERN);
312:
313: }
314:
315: commdec( id ){ /* make a common declaration for id, if reasonable */
316: register struct symtab *q;
317: OFFSZ off, tsize();
318:
319: q = &stab[id];
320: printf( " .comm %s,", exname( q->sname ) );
321: off = tsize( q->stype, q->dimoff, q->sizoff );
322: printf( CONFMT, off/SZCHAR );
323: printf( "\n" );
324: }
325:
326: isitlong( cb, ce ){ /* is lastcon to be long or short */
327: /* cb is the first character of the representation, ce the last */
328:
329: if( ce == 'l' || ce == 'L' ||
330: lastcon >= (1L << (SZINT-1) ) ) return (1);
331: return(0);
332: }
333:
334:
335: isitfloat( s ) char *s; {
336: double atof();
337: dcon = atof(s);
338: return( FCON );
339: }
340:
341: ecode( p ) NODE *p; {
342:
343: /* walk the tree and write out the nodes.. */
344:
345: if( nerrors ) return;
346: p2tree( p );
347: p2compile( p );
348: }
349:
350: #ifndef ONEPASS
351: tlen(p) NODE *p;
352: {
353: switch(p->in.type) {
354: case CHAR:
355: case UCHAR:
356: return(1);
357:
358: case SHORT:
359: case USHORT:
360: return(2);
361:
362: case DOUBLE:
363: return(8);
364:
365: default:
366: return(4);
367: }
368: }
369: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.