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