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