![[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 [MW Coherent from dump] / coherent / b / bin / ld386|
Return to ld.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / ld386 |
1.1 ! root 1: /* ! 2: * One pass Coff Loader. ! 3: * Acts as ld and drvld. Will be mkshrlb when the specs are done. ! 4: * ! 5: * By Charles Fiterman for Mark Williams 3/30/92. ! 6: */ ! 7: #include "ld.h" ! 8: #include <stdlib.h> ! 9: #include <signal.h> ! 10: #include <ctype.h> ! 11: #include <path.h> ! 12: ! 13: flag_t reloc, /* Combine input into a new .o not an executable */ ! 14: nosym, /* No symbol table out. */ ! 15: watch, /* Produce a trace */ ! 16: noilcl, /* Discard C local symbols beginning .L */ ! 17: nolcl, /* Discard all local symbols */ ! 18: qflag, /* No warn on commons of different length */ ! 19: Qflag, /* Absolute silence on everything */ ! 20: debflg, /* Create debug data */ ! 21: drvld, /* Called as drvld */ ! 22: fource = -1; /* halt on error */ ! 23: ! 24: int errCount; ! 25: int nundef; ! 26: mod_t *head, /* head of list of modules to load */ ! 27: *tail, /* tail or list of modules */ ! 28: *xhead, /* head of noload modules */ ! 29: *xtail; /* tail of noload modules */ ! 30: ren_t *rhead; /* rename list */ ! 31: ! 32: char *ofname = "a.out"; /* output file name */ ! 33: long comnb, comns, comnl; /* common lengths */ ! 34: char *entrys; /* entry string */ ! 35: sym_t *symtable[NHASH]; /* hashed symbol table */ ! 36: ! 37: unsigned short osegs = NLSEG; /* the number of output segments */ ! 38: unsigned short segMap[MAXSEG] = /* All segments map to the first four */ ! 39: { S_TEXT, S_DATA, S_BSSD, S_COMM }; ! 40: ! 41: FILEHDR fileh; ! 42: AOUTHDR aouth; ! 43: SCNHDR *secth; /* output segments */ ! 44: ! 45: static long str_length; ! 46: static int ofd; ! 47: static long *file_value = NULL, file_first; ! 48: char *argv0; ! 49: ! 50: /* ! 51: * Write or die. ! 52: */ ! 53: void ! 54: xwrite(loc, size) ! 55: char *loc; ! 56: unsigned int size; ! 57: { ! 58: if (size != write(ofd, loc, size)) ! 59: fatal("write error"); /**/ ! 60: } ! 61: ! 62: /* ! 63: * Init segment descriptors. ! 64: */ ! 65: void ! 66: initSegs() ! 67: { ! 68: secth = alloc(sizeof(*secth) * MAXSEG); ! 69: strcpy(secth[S_TEXT].s_name, _TEXT); ! 70: secth[S_TEXT].s_flags = STYP_TEXT; ! 71: strcpy(secth[S_DATA].s_name, _DATA); ! 72: secth[S_DATA].s_flags = STYP_DATA; ! 73: strcpy(secth[S_BSSD].s_name, _BSS); ! 74: secth[S_BSSD].s_flags = STYP_BSS; ! 75: strcpy(secth[S_COMM].s_name, _COMMENT); ! 76: secth[S_COMM].s_flags = STYP_INFO; ! 77: } ! 78: ! 79: /* ! 80: * Come here on interrupt. ! 81: */ ! 82: byebye() ! 83: { ! 84: driver_fail(&aouth); ! 85: exit(1); ! 86: } ! 87: ! 88: /* ! 89: * We are drvld not ld. Ask the system where to put the stuff. ! 90: */ ! 91: getsys() ! 92: { ! 93: register int i; ! 94: long bsz, daddr; ! 95: ! 96: time(&fileh.f_timdat); ! 97: fileh.f_nscns = osegs = NLSEG; ! 98: ! 99: daddr = sizeof(fileh) + (sizeof(* secth) * osegs) + ! 100: (fileh.f_opthdr = sizeof(aouth)); ! 101: ! 102: for (i = 0; i < S_BSSD; i++) { ! 103: secth[i].s_scnptr = daddr; ! 104: daddr += secth[i].s_size; ! 105: } ! 106: bsz = secth[S_BSSD].s_size; ! 107: aouth.tsize = secth[S_TEXT].s_size; ! 108: aouth.dsize = secth[S_DATA].s_size + bsz; ! 109: signal(SIGKILL, byebye); ! 110: if (!driver_alloc(&aouth)) ! 111: fatal("kernel interface failed"); ! 112: /* This will become more elaborite when the kernel is done */ ! 113: secth[S_TEXT].s_vaddr = secth[S_TEXT].s_paddr = aouth.text_start; ! 114: secth[S_DATA].s_vaddr = secth[S_DATA].s_paddr = aouth.data_start; ! 115: secth[S_BSSD].s_vaddr = secth[S_BSSD].s_paddr = aouth.data_start + bsz; ! 116: aouth.dsize -= aouth.bsize = bsz; ! 117: ! 118: if (!nosym) ! 119: fileh.f_symptr = daddr; ! 120: } ! 121: ! 122: /* ! 123: * Set virtual bases in array of segments. ! 124: */ ! 125: static ! 126: baseall() ! 127: { ! 128: register SCNHDR *sh; ! 129: int i; ! 130: unsigned long daddr, vaddr, size; ! 131: ! 132: time(&fileh.f_timdat); ! 133: ! 134: /* Add extra segments to real segments */ ! 135: for (i = NLSEG; i < osegs; i++) { ! 136: SCNHDR *oh; ! 137: ! 138: oh = secth + i; ! 139: sh = secth + segMap[i]; ! 140: ! 141: sh->s_size += oh->s_size; ! 142: sh->s_nreloc += oh->s_nreloc; ! 143: sh->s_nlnno += oh->s_nlnno; ! 144: } ! 145: ! 146: /* only output S_COMM if it has something */ ! 147: fileh.f_nscns = secth[S_COMM].s_size ? NLSEG : S_COMM; ! 148: ! 149: size = 0; ! 150: daddr = sizeof(fileh) + (sizeof(* secth) * fileh.f_nscns); ! 151: if (reloc) ! 152: vaddr = 0; ! 153: else { ! 154: daddr += fileh.f_opthdr = sizeof(aouth); ! 155: if (fileh.f_flags & F_KER) /* kernel */ ! 156: vaddr = KERBASE; ! 157: else /* executable */ ! 158: vaddr = daddr; ! 159: } ! 160: ! 161: /* set s_vaddr, s_paddr, s_size, and s_scnptr for all segments */ ! 162: for (i = 0; i < NLSEG; i++) { ! 163: sh = secth + i; ! 164: switch (i) { ! 165: case S_TEXT: ! 166: aouth.text_start = sh->s_vaddr = vaddr; ! 167: aouth.tsize = size = sh->s_size; ! 168: break; ! 169: ! 170: case S_DATA: /* data adjustment */ ! 171: if (!reloc) { ! 172: if (fileh.f_flags & F_KER) ! 173: vaddr = (vaddr + 0x0fff) & ~0x0fffL; ! 174: else ! 175: vaddr = (vaddr & 0x0fff) + DATABASE; ! 176: } ! 177: ! 178: aouth.data_start = sh->s_vaddr = vaddr; ! 179: aouth.dsize = size = sh->s_size; ! 180: break; ! 181: ! 182: case S_BSSD: ! 183: sh->s_paddr = sh->s_vaddr = vaddr; ! 184: vaddr += aouth.bsize = sh->s_size; ! 185: sh->s_scnptr = 0; ! 186: continue; ! 187: ! 188: default: ! 189: sh->s_vaddr = vaddr; ! 190: size = sh->s_size; ! 191: } ! 192: ! 193: sh->s_paddr = sh->s_vaddr; ! 194: sh->s_scnptr = daddr; ! 195: daddr += size; ! 196: vaddr += size; ! 197: } ! 198: ! 199: /* fix new segments to point to right places */ ! 200: for (i = 0; i < NLSEG; i++) { ! 201: int j; ! 202: long vaddr, daddr; ! 203: ! 204: sh = secth + i; ! 205: vaddr = sh->s_vaddr + sh->s_size; /* mark the end */ ! 206: daddr = sh->s_scnptr + sh->s_size; ! 207: ! 208: for (j = osegs; --j >= NLSEG;) { ! 209: SCNHDR *oh; ! 210: ! 211: if (segMap[j] != i) ! 212: continue; ! 213: ! 214: oh = secth + j; ! 215: oh->s_vaddr = vaddr -= oh->s_size; ! 216: oh->s_scnptr = daddr -= oh->s_size; ! 217: w_message("set extra %.8s at %x %x", ! 218: oh->s_name, vaddr, daddr); ! 219: } ! 220: } ! 221: ! 222: /* set relocations for all segments */ ! 223: for (i = 0; i < NLSEG; i++) { ! 224: sh = secth + i; ! 225: if (!reloc || (S_BSSD == i) || !sh->s_nreloc) { ! 226: sh->s_relptr = 0; ! 227: continue; ! 228: } ! 229: sh->s_relptr = daddr; ! 230: daddr += sh->s_nreloc * RELSZ; ! 231: } ! 232: ! 233: /* set line numbers for all segments */ ! 234: for (i = 0; i < NLSEG; i++) { ! 235: sh = secth + i; ! 236: if (!debflg || !sh->s_nlnno) { ! 237: sh->s_nlnno = sh->s_lnnoptr = 0; ! 238: continue; ! 239: } ! 240: sh->s_lnnoptr = daddr; ! 241: daddr += sh->s_nlnno * LINESZ; ! 242: } ! 243: ! 244: if (!nosym) ! 245: fileh.f_symptr = daddr; ! 246: } ! 247: ! 248: /* ! 249: * return entry point ! 250: */ ! 251: static long ! 252: lentry(str) ! 253: char *str; ! 254: { ! 255: if (NULL == str) /* not user specified */ ! 256: return(aouth.text_start); ! 257: ! 258: /* If an octal number use that */ ! 259: { ! 260: register unsigned char c, *s; ! 261: long oaddr = 0; ! 262: ! 263: /* Try to scan whole string as octal. */ ! 264: for (s = str; c = *s++;) { ! 265: if (('0' > c) || (c > '7')) ! 266: break; ! 267: oaddr = (oaddr * 8) + (c - '0'); ! 268: } ! 269: ! 270: if (!c) ! 271: return (oaddr); ! 272: } ! 273: ! 274: /* Search for string in symbol table. */ ! 275: { ! 276: register sym_t *sp; ! 277: char work[SYMNMLEN + 1]; ! 278: ! 279: for (sp = symtable[crc16(str) % NHASH]; ! 280: sp != NULL; ! 281: sp = sp->next) { ! 282: if ((sp->sym.n_sclass == C_EXT) && ! 283: !strcmp(symName(&(sp->sym), work), str)) { ! 284: if (sp->sym.n_scnum != (S_TEXT + 1)) ! 285: message("entry point '%s' not in .text"); ! 286: return(sp->sym.n_value); ! 287: } ! 288: } ! 289: ! 290: message("entry point '%s' undefined", str); /**/ ! 291: return (aouth.text_start); ! 292: } ! 293: } ! 294: ! 295: /* ! 296: * Define referenced special symbols. ! 297: */ ! 298: void ! 299: symBind(sn, ldrv, name, loc) ! 300: int sn, ldrv; ! 301: char *name; ! 302: long loc; ! 303: { ! 304: register SYMENT *sym; ! 305: register sym_t *sp; ! 306: char work[SYMNMLEN + 1]; ! 307: ! 308: for (sp = symtable[crc16(name) % NHASH]; sp != NULL; sp = sp->next) { ! 309: sym = &(sp->sym); ! 310: if ((sym->n_sclass != C_EXT) || ! 311: strcmp(symName(sym, work), name)) ! 312: continue; ! 313: ! 314: if (undefined(sym)) { ! 315: nundef--; ! 316: sym->n_scnum = sn + 1; ! 317: sym->n_value = loc; ! 318: sp->mod = NULL; /* not defined in any mod */ ! 319: return; ! 320: } ! 321: ! 322: if (ldrv) ! 323: return; ! 324: else ! 325: spwarn(sp, "redefines builtin symbol"); ! 326: /* Some symbols such as __end and __end_text ! 327: * are special to the linker. In general symbols ! 328: * beginning __ are reserved to implementors and ! 329: * should be avoided by users. ! 330: * Your definition has been used. */ ! 331: } ! 332: } ! 333: ! 334: /* ! 335: * Add reference to symbol table ! 336: */ ! 337: void ! 338: undef(s) ! 339: char *s; ! 340: { ! 341: SYMENT lds; ! 342: ! 343: memset(&lds, '\0', sizeof(lds)); ! 344: lds.n_offset = (long)s; /* point symbol at our stuff */ ! 345: lds.n_sclass = C_EXTDEF; /* mark undefined */ ! 346: addsym(&lds, NULL); /* connect to no module */ ! 347: } ! 348: ! 349: /* ! 350: * Show undefined symbols. ! 351: */ ! 352: void ! 353: showUndef(sp, sym) ! 354: register sym_t *sp; ! 355: register SYMENT *sym; ! 356: { ! 357: if (undefined(sym)) ! 358: spmsg(sp, ""); /* NODOC */ ! 359: } ! 360: ! 361: /* ! 362: * Pass all symbols through a function. ! 363: * In a really elaborite order. ! 364: */ ! 365: void ! 366: allSym(fun) ! 367: int (*fun)(); ! 368: { ! 369: register SYMENT *sym; ! 370: register sym_t *sp; ! 371: register mod_t *mp; ! 372: register i; ! 373: SYMENT *symEnd; ! 374: ! 375: if (reloc) { /* We are producing another .o */ ! 376: /* ! 377: * Do symbols connected to modules in module order. ! 378: * Only process a global symbol for it's owner. ! 379: */ ! 380: for (mp = head; mp != (mod_t *)NULL; mp = mp->next) { ! 381: sym = ((SYMENT *)(mp->f->f_symptr)); ! 382: symEnd = sym + mp->f->f_nsyms; ! 383: for (; sym < symEnd; sym += sym->n_numaux + 1) { ! 384: if (1 == sym->n_zeroes) { /* pointer to original */ ! 385: sp = (sym_t *)sym->n_offset; ! 386: if (sp->mod == mp) ! 387: (*fun)(sp, &(sp->sym), mp, sym); ! 388: } ! 389: else ! 390: (*fun)(NULL, sym, mp, sym); ! 391: } ! 392: } ! 393: } ! 394: else { ! 395: /* ! 396: * Producing an executable. ! 397: */ ! 398: for (mp = head; mp != (mod_t *)NULL; mp = mp->next) { ! 399: char showSym; ! 400: ! 401: sym = ((SYMENT *)(mp->f->f_symptr)); ! 402: symEnd = sym + mp->f->f_nsyms; ! 403: ! 404: /* ! 405: * If first entry is not C_FILE supress ! 406: * all non C_EXT entries for debug, they make ! 407: * Orignon barf. If not debug mode and the ! 408: * user wants a symbol table give him everything. ! 409: */ ! 410: showSym = !debflg || C_FILE == sym->n_sclass; ! 411: ! 412: for (; sym < symEnd; sym += sym->n_numaux + 1) { ! 413: if ((C_EXT == sym->n_sclass) && !sym->n_numaux) ! 414: continue; /* do later */ ! 415: ! 416: /* pointer to original */ ! 417: if (1 == sym->n_zeroes) { ! 418: sp = (sym_t *)sym->n_offset; ! 419: if (sp->mod == mp) ! 420: (*fun)(showSym ? sp : NULL, ! 421: &(sp->sym), mp, sym); ! 422: } ! 423: else ! 424: (*fun)(NULL, sym, mp, sym); ! 425: } ! 426: } ! 427: ! 428: /* All C_EXT entries go at the end. */ ! 429: for (mp = head; mp != (mod_t *)NULL; mp = mp->next) { ! 430: sym = ((SYMENT *)(mp->f->f_symptr)); ! 431: symEnd = sym + mp->f->f_nsyms; ! 432: for (; sym < symEnd; sym += sym->n_numaux + 1) { ! 433: if (!((C_EXT == sym->n_sclass) && ! 434: !sym->n_numaux)) ! 435: continue; ! 436: ! 437: /* pointer to original */ ! 438: if (1 == sym->n_zeroes) { ! 439: sp = (sym_t *)sym->n_offset; ! 440: if (sp->mod == mp) ! 441: (*fun)(sp, &(sp->sym), mp, sym); ! 442: } ! 443: else ! 444: (*fun)(NULL, sym, mp, sym); ! 445: } ! 446: } ! 447: } ! 448: ! 449: /* ! 450: * Do symbols not connected to a module. ! 451: * These are end symbols and symbols defined with -u option ! 452: */ ! 453: for (i = 0; i < NHASH; i++) ! 454: for (sp = symtable[i]; NULL != sp; sp = sp->next) ! 455: if (NULL == sp->mod) ! 456: (*fun)(sp, &(sp->sym), sp->mod, NULL); ! 457: } ! 458: ! 459: /* ! 460: * Fixup a symbol between passes. ! 461: */ ! 462: void ! 463: symFix(sp, sym, mp, auxp) ! 464: sym_t *sp; ! 465: register SYMENT *sym, *auxp; ! 466: mod_t *mp; ! 467: { ! 468: int segn, len; ! 469: ! 470: segn = sym->n_scnum; ! 471: if (debflg && NULL != auxp && C_FILE == sym->n_sclass) { ! 472: if (NULL != file_value) /* files point in a circle */ ! 473: *file_value = fileh.f_nsyms; ! 474: else ! 475: file_first = fileh.f_nsyms; ! 476: file_value = &(sym->n_value); ! 477: fileh.f_nsyms += sym->n_numaux + 1; ! 478: return; ! 479: } ! 480: if (!reloc && common(sym)) { ! 481: switch ((len = sym->n_value) & 3) { ! 482: case 2: /* 2 byte aligned */ ! 483: sym->n_value = comns; ! 484: comns += len; ! 485: break; ! 486: case 0: /* 4 byte aligned */ ! 487: sym->n_value = comnl; ! 488: comnl += len; ! 489: break; ! 490: default: /* unaligned */ ! 491: sym->n_value = comnb; ! 492: comnb += len; ! 493: } ! 494: sym->n_scnum = S_BSSD + 1; ! 495: } ! 496: else if (segn > 0) ! 497: /* ! 498: * Correct the value to the output sector header. ! 499: * If mp == NULL then segn this is a constructed symbol ! 500: * and segn is relative to the output sector headers. ! 501: * Otherwise it is relative to the input sector headers ! 502: * but the connection to the output sector headers was ! 503: * placed in s_paddr by pass1.c/object(). ! 504: */ ! 505: sym->n_value += secth[(NULL == mp) ? segn - 1 : ! 506: mp->s[segn - 1].s_paddr].s_vaddr; ! 507: ! 508: if (NULL != sp && !nosym) { ! 509: sp->symno = fileh.f_nsyms++; ! 510: if (debflg) ! 511: fileh.f_nsyms += sym->n_numaux; ! 512: } ! 513: } ! 514: ! 515: /* ! 516: * Do work between passes. ! 517: */ ! 518: void ! 519: betweenPass() ! 520: { ! 521: if (reloc) ! 522: fileh.f_flags |= F_AR32WR; ! 523: else { ! 524: fileh.f_flags |= F_RELFLG | F_EXEC | F_AR32WR; ! 525: comnb += (4 - ((comnb + comns) & 3)) & 3; ! 526: secth[S_BSSD].s_size += comnb + comns + comnl; ! 527: } ! 528: if (nosym) ! 529: fileh.f_flags |= F_LSYMS; ! 530: ! 531: if (!debflg) ! 532: fileh.f_flags |= F_LNNO; ! 533: ! 534: if (drvld) ! 535: getsys(); /* get segment base information from system */ ! 536: else ! 537: baseall(); /* compute segment base information */ ! 538: ! 539: if (!reloc) { ! 540: int i; ! 541: ! 542: /* define referenced end of segment symbols */ ! 543: for (i = 0; i < NLSEG; i++) { ! 544: char end_name[20], c, *p; ! 545: ! 546: sprintf(end_name, "__end%.8s", secth[i].s_name); ! 547: for (p = end_name; '\0' != (c = *p); p++) ! 548: if (!isalnum(c)) ! 549: *p = '_'; ! 550: ! 551: symBind(i, drvld, end_name, secth[i].s_size); ! 552: } ! 553: /* define absolute end symbol */ ! 554: symBind(S_BSSD, drvld, "__end", secth[S_BSSD].s_size); ! 555: ! 556: /* get starting addresses for 1, 2 and 4 alligned commons */ ! 557: comnb = secth[S_BSSD].s_vaddr + secth[S_BSSD].s_size - comnb; ! 558: comns = comnb - comns; ! 559: comnl = comns - comnl; ! 560: } ! 561: ! 562: if (nundef && !reloc) { ! 563: message("the following symbols are undefined"); ! 564: errCount--; ! 565: allSym(showUndef); ! 566: } ! 567: ! 568: switch (errCount & fource) { ! 569: case 0: ! 570: break; ! 571: case 1: ! 572: fatal("pass 1, 1 error"); /* NODOC */ ! 573: default: ! 574: fatal("pass 1, %d errors", errCount); ! 575: /* At the end of pass 1 there were \fIn\fB errors detected. ! 576: * The link stopped here. */ ! 577: } ! 578: ! 579: /* Run through symbol table doing fixups */ ! 580: fileh.f_nsyms = 0; ! 581: allSym(symFix); ! 582: ! 583: if (NULL != file_value) ! 584: *file_value = file_first; ! 585: ! 586: aouth.entry = lentry(entrys); ! 587: } ! 588: ! 589: /* ! 590: * output symbol table. ! 591: */ ! 592: static void ! 593: outputSym(s, sm, mp, auxp) ! 594: register sym_t *s; ! 595: register SYMENT *sm; ! 596: mod_t *mp; ! 597: SYMENT *auxp; ! 598: { ! 599: int i; ! 600: char *name, work[SYMNMLEN + 1]; ! 601: SCNHDR *scn; ! 602: SYMENT sym; ! 603: ! 604: if (NULL == (char *)s) ! 605: return; ! 606: ! 607: /* build writeable copy */ ! 608: memcpy(&sym, sm, sizeof(sym)); ! 609: name = symName(sm, work); ! 610: ! 611: if (SYMNMLEN < (i = strlen(name))) { ! 612: sym.n_offset = str_length; ! 613: str_length += i + 1; ! 614: } ! 615: else ! 616: memcpy(sym.n_name, name, SYMNMLEN); ! 617: ! 618: if (!debflg || NULL == auxp) ! 619: sym.n_numaux = 0; ! 620: ! 621: if ((sym.n_scnum > 0) && (NULL != mp)) ! 622: sym.n_scnum = segMap[mp->s[sym.n_scnum - 1].s_paddr] + 1; ! 623: ! 624: xwrite(&sym, SYMESZ); ! 625: ! 626: if (sym.n_numaux) { ! 627: int aux = 1; ! 628: int has_fcn = 0; ! 629: ! 630: switch(sym.n_sclass) { ! 631: case C_STRTAG: ! 632: case C_UNTAG: ! 633: case C_ENTAG: ! 634: case C_BLOCK: ! 635: has_fcn = 1; ! 636: break; ! 637: case C_STAT: ! 638: case C_FILE: ! 639: aux = sym.n_numaux + 1; /* dont scan for ixs */ ! 640: break; ! 641: default: ! 642: if (ISFCN(sym.n_type)) ! 643: has_fcn = 1; ! 644: } ! 645: ! 646: for (; aux <= sym.n_numaux; aux++) { ! 647: SYMENT *s1, *s2, *s3; ! 648: AUXENT *a = auxp + aux; ! 649: ! 650: /* ! 651: * Fix indices to new value. ! 652: */ ! 653: if (a->ae_tagndx) { ! 654: s1 = ((SYMENT *)(mp->f->f_symptr)) + ! 655: a->ae_tagndx; ! 656: s = (sym_t *)s1->n_offset; ! 657: a->ae_tagndx = s->symno; ! 658: } ! 659: /* ae_endndx points past an entry */ ! 660: if (has_fcn && a->ae_endndx) { ! 661: s2 = ((SYMENT *)(mp->f->f_symptr)); ! 662: /* find the entry it points past */ ! 663: for (s1 = s2 + a->ae_endndx; ! 664: (s3 = (s2 + s2->n_numaux + 1)) < s1; ! 665: s2 = s3) ! 666: ; ! 667: s = (sym_t *)s2->n_offset; ! 668: a->ae_endndx = s->symno + s2->n_numaux + 1; ! 669: } ! 670: } ! 671: xwrite(auxp + 1, SYMESZ * sym.n_numaux); ! 672: } ! 673: } ! 674: ! 675: /* ! 676: * output long symbols. ! 677: */ ! 678: static void ! 679: longSym(s, sm) ! 680: register sym_t *s; ! 681: register SYMENT *sm; ! 682: { ! 683: int i; ! 684: char *name, work[SYMNMLEN + 1]; ! 685: ! 686: if (NULL == s) ! 687: return; ! 688: ! 689: name = symName(sm, work); ! 690: if (SYMNMLEN < (i = strlen(name))) ! 691: xwrite(name, i + 1); ! 692: } ! 693: ! 694: ! 695: /* ! 696: * Scan this modules sections for a name match. ! 697: */ ! 698: SCNHDR * ! 699: findSeg(mp, segn) ! 700: register mod_t *mp; ! 701: { ! 702: int i; ! 703: register SCNHDR *orsp, *isgp; ! 704: ! 705: orsp = secth + segn; ! 706: for (i = 0; i < mp->f->f_nscns; i++) { ! 707: isgp = mp->s + i; ! 708: if (strncmp(isgp->s_name, orsp->s_name, 8)) ! 709: isgp = NULL; ! 710: else ! 711: break; ! 712: } ! 713: return isgp; ! 714: } ! 715: ! 716: /* ! 717: * Do relocations ! 718: */ ! 719: static void ! 720: relocations(mp, osegn, isegn) ! 721: mod_t * mp; ! 722: { ! 723: register RELOC *rel; ! 724: char *t; /* actual text */ ! 725: SCNHDR *isgp, *orsp; ! 726: unsigned i; ! 727: long size, told, fixr; ! 728: ! 729: if ((NULL == (isgp = findSeg(mp, isegn))) || !(size = isgp->s_size)) ! 730: return; ! 731: ! 732: orsp = secth + osegn; ! 733: fixr = isgp->s_vaddr - orsp->s_vaddr; ! 734: t = (char *)isgp->s_scnptr; ! 735: ! 736: if (watch) { ! 737: errCount--; ! 738: mpmsg(mp, "relocating seg#%.8s[%06lx]@%06lx to %06lx r %ld", ! 739: isgp->s_name, ! 740: size, ! 741: isgp->s_vaddr, ! 742: orsp->s_vaddr, ! 743: isgp->s_nreloc); /* NODOC */ ! 744: told = lseek(ofd, 0, 2); ! 745: } ! 746: ! 747: for (i = 0; i < isgp->s_nreloc; i++) { ! 748: char *ptr; ! 749: char *mtype; ! 750: sym_t *sp; ! 751: SYMENT *s, *sym; ! 752: long relf, w, at; ! 753: int undef; ! 754: char work[SYMNMLEN + 1], *name; ! 755: static char *pcrel = "pcrel"; ! 756: ! 757: /* get reloc record */ ! 758: rel = ((RELOC *)isgp->s_relptr) + i; ! 759: ! 760: w = rel->r_vaddr - isgp->s_vaddr; ! 761: if ((w < 0) || (w > size)) ! 762: corrupt(mp); ! 763: ptr = t + w; ! 764: ! 765: if ((rel->r_symndx < 0) || (rel->r_symndx > mp->f->f_nsyms)) ! 766: corrupt(mp); ! 767: ! 768: s = (SYMENT *)mp->f->f_symptr + rel->r_symndx; ! 769: if (1 == s->n_zeroes) { /* fixed elsewhere */ ! 770: sp = (sym_t *)s->n_offset; ! 771: sym = &(sp->sym); ! 772: } else { ! 773: sp = NULL; ! 774: sym = s; ! 775: } ! 776: relf = sym->n_value; ! 777: mtype = "rel"; ! 778: undef = undefined(sym); ! 779: ! 780: if (watch) { ! 781: at = told + w; ! 782: name = symName(sym, work); ! 783: } ! 784: /* ! 785: * This wierdness is to deal with a coff wierdness. ! 786: * The address of a common is incremented by the ! 787: * length of the common as seen in that module. ! 788: */ ! 789: if (common(s)) ! 790: relf -= s->n_value; ! 791: /* ! 792: * If the symbol is native to this module ! 793: * the reference already has this modules ! 794: * segment address. Subtract it. ! 795: */ ! 796: else if (!undef && ((NULL == sp) || (sp->mod == mp))) ! 797: relf -= mp->s[s->n_scnum - 1].s_vaddr; ! 798: ! 799: /* relocate what the pointer is aimed at and leave a record */ ! 800: #define relocate(type) *(type *)ptr = (w = *(type *)ptr) + relf ! 801: ! 802: if (reloc) { ! 803: rel->r_vaddr = w + orsp->s_vaddr; ! 804: rel->r_symndx = sp->symno; ! 805: ! 806: switch (rel->r_type) { ! 807: case R_PCRBYTE: ! 808: mtype = pcrel; ! 809: relf = fixr; ! 810: ! 811: case R_DIR8: ! 812: case R_RELBYTE: ! 813: relocate(char); ! 814: break; ! 815: ! 816: case R_PCRWORD: ! 817: mtype = pcrel; ! 818: relf = fixr; ! 819: ! 820: case R_DIR16: ! 821: case R_RELWORD: ! 822: relocate(short); ! 823: break; ! 824: ! 825: case R_PCRLONG: ! 826: mtype = pcrel; ! 827: relf = fixr; ! 828: ! 829: case R_DIR32: ! 830: case R_RELLONG: ! 831: relocate(long); ! 832: break; ! 833: ! 834: case R_NONREL: ! 835: mtype = "nonrel"; ! 836: w = *(long *)ptr; ! 837: relf = 0; ! 838: break; ! 839: ! 840: default: ! 841: mpmsg(mp, "unknown r_type %d in segment %.8s record %d", ! 842: rel->r_type, isgp->s_name, i); ! 843: /* Unknown type on COFF relocation record. */ ! 844: } ! 845: ! 846: if ((sym->n_scnum > 0) && (mtype != pcrel)) ! 847: rel->r_symndx = sym->n_scnum - 1; ! 848: ! 849: if (!undef && (sym->n_scnum < 0)) ! 850: rel->r_type = R_NONREL; ! 851: ! 852: w_message("%lx '%s'(%d %lx %lx) %lx = '%s'(%lx) + %lx", ! 853: at, ! 854: mtype, ! 855: rel->r_type, ! 856: rel->r_vaddr, ! 857: rel->r_symndx, ! 858: relf + w, ! 859: name, ! 860: sym->n_value, ! 861: w); ! 862: } ! 863: else { ! 864: switch (rel->r_type) { ! 865: case R_PCRBYTE: ! 866: mtype = pcrel; ! 867: relf -= orsp->s_vaddr; ! 868: case R_DIR8: ! 869: case R_RELBYTE: ! 870: relocate(char); ! 871: break; ! 872: case R_PCRWORD: ! 873: mtype = pcrel; ! 874: relf -= orsp->s_vaddr; ! 875: case R_RELWORD: ! 876: case R_DIR16: ! 877: relocate(short); ! 878: break; ! 879: case R_PCRLONG: ! 880: mtype = pcrel; ! 881: relf -= orsp->s_vaddr; ! 882: case R_RELLONG: ! 883: case R_DIR32: ! 884: relocate(long); ! 885: break; ! 886: case R_NONREL: ! 887: mtype = "nonrel"; ! 888: w = *(long *)ptr; ! 889: relf = 0; ! 890: break; ! 891: default: ! 892: mpmsg(mp, "unknown r_type %d in segment %.8s record %d", ! 893: rel->r_type, isgp->s_name, i); ! 894: /* NODOC */ ! 895: } ! 896: w_message("%lx '%s'(%d) %lx = '%s'(%lx) + %lx", ! 897: at, ! 898: mtype, ! 899: rel->r_type, ! 900: relf + w, ! 901: name, ! 902: sym->n_value, ! 903: w); ! 904: } ! 905: } ! 906: #undef relocate ! 907: ! 908: orsp->s_vaddr += size; ! 909: xwrite(t, (int)size); ! 910: } ! 911: ! 912: /* ! 913: * Write line records for a segment. ! 914: */ ! 915: writeLine(mp, segn) ! 916: mod_t *mp; ! 917: { ! 918: int j; ! 919: long fptr; ! 920: AUXENT *a; ! 921: SYMENT *sym; ! 922: LINENO *l; ! 923: SCNHDR *scn; ! 924: ! 925: if (NULL == (scn = findSeg(mp, segn)) || (!scn->s_nlnno)) ! 926: return; ! 927: ! 928: /* ! 929: * set up n_lnnoptr in symbol table to point ! 930: * to line records ! 931: */ ! 932: l = (LINENO *)scn->s_lnnoptr; ! 933: fptr = lseek(ofd, 0L, 1); /* where I am */ ! 934: for (j = 0; j < scn->s_nlnno; j++, l++) { ! 935: if (!l->l_lnno) { ! 936: sym = ((SYMENT *)(mp->f->f_symptr)) + ! 937: l->l_addr.l_symndx; ! 938: if (sym->n_numaux) { ! 939: a = (AUXENT *)sym + 1; ! 940: a->ae_lnnoptr = fptr; ! 941: if (1 == sym->n_zeroes) { ! 942: sym_t *sp; ! 943: sp = (sym_t *)sym->n_offset; ! 944: l->l_addr.l_symndx = sp->symno; ! 945: } ! 946: } ! 947: } ! 948: fptr += LINESZ; ! 949: } ! 950: xwrite(scn->s_lnnoptr, LINESZ * scn->s_nlnno); ! 951: } ! 952: ! 953: /* ! 954: * Output all data. ! 955: */ ! 956: outputAll() ! 957: { ! 958: register mod_t *mp; ! 959: register SCNHDR *scn; ! 960: int i, j; ! 961: struct stat statbuf; ! 962: ! 963: /* Open output file */ ! 964: ofd = qopen(ofname, 1); ! 965: ! 966: /* write header */ ! 967: xwrite(&fileh, sizeof(fileh)); ! 968: ! 969: if (!reloc) { /* if executable set bits and write opt header */ ! 970: stat(ofname, &statbuf); ! 971: chmod(ofname, ! 972: statbuf.st_mode | S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6)); ! 973: ! 974: aouth.magic = Z_MAGIC; ! 975: xwrite(&aouth, sizeof(aouth)); ! 976: } ! 977: ! 978: /* write sector headers */ ! 979: xwrite(secth, sizeof(* secth) * fileh.f_nscns); ! 980: ! 981: /* write corrected text segments */ ! 982: for (i = 0; i < NLSEG; i++) { ! 983: if (i == S_BSSD) ! 984: continue; ! 985: for (j = 0; j < osegs; j++) { ! 986: if (segMap[j] == i) ! 987: for (mp = head; mp != NULL; mp = mp->next) ! 988: relocations(mp, i, j); ! 989: } ! 990: } ! 991: ! 992: /* write relocation if required */ ! 993: for (i = (reloc ? 0 : S_BSSD); i < S_BSSD; i++) { ! 994: for (j = 0; j < osegs; j++) { ! 995: if (segMap[j] != i) ! 996: continue; ! 997: ! 998: for (mp = head; mp != NULL; mp = mp->next) { ! 999: if ((NULL == (scn = findSeg(mp, j))) || ! 1000: !scn->s_nreloc) ! 1001: continue; ! 1002: xwrite(scn->s_relptr, ! 1003: RELSZ * (int)scn->s_nreloc); ! 1004: } ! 1005: } ! 1006: } ! 1007: ! 1008: /* write lines if required */ ! 1009: for (i = (debflg ? 0 : NLSEG); i < NLSEG; i++) { ! 1010: for (j = 0; j < osegs; j++) { ! 1011: if (segMap[j] != i) ! 1012: continue; ! 1013: ! 1014: for (mp = head; mp != NULL; mp = mp->next) ! 1015: writeLine(mp, j); ! 1016: } ! 1017: } ! 1018: ! 1019: if (!nosym) { ! 1020: str_length = 4; ! 1021: ! 1022: allSym(outputSym); ! 1023: if (4 != str_length) { ! 1024: xwrite(&str_length, sizeof(str_length)); ! 1025: allSym(longSym); ! 1026: } ! 1027: } ! 1028: ! 1029: close(ofd); ! 1030: } ! 1031: ! 1032: /* ! 1033: * Process arguements, and call other work. ! 1034: */ ! 1035: main(argc, argv) ! 1036: char *argv[]; ! 1037: { ! 1038: int c; ! 1039: char *specialList = NULL; ! 1040: char *argString = "?ge:finKl:L:o:A:O:rsu:wXxZ:qQ"; ! 1041: char *env; ! 1042: ! 1043: /* find program name */ ! 1044: if (NULL == (argv0 = strrchr(argv[0], '/'))) ! 1045: argv0 = argv[0]; ! 1046: else ! 1047: argv0++; ! 1048: ! 1049: env = getenv("LIBPATH"); ! 1050: /* ! 1051: * drvld is an alternative name for ld. ! 1052: * In this mode ld will load the kernel's symbol table, so ! 1053: * that the loadable driver can link directly to kernel services. ! 1054: * After pass1 we call driver_alloc() to tell the kernel the ! 1055: * sizes of the driver segments, the kernel replys with locations ! 1056: * for them. Then we output the driver to a tmp file and execl() ! 1057: */ ! 1058: if (!strcmp(argv0, "drvld")) { ! 1059: #if 0 ! 1060: ofname = tmpnam(NULL); ! 1061: #endif ! 1062: argString = "?ge:l:L:u:wdq"; ! 1063: fileh.f_flags |= F_KER; ! 1064: drvld = 1; ! 1065: /* read kernel for symbol table but don't load */ ! 1066: readFile(kernelName(), 0, NULL); ! 1067: _addargs("DRVLD", &argc, &argv); ! 1068: } ! 1069: else ! 1070: _addargs("LD", &argc, &argv); ! 1071: ! 1072: initSegs(); ! 1073: ! 1074: while (EOF != (c = getargs(argc, argv, argString))) { ! 1075: switch (c) { ! 1076: case 0: /* Not an option, read a file for load */ ! 1077: readFile(optarg, 1, NULL); ! 1078: continue; ! 1079: ! 1080: case 'A': /* Read a file as an archive regardless of name */ ! 1081: readFile(optarg, 1, ".a"); ! 1082: continue; ! 1083: ! 1084: case 'O': /* Read a file as an object regardless of name */ ! 1085: readFile(optarg, 1, ".o"); ! 1086: continue; ! 1087: ! 1088: case 'f': /* attempt link even if errors */ ! 1089: fource = 0; ! 1090: continue; ! 1091: ! 1092: case 'g': /* save extra segments and aux symbols */ ! 1093: debflg ^= 1; ! 1094: continue; ! 1095: ! 1096: case 'e': ! 1097: entrys = optarg; ! 1098: ! 1099: case 'Z': /* use and erase after */ ! 1100: case 'i': /* obselete options */ ! 1101: case 'n': ! 1102: continue; ! 1103: ! 1104: case 'K': /* recompile of Kernel */ ! 1105: fileh.f_flags |= F_KER; ! 1106: continue; ! 1107: ! 1108: case 'L': ! 1109: /* ! 1110: * Special filelist for lookup. ! 1111: */ ! 1112: { ! 1113: char *new; ! 1114: ! 1115: if (NULL == specialList) { ! 1116: new = alloc(strlen(optarg) + 2); ! 1117: sprintf(new, "%c%s", LISTSEP, optarg); ! 1118: } ! 1119: else { ! 1120: new = alloc( ! 1121: strlen(specialList)+strlen(optarg)+2); ! 1122: sprintf(new, "%s%c%s", ! 1123: specialList, LISTSEP, optarg); ! 1124: free(specialList); ! 1125: } ! 1126: specialList = new; ! 1127: continue; ! 1128: } ! 1129: ! 1130: case 'l': ! 1131: /* -l<lib>: use standard lib */ ! 1132: { ! 1133: char *xp, *lp; ! 1134: ! 1135: xp = alloc(strlen(optarg) + 6); ! 1136: sprintf(xp, "lib%s.a", optarg); ! 1137: lp = NULL; ! 1138: if (NULL != specialList) ! 1139: lp = path(specialList, xp, AREAD); ! 1140: if (NULL == lp && NULL != env) ! 1141: lp = path(env, xp, AREAD); ! 1142: if (NULL == lp) ! 1143: lp = path(DEFLIBPATH, xp, AREAD); ! 1144: if (NULL == lp) ! 1145: fatal("can't find '%s'", xp); ! 1146: /* Can't locate requested library. */ ! 1147: ! 1148: readFile(lp, 1, NULL); ! 1149: free(xp); ! 1150: continue; ! 1151: } ! 1152: ! 1153: case 'o': ! 1154: ofname = optarg; ! 1155: continue; ! 1156: ! 1157: case 'r': ! 1158: reloc ^= 1; /* retain relocation information */ ! 1159: continue; ! 1160: ! 1161: case 's': ! 1162: nosym ^= 1; ! 1163: continue; ! 1164: ! 1165: case 'u': ! 1166: undef(optarg); ! 1167: continue; ! 1168: ! 1169: case 'Q': ! 1170: Qflag = 1; ! 1171: ! 1172: case 'q': ! 1173: qflag = 1; ! 1174: continue; ! 1175: ! 1176: case 'w': ! 1177: watch ^= 1; ! 1178: continue; ! 1179: ! 1180: case 'X': ! 1181: noilcl ^= 1; ! 1182: continue; ! 1183: ! 1184: case 'x': ! 1185: nolcl ^= 1; ! 1186: continue; ! 1187: ! 1188: case '?': ! 1189: help(); /* non returning */ ! 1190: ! 1191: default: ! 1192: usage(); /* non returning */ ! 1193: } ! 1194: } ! 1195: if (nosym) ! 1196: nolcl = 1; ! 1197: ! 1198: if (reloc || debflg) ! 1199: nosym = nolcl = noilcl = 0; ! 1200: ! 1201: if (!fileh.f_magic) ! 1202: fatal("No work"); ! 1203: /* There were no object files loaded. */ ! 1204: ! 1205: betweenPass(); /* between passes */ ! 1206: outputAll(); /* output all data */ ! 1207: ! 1208: /* repass argument list to erase any -Z files */ ! 1209: for (optix = 1; EOF != (c = getargs(argc, argv, argString));) ! 1210: if ('Z' == c) ! 1211: unlink(optarg); ! 1212: ! 1213: #if 0 ! 1214: if (drvld) { ! 1215: execl(ofname, ofname, NULL); /* should never return */ ! 1216: fatal("Cannot execute loadable driver '%s'.", ofname); /**/ ! 1217: } ! 1218: #endif ! 1219: return (0); ! 1220: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.