![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / ld|
Return to ld.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / ld |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)ld.c 1.1 86/02/03 SMI"; /* from UCB 4.9 83/07/01 */
3: #endif
4:
5: /*
6: * ld - string table version
7: */
8:
9: #include <sys/types.h>
10: #include <signal.h>
11: #include <stdio.h>
12: #include <ctype.h>
13: #include <ar.h>
14: #include <a.out.h>
15: #include <ranlib.h>
16: #include <sys/stat.h>
17: #include <stab.h>
18: #include <sys/dir.h>
19:
20: int nsymwrite;
21: char *rindex();
22:
23:
24: /*
25: * Basic strategy:
26: *
27: * The loader takes a number of files and libraries as arguments.
28: * A first pass examines each file in turn. Normal files are
29: * unconditionally loaded, and the (external) symbols they define and require
30: * are noted in the symbol table. Libraries are searched, and the
31: * library members which define needed symbols are remembered
32: * in a special data structure so they can be selected on the second
33: * pass. Symbols defined and required by library members are also
34: * recorded.
35: *
36: * After the first pass, the loader knows the size of the basic text
37: * data, and bss segments from the sum of the sizes of the modules which
38: * were required. It has computed, for each ``common'' symbol, the
39: * maximum size of any reference to it, and these symbols are then assigned
40: * storage locations after their sizes are appropriately rounded.
41: * The loader now knows all sizes for the eventual output file, and
42: * can determine the final locations of external symbols before it
43: * begins a second pass.
44: *
45: * On the second pass each normal file and required library member
46: * is processed again. The symbol table for each such file is
47: * reread and relevant parts of it are placed in the output. The offsets
48: * in the local symbol table for externally defined symbols are recorded
49: * since relocation information refers to symbols in this way.
50: * Armed with all necessary information, the text and data segments
51: * are relocated and the result is placed in the output file, which
52: * is pasted together, ``in place'', by writing to it in several
53: * different places concurrently.
54: */
55:
56: /*
57: * Internal data structures
58: *
59: * All internal data structures are segmented and dynamically extended.
60: * The basic structures hold 1103 (NSYM) symbols, ~~200 (NROUT)
61: * referenced library members, and 100 (NSYMPR) private (local) symbols
62: * per object module. For large programs and/or modules, these structures
63: * expand to be up to 40 (NSEG) times as large as this as necessary.
64: */
65: #define NSEG 40 /* Number of segments, each data structure */
66: #define NSYM 1103 /* Number of symbols per segment */
67: #define NROUT 250 /* Number of library references per segment */
68: #define NSYMPR 100 /* Number of private symbols per segment */
69:
70: /*
71: * Structure describing each symbol table segment.
72: * Each segment has its own hash table. We record the first
73: * address in and first address beyond both the symbol and hash
74: * tables, for use in the routine symx and the lookup routine respectively.
75: * The symfree routine also understands this structure well as it used
76: * to back out symbols from modules we decide that we don't need in pass 1.
77: *
78: * Csymseg points to the current symbol table segment;
79: * csymseg->sy_first[csymseg->sy_used] is the next symbol slot to be allocated,
80: * (unless csymseg->sy_used == NSYM in which case we will allocate another
81: * symbol table segment first.)
82: */
83: struct symseg {
84: struct nlist *sy_first; /* base of this alloc'ed segment */
85: struct nlist *sy_last; /* end of this segment, for n_strx */
86: int sy_used; /* symbols used in this seg */
87: struct nlist **sy_hfirst; /* base of hash table, this seg */
88: struct nlist **sy_hlast; /* end of hash table, this seg */
89: } symseg[NSEG], *csymseg;
90:
91: /*
92: * The lookup routine uses quadratic rehash. Since a quadratic rehash
93: * only probes 1/2 of the buckets in the table, and since the hash
94: * table is segmented the same way the symbol table is, we make the
95: * hash table have twice as many buckets as there are symbol table slots
96: * in the segment. This guarantees that the quadratic rehash will never
97: * fail to find an empty bucket if the segment is not full and the
98: * symbol is not there.
99: */
100: #define HSIZE (NSYM*2)
101:
102: #ifndef n_hash
103: #define n_hash n_desc
104: #endif n_hash
105:
106: /*
107: * Xsym converts symbol table indices (ala x) into symbol table pointers.
108: * Symx (harder, but never used in loops) inverts pointers into the symbol
109: * table into indices using the symseg[] structure.
110: */
111: #define xsym(x) (symseg[(x)/NSYM].sy_first+((x)%NSYM))
112: /* symx() is a function, defined below */
113:
114: struct nlist cursym; /* current symbol */
115: struct nlist *lastsym; /* last symbol entered */
116: struct nlist *nextsym; /* next available symbol table entry */
117: struct nlist *addsym; /* first sym defined during incr load */
118: int nsym; /* pass2: number of local symbols in a.out */
119: /* nsym + symx(nextsym) is the symbol table size during pass2 */
120:
121: struct nlist **lookup(), **slookup();
122: struct nlist *p_etext, *p_edata, *p_end, *entrypt;
123:
124: /*
125: * Definitions of segmentation for library member table.
126: * For each library we encounter on pass 1 we record pointers to all
127: * members which we will load on pass 2. These are recorded as offsets
128: * into the archive in the library member table. Libraries are
129: * separated in the table by the special offset value -1.
130: */
131: off_t li_init[NROUT];
132: struct libseg {
133: off_t *li_first;
134: int li_used;
135: int li_used2;
136: } libseg[NSEG] = {
137: li_init, 0, 0,
138: }, *clibseg = libseg;
139:
140: /*
141: * In processing each module on pass 2 we must relocate references
142: * relative to external symbols. These references are recorded
143: * in the relocation information as relative to local symbol numbers
144: * assigned to the external symbols when the module was created.
145: * Thus before relocating the module in pass 2 we create a table
146: * which maps these internal numbers to symbol table entries.
147: * A hash table is constructed, based on the local symbol table indices,
148: * for quick lookup of these symbols.
149: */
150: #define LHSIZ 31
151: struct local {
152: int l_index; /* index to symbol in file */
153: struct nlist *l_symbol; /* ptr to symbol table */
154: struct local *l_link; /* hash link */
155: } *lochash[LHSIZ], lhinit[NSYMPR];
156: struct locseg {
157: struct local *lo_first;
158: int lo_used;
159: } locseg[NSEG] = {
160: lhinit, 0
161: }, *clocseg;
162:
163: /*
164: * Libraries are typically built with a table of contents,
165: * which is the first member of a library with special file
166: * name __.SYMDEF and contains a list of symbol names
167: * and with each symbol the offset of the library member which defines
168: * it. The loader uses this table to quickly tell which library members
169: * are (potentially) useful. The alternative, examining the symbol
170: * table of each library member, is painfully slow for large archives.
171: *
172: * See <ranlib.h> for the definition of the ranlib structure and an
173: * explanation of the __.SYMDEF file format.
174: */
175: int tnum; /* number of symbols in table of contents */
176: int ssiz; /* size of string table for table of contents */
177: struct ranlib *tab; /* the table of contents (dynamically allocated) */
178: char *tabstr; /* string table for table of contents */
179:
180: /*
181: * We open each input file or library only once, but in pass2 we
182: * (historically) read from such a file at 2 different places at the
183: * same time. These structures are remnants from those days,
184: * and now serve only to catch ``Premature EOF''.
185: * In order to make I/O more efficient, we provide routines which
186: * work in hardware page sizes. The associated constants are defined
187: * as BLKSIZE, BLKSHIFT, and BLKMASK.
188: */
189: #define BLKSIZE 1024
190: #define BLKSHIFT 10
191: #define BLKMASK (BLKSIZE - 1)
192: typedef struct {
193: short *fakeptr;
194: int bno;
195: int nibuf;
196: int nuser;
197: char buff[BLKSIZE];
198: } PAGE;
199:
200: PAGE page[2];
201:
202: struct {
203: short *fakeptr;
204: int bno;
205: int nibuf;
206: int nuser;
207: } fpage;
208:
209: typedef struct {
210: char *ptr;
211: int bno;
212: int nibuf;
213: long size;
214: long pos;
215: PAGE *pno;
216: } STREAM;
217:
218: STREAM text;
219: STREAM reloc;
220:
221: /*
222: * Header from the a.out and the archive it is from (if any).
223: */
224: struct exec filhdr;
225: struct exec outfilhdr;
226: struct ar_hdr archdr;
227: #define OARMAG 0177545
228:
229: /*
230: * Options.
231: */
232: int trace;
233: int xflag; /* discard local symbols */
234: int Xflag; /* discard locals starting with 'L' */
235: int Sflag; /* discard all except locals and globals*/
236: int rflag; /* preserve relocation bits, don't define common */
237: int arflag; /* original copy of rflag */
238: int sflag; /* discard all symbols */
239: int Mflag; /* print rudimentary load map */
240: int nflag; /* pure procedure */
241: int dflag; /* define common even with rflag */
242: int zflag; /* demand paged */
243: long hsize; /* size of hole at beginning of data to be squashed */
244: int Aflag; /* doing incremental load */
245: int Tflag = 0;
246: int Nflag; /* want impure a.out */
247: int funding; /* reading fundamental file for incremental load */
248: int yflag; /* number of symbols to be traced */
249: char **ytab; /* the symbols */
250:
251: #ifdef sun3
252: int use68020; /* 68020-specific instructions used */
253: #endif sun3
254:
255: /*
256: * These are the cumulative sizes, set in pass 1, which
257: * appear in the a.out header when the loader is finished.
258: */
259: off_t tsize, dsize, bsize, trsize, drsize, ssize;
260:
261: /*
262: * Symbol relocation: c?rel is a scale factor which is
263: * added to an old relocation to convert it to new units;
264: * i.e. it is the difference between segment origins.
265: * (Thus if we are loading from a data segment which began at location
266: * 4 in a .o file into an a.out where it will be loaded starting at
267: * 1024, cdrel will be 1020.)
268: */
269: long ctrel, cdrel, cbrel;
270:
271: /*
272: * Textbase is the start address of all text, given by textreloc()
273: * unless specified by -T, or unless we are still relocating (-r), in
274: * which case it is 0. Database is the base of all data, computed
275: * before and used during pass2.
276: */
277: long textbase = -1, database = -1;
278:
279: #ifdef vax
280: #define textreloc() 0
281: #define pagesize() sys_pagesize
282: #define segsize() sys_pagesize
283: #endif vax
284:
285: #ifdef sun
286: # ifdef sun3
287: # define textreloc() (zflag ? PAGSIZ+sizeof(struct exec): PAGSIZ)
288: # define pagesize() PAGSIZ
289: # define segsize() SEGSIZ
290: # else !sun3
291: # define textreloc() OLD_SEGSIZ
292: # define pagesize() OLD_PAGSIZ
293: # define segsize() OLD_SEGSIZ
294: # endif !sun3
295: #endif sun
296:
297: /*
298: * Origins of the text and data segments can be regulated by command-
299: * line flags -Ttext & -Tdata (just -T will be interpreted as -Ttext).
300: */
301: struct origopts{
302: char *optname;
303: char *whatbase;
304: int *flagptr;
305: int *whatsize;
306: } origopts[] = {
307: "T", "text", &textbase, &tsize,
308: "Ttext", "text", &textbase, &tsize,
309: "Tdata", "data", &database, &dsize,
310: (char *)0 ,
311: };
312:
313: /*
314: * changes for Sun-3 and subsequent architectures:
315: *
316: * 1. (magic numbers) Magic numbers are 16 bits and are preceded by
317: * a 16-bit machine type field, which is 0 for Sun-2 and earlier
318: * architectures. Sun-3 has a machine type of 1.
319: *
320: * 2. (segment relocation bases) Changed from Sun-2:
321: *
322: * text(old): 0x8000
323: * text(new): 0x2000 + sizeof(struct exec)
324: * data(old): begins at a multiple of 0x8000
325: * data(new): begins at a multiple of 0x20000
326: *
327: * 3. (location of a.out header) In all Sun-3 object file formats,
328: * the exec structure is at the beginning of the text segment.
329: * In demand-paged (0413) files, this saves about a page of
330: * disk space.
331: */
332:
333: /*
334: * The base addresses for the loaded text, data and bss from the
335: * current module during pass2 are given by torigin, dorigin and borigin.
336: */
337: long torigin, dorigin, borigin;
338:
339: /*
340: * Errlev is nonzero when errors have occured.
341: * Delarg is an implicit argument to the routine delexit
342: * which is called on error. We do ``delarg = errlev'' before normal
343: * exits, and only if delarg is 0 (i.e. errlev was 0) do we make the
344: * result file executable.
345: */
346: int errlev;
347: int delarg = 4;
348:
349: /*
350: * The biobuf structure and associated routines are used to write
351: * into one file at several places concurrently. Calling bopen
352: * with a biobuf structure sets it up to write ``biofd'' starting
353: * at the specified offset. You can then use ``bwrite'' and/or ``bputc''
354: * to stuff characters in the stream, much like ``fwrite'' and ``fputc''.
355: * Calling bflush drains all the buffers and MUST be done before exit.
356: */
357: struct biobuf {
358: short b_nleft; /* Number free spaces left in b_buf */
359: /* Initialize to be less than BUFSIZ initially, to boundary align in file */
360: char *b_ptr; /* Next place to stuff characters */
361: char b_buf[BUFSIZ]; /* The buffer itself */
362: off_t b_off; /* Current file offset */
363: struct biobuf *b_link; /* Link in chain for bflush() */
364: } *biobufs;
365: #define bputc(c,b) ((b)->b_nleft ? (--(b)->b_nleft, *(b)->b_ptr++ = (c)) \
366: : bflushc(b, c))
367: int biofd;
368: off_t boffset;
369: struct biobuf *tout, *dout, *trout, *drout, *sout, *strout;
370:
371: /*
372: * Offset is the current offset in the string file.
373: * Its initial value reflects the fact that we will
374: * eventually stuff the size of the string table at the
375: * beginning of the string table (i.e. offset itself!).
376: */
377: off_t offset = sizeof (off_t);
378:
379: char *aoutname = "a.out"; /* name of resultant file: -o argument or a.out */
380: char ofilename[DIRSIZ+1];
381: int ofilemode; /* respect umask even for unsucessful ld's */
382: int infil; /* current input file descriptor */
383: char *filname; /* and its name */
384: int header_num; /* ordinal # of header file (for dbx) */
385:
386: /*
387: * Base of the string table of the current module (pass1 and pass2).
388: */
389: char *curstr;
390:
391: /*
392: * System software page size
393: */
394:
395: /* int sys_pagesize;*/
396:
397: char get();
398: int delexit();
399: char *savestr();
400:
401: main(argc, argv)
402: int argc;
403: char **argv;
404: {
405: register int c, i;
406: int num;
407: register char *ap, **p;
408: char save;
409:
410: if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
411: signal(SIGINT, delexit);
412: signal(SIGTERM, delexit);
413: }
414: if (argc == 1)
415: exit(4);
416: p = argv+1;
417: alloc_inclstack();
418: /* sys_pagesize = getpagesize(); */
419:
420: /*
421: * Scan arguments to determine the correct setting of
422: * zflag. The text relocation base depends on it, and
423: * cannot change after the first file is processed.
424: */
425: zflag = 1; /* default: on */
426: for (c=1; c<argc; c++) {
427: ap = argv[c];
428: if (ap[0] != '-') {
429: /* not an option string */
430: continue;
431: }
432: for (i=1; ap[i]; i++) {
433: switch (ap[i]) {
434: case 'o':
435: case 'u':
436: case 'e':
437: case 'H':
438: case 'D':
439: /*
440: * skip the next argument string --
441: * but look at the rest of the flags
442: * in the current one (bletch)
443: */
444: c++;
445: continue;
446: case 'A':
447: c++;
448: zflag = 0;
449: continue;
450: case 'T':
451: /*
452: * skip the next argument string,
453: * discard the rest of the current one,
454: * and cancel zflag
455: */
456: c++;
457: zflag = 0;
458: Tflag = 1;
459: goto nextarg;
460: case 'l':
461: case 'y':
462: /*
463: * discard the rest of the current argument
464: * string
465: */
466: goto nextarg;
467: case 'r':
468: case 'n':
469: case 'N':
470: /*
471: * the whole point of this silly loop:
472: * cancel zflag
473: */
474: zflag = 0;
475: continue;
476: default:
477: continue;
478: }
479: }
480: nextarg:
481: continue;
482: }
483:
484: /*
485: * Scan files once to find where symbols are defined.
486: */
487: for (c=1; c<argc; c++) {
488: if (trace)
489: printf("%s:\n", *p);
490: filname = 0;
491: ap = *p++;
492: if (*ap != '-') {
493: load1arg(ap);
494: continue;
495: }
496: for (i=1; ap[i]; i++) switch (ap[i]) {
497:
498: case 'o':
499: if (++c >= argc)
500: error(1, "-o where?");
501: aoutname = *p++;
502: continue;
503: case 'u':
504: case 'e':
505: if (++c >= argc)
506: error(1, "-u or -c: arg missing");
507: enter(slookup(*p++));
508: if (ap[i]=='e')
509: entrypt = lastsym;
510: continue;
511: case 'H':
512: if (++c >= argc)
513: error(1, "-H: arg missing");
514: if (tsize!=0)
515: error(1, "-H: too late, some text already loaded");
516: hsize = atoi(*p++);
517: continue;
518: case 'A':
519: if (++c >= argc)
520: error(1, "-A: arg missing");
521: if (Aflag)
522: error(1, "-A: only one base file allowed");
523: Aflag = 1;
524: nflag = 0;
525: funding = 1;
526: load1arg(*p++);
527: trsize = drsize = tsize = dsize = bsize = 0;
528: ctrel = cdrel = cbrel = 0;
529: funding = 0;
530: addsym = nextsym;
531: continue;
532: case 'D':
533: if (++c >= argc)
534: error(1, "-D: arg missing");
535: num = htoi(*p++);
536: if (dsize > num)
537: error(1, "-D: too small");
538: dsize = num;
539: continue;
540: case 'T':
541: {
542: struct origopts *t;
543: for (t = origopts; t->optname; t++){
544: if (!strcmp( &ap[i] ,t->optname))
545: break;
546: }
547: if (t->optname==NULL)
548: error(1, "-%s option unrecognized", &ap[i] );
549: if (++c >= argc)
550: error(1, "-%s: arg missing", t->optname);
551: if (*(t->whatsize)!=0)
552: error(1, "-%s: too late, some %s already loaded",
553: t->optname, t->whatbase);
554: if (*(t->flagptr)>=0 && !Aflag)
555: error(-1, "-%s: %s base already given: old value overridden",
556: t->optname, t->whatbase);
557: *(t->flagptr) = htoi(*p++);
558: }
559: goto next;
560: case 'l':
561: save = ap[--i];
562: ap[i]='-';
563: load1arg(&ap[i]);
564: ap[i]=save;
565: goto next;
566: case 'M':
567: Mflag++;
568: continue;
569: case 'x':
570: xflag++;
571: continue;
572: case 'X':
573: Xflag++;
574: continue;
575: case 'S':
576: Sflag++;
577: continue;
578: case 'r':
579: rflag++;
580: arflag++;
581: /* We don't want to relocate the text. */
582: if (textbase != 0 && textbase != -1){
583: if (tsize!=0)
584: error(1, "-r: too late, some text already loaded");
585: else
586: error(0, "-T & -r are mutually exclusive");
587: }
588: textbase = 0;
589: continue;
590: case 's':
591: sflag++;
592: xflag++;
593: continue;
594: case 'd':
595: dflag++;
596: continue;
597: case 'i':
598: printf("ld: -i ignored\n");
599: continue;
600: case 't':
601: trace++;
602: continue;
603: case 'y':
604: if (ap[i+1] == 0)
605: error(1, "-y: symbol name missing");
606: if (yflag == 0) {
607: ytab = (char **)calloc(argc, sizeof (char **));
608: if (ytab == 0)
609: error(1, "ran out of memory (-y)");
610: }
611: ytab[yflag++] = &ap[i+1];
612: goto next;
613: case 'N':
614: Nflag++;
615: nflag = zflag = 0;
616: continue;
617: case 'n':
618: nflag++;
619: Nflag = zflag = 0;
620: continue;
621: case 'z':
622: zflag++;
623: Nflag = nflag = 0;
624: continue;
625: default:
626: filname = savestr("-x"); /* kludge */
627: filname[1] = ap[i]; /* kludge */
628: archdr.ar_name[0] = 0; /* kludge */
629: error(1, "bad flag");
630: }
631: next:
632: ;
633: }
634: ap = rindex( aoutname, '/' );
635: if ( ap != 0 ){
636: strncpy( ofilename, aoutname, ap-aoutname+1 );
637: }
638: strcat( ofilename, "l.outXXXXXX");
639: mktemp( ofilename );
640:
641: header_num = 0;
642: merge_headers();
643: endload(argc, argv);
644: exit(0);
645: }
646:
647: /*
648: * Convert a ascii string which is a hex number.
649: * Used by -T and -D options.
650: */
651: htoi(p)
652: register char *p;
653: {
654: register int c, n;
655:
656: n = 0;
657: while (c = *p++) {
658: n <<= 4;
659: if (isdigit(c))
660: n += c - '0';
661: else if (c >= 'a' && c <= 'f')
662: n += 10 + (c - 'a');
663: else if (c >= 'A' && c <= 'F')
664: n += 10 + (c - 'A');
665: else
666: error(1, "badly formed hex number");
667: }
668: return (n);
669: }
670:
671: delexit()
672: {
673: struct stat stbuf;
674: long size;
675: char c = 0;
676:
677: bflush();
678: unlink(ofilename);
679: if (delarg==0 && Aflag==0)
680: chmod(aoutname, ofilemode);
681: /*
682: * We have to insure that the last block of the data segment
683: * is allocated a full size page. If the underlying
684: * file system allocates frags that are smaller than pagesize,
685: * a full zero filled block needs to be allocated so
686: * that when it is demand paged, the paged in block will be
687: * appropriately filled with zeros.
688: */
689: fstat(biofd, &stbuf);
690: size = round(stbuf.st_size, pagesize());
691: if (!rflag && zflag && size > stbuf.st_size) {
692: lseek(biofd, size - 1, 0);
693: write(biofd, &c, 1);
694: }
695: exit (delarg);
696: }
697:
698: endload(argc, argv)
699: int argc;
700: char **argv;
701: {
702: register int c, i;
703: long dnum;
704: register char *ap, **p;
705:
706: clibseg = libseg;
707: filname = 0;
708: middle();
709: setupout();
710: p = argv+1;
711: for (c=1; c<argc; c++) {
712: ap = *p++;
713: if (trace)
714: printf("%s:\n", ap);
715: if (*ap != '-') {
716: load2arg(ap);
717: continue;
718: }
719: for (i=1; ap[i]; i++) switch (ap[i]) {
720:
721: case 'D':
722: dnum = htoi(*p);
723: if (dorigin < dnum)
724: while (dorigin < dnum)
725: bputc(0, dout), dorigin++;
726: /* fall into ... */
727: case 'u':
728: case 'e':
729: case 'o':
730: case 'H':
731: ++c;
732: ++p;
733: /* fall into ... */
734: default:
735: continue;
736: case 'A':
737: funding = 1;
738: load2arg(*p++);
739: funding = 0;
740: c++;
741: continue;
742: case 'T':
743: ++c;
744: ++p;
745: /* fall into ... */
746: case 'y':
747: goto next;
748: case 'l':
749: ap[--i]='-';
750: load2arg(&ap[i]);
751: goto next;
752: }
753: next:
754: ;
755: }
756: finishout();
757: }
758:
759:
760: /*
761: * Scan file to find defined symbols.
762: */
763: load1arg(cp)
764: register char *cp;
765: {
766: register struct ranlib *tp;
767: off_t nloc;
768: int kind;
769:
770: /*
771: * If the user hasn't somehow specified a textbase (by -T or -r)
772: * take the default.
773: */
774: if (textbase == -1 && !Aflag)
775: textbase = textreloc();
776: kind = getfile(cp);
777: if (Mflag)
778: printf("%s\n", filname);
779: switch (kind) {
780:
781: /*
782: * Plain file.
783: */
784: case 0:
785: load1(0, 0L);
786: break;
787:
788: /*
789: * Archive without table of contents.
790: * (Slowly) process each member.
791: */
792: case 1:
793: error(-1,
794: "warning: archive has no table of contents; add one using ranlib(1)");
795: nloc = SARMAG;
796: while (step(nloc))
797: nloc += sizeof(archdr) +
798: round(atol(archdr.ar_size), sizeof (short));
799: break;
800:
801: /*
802: * Archive with table of contents.
803: * Read the table of contents and its associated string table.
804: * Pass through the library resolving symbols until nothing changes
805: * for an entire pass (i.e. you can get away with backward references
806: * when there is a table of contents!)
807: */
808: case 2:
809: nloc = SARMAG + sizeof (archdr);
810: dseek(&text, nloc, sizeof (tnum));
811: mget((char *)&tnum, sizeof (tnum), &text);
812: nloc += sizeof (tnum);
813: tab = (struct ranlib *)malloc(tnum);
814: if (tab == 0)
815: error(1, "ran out of memory (toc)");
816: dseek(&text, nloc, tnum);
817: mget((char *)tab, tnum, &text);
818: nloc += tnum;
819: tnum /= sizeof (struct ranlib);
820: dseek(&text, nloc, sizeof (ssiz));
821: mget((char *)&ssiz, sizeof (ssiz), &text);
822: nloc += sizeof (ssiz);
823: tabstr = (char *)malloc(ssiz);
824: if (tabstr == 0)
825: error(1, "ran out of memory (tocstr)");
826: dseek(&text, nloc, ssiz);
827: mget((char *)tabstr, ssiz, &text);
828: for (tp = &tab[tnum]; --tp >= tab;) {
829: if (tp->ran_un.ran_strx < 0 ||
830: tp->ran_un.ran_strx >= ssiz)
831: error(1, "mangled archive table of contents");
832: tp->ran_un.ran_name = tabstr + tp->ran_un.ran_strx;
833: }
834: while (ldrand())
835: continue;
836: cfree((char *)tab);
837: cfree(tabstr);
838: nextlibp(-1);
839: break;
840:
841: /*
842: * Table of contents is out of date, so search
843: * as a normal library (but skip the __.SYMDEF file).
844: */
845: case 3:
846: error(-1,
847: "warning: table of contents for archive is out of date; rerun ranlib(1)");
848: nloc = SARMAG;
849: do
850: nloc += sizeof(archdr) +
851: round(atol(archdr.ar_size), sizeof(short));
852: while (step(nloc));
853: break;
854: }
855: close(infil);
856: }
857:
858: /*
859: * Advance to the next archive member, which
860: * is at offset nloc in the archive. If the member
861: * is useful, record its location in the liblist structure
862: * for use in pass2. Mark the end of the archive in libilst with a -1.
863: */
864: step(nloc)
865: off_t nloc;
866: {
867:
868: dseek(&text, nloc, (long) sizeof archdr);
869: if (text.size <= 0) {
870: nextlibp(-1);
871: return (0);
872: }
873: getarhdr();
874: if (load1(1, nloc + (sizeof archdr)))
875: nextlibp(nloc);
876: return (1);
877: }
878:
879: /*
880: * Record the location of a useful archive member.
881: * Recording -1 marks the end of files from an archive.
882: * The liblist data structure is dynamically extended here.
883: */
884: nextlibp(val)
885: off_t val;
886: {
887:
888: if (clibseg->li_used == NROUT) {
889: if (++clibseg == &libseg[NSEG])
890: error(1, "too many files loaded from libraries");
891: clibseg->li_first = (off_t *)malloc(NROUT * sizeof (off_t));
892: if (clibseg->li_first == 0)
893: error(1, "ran out of memory (nextlibp)");
894: }
895: clibseg->li_first[clibseg->li_used++] = val;
896: if (val != -1 && Mflag)
897: printf("\t%s\n", archdr.ar_name);
898: }
899:
900: /*
901: * One pass over an archive with a table of contents.
902: * Remember the number of symbols currently defined,
903: * then call step on members which look promising (i.e.
904: * that define a symbol which is currently externally undefined).
905: * Indicate to our caller whether this process netted any more symbols.
906: */
907: ldrand()
908: {
909: register struct nlist *sp, **hp;
910: register struct ranlib *tp, *tplast;
911: off_t loc;
912: int nsymt = symx(nextsym);
913:
914: tplast = &tab[tnum-1];
915: for (tp = tab; tp <= tplast; tp++) {
916: if ((hp = slookup(tp->ran_un.ran_name)) == 0)
917: continue;
918: if ((sp = *hp) == NULL)
919: continue;
920: if (sp->n_type != N_EXT+N_UNDF)
921: continue;
922: step(tp->ran_off);
923: loc = tp->ran_off;
924: while (tp < tplast && (tp+1)->ran_off == loc)
925: tp++;
926: }
927: return (symx(nextsym) != nsymt);
928: }
929:
930: /*
931: * Examine a single file or archive member on pass 1.
932: */
933: load1(libflg, loc)
934: off_t loc;
935: {
936: register struct nlist *sp;
937: struct nlist *savnext;
938: int ndef, nlocal, type, size, nsymt;
939: register int i;
940: off_t maxoff;
941: struct stat stb;
942:
943: new_obj1();
944: readhdr(loc);
945: if (filhdr.a_syms == 0) {
946: if (filhdr.a_text+filhdr.a_data == 0) {
947: if (libflg == 0) {
948: ssize += sizeof(cursym);
949: }
950: return(0);
951: }
952: error(1, "no namelist");
953: }
954: if (libflg)
955: maxoff = atol(archdr.ar_size);
956: else {
957: fstat(infil, &stb);
958: maxoff = stb.st_size;
959: }
960: if (N_STROFF(filhdr) + sizeof (off_t) >= maxoff)
961: error(1, "too small (old format .o?)");
962: ctrel = tsize; cdrel += dsize; cbrel += bsize;
963: ndef = 0;
964: nlocal = sizeof(cursym);
965: savnext = nextsym;
966: loc += N_SYMOFF(filhdr);
967: dseek(&text, loc, filhdr.a_syms);
968: dseek(&reloc, loc + filhdr.a_syms, sizeof(off_t));
969: mget(&size, sizeof (size), &reloc);
970: dseek(&reloc, loc + filhdr.a_syms+sizeof (off_t), size-sizeof (off_t));
971: curstr = (char *)malloc(size);
972: if (curstr == NULL)
973: error(1, "no space for string table");
974: mget(curstr+sizeof(off_t), size-sizeof(off_t), &reloc);
975: while (text.size > 0) {
976: mget((char *)&cursym, sizeof(struct nlist), &text);
977: if (cursym.n_un.n_strx) {
978: if (cursym.n_un.n_strx<sizeof(size) ||
979: cursym.n_un.n_strx>=size)
980: error(1, "bad string table index (pass 1)");
981: cursym.n_un.n_name = curstr + cursym.n_un.n_strx;
982: }
983: type = cursym.n_type;
984: if (type & N_STAB) {
985: if (type == N_BINCL) {
986: start_incl1(&cursym, header_num);
987: header_num++;
988: } else if (type == N_EINCL) {
989: end_incl1();
990: } else {
991: stab1(&cursym);
992: }
993: }
994: if ((type&N_EXT)==0) {
995: if (Xflag==0 || type & N_STAB ||
996: cursym.n_un.n_name[0]!='L' )
997: nlocal += sizeof cursym;
998: continue;
999: }
1000: symreloc();
1001: if (enter(lookup()))
1002: continue;
1003: if ((sp = lastsym)->n_type != N_EXT+N_UNDF)
1004: continue;
1005: if (cursym.n_type == N_EXT+N_UNDF) {
1006: if (cursym.n_value > sp->n_value)
1007: sp->n_value = cursym.n_value;
1008: continue;
1009: }
1010: if (sp->n_value != 0 && cursym.n_type == N_EXT+N_TEXT)
1011: continue;
1012: ndef++;
1013: sp->n_type = cursym.n_type;
1014: sp->n_value = cursym.n_value;
1015: }
1016: if (libflg==0 || ndef) {
1017: tsize += filhdr.a_text;
1018: dsize += round(filhdr.a_data, sizeof (long));
1019: bsize += round(filhdr.a_bss, sizeof (long));
1020: ssize += nlocal;
1021: trsize += filhdr.a_trsize;
1022: drsize += filhdr.a_drsize;
1023: if (funding) {
1024: if (textbase == -1 && Tflag == 0) {
1025: if ((*slookup("_end")) == 0) {
1026: error(1, "base address is not provided, use option \"-T\" or link the fundamental file with option \"-u _end\"");
1027: }
1028: textbase = (*slookup("_end"))->n_value;
1029: }
1030: }
1031: nsymt = symx(nextsym);
1032: for (i = symx(savnext); i < nsymt; i++) {
1033: sp = xsym(i);
1034: if (sp->n_un.n_name)
1035: sp->n_un.n_name = savestr(sp->n_un.n_name);
1036: }
1037: free(curstr);
1038: return (1);
1039: }
1040: /*
1041: * No symbols defined by this library member.
1042: * Rip out the hash table entries and reset the symbol table.
1043: */
1044: incl_free();
1045: symfree(savnext);
1046: free(curstr);
1047: return(0);
1048: }
1049:
1050: middle()
1051: {
1052: register struct nlist *sp;
1053: long csize, t, corigin, ocsize;
1054: int nund, rnd;
1055: char s;
1056: register int i;
1057: int nsymt;
1058:
1059: torigin = 0;
1060: dorigin = 0;
1061: borigin = 0;
1062:
1063: p_etext = *slookup("_etext");
1064: p_edata = *slookup("_edata");
1065: p_end = *slookup("_end");
1066: /*
1067: * If there are any undefined symbols, save the relocation bits.
1068: */
1069: nsymt = symx(nextsym);
1070: if (rflag==0) {
1071: for (i = 0; i < nsymt; i++) {
1072: sp = xsym(i);
1073: if (sp->n_type==N_EXT+N_UNDF && sp->n_value==0 &&
1074: sp!=p_end && sp!=p_edata && sp!=p_etext) {
1075: rflag++;
1076: dflag = 0;
1077: break;
1078: }
1079: }
1080: }
1081: if (rflag)
1082: sflag = zflag = 0;
1083: /*
1084: * Assign common locations.
1085: */
1086: csize = 0;
1087: if (!Aflag)
1088: addsym = symseg[0].sy_first;
1089: #ifdef sun3
1090: if (zflag) {
1091: /*
1092: * in sun-3 demand-paged programs,
1093: * the exec structure is in text space
1094: */
1095: tsize += sizeof(struct exec);
1096: }
1097: #endif sun3
1098: #ifdef mc68000
1099: /*
1100: * prevent programs from ending exactly on a page boundary;
1101: * if they do, they will coredump as they prefetch the last
1102: * "unlk a6; rts" instruction sequence (bug in unlk instruction)
1103: */
1104: if (tsize > 0 && tsize % pagesize() == 0) {
1105: tsize += sizeof(long);
1106: }
1107: #endif mc68000
1108: if (database == -1 ){
1109: /* compute normal, default data base */
1110: database = round(tsize+textbase,
1111: (nflag||zflag ? segsize() : sizeof (long)));
1112: database += hsize;
1113: }
1114: if (dflag || rflag==0) {
1115: ldrsym(p_etext, tsize, N_EXT+N_TEXT);
1116: ldrsym(p_edata, dsize, N_EXT+N_DATA);
1117: ldrsym(p_end, bsize, N_EXT+N_BSS);
1118: for (i = symx(addsym); i < nsymt; i++) {
1119: sp = xsym(i);
1120: if ((s=sp->n_type)==N_EXT+N_UNDF &&
1121: (t = sp->n_value)!=0) {
1122: if (t >= sizeof (double))
1123: rnd = sizeof (double);
1124: else if (t >= sizeof (long))
1125: rnd = sizeof (long);
1126: else
1127: rnd = sizeof (short);
1128: csize = round(csize, rnd);
1129: sp->n_value = csize;
1130: sp->n_type = N_EXT+N_COMM;
1131: ocsize = csize;
1132: csize += t;
1133: }
1134: if (s&N_EXT && (s&N_TYPE)==N_UNDF && s&N_STAB) {
1135: sp->n_value = ocsize;
1136: sp->n_type = (s&N_STAB) | (N_EXT+N_COMM);
1137: }
1138: }
1139: }
1140: /*
1141: * Now set symbols to their final value
1142: */
1143: csize = round(csize, sizeof (long));
1144: torigin = textbase;
1145: dorigin = database;
1146: corigin = dorigin + dsize;
1147: borigin = corigin + csize;
1148: nund = 0;
1149: nsymt = symx(nextsym);
1150: for (i = symx(addsym); i<nsymt; i++) {
1151: sp = xsym(i);
1152: switch (sp->n_type & (N_TYPE+N_EXT)) {
1153:
1154: case N_EXT+N_UNDF:
1155: if (arflag == 0)
1156: errlev |= 01;
1157: if ((arflag==0 || dflag) && sp->n_value==0) {
1158: if (sp==p_end || sp==p_etext || sp==p_edata)
1159: continue;
1160: if (nund==0)
1161: printf("Undefined:\n");
1162: nund++;
1163: printf("%s\n", sp->n_un.n_name);
1164: }
1165: continue;
1166: case N_EXT+N_ABS:
1167: default:
1168: continue;
1169: case N_EXT+N_TEXT:
1170: sp->n_value += torigin;
1171: continue;
1172: case N_EXT+N_DATA:
1173: sp->n_value += dorigin;
1174: continue;
1175: case N_EXT+N_BSS:
1176: sp->n_value += borigin;
1177: continue;
1178: case N_EXT+N_COMM:
1179: sp->n_type = (sp->n_type & N_STAB) | (N_EXT+N_BSS);
1180: sp->n_value += corigin;
1181: continue;
1182: }
1183: }
1184: if (sflag || xflag)
1185: ssize = 0;
1186: bsize += csize;
1187: nsym = ssize / (sizeof cursym);
1188: if (Aflag) {
1189: fixspec(p_etext,torigin);
1190: fixspec(p_edata,dorigin);
1191: fixspec(p_end,borigin);
1192: }
1193: }
1194:
1195: fixspec(sym,offset)
1196: struct nlist *sym;
1197: long offset;
1198: {
1199:
1200: if (symx(sym) < symx(addsym) && sym!=0)
1201: sym->n_value += offset;
1202: }
1203:
1204: ldrsym(sp, val, type)
1205: register struct nlist *sp;
1206: long val;
1207: {
1208:
1209: if (sp == 0)
1210: return;
1211: if ((sp->n_type != N_EXT+N_UNDF || sp->n_value) && !Aflag) {
1212: printf("%s: ", sp->n_un.n_name);
1213: error(0, "user attempt to redfine loader-defined symbol");
1214: return;
1215: }
1216: sp->n_type = type;
1217: sp->n_value = val;
1218: }
1219:
1220: off_t wroff;
1221: struct biobuf toutb;
1222:
1223: setupout()
1224: {
1225: int bss;
1226: int newpage;
1227: extern char *sys_errlist[];
1228: extern int errno;
1229:
1230: ofilemode = 0777 & ~umask(0);
1231: biofd = creat(ofilename, 0666 & ofilemode);
1232: if (biofd < 0) {
1233: filname = ofilename; /* kludge */
1234: archdr.ar_name[0] = 0; /* kludge */
1235: error(1, sys_errlist[errno]); /* kludge */
1236: } else {
1237: struct stat mybuf; /* kls kludge */
1238: fstat(biofd, &mybuf); /* suppose file exists, wrong*/
1239: if (mybuf.st_mode & 0111) { /* mode, ld fails? */
1240: chmod(ofilename, mybuf.st_mode & 0666);
1241: ofilemode = mybuf.st_mode;
1242: }
1243: }
1244: tout = &toutb;
1245: bopen(tout, 0);
1246: #ifdef sun3
1247: outfilhdr.a_machtype = (use68020 ? M_68020 : M_68010);
1248: #endif !sun3
1249: outfilhdr.a_magic = nflag ? NMAGIC : (zflag ? ZMAGIC : OMAGIC);
1250: outfilhdr.a_text = round(tsize, zflag ? pagesize() : sizeof(long));
1251: outfilhdr.a_data = round(dsize, zflag ? pagesize() : sizeof(long));
1252: bss = bsize - (outfilhdr.a_data - dsize);
1253: if (bss < 0)
1254: bss = 0;
1255: outfilhdr.a_bss = bss;
1256: outfilhdr.a_trsize = trsize;
1257: outfilhdr.a_drsize = drsize;
1258: outfilhdr.a_syms = sflag? 0: (ssize + (sizeof cursym)*symx(nextsym));
1259: if (entrypt) {
1260: if (entrypt->n_type!=N_EXT+N_TEXT)
1261: error(0, "entry point not in text");
1262: else
1263: outfilhdr.a_entry = entrypt->n_value;
1264: } else
1265: outfilhdr.a_entry = textbase;
1266: outfilhdr.a_trsize = (rflag ? trsize:0);
1267: outfilhdr.a_drsize = (rflag ? drsize:0);
1268: bwrite((char *)&outfilhdr, sizeof (outfilhdr), tout);
1269: #ifndef sun3
1270: if (zflag) {
1271: /* start text on a new page */
1272: bflush1(tout);
1273: biobufs = 0;
1274: bopen(tout, pagesize());
1275: }
1276: #endif !sun3
1277: wroff = N_TXTOFF(outfilhdr) + outfilhdr.a_text;
1278: outb(&dout, outfilhdr.a_data);
1279: if (rflag) {
1280: outb(&trout, outfilhdr.a_trsize);
1281: outb(&drout, outfilhdr.a_drsize);
1282: }
1283: if (sflag==0 || xflag==0) {
1284: outb(&sout, outfilhdr.a_syms);
1285: wroff += sizeof (offset);
1286: outb(&strout, 0);
1287: }
1288: }
1289:
1290: outb(bp, inc)
1291: register struct biobuf **bp;
1292: {
1293:
1294: *bp = (struct biobuf *)malloc(sizeof (struct biobuf));
1295: if (*bp == 0)
1296: error(1, "ran out of memory (outb)");
1297: bopen(*bp, wroff);
1298: wroff += inc;
1299: }
1300:
1301: load2arg(acp)
1302: char *acp;
1303: {
1304: register char *cp;
1305: off_t loc;
1306:
1307: cp = acp;
1308: if (getfile(cp) == 0) {
1309: while (*cp)
1310: cp++;
1311: while (cp >= acp && *--cp != '/');
1312: mkfsym(++cp);
1313: load2(0L);
1314: } else { /* scan archive members referenced */
1315: for (;;) {
1316: if (clibseg->li_used2 == clibseg->li_used) {
1317: if (clibseg->li_used < NROUT)
1318: error(1, "libseg botch");
1319: clibseg++;
1320: }
1321: loc = clibseg->li_first[clibseg->li_used2++];
1322: if (loc == -1)
1323: break;
1324: dseek(&text, loc, (long)sizeof(archdr));
1325: getarhdr();
1326: mkfsym(archdr.ar_name);
1327: load2(loc + (long)sizeof(archdr));
1328: }
1329: }
1330: close(infil);
1331: }
1332:
1333: load2(loc)
1334: long loc;
1335: {
1336: int size;
1337: register struct nlist *sp;
1338: register struct local *lp;
1339: register int symno, i;
1340: int type;
1341: int exclude;
1342:
1343: exclude = 0;
1344: readhdr(loc);
1345: if (!funding) {
1346: ctrel = torigin;
1347: cdrel += dorigin;
1348: cbrel += borigin;
1349: }
1350: /*
1351: * Reread the symbol table, recording the numbering
1352: * of symbols for fixing external references.
1353: */
1354: for (i = 0; i < LHSIZ; i++)
1355: lochash[i] = 0;
1356: clocseg = locseg;
1357: clocseg->lo_used = 0;
1358: symno = -1;
1359: loc += N_TXTOFF(filhdr);
1360: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1361: filhdr.a_trsize+filhdr.a_drsize+filhdr.a_syms, sizeof(off_t));
1362: mget(&size, sizeof(size), &text);
1363: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1364: filhdr.a_trsize+filhdr.a_drsize+filhdr.a_syms+sizeof(off_t),
1365: size - sizeof(off_t));
1366: curstr = (char *)malloc(size);
1367: if (curstr == NULL)
1368: error(1, "out of space reading string table (pass 2)");
1369: mget(curstr+sizeof(off_t), size-sizeof(off_t), &text);
1370: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1371: filhdr.a_trsize+filhdr.a_drsize, filhdr.a_syms);
1372: while (text.size > 0) {
1373: symno++;
1374: mget((char *)&cursym, sizeof(struct nlist), &text);
1375: if (cursym.n_un.n_strx) {
1376: if (cursym.n_un.n_strx<sizeof(size) ||
1377: cursym.n_un.n_strx>=size)
1378: error(1, "bad string table index (pass 2)");
1379: cursym.n_un.n_name = curstr + cursym.n_un.n_strx;
1380: }
1381: if (cursym.n_type & N_STAB) {
1382: if (cursym.n_type == N_BINCL) {
1383: exclude = start_incl2(&cursym, header_num);
1384: header_num++;
1385: } else if (cursym.n_type == N_EINCL) {
1386: if (exclude) {
1387: exclude = end_incl2();
1388: continue;
1389: } else {
1390: exclude = end_incl2();
1391: }
1392: } else if (exclude) {
1393: continue;
1394: }
1395: }
1396: /* inline expansion of symreloc() */
1397: switch (cursym.n_type & 017) {
1398: case N_TEXT:
1399: case N_EXT+N_TEXT:
1400: cursym.n_value += ctrel;
1401: break;
1402: case N_DATA:
1403: case N_EXT+N_DATA:
1404: cursym.n_value += cdrel;
1405: break;
1406: case N_BSS:
1407: case N_EXT+N_BSS:
1408: cursym.n_value += cbrel;
1409: break;
1410: case N_EXT+N_UNDF:
1411: break;
1412: default:
1413: if (cursym.n_type&N_EXT)
1414: cursym.n_type = N_EXT+N_ABS;
1415: }
1416: /* end inline expansion of symreloc() */
1417: type = cursym.n_type;
1418: if (yflag && cursym.n_un.n_name)
1419: for (i = 0; i < yflag; i++)
1420: /* fast check for 2d character! */
1421: if (ytab[i][1] == cursym.n_un.n_name[1] &&
1422: !strcmp(ytab[i], cursym.n_un.n_name)) {
1423: tracesym();
1424: break;
1425: }
1426: if ((type&N_EXT) == 0) {
1427: if (!sflag&&!xflag&&
1428: (!Xflag||type&N_STAB||cursym.n_un.n_name[0]!='L'))
1429: symwrite(&cursym, sout);
1430: continue;
1431: }
1432: if (funding)
1433: continue;
1434: if ((sp = *lookup()) == 0)
1435: error(1, "internal error: symbol not found");
1436: if (cursym.n_type == N_EXT+N_UNDF) {
1437: if (clocseg->lo_used == NSYMPR) {
1438: if (++clocseg == &locseg[NSEG])
1439: error(1, "local symbol overflow");
1440: clocseg->lo_used = 0;
1441: }
1442: if (clocseg->lo_first == 0) {
1443: clocseg->lo_first = (struct local *)
1444: malloc(NSYMPR * sizeof (struct local));
1445: if (clocseg->lo_first == 0)
1446: error(1, "out of memory (clocseg)");
1447: }
1448: lp = &clocseg->lo_first[clocseg->lo_used++];
1449: lp->l_index = symno;
1450: lp->l_symbol = sp;
1451: lp->l_link = lochash[symno % LHSIZ];
1452: lochash[symno % LHSIZ] = lp;
1453: continue;
1454: }
1455: if (cursym.n_type & N_STAB)
1456: continue;
1457: if (cursym.n_type!=sp->n_type || cursym.n_value!=sp->n_value) {
1458: printf("%s: ", cursym.n_un.n_name);
1459: error(0, "multiply defined");
1460: }
1461: }
1462: if (funding)
1463: return;
1464: dseek(&text, loc, filhdr.a_text);
1465: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data, filhdr.a_trsize);
1466: load2td(ctrel, torigin - textbase, tout, trout);
1467: dseek(&text, loc+filhdr.a_text, filhdr.a_data);
1468: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data+filhdr.a_trsize,
1469: filhdr.a_drsize);
1470: load2td(cdrel, dorigin - database, dout, drout);
1471: while (filhdr.a_data & (sizeof(long)-1)) {
1472: bputc(0, dout);
1473: filhdr.a_data++;
1474: }
1475: torigin += filhdr.a_text;
1476: dorigin += round(filhdr.a_data, sizeof (long));
1477: borigin += round(filhdr.a_bss, sizeof (long));
1478: free(curstr);
1479: }
1480:
1481: struct tynames {
1482: int ty_value;
1483: char *ty_name;
1484: } tynames[] = {
1485: N_UNDF, "undefined",
1486: N_ABS, "absolute",
1487: N_TEXT, "text",
1488: N_DATA, "data",
1489: N_BSS, "bss",
1490: N_COMM, "common",
1491: 0, 0,
1492: };
1493:
1494: tracesym()
1495: {
1496: register struct tynames *tp;
1497:
1498: if (cursym.n_type & N_STAB)
1499: return;
1500: printf("%s", filname);
1501: if (archdr.ar_name[0])
1502: printf("(%s)", archdr.ar_name);
1503: printf(": ");
1504: if ((cursym.n_type&N_TYPE) == N_UNDF && cursym.n_value) {
1505: printf("definition of common %s size %d\n",
1506: cursym.n_un.n_name, cursym.n_value);
1507: return;
1508: }
1509: for (tp = tynames; tp->ty_name; tp++)
1510: if (tp->ty_value == (cursym.n_type&N_TYPE))
1511: break;
1512: printf((cursym.n_type&N_TYPE) ? "definition of" : "reference to");
1513: if (cursym.n_type&N_EXT)
1514: printf(" external");
1515: if (tp->ty_name)
1516: printf(" %s", tp->ty_name);
1517: printf(" %s\n", cursym.n_un.n_name);
1518: }
1519:
1520: /*
1521: * This routine relocates the single text or data segment argument.
1522: * Offsets from external symbols are resolved by adding the value
1523: * of the external symbols. Non-external reference are updated to account
1524: * for the relative motion of the segments (ctrel, cdrel, ...). If
1525: * a relocation was pc-relative, then we update it to reflect the
1526: * change in the positioning of the segments by adding the displacement
1527: * of the referenced segment and subtracting the displacement of the
1528: * current segment (creloc).
1529: *
1530: * If we are saving the relocation information, then we increase
1531: * each relocation datum address by our base position in the new segment.
1532: */
1533: load2td(creloc, position, b1, b2)
1534: long creloc, offset;
1535: struct biobuf *b1, *b2;
1536: {
1537: register struct nlist *sp;
1538: register struct local *lp;
1539: long tw;
1540: register struct relocation_info *rp, *rpend;
1541: struct relocation_info *relp;
1542: char *codep;
1543: register char *cp;
1544: int relsz, codesz;
1545:
1546: relsz = reloc.size;
1547: relp = (struct relocation_info *)malloc(relsz);
1548: codesz = text.size;
1549: codep = (char *)malloc(codesz);
1550: if (relp == 0 || codep == 0)
1551: error(1, "out of memory (load2td)");
1552: mget((char *)relp, relsz, &reloc);
1553: rpend = &relp[relsz / sizeof (struct relocation_info)];
1554: mget(codep, codesz, &text);
1555: for (rp = relp; rp < rpend; rp++) {
1556: cp = codep + rp->r_address;
1557: /*
1558: * Pick up previous value at location to be relocated.
1559: */
1560: switch (rp->r_length) {
1561:
1562: case 0: /* byte */
1563: tw = *cp;
1564: break;
1565:
1566: case 1: /* word */
1567: tw = *(short *)cp;
1568: break;
1569:
1570: case 2: /* long */
1571: tw = *(long *)cp;
1572: break;
1573:
1574: default:
1575: error(1, "load2td botch: bad length");
1576: }
1577: /*
1578: * If relative to an external which is defined,
1579: * resolve to a simpler kind of reference in the
1580: * result file. If the external is undefined, just
1581: * convert the symbol number to the number of the
1582: * symbol in the result file and leave it undefined.
1583: */
1584: if (rp->r_extern) {
1585: /*
1586: * Search the hash table which maps local
1587: * symbol numbers to symbol tables entries
1588: * in the new a.out file.
1589: */
1590: lp = lochash[rp->r_symbolnum % LHSIZ];
1591: while (lp->l_index != rp->r_symbolnum) {
1592: lp = lp->l_link;
1593: if (lp == 0)
1594: error(1, "local symbol botch");
1595: }
1596: sp = lp->l_symbol;
1597: if (sp->n_type == N_EXT+N_UNDF)
1598: rp->r_symbolnum = nsym+symx(sp);
1599: else {
1600: rp->r_symbolnum = sp->n_type & N_TYPE;
1601: tw += sp->n_value;
1602: rp->r_extern = 0;
1603: }
1604: } else switch (rp->r_symbolnum & N_TYPE) {
1605: /*
1606: * Relocation is relative to the loaded position
1607: * of another segment. Update by the change in position
1608: * of that segment.
1609: */
1610: case N_TEXT:
1611: tw += ctrel;
1612: break;
1613: case N_DATA:
1614: tw += cdrel;
1615: break;
1616: case N_BSS:
1617: tw += cbrel;
1618: break;
1619: case N_ABS:
1620: break;
1621: default:
1622: error(1, "relocation format botch (symbol type))");
1623: }
1624: /*
1625: * Relocation is pc relative, so decrease the relocation
1626: * by the amount the current segment is displaced.
1627: * (E.g if we are a relative reference to a text location
1628: * from data space, we added the increase in the text address
1629: * above, and subtract the increase in our (data) address
1630: * here, leaving the net change the relative change in the
1631: * positioning of our text and data segments.)
1632: */
1633: if (rp->r_pcrel)
1634: tw -= creloc;
1635: /*
1636: * Put the value back in the segment,
1637: * while checking for overflow.
1638: */
1639: switch (rp->r_length) {
1640:
1641: case 0: /* byte */
1642: if (tw < -128 || tw > 127)
1643: error(0, "byte displacement overflow at %s+%#x",
1644: b1==tout?"text":"data", rp->r_address);
1645: *cp = tw;
1646: break;
1647: case 1: /* word */
1648: if (tw < -32768 || tw > 32767)
1649: error(0, "word displacement overflow at %s+%#x",
1650: b1==tout?"text":"data", rp->r_address);
1651: *(short *)cp = tw;
1652: break;
1653: case 2: /* long */
1654: *(long *)cp = tw;
1655: break;
1656: }
1657: /*
1658: * If we are saving relocation information,
1659: * we must convert the address in the segment from
1660: * the old .o file into an address in the segment in
1661: * the new a.out, by adding the position of our
1662: * segment in the new larger segment.
1663: */
1664: if (rflag)
1665: rp->r_address += position;
1666: }
1667: bwrite(codep, codesz, b1);
1668: if (rflag)
1669: bwrite(relp, relsz, b2);
1670: cfree((char *)relp);
1671: cfree(codep);
1672: }
1673:
1674: finishout()
1675: {
1676: register int i;
1677: int nsymt;
1678: int symsize;
1679:
1680: if (sflag==0) {
1681: nsymt = symx(nextsym);
1682: for (i = 0; i < nsymt; i++)
1683: symwrite(xsym(i), sout);
1684: bwrite(&offset, sizeof offset, sout);
1685: }
1686: filname = aoutname;
1687: archdr.ar_name[0] = '\0';
1688: unlink(aoutname);
1689: if (link(ofilename, aoutname) < 0)
1690: error(1, "cannot move temp file %s to output", ofilename );
1691: delarg = errlev;
1692: delexit();
1693: }
1694:
1695: mkfsym(s)
1696: char *s;
1697: {
1698: static struct nlist fsym;
1699:
1700: if (sflag || xflag)
1701: return;
1702: fsym.n_un.n_name = s;
1703: fsym.n_type = N_TEXT;
1704: fsym.n_value = torigin;
1705: symwrite(&fsym, sout);
1706: }
1707:
1708: getarhdr()
1709: {
1710: register char *cp;
1711:
1712: mget((char *)&archdr, sizeof archdr, &text);
1713: for (cp=archdr.ar_name; cp<&archdr.ar_name[sizeof(archdr.ar_name)];)
1714: if (*cp++ == ' ') {
1715: cp[-1] = 0;
1716: return;
1717: }
1718: }
1719:
1720: mget(loc, n, sp)
1721: register STREAM *sp;
1722: register char *loc;
1723: {
1724: register char *p;
1725: register int take;
1726:
1727: top:
1728: if (n == 0)
1729: return;
1730: if (sp->size && sp->nibuf) {
1731: p = sp->ptr;
1732: take = sp->size;
1733: if (take > sp->nibuf)
1734: take = sp->nibuf;
1735: if (take > n)
1736: take = n;
1737: n -= take;
1738: sp->size -= take;
1739: sp->nibuf -= take;
1740: sp->pos += take;
1741: do
1742: *loc++ = *p++;
1743: while (--take > 0);
1744: sp->ptr = p;
1745: goto top;
1746: }
1747: if (n > BUFSIZ) {
1748: take = n - n % BLKSIZE;
1749: lseek(infil, (sp->bno+1)*BLKSIZE, 0);
1750: if (take > sp->size || read(infil, loc, take) != take)
1751: error(1, "premature EOF");
1752: loc += take;
1753: n -= take;
1754: sp->size -= take;
1755: sp->pos += take;
1756: dseek(sp, (sp->bno+1+take/BLKSIZE)*BLKSIZE, -1);
1757: goto top;
1758: }
1759: *loc++ = get(sp);
1760: --n;
1761: goto top;
1762: }
1763:
1764: symwrite(sp, bp)
1765: struct nlist *sp;
1766: struct biobuf *bp;
1767: {
1768: register int len;
1769: register char *str;
1770:
1771: str = sp->n_un.n_name;
1772: if (str) {
1773: sp->n_un.n_strx = offset;
1774: len = strlen(str) + 1;
1775: bwrite(str, len, strout);
1776: offset += len;
1777: }
1778: bwrite(sp, sizeof (*sp), bp);
1779: sp->n_un.n_name = str;
1780: nsymwrite++;
1781: }
1782:
1783: dseek(sp, loc, s)
1784: register STREAM *sp;
1785: long loc, s;
1786: {
1787: register PAGE *p;
1788: register b, o;
1789: int n;
1790:
1791: b = loc>>BLKSHIFT;
1792: o = loc&BLKMASK;
1793: if (o&01)
1794: error(1, "loader error; odd offset");
1795: --sp->pno->nuser;
1796: if ((p = &page[0])->bno!=b && (p = &page[1])->bno!=b)
1797: if (p->nuser==0 || (p = &page[0])->nuser==0) {
1798: if (page[0].nuser==0 && page[1].nuser==0)
1799: if (page[0].bno < page[1].bno)
1800: p = &page[0];
1801: p->bno = b;
1802: lseek(infil, loc & ~(long)BLKMASK, 0);
1803: if ((n = read(infil, p->buff, sizeof(p->buff))) < 0)
1804: n = 0;
1805: p->nibuf = n;
1806: } else
1807: error(1, "botch: no pages");
1808: ++p->nuser;
1809: sp->bno = b;
1810: sp->pno = p;
1811: if (s != -1) {sp->size = s; sp->pos = 0;}
1812: sp->ptr = (char *)(p->buff + o);
1813: if ((sp->nibuf = p->nibuf-o) <= 0)
1814: sp->size = 0;
1815: }
1816:
1817: char
1818: get(asp)
1819: STREAM *asp;
1820: {
1821: register STREAM *sp;
1822:
1823: sp = asp;
1824: if ((sp->nibuf -= sizeof(char)) < 0) {
1825: dseek(sp, ((long)(sp->bno+1)<<BLKSHIFT), (long)-1);
1826: sp->nibuf -= sizeof(char);
1827: }
1828: if ((sp->size -= sizeof(char)) <= 0) {
1829: if (sp->size < 0)
1830: error(1, "premature EOF");
1831: ++fpage.nuser;
1832: --sp->pno->nuser;
1833: sp->pno = (PAGE *) &fpage;
1834: }
1835: sp->pos += sizeof(char);
1836: return(*sp->ptr++);
1837: }
1838:
1839: getfile(acp)
1840: char *acp;
1841: {
1842: register char *cp;
1843: register int c;
1844: char arcmag[SARMAG+1];
1845: struct stat stb;
1846:
1847: cp = acp;
1848: infil = -1;
1849: archdr.ar_name[0] = '\0';
1850: filname = cp;
1851: if (cp[0]=='-' && cp[1]=='l') {
1852: char *locfilname = "/usr/local/lib/libxxxxxxxxxxxxxxx";
1853: if (cp[2] == '\0')
1854: cp = "-la";
1855: filname = "/usr/lib/libxxxxxxxxxxxxxxx";
1856: for(c=0; cp[c+2]; c++) {
1857: filname[c+12] = cp[c+2];
1858: locfilname[c+18] = cp[c+2];
1859: }
1860: filname[c+12] = locfilname[c+18] = '.';
1861: filname[c+13] = locfilname[c+19] = 'a';
1862: filname[c+14] = locfilname[c+20] = '\0';
1863: if ((infil = open(filname+4, 0)) >= 0) {
1864: filname += 4;
1865: } else if ((infil = open(filname, 0)) < 0) {
1866: filname = locfilname;
1867: }
1868: }
1869: if (infil == -1 && (infil = open(filname, 0)) < 0)
1870: error(1, "cannot open");
1871: page[0].bno = page[1].bno = -1;
1872: page[0].nuser = page[1].nuser = 0;
1873: text.pno = reloc.pno = (PAGE *) &fpage;
1874: fpage.nuser = 2;
1875: dseek(&text, 0L, SARMAG);
1876: if (text.size <= 0)
1877: error(1, "premature EOF");
1878: mget((char *)arcmag, SARMAG, &text);
1879: arcmag[SARMAG] = 0;
1880: if (strcmp(arcmag, ARMAG))
1881: return (0);
1882: dseek(&text, SARMAG, sizeof archdr);
1883: if (text.size <= 0)
1884: return (1);
1885: getarhdr();
1886: if (strncmp(archdr.ar_name, "__.SYMDEF", sizeof(archdr.ar_name)) != 0)
1887: return (1);
1888: fstat(infil, &stb);
1889: return (stb.st_mtime > atol(archdr.ar_date) ? 3 : 2);
1890: }
1891:
1892: struct nlist **
1893: lookup()
1894: {
1895: register int sh;
1896: register struct nlist **hp;
1897: register char *cp, *cp1;
1898: register struct symseg *gp;
1899: register int i;
1900:
1901: sh = 0;
1902: for (cp = cursym.n_un.n_name; *cp;)
1903: sh = (sh<<1) + *cp++;
1904: sh = (sh & 0x7fffffff) % HSIZE;
1905: for (gp = symseg; gp < &symseg[NSEG]; gp++) {
1906: if (gp->sy_first == 0) {
1907: gp->sy_first = (struct nlist *)
1908: calloc(NSYM, sizeof (struct nlist));
1909: gp->sy_hfirst = (struct nlist **)
1910: calloc(HSIZE, sizeof (struct nlist *));
1911: if (gp->sy_first == 0 || gp->sy_hfirst == 0)
1912: error(1, "ran out of space for symbol table");
1913: gp->sy_last = gp->sy_first + NSYM;
1914: gp->sy_hlast = gp->sy_hfirst + HSIZE;
1915: }
1916: if (gp > csymseg)
1917: csymseg = gp;
1918: hp = gp->sy_hfirst + sh;
1919: i = 1;
1920: do {
1921: if (*hp == 0) {
1922: if (gp->sy_used == NSYM)
1923: break;
1924: return (hp);
1925: }
1926: cp1 = (*hp)->n_un.n_name;
1927: for (cp = cursym.n_un.n_name; *cp == *cp1++;)
1928: if (*cp++ == 0)
1929: return (hp);
1930: hp += i;
1931: i += 2;
1932: if (hp >= gp->sy_hlast)
1933: hp -= HSIZE;
1934: } while (i < HSIZE);
1935: if (i > HSIZE)
1936: error(1, "hash table botch");
1937: }
1938: error(1, "symbol table overflow");
1939: /*NOTREACHED*/
1940: }
1941:
1942: symfree(saved)
1943: struct nlist *saved;
1944: {
1945: register struct symseg *gp;
1946: register struct nlist *sp;
1947:
1948: for (gp = csymseg; gp >= symseg; gp--, csymseg--) {
1949: sp = gp->sy_first + gp->sy_used;
1950: if (sp == saved) {
1951: nextsym = sp;
1952: return;
1953: }
1954: for (sp--; sp >= gp->sy_first; sp--) {
1955: gp->sy_hfirst[sp->n_hash] = 0;
1956: gp->sy_used--;
1957: if (sp == saved) {
1958: nextsym = sp;
1959: return;
1960: }
1961: }
1962: }
1963: if (saved == 0)
1964: return;
1965: error(1, "symfree botch");
1966: }
1967:
1968: struct nlist **
1969: slookup(s)
1970: char *s;
1971: {
1972:
1973: cursym.n_un.n_name = s;
1974: cursym.n_type = N_EXT+N_UNDF;
1975: cursym.n_value = 0;
1976: return (lookup());
1977: }
1978:
1979: enter(hp)
1980: register struct nlist **hp;
1981: {
1982: register struct nlist *sp;
1983:
1984: if (*hp==0) {
1985: if (hp < csymseg->sy_hfirst || hp >= csymseg->sy_hlast)
1986: error(1, "enter botch");
1987: *hp = lastsym = sp = csymseg->sy_first + csymseg->sy_used;
1988: csymseg->sy_used++;
1989: sp->n_un.n_name = cursym.n_un.n_name;
1990: sp->n_type = cursym.n_type;
1991: sp->n_hash = hp - csymseg->sy_hfirst;
1992: sp->n_value = cursym.n_value;
1993: nextsym = lastsym + 1;
1994: return(1);
1995: } else {
1996: lastsym = *hp;
1997: return(0);
1998: }
1999: }
2000:
2001: symx(sp)
2002: struct nlist *sp;
2003: {
2004: register struct symseg *gp;
2005:
2006: if (sp == 0)
2007: return (0);
2008: for (gp = csymseg; gp >= symseg; gp--)
2009: /* <= is sloppy so nextsym will always work */
2010: if (sp >= gp->sy_first && sp <= gp->sy_last)
2011: return ((gp - symseg) * NSYM + sp - gp->sy_first);
2012: error(1, "symx botch");
2013: /*NOTREACHED*/
2014: }
2015:
2016: symreloc()
2017: {
2018: if (funding)
2019: return;
2020: switch (cursym.n_type & 017) {
2021:
2022: case N_TEXT:
2023: case N_EXT+N_TEXT:
2024: cursym.n_value += ctrel;
2025: return;
2026:
2027: case N_DATA:
2028: case N_EXT+N_DATA:
2029: cursym.n_value += cdrel;
2030: return;
2031:
2032: case N_BSS:
2033: case N_EXT+N_BSS:
2034: cursym.n_value += cbrel;
2035: return;
2036:
2037: case N_EXT+N_UNDF:
2038: return;
2039:
2040: default:
2041: if (cursym.n_type&N_EXT)
2042: cursym.n_type = N_EXT+N_ABS;
2043: return;
2044: }
2045: }
2046:
2047: /*VARARGS 2*/
2048: error(n, s, w, x, y , z)
2049: char *s;
2050: {
2051:
2052: if (errlev==0)
2053: printf("ld:");
2054: if (filname) {
2055: printf("%s", filname);
2056: if (n != -1 && archdr.ar_name[0])
2057: printf("(%s)", archdr.ar_name);
2058: printf(": ");
2059: }
2060: printf( s, w, x, y, z);
2061: printf("\n");
2062: if (n == -1)
2063: return;
2064: if (n)
2065: delexit();
2066: errlev = 2;
2067: }
2068:
2069: readhdr(loc)
2070: off_t loc;
2071: {
2072:
2073: dseek(&text, loc, (long)sizeof(filhdr));
2074: mget((short *)&filhdr, sizeof(filhdr), &text);
2075: if (N_BADMAG(filhdr)) {
2076: if (filhdr.a_magic == OARMAG)
2077: error(1, "old archive");
2078: error(1, "bad magic number");
2079: }
2080: #ifdef sun3
2081: if (filhdr.a_machtype == M_68020) {
2082: use68020 = 1;
2083: }
2084: #endif sun3
2085: if (filhdr.a_text&01 || filhdr.a_data&01)
2086: error(1, "text/data size odd");
2087: if (filhdr.a_magic == NMAGIC || filhdr.a_magic == ZMAGIC) {
2088: cdrel = -round(filhdr.a_text, segsize());
2089: cbrel = cdrel - filhdr.a_data;
2090: } else if (filhdr.a_magic == OMAGIC) {
2091: cdrel = -filhdr.a_text;
2092: cbrel = cdrel - filhdr.a_data;
2093: } else
2094: error(1, "bad format");
2095: }
2096:
2097: round(v, r)
2098: int v;
2099: u_long r;
2100: {
2101:
2102: r--;
2103: v += r;
2104: v &= ~(long)r;
2105: return(v);
2106: }
2107:
2108: #define NSAVETAB 8192
2109: char *savetab;
2110: int saveleft;
2111:
2112: char *
2113: savestr(cp)
2114: register char *cp;
2115: {
2116: register int len;
2117:
2118: len = strlen(cp) + 1;
2119: if (len > saveleft) {
2120: saveleft = NSAVETAB;
2121: if (len > saveleft)
2122: saveleft = len;
2123: savetab = (char *)malloc(saveleft);
2124: if (savetab == 0)
2125: error(1, "ran out of memory (savestr)");
2126: }
2127: strncpy(savetab, cp, len);
2128: cp = savetab;
2129: savetab += len;
2130: saveleft -= len;
2131: return (cp);
2132: }
2133:
2134: bopen(bp, off)
2135: struct biobuf *bp;
2136: {
2137:
2138: bp->b_ptr = bp->b_buf;
2139: bp->b_nleft = BUFSIZ - off % BUFSIZ;
2140: bp->b_off = off;
2141: bp->b_link = biobufs;
2142: biobufs = bp;
2143: }
2144:
2145: int bwrerror;
2146:
2147: bwrite(p, cnt, bp)
2148: register char *p;
2149: register int cnt;
2150: register struct biobuf *bp;
2151: {
2152: register int put;
2153: register char *to;
2154:
2155: top:
2156: if (cnt == 0)
2157: return;
2158: if (bp->b_nleft) {
2159: put = bp->b_nleft;
2160: if (put > cnt)
2161: put = cnt;
2162: bp->b_nleft -= put;
2163: to = bp->b_ptr;
2164: memcpy(to, p, put);
2165: bp->b_ptr += put;
2166: p += put;
2167: cnt -= put;
2168: goto top;
2169: }
2170: if (cnt >= BUFSIZ) {
2171: if (bp->b_ptr != bp->b_buf)
2172: bflush1(bp);
2173: put = cnt - cnt % BUFSIZ;
2174: if (boffset != bp->b_off)
2175: lseek(biofd, bp->b_off, 0);
2176: if (write(biofd, p, put) != put) {
2177: bwrerror = 1;
2178: error(1, "output write error");
2179: }
2180: bp->b_off += put;
2181: boffset = bp->b_off;
2182: p += put;
2183: cnt -= put;
2184: goto top;
2185: }
2186: bflush1(bp);
2187: goto top;
2188: }
2189:
2190: bflush()
2191: {
2192: register struct biobuf *bp;
2193:
2194: if (bwrerror)
2195: return;
2196: for (bp = biobufs; bp; bp = bp->b_link)
2197: bflush1(bp);
2198: }
2199:
2200: bflush1(bp)
2201: register struct biobuf *bp;
2202: {
2203: register int cnt = bp->b_ptr - bp->b_buf;
2204:
2205: if (cnt == 0)
2206: return;
2207: if (boffset != bp->b_off)
2208: lseek(biofd, bp->b_off, 0);
2209: if (write(biofd, bp->b_buf, cnt) != cnt) {
2210: bwrerror = 1;
2211: error(1, "output write error");
2212: }
2213: bp->b_off += cnt;
2214: boffset = bp->b_off;
2215: bp->b_ptr = bp->b_buf;
2216: bp->b_nleft = BUFSIZ;
2217: }
2218:
2219: bflushc(bp, c)
2220: register struct biobuf *bp;
2221: {
2222:
2223: bflush1(bp);
2224: bputc(c, bp);
2225: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.