![[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] / researchv9 / jerq / sgs / comp|
Return to local.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 root 1: /* @(#) local.c: 1.7 3/19/84 */
2: /* local.c - machine dependent stuff for front end
3: *
4: * WE 32000
5: *
6: */
7:
8: #include <signal.h>
9: #include "mfile1.h"
10:
11: int dsflag = 0; /* symbol info initially enabled */
12: static int dlflag = 0; /* line number info initially enabled */
13:
14: /* location counters for PROG, DATA, ADATA, ISTRNG, STRNG */
15: char *locnames[] =
16: {
17: " .text\n",
18: " .data\n",
19: " .data\n",
20: " .data 1\n",
21: " .data 1\n",
22: };
23:
24: int minrvar = TOTREGS;
25:
26: static char *tmpfn;
27: static FILE *outfile = stdout;
28: static FILE *tmpfp;
29:
30: #ifdef M32B
31: int wloop_level = LL_BOT; /* place "while" test at loop end */
32: int floop_level = LL_BOT; /* place "for" test at loop end */
33: #else
34: int wloop_level = LL_BOT; /* place "while" test at loop end */
35: int floop_level = LL_BOT; /* place "for" test at top and bot */
36: #endif
37:
38:
39: myexit(n)
40: {
41: unlink(tmpfn);
42: if (n == 1)
43: n = 51;
44: exit(n);
45: }
46:
47: getout()
48: {
49: myexit(55);
50: }
51:
52: FILE *fopen();
53: static int proflag;
54:
55: main(argc, argv)
56: int argc;
57: char **argv;
58: {
59: int j, m, n;
60: char buf[BUFSIZ], *gotnm = NULL, *findnm;
61:
62: /* catch signals if they're not now being ignored */
63:
64: if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
65: signal(SIGHUP, getout);
66: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
67: signal(SIGINT, getout);
68: if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
69: signal(SIGQUIT, getout);
70: if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
71: signal(SIGTERM, getout);
72:
73: for (m = 1; m < argc && argv[m][0] == '-'; ++m)
74: {
75: switch( argv[m][1] )
76: {
77: case 'i': /* input file name */
78: if (!freopen(argv[m+1], "r", stdin))
79: {
80: fprintf(stderr, "Can't open %s\n", argv[m+1]);
81: myexit(2);
82: }
83: n = 2;
84: break;
85:
86: case 'o': /* output file name */
87: if (!freopen(argv[m+1], "w", stdout))
88: {
89: fprintf(stderr, "Can't open %s\n", argv[m+1]);
90: myexit(2);
91: }
92: n = 2;
93: break;
94:
95: case 'f': /* .c source file name */
96: for (gotnm = findnm = argv[m+1]; *findnm; ++findnm)
97: if (*findnm == '/')
98: gotnm = findnm + 1;
99: n = 2;
100: break;
101:
102: case 'd': /* prevent symbolic debug output */
103: if (argv[m][2] == 'l' || argv[m][3] == 'l')
104: dlflag = 1;
105: if (argv[m][2] == 's' || argv[m][3] == 's')
106: dsflag = 1;
107: n = 1;
108: break;
109:
110: case '1': /* debug flags to front */
111: argv[m][1] = 'X';
112: continue;
113:
114: case '2': /* debug flags to back */
115: argv[m]++;
116: argv[m][0] = '-';
117: continue;
118:
119: case 'V': /* print version info */
120: fputs("WE32000 pcc2 compiler: @(#)local.c SVR2\n",
121: stderr);
122: n = 1;
123: break;
124:
125: case 'p':
126: ++proflag;
127: n = 1;
128: break;
129:
130: default:
131: continue;
132:
133: }
134:
135: argc -= n;
136: for( j = m; j < argc; ++j )
137: argv[j] = argv[j+n];
138: m--;
139: }
140:
141: if (gotnm != NULL)
142: {
143: strcpy(ftitle, "\"");
144: strcat(ftitle, gotnm);
145: strcat(ftitle, "\"");
146: }
147: n = mainp1(argc, argv);
148: fclose(tmpfp);
149: if (!(tmpfp = fopen(tmpfn, "r")))
150: cerror("string file disappeared???");
151: while (m = fread(buf, 1, BUFSIZ, tmpfp))
152: fwrite(buf, 1, m, stdout);
153: myexit(n);
154: }
155:
156: beg_file()
157: {
158: /* called as the very first thing by the parser to do machine
159: * dependent stuff
160: */
161: register char *p, *s;
162: char *mktemp();
163:
164: /* note: double quotes already in ftitle... */
165: p = ftitle + strlen( ftitle ) - 2;
166: s = p - 14; /* max name length */
167: while ( p > s && *p != '"' && *p != '/' )
168: --p;
169: printf( "\t.file\t\"%.15s\n", p + 1 );
170: if(!(tmpfp= fopen(tmpfn = mktemp("pcc2SXXXXXX"), "w")))
171: cerror("can't create string file\n");
172: }
173:
174: locctr(l) /* output the location counter */
175: {
176: static int lastloc = PROG, lastpd = PROG;
177: int retval = lastloc; /* value to return at end */
178:
179: curloc = l;
180: switch (l)
181: {
182: case PROG:
183: if (lastloc == PROG)
184: break;
185: if (lastpd == DATA)
186: puts(" .text");
187: lastpd = PROG;
188: outfile = stdout;
189: break;
190:
191: case DATA:
192: case ADATA:
193: if (lastloc == DATA || lastloc == ADATA)
194: break;
195: if (lastpd == PROG)
196: puts(" .data");
197: lastpd = DATA;
198: outfile = stdout;
199: break;
200:
201: case STRNG:
202: case ISTRNG:
203: /* output string initializers to a temporary file for now
204: * don't update lastloc
205: */
206:
207: outfile = tmpfp;
208: break;
209:
210: default:
211: cerror( "illegal location counter" );
212: }
213:
214: lastloc = l;
215: return( retval ); /* declare previous loc. ctr. */
216: }
217:
218: NODE *
219: treecpy(p) /* first pass version of tcopy() */
220: register NODE *p;
221: {
222: /* make a fresh copy of p */
223: register NODE *q;
224:
225: q = talloc();
226: *q = *p;
227: switch (optype(q->in.op))
228: {
229: case BITYPE:
230: q->in.right = treecpy(p->in.right);
231: case UTYPE:
232: q->in.left = treecpy(p->in.left);
233: }
234: return (q);
235: }
236:
237:
238: NODE *
239: clocal(p) /* manipulate the parse tree for local xforms */
240: register NODE *p;
241: {
242: register NODE *l, *r;
243:
244: #if defined(M32B) && defined(IMPREGAL)
245: if ((p->in.op == VAUTO || p->in.op == VPARAM) && p->in.pad[0] == '@')
246: {
247: raname(p);
248: p->in.pad[0] = '~'; /*has been raname()'d*/
249: }
250: #endif
251: if (!asgbinop(p->in.op) && p->in.op != ASSIGN)
252: return (p);
253: r = p->in.right;
254: if (optype(r->in.op) == LTYPE)
255: return (p);
256: l = r->in.left;
257: if (r->in.op == QUEST ||
258: (r->in.op == CONV && l->in.op == QUEST) ||
259: (r->in.op == CONV && l->in.op == CONV &&
260: l->in.left->in.op == QUEST))
261: /* distribute assigns over colons */
262: {
263: register NODE *pwork;
264: NODE *pcpy = treecpy(p), *pnew;
265: #ifndef NODBG
266: extern int xdebug, eprint();
267:
268: if (xdebug)
269: {
270: puts("Entering [op]=?: distribution");
271: eprint(p);
272: }
273: #endif
274: pnew = pcpy->in.right;
275: while (pnew->in.op != QUEST)
276: pnew = pnew->in.left;
277: /*
278: * pnew is top of new tree
279: */
280: if ((pwork = p)->in.right->in.op == QUEST)
281: {
282: tfree(pwork->in.right);
283: pwork->in.right = pnew->in.right->in.left;
284: pnew->in.right->in.left = pwork;
285: /* at this point, 1/2 distributed. Tree looks like:
286: * ASSIGN|ASGOP
287: * LVAL QUEST
288: * EXPR1 COLON
289: * ASSIGN|ASGOP EXPR3
290: * LVAL EXPR2
291: * pnew "holds" new tree from QUEST node
292: */
293: }
294: else
295: {
296: NODE *pholdtop = pwork;
297:
298: pwork = pwork->in.right;
299: while (pwork->in.left->in.op != QUEST)
300: pwork = pwork->in.left;
301: tfree(pwork->in.left);
302: pwork->in.left = pnew->in.right->in.left;
303: pnew->in.right->in.left = pholdtop;
304: /* at this point, 1/2 distributed. Tree looks like:
305: * ASSIGN|ASGOP
306: * LVAL ANY # OF CONVs
307: * QUEST
308: * EXPR1 COLON
309: * ASSIGN|ASGOP EXPR3
310: * LVAL ANY # OF CONVs
311: * EXPR2
312: * pnew "holds" new tree from QUEST node
313: */
314: }
315: if ((pwork = pcpy)->in.right->in.op == QUEST)
316: {
317: pwork->in.right = pnew->in.right->in.right;
318: pnew->in.right->in.right = pwork;
319: /*
320: * done with the easy case
321: */
322: }
323: else
324: {
325: NODE *pholdtop = pwork;
326:
327: pwork = pwork->in.right;
328: while (pwork->in.left->in.op != QUEST)
329: pwork = pwork->in.left;
330: pwork->in.left = pnew->in.right->in.right;
331: pnew->in.right->in.right = pholdtop;
332: /*
333: * done with the CONVs case
334: */
335: }
336: p = pnew;
337: #ifndef NODBG
338: if (xdebug)
339: {
340: puts("Leaving [op]=?: distribution");
341: eprint(p);
342: }
343: #endif
344: }
345: return(p);
346: }
347:
348:
349: cisreg(t) /* can auto of type t go in reg */
350: TWORD t;
351: {
352: int nregs;
353:
354: /*
355: * Only allow register basic types or pointers.
356: * Someday, maybe allow register small-struct
357: */
358: switch (t)
359: {
360: case CHAR: case SHORT: case INT: case LONG:
361: case UCHAR: case USHORT: case UNSIGNED: case ULONG:
362: case FLOAT: case DOUBLE:
363: break;
364: default:
365: if (ISPTR(t))
366: break;
367: return (0);
368: }
369: nregs = (t == DOUBLE ? 2 : 1);
370: if (regvar + nregs <= TOTREGS-NRGS) /* check for too many */
371: {
372: regvar += nregs; /* number now in use */
373: if ((TOTREGS - regvar) < minrvar)
374: minrvar -= nregs;
375: nextrvar = TOTREGS - regvar;
376: return (1);
377: }
378: else
379: return (0);
380: }
381:
382: incode( p, sz )
383: register NODE *p;
384: {
385: /* generate initialization code for assigning a constant c
386: * to a field of width sz
387: * we assume that the proper alignment has been obtained and sz < SZINT
388: * inoff is updated to have the proper final value
389: */
390: if (inoff % SZINT == 0 )
391: printf(" .word %d:%d", sz, p->tn.lval);
392: else
393: printf(",%d:%d", sz, p->tn.lval);
394: inoff += sz;
395: if (inoff % SZINT == 0)
396: putchar('\n');
397: }
398:
399: vfdzero(n) /* define n bits of zeros in a vfd */
400: int n;
401: {
402: if( n <= 0 )
403: return;
404: if (inoff % SZINT == 0 )
405: printf(" .word %d:0", n);
406: else
407: printf(",%d:0", n);
408: inoff += n;
409: if (inoff % SZINT == 0)
410: putchar('\n');
411: }
412:
413: fincode(d, sz) /* floating initialization */
414: double d;
415: int sz;
416: {
417: #if defined(u3b) || defined(u3b5) || defined(u3b2)
418: union { double d; float f; int i[2] } cheat;
419:
420: if (sz == SZDOUBLE)
421: {
422: cheat.d = d;
423: printf(" .word 0x%x,0x%x\n", cheat.i[0], cheat.i[1]);
424: }
425: else
426: {
427: cheat.f = d;
428: printf(" .word 0x%x\n", cheat.i[0]);
429: }
430: #else
431: printf("\t.%s\t%.15e\n", sz == SZDOUBLE ? "double" : "float", d);
432: #endif
433: inoff += sz;
434: }
435:
436:
437: char *
438: exname(p) /* a name using external naming conventions */
439: char *p;
440: {
441: return( p );
442: }
443:
444:
445: commdec(id) /* generate a .comm from stab index id */
446: int id;
447: {
448: register struct symtab *psym;
449: OFFSZ n;
450:
451: psym = &stab[id];
452: n = tsize(psym->stype, psym->dimoff, psym->sizoff) / SZCHAR;
453: # ifndef NOSYMB
454: if ( psym->slevel == 0)
455: prdef(psym, dsflag); /* output debug info */
456: # endif
457: if (psym->sclass == STATIC)
458: printf(" .bss %s,%ld,%ld\n", exname(psym->sname),
459: n, nalign(psym->stype));
460: else if (psym->sclass == EXTERN)
461: printf(" .comm %s,%ld\n", exname(psym->sname), n);
462:
463:
464: else
465: cerror("Non-static/external in common");
466: }
467:
468:
469: static
470: nalign(t) /* figure alignment for type t */
471: TWORD t;
472: {
473: int aln;
474:
475: if (ISPTR(t))
476: aln = ALPOINT;
477: else switch (BTYPE(t))
478: {
479: case CHAR:
480: case UCHAR:
481: aln = ALCHAR;
482: break;
483: case SHORT:
484: case USHORT:
485: aln = ALSHORT;
486: break;
487: case INT:
488: case UNSIGNED:
489: case ENUMTY:
490: aln = ALINT;
491: break;
492: case LONG:
493: case ULONG:
494: aln = ALLONG;
495: break;
496: case FLOAT:
497: aln = ALFLOAT;
498: break;
499: case DOUBLE:
500: aln = ALDOUBLE;
501: break;
502: case STRTY:
503: case UNIONTY:
504: aln = ALSTRUCT;
505: break;
506: default:
507: cerror("Confused type in nalign");
508: /*NOTREACHED*/
509: }
510: return (aln / SZCHAR);
511: }
512:
513:
514: branch(n) /* branch to label n or return */
515: int n;
516: {
517: if (!reached) /* return <expr>; } comes here 2x */
518: return;
519: else
520: printf(" jmp .L%d\n", n);
521: }
522:
523:
524: defalign(n) /* align to multiple of n */
525: int n;
526: {
527: if ((n /= SZCHAR) > 1)
528: printf(" .align %d\n", n);
529: }
530:
531:
532: deflab(n) /* label n */
533: int n;
534: {
535: fprintf(outfile, ".L%d:\n", n);
536: }
537:
538:
539: efcode() /* wind up a function */
540: {
541: extern int maxboff, maxtemp, maxarg;
542: extern int strftn; /* non-zero if function is structure function,
543: ** contains label number of local static value
544: */
545: register int i, enterval;
546:
547: deflab(retlab);
548:
549: efdebug(); /* end of function debug info */
550:
551: if (strftn) /* return addr in 1st auto */
552: printf(" movw 0(%%fp),%%r0\n", ftnno);
553: printf("\t.set\t.F%d,%d\n\t.set\t.R%d,%d\n\tret\t&.R%d\n", ftnno,
554: (maxtemp + maxboff) / SZCHAR, ftnno, TOTREGS - minrvar, ftnno);
555: minrvar = TOTREGS;
556: }
557:
558:
559: bfcode(a, n) /* begin function code. a is array of n stab */
560: int a[], n; /* indices corresponding to incoming args */
561: {
562: int temp;
563:
564: #if defined(M32B) && defined(IMPREGAL)
565: rainit();
566: #endif
567: printf(" save &.R%d\n", ftnno);
568: if (proflag)
569: {
570: puts(" .data");
571: temp = getlab();
572: deflab(temp);
573: puts("\t.align\t4\n\t.word 0\n .text");
574: printf(" movw &.L%d,%%r0\n",temp);
575: puts(" jsb _mcount");
576: }
577: printf(" addw2 &.F%d,%%sp\n", ftnno);
578: retlab = getlab();
579: bfdebug( a, n, dsflag ); /* do debug info at fcn begin */
580: }
581:
582:
583: defnam(psym) /* current location is name from psym */
584: register struct symtab *psym;
585: {
586: /* define the current location as the name psym->sname
587: * first give the debugging info for external definitions
588: */
589: if( psym->slevel == 0 ) /* make sure it's external */
590: ISFTN(psym->stype) ? prdef(psym,0) : prdef(psym,dsflag);
591:
592: if (psym->sclass == EXTDEF)
593: printf(" .globl %s\n", exname(psym->sname));
594: printf("%s:\n", exname(psym->sname));
595: }
596:
597:
598: bycode(ch, loc) /* byte ch into string location loc */
599: int ch, loc;
600: {
601: if (ch < 0) /* eos */
602: {
603: if (loc)
604: putc('\n', outfile);
605: }
606: else
607: {
608: if ((loc % 10) == 0)
609: fputs("\n .byte ", outfile);
610: else
611: putc(',', outfile);
612: fprintf(outfile, "%d", ch);
613: }
614: }
615:
616: zecode(n) /* n words of 0 */
617: register int n;
618: {
619: if (n <= 0) /* this is possible, folks */
620: return;
621: printf(" .zero %d\n", (SZINT / SZCHAR) * n);
622: inoff += n * SZINT;
623: }
624:
625: struct sw heapsw[SWITSZ]; /* heap for switches */
626:
627: genswitch(p, n)
628: register struct sw *p;
629: int n;
630: {
631: /* p points to an array of structures, each consisting */
632: /* of a constant value and a label. */
633: /* The first is >=0 if there is a default label; its */
634: /* value is the label number. The entries p[1] to p[n] */
635: /* are the nontrivial cases */
636:
637: register int i;
638: register CONSZ j, range;
639: register int dlab, swlab;
640:
641: range = p[n].sval-p[1].sval;
642: if (range > 0 && range <= (3 * n) && n >= 4)
643: { /* implement a direct switch */
644: dlab = (p->slab >= 0) ? p->slab : getlab();
645: if (p[1].sval)
646: #if defined(M32B) && defined(IMPSWREG)
647: {
648: printf("\tsubw3\t&%ld,%%r%d,%%r0\n\tjneg\t.L%d\n",
649: p[1].sval, swregno, dlab);
650: swregno = 0;
651: }
652: #else
653: printf("\tsubw2\t&%ld,%%r0\n\tjneg\t.L%d\n",
654: p[1].sval, dlab);
655: #endif
656: swlab = getlab();
657: #if defined(M32B) && defined(IMPSWREG)
658: printf("\tcmpw\t%%r%d,&%d\n\tjg\t.L%d\n\tALSW3\t&2,%%r%d,%%r0\n"
659: , swregno, range, dlab, swregno);
660: printf("\tcmpw\t%%r%d,&0\n\tjneg\t.L%d\n",
661: swregno, dlab);
662: #else
663: printf("\tcmpw\t%%r0,&%d\n\tjg\t.L%d\n\tALSW3\t&2,%%r0,%%r0\n",
664: range, dlab);
665: printf("\tcmpw\t%%r0,&0 \n\tjneg\t.L%d\n", dlab);
666: #endif
667: printf("\tjmp\t*.L%d(%%r0)\n", swlab);
668: locctr(ADATA); /* output table */
669: defalign(ALPOINT);
670: puts("#SWBEG");
671: deflab(swlab);
672: for (i = 1, j = p[1].sval; i <= n; ++j)
673: printf(" .word .L%d\n",
674: (j == p[i].sval) ? p[i++].slab : dlab );
675: puts("#SWEND");
676: locctr(PROG);
677: if (p->slab < 0)
678: deflab(dlab);
679: }
680: else if ( n > 8 )
681: {
682: heapsw[0].slab = dlab = p->slab >= 0 ? p->slab : getlab();
683: makeheap( p, n, 1 ); /* build heap */
684: walkheap( 1, n ); /* produce code */
685: if( p->slab >= 0 )
686: branch( dlab );
687: else
688: deflab( dlab );
689: }
690: else /* simple switch code */
691: {
692: for (i = 1; i <= n; ++i)
693: #if defined(M32B) && defined(IMPSWREG)
694: printf("\tcmpw\t&%ld,%%r%d\n\tje\t.L%d\n",
695: p[i].sval, swregno, p[i].slab);
696: #else
697: printf("\tcmpw\t&%ld,%%r0\n\tje\t.L%d\n",
698: p[i].sval, p[i].slab);
699: #endif
700: if (p->slab >= 0)
701: branch(p->slab);
702: }
703: }
704:
705: makeheap( p, m, n )
706: register struct sw *p;
707: {
708: register int q;
709:
710: if( n >= SWITSZ )
711: cerror( "heap switch size exceeded" );
712: q = select( m );
713: heapsw[n] = p[q];
714: if( q > 1 )
715: makeheap( p, q-1, 2*n );
716: if( q < m )
717: makeheap( p+q, m-q, 2*n+1 );
718: }
719:
720: select( m )
721: {
722: register int l, i, k;
723:
724: for( i=1; ; i*=2 )
725: if( (i-1) > m ) break;
726: l = ((k = i/2 - 1) + 1)/2;
727: return( l + (m-k < l ? m-k : l) );
728: }
729:
730: walkheap( start, limit )
731: {
732: int label;
733:
734: if( start > limit )
735: return;
736: #if defined(M32B) && defined(IMPSWREG)
737: fprintf( outfile, "\tcmpw\t%%r%d,&%ld\n\tje\t.L%d\n",
738: swregno, heapsw[start].sval, heapsw[start].slab );
739: #else
740: fprintf( outfile, "\tcmpw\t%%r0,&%ld\n\tje\t.L%d\n",
741: heapsw[start].sval, heapsw[start].slab );
742: #endif
743: if( (2*start) > limit )
744: {
745: fprintf( outfile, " jmp .L%d\n", heapsw[0].slab );
746: return;
747: }
748: if( (2*start+1) <= limit )
749: {
750: label = getlab();
751: fprintf( outfile, " jg .L%d\n", label );
752: }
753: else
754: fprintf( outfile, " jg .L%d\n", heapsw[0].slab );
755: walkheap( 2*start, limit );
756: if( (2*start+1) <= limit )
757: {
758: fprintf( outfile, ".L%d:\n", label );
759: walkheap( 2*start+1, limit );
760: }
761: }
762:
763: #ifdef M32B
764: NODE *
765: setswreg( p )
766: NODE *p;
767: {
768: NODE *q;
769:
770: swregno = 0;
771: #ifdef IMPSWREG
772: if (p->in.op == ASSIGN && p->in.left->in.op == SNODE)
773: {
774: q = p->in.right;
775: if( q->in.op == REG )
776: {
777: swregno = q->tn.rval;
778: p->in.op = FREE;
779: p->in.left->in.op = FREE;
780: p = q;
781: }
782: }
783: #endif
784: return( p );
785: }
786:
787: NODE *
788: myand(p)
789: NODE *p;
790: {
791: #ifdef IMPREGAL
792: raua(p);
793: #endif
794: return(p);
795: }
796: #endif
797:
798:
799:
800: /* interface routines to debug output */
801:
802: fixdef(p)
803: struct symtab * p;
804: {
805: fix1def(p,dsflag); /* pass along flag */
806: return;
807: }
808:
809: strend(dimst)
810: int dimst;
811: {
812: str1end( dimst, dsflag ); /* pass along flag */
813: return;
814: }
815:
816: sdbline()
817: {
818: sdbln1( dlflag ); /* pass along flag */
819: return;
820: }
821:
822: aoend()
823: {
824: aoend1( dsflag ); /* pass along flag */
825: return;
826: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.