![[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 [CSRG BSD Unix] / 3BSD / cmd|
Return to ld.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd |
1.1 root 1: char LD[] = "@(#)ld.c 1.10 78/12/07 15:34:58"; /* sccs ident */
2: /*
3: * link editor for VAX
4: */
5:
6: /* layout of a.out file:
7: *
8: * header of 8 words magic number 0410:
9: data starts at 1st (PAGSIZ)
10: boundary above text
11: magic number 0407:
12: data starts immediately after
13: text
14: * text size )
15: * data size ) in bytes
16: * bss size )
17: * symbol table size
18: * entry point
19: * size of text relocation info
20: * size of data relocation info
21: *
22: * 'segment' origin comments
23: * header: 0
24: * text: 32 0 padded to multiple of 4 bytes
25: * data: 32+textsize 0 padded to multiple of 4 bytes
26: * text relocation: 32+textsize+datasize
27: * data relocation: 32+textsize+datasize+textrelocationsize
28: * symbol table: 32+textsize+datasize+textrelocationsize+datarelocationsize
29: *
30: */
31: #include <signal.h>
32: #include <stdio.h>
33: #include <ar.h>
34: #include <a.out.h>
35: #include <pagsiz.h>
36:
37: struct {short hiword; short loword;}; /* stupid fp-11 */
38: fixl(p) register long *p;{
39: register short t;
40: t=p->hiword; p->hiword=p->loword; p->loword=t;
41: }
42:
43: writel(p,n,f) long *p; FILE *f; {
44: #ifdef vax
45: fwrite(p,sizeof(*p),n,f);
46: #else
47: while (n--) {
48: fwrite(&(*p).loword,2,1,f);
49: fwrite(&(*p).hiword,2,1,f);
50: p++;
51: }
52: #endif
53: }
54:
55: long htoi(p) register char *p; {/* hex to integer conversion */
56: register long n = 0;
57: while (*p) {
58: n <<= 4;
59: if (*p<='9' && *p>='0') n += *p - '0';
60: else if (*p<='f' && *p>='a') n += *p -'a' +10;
61: else if (*p<='F' && *p>='A') n += *p -'A' +10;
62: p++;
63: }
64: return(n);
65: }
66:
67: typedef char *STRING;
68: typedef int BOOL;
69: #define TRUE 1
70: #define FALSE 0
71:
72: #define OMAGIC 0407
73: #define NMAGIC 0410
74:
75: /*
76: * Symbol types
77: */
78: #define UNDEF 0x0
79: #define ABS 0x2
80: #define TEXT 0x4
81: #define DATA 0x6
82: #define BSS 0x8
83: #define DATAO 0xA
84: #define BSSO 0xC
85: #define TEXTO 0xE
86: #define ABSO 0x10
87:
88: #define COMM 0x12 /* for internal use only */
89:
90: #define EXTERN 0x1
91: #define TYPE 0x1E
92: #define STABTYPS 0xE0
93: /*
94: * address reference types
95: */
96: #define PCREL 1
97: #define LEN1 0
98: #define LEN2 2
99: #define LEN4 4
100:
101: #define HW 01
102: #define FW 03
103: #define DW 07
104:
105:
106: #define TYPMASK 0x1E
107: #define TYMASK (0x1E)
108: #define TMASK 0x1F
109:
110: #define RABS (ABS)
111: #define RTEXT TEXT
112: #define RDATA DATA
113: #define RBSS BSS
114: #define RDATAO DATAO
115: #define RBSSO BSSO
116: #define RTEXTO TEXTO
117: #define RABSO ABSO
118: #define REXT (01<<3)
119: #define ROFF (02<<3)
120: #define REFMASK 0x7
121:
122: #define NOVLY 1
123: #define RELFLG 01
124: #define NROUT 256
125: #define NSYM 1103
126: #define NSYMPR 500
127:
128: char premeof[] = "Premature EOF";
129:
130: typedef struct {
131: long loc;
132: } LIBLIST;
133:
134: /* overlay management */
135: int vindex;
136: typedef struct {
137: int argsav;
138: int symsav;
139: LIBLIST *libsav;
140: STRING vname;
141: long ctsav, cdsav, cbsav;
142: long offt, offd, offb, offtr, offdr, offs;
143: } OVERLAY;
144: OVERLAY vnodes[NOVLY];
145:
146: /* input management */
147: typedef struct {
148: short *fakeptr;
149: int bno;
150: int nibuf;
151: int nuser;
152: char buff[BSIZE];
153: } PAGE;
154:
155: PAGE page[2];
156:
157: struct {
158: short *fakeptr;
159: int bno;
160: int nibuf;
161: int nuser;
162: } fpage;
163:
164: typedef struct {
165: char *ptr;
166: int bno;
167: int nibuf;
168: long size;
169: long pos;
170: PAGE *pno;
171: } STREAM;
172:
173: STREAM text;
174: STREAM reloc;
175:
176: struct ar_hdr archdr;
177:
178: struct exec filhdr;
179:
180: /* one entry for each archive member referenced;
181: * set in first pass; needs restoring for overlays
182: */
183:
184: LIBLIST liblist[NROUT];
185: LIBLIST *libp = liblist;
186:
187:
188: /* symbol management */
189: typedef struct {
190: char sname[8];
191: char stype;
192: char spare;
193: short symhash; /* index of hash table entry pointing to this symbol */
194: long svalue;
195: } SYMBOL;
196:
197: typedef struct {
198: int locindex; /* index to symbol in file */
199: SYMBOL *locsymbol; /* ptr to symbol table */
200: } LOCAL;
201:
202: SYMBOL cursym; /* current symbol */
203: SYMBOL *symtab; /* actual symbols */
204: SYMBOL *lastsym; /* last symbol entered */
205: SYMBOL *nextsym; /* next available symbol table entry */
206: int nsym; /* number of symbols allocated in symtab */
207: SYMBOL *hshtab[NSYM+2]; /* hash table for symbols */
208: LOCAL *local;
209:
210: /* internal symbols */
211: SYMBOL *p_data;
212: SYMBOL *p_etext;
213: SYMBOL *p_edata;
214: SYMBOL *p_end;
215: SYMBOL *entrypt;
216:
217: int trace;
218: /* flags */
219: int xflag; /* discard local symbols */
220: int Xflag; /* discard locals starting with 'L' */
221: int Sflag; /* discard all except locals and globals*/
222: int rflag; /* preserve relocation bits, don't define common */
223: int arflag; /* original copy of rflag */
224: int sflag; /* discard all symbols */
225: int nflag = 1; /* pure procedure */
226: int dflag; /* define common even with rflag */
227: int iflag; /* I/D space separated */
228: BOOL vflag; /* overlays used */
229: int zflag;
230:
231: int ofilfnd;
232: char *ofilename = "l.out";
233: int infil;
234: char *filname;
235:
236: long textbase;
237: /* cumulative sizes set in pass 1 */
238: long tsize;
239: long dsize;
240: long bsize;
241: long trsize;
242: long drsize;
243: long ssize;
244:
245: /* symbol relocation; both passes */
246: long ctrel;
247: long cdrel;
248: long cbrel;
249: long ctorel;
250: long cdorel;
251: long cborel;
252:
253: int errlev;
254: int delarg = 4;
255:
256:
257: FILE *tout;
258: FILE *dout;
259: char *doutn = "";
260: FILE *trout;
261: char *troutn = "";
262: FILE *drout;
263: char *droutn = "";
264: FILE *sout;
265: char *soutn = "";
266:
267: char *mktemp();
268: char get();
269: char getb();
270: short gets();
271: long get3();
272: long getl();
273: SYMBOL **lookup();
274: FILE *tcreat();
275: long round();
276: SYMBOL **slookup();
277: SYMBOL *lookloc();
278:
279: symwrite(sp,n,f) SYMBOL *sp; FILE *f; {
280: #ifdef vax
281: fwrite(sp,sizeof(*symtab),n,f);
282: #else
283: while (n--) {
284: fwrite(sp,sizeof(*symtab)-sizeof(sp->svalue),1,f);
285: writel(&(sp->svalue),1,f); sp++;
286: }
287: #endif
288: }
289:
290: delexit()
291: {
292: unlink("l.out");
293: unlink(doutn);
294: unlink(troutn);
295: unlink(droutn);
296: unlink(soutn);
297: if (delarg==0)
298: chmod(ofilename, 0777 &~ umask(0));
299: exit(delarg);
300: }
301:
302: main(argc, argv)
303: char **argv;
304: {
305: register int c, i;
306: int num;
307: register char *ap, **p;
308: BOOL found;
309: int vscan;
310: char save;
311:
312: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
313: signal(SIGINT, delexit);
314: if (argc == 1)
315: exit(4);
316: p = argv+1;
317:
318: nextsym=symtab=sbrk(0); nsym=0;
319: /* scan files once to find symdefs */
320: for (c=1; c<argc; c++) {
321: if (trace) printf("%s:\n", *p);
322: filname = 0;
323: ap = *p++;
324:
325: if (*ap == '-') {
326: for (i=1; ap[i]; i++) {
327: switch (ap[i]) {
328: case 'o':
329: if (++c >= argc)
330: error(1, "Bad output file");
331: ofilename = *p++;
332: ofilfnd++;
333: continue;
334:
335: case 'u':
336: case 'e':
337: if (++c >= argc)
338: error(1, "Bad 'use' or 'entry'");
339: enter(slookup(*p++));
340: if (ap[i]=='e')
341: entrypt = lastsym;
342: continue;
343:
344: case 'v':
345: if (++c >= argc)
346: error(1, "-v: arg missing");
347: vflag=TRUE;
348: vscan = vindex;
349: found=FALSE;
350: while (--vscan>=0 && found==FALSE)
351: found = eq(vnodes[vscan].vname, *p);
352: if (found) {
353: endload(c, argv);
354: restore(vscan);
355: } else
356: record(c, *p);
357: p++;
358: continue;
359:
360: case 'D':
361: if (++c >= argc)
362: error(1, "-D: arg missing");
363: num = htoi(*p++);
364: if (dsize>num)
365: error(1, "-D: too small");
366: dsize = num;
367: continue;
368:
369: case 'T':
370: if (++c >= argc)
371: error(1, "-T: arg missing");
372: if (tsize!=0)
373: error(1, "-T: too late, some text already loaded");
374: textbase = htoi(*p++);
375: continue;
376:
377: case 'l':
378: save = ap[--i];
379: ap[i]='-';
380: load1arg(&ap[i]);
381: ap[i]=save;
382: break;
383:
384: case 'x':
385: xflag++;
386: continue;
387:
388: case 'X':
389: Xflag++;
390: continue;
391:
392: case 'S':
393: Sflag++;
394: continue;
395:
396: case 'r':
397: rflag++;
398: arflag++;
399: continue;
400:
401: case 's':
402: sflag++;
403: xflag++;
404: continue;
405:
406: case 'n':
407: nflag++;
408: continue;
409:
410: case 'N':
411: nflag = 0;
412: continue;
413:
414: case 'd':
415: dflag++;
416: continue;
417:
418: case 'i':
419: iflag++;
420: continue;
421:
422: case 't':
423: trace++;
424: continue;
425:
426: case 'z':
427: zflag++;
428: continue;
429:
430: default:
431: error(1, "bad flag");
432: } /*endsw*/
433: break;
434: } /*endfor*/
435: } else
436: load1arg(ap);
437: }
438: endload(argc, argv);
439: exit(0);
440: }
441:
442: /* used after pass 1 */
443: long torigin;
444: long dorigin;
445: long borigin;
446: long database;
447:
448: endload(argc, argv)
449: int argc;
450: char **argv;
451: {
452: register int c, i;
453: long dnum;
454: register char *ap, **p;
455:
456: brk(nextsym);
457: filname = 0;
458: middle();
459: setupout();
460: if (-1==(local=sbrk(NSYMPR*sizeof(*local)))) error(1,"Memory overflow");
461: p = argv+1;
462: libp = liblist;
463: for (c=1; c<argc; c++) {
464: ap = *p++;
465: if (trace) printf("%s:\n", ap);
466: if (*ap == '-') {
467: for (i=1; ap[i]; i++) {
468: switch (ap[i]) {
469: case 'D':
470: for (dnum = htoi(*p); dorigin<dnum; dorigin++) putc(0, dout);
471: case 'T':
472: case 'u':
473: case 'e':
474: case 'o':
475: case 'v':
476: ++c;
477: ++p;
478:
479: default:
480: continue;
481:
482: case 'l':
483: ap[--i]='-';
484: load2arg(&ap[i]);
485: break;
486: } /*endsw*/
487: break;
488: } /*endfor*/
489: } else
490: load2arg(ap);
491: }
492: finishout();
493: }
494:
495: record(c, nam)
496: int c;
497: STRING nam;
498: {
499: register OVERLAY *v;
500:
501: v = &vnodes[vindex++];
502: v->argsav = c;
503: v->symsav = nextsym-symtab;
504: v->libsav = libp;
505: v->vname = nam;
506: v->offt = tsize;
507: v->offd = dsize;
508: v->offb = bsize;
509: v->offtr = trsize;
510: v->offdr = drsize;
511: v->offs = ssize;
512: v->ctsav = ctrel;
513: v->cdsav = cdrel;
514: v->cbsav = cbrel;
515: }
516:
517: restore(vscan)
518: int vscan;
519: {
520: register OVERLAY *v;
521: register SYMBOL *saved,*sp;
522:
523: v = &vnodes[vscan];
524: vindex = vscan+1;
525: libp = v->libsav;
526: ctrel = v->ctsav;
527: cdrel = v->cdsav;
528: cbrel = v->cbsav;
529: tsize = v->offt;
530: dsize = v->offd;
531: bsize = v->offb;
532: trsize = v->offtr;
533: drsize = v->offdr;
534: ssize = v->offs;
535: saved = symtab + v->symsav;
536: sp = nextsym;
537: while (sp>saved)
538: hshtab[(--sp)->symhash]=0;
539: nextsym = saved;
540: }
541:
542: /* scan file to find defined symbols */
543: load1arg(cp)
544: register char *cp;
545: {
546: long loc;
547:
548: if (getfile(cp)==0)
549: load1(0, 0L);
550: else {
551: loc = sizeof(int);
552: for (;;) {
553: dseek(&text, loc, (long)sizeof(archdr));
554: if (text.size <= 0) {
555: libp->loc = -1;
556: if( ++libp >= liblist + NROUT)
557: error(1,"liblist overflow");
558: /* thanks to Dennis Wasley */
559: return;
560: }
561: mget((short *)&archdr, sizeof archdr, &text);
562: if (load1(1, loc+sizeof(archdr))) {
563: libp->loc = loc;
564: libp++;
565: }
566: #ifndef vax
567: if (archdr.ar_size.loword==0) fixl(&archdr.ar_size);
568: #endif
569: loc += round(archdr.ar_size, 1) + sizeof(archdr);
570: }
571: }
572: close(infil);
573: }
574:
575: /* single file or archive member */
576: load1(libflg, loc)
577: long loc;
578: {
579: register SYMBOL *sp;
580: SYMBOL *savnext;
581: int ndef, nlocal, type;
582:
583: readhdr(loc);
584: ctrel = tsize;
585: cdrel += dsize;
586: cbrel += bsize;
587: ndef = 0;
588: nlocal = sizeof(cursym);
589: savnext = nextsym;
590: /* if (filhdr.a_trsize+filhdr.a_drsize==0) {
591: /* error(0, "No relocation bits");
592: /* return(0);
593: /* }
594: */
595: loc += filhdr.a_text + filhdr.a_data +
596: filhdr.a_trsize + filhdr.a_drsize + sizeof(filhdr);
597: dseek(&text, loc, filhdr.a_syms);
598: while (text.size > 0) {
599: symget(&cursym, &text);
600: type = cursym.stype;
601: if ((type&EXTERN)==0) {
602: if (Xflag==0 || cursym.sname[0]!='L' || type & STABTYPS)
603: nlocal += sizeof cursym;
604: continue;
605: }
606: symreloc();
607: if (enter(lookup()))
608: continue;
609: if ((sp = lastsym)->stype != EXTERN+UNDEF)
610: continue;
611: if (cursym.stype == EXTERN+UNDEF) {
612: if (cursym.svalue > sp->svalue)
613: sp->svalue = cursym.svalue;
614: continue;
615: }
616: if (sp->svalue != 0 && cursym.stype == EXTERN+TEXT)
617: continue;
618: ndef++;
619: sp->stype = cursym.stype;
620: sp->svalue = cursym.svalue;
621: }
622: if (libflg==0 || ndef) {
623: tsize += filhdr.a_text;
624: dsize += round(filhdr.a_data, FW);
625: bsize += round(filhdr.a_bss, FW);
626: ssize += nlocal;
627: trsize += filhdr.a_trsize;
628: drsize += filhdr.a_drsize;
629: return(1);
630: }
631: /*
632: * No symbols defined by this library member.
633: * Rip out the hash table entries and reset the symbol table.
634: */
635: while (nextsym>savnext)
636: hshtab[(--nextsym)->symhash]=0;
637: return(0);
638: }
639:
640: middle()
641: {
642: register SYMBOL *sp, *symp;
643: long csize, t, corigin, ocsize;
644: int nund, rnd;
645: char s;
646:
647: torigin = 0;
648: dorigin = 0;
649: borigin = 0;
650:
651: p_data = *slookup("_data");
652: p_etext = *slookup("_etext");
653: p_edata = *slookup("_edata");
654: p_end = *slookup("_end");
655: /*
656: * If there are any undefined symbols, save the relocation bits.
657: */
658: symp = nextsym;
659: if (rflag==0) {
660: for (sp = symtab; sp<symp; sp++)
661: if (sp->stype==EXTERN+UNDEF && sp->svalue==0
662: && sp!=p_end && sp!=p_edata && sp!=p_etext
663: && sp!=p_data) {
664: rflag++;
665: dflag = 0;
666: break;
667: }
668: }
669: if (rflag)
670: sflag = iflag = 0;
671: /*
672: * Assign common locations.
673: */
674: csize = 0;
675: database = round(tsize+textbase, (nflag? PAGRND:FW));
676: if (dflag || rflag==0) {
677: ldrsym(p_data, (long)0 , EXTERN+DATA);
678: ldrsym(p_etext, tsize, EXTERN+TEXT);
679: ldrsym(p_edata, dsize, EXTERN+DATA);
680: ldrsym(p_end, bsize, EXTERN+BSS);
681: for (sp = symtab; sp<symp; sp++) {
682: if ((s=sp->stype)==EXTERN+UNDEF && (t = sp->svalue)!=0) {
683: if (t>DW)
684: rnd = DW;
685: else if (t>FW)
686: rnd = FW;
687: else
688: rnd = HW;
689: csize = round(csize, rnd);
690: sp->svalue = csize;
691: sp->stype = EXTERN+COMM;
692: ocsize = csize;
693: csize += t;
694: }
695: if (((s&TMASK) == EXTERN+UNDEF) && (s & STABTYPS)) {
696: sp->svalue = ocsize;
697: sp->stype = (s & STABTYPS) | (EXTERN+COMM);
698: }
699: }
700: }
701: /*
702: * Now set symbols to their final value
703: */
704: csize = round(csize, FW);
705: torigin = textbase;
706: dorigin = database;
707: corigin = dorigin + dsize;
708: borigin = corigin + csize;
709: /*
710: if (zflag)
711: borigin = round(borigin, PAGRND);
712: */
713: cdorel = 0;
714: cborel = dsize+csize;
715: nund = 0;
716: for (sp = symtab; sp<symp; sp++) switch (sp->stype & TMASK) {
717: case EXTERN+UNDEF:
718: errlev |= 01;
719: if ((arflag==0 || dflag) && sp->svalue==0) {
720: if (nund==0)
721: printf("Undefined:\n");
722: nund++;
723: printf("%.8s\n", sp->sname);
724: }
725: continue;
726:
727: case EXTERN+ABS:
728: default:
729: continue;
730:
731: case EXTERN+TEXT:
732: sp->svalue += torigin;
733: continue;
734:
735: case EXTERN+DATA:
736: sp->svalue += dorigin;
737: continue;
738:
739: case EXTERN+BSS:
740: sp->svalue += borigin;
741: continue;
742:
743: case EXTERN+COMM:
744: sp->stype = (sp->stype & STABTYPS) | (EXTERN+BSS);
745: sp->svalue += corigin;
746: continue;
747: }
748: if (sflag || xflag)
749: ssize = 0;
750: bsize += csize;
751: nsym = ssize / (sizeof cursym);
752: }
753:
754: ldrsym(asp, val, type)
755: long val;
756: SYMBOL *asp;
757: {
758: register SYMBOL *sp;
759:
760: if ((sp = asp) == 0)
761: return;
762: if (sp->stype != EXTERN+UNDEF || sp->svalue) {
763: printf("%.8s: ", sp->sname);
764: error(0, "Multiply defined (internal)");
765: return;
766: }
767: sp->stype = type;
768: sp->svalue = val;
769: }
770:
771: extern char _sibuf[BUFSIZ]; /* the space is forced upon us; might as well use it */
772:
773: setupout()
774: {
775: int bss;
776: tout = fopen(ofilename, "w");
777: if (tout==NULL)
778: error(1, "cannot create output");
779: setbuf(tout,_sibuf);
780: dout = tcreat(&doutn, "/tmp/ldaaXXXXX");
781: if (sflag==0 || xflag==0)
782: sout = tcreat(&soutn, "/tmp/ldbaXXXXX");
783: if (rflag) {
784: trout = tcreat(&troutn, "/tmp/ldcaXXXXX");
785: drout = tcreat(&droutn, "/tmp/lddaXXXXX");
786: }
787: filhdr.a_magic = nflag? NMAGIC:OMAGIC;
788: if (zflag)
789: filhdr.a_magic = nflag?0413:0412;
790: filhdr.a_text = nflag? tsize:round(tsize, FW);
791: if (zflag)
792: filhdr.a_text = round(tsize, PAGRND);
793: filhdr.a_data = dsize;
794: if (zflag)
795: filhdr.a_data = round(dsize, PAGRND);
796: bss = bsize - (filhdr.a_data - dsize);
797: if (bss < 0)
798: bss = 0;
799: filhdr.a_bss = bss;
800: filhdr.a_trsize = trsize;
801: filhdr.a_drsize = drsize;
802: filhdr.a_syms = sflag? 0: (ssize + (sizeof cursym)*(nextsym-symtab));
803: if (entrypt) {
804: if (entrypt->stype!=EXTERN+TEXT)
805: error(0, "Entry point not in text");
806: else
807: filhdr.a_entry = entrypt->svalue;
808: } else
809: filhdr.a_entry=0;
810: filhdr.a_trsize = (rflag ? trsize:0);
811: filhdr.a_drsize = (rflag ? drsize:0);
812: writel(&filhdr,8,tout);
813: if (zflag)
814: fseek(tout, PAGSIZ, 0);
815: }
816:
817: FILE *
818: tcreat(namep, name)
819: char **namep, *name;
820: {
821: register FILE *fp;
822: register char *tnm;
823:
824: tnm = mktemp(name);
825: if ((fp = fopen(tnm, "w")) == NULL)
826: error(1, "Cannot create temp file");
827: chmod(tnm, 0600);
828: *namep = tnm;
829: return(fp);
830: }
831:
832: load2arg(acp)
833: char *acp;
834: {
835: register char *cp;
836: register LIBLIST *lp;
837:
838: cp = acp;
839: if (getfile(cp) == 0) {
840: while (*cp)
841: cp++;
842: while (cp >= acp && *--cp != '/');
843: mkfsym(++cp);
844: load2(0L);
845: } else { /* scan archive members referenced */
846: for (lp = libp; lp->loc != -1; lp++) {
847: dseek(&text, lp->loc, (long)sizeof(archdr));
848: mget((short *)&archdr, sizeof(archdr), &text);
849: mkfsym(archdr.ar_name);
850: load2(lp->loc + (long)sizeof(archdr));
851: }
852: libp = ++lp;
853: }
854: close(infil);
855: }
856:
857: load2(loc)
858: long loc;
859: {
860: register SYMBOL *sp;
861: register LOCAL *lp;
862: register int symno;
863: int type;
864:
865: readhdr(loc);
866: ctrel = torigin;
867: cdrel += dorigin;
868: cbrel += borigin;
869: /*
870: * Reread the symbol table, recording the numbering
871: * of symbols for fixing external references.
872: */
873: lp = local;
874: symno = -1;
875: loc += sizeof(filhdr);
876: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
877: filhdr.a_trsize+filhdr.a_drsize, filhdr.a_syms);
878: while (text.size > 0) {
879: symno++;
880: symget(&cursym, &text);
881: symreloc();
882: type = cursym.stype;
883: if ((type&EXTERN) == 0) {
884: if (!sflag&&!xflag&&
885: (!Xflag||cursym.sname[0]!='L'||type&STABTYPS))
886: symwrite(&cursym, 1, sout);
887: continue;
888: }
889: if ((sp = *lookup()) == 0)
890: error(1, "internal error: symbol not found");
891: if (cursym.stype == EXTERN+UNDEF) {
892: if (lp >= local+NSYMPR)
893: error(1, "Local symbol overflow");
894: lp->locindex = symno;
895: lp++->locsymbol = sp;
896: continue;
897: }
898: if(cursym.stype & STABTYPS) continue;
899: if (cursym.stype!=sp->stype || cursym.svalue!=sp->svalue) {
900: printf("%.8s: ", cursym.sname);
901: error(0, "Multiply defined");
902: }
903: }
904: dseek(&text, loc, filhdr.a_text);
905: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data, filhdr.a_trsize);
906: load2td(lp, ctrel, tout, trout);
907: dseek(&text, loc+filhdr.a_text, filhdr.a_data);
908: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data+filhdr.a_trsize, filhdr.a_drsize);
909: load2td(lp, cdrel, dout, drout);
910: while (filhdr.a_data&FW) {
911: putc(0, dout); filhdr.a_data++;
912: }
913: torigin += filhdr.a_text;
914: dorigin += filhdr.a_data;
915: borigin += filhdr.a_bss;
916: cdorel += filhdr.a_data;
917: cborel += filhdr.a_bss;
918: }
919:
920: load2td(lp, creloc, b1, b2)
921: LOCAL *lp;
922: long creloc;
923: FILE *b1, *b2;
924: {
925: register r1;
926: register char r2;
927: register long t;
928: register SYMBOL *sp;
929: long tw,u,l;
930:
931: for (;;) {
932: if (reloc.size==0) {while (text.size) putc(get(&text),b1); break;}
933: t=getl(&reloc); /* position of relocatable stuff */
934: if (rflag) putl(t+creloc,b2); /* remember for subsequent link editing */
935: while (text.pos<t) putc(get(&text),b1); /* advance to proper position */
936: r1=get3(&reloc); /* kind of relocation */
937: r2 = getb(&reloc);
938: switch (r2&06) {/* read raw datum according to its length */
939: case LEN1: tw=get(&text); break;
940: case LEN2: tw=gets(&text); break;
941: case LEN4: tw=getl(&text); break;
942: }
943: if (r2&REXT) {
944: sp=lookloc(lp,r1); /* find the symbol */
945: if (sp->stype==EXTERN+UNDEF) { /* still undefined */
946: r2=(r2&(REFMASK+REXT+ROFF));
947: r1 = nsym+(sp-symtab); /* new reloc */
948: }
949: else {
950: if (sp->stype==EXTERN+DATA && r2&ROFF) {
951: r1=RDATAO;
952: r2&=REFMASK;
953: }
954: else if (sp->stype==EXTERN+BSS && r2&ROFF) {
955: r1=RBSSO;
956: r2&=REFMASK;
957: }
958: else if (sp->stype==EXTERN+ABS && r2&ROFF) {
959: r1=RABSO;
960: r2&=REFMASK;
961: }
962: else if (sp->stype==EXTERN+TEXT && r2&ROFF) {
963: r1=RTEXTO;
964: r2&=REFMASK;
965: }
966: else {if (r2&ROFF) {if (rflag) {error(0,"!-r; see JFR"); rflag=0;}}
967: else tw += database;
968: r1=sp->stype&TYPE;
969: r2&=REFMASK;
970: }
971: tw += sp->svalue - database;
972: }
973: } else switch (r1&TYMASK) {
974: case RTEXT: tw += ctrel; break;
975: case RTEXTO:tw += round(filhdr.a_text,PAGRND)+ctrel-database; break;
976: case RDATA: tw += cdrel; break;
977: case RDATAO:tw += cdorel; break;
978: case RBSS: tw += cbrel; break;
979: case RBSSO: tw += cborel-filhdr.a_data; break;
980: case RABSO: tw += round(filhdr.a_text,PAGRND)-database; break;
981: }
982: if (rflag) { /* remember for subsequent link editing */
983: put3(r1,b2);
984: putb(r2,b2);
985: }
986: if (r2&PCREL) tw -= creloc; /* assembler already subtracted text.pos */
987: switch (r2&06) {/* output relocated datum according to its length */
988: case LEN1: l= -128; u=127; putc((char)tw,b1); break;
989: case LEN2: l= -32768; u=32767; puts((short)tw,b1); break;
990: case LEN4: l=0x80000000; u=0x7FFFFFFF; putl(tw,b1); break;
991: }
992: if (tw<l || u<tw) error(0,"Displacement overflow");
993: }
994: }
995:
996: finishout()
997: {
998:
999: if (!nflag)
1000: while (tsize&FW) {
1001: putc(0, tout); tsize++;
1002: }
1003: if (zflag) {
1004: while (tsize&PAGRND) {
1005: putc(0, tout); tsize++;
1006: }
1007: while (dsize&PAGRND) {
1008: putc(0, dout); dsize++;
1009: }
1010: }
1011: fclose(dout);
1012: copy(doutn);
1013: if (rflag) {
1014: fclose(trout);
1015: copy(troutn);
1016: fclose(drout);
1017: copy(droutn);
1018: }
1019: if (sflag==0) {
1020: if (xflag==0) {
1021: fclose(sout);
1022: copy(soutn);
1023: }
1024: symwrite(symtab, nextsym-symtab, tout);
1025: }
1026: fclose(tout);
1027: if (!ofilfnd) {
1028: unlink("a.out");
1029: link("l.out", "a.out");
1030: ofilename = "a.out";
1031: }
1032: delarg = errlev;
1033: delexit();
1034: }
1035:
1036: copy(np)
1037: char *np;
1038: {
1039: register c;
1040: register FILE *fp;
1041:
1042: if ((fp = fopen(np, "r")) == NULL)
1043: error(1, "cannot recopy output");
1044: while ((c = getc(fp)) != EOF)
1045: putc(c, tout);
1046: fclose(fp);
1047: }
1048:
1049: mkfsym(s)
1050: char *s;
1051: {
1052:
1053: if (sflag || xflag)
1054: return;
1055: cp8c(s, cursym.sname);
1056: cursym.stype = TEXT;
1057: cursym.svalue = torigin;
1058: symwrite(&cursym, 1, sout);
1059: }
1060:
1061: mget(loc, n, sp)
1062: register STREAM *sp;
1063: register char *loc;
1064: {
1065: register char *p;
1066:
1067: if ((sp->nibuf -= n) >= 0) {
1068: if ((sp->size -= n) > 0) {
1069: p = sp->ptr;
1070: sp->pos += n;
1071: do
1072: *loc++ = *p++;
1073: while (--n);
1074: sp->ptr = p;
1075: return;
1076: } else
1077: sp->size += n;
1078: }
1079: sp->nibuf += n;
1080: do {
1081: *loc++ = get(sp);
1082: } while (--n);
1083: }
1084:
1085: short
1086: gets(sp) STREAM *sp; {
1087: short t; mget(&t,2,sp); return(t);
1088: }
1089:
1090: char
1091: getb(sp) STREAM *sp; {
1092: char t; mget(&t,1,sp); return(t);
1093: }
1094:
1095: long
1096: get3(sp) STREAM *sp; {
1097: long t; t=0; mget(&t,3,sp); return(t);
1098: }
1099:
1100: long
1101: getl(sp) STREAM *sp; {
1102: long t; mget(&t,4,sp);
1103: #ifndef vax
1104: fixl(&t);
1105: #endif
1106: return(t);
1107: }
1108:
1109: symget(sp,f) SYMBOL *sp; STREAM *f; {
1110: mget(sp,sizeof(*sp),f);
1111: #ifndef vax
1112: fixl(&sp->svalue);
1113: #endif
1114: }
1115:
1116: dseek(sp, loc, s)
1117: register STREAM *sp;
1118: long loc, s;
1119: {
1120: register PAGE *p;
1121: register b, o;
1122: int n;
1123:
1124: b = loc>>BSHIFT;
1125: o = loc&BMASK;
1126: if (o&01)
1127: error(1, "loader error; odd offset");
1128: --sp->pno->nuser;
1129: if ((p = &page[0])->bno!=b && (p = &page[1])->bno!=b)
1130: if (p->nuser==0 || (p = &page[0])->nuser==0) {
1131: if (page[0].nuser==0 && page[1].nuser==0)
1132: if (page[0].bno < page[1].bno)
1133: p = &page[0];
1134: p->bno = b;
1135: lseek(infil, loc & ~(long)BMASK, 0);
1136: if ((n = read(infil, p->buff, sizeof(p->buff))) < 0)
1137: n = 0;
1138: p->nibuf = n;
1139: } else
1140: error(1, "No pages");
1141: ++p->nuser;
1142: sp->bno = b;
1143: sp->pno = p;
1144: if (s != -1) {sp->size = s; sp->pos = 0;}
1145: sp->ptr = (short *)(p->buff + o);
1146: if ((sp->nibuf = p->nibuf-o) <= 0)
1147: sp->size = 0;
1148: }
1149:
1150: char
1151: get(asp)
1152: STREAM *asp;
1153: {
1154: register STREAM *sp;
1155:
1156: sp = asp;
1157: if ((sp->nibuf -= sizeof(char)) < 0) {
1158: dseek(sp, ((long)(sp->bno+1)<<BSHIFT), (long)-1);
1159: sp->nibuf -= sizeof(char);
1160: }
1161: if ((sp->size -= sizeof(char)) <= 0) {
1162: if (sp->size < 0)
1163: error(1, premeof);
1164: ++fpage.nuser;
1165: --sp->pno->nuser;
1166: sp->pno = &fpage;
1167: }
1168: sp->pos += sizeof(char);
1169: return(*sp->ptr++);
1170: }
1171:
1172: getfile(acp)
1173: STRING acp;
1174: {
1175: register STRING cp;
1176: register int c;
1177: int arcmag;
1178:
1179: cp = acp;
1180: infil = -1;
1181: archdr.ar_name[0] = '\0';
1182: filname = cp;
1183: if (cp[0]=='-' && cp[1]=='l') {
1184: char *locfilname = "/usr/local/lib/libxxxxxxxxxxxxxxx";
1185: if(cp[2] == '\0')
1186: cp = "-la";
1187: filname = "/usr/lib/libxxxxxxxxxxxxxxx";
1188: for(c=0; cp[c+2]; c++) {
1189: filname[c+12] = cp[c+2];
1190: locfilname[c+18] = cp[c+2];
1191: }
1192: filname[c+12] = locfilname[c+18] = '.';
1193: filname[c+13] = locfilname[c+19] = 'a';
1194: filname[c+14] = locfilname[c+20] = '\0';
1195: if ((infil = open(filname+4, 0)) >= 0) {
1196: filname += 4;
1197: } else if ((infil = open(filname, 0)) < 0) {
1198: filname = locfilname;
1199: }
1200: }
1201: if (infil == -1 && (infil = open(filname, 0)) < 0)
1202: error(1, "cannot open");
1203: page[0].bno = page[1].bno = -1;
1204: page[0].nuser = page[1].nuser = 0;
1205: text.pno = reloc.pno = &fpage;
1206: fpage.nuser = 2;
1207: dseek(&text, 0L, (long)sizeof(int));
1208: if (text.size <= 0)
1209: error(1, premeof);
1210: mget(&arcmag, sizeof(arcmag), &text);
1211: return(arcmag==ARMAG);
1212: }
1213:
1214: SYMBOL **lookup()
1215: {
1216: int i;
1217: BOOL clash;
1218: register SYMBOL **hp;
1219: register char *cp, *cp1;
1220:
1221: i = 0;
1222: for (cp = cursym.sname; cp < &cursym.sname[8];)
1223: i = (i<<1) + *cp++;
1224: for (hp = &hshtab[(i&077777)%NSYM+2]; *hp!=0;) {
1225: cp1 = (*hp)->sname;
1226: clash=FALSE;
1227: for (cp = cursym.sname; cp < &cursym.sname[8];)
1228: if (*cp++ != *cp1++) {
1229: clash=TRUE;
1230: break;
1231: }
1232: if (clash) {
1233: if (++hp >= &hshtab[NSYM+2])
1234: hp = hshtab;
1235: } else
1236: break;
1237: }
1238: return(hp);
1239: }
1240:
1241: SYMBOL **slookup(s)
1242: char *s;
1243: {
1244: cp8c(s, cursym.sname);
1245: cursym.stype = EXTERN+UNDEF;
1246: cursym.svalue = 0;
1247: return(lookup());
1248: }
1249:
1250: enter(hp)
1251: register SYMBOL **hp;
1252: {
1253: register SYMBOL *sp;
1254:
1255: if (*hp==0) {
1256: if ((nextsym-symtab)>=NSYM)
1257: error(1, "Symbol table overflow");
1258: if ((nextsym-symtab)>=nsym) {
1259: if (-1==sbrk(NSYM/5 * sizeof(*symtab))) error(1,"Memory overflow");
1260: nsym += NSYM/5;
1261: }
1262: *hp = lastsym = sp = nextsym++;
1263: cp8c(cursym.sname, sp->sname);
1264: sp->stype = cursym.stype;
1265: sp->symhash = hp-hshtab;
1266: sp->svalue = cursym.svalue;
1267: return(1);
1268: } else {
1269: lastsym = *hp;
1270: return(0);
1271: }
1272: }
1273:
1274: symreloc()
1275: {
1276: switch (cursym.stype & 017) {
1277:
1278: case TEXT:
1279: case EXTERN+TEXT:
1280: cursym.svalue += ctrel;
1281: return;
1282:
1283: case DATA:
1284: case EXTERN+DATA:
1285: cursym.svalue += cdrel;
1286: return;
1287:
1288: case BSS:
1289: case EXTERN+BSS:
1290: cursym.svalue += cbrel;
1291: return;
1292:
1293: case EXTERN+UNDEF:
1294: return;
1295: }
1296: if (cursym.stype&EXTERN)
1297: cursym.stype = EXTERN+ABS;
1298: }
1299:
1300: error(n, s)
1301: char *s;
1302: {
1303: if (errlev==0)
1304: printf("ld:");
1305: if (filname) {
1306: printf("%s", filname);
1307: if (archdr.ar_name[0])
1308: printf("(%.14s)", archdr.ar_name);
1309: printf(": ");
1310: }
1311: printf("%s\n", s);
1312: if (n)
1313: delexit();
1314: errlev = 2;
1315: }
1316:
1317: SYMBOL *
1318: lookloc(lp, r)
1319: register LOCAL *lp;
1320: {
1321: register LOCAL *clp;
1322: register sn;
1323:
1324: sn = r;
1325: for (clp = local; clp<lp; clp++)
1326: if (clp->locindex == sn)
1327: return(clp->locsymbol);
1328: error(1, "Local symbol botch");
1329: }
1330:
1331: readhdr(loc)
1332: long loc;
1333: {
1334: long *p; int i;
1335: dseek(&text, loc, (long)sizeof(filhdr));
1336: mget((short *)&filhdr, sizeof(filhdr), &text);
1337: #ifndef vax
1338: for (p= &filhdr,i=8;--i>=0;) fixl(p++);
1339: #endif
1340: if (filhdr.a_magic!=A_MAGIC1 && filhdr.a_magic!=A_MAGIC2 &&
1341: filhdr.a_magic!=A_MAGIC3 && filhdr.a_magic!=A_MAGIC4)
1342: error(1,"Bad magic number");
1343: if (filhdr.a_text&01 || filhdr.a_data&01) {
1344: printf("tsize=%X dsize=%X\n",filhdr.a_text,filhdr.a_data);
1345: error(1, "Text/data size odd");
1346: }
1347: filhdr.a_bss = round(filhdr.a_bss, FW);
1348: if (filhdr.a_magic == NMAGIC) {
1349: cdrel = -round(filhdr.a_text, PAGRND);
1350: cbrel = cdrel - filhdr.a_data;
1351: } else if (filhdr.a_magic == OMAGIC) {
1352: cdrel = -filhdr.a_text;
1353: cbrel = cdrel - filhdr.a_data;
1354: } else
1355: error(1, "Bad format");
1356: }
1357:
1358: cp8c(from, to)
1359: char *from, *to;
1360: {
1361: register char *f, *t, *te;
1362:
1363: f = from;
1364: t = to;
1365: te = t+8;
1366: while ((*t++ = *f++) && t<te);
1367: while (t<te)
1368: *t++ = 0;
1369: }
1370:
1371: eq(s1, s2)
1372: STRING s1;
1373: STRING s2;
1374: {
1375: while (*s1==*s2++)
1376: if ((*s1++)==0)
1377: return(TRUE);
1378: return(FALSE);
1379: }
1380:
1381: long
1382: round(v, r)
1383: long v;
1384: unsigned r;
1385: {
1386: v += r;
1387: v &= ~(long)r;
1388: return(v);
1389: }
1390:
1391: puts(w, f)
1392: FILE *f; short w; {
1393: fwrite(&w,sizeof(short),1,f);
1394: }
1395:
1396: putb(w, f)
1397: FILE *f; char w; {
1398: fwrite(&w,sizeof(char),1,f);
1399: }
1400:
1401: put3(w, f)
1402: FILE *f; long w; {
1403: fwrite(&w,3,1,f);
1404: }
1405:
1406: putl(w, f)
1407: FILE *f; long w; {
1408: #ifndef vax
1409: fixl(&w);
1410: #endif
1411: fwrite(&w,sizeof(long),1,f);
1412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.