![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asmain.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe|
Return to asmain.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / as.tahoe |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)asmain.c 4.13 6/30/83";
6: #endif not lint
7:
8: #include <stdio.h>
9: #include <ctype.h>
10: #include <signal.h>
11:
12: #include "as.h"
13: #include "assyms.h"
14: #include "asscan.h"
15: #include "asexpr.h"
16: #include <paths.h>
17:
18: #define unix_lang_name "VAX/UNIX Assembler V6/30/83 4.13"
19: /*
20: * variables to manage reading the assembly source files
21: */
22: char *dotsname; /*the current file name; managed by the parser*/
23: int lineno; /*current line number; managed by the parser*/
24: char **innames; /*names of the files being assembled*/
25: int ninfiles; /*how many interesting files there are*/
26: FILE *source; /*current source file (for listing) */
27: char layout[400]; /*layout bytes */
28: char *layoutpos = layout; /*layout position in listfile */
29: int ind = 0; /*innames in-index: 0..minfiles */
30: int endofsource = 0;
31: long sourcepos;
32: /*
33: * Flags settable from the argv process argument list
34: */
35: int silent = 0; /*don't complain about any errors*/
36: int savelabels = 0; /*write the labels to the a.out file*/
37: int d124 = 4; /*default allocate 4 bytes for unknown pointers*/
38: int anyerrs = 0; /*no errors yet*/
39: int anywarnings=0; /*no warnings yet*/
40: int orgwarn = 0; /*Bad origins*/
41: int passno = 1; /* current pass*/
42: int jxxxJUMP = 0; /* in jxxxes that branch too far, use jmp instead of brw */
43: int readonlydata = 0; /* initialzed data -> text space */
44: int liston = 0; /* don't produce listing */
45:
46:
47: #ifdef DEBUG
48: int debug = 0;
49: int toktrace = 0;
50: #endif
51:
52: int useVM = 0;
53:
54: char *endcore; /*where to get more symbol space*/
55:
56: /*
57: * Managers of the a.out file.
58: */
59: struct exec hdr;
60: #define MAGIC 0407
61: u_long tsize; /* total text size */
62: u_long dsize; /* total data size */
63: u_long datbase; /* base of the data segment */
64: u_long trsize; /* total text relocation size */
65: u_long drsize; /* total data relocation size */
66:
67: /*
68: * Information about the current segment is accumulated in
69: * usedot; the most important information stored is the
70: * accumulated size of each of the text and data segments
71: *
72: * dotp points to the correct usedot expression for the current segment
73: */
74: struct exp usedot[NLOC+NLOC]; /* info about all segments */
75: struct exp *dotp; /* data/text location pointer */
76: /*
77: * The inter pass temporary token file is opened and closed by stdio, but
78: * is written to using direct read/write, as the temporary file
79: * is composed of buffers exactly BUFSIZ long.
80: */
81: FILE *tokfile; /* interpass communication file */
82: char tokfilename[TNAMESIZE];
83: /*
84: * The string file is the string table
85: * cat'ed to the end of the built up a.out file
86: */
87: FILE *strfile; /* interpass string file */
88: char strfilename[TNAMESIZE];
89: int strfilepos = 0; /* position within the string file */
90: /*
91: * a.out is created during the second pass.
92: * It is opened by stdio, but is filled with the parallel
93: * block I/O library
94: */
95: char *outfile = "a.out";
96: FILE *a_out_file;
97: off_t a_out_off; /* cumulative offsets for segments */
98: /*
99: * The logical files containing the assembled data for each of
100: * the text and data segments are
101: * managed by the parallel block I/O library.
102: * a.out is logically opened in many places at once to
103: * receive the assembled data from the various segments as
104: * it all trickles in, but is physically opened only once
105: * to minimize file overhead.
106: */
107: BFILE *usefile[NLOC+NLOC]; /* text/data files */
108: BFILE *txtfil; /* current text/data file */
109: /*
110: * Relocation information is accumulated seperately for each
111: * segment. This is required by the old loader (from BTL),
112: * but not by the new loader (Bill Joy).
113: *
114: * However, the size of the relocation information can not be computed
115: * during or after the 1st pass because the ''absoluteness' of values
116: * is unknown until all locally declared symbols have been seen.
117: * Thus, the size of the relocation information is only
118: * known after the second pass is finished.
119: * This obviates the use of the block I/O
120: * library, which requires knowing the exact offsets in a.out.
121: *
122: * So, we save the relocation information internally (we don't
123: * go to internal files to minimize overhead).
124: *
125: * Empirically, we studied 259 files composing the system,
126: * two compilers and a compiler generator: (all of which have
127: * fairly large source files)
128: *
129: * Number of files = 259
130: * Number of non zero text reloc files: 233
131: * Number of non zero data reloc files: 53
132: * Average text relocation = 889
133: * Average data relocation = 346
134: * Number of files > BUFSIZ text relocation = 71
135: * Number of files > BUFSIZ data relocation = 6
136: *
137: * For compiled C code, there is usually one text segment and two
138: * data segments; we see that allocating our own buffers and
139: * doing our internal handling of relocation information will,
140: * on the average, not use more memory than taken up by the buffers
141: * allocated for doing file I/O in parallel to a number of file.
142: *
143: * If we are assembling with the -V option, we
144: * use the left over token buffers from the 2nd pass,
145: * otherwise, we create our own.
146: *
147: * When the 2nd pass is complete, closeoutrel flushes the token
148: * buffers out to a BFILE.
149: *
150: * The internals to relbufdesc are known only in assyms.c
151: *
152: * outrel constructs the relocation information.
153: * closeoutrel flushes the relocation information to relfil.
154: */
155: struct relbufdesc *rusefile[NLOC+NLOC];
156: struct relbufdesc *relfil; /* un concatnated relocation info */
157: BFILE *relocfile; /* concatnated relocation info */
158: /*
159: * Once the relocation information has been written,
160: * we can write out the symbol table using the Block I/O
161: * mechanisms, as we once again know the offsets into
162: * the a.out file.
163: *
164: * We use relfil to output the symbol table information.
165: */
166: char *tmpdirprefix = _PATH_TMP;
167: int delexit();
168:
169: main(argc, argv)
170: int argc;
171: char **argv;
172: {
173: char *sbrk();
174:
175: tokfilename[0] = 0;
176: strfilename[0] = 0;
177: endcore = sbrk(0);
178:
179: argprocess(argc, argv); /* process argument lists */
180: if (anyerrs) exit(1);
181:
182: initialize();
183: zeroorigins(); /* set origins to zero */
184: zerolocals(); /* fix local label counters */
185:
186: i_pass1(); /* open temp files, etc */
187: pass1(); /* first pass through .s files */
188: testlocals(); /* check for undefined locals */
189: if (anyerrs) delexit();
190:
191: pass1_5(); /* resolve jxxx */
192: if (anyerrs) delexit();
193:
194: open_a_out(); /* open a.out */
195: roundsegments(); /* round segments to FW */
196: build_hdr(); /* build initial header, and output */
197:
198: i_pass2(); /* reopen temporary file, etc */
199: pass2(); /* second pass through the virtual .s */
200: if (anyerrs) delexit();
201:
202: fillsegments(); /* fill segments with 0 to FW */
203: reloc_syms(); /* dump relocation and symbol table */
204:
205: delete(); /* remove tmp file */
206: bflush(); /* close off block I/O view of a.out */
207: fix_a_out(); /* add in text and data reloc counts */
208:
209: if (anyerrs == 0 && orgwarn)
210: yyerror("Caution: absolute origins.\n");
211:
212: exit(anyerrs != 0);
213: }
214:
215: argprocess(argc, argv)
216: int argc;
217: char *argv[];
218: {
219: register char *cp;
220:
221: ninfiles = 0;
222: silent = 0;
223: #ifdef DEBUG
224: debug = 0;
225: #endif
226: innames = (char **)ClearCalloc(argc+1, sizeof (innames[0]));
227: dotsname = "<argv error>";
228: while (argc > 1) {
229: if (argv[1][0] != '-')
230: innames[ninfiles++] = argv[1];
231: else {
232: cp = argv[1] + 1;
233: /*
234: * We can throw away single minus signs, so
235: * that make scripts for the PDP 11 assembler work
236: * on this assembler too
237: */
238: while (*cp){
239: switch(*cp++){
240: default:
241: yyerror("Unknown flag: %c", *--cp);
242: cp++;
243: break;
244: case 'v':
245: selfwhat(stdout);
246: exit(1);
247: case 'd':
248: d124 = *cp++ - '0';
249: if ( (d124 != 1) && (d124 != 2) &&
250: (d124 != 4)){
251: yyerror("-d[124] only");
252: exit(1);
253: }
254: break;
255: case 'P':
256: liston = 1;
257: listfile = stdout;
258: break;
259: case 'o':
260: if (argc < 3){
261: yyerror("-o what???");
262: exit(1);
263: }
264: outfile = argv[2];
265: bumpone:
266: argc -= 2;
267: argv += 2;
268: goto nextarg;
269:
270: case 't':
271: if (argc < 3){
272: yyerror("-t what???");
273: exit(1);
274: }
275: tmpdirprefix = argv[2];
276: goto bumpone;
277:
278: case 'V':
279: useVM = 1;
280: break;
281: case 'W':
282: silent = 1;
283: break;
284: case 'L':
285: savelabels = 1;
286: break;
287: case 'J':
288: jxxxJUMP = 1;
289: break;
290: #ifdef DEBUG
291: case 'D':
292: debug = 1;
293: break;
294: case 'T':
295: toktrace = 1;
296: break;
297: #endif
298: case 'R':
299: readonlydata = 1;
300: break;
301: } /*end of the switch*/
302: } /*end of pulling out all arguments*/
303: } /*end of a flag argument*/
304: --argc; ++argv;
305: nextarg:;
306: }
307: /* innames[ninfiles] = 0; */
308: }
309: /*
310: * poke through the data space and find all sccs identifiers.
311: * We assume:
312: * a) that extern char **environ; is the first thing in the bss
313: * segment (true, if one is using the new version of cmgt.crt0.c)
314: * b) that the sccsid's have not been put into text space.
315: */
316: selfwhat(place)
317: FILE *place;
318: {
319: extern char **environ;
320: register char *ub;
321: register char *cp;
322: char *sbrk();
323:
324: for (cp = (char *)&environ, ub = sbrk(0); cp < ub; cp++){
325: if (cp[0] != '@') continue;
326: if (cp[1] != '(') continue;
327: if (cp[2] != '#') continue;
328: if (cp[3] != ')') continue;
329: fputc('\t', place);
330: for (cp += 4; cp < ub; cp++){
331: if (*cp == 0) break;
332: if (*cp == '>') break;
333: if (*cp == '\n') break;
334: fputc(*cp, place);
335: }
336: fputc('\n', place);
337: }
338: }
339:
340: initialize()
341: {
342: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
343: signal(SIGINT, delexit);
344: /*
345: * Install symbols in the table
346: */
347: symtabinit();
348: syminstall();
349: /*
350: * Build the expression parser accelerator token sets
351: */
352: buildtokensets();
353: }
354:
355: zeroorigins()
356: {
357: register int locindex;
358: /*
359: * Mark usedot: the first NLOC slots are for named text segments,
360: * the next for named data segments.
361: */
362: for (locindex = 0; locindex < NLOC; locindex++){
363: usedot[locindex].e_xtype = XTEXT;
364: usedot[NLOC + locindex].e_xtype = XDATA;
365: usedot[locindex].e_xvalue = 0;
366: usedot[NLOC + locindex].e_xvalue = 0;
367: }
368: }
369:
370: zerolocals()
371: {
372: register int i;
373:
374: for (i = 0; i <= 9; i++) {
375: lgensym[i] = 1;
376: genref[i] = 0;
377: }
378: }
379:
380: i_pass1()
381: {
382: FILE *tempopen();
383: if (useVM == 0)
384: tokfile = tempopen(tokfilename, "T");
385: strfile = tempopen(strfilename, "S");
386: /*
387: * write out the string length.
388: * This will be overwritten when the
389: * strings are tacked onto the growing a.out file
390: */
391: strfilepos = sizeof(int);
392: fwrite(&strfilepos, sizeof(int), 1, strfile);
393:
394: inittokfile();
395: initijxxx();
396: }
397:
398: FILE *tempopen(tname, part)
399: char *tname;
400: char *part;
401: {
402: FILE *file;
403: (void)sprintf(tname, "%s%sas%s%05d",
404: tmpdirprefix,
405: (tmpdirprefix[strlen(tmpdirprefix)-1] != '/') ? "/" : 0,
406: part,
407: getpid());
408: file = fopen(tname, "w");
409: if (file == NULL) {
410: yyerror("Bad pass 1 temporary file for writing %s", tname);
411: delexit();
412: }
413: return(file);
414: }
415:
416: pass1()
417: {
418: register int i;
419:
420: passno = 1;
421: dotp = &usedot[0];
422: txtfil = (BFILE *)0;
423: relfil = (struct relbufdesc *)0;
424:
425: if (ninfiles == 0){ /*take the input from stdin directly*/
426: lineno = 1;
427: dotsname = "<stdin>";
428:
429: yyparse();
430: } else { /*we have the names tanked*/
431: for (i = 0; i < ninfiles; i++){
432: new_dot_s(innames[i]);
433: if (freopen(innames[i], "r", stdin) == NULL) {
434: yyerror( "Can't open source file %s\n",
435: innames[i]);
436: exit(2);
437: }
438: /* stdio is NOT used to read the input characters */
439: /* we use read directly, into our own buffers */
440: yyparse();
441: }
442: }
443:
444: closetokfile(); /*kick out the last buffered intermediate text*/
445: }
446:
447: testlocals()
448: {
449: register int i;
450: for (i = 0; i <= 9; i++) {
451: if (genref[i])
452: yyerror("Reference to undefined local label %df", i);
453: lgensym[i] = 1;
454: genref[i] = 0;
455: }
456: }
457:
458: pass1_5()
459: {
460: sortsymtab();
461: #ifdef DEBUG
462: if (debug) dumpsymtab();
463: #endif
464: jxxxfix();
465: #ifdef DEBUG
466: if (debug) dumpsymtab();
467: #endif
468: }
469:
470: open_a_out()
471: {
472: /*
473: * Open up the a.out file now, and get set to build
474: * up offsets into it for all of the various text,data
475: * text relocation and data relocation segments.
476: */
477: a_out_file = fopen(outfile, "w");
478: if (a_out_file == NULL) {
479: yyerror("Cannot create %s", outfile);
480: delexit();
481: }
482: biofd = a_out_file->_file;
483: a_out_off = 0;
484: }
485:
486: roundsegments()
487: {
488: register int locindex;
489: register long v;
490: /*
491: * round and assign text segment origins
492: * the exec header always goes in usefile[0]
493: */
494: tsize = 0;
495: for (locindex=0; locindex<NLOC; locindex++) {
496: v = round(usedot[locindex].e_xvalue, FW);
497: usedot[locindex].e_xvalue = tsize;
498: if ((locindex == 0) || (v != 0) ){
499: usefile[locindex] = (BFILE *)Calloc(1, sizeof(BFILE));
500: bopen(usefile[locindex], a_out_off);
501: if (locindex == 0)
502: a_out_off = sizeof (struct exec);
503: } else {
504: usefile[locindex] = (BFILE *)-1;
505: }
506: tsize += v;
507: a_out_off += v;
508: }
509: /*
510: * Round and assign data segment origins.
511: */
512: datbase = round(tsize, FW);
513: for (locindex=0; locindex<NLOC; locindex++) {
514: v = round(usedot[NLOC+locindex].e_xvalue, FW);
515: usedot[NLOC+locindex].e_xvalue = datbase + dsize;
516: if (v != 0){
517: usefile[NLOC + locindex] = (BFILE *)Calloc(1,sizeof(BFILE));
518: bopen(usefile[NLOC + locindex], a_out_off);
519: } else {
520: usefile[NLOC + locindex] = (BFILE *)-1;
521: }
522: dsize += v;
523: a_out_off += v;
524: }
525: /*
526: * Assign final values to symbols
527: */
528: hdr.a_bss = dsize;
529: freezesymtab(); /* this touches hdr.a_bss */
530: stabfix();
531: /*
532: * Set up the relocation information "files" to
533: * be zero; outrel takes care of the rest
534: */
535: for (locindex = 0; locindex < NLOC + NLOC; locindex++){
536: rusefile[locindex] = (struct relbufdesc *)0;
537: }
538: }
539:
540: build_hdr()
541: {
542: /*
543: * Except for the text and data relocation sizes,
544: * calculate the final values for the header
545: *
546: * Write out the initial copy; we to come
547: * back later and patch up a_trsize and a_drsize,
548: * and overwrite this first version of the header.
549: */
550: hdr.a_magic = MAGIC;
551: hdr.a_text = tsize;
552: hdr.a_data = dsize;
553: hdr.a_bss -= dsize;
554: hdr.a_syms = sizesymtab(); /* Does not include string pool length */
555: hdr.a_entry = 0;
556: hdr.a_trsize = 0;
557: hdr.a_drsize = 0;
558:
559: bwrite((char *)&hdr, sizeof(hdr), usefile[0]);
560: }
561:
562: i_pass2()
563: {
564: if (useVM == 0) {
565: fclose(tokfile);
566: tokfile = fopen(tokfilename, "r");
567: if (tokfile==NULL) {
568: yyerror("Bad pass 2 temporary file for reading %s", tokfilename);
569: delexit();
570: }
571: }
572: fclose(strfile);
573: strfile = fopen(strfilename, "r");
574: }
575:
576: pass2()
577: {
578: #ifdef DEBUG
579: if (debug)
580: printf("\n\n\n\t\tPASS 2\n\n\n\n");
581: #endif DEBUG
582: passno = 2;
583: lineno = 1;
584: if (liston && ninfiles != 0)
585: {
586: char ch;
587: source = fopen (innames[ind++], "r");
588: (void)sprintf (layoutpos, "%4ld 00000000 ", lineno);
589: layoutpos += LHEAD;
590: ch = getc (source);
591: if (ch == EOF)
592: {
593: if (ind == ninfiles)
594: endofsource = 1;
595: else
596: source = fopen (innames[ind++], "r");
597: }
598: else
599: ungetc (ch, source);
600: }
601: else
602: endofsource = 1;
603: dotp = &usedot[0];
604: txtfil = usefile[0]; /* already opened (always!) */
605: relfil = 0; /* outrel takes care of the rest */
606: initoutrel();
607:
608: inittokfile();
609:
610: yyparse();
611:
612: closetokfile();
613: }
614:
615: fillsegments()
616: {
617: int locindex;
618: /*
619: * Round text and data segments to FW by appending zeros
620: */
621: for (locindex = 0; locindex < NLOC + NLOC; locindex++) {
622: if (usefile[locindex]) {
623: txtfil = usefile[locindex];
624: dotp = &usedot[locindex];
625: while (usedot[locindex].e_xvalue & FW)
626: outb(0);
627: }
628: }
629: }
630:
631: reloc_syms()
632: {
633: u_long closerelfil();
634: /*
635: * Move the relocation information to a.out
636: * a_out_off is the offset so far:
637: * exec + text segments + data segments
638: */
639: relocfile = (BFILE *)Calloc(1,sizeof(BFILE));
640: bopen(relocfile, a_out_off);
641: a_out_off += closeoutrel(relocfile);
642:
643: hdr.a_trsize = trsize;
644: hdr.a_drsize = drsize;
645: if (readonlydata) {
646: hdr.a_text += hdr.a_data;
647: hdr.a_data = 0;
648: hdr.a_trsize += hdr.a_drsize;
649: hdr.a_drsize = 0;
650: }
651: /*
652: * Output the symbol table and the string pool
653: *
654: * We must first rewind the string pool file to its beginning,
655: * in case it was seek'ed into for fetching ascii and asciz
656: * strings.
657: */
658: fseek(strfile, 0, 0);
659: symwrite(relocfile);
660: }
661:
662: fix_a_out()
663: {
664: if (lseek(a_out_file->_file, 0L, 0) < 0L)
665: yyerror("Reposition for header rewrite fails");
666: if (write(a_out_file->_file, (char *)&hdr, sizeof (struct exec)) < 0)
667: yyerror("Rewrite of header fails");
668: }
669:
670: delexit()
671: {
672: delete();
673: if (passno == 2){
674: unlink(outfile);
675: }
676: exit(1);
677: }
678:
679: delete()
680: {
681: if (useVM == 0 || tokfilename[0])
682: unlink(tokfilename);
683: if (strfilename[0])
684: unlink(strfilename);
685: }
686:
687: sawabort()
688: {
689: char *fillinbuffer();
690: while (fillinbuffer() != (char *)0)
691: continue;
692: delete();
693: exit(1); /*although the previous pass will also exit non zero*/
694: }
695:
696: panic(fmt, a1, a2, a3, a4)
697: char *fmt;
698: /*VARARGS 1*/
699: {
700: yyerror("Assembler panic: bad internal data structure.");
701: yyerror(fmt, a1, a2, a3, a4);
702: delete();
703: abort();
704: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.