![[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] / 3BSD / cmd / pcc|
Return to local.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / pcc |
1.1 root 1: # include "mfile1"
2: extern int eprint();
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->left->op = FREE;
12: p->op = FREE;
13: return( p->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->op ){
37:
38: case NAME:
39: if( p->rval < 0 ) { /* already processed; ignore... */
40: return(p);
41: }
42: q = &stab[p->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->lval = 0;
50: r->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->lval = 0;
59: p->rval = -q->offset;
60: break;
61:
62: case REGISTER:
63: p->op = REG;
64: p->lval = 0;
65: p->rval = q->offset;
66: break;
67:
68: }
69: break;
70:
71: case PCONV:
72: /* do pointer conversions for char and longs */
73: ml = p->left->type;
74: if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->left->op != ICON ) break;
75:
76: /* pointers all have the same representation; the type is inherited */
77:
78: inherit:
79: p->left->type = p->type;
80: p->left->cdim = p->cdim;
81: p->left->csiz = p->csiz;
82: p->op = FREE;
83: return( p->left );
84:
85: case SCONV:
86: m = (p->type == FLOAT || p->type == DOUBLE );
87: ml = (p->left->type == FLOAT || p->left->type == DOUBLE );
88: if( m != ml ) break;
89:
90: /* now, look for conversions downwards */
91:
92: m = p->type;
93: ml = p->left->type;
94: if( p->left->op == ICON ){ /* simulate the conversion here */
95: CONSZ val;
96: val = p->left->lval;
97: switch( m ){
98: case CHAR:
99: p->left->lval = (char) val;
100: break;
101: case UCHAR:
102: p->left->lval = val & 0XFF;
103: break;
104: case USHORT:
105: p->left->lval = val & 0XFFFFL;
106: break;
107: case SHORT:
108: p->left->lval = (short)val;
109: break;
110: case UNSIGNED:
111: p->left->lval = val & 0xFFFFFFFFL;
112: break;
113: case INT:
114: p->left->lval = (int)val;
115: break;
116: }
117: p->left->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->left) ) goto inherit;
132: p->op = FREE;
133: return( p->left ); /* conversion gets clobbered */
134:
135: case PVCONV:
136: case PMCONV:
137: if( p->right->op != ICON ) cerror( "bad conversion", 0);
138: p->op = FREE;
139: return( buildtree( o==PMCONV?MUL:DIV, p->left, p->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: if( ISUNSIGNED(p->left->type) ) break;
146: p->right = buildtree( UNARY MINUS, p->right, NIL );
147: if( p->op == RS ) p->op = LS;
148: else p->op = ASG LS;
149: break;
150:
151: case FLD:
152: if( p->left->op == UNARY MUL && (r=p->left->left)->op == PCONV)
153: if( r->left->op == PLUS || r->left->op == MINUS )
154: if( ISPTR(r->type) ) {
155: if( ISUNSIGNED(p->left->type) )
156: p->left->type = UCHAR;
157: else
158: p->left->type = CHAR;
159: }
160: break;
161: }
162:
163: return(p);
164: }
165:
166: andable( p ) NODE *p; {
167: return(1); /* all names can have & taken on them */
168: }
169:
170: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */
171: autooff = AUTOINIT;
172: }
173:
174: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */
175:
176: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */
177: || t==CHAR || t==UCHAR || t==SHORT || t==USHORT /* tbl */
178: || t==FLOAT || t==DOUBLE || ISPTR(t)) return(1); /* tbl */
179: return(0);
180: }
181:
182: NODE *
183: offcon( off, t, d, s ) OFFSZ off; TWORD t; {
184:
185: /* return a node, for structure references, which is suitable for
186: being added to a pointer of type t, in order to be off bits offset
187: into a structure */
188:
189: register NODE *p;
190:
191: /* t, d, and s are the type, dimension offset, and sizeoffset */
192: /* in general they are necessary for offcon, but not on H'well */
193:
194: p = bcon(0);
195: p->lval = off/SZCHAR;
196: return(p);
197:
198: }
199:
200:
201: static inwd /* current bit offsed in word */;
202: static word /* word being built from fields */;
203:
204: incode( p, sz ) register NODE *p; {
205:
206: /* generate initialization code for assigning a constant c
207: to a field of width sz */
208: /* we assume that the proper alignment has been obtained */
209: /* inoff is updated to have the proper final value */
210: /* we also assume sz < SZINT */
211:
212: if((sz+inwd) > SZINT) cerror("incode: field > int");
213: word |= ((unsigned)(p->lval<<(32-sz))) >> (32-sz-inwd);
214: inwd += sz;
215: inoff += sz;
216: if(inoff%SZINT == 0) {
217: printf( " .long 0x%x\n", word);
218: word = inwd = 0;
219: }
220: }
221:
222: fincode( d, sz ) double d; {
223: /* output code to initialize space of size sz to the value d */
224: /* the proper alignment has been obtained */
225: /* inoff is updated to have the proper final value */
226: /* on the target machine, write it out in octal! */
227:
228:
229: printf(" %s 0%c%.20e\n", sz == SZDOUBLE ? ".double" : ".float",
230: sz == SZDOUBLE ? 'd' : 'f', d);
231: inoff += sz;
232: }
233:
234: cinit( p, sz ) NODE *p; {
235: /* arrange for the initialization of p into a space of
236: size sz */
237: /* the proper alignment has been opbtained */
238: /* inoff is updated to have the proper final value */
239: ecode( p );
240: inoff += sz;
241: }
242:
243: vfdzero( n ){ /* define n bits of zeros in a vfd */
244:
245: if( n <= 0 ) return;
246:
247: inwd += n;
248: inoff += n;
249: if( inoff%ALINT ==0 ) {
250: printf( " .long 0x%x\n", word );
251: word = inwd = 0;
252: }
253: }
254:
255: char *
256: exname( p ) char *p; {
257: /* make a name look like an external name in the local machine */
258:
259: static char text[NCHNAM+1];
260:
261: register i;
262:
263: text[0] = '_';
264: for( i=1; *p&&i<NCHNAM; ++i ){
265: text[i] = *p++;
266: }
267:
268: text[i] = '\0';
269: text[NCHNAM] = '\0'; /* truncate */
270:
271: return( text );
272: }
273:
274: ctype( type ){ /* map types which are not defined on the local machine */
275: switch( BTYPE(type) ){
276:
277: case LONG:
278: MODTYPE(type,INT);
279: break;
280:
281: case ULONG:
282: MODTYPE(type,UNSIGNED);
283: }
284: return( type );
285: }
286:
287: noinit( t ) { /* curid is a variable which is defined but
288: is not initialized (and not a function );
289: This routine returns the stroage class for an uninitialized declaration */
290:
291: return(EXTERN);
292:
293: }
294:
295: commdec( id ){ /* make a common declaration for id, if reasonable */
296: register struct symtab *q;
297: OFFSZ off, tsize();
298:
299: q = &stab[id];
300: printf( " .comm %s,", exname( q->sname ) );
301: off = tsize( q->stype, q->dimoff, q->sizoff );
302: printf( CONFMT, off/SZCHAR );
303: printf( "\n" );
304: }
305:
306: isitlong( cb, ce ){ /* is lastcon to be long or short */
307: /* cb is the first character of the representation, ce the last */
308:
309: if( ce == 'l' || ce == 'L' ||
310: lastcon >= (1L << (SZINT-1) ) ) return (1);
311: return(0);
312: }
313:
314:
315: isitfloat( s ) char *s; {
316: double atof();
317: dcon = atof(s);
318: return( FCON );
319: }
320:
321: ecode( p ) NODE *p; {
322:
323: /* walk the tree and write out the nodes.. */
324:
325: if( nerrors ) return;
326: p2tree( p );
327: p2compile( p );
328: }
329:
330: #include "a.out.h"
331: int ddebug;
332: int gdebug;
333:
334:
335: outstab(p)
336: struct symtab *p; {
337: register TWORD ptype;
338: register char *pname;
339: register char pclass;
340: register int poffset;
341:
342: if (!gdebug) return;
343:
344: ptype = p->stype;
345: pname = p->sname;
346: pclass = p->sclass;
347: poffset = p->offset;
348:
349: if (ISFTN(ptype)) {
350: return;
351: }
352:
353: switch (pclass) {
354:
355: case AUTO:
356: pstab(pname, N_LSYM);
357: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR);
358: poffs(p);
359: return;
360:
361: case EXTDEF:
362: case EXTERN:
363: pstab(pname, N_GSYM);
364: printf("0,%d,0\n", ptype);
365: poffs(p);
366: return;
367:
368: case STATIC:
369: pstab(pname, N_STSYM);
370: if (p->slevel > 1) {
371: printf("0,%d,L%d\n", ptype, poffset);
372: } else {
373: printf("0,%d,%s\n", ptype, exname(pname));
374: }
375: poffs(p);
376: return;
377:
378: case REGISTER:
379: pstab(pname, N_RSYM);
380: printf("0,%d,%d\n", ptype, poffset);
381: poffs(p);
382: return;
383:
384: case MOS:
385: case MOU:
386: pstab(pname, N_SSYM);
387: printf("0,%d,%d\n", ptype, poffset/SZCHAR);
388: poffs(p);
389: return;
390:
391: case PARAM:
392: /* parameter stab entries are processed in dclargs() */
393: return;
394:
395: default:
396: if (ddebug) printf(" No .stab for %.8s\n", pname);
397: }
398: }
399:
400: pstab(name, type)
401: char *name;
402: int type;
403: {
404: register int i;
405: register char c;
406: if (!gdebug) return;
407: #ifdef ASSTRINGS
408: if ( name[0] == '\0')
409: printf("\t.stabn\t");
410: else
411: printf("\t.stabs\t\"%.8s\", ", name);
412: #else
413:
414: printf(" .stab ");
415: for(i=0; i<8; i++)
416: if (c = name[i]) printf("'%c,", c);
417: else printf("0,");
418: #endif
419: printf("0%o,", type);
420: }
421:
422: #ifdef STABDOT
423: pstabdot(type, value)
424: int type;
425: int value;
426: {
427: if ( ! gdebug) return;
428: printf("\t.stabd\t");
429: printf("0%o,0,0%o\n",type, value);
430: }
431: #endif
432:
433: poffs(p)
434: register struct symtab *p; {
435: int s;
436: if (!gdebug) return;
437: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) {
438: pstab(p->sname, N_LENG);
439: printf("1,0,%d\n", s);
440: }
441: }
442:
443: char NULLNAME[8];
444: int labelno;
445: int fdefflag;
446:
447: psline() {
448: static int lastlineno;
449: register char *cp, *cq;
450: register int i;
451:
452: if (!gdebug) return;
453:
454: cq = ititle;
455: cp = ftitle;
456:
457: while ( *cq ) if ( *cp++ != *cq++ ) goto neq;
458: if ( *cp == '\0' ) goto eq;
459:
460: neq: for (i=0; i<100; i++)
461: ititle[i] = '\0';
462: cp = ftitle;
463: cq = ititle;
464: while ( *cp )
465: *cq++ = *cp++;
466: *cq = '\0';
467: *--cq = '\0';
468: for ( cp = ititle+1; *(cp-1); cp += 8 ) {
469: /*
470: * We use the old style stab to introduce the
471: * name of the file. This is the only place
472: * where we could use a stab, with the last
473: * expression the '.', but this is also the only
474: * place where the first argument to the stab is
475: * a string (namely the name of the file).
476: */
477: pstab(cp, N_SOL);
478: if (gdebug) printf("0,0,LL%d\n", labelno);
479: }
480: *cq = '"';
481: printf("LL%d:\n", labelno++);
482:
483: eq: if (lineno == lastlineno) return;
484: lastlineno = lineno;
485:
486: if (fdefflag) {
487: #ifdef STABDOT
488: pstabdot(N_SLINE, lineno);
489: #else
490: pstab(NULLNAME, N_SLINE);
491: printf("0,%d,LL%d\n", lineno, labelno);
492: printf("LL%d:\n", labelno++);
493: #endif
494: }
495: }
496:
497: plcstab(level) {
498: if (!gdebug) return;
499: #ifdef STABDOT
500: pstabdot(N_LBRAC, level);
501: #else
502: pstab(NULLNAME, N_LBRAC);
503: printf("0,%d,LL%d\n", level, labelno);
504: printf("LL%d:\n", labelno++);
505: #endif
506: }
507:
508: prcstab(level) {
509: if (!gdebug) return;
510: #ifdef STABDOT
511: pstabdot(N_RBRAC, level);
512: #else
513: pstab(NULLNAME, N_RBRAC);
514: printf("0,%d,LL%d\n", level, labelno);
515: printf("LL%d:\n", labelno++);
516: #endif
517: }
518:
519: pfstab(sname)
520: char *sname; {
521: if (!gdebug) return;
522: pstab(sname, N_FUN);
523: printf("0,%d,_%.7s\n", lineno, sname);
524: }
525:
526: #ifndef ONEPASS
527: tlen(p) NODE *p;
528: {
529: switch(p->type) {
530: case CHAR:
531: case UCHAR:
532: return(1);
533:
534: case SHORT:
535: case USHORT:
536: return(2);
537:
538: case DOUBLE:
539: return(8);
540:
541: default:
542: return(4);
543: }
544: }
545: #endif
546:
547:
548:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.