![[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 / pcc|
Return to local.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / pcc |
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) 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 o;
23: register 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 == FLOAT || p->in.type == DOUBLE );
92: ml = (p->in.left->in.type == FLOAT || p->in.left->in.type == DOUBLE );
93: if( m != ml ) break;
94:
95: /* now, look for conversions downwards */
96:
97: m = p->in.type;
98: ml = p->in.left->in.type;
99: if( p->in.left->in.op == ICON ){ /* simulate the conversion here */
100: CONSZ val;
101: val = p->in.left->tn.lval;
102: switch( m ){
103: case CHAR:
104: p->in.left->tn.lval = (char) val;
105: break;
106: case UCHAR:
107: p->in.left->tn.lval = val & 0XFF;
108: break;
109: case USHORT:
110: p->in.left->tn.lval = val & 0XFFFFL;
111: break;
112: case SHORT:
113: p->in.left->tn.lval = (short)val;
114: break;
115: case UNSIGNED:
116: p->in.left->tn.lval = val & 0xFFFFFFFFL;
117: break;
118: case INT:
119: p->in.left->tn.lval = (int)val;
120: break;
121: }
122: p->in.left->in.type = m;
123: }
124: else {
125: /* meaningful ones are conversion of int to char, int to short,
126: and short to char, and unsigned versions thereof */
127: if( m==CHAR || m==UCHAR ){
128: if( ml!=CHAR && ml!= UCHAR ) break;
129: }
130: else if( m==SHORT || m==USHORT ){
131: if( ml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break;
132: }
133: }
134:
135: /* clobber conversion */
136: if( tlen(p) == tlen(p->in.left) ) goto inherit;
137: p->in.op = FREE;
138: return( p->in.left ); /* conversion gets clobbered */
139:
140: case PVCONV:
141: case PMCONV:
142: if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0);
143: p->in.op = FREE;
144: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) );
145:
146: case FLD:
147: /* make sure that the second pass does not make the
148: descendant of a FLD operator into a doubly indexed OREG */
149:
150: if( p->in.left->in.op == UNARY MUL
151: && (r=p->in.left->in.left)->in.op == PCONV)
152: if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS )
153: if( ISPTR(r->in.type) ) {
154: if( ISUNSIGNED(p->in.left->in.type) )
155: p->in.left->in.type = UNSIGNED;
156: else
157: p->in.left->in.type = INT;
158: }
159: break;
160: }
161:
162: return(p);
163: }
164:
165: andable( p ) NODE *p; {
166: return(1); /* all names can have & taken on them */
167: }
168:
169: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
170: autooff = AUTOINIT;
171: }
172:
173: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
174:
175: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */
176: #ifdef REG_CHAR
177: || t==CHAR || t==UCHAR || t==SHORT || t==USHORT /* tbl */
178: #endif
179: || ISPTR(t)) return (1); /* wnj */
180: return(0);
181: }
182:
183: NODE *
184: offcon( off, t, d, s ) OFFSZ off; TWORD t; {
185:
186: /* return a node, for structure references, which is suitable for
187: being added to a pointer of type t, in order to be off bits offset
188: into a structure */
189:
190: register NODE *p;
191:
192: /* t, d, and s are the type, dimension offset, and sizeoffset */
193: /* in general they are necessary for offcon, but not on H'well */
194:
195: p = bcon(0);
196: p->tn.lval = off/SZCHAR;
197: return(p);
198:
199: }
200:
201:
202: static inwd /* current bit offsed in word */;
203: static CONSZ word /* word being built from fields */;
204:
205: incode( p, sz ) register NODE *p; {
206:
207: /* generate initialization code for assigning a constant c
208: to a field of width sz */
209: /* we assume that the proper alignment has been obtained */
210: /* inoff is updated to have the proper final value */
211: /* we also assume sz < SZINT */
212:
213: inwd += sz;
214: if(inwd > SZINT) cerror("incode: field > int");
215: word |= (p->tn.lval&((1L<<sz)-1)) << (SZINT-inwd);
216: inoff += sz;
217: if(inoff%SZINT == 0) {
218: printf( " .long 0x%08X\n", word);
219: word = inwd = 0;
220: }
221: }
222:
223: fincode( d, sz ) double d; register sz; {
224: /* output code to initialize space of size sz to the value d */
225: /* the proper alignment has been obtained */
226: /* inoff is updated to have the proper final value */
227: /* this code should be the same for PDP, VAX and Tahoe */
228:
229: register struct sh4 {
230: unsigned short sh[4];
231: } *x;
232: # ifdef SFCON
233: register type;
234: # endif
235:
236: x = (struct sh4 *)&d;
237: printf(" .long 0x%04x%04x", x->sh[0], x->sh[1]);
238: # ifdef SFCON
239: if(sz==0)
240: if(x->sh[2]==0 && x->sh[3]==0) {
241: sz = SZFLOAT;
242: type = FLOAT;
243: } else {
244: sz = SZDOUBLE;
245: type = DOUBLE;
246: }
247: # endif
248: if(sz == SZDOUBLE) {
249: printf(", 0x%04x%04x", x->sh[2], x->sh[3]);
250: printf(" # .double");
251: } else
252: printf(" # .float");
253: printf(" %.20g\n", d);
254: inoff += sz;
255: # ifdef SFCON
256: return type;
257: # endif
258: }
259:
260: cinit( p, sz ) NODE *p; {
261: /* arrange for the initialization of p into a space of
262: size sz */
263: /* the proper alignment has been opbtained */
264: /* inoff is updated to have the proper final value */
265: ecode( p );
266: inoff += sz;
267: }
268:
269: vfdzero( n ){ /* define n bits of zeros in a vfd */
270:
271: if( n <= 0 ) return;
272:
273: inwd += n;
274: inoff += n;
275: if( inoff%ALINT ==0 ) {
276: printf( " .long 0x%08X\n", word );
277: word = inwd = 0;
278: }
279: }
280:
281: char *
282: exname( p ) char *p; {
283: /* make a name look like an external name in the local machine */
284:
285: #ifndef FLEXNAMES
286: static char text[NCHNAM+1];
287: #else
288: static char text[BUFSIZ+1];
289: #endif
290:
291: register i;
292:
293: text[0] = '_';
294: #ifndef FLEXNAMES
295: for( i=1; *p&&i<NCHNAM; ++i ){
296: #else
297: for( i=1; *p; ++i ){
298: #endif
299: text[i] = *p++;
300: }
301:
302: text[i] = '\0';
303: #ifndef FLEXNAMES
304: text[NCHNAM] = '\0'; /* truncate */
305: #endif
306:
307: return( text );
308: }
309:
310: ctype( type )TWORD type;{ /* map types which are not defined on the local machine */
311: switch( BTYPE(type) ){
312:
313: case LONG:
314: MODTYPE(type,INT);
315: break;
316:
317: case ULONG:
318: MODTYPE(type,UNSIGNED);
319: }
320: return( type );
321: }
322:
323: noinit() { /* curid is a variable which is defined but
324: is not initialized (and not a function );
325: This routine returns the stroage class for an uninitialized declaration */
326:
327: return(EXTERN);
328:
329: }
330:
331: commdec( id ){ /* make a common declaration for id, if reasonable */
332: register struct symtab *q;
333: OFFSZ off, tsize();
334:
335: q = &stab[id];
336: printf( " .comm %s,", exname( q->sname ) );
337: off = tsize( q->stype, q->dimoff, q->sizoff );
338: printf( "%d" /*CONFMT*/, off/SZCHAR );
339: printf( "\n" );
340: }
341:
342:
343: isitfloat( s ) char *s; {
344: double atof();
345: dcon = atof(s);
346: return( FCON );
347: }
348:
349: ecode( p ) NODE *p; {
350:
351: /* walk the tree and write out the nodes.. */
352:
353: if( nerrors ) return;
354: p2tree( p );
355: p2compile( p );
356: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.