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