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