![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to foo CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to foo CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 root 1: # 1 ""
2:
3:
4:
5:
6: # 1 "/usr/include/sys/types.h"
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23: typedef unsigned char u_char;
24: typedef unsigned short u_short;
25: typedef unsigned int u_int;
26: typedef unsigned long u_long;
27:
28: typedef struct _physadr { int r[1]; } *physadr;
29: typedef long daddr_t;
30: typedef char * caddr_t;
31: typedef u_short ino_t;
32: typedef long swblk_t;
33: typedef long size_t;
34: typedef long time_t;
35: typedef long label_t[14];
36: typedef u_short dev_t;
37: typedef long off_t;
38: typedef long portid_t;
39:
40:
41: # 37 "/usr/include/sys/types.h"
42:
43: # 1 "/usr/include/sys/param.h"
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55: # 14 "/usr/include/sys/param.h"
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91: # 1 "/usr/include/signal.h"
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130: typedef int (*SIG_TYP)();
131:
132: SIG_TYP signal();
133:
134:
135:
136:
137:
138: # 49 "/usr/include/signal.h"
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150: # 50 "/usr/include/sys/param.h"
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197: # 106 "/usr/include/sys/param.h"
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218: # 135 "/usr/include/sys/param.h"
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254: # 1 "/usr/include/sys/types.h"
255:
256:
257:
258:
259: # 52 "/usr/include/sys/types.h"
260:
261: # 171 "/usr/include/sys/param.h"
262: # 173 "/usr/include/sys/param.h"
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277: # 39 "/usr/include/sys/types.h"
278:
279:
280:
281:
282:
283:
284:
285: typedef struct fd_set { unsigned long fds_bits[(128+sizeof(int)*8-1)/(sizeof(int)*8)]; } fd_set;
286:
287:
288:
289:
290:
291:
292: # 6 ""
293: # 1 "/usr/include/sys/stat.h"
294: struct stat
295: {
296: dev_t st_dev;
297: ino_t st_ino;
298: unsigned short st_mode;
299: short st_nlink;
300: short st_uid;
301: short st_gid;
302: dev_t st_rdev;
303: off_t st_size;
304: time_t st_atime;
305: time_t st_mtime;
306: time_t st_ctime;
307: };
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323: # 7 ""
324: # 1 "/usr/include/a.out.h"
325:
326:
327:
328: struct exec {
329: long a_magic;
330: unsigned long a_text;
331: unsigned long a_data;
332: unsigned long a_bss;
333: unsigned long a_syms;
334: unsigned long a_entry;
335: unsigned long a_trsize;
336: unsigned long a_drsize;
337: };
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360: struct relocation_info {
361: int r_address;
362: unsigned int r_symbolnum:24,
363: r_pcrel:1,
364: r_length:2,
365: r_extern:1,
366: r_addsyl:1,
367: :3;
368: };
369:
370:
371:
372:
373:
374:
375: struct nlist {
376: union {
377: char *n_name;
378: long n_strx;
379: } n_un;
380: unsigned char n_type;
381: char n_other;
382: short n_desc;
383: unsigned long n_value;
384: };
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
400:
401:
402:
403:
404:
405:
406:
407:
408:
409:
410:
411: # 8 ""
412: # 1 "/usr/include/ar.h"
413:
414:
415:
416:
417:
418: struct ar_hdr {
419: char ar_name[16];
420: char ar_date[12];
421: char ar_uid[6];
422: char ar_gid[6];
423: char ar_mode[8];
424: char ar_size[10];
425: char ar_fmag[2];
426: };
427:
428: # 9 ""
429: # 1 "/usr/include/ctype.h"
430:
431:
432:
433:
434:
435:
436:
437:
438:
439: extern char _ctype[];
440:
441:
442:
443:
444:
445:
446:
447:
448:
449:
450:
451:
452:
453:
454:
455:
456: # 10 ""
457: # 1 "/usr/include/pagsiz.h"
458:
459:
460:
461:
462:
463:
464:
465:
466:
467:
468:
469: # 11 ""
470: # 1 "/usr/include/ranlib.h"
471:
472:
473:
474:
475:
476:
477:
478:
479:
480: struct ranlib {
481: union {
482: off_t ran_strx;
483: char *ran_name;
484: } ran_un;
485: off_t ran_off;
486: };
487: # 12 ""
488: # 1 "/usr/include/signal.h"
489: # 59 "/usr/include/signal.h"
490:
491: # 13 ""
492: # 1 "/usr/include/stdio.h"
493:
494:
495:
496: extern struct _iobuf {
497: int _cnt;
498: unsigned char *_ptr;
499: unsigned char *_base;
500: short _flag;
501: char _file;
502: } _iob[120];
503:
504:
505:
506:
507:
508:
509:
510:
511:
512:
513:
514:
515:
516:
517:
518:
519:
520:
521:
522:
523:
524:
525:
526:
527:
528:
529: struct _iobuf *fopen();
530: struct _iobuf *fdopen();
531: struct _iobuf *freopen();
532: struct _iobuf *popen();
533: long ftell();
534: char *fgets();
535:
536:
537: # 1 "/usr/include/tmpnam.h"
538:
539:
540: # 46 "/usr/include/stdio.h"
541:
542: # 14 ""
543:
544:
545:
546:
547:
548:
549:
550:
551:
552:
553:
554:
555:
556:
557:
558:
559:
560:
561:
562:
563:
564:
565:
566:
567:
568:
569:
570:
571:
572:
573:
574:
575:
576:
577:
578:
579:
580:
581:
582:
583:
584:
585:
586:
587:
588:
589:
590:
591:
592:
593:
594:
595:
596:
597:
598:
599:
600:
601:
602:
603: struct symseg {
604: struct nlist *sy_first;
605: struct nlist *sy_last;
606: int sy_used;
607: struct nlist **sy_hfirst;
608: struct nlist **sy_hlast;
609: } symseg[40], *csymseg;
610:
611:
612:
613:
614:
615:
616:
617:
618:
619:
620:
621:
622:
623:
624:
625:
626:
627:
628:
629:
630: struct nlist cursym;
631: struct nlist *lastsym;
632: struct nlist *nextsym;
633: struct nlist *addsym;
634: int nsym;
635:
636:
637: struct nlist **lookup(), **slookup();
638: struct nlist *p_etext, *p_edata, *p_end, *entrypt;
639:
640:
641:
642:
643:
644:
645:
646:
647: off_t li_init[250];
648: struct libseg {
649: off_t *li_first;
650: int li_used;
651: int li_used2;
652: } libseg[40] = {
653: li_init, 0, 0,
654: }, *clibseg = libseg;
655:
656:
657:
658:
659:
660:
661:
662:
663:
664:
665:
666:
667: struct local {
668: int l_index;
669: struct nlist *l_symbol;
670: struct local *l_link;
671: } *lochash[31], lhinit[100];
672: struct locseg {
673: struct local *lo_first;
674: int lo_used;
675: } locseg[40] = {
676: lhinit, 0
677: }, *clocseg;
678:
679:
680:
681:
682:
683:
684:
685:
686:
687:
688:
689:
690:
691: int tnum;
692: int ssiz;
693: struct ranlib *tab;
694: char *tabstr;
695:
696:
697:
698:
699:
700:
701:
702:
703:
704:
705:
706:
707:
708:
709:
710: typedef struct {
711: short *fakeptr;
712: int bno;
713: int nibuf;
714: int nuser;
715: char buff[(1<<12)];
716: } PAGE;
717:
718: PAGE page[2];
719:
720: struct {
721: short *fakeptr;
722: int bno;
723: int nibuf;
724: int nuser;
725: } fpage;
726:
727: typedef struct {
728: char *ptr;
729: int bno;
730: int nibuf;
731: long size;
732: long pos;
733: PAGE *pno;
734: } STREAM;
735:
736: STREAM text;
737: STREAM reloc;
738:
739:
740:
741:
742: struct exec filhdr;
743: struct ar_hdr archdr;
744:
745:
746:
747:
748:
749: int trace;
750: int xflag;
751: int Xflag;
752: int Sflag;
753: int rflag;
754: int arflag;
755: int sflag;
756: int Mflag;
757: int nflag;
758: int dflag;
759: int zflag;
760: long hsize;
761: int Aflag;
762: int Nflag;
763: int funding;
764: int yflag;
765: char **ytab;
766:
767:
768:
769:
770:
771: off_t tsize, dsize, bsize, trsize, drsize, ssize;
772:
773:
774:
775:
776:
777:
778:
779:
780:
781: long ctrel, cdrel, cbrel;
782:
783:
784:
785:
786:
787: long textbase, database;
788:
789:
790:
791:
792:
793: long torigin, dorigin, borigin;
794:
795:
796:
797:
798:
799:
800:
801:
802: int errlev;
803: int delarg = 4;
804:
805:
806:
807:
808:
809:
810:
811:
812:
813: struct biobuf {
814: short b_nleft;
815:
816: char *b_ptr;
817: char b_buf[4096];
818: off_t b_off;
819: struct biobuf *b_link;
820: } *biobufs;
821:
822:
823: int biofd;
824: off_t boffset;
825: struct biobuf *tout, *dout, *trout, *drout, *sout, *strout;
826:
827:
828:
829:
830:
831:
832:
833: off_t offset = sizeof (off_t);
834:
835: int ofilfnd;
836: char *ofilename = "l.out";
837: int ofilemode;
838: int infil;
839: char *filname;
840:
841:
842:
843:
844: char *curstr;
845:
846: char get();
847: int delexit();
848: char *savestr();
849:
850: main(argc, argv)
851: char **argv;
852: {
853: register int c, i;
854: int num;
855: register char *ap, **p;
856: char save;
857:
858: if (signal(2, (SIG_TYP)1) != (SIG_TYP)1) {
859: signal(2, delexit);
860: signal(15, delexit);
861: }
862: if (argc == 1)
863: exit(4);
864: p = argv+1;
865:
866:
867:
868:
869: for (c=1; c<argc; c++) {
870: if (trace)
871: printf("%s:\n", *p);
872: filname = 0;
873: ap = *p++;
874: if (*ap != '-') {
875: load1arg(ap);
876: continue;
877: }
878: for (i=1; ap[i]; i++) switch (ap[i]) {
879:
880: case 'o':
881: if (++c >= argc)
882: error(1, "-o where?");
883: ofilename = *p++;
884: ofilfnd++;
885: continue;
886: case 'u':
887: case 'e':
888: if (++c >= argc)
889: error(1, "-u or -c: arg missing");
890: enter(slookup(*p++));
891: if (ap[i]=='e')
892: entrypt = lastsym;
893: continue;
894: case 'H':
895: if (++c >= argc)
896: error(1, "-H: arg missing");
897: if (tsize!=0)
898: error(1, "-H: too late, some text already loaded");
899: hsize = atoi(*p++);
900: continue;
901: case 'A':
902: if (++c >= argc)
903: error(1, "-A: arg missing");
904: if (Aflag)
905: error(1, "-A: only one base file allowed");
906: Aflag = 1;
907: nflag = 0;
908: funding = 1;
909: load1arg(*p++);
910: trsize = drsize = tsize = dsize = bsize = 0;
911: ctrel = cdrel = cbrel = 0;
912: funding = 0;
913: addsym = nextsym;
914: continue;
915: case 'D':
916: if (++c >= argc)
917: error(1, "-D: arg missing");
918: num = htoi(*p++);
919: if (dsize > num)
920: error(1, "-D: too small");
921: dsize = num;
922: continue;
923: case 'T':
924: if (++c >= argc)
925: error(1, "-T: arg missing");
926: if (tsize!=0)
927: error(1, "-T: too late, some text already loaded");
928: textbase = htoi(*p++);
929: continue;
930: case 'l':
931: save = ap[--i];
932: ap[i]='-';
933: load1arg(&ap[i]);
934: ap[i]=save;
935: goto next;
936: case 'M':
937: Mflag++;
938: continue;
939: case 'x':
940: xflag++;
941: continue;
942: case 'X':
943: Xflag++;
944: continue;
945: case 'S':
946: Sflag++;
947: continue;
948: case 'r':
949: rflag++;
950: arflag++;
951: continue;
952: case 's':
953: sflag++;
954: xflag++;
955: continue;
956: case 'n':
957: nflag++;
958: Nflag = zflag = 0;
959: continue;
960: case 'N':
961: Nflag++;
962: nflag = zflag = 0;
963: continue;
964: case 'd':
965: dflag++;
966: continue;
967: case 'i':
968: printf("ld: -i ignored\n");
969: continue;
970: case 't':
971: trace++;
972: continue;
973: case 'y':
974: if (ap[i+1] == 0)
975: error(1, "-y: symbol name missing");
976: if (yflag == 0) {
977: ytab = (char **)calloc(argc, sizeof (char **));
978: if (ytab == 0)
979: error(1, "ran out of memory (-y)");
980: }
981: ytab[yflag++] = &ap[i+1];
982: goto next;
983: case 'z':
984: zflag++;
985: Nflag = nflag = 0;
986: continue;
987: default:
988: filname = savestr("-x");
989: filname[1] = ap[i];
990: archdr.ar_name[0] = 0;
991: error(1, "bad flag");
992: }
993: next:
994: ;
995: }
996: if (rflag == 0 && Nflag == 0 && nflag == 0)
997: zflag++;
998: endload(argc, argv);
999: exit(0);
1000: }
1001:
1002:
1003:
1004:
1005:
1006: htoi(p)
1007: register char *p;
1008: {
1009: register int c, n;
1010:
1011: n = 0;
1012: while (c = *p++) {
1013: n <<= 4;
1014: if (((_ctype+1)[c]&04))
1015: n += c - '0';
1016: else if (c >= 'a' && c <= 'f')
1017: n += 10 + (c - 'a');
1018: else if (c >= 'A' && c <= 'F')
1019: n += 10 + (c - 'A');
1020: else
1021: error(1, "badly formed hex number");
1022: }
1023: return (n);
1024: }
1025:
1026: delexit()
1027: {
1028:
1029: bflush();
1030: unlink("l.out");
1031: if (delarg==0 && Aflag==0)
1032: chmod(ofilename, ofilemode);
1033: exit (delarg);
1034: }
1035:
1036: endload(argc, argv)
1037: int argc;
1038: char **argv;
1039: {
1040: register int c, i;
1041: long dnum;
1042: register char *ap, **p;
1043:
1044: clibseg = libseg;
1045: filname = 0;
1046: middle();
1047: setupout();
1048: p = argv+1;
1049: for (c=1; c<argc; c++) {
1050: ap = *p++;
1051: if (trace)
1052: printf("%s:\n", ap);
1053: if (*ap != '-') {
1054: load2arg(ap);
1055: continue;
1056: }
1057: for (i=1; ap[i]; i++) switch (ap[i]) {
1058:
1059: case 'D':
1060: dnum = htoi(*p);
1061: if (dorigin < dnum)
1062: while (dorigin < dnum)
1063: (( dout)->b_nleft ? (--( dout)->b_nleft, *( dout)->b_ptr++ = (0)) : bflushc( dout, 0)), dorigin++;
1064:
1065: case 'T':
1066: case 'u':
1067: case 'e':
1068: case 'o':
1069: case 'H':
1070: ++c;
1071: ++p;
1072:
1073: default:
1074: continue;
1075: case 'A':
1076: funding = 1;
1077: load2arg(*p++);
1078: funding = 0;
1079: c++;
1080: continue;
1081: case 'y':
1082: goto next;
1083: case 'l':
1084: ap[--i]='-';
1085: load2arg(&ap[i]);
1086: goto next;
1087: }
1088: next:
1089: ;
1090: }
1091: finishout();
1092: }
1093:
1094:
1095:
1096:
1097: load1arg(cp)
1098: register char *cp;
1099: {
1100: register struct ranlib *tp;
1101: off_t nloc;
1102: int kind;
1103:
1104: kind = getfile(cp);
1105: if (Mflag)
1106: printf("%s\n", filname);
1107: switch (kind) {
1108:
1109:
1110:
1111:
1112: case 0:
1113: load1(0, 0L);
1114: break;
1115:
1116:
1117:
1118:
1119:
1120: case 1:
1121: error(-1,
1122: "warning: archive has no table of contents; add one using ranlib(1)");
1123: nloc = 8;
1124: while (step(nloc))
1125: nloc += sizeof(archdr) +
1126: round(atol(archdr.ar_size), sizeof (short));
1127: break;
1128:
1129:
1130:
1131:
1132:
1133:
1134:
1135:
1136: case 2:
1137: nloc = 8 + sizeof (archdr);
1138: dseek(&text, nloc, sizeof (tnum));
1139: mget((char *)&tnum, sizeof (tnum), &text);
1140: nloc += sizeof (tnum);
1141: tab = (struct ranlib *)malloc(tnum);
1142: if (tab == 0)
1143: error(1, "ran out of memory (toc)");
1144: dseek(&text, nloc, tnum);
1145: mget((char *)tab, tnum, &text);
1146: nloc += tnum;
1147: tnum /= sizeof (struct ranlib);
1148: dseek(&text, nloc, sizeof (ssiz));
1149: mget((char *)&ssiz, sizeof (ssiz), &text);
1150: nloc += sizeof (ssiz);
1151: tabstr = (char *)malloc(ssiz);
1152: if (tabstr == 0)
1153: error(1, "ran out of memory (tocstr)");
1154: dseek(&text, nloc, ssiz);
1155: mget((char *)tabstr, ssiz, &text);
1156: for (tp = &tab[tnum]; --tp >= tab;) {
1157: if (tp->ran_un.ran_strx < 0 ||
1158: tp->ran_un.ran_strx >= ssiz)
1159: error(1, "mangled archive table of contents");
1160: tp->ran_un.ran_name = tabstr + tp->ran_un.ran_strx;
1161: }
1162: while (ldrand())
1163: continue;
1164: cfree((char *)tab);
1165: cfree(tabstr);
1166: nextlibp(-1);
1167: break;
1168:
1169:
1170:
1171:
1172:
1173: case 3:
1174: error(-1,
1175: "warning: table of contents for archive is out of date; rerun ranlib(1)");
1176: nloc = 8;
1177: do
1178: nloc += sizeof(archdr) +
1179: round(atol(archdr.ar_size), sizeof(short));
1180: while (step(nloc));
1181: break;
1182: }
1183: close(infil);
1184: }
1185:
1186:
1187:
1188:
1189:
1190:
1191:
1192: step(nloc)
1193: off_t nloc;
1194: {
1195:
1196: dseek(&text, nloc, (long) sizeof archdr);
1197: if (text.size <= 0) {
1198: nextlibp(-1);
1199: return (0);
1200: }
1201: getarhdr();
1202: if (load1(1, nloc + (sizeof archdr)))
1203: nextlibp(nloc);
1204: return (1);
1205: }
1206:
1207:
1208:
1209:
1210:
1211:
1212: nextlibp(val)
1213: off_t val;
1214: {
1215:
1216: if (clibseg->li_used == 250) {
1217: if (++clibseg == &libseg[40])
1218: error(1, "too many files loaded from libraries");
1219: clibseg->li_first = (off_t *)malloc(250 * sizeof (off_t));
1220: if (clibseg->li_first == 0)
1221: error(1, "ran out of memory (nextlibp)");
1222: }
1223: clibseg->li_first[clibseg->li_used++] = val;
1224: if (val != -1 && Mflag)
1225: printf("\t%s\n", archdr.ar_name);
1226: }
1227:
1228:
1229:
1230:
1231:
1232:
1233:
1234:
1235: ldrand()
1236: {
1237: register struct nlist *sp, **hp;
1238: register struct ranlib *tp, *tplast;
1239: off_t loc;
1240: int nsymt = symx(nextsym);
1241:
1242: tplast = &tab[tnum-1];
1243: for (tp = tab; tp <= tplast; tp++) {
1244: if ((hp = slookup(tp->ran_un.ran_name)) == 0)
1245: continue;
1246: sp = *hp;
1247: if (sp == 0)
1248: continue;
1249: if (sp->n_type != 01+0x0)
1250: continue;
1251: step(tp->ran_off);
1252: loc = tp->ran_off;
1253: while (tp < tplast && (tp+1)->ran_off == loc)
1254: tp++;
1255: }
1256: return (symx(nextsym) != nsymt);
1257: }
1258:
1259:
1260:
1261:
1262: load1(libflg, loc)
1263: off_t loc;
1264: {
1265: register struct nlist *sp;
1266: struct nlist *savnext;
1267: int ndef, nlocal, type, size, nsymt;
1268: register int i;
1269: off_t maxoff;
1270: struct stat stb;
1271:
1272: readhdr(loc);
1273: if (filhdr.a_syms == 0) {
1274: if (filhdr.a_text+filhdr.a_data == 0)
1275: return (0);
1276: error(1, "no namelist");
1277: }
1278: if (libflg)
1279: maxoff = atol(archdr.ar_size);
1280: else {
1281: fstat(infil, &stb);
1282: maxoff = stb.st_size;
1283: }
1284: if (((((filhdr).a_magic==0413 ? 1024 : sizeof (struct exec)) + (filhdr).a_text+(filhdr).a_data + (filhdr).a_trsize+(filhdr).a_drsize) + (filhdr).a_syms) + sizeof (off_t) >= maxoff)
1285: error(1, "too small (old format .o?)");
1286: ctrel = tsize; cdrel += dsize; cbrel += bsize;
1287: ndef = 0;
1288: nlocal = sizeof(cursym);
1289: savnext = nextsym;
1290: loc += (((filhdr).a_magic==0413 ? 1024 : sizeof (struct exec)) + (filhdr).a_text+(filhdr).a_data + (filhdr).a_trsize+(filhdr).a_drsize);
1291: dseek(&text, loc, filhdr.a_syms);
1292: dseek(&reloc, loc + filhdr.a_syms, sizeof(off_t));
1293: mget(&size, sizeof (size), &reloc);
1294: dseek(&reloc, loc + filhdr.a_syms+sizeof (off_t), size-sizeof (off_t));
1295: curstr = (char *)malloc(size);
1296: if (curstr == 0)
1297: error(1, "no space for string table");
1298: mget(curstr+sizeof(off_t), size-sizeof(off_t), &reloc);
1299: while (text.size > 0) {
1300: mget((char *)&cursym, sizeof(struct nlist), &text);
1301: if (cursym.n_un.n_strx) {
1302: if (cursym.n_un.n_strx<sizeof(size) ||
1303: cursym.n_un.n_strx>=size)
1304: error(1, "bad string table index (pass 1)");
1305: cursym.n_un.n_name = curstr + cursym.n_un.n_strx;
1306: }
1307: type = cursym.n_type;
1308: if ((type&01)==0) {
1309: if (Xflag==0 || cursym.n_un.n_name[0]!='L' ||
1310: type & 0xe0)
1311: nlocal += sizeof cursym;
1312: continue;
1313: }
1314: symreloc();
1315: if (enter(lookup()))
1316: continue;
1317: if ((sp = lastsym)->n_type != 01+0x0)
1318: continue;
1319: if (cursym.n_type == 01+0x0) {
1320: if (cursym.n_value > sp->n_value)
1321: sp->n_value = cursym.n_value;
1322: continue;
1323: }
1324: if (sp->n_value != 0 && cursym.n_type == 01+0x4)
1325: continue;
1326: ndef++;
1327: sp->n_type = cursym.n_type;
1328: sp->n_value = cursym.n_value;
1329: }
1330: if (libflg==0 || ndef) {
1331: tsize += filhdr.a_text;
1332: dsize += round(filhdr.a_data, sizeof (long));
1333: bsize += round(filhdr.a_bss, sizeof (long));
1334: ssize += nlocal;
1335: trsize += filhdr.a_trsize;
1336: drsize += filhdr.a_drsize;
1337: if (funding)
1338: textbase = (*slookup("_end"))->n_value;
1339: nsymt = symx(nextsym);
1340: for (i = symx(savnext); i < nsymt; i++) {
1341: sp = (symseg[(i)/1103].sy_first+((i)%1103));
1342: sp->n_un.n_name = savestr(sp->n_un.n_name);
1343: }
1344: free(curstr);
1345: return (1);
1346: }
1347:
1348:
1349:
1350:
1351: symfree(savnext);
1352: free(curstr);
1353: return(0);
1354: }
1355:
1356: middle()
1357: {
1358: register struct nlist *sp;
1359: long csize, t, corigin, ocsize;
1360: int nund, rnd;
1361: char s;
1362: register int i;
1363: int nsymt;
1364:
1365: torigin = 0;
1366: dorigin = 0;
1367: borigin = 0;
1368:
1369: p_etext = *slookup("_etext");
1370: p_edata = *slookup("_edata");
1371: p_end = *slookup("_end");
1372:
1373:
1374:
1375: nsymt = symx(nextsym);
1376: if (rflag==0) {
1377: for (i = 0; i < nsymt; i++) {
1378: sp = (symseg[(i)/1103].sy_first+((i)%1103));
1379: if (sp->n_type==01+0x0 && sp->n_value==0 &&
1380: sp!=p_end && sp!=p_edata && sp!=p_etext) {
1381: rflag++;
1382: dflag = 0;
1383: break;
1384: }
1385: }
1386: }
1387: if (rflag)
1388: sflag = zflag = 0;
1389:
1390:
1391:
1392: csize = 0;
1393: if (!Aflag)
1394: addsym = symseg[0].sy_first;
1395: database = round(tsize+textbase,
1396: (nflag||zflag? (512*2) : sizeof (long)));
1397: database += hsize;
1398: if (dflag || rflag==0) {
1399: ldrsym(p_etext, tsize, 01+0x4);
1400: ldrsym(p_edata, dsize, 01+0x6);
1401: ldrsym(p_end, bsize, 01+0x8);
1402: for (i = symx(addsym); i < nsymt; i++) {
1403: sp = (symseg[(i)/1103].sy_first+((i)%1103));
1404: if ((s=sp->n_type)==01+0x0 &&
1405: (t = sp->n_value)!=0) {
1406: if (t >= sizeof (double))
1407: rnd = sizeof (double);
1408: else if (t >= sizeof (long))
1409: rnd = sizeof (long);
1410: else
1411: rnd = sizeof (short);
1412: csize = round(csize, rnd);
1413: sp->n_value = csize;
1414: sp->n_type = 01+0x12;
1415: ocsize = csize;
1416: csize += t;
1417: }
1418: if (s&01 && (s&0x1e)==0x0 && s&0xe0) {
1419: sp->n_value = ocsize;
1420: sp->n_type = (s&0xe0) | (01+0x12);
1421: }
1422: }
1423: }
1424:
1425:
1426:
1427: csize = round(csize, sizeof (long));
1428: torigin = textbase;
1429: dorigin = database;
1430: corigin = dorigin + dsize;
1431: borigin = corigin + csize;
1432: nund = 0;
1433: nsymt = symx(nextsym);
1434: for (i = symx(addsym); i<nsymt; i++) {
1435: sp = (symseg[(i)/1103].sy_first+((i)%1103));
1436: switch (sp->n_type & (0x1e+01)) {
1437:
1438: case 01+0x0:
1439: if (arflag == 0)
1440: errlev |= 01;
1441: if ((arflag==0 || dflag) && sp->n_value==0) {
1442: if (sp==p_end || sp==p_etext || sp==p_edata)
1443: continue;
1444: if (nund==0)
1445: printf("Undefined:\n");
1446: nund++;
1447: printf("%s\n", sp->n_un.n_name);
1448: }
1449: continue;
1450: case 01+0x2:
1451: default:
1452: continue;
1453: case 01+0x4:
1454: sp->n_value += torigin;
1455: continue;
1456: case 01+0x6:
1457: sp->n_value += dorigin;
1458: continue;
1459: case 01+0x8:
1460: sp->n_value += borigin;
1461: continue;
1462: case 01+0x12:
1463: sp->n_type = (sp->n_type & 0xe0) | (01+0x8);
1464: sp->n_value += corigin;
1465: continue;
1466: }
1467: }
1468: if (sflag || xflag)
1469: ssize = 0;
1470: bsize += csize;
1471: nsym = ssize / (sizeof cursym);
1472: if (Aflag) {
1473: fixspec(p_etext,torigin);
1474: fixspec(p_edata,dorigin);
1475: fixspec(p_end,borigin);
1476: }
1477: }
1478:
1479: fixspec(sym,offset)
1480: struct nlist *sym;
1481: long offset;
1482: {
1483:
1484: if(symx(sym) < symx(addsym) && sym!=0)
1485: sym->n_value += offset;
1486: }
1487:
1488: ldrsym(sp, val, type)
1489: register struct nlist *sp;
1490: long val;
1491: {
1492:
1493: if (sp == 0)
1494: return;
1495: if ((sp->n_type != 01+0x0 || sp->n_value) && !Aflag) {
1496: printf("%s: ", sp->n_un.n_name);
1497: error(0, "user attempt to redefine loader-defined symbol");
1498: return;
1499: }
1500: sp->n_type = type;
1501: sp->n_value = val;
1502: }
1503:
1504: off_t wroff;
1505: struct biobuf toutb;
1506:
1507: setupout()
1508: {
1509: int bss;
1510: extern char *sys_errlist[];
1511: extern int errno;
1512:
1513: ofilemode = 0777 & ~umask(0);
1514: biofd = creat(ofilename, 0666 & ofilemode);
1515: if (biofd < 0) {
1516: filname = ofilename;
1517: archdr.ar_name[0] = 0;
1518: error(1, sys_errlist[errno]);
1519: } else {
1520: struct stat mybuf;
1521: fstat(biofd, &mybuf);
1522: if(mybuf.st_mode & 0111) {
1523: chmod(ofilename, mybuf.st_mode & 0666);
1524: ofilemode = mybuf.st_mode;
1525: }
1526: }
1527: tout = &toutb;
1528: bopen(tout, 0);
1529: filhdr.a_magic = nflag ? 0410 : (zflag ? 0413 : 0407);
1530: filhdr.a_text = nflag ? tsize :
1531: round(tsize, zflag ? (512*2) : sizeof (long));
1532: filhdr.a_data = zflag ? round(dsize, (512*2)) : dsize;
1533: bss = bsize - (filhdr.a_data - dsize);
1534: if (bss < 0)
1535: bss = 0;
1536: filhdr.a_bss = bss;
1537: filhdr.a_trsize = trsize;
1538: filhdr.a_drsize = drsize;
1539: filhdr.a_syms = sflag? 0: (ssize + (sizeof cursym)*symx(nextsym));
1540: if (entrypt) {
1541: if (entrypt->n_type!=01+0x4)
1542: error(0, "entry point not in text");
1543: else
1544: filhdr.a_entry = entrypt->n_value;
1545: } else
1546: filhdr.a_entry = 0;
1547: filhdr.a_trsize = (rflag ? trsize:0);
1548: filhdr.a_drsize = (rflag ? drsize:0);
1549: bwrite((char *)&filhdr, sizeof (filhdr), tout);
1550: if (zflag) {
1551: bflush1(tout);
1552: biobufs = 0;
1553: bopen(tout, (512*2));
1554: }
1555: wroff = ((filhdr).a_magic==0413 ? 1024 : sizeof (struct exec)) + filhdr.a_text;
1556: outb(&dout, filhdr.a_data);
1557: if (rflag) {
1558: outb(&trout, filhdr.a_trsize);
1559: outb(&drout, filhdr.a_drsize);
1560: }
1561: if (sflag==0 || xflag==0) {
1562: outb(&sout, filhdr.a_syms);
1563: wroff += sizeof (offset);
1564: outb(&strout, 0);
1565: }
1566: }
1567:
1568: outb(bp, inc)
1569: register struct biobuf **bp;
1570: {
1571:
1572: *bp = (struct biobuf *)malloc(sizeof (struct biobuf));
1573: if (*bp == 0)
1574: error(1, "ran out of memory (outb)");
1575: bopen(*bp, wroff);
1576: wroff += inc;
1577: }
1578:
1579: load2arg(acp)
1580: char *acp;
1581: {
1582: register char *cp;
1583: off_t loc;
1584:
1585: cp = acp;
1586: if (getfile(cp) == 0) {
1587: while (*cp)
1588: cp++;
1589: while (cp >= acp && *--cp != '/');
1590: mkfsym(++cp);
1591: load2(0L);
1592: } else {
1593: for (;;) {
1594: if (clibseg->li_used2 == clibseg->li_used) {
1595: if (clibseg->li_used < 250)
1596: error(1, "libseg botch");
1597: clibseg++;
1598: }
1599: loc = clibseg->li_first[clibseg->li_used2++];
1600: if (loc == -1)
1601: break;
1602: dseek(&text, loc, (long)sizeof(archdr));
1603: getarhdr();
1604: mkfsym(archdr.ar_name);
1605: load2(loc + (long)sizeof(archdr));
1606: }
1607: }
1608: close(infil);
1609: }
1610:
1611: load2(loc)
1612: long loc;
1613: {
1614: int size;
1615: register struct nlist *sp;
1616: register struct local *lp;
1617: register int symno, i;
1618: int type;
1619:
1620: readhdr(loc);
1621: if (!funding) {
1622: ctrel = torigin;
1623: cdrel += dorigin;
1624: cbrel += borigin;
1625: }
1626:
1627:
1628:
1629:
1630: for (i = 0; i < 31; i++)
1631: lochash[i] = 0;
1632: clocseg = locseg;
1633: clocseg->lo_used = 0;
1634: symno = -1;
1635: loc += ((filhdr).a_magic==0413 ? 1024 : sizeof (struct exec));
1636: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1637: filhdr.a_trsize+filhdr.a_drsize+filhdr.a_syms, sizeof(off_t));
1638: mget(&size, sizeof(size), &text);
1639: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1640: filhdr.a_trsize+filhdr.a_drsize+filhdr.a_syms+sizeof(off_t),
1641: size - sizeof(off_t));
1642: curstr = (char *)malloc(size);
1643: if (curstr == 0)
1644: error(1, "out of space reading string table (pass 2)");
1645: mget(curstr+sizeof(off_t), size-sizeof(off_t), &text);
1646: dseek(&text, loc+filhdr.a_text+filhdr.a_data+
1647: filhdr.a_trsize+filhdr.a_drsize, filhdr.a_syms);
1648: while (text.size > 0) {
1649: symno++;
1650: mget((char *)&cursym, sizeof(struct nlist), &text);
1651: if (cursym.n_un.n_strx) {
1652: if (cursym.n_un.n_strx<sizeof(size) ||
1653: cursym.n_un.n_strx>=size)
1654: error(1, "bad string table index (pass 2)");
1655: cursym.n_un.n_name = curstr + cursym.n_un.n_strx;
1656: }
1657:
1658: switch (cursym.n_type & 017) {
1659:
1660: case 0x4:
1661: case 01+0x4:
1662: cursym.n_value += ctrel;
1663: break;
1664: case 0x6:
1665: case 01+0x6:
1666: cursym.n_value += cdrel;
1667: break;
1668: case 0x8:
1669: case 01+0x8:
1670: cursym.n_value += cbrel;
1671: break;
1672: case 01+0x0:
1673: break;
1674: default:
1675: if (cursym.n_type&01)
1676: cursym.n_type = 01+0x2;
1677: }
1678:
1679: type = cursym.n_type;
1680: if (yflag && cursym.n_un.n_name)
1681: for (i = 0; i < yflag; i++)
1682:
1683: if (ytab[i][1] == cursym.n_un.n_name[1] &&
1684: !strcmp(ytab[i], cursym.n_un.n_name)) {
1685: tracesym();
1686: break;
1687: }
1688: if ((type&01) == 0) {
1689: if (!sflag&&!xflag&&
1690: (!Xflag||cursym.n_un.n_name[0]!='L'||type&0xe0))
1691: symwrite(&cursym, sout);
1692: continue;
1693: }
1694: if (funding)
1695: continue;
1696: if ((sp = *lookup()) == 0)
1697: error(1, "internal error: symbol not found");
1698: if (cursym.n_type == 01+0x0) {
1699: if (clocseg->lo_used == 100) {
1700: if (++clocseg == &locseg[40])
1701: error(1, "local symbol overflow");
1702: clocseg->lo_used = 0;
1703: }
1704: if (clocseg->lo_first == 0) {
1705: clocseg->lo_first = (struct local *)
1706: malloc(100 * sizeof (struct local));
1707: if (clocseg->lo_first == 0)
1708: error(1, "out of memory (clocseg)");
1709: }
1710: lp = &clocseg->lo_first[clocseg->lo_used++];
1711: lp->l_index = symno;
1712: lp->l_symbol = sp;
1713: lp->l_link = lochash[symno % 31];
1714: lochash[symno % 31] = lp;
1715: continue;
1716: }
1717: if (cursym.n_type & 0xe0)
1718: continue;
1719: if (cursym.n_type!=sp->n_type || cursym.n_value!=sp->n_value) {
1720: printf("%s: ", cursym.n_un.n_name);
1721: error(0, "multiply defined");
1722: }
1723: }
1724: if (funding)
1725: return;
1726: dseek(&text, loc, filhdr.a_text);
1727: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data, filhdr.a_trsize);
1728: load2td(ctrel, torigin - textbase, tout, trout);
1729: dseek(&text, loc+filhdr.a_text, filhdr.a_data);
1730: dseek(&reloc, loc+filhdr.a_text+filhdr.a_data+filhdr.a_trsize,
1731: filhdr.a_drsize);
1732: load2td(cdrel, dorigin - database, dout, drout);
1733: while (filhdr.a_data & (sizeof(long)-1)) {
1734: (( dout)->b_nleft ? (--( dout)->b_nleft, *( dout)->b_ptr++ = (0)) : bflushc( dout, 0));
1735: filhdr.a_data++;
1736: }
1737: torigin += filhdr.a_text;
1738: dorigin += round(filhdr.a_data, sizeof (long));
1739: borigin += round(filhdr.a_bss, sizeof (long));
1740: free(curstr);
1741: }
1742:
1743: struct tynames {
1744: int ty_value;
1745: char *ty_name;
1746: } tynames[] = {
1747: 0x0, "undefined",
1748: 0x2, "absolute",
1749: 0x4, "text",
1750: 0x6, "data",
1751: 0x8, "bss",
1752: 0x12, "common",
1753: 0, 0,
1754: };
1755:
1756: tracesym()
1757: {
1758: register struct tynames *tp;
1759:
1760: if (cursym.n_type & 0xe0)
1761: return;
1762: printf("%s", filname);
1763: if (archdr.ar_name[0])
1764: printf("(%s)", archdr.ar_name);
1765: printf(": ");
1766: if ((cursym.n_type&0x1e) == 0x0 && cursym.n_value) {
1767: printf("definition of common %s size %d\n",
1768: cursym.n_un.n_name, cursym.n_value);
1769: return;
1770: }
1771: for (tp = tynames; tp->ty_name; tp++)
1772: if (tp->ty_value == (cursym.n_type&0x1e))
1773: break;
1774: printf((cursym.n_type&0x1e) ? "definition of" : "reference to");
1775: if (cursym.n_type&01)
1776: printf(" external");
1777: if (tp->ty_name)
1778: printf(" %s", tp->ty_name);
1779: printf(" %s\n", cursym.n_un.n_name);
1780: }
1781:
1782:
1783:
1784:
1785:
1786:
1787:
1788:
1789:
1790:
1791:
1792:
1793:
1794:
1795: load2td(creloc, position, b1, b2)
1796: long creloc, offset;
1797: struct biobuf *b1, *b2;
1798: {
1799: register struct nlist *sp;
1800: register struct local *lp;
1801: long tw;
1802: register struct relocation_info *rp, *rpend;
1803: struct relocation_info *relp;
1804: char *codep;
1805: register char *cp;
1806: int relsz, codesz;
1807:
1808: relsz = reloc.size;
1809: relp = (struct relocation_info *)malloc(relsz);
1810: codesz = text.size;
1811: codep = (char *)malloc(codesz);
1812: if (relp == 0 || codep == 0)
1813: error(1, "out of memory (load2td)");
1814: mget((char *)relp, relsz, &reloc);
1815: rpend = &relp[relsz / sizeof (struct relocation_info)];
1816: mget(codep, codesz, &text);
1817: for (rp = relp; rp < rpend; rp++) {
1818: cp = codep + rp->r_address;
1819:
1820:
1821:
1822: switch (rp->r_length) {
1823:
1824: case 0:
1825: tw = *cp;
1826: break;
1827:
1828: case 1:
1829: tw = *(short *)cp;
1830: break;
1831:
1832: case 2:
1833: tw = *(long *)cp;
1834: break;
1835:
1836: default:
1837: error(1, "load2td botch: bad length");
1838: }
1839:
1840:
1841:
1842:
1843:
1844:
1845:
1846: if (rp->r_extern) {
1847:
1848:
1849:
1850:
1851:
1852: lp = lochash[rp->r_symbolnum % 31];
1853: while (lp->l_index != rp->r_symbolnum) {
1854: lp = lp->l_link;
1855: if (lp == 0)
1856: error(1, "local symbol botch");
1857: }
1858: sp = lp->l_symbol;
1859: if (sp->n_type == 01+0x0)
1860: rp->r_symbolnum = nsym+symx(sp);
1861: else {
1862: rp->r_symbolnum = sp->n_type & 0x1e;
1863: tw += sp->n_value;
1864: rp->r_extern = 0;
1865: }
1866: } else switch (rp->r_symbolnum & 0x1e) {
1867:
1868:
1869:
1870:
1871:
1872: case 0x4:
1873: tw += ctrel;
1874: break;
1875: case 0x6:
1876: tw += cdrel;
1877: break;
1878: case 0x8:
1879: tw += cbrel;
1880: break;
1881: case 0x2:
1882: break;
1883: default:
1884: error(1, "relocation format botch (symbol type))");
1885: }
1886:
1887:
1888:
1889:
1890:
1891:
1892:
1893:
1894:
1895: if (rp->r_pcrel)
1896: tw -= creloc;
1897:
1898:
1899:
1900:
1901: switch (rp->r_length) {
1902:
1903: case 0:
1904: if (tw < -128 || tw > 127)
1905: error(0, "byte displacement overflow");
1906: *cp = tw;
1907: break;
1908: case 1:
1909: if (tw < -32768 || tw > 32767)
1910: error(0, "word displacement overflow");
1911: *(short *)cp = tw;
1912: break;
1913: case 2:
1914: *(long *)cp = tw;
1915: break;
1916: }
1917:
1918:
1919:
1920:
1921:
1922:
1923:
1924: if (rflag)
1925: rp->r_address += position;
1926: }
1927: bwrite(codep, codesz, b1);
1928: if (rflag)
1929: bwrite(relp, relsz, b2);
1930: cfree((char *)relp);
1931: cfree(codep);
1932: }
1933:
1934: finishout()
1935: {
1936: register int i;
1937: int nsymt;
1938:
1939: if (sflag==0) {
1940: nsymt = symx(nextsym);
1941: for (i = 0; i < nsymt; i++)
1942: symwrite((symseg[(i)/1103].sy_first+((i)%1103)), sout);
1943: bwrite(&offset, sizeof offset, sout);
1944: }
1945: if (!ofilfnd) {
1946: unlink("a.out");
1947: if (link("l.out", "a.out") < 0)
1948: error(1, "cannot move l.out to a.out");
1949: ofilename = "a.out";
1950: }
1951: delarg = errlev;
1952: delexit();
1953: }
1954:
1955: mkfsym(s)
1956: char *s;
1957: {
1958:
1959: if (sflag || xflag)
1960: return;
1961: cursym.n_un.n_name = s;
1962: cursym.n_type = 0x4;
1963: cursym.n_value = torigin;
1964: symwrite(&cursym, sout);
1965: }
1966:
1967: getarhdr()
1968: {
1969: register char *cp;
1970:
1971: mget((char *)&archdr, sizeof archdr, &text);
1972: for (cp=archdr.ar_name; cp<&archdr.ar_name[sizeof(archdr.ar_name)];)
1973: if (*cp++ == ' ') {
1974: cp[-1] = 0;
1975: return;
1976: }
1977: }
1978:
1979: mget(loc, n, sp)
1980: register STREAM *sp;
1981: register char *loc;
1982: {
1983: register char *p;
1984: register int take;
1985:
1986: top:
1987: if (n == 0)
1988: return;
1989: if (sp->size && sp->nibuf) {
1990: p = sp->ptr;
1991: take = sp->size;
1992: if (take > sp->nibuf)
1993: take = sp->nibuf;
1994: if (take > n)
1995: take = n;
1996: n -= take;
1997: sp->size -= take;
1998: sp->nibuf -= take;
1999: sp->pos += take;
2000: do
2001: *loc++ = *p++;
2002: while (--take > 0);
2003: sp->ptr = p;
2004: goto top;
2005: }
2006: if (n > 4096) {
2007: take = n - n % (1<<12);
2008: lseek(infil, (sp->bno+1)*(1<<12), 0);
2009: if (take > sp->size || read(infil, loc, take) != take)
2010: error(1, "premature EOF");
2011: loc += take;
2012: n -= take;
2013: sp->size -= take;
2014: sp->pos += take;
2015: dseek(sp, (sp->bno+1+take/(1<<12))*(1<<12), -1);
2016: goto top;
2017: }
2018: *loc++ = get(sp);
2019: --n;
2020: goto top;
2021: }
2022:
2023: symwrite(sp, bp)
2024: struct nlist *sp;
2025: struct biobuf *bp;
2026: {
2027: register int len;
2028: register char *str;
2029:
2030: str = sp->n_un.n_name;
2031: if (str) {
2032: sp->n_un.n_strx = offset;
2033: len = strlen(str) + 1;
2034: bwrite(str, len, strout);
2035: offset += len;
2036: }
2037: bwrite(sp, sizeof (*sp), bp);
2038: sp->n_un.n_name = str;
2039: }
2040:
2041: dseek(sp, loc, s)
2042: register STREAM *sp;
2043: long loc, s;
2044: {
2045: register PAGE *p;
2046: register b, o;
2047: int n;
2048:
2049: b = loc>>12;
2050: o = loc&((1<<12)-1);
2051: if (o&01)
2052: error(1, "loader error; odd offset");
2053: --sp->pno->nuser;
2054: if ((p = &page[0])->bno!=b && (p = &page[1])->bno!=b)
2055: if (p->nuser==0 || (p = &page[0])->nuser==0) {
2056: if (page[0].nuser==0 && page[1].nuser==0)
2057: if (page[0].bno < page[1].bno)
2058: p = &page[0];
2059: p->bno = b;
2060: lseek(infil, loc & ~(long)((1<<12)-1), 0);
2061: if ((n = read(infil, p->buff, sizeof(p->buff))) < 0)
2062: n = 0;
2063: p->nibuf = n;
2064: } else
2065: error(1, "botch: no pages");
2066: ++p->nuser;
2067: sp->bno = b;
2068: sp->pno = p;
2069: if (s != -1) {sp->size = s; sp->pos = 0;}
2070: sp->ptr = (char *)(p->buff + o);
2071: if ((sp->nibuf = p->nibuf-o) <= 0)
2072: sp->size = 0;
2073: }
2074:
2075: char
2076: get(asp)
2077: STREAM *asp;
2078: {
2079: register STREAM *sp;
2080:
2081: sp = asp;
2082: if ((sp->nibuf -= sizeof(char)) < 0) {
2083: dseek(sp, ((long)(sp->bno+1)<<12), (long)-1);
2084: sp->nibuf -= sizeof(char);
2085: }
2086: if ((sp->size -= sizeof(char)) <= 0) {
2087: if (sp->size < 0)
2088: error(1, "premature EOF");
2089: ++fpage.nuser;
2090: --sp->pno->nuser;
2091: sp->pno = (PAGE *) &fpage;
2092: }
2093: sp->pos += sizeof(char);
2094: return(*sp->ptr++);
2095: }
2096:
2097: getfile(acp)
2098: char *acp;
2099: {
2100: register char *cp;
2101: register int c;
2102: char arcmag[8+1];
2103: struct stat stb;
2104:
2105: cp = acp;
2106: infil = -1;
2107: archdr.ar_name[0] = '\0';
2108: filname = cp;
2109: if (cp[0]=='-' && cp[1]=='l') {
2110: char *locfilname = "/usr/local/lib/libxxxxxxxxxxxxxxx";
2111: if(cp[2] == '\0')
2112: cp = "-la";
2113: filname = "/usr/lib/libxxxxxxxxxxxxxxx";
2114: for(c=0; cp[c+2]; c++) {
2115: filname[c+12] = cp[c+2];
2116: locfilname[c+18] = cp[c+2];
2117: }
2118: filname[c+12] = locfilname[c+18] = '.';
2119: filname[c+13] = locfilname[c+19] = 'a';
2120: filname[c+14] = locfilname[c+20] = '\0';
2121: if ((infil = open(filname+4, 0)) >= 0) {
2122: filname += 4;
2123: } else if ((infil = open(filname, 0)) < 0) {
2124: filname = locfilname;
2125: }
2126: }
2127: if (infil == -1 && (infil = open(filname, 0)) < 0)
2128: error(1, "cannot open");
2129: page[0].bno = page[1].bno = -1;
2130: page[0].nuser = page[1].nuser = 0;
2131: text.pno = reloc.pno = (PAGE *) &fpage;
2132: fpage.nuser = 2;
2133: dseek(&text, 0L, 8);
2134: if (text.size <= 0)
2135: error(1, "premature EOF");
2136: mget((char *)arcmag, 8, &text);
2137: arcmag[8] = 0;
2138: if (strcmp(arcmag, "!<arch>\n"))
2139: return (0);
2140: dseek(&text, 8, sizeof archdr);
2141: if(text.size <= 0)
2142: return (1);
2143: getarhdr();
2144: if (strncmp(archdr.ar_name, "__.SYMDEF", sizeof(archdr.ar_name)) != 0)
2145: return (1);
2146: fstat(infil, &stb);
2147: return (stb.st_mtime > atol(archdr.ar_date) ? 3 : 2);
2148: }
2149:
2150: struct nlist **
2151: lookup()
2152: {
2153: register int sh;
2154: register struct nlist **hp;
2155: register char *cp, *cp1;
2156: register struct symseg *gp;
2157: register int i;
2158:
2159: sh = 0;
2160: for (cp = cursym.n_un.n_name; *cp;)
2161: sh = (sh<<1) + *cp++;
2162: sh = (sh & 0x7fffffff) % (1103*2);
2163: for (gp = symseg; gp < &symseg[40]; gp++) {
2164: if (gp->sy_first == 0) {
2165: gp->sy_first = (struct nlist *)
2166: calloc(1103, sizeof (struct nlist));
2167: gp->sy_hfirst = (struct nlist **)
2168: calloc((1103*2), sizeof (struct nlist *));
2169: if (gp->sy_first == 0 || gp->sy_hfirst == 0)
2170: error(1, "ran out of space for symbol table");
2171: gp->sy_last = gp->sy_first + 1103;
2172: gp->sy_hlast = gp->sy_hfirst + (1103*2);
2173: }
2174: if (gp > csymseg)
2175: csymseg = gp;
2176: hp = gp->sy_hfirst + sh;
2177: i = 1;
2178: do {
2179: if (*hp == 0) {
2180: if (gp->sy_used == 1103)
2181: break;
2182: return (hp);
2183: }
2184: cp1 = (*hp)->n_un.n_name;
2185: for (cp = cursym.n_un.n_name; *cp == *cp1++;)
2186: if (*cp++ == 0)
2187: return (hp);
2188: hp += i;
2189: i += 2;
2190: if (hp >= gp->sy_hlast)
2191: hp -= (1103*2);
2192: } while (i < (1103*2));
2193: if (i > (1103*2))
2194: error(1, "hash table botch");
2195: }
2196: error(1, "symbol table overflow");
2197:
2198: }
2199:
2200: symfree(saved)
2201: struct nlist *saved;
2202: {
2203: register struct symseg *gp;
2204: register struct nlist *sp;
2205:
2206: for (gp = csymseg; gp >= symseg; gp--, csymseg--) {
2207: sp = gp->sy_first + gp->sy_used;
2208: if (sp == saved) {
2209: nextsym = sp;
2210: return;
2211: }
2212: for (sp--; sp >= gp->sy_first; sp--) {
2213: gp->sy_hfirst[sp->n_desc] = 0;
2214: gp->sy_used--;
2215: if (sp == saved) {
2216: nextsym = sp;
2217: return;
2218: }
2219: }
2220: }
2221: if (saved == 0)
2222: return;
2223: error(1, "symfree botch");
2224: }
2225:
2226: struct nlist **
2227: slookup(s)
2228: char *s;
2229: {
2230:
2231: cursym.n_un.n_name = s;
2232: cursym.n_type = 01+0x0;
2233: cursym.n_value = 0;
2234: return (lookup());
2235: }
2236:
2237: enter(hp)
2238: register struct nlist **hp;
2239: {
2240: register struct nlist *sp;
2241:
2242: if (*hp==0) {
2243: if (hp < csymseg->sy_hfirst || hp >= csymseg->sy_hlast)
2244: error(1, "enter botch");
2245: *hp = lastsym = sp = csymseg->sy_first + csymseg->sy_used;
2246: csymseg->sy_used++;
2247: sp->n_un.n_name = cursym.n_un.n_name;
2248: sp->n_type = cursym.n_type;
2249: sp->n_desc = hp - csymseg->sy_hfirst;
2250: sp->n_value = cursym.n_value;
2251: nextsym = lastsym + 1;
2252: return(1);
2253: } else {
2254: lastsym = *hp;
2255: return(0);
2256: }
2257: }
2258:
2259: symx(sp)
2260: struct nlist *sp;
2261: {
2262: register struct symseg *gp;
2263:
2264: if (sp == 0)
2265: return (0);
2266: for (gp = csymseg; gp >= symseg; gp--)
2267:
2268: if (sp >= gp->sy_first && sp <= gp->sy_last)
2269: return ((gp - symseg) * 1103 + sp - gp->sy_first);
2270: error(1, "symx botch");
2271:
2272: }
2273:
2274: symreloc()
2275: {
2276: if(funding) return;
2277: switch (cursym.n_type & 017) {
2278:
2279: case 0x4:
2280: case 01+0x4:
2281: cursym.n_value += ctrel;
2282: return;
2283:
2284: case 0x6:
2285: case 01+0x6:
2286: cursym.n_value += cdrel;
2287: return;
2288:
2289: case 0x8:
2290: case 01+0x8:
2291: cursym.n_value += cbrel;
2292: return;
2293:
2294: case 01+0x0:
2295: return;
2296:
2297: default:
2298: if (cursym.n_type&01)
2299: cursym.n_type = 01+0x2;
2300: return;
2301: }
2302: }
2303:
2304: error(n, s)
2305: char *s;
2306: {
2307:
2308: if (errlev==0)
2309: printf("ld:");
2310: if (filname) {
2311: printf("%s", filname);
2312: if (n != -1 && archdr.ar_name[0])
2313: printf("(%s)", archdr.ar_name);
2314: printf(": ");
2315: }
2316: printf("%s\n", s);
2317: if (n == -1)
2318: return;
2319: if (n)
2320: delexit();
2321: errlev = 2;
2322: }
2323:
2324: readhdr(loc)
2325: off_t loc;
2326: {
2327:
2328: dseek(&text, loc, (long)sizeof(filhdr));
2329: mget((short *)&filhdr, sizeof(filhdr), &text);
2330: if ((((filhdr).a_magic)!=0407 && ((filhdr).a_magic)!=0410 && ((filhdr).a_magic)!=0413)) {
2331: if (filhdr.a_magic == 0177545)
2332: error(1, "old archive");
2333: error(1, "bad magic number");
2334: }
2335: if (filhdr.a_text&01 || filhdr.a_data&01)
2336: error(1, "text/data size odd");
2337: if (filhdr.a_magic == 0410 || filhdr.a_magic == 0413) {
2338: cdrel = -round(filhdr.a_text, (512*2));
2339: cbrel = cdrel - filhdr.a_data;
2340: } else if (filhdr.a_magic == 0407) {
2341: cdrel = -filhdr.a_text;
2342: cbrel = cdrel - filhdr.a_data;
2343: } else
2344: error(1, "bad format");
2345: }
2346:
2347: round(v, r)
2348: int v;
2349: u_long r;
2350: {
2351:
2352: r--;
2353: v += r;
2354: v &= ~(long)r;
2355: return(v);
2356: }
2357:
2358:
2359: char *savetab;
2360: int saveleft;
2361:
2362: char *
2363: savestr(cp)
2364: register char *cp;
2365: {
2366: register int len;
2367:
2368: len = strlen(cp) + 1;
2369: if (len > saveleft) {
2370: saveleft = 8192;
2371: if (len > saveleft)
2372: saveleft = len;
2373: savetab = (char *)malloc(saveleft);
2374: if (savetab == 0)
2375: error(1, "ran out of memory (savestr)");
2376: }
2377: strncpy(savetab, cp, len);
2378: cp = savetab;
2379: savetab += len;
2380: saveleft -= len;
2381: return (cp);
2382: }
2383:
2384: bopen(bp, off)
2385: struct biobuf *bp;
2386: {
2387:
2388: bp->b_ptr = bp->b_buf;
2389: bp->b_nleft = 4096 - off % 4096;
2390: bp->b_off = off;
2391: bp->b_link = biobufs;
2392: biobufs = bp;
2393: }
2394:
2395: int bwrerror;
2396:
2397: bwrite(p, cnt, bp)
2398: register char *p;
2399: register int cnt;
2400: register struct biobuf *bp;
2401: {
2402: register int put;
2403: register char *to;
2404:
2405: top:
2406: if (cnt == 0)
2407: return;
2408: if (bp->b_nleft) {
2409: put = bp->b_nleft;
2410: if (put > cnt)
2411: put = cnt;
2412: bp->b_nleft -= put;
2413: to = bp->b_ptr;
2414: asm("movc3 r8,(r11),(r7)");
2415: bp->b_ptr += put;
2416: p += put;
2417: cnt -= put;
2418: goto top;
2419: }
2420: if (cnt >= 4096) {
2421: if (bp->b_ptr != bp->b_buf)
2422: bflush1(bp);
2423: put = cnt - cnt % 4096;
2424: if (boffset != bp->b_off)
2425: lseek(biofd, bp->b_off, 0);
2426: if (write(biofd, p, put) != put) {
2427: bwrerror = 1;
2428: error(1, "output write error");
2429: }
2430: bp->b_off += put;
2431: boffset = bp->b_off;
2432: p += put;
2433: cnt -= put;
2434: goto top;
2435: }
2436: bflush1(bp);
2437: goto top;
2438: }
2439:
2440: bflush()
2441: {
2442: register struct biobuf *bp;
2443:
2444: if (bwrerror)
2445: return;
2446: for (bp = biobufs; bp; bp = bp->b_link)
2447: bflush1(bp);
2448: }
2449:
2450: bflush1(bp)
2451: register struct biobuf *bp;
2452: {
2453: register int cnt = bp->b_ptr - bp->b_buf;
2454:
2455: if (cnt == 0)
2456: return;
2457: if (boffset != bp->b_off)
2458: lseek(biofd, bp->b_off, 0);
2459: if (write(biofd, bp->b_buf, cnt) != cnt) {
2460: bwrerror = 1;
2461: error(1, "output write error");
2462: }
2463: bp->b_off += cnt;
2464: boffset = bp->b_off;
2465: bp->b_ptr = bp->b_buf;
2466: bp->b_nleft = 4096;
2467: }
2468:
2469: bflushc(bp, c)
2470: register struct biobuf *bp;
2471: {
2472:
2473: bflush1(bp);
2474: (( bp)->b_nleft ? (--( bp)->b_nleft, *( bp)->b_ptr++ = (c)) : bflushc( bp, c));
2475: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.