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