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