![[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 [Research Unix] / researchv8dc / cmd / ccom / vax|
Return to local.c CVS log | Up to [Research Unix] / researchv8dc / cmd / ccom / vax |
1.1 root 1: # include <stdio.h>
2: extern int Pflag, bbcnt;
3: # include "mfile1.h"
4:
5: int minrvar = 11;
6: int wloop_level = LL_BOT;
7: int floop_level = LL_BOT;
8: int maxboff;
9: int maxtemp;
10: codgen(p)
11: NODE *p;
12: { extern int bothdebug;
13: if(bothdebug)
14: tfree(p);
15: } /* so pcc2 stuff doesn't get loaded */
16: #if !defined(COMBINED)
17:
18: main( argc, argv ) char *argv[];
19: {
20: int r; char errbuf[BUFSIZ];
21:
22: setbuf(stderr, errbuf);
23: r = mainp1( argc, argv );
24: flushx();
25: return( r );
26: }
27:
28: beg_file()
29: {
30: /* called as the very first thing by the parser to do machine
31: * dependent stuff
32: */
33: regvar = minrvar;
34: dbfile(NULL);
35: }
36:
37: #else /* defined(COMBINED) */
38:
39: locctr(i)
40: int i;
41: {
42: static int last = PROG;
43:
44: if (i == last)
45: return;
46: else if (i == PROG)
47: printx(" .text\n");
48: else if (i == DATA)
49: printx(" .data\n");
50: else
51: cerror("funny location counter");
52: last = i;
53: }
54:
55: #endif
56:
57: NODE *
58: treecpy(p) /* first pass version of tcopy() */
59: register NODE *p;
60: {
61: /* make a fresh copy of p */
62: register NODE *q;
63:
64: q = talloc();
65: *q = *p;
66: switch (optype(q->in.op))
67: {
68: case BITYPE:
69: q->in.right = treecpy(p->in.right);
70: case UTYPE:
71: q->in.left = treecpy(p->in.left);
72: }
73: return (q);
74: }
75:
76: #if !defined(COMBINED)
77:
78: NODE *
79: clocal(p) NODE *p;
80: {
81: register NODE *l,*ll,*r;
82: if( p->in.op == STAR )
83: { /* if it looks like index mode put the */
84: /* offset on the right */
85: l = p->in.left;
86: if( l->in.op == PLUS )
87: {
88: ll = l->in.left;
89: if( ll->in.op != MUL && ll->in.op != UNARY AND )
90: {
91: if( (l->in.right)->in.op == MUL )
92: {
93: r = l->in.right;
94: l->in.right = l->in.left;
95: l->in.left = r;
96: }
97: }
98: }
99: }
100: #ifdef DASSOVCOL
101: if (!asgbinop(p->in.op) && p->in.op != ASSIGN)
102: return (p);
103: r = p->in.right;
104: if (optype(r->in.op) == LTYPE)
105: return (p);
106: l = r->in.left;
107: if (r->in.op == QUEST || (r->in.op == CONV && l->in.op == QUEST) ||
108: (r->in.op == CONV && l->in.op == CONV &&
109: l->in.left->in.op == QUEST))
110: /* distribute assigns over colons */
111: {
112: register NODE *pwork;
113: NODE *pcpy = treecpy(p), *pnew;
114: #ifndef NODBG
115: extern int xdebug, eprint();
116:
117: if (xdebug)
118: {
119: puts("Entering [op]=?: distribution");
120: eprint(p);
121: }
122: #endif
123: pnew = pcpy->in.right;
124: while (pnew->in.op != QUEST)
125: pnew = pnew->in.left;
126: /*
127: * pnew is top of new tree
128: */
129: if ((pwork = p)->in.right->in.op == QUEST)
130: {
131: tfree(pwork->in.right);
132: pwork->in.right = pnew->in.right->in.left;
133: pnew->in.right->in.left = pwork;
134: /* at this point, 1/2 distributed. Tree looks like:
135: * ASSIGN|ASGOP
136: * LVAL QUEST
137: * EXPR1 COLON
138: * ASSIGN|ASGOP EXPR3
139: * LVAL EXPR2
140: * pnew "holds" new tree from QUEST node
141: */
142: }
143: else
144: {
145: NODE *pholdtop = pwork;
146:
147: pwork = pwork->in.right;
148: while (pwork->in.left->in.op != QUEST)
149: pwork = pwork->in.left;
150: tfree(pwork->in.left);
151: pwork->in.left = pnew->in.right->in.left;
152: pnew->in.right->in.left = pholdtop;
153: /* at this point, 1/2 distributed. Tree looks like:
154: * ASSIGN|ASGOP
155: * LVAL ANY # OF CONVs
156: * QUEST
157: * EXPR1 COLON
158: * ASSIGN|ASGOP EXPR3
159: * LVAL ANY # OF CONVs
160: * EXPR2
161: * pnew "holds" new tree from QUEST node
162: */
163: }
164: if ((pwork = pcpy)->in.right->in.op == QUEST)
165: {
166: pwork->in.right = pnew->in.right->in.right;
167: pnew->in.right->in.right = pwork;
168: /*
169: * done with the easy case
170: */
171: }
172: else
173: {
174: NODE *pholdtop = pwork;
175:
176: pwork = pwork->in.right;
177: while (pwork->in.left->in.op != QUEST)
178: pwork = pwork->in.left;
179: pwork->in.left = pnew->in.right->in.right;
180: pnew->in.right->in.right = pholdtop;
181: /*
182: * done with the CONVs case
183: */
184: }
185: p = pnew;
186: #ifndef NODBG
187: if (xdebug)
188: {
189: puts("Leaving [op]=?: distribution");
190: eprint(p);
191: }
192: #endif
193: }
194: #endif
195: return(p);
196: }
197: #endif
198:
199: cisreg( t ) TWORD t;
200: { /* is an automatic variable of type t OK for a register variable */
201:
202: if( t==INT || t==UNSIGNED || ISPTR(t) || t==CHAR || t==UCHAR
203: || t==SHORT || t==USHORT || t==FLOAT
204: /* (sigh) || t==STRTY || t == UNIONTY*/ )
205: {
206: if( regvar >= 6 )
207: {
208: nextrvar = regvar--;
209: if( regvar < minrvar ) minrvar = regvar;
210: return(1);
211: }
212: }
213: return(0);
214: }
215:
216: opbigsz( op )
217: {
218: /* the size below which we do not shrink ops */
219: switch( op )
220: {
221:
222: default:
223: return( SZINT );
224:
225: case PLUS:
226: case MINUS:
227: case OR:
228: case AND:
229: case ER:
230: case COMPL:
231: case UNARY MINUS:
232: return( SZCHAR );
233:
234: }
235: }
236:
237: branch(n) /* branch to label n or return */
238: int n;
239: {
240: if (!reached) /* return <expr>; } comes here 2x */
241: return;
242: genubr(n);
243: }
244:
245: #if !defined(COMBINED)
246: /* direct switch beginning */
247: static int tablelabel;
248:
249: struct sw heapsw[SWITSZ]; /* heap for switches */
250:
251: /* test for whether to do a direct switch */
252: # ifndef DSWTEST
253: # define DSWTEST(r,n) (r>0 && r<=(3*n) && n>=4)
254: # endif
255: /* test for whether to do a heap switch */
256: # ifndef HEAPTEST
257: # define HEAPTEST( n ) (n>8)
258: # endif
259:
260: genswitch(p,n) register struct sw *p;
261: {
262: /* p points to an array of structures, each consisting
263: of a constant value and a label.
264: The first is >=0 if there is a default label;
265: its value is the label number
266: The entries p[1] to p[n] are the nontrivial cases
267: */
268: register i;
269: register CONSZ j, range;
270: register dlab, swlab;
271:
272: range = p[n].sval-p[1].sval;
273:
274: if( DSWTEST( range, n ) )
275: { /* implement a direct switch */
276:
277: swlab = getlab();
278: dlab = ((p->slab >= 0) ? p->slab : getlab());
279:
280: dswbegin( n, p[1].sval, range, swlab, dlab );
281:
282: for( i=1,j=p[1].sval; i<=n; j++)
283: {
284: if( j == p[i].sval )
285: {
286: dswcase( p[i].slab );
287: j = p[i++].sval;
288: }
289: else
290: {
291: dswcase( dlab );
292: }
293: }
294:
295: /* in case dswbegin changed location counters... */
296: locctr( PROG );
297:
298: if( p->slab >= 0 ) genubr( dlab );
299: else deflab( dlab );
300: return;
301: }
302:
303: if( HEAPTEST(n) )
304: { /* heap switch */
305:
306: heapsw[0].slab = dlab = (p->slab >= 0 ? p->slab : getlab());
307: makeheap(p, n, 1); /* build heap */
308: walkheap(1, n); /* produce code */
309:
310: if( p->slab >= 0 )
311: genubr( dlab );
312: else
313: deflab( dlab );
314: return;
315: }
316:
317: /* simple switch code */
318:
319: for( i=1; i<=n; ++i ) sswtest( p[i].sval, p[i].slab );
320: if( p->slab>=0 ) genubr( p->slab );
321:
322: }
323:
324: makeheap(p, m, n)
325: register struct sw *p;
326: {
327: register int q;
328:
329: q = select(m);
330: heapsw[n] = p[q];
331: if( q>1 ) makeheap(p, q-1, 2*n);
332: if( q<m ) makeheap(p+q, m-q, 2*n+1);
333: }
334:
335: select(m) {
336: register int l,i,k;
337:
338: for(i=1; ; i*=2)
339: if( (i-1) > m ) break;
340: l = ((k = i/2 - 1) + 1)/2;
341: return( l + (m-k < l ? m-k : l));
342: }
343:
344: walkheap(start, limit)
345: {
346: int label;
347:
348:
349: if( start > limit ) return;
350: sswtest( heapsw[start].sval, heapsw[start].slab );
351: if( (2*start) > limit ) {
352: genubr( heapsw[0].slab );
353: return;
354: }
355: if( (2*start+1) <= limit ) {
356: label = getlab();
357: hswelse( label );
358: } else
359: hswelse( heapsw[0].slab );
360: walkheap( 2*start, limit);
361: if( (2*start+1) <= limit ) {
362: deflab( label );
363: walkheap( 2*start+1, limit);
364: }
365: }
366:
367:
368: dswbegin( numb, first, range, labl, dlab )
369: CONSZ first, range;
370: int numb, labl, dlab;
371: {
372: printx(" casel r0,$%ld,$%ld\n", first, range );
373: printx("L%d:\n", labl );
374: tablelabel = labl;
375: }
376:
377: dswcase( l )
378: int l;
379: {
380: printx(" .word L%d-L%d\n", l, tablelabel );
381: }
382:
383: sswtest( val, lab )
384: CONSZ val;
385: int lab;
386: {
387: printx( " cmpl r0,$%ld\n jeql L%d\n", val, lab );
388: }
389:
390: hswelse( lab )
391: int lab;
392: {
393: printx(" jgtr L%d\n", lab );
394: }
395: #endif /* COMBINED */
396:
397: OFFSZ inoff; /* size of offset in structure */
398:
399: static inwd; /* current bit offset in word */
400: static long word; /* word being built from fields */
401:
402: zecode( n )
403: int n;
404: {
405: /* n integer words of zeros */
406: if (n <= 0) return;
407: printx( " .space %d\n", 4*n );
408: inoff += n*SZINT;
409: }
410:
411: vfdzero( n ){ /* define n bits of zeros in a vfd */
412:
413: /* this could be done more cleverly: the following is safe */
414:
415: sz_incode( (CONSZ)0, n );
416: }
417:
418: incode (p, sz)
419: NODE *p;
420: {
421: sz_incode(p->tn.lval, sz);
422: }
423:
424: sz_incode( val, sz )
425: CONSZ val;
426: {
427:
428: /* generate initialization code for assigning a constant c
429: to a field of width sz */
430: /* we assume that the proper alignment has been obtained */
431: /* inoff is updated to have the proper final value */
432:
433: if((sz+inwd) > SZLONG) cerror("incode: field > long");
434:
435: /* this code will have to be replaced if the size of a long on
436: /* the target machine differs from that on the host machine */
437:
438: # ifdef RTOLBYTES
439: word |= ((unsigned)(val<<(SZLONG-sz))) >> (SZLONG-sz-inwd);
440: # else
441: word |= ((unsigned)(val<<(SZLONG-sz))) >> inwd;
442: # endif
443: inwd += sz;
444: inoff += sz;
445:
446: /* if initialization can be carried out using shorts, do it */
447: # if (SZSHORT >= ALINIT)
448: if(inwd == SZSHORT )
449: {
450: # ifdef RTOLBYTES
451: genshort( (short) word );
452: # else
453: genshort( (short) (word>>(SZLONG-SZSHORT)) );
454: # endif
455: word = inwd = 0;
456: } else
457: # endif
458: if( inwd == SZLONG )
459: {
460: genlong( word );
461: word = inwd = 0;
462: }
463: }
464:
465: fincode( d, sz )
466: double d;
467: int sz;
468: {
469: /* output code to initialize space of size sz to the value d */
470: /* the proper alignment has been obtained */
471: /* on the target machine, write it out in hex! */
472:
473: #if defined(vax)
474: union { float f; double d; int i[2] } cheat;
475:
476: if (sz == SZDOUBLE)
477: {
478: cheat.d = d;
479: printx("\t.long\t0x%x,0x%x\t# %.20e\n", cheat.i[0], cheat.i[1],
480: cheat.d);
481: }
482: else
483: {
484: cheat.f = d;
485: printx("\t.long\t0x%x\t# %.20e\n", cheat.i[0], cheat.f);
486: }
487: #else
488: printx(" %s 0%c%.20e\n",
489: sz == SZDOUBLE ? ".double" : ".float",
490: sz == SZDOUBLE ? 'd' : 'f', d);
491: #endif
492: inoff += sz;
493:
494: }
495:
496: int ftlab1, ftlab2;
497: int proflag;
498:
499: int ent_mask[] = {
500: 0,0,0,0,0, 0xfc0, 0xf80, 0xf00, 0xe00, 0xc00, 0x800, 0};
501:
502: #if defined(COMBINED)
503: efcode(type)
504: int type;
505: #else
506: efcode()
507: #endif
508: {
509: /* code for the end of a function */
510: long spoff; /* offset from stack pointer */
511:
512: #if defined(COMBINED)
513: deflab(retlab);
514: repl_retval(type);
515: printx("\tret\n");
516: #else
517: genret( strftn, strftn, retlab );
518: #endif
519: printx( " .set L.R%d,0x%x\n", ftnno, ent_mask[minrvar] );
520:
521: #ifdef FORT
522: spoff = maxboff;
523: if( spoff >= BITOOR(AUTOINIT) ) spoff -= BITOOR(AUTOINIT);
524: spoff += maxtemp;
525: spoff /= SZCHAR;
526: printx( " .set L.F%d,%ld\n", ftnno, spoff / SZCHAR );
527: #else
528: spoff = maxboff;
529: if( spoff >= BITOOR(AUTOINIT) ) spoff -= BITOOR(AUTOINIT);
530: spoff += maxtemp;
531: spoff /= SZCHAR;
532: printx("\t.set\tL.SO%d,0x%x\n", ftnno, spoff);
533: #endif
534: regvar = minrvar = 11;
535: #ifdef GDEBUG
536: dbfunend(getlab());
537: #endif
538: }
539:
540: bfcode( a, n )
541: int a[], n;
542: {
543: /* code for the beginning of a function; a is an array of
544: indices in stab for the arguments; n is the number */
545: register i;
546:
547: /* routine prolog */
548:
549: printx( " .word L.R%d\n", ftnno);
550: printx("\tsubl2\t$L.SO%d,sp\n", ftnno);
551:
552: retlab = getlab();
553:
554: if( proflag )
555: { /* profile code */
556: i = getlab();
557: printx(" movab L%d,r0\n", i);
558: printx(" jsb mcount\n");
559: printx(" .data\n");
560: printx(" .align 2\n");
561: printx("L%d: .long 0\n", i);
562: printx(" .text\n");
563: }
564: if(Pflag) {
565: printx("\t.data\n\t.comm _proFptr,4\n\t.text\n");
566: printx("\ttstl locprof+4\n\tbneq L%da\n", ++bbcnt);
567: printx("\tmovl _proFptr,locprof+4\n\tmoval locprof,_proFptr\n");
568: printx("#entry %d\n", bbcnt);
569: printf("L%da:\tincl locprof+%d\n", bbcnt, 4*(bbcnt+3));
570: }
571: #ifdef GDEBUG
572: dbfunbeg(&stab[curftn]);
573: for (i = 0; i < n; ++i) {
574: extern TWORD argty[];
575: extern int argsoff[];
576: struct symtab q;
577: q = stab[a[i]];
578: q.sclass = PARAM;
579: q.stype = argty[i];
580: q.offset = argsoff[i];
581: dbfunarg(&q);
582: }
583: #endif
584: }
585:
586: defnam( psym )
587: register struct symtab *psym;
588: {
589: /* define the current location as the name psym->sname
590: * first give the debugging info for external definitions
591: */
592: /*if( psym->slevel == 0 ) /* make sure it's external */
593: /* ISFTN(psym->stype) ? prdef(psym,0) : prdef(psym,dsflag);
594: */
595:
596: if (psym->sclass == EXTDEF)
597: printx( " .globl %s\n", exname(psym->sname) );
598: printx("%s:\n", exname(psym->sname));
599: }
600:
601: commdec(id) /* generate a .comm from stab index id */
602: int id;
603: {
604: #if !defined(COMBINED)
605: register struct symtab *psym;
606: OFFSZ n;
607:
608: psym = &stab[id];
609: psym->sflags |= SBSS;
610: n = tsize(psym->stype, psym->dimoff, psym->sizoff) / SZCHAR;
611: if (psym->sclass == STATIC)
612: if (psym->slevel)
613: printx(" .lcomm L%d,%ld\n", psym->offset, n);
614: else
615: printx(" .lcomm %s,%ld\n", exname(psym->sname), n);
616: else if (psym->sclass == EXTERN)
617: printx(" .comm %s,%ld\n", exname(psym->sname), n);
618:
619: else
620: cerror("Non-static/external in common");
621: #endif
622: }
623:
624: myfcon(p)
625: NODE *p;
626: {
627: union { double d; int i[2]; } u;
628:
629: u.d = p->fpn.dval;
630: if (u.i[1] == 0) /* no significant lo bits, shorten */
631: {
632: p->fn.type = FLOAT;
633: p->fn.csiz = FLOAT;
634: }
635: }
636:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.