![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2|
Return to cc2.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 |
1.1 root 1: /*
2: * This file contains the main
3: * driving routine for the code assembly
4: * phase of the C compiler.
5: * It reads the intermediate file and calls
6: * off to the appropriate routines to get things
7: * done.
8: */
9: #ifdef vax
10: #include "INC$LIB:cc2.h"
11: #else
12: #include "cc2.h"
13: #endif
14:
15: /* Verbosity. Parallel to ccscan.c. */
16: #ifdef COHERENT
17: #define ERRMSG "cc:"
18: #else
19: #if INTEL
20: #define ERRMSG "***"
21: #else
22: #if OMF286
23: #define ERRMSG "MWC286:"
24: #else
25: #define ERRMSG "MWC86:"
26: #endif
27: #endif
28: #endif
29:
30: #if !OVERLAID
31: FILE *ifp; /* Input file */
32: FILE *ofp; /* Output file */
33: char file[NFNAME]; /* File name */
34: char module[NMNAME]; /* Module name */
35: int line; /* Line number */
36: char id[NCSYMB]; /* Name buffer */
37: VARIANT variant; /* Variant template */
38: int dotseg; /* Current segment # */
39: #endif
40:
41: int changes; /* Change flag */
42: ADDRESS dot; /* Current location */
43: SYM *hash2[NSHASH]; /* Symbol table */
44: INS ins; /* Head of instruction list */
45: int nlabdel; /* # of labels deleted */
46: int ndead; /* # of dead instructions deleted */
47: int nbrbr; /* # of branches to branches */
48: int nexbr; /* # of extra branches */
49: int ncbrbr; /* # of conditional branches to branches */
50: int nbrnext; /* # of branches to next instruction */
51: int nxjump; /* # of cross jumps */
52: int ncomseq; /* # of common sequences */
53: int nsimplify; /* # of instructions simplified */
54: int nuseless; /* # of instructions deleted */
55:
56: #if !TINY
57: int vflag; /* Verbosity */
58: int xflag; /* More verbosity */
59: #endif
60:
61: /*
62: * Segment table.
63: */
64: SEG seg[NSEG];
65:
66: #if !OVERLAID
67: /*
68: * Mainline.
69: * Interpret options and
70: * open files.
71: */
72: main(argc, argv)
73: char *argv[];
74: {
75: #ifdef vax
76: int ofd;
77: #endif
78:
79: passname = "cc2";
80: if (argc < 4)
81: usage();
82: getvariant(argv[1]);
83: #if GEMDOS
84: {
85: extern long gemdos();
86: extern char *lmalloc();
87: free(lmalloc((gemdos(0x48,-1L)-4096) & ~1023L));
88: }
89: #endif
90: if ((ifp=fopen(argv[2], SRMODE)) == NULL) {
91: fprintf(stderr, "%s: cannot open.\n", argv[2]);
92: exit(BAD);
93: }
94: if (isvariant(VASM)) {
95: if ((ofp=fopen(argv[3], SWMODE)) == NULL)
96: nocreate(argv[3]);
97: } else {
98: if (argc < 5)
99: usage();
100: if ((ofp=fopen(argv[4], SWMODE)) == NULL)
101: nocreate(argv[4]);
102: }
103: #if !TINY
104: if (argc > 5)
105: vflag = atoi(argv[5]);
106: if (argc > 6)
107: xflag = atoi(argv[6]);
108: #endif
109: labgen = 20000;
110: dotseg = -1;
111: outinit();
112: work2();
113: outdone();
114: if (notvariant(VASM)) {
115: fclose(ifp);
116: fclose(ofp);
117: if ((ifp=fopen(argv[4], SRMODE)) == NULL)
118: cfatal("%s: cannot reopen", argv[4]);
119: #ifdef vax
120: #if VAXFMT
121: if ((ofd=creat(argv[3], 0666, "rfm=var")) < 0
122: || (ofp=fdopen(ofd, SWMODE)) == NULL)
123: #else
124: if ((ofp=fopen(argv[3], SWMODE)) == NULL)
125: #endif
126: #else
127: if ((ofp=fopen(argv[3], SWMODE)) == NULL)
128: #endif
129: nocreate(argv[3]);
130: copycode();
131: }
132: if (isvariant(VSTAT))
133: showstats();
134: if (nerr != 0)
135: exit(BAD);
136: exit(OK);
137: }
138:
139: /*
140: * Print usage message.
141: */
142: usage()
143: {
144: fprintf(stderr, "Usage: cc2 variant in out [temp]\n");
145: exit(BAD);
146: }
147:
148: /*
149: * Complain that a file cannot be
150: * created.
151: */
152: nocreate(fn)
153: char *fn;
154: {
155: fprintf(stderr, "%s: cannot create.\n", fn);
156: exit(BAD);
157: }
158: #else
159: /*
160: * Driving routine for the
161: * overlaid version of the optimizer and
162: * code assembly phase. The files have all been
163: * opened by the command line scanner in the
164: * root segment. Set up a fatal error context and
165: * do the work. Return exit status.
166: */
167: cc2a()
168: {
169: #if MONOLITHIC
170: register int i;
171: #endif
172: passname = "cc2a";
173: if (setjmp(death) != 0) {
174: freesym2();
175: return (ABORT);
176: }
177: labgen = 20000;
178: dotseg = -1;
179: #if MONOLITHIC
180: dot = 0;
181: nlabdel = 0;
182: ndead = 0;
183: nbrbr = 0;
184: nexbr = 0;
185: ncbrbr = 0;
186: nbrnext = 0;
187: nxjump = 0;
188: ncomseq = 0;
189: nsimplify = 0;
190: nuseless = 0;
191: for (i=0; i<NSEG; ++i)
192: seg[i].s_dot = 0;
193: #endif
194: outinit();
195: work2();
196: outdone();
197: if (isvariant(VSTAT))
198: showstats();
199: if (isvariant(VASM))
200: freesym2();
201: if (nerr != 0)
202: return (BAD);
203: return (OK);
204: }
205:
206: /*
207: * Second part. Copy the code back. This is
208: * only done if aflag==0. The root segment will have moved
209: * all of the files around. The same fatal error game is
210: * played.
211: */
212: cc2b()
213: {
214: passname = "cc2b";
215: if (setjmp(death) != 0) {
216: freesym2();
217: return (ABORT);
218: }
219: copycode();
220: freesym2();
221: if (nerr != 0)
222: return (BAD);
223: return (OK);
224: }
225: #endif
226:
227: /*
228: * Print statistics.
229: */
230: showstats()
231: {
232: printstat(nlabdel, "label# deleted");
233: printstat(ndead, "dead instruction# deleted");
234: printstat(nbrbr, "jump# to a jump");
235: printstat(ncbrbr, "conditional jump# over a jump");
236: printstat(nbrnext, "jump# to next instruction");
237: printstat(nexbr, "extra jump#");
238: printstat(nxjump, "cross jump#");
239: printstat(ncomseq, "common sequence#");
240: printstat(nsimplify, "instruction# simplified");
241: printstat(nuseless, "instruction# deleted");
242: }
243:
244: /*
245: * Print a statistic message.
246: */
247: printstat(n, s)
248: register int n;
249: register char *s;
250: {
251: register int c;
252:
253: if (n != 0) {
254: #if OVERLAID
255: printf ("%s ", ERRMSG);
256: #endif
257: printf("%d ", n);
258: while ((c = *s++) != 0) {
259: if (c == '#') {
260: if (n != 1)
261: putchar('s');
262: } else
263: putchar(c);
264: }
265: putchar('\n');
266: }
267: }
268:
269: /*
270: * Read through the temporary file,
271: * processing things until you run into a
272: * function prolog operation. Functions
273: * get read in, optimized and written back
274: * out.
275: */
276: work2()
277: {
278: register int op;
279: sizeof_t size;
280: register INS *ip;
281: register SYM *sp;
282:
283: for (;;) {
284: switch (op = bget()) {
285:
286: case LINE:
287: line = iget();
288: break;
289:
290: case DLABEL:
291: gendbgt(0);
292: break;
293:
294: case FNAME:
295: sget(file, NFNAME);
296: break;
297:
298: case MNAME:
299: sget(module, NMNAME);
300: if (isvariant(VASM)) {
301: bput(op);
302: sput(module);
303: }
304: break;
305:
306: case GLABEL:
307: case SLABEL:
308: sget(id, NCSYMB);
309: sp = glookup(id, 1);
310: sp->s_seg = dotseg;
311: sp->s_value = dot;
312: if (op == GLABEL) {
313: sp->s_flag |= S_GBL;
314: }
315: if (isvariant(VASM)) {
316: bput(op);
317: sput(id);
318: }
319: break;
320:
321: case COMM:
322: sget(id, NCSYMB);
323: size = zget();
324: sp = glookup(id, 0);
325: if ((sp->s_flag&S_DEF) == 0) {
326: sp->s_seg = SBSS;
327: sp->s_flag |= S_GBL;
328: if (size > sp->s_value)
329: sp->s_value = size;
330: }
331: if (isvariant(VASM)) {
332: bput(op);
333: sput(id);
334: zput(size);
335: }
336: break;
337:
338: #ifdef KLUDGE
339: case SGUESS:
340: {
341: int seg;
342: sget(id, NCSYMB);
343: seg = bget();
344: sp = glookup(id, 0);
345: if ((sp->s_flag&S_DEF) == 0)
346: sp->s_seg = seg;
347: break;
348: }
349:
350: #endif
351:
352: case LLABEL:
353: sp = llookup(iget(), 1);
354: sp->s_seg = dotseg;
355: sp->s_value = dot;
356: sp->s_flag |= S_NFL;
357: if (isvariant(VASM)) {
358: bput(op);
359: iput(sp->s_labno);
360: }
361: break;
362:
363: case BLOCK:
364: genblock(zget());
365: break;
366:
367: case ENTER:
368: genseg(bget());
369: break;
370:
371: case PROLOG:
372: #if !TINY
373: #define vcheck(v,s) if (vflag>v) check(s)
374: #else
375: #define vcheck(v,s) /* if (vflag>v) check(s) */
376: #endif
377: getfunc();
378: fixdbgt();
379: shuffle();
380: vcheck(0, "Befor optim");
381: do {
382: changes = 0;
383: labels();
384: vcheck(8, "After labels");
385: fixbr();
386: vcheck(8, "After fixbr()");
387: if (isvariant(VPEEP)) {
388: peephole();
389: vcheck(8, "After peephole");
390: }
391: if (notvariant(VNOOPT)) {
392: xjumps();
393: vcheck(8, "After xjumps");
394: comseq();
395: vcheck(8, "After comseq");
396: }
397: deadcode();
398: vcheck(2, "Before while (changes)");
399: } while (changes);
400: genprolog();
401: genfunc();
402: genepilog();
403: break;
404:
405: case ALIGN:
406: genalign(bget());
407: break;
408:
409: case CODE:
410: unbget(CODE);
411: ip = getins();
412: genins(ip);
413: free((char *) ip);
414: break;
415:
416: case FINISH:
417: genseg(-1);
418: if (isvariant(VASM))
419: bput(op);
420: return;
421:
422: case EOF:
423: cfatal("unexpected EOF");
424:
425: default:
426: cbotch("bad temporary file opcode %d", op);
427: }
428: }
429: }
430:
431: #if !TINY
432: /*
433: * Compiler debugging printout.
434: */
435: check(where)
436: char *where;
437: {
438: register INS *ip;
439:
440: printf("Check %s:\n", where);
441: for (ip = ins.i_fp; ip != &ins; ip = ip->i_fp) {
442: iprint(ip);
443: }
444: printf("\n");
445: }
446:
447: iprint(ip)
448: register INS *ip;
449: {
450: dprint(ip);
451: #if RUNNING_LARGE
452: printf("\t%08lx: %08lx %08lx: ", ip, ip->i_bp, ip->i_fp);
453: #else
454: printf("\t%04x: %04x %04x: ", ip, ip->i_bp, ip->i_fp);
455: #endif
456: switch (ip->i_type) {
457: case ENTER:
458: printf("enter %d", ip->i_seg);
459: break;
460: case EPILOG:
461: printf("epilog");
462: break;
463: case PROLOG:
464: printf("prolog");
465: break;
466: case BLOCK:
467: printf("block %ld", (long)ip->i_len);
468: break;
469: case ALIGN:
470: printf("align %d", ip->i_align);
471: break;
472: case LLABEL:
473: printf("label L%d", ip->i_labno);
474: break;
475: case JUMP:
476: printf("jump %d L%d", ip->i_rel, ip->i_labno);
477: break;
478: case LLLINK:
479: printf("llink L%d", ip->i_labno);
480: break;
481: case CODE:
482: printf("code %d(%d)", ip->i_op, ip->i_naddr);
483: break;
484: default:
485: printf("?? %d", ip->i_type);
486: break;
487: }
488: printf("\n");
489: }
490: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.