![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / load|
Return to main.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / load |
1.1 ! root 1: /* ld/main.c */ ! 2: ! 3: #include "data.h" ! 4: ! 5: extern char *mktemp(); ! 6: ! 7: main( argc, argv ) ! 8: int argc; ! 9: char *argv[]; ! 10: { ! 11: flag_t dcomm = 0, /* define commons even if reloc out */ ! 12: nosym = 0, /* do not output symbol table */ ! 13: memld = 0, /* do in-memory load */ ! 14: reloc = 0; /* output relocation info */ ! 15: char *ofname = "l.out", ! 16: *entrys = NULL, ! 17: *mfn, ! 18: *lp; ! 19: seg_t *sgp; ! 20: sym_t *sp; ! 21: mod_t *mp; ! 22: FILE *ofp; ! 23: struct stat statbuf; ! 24: int i, segn; ! 25: unsigned int symno; ! 26: fsize_t daddr; ! 27: uaddr_t addr; ! 28: #if BREADBOX ! 29: int abort(); ! 30: #endif ! 31: ! 32: setbuf( stdout, NULL ); ! 33: setbuf( stderr, NULL ); ! 34: ! 35: /* ! 36: * set separate code/data flag (required for 286 protected mode) ! 37: */ ! 38: oldh.l_flag |= LF_SEP; ! 39: ! 40: nmod = mxmsym = mdisk = 0; ! 41: ! 42: if ( argc <= 1 ) ! 43: usage( "no args" ); ! 44: ! 45: /* ! 46: * Pass 1: Scan argument list. ! 47: */ ! 48: for ( i = 1; i < argc; i++ ) { ! 49: ! 50: /* ! 51: * Not -option; attempt to read file ! 52: */ ! 53: if ( *argv[i] != '-' ) { ! 54: if ( !rdfile(argv[i]) ) ! 55: fatal( "can't open %s", argv[i] ); ! 56: } ! 57: ! 58: /* ! 59: * Decode options ! 60: */ ! 61: else switch ( argv[i][1] ) { ! 62: ! 63: default: ! 64: usage( "unknown option %s", argv[i] ); ! 65: continue; ! 66: ! 67: case 'b': ! 68: /* ! 69: * -b: undocumented option ! 70: * big link stores module structs on disk ! 71: */ ! 72: mdisk++; ! 73: ! 74: if ( (mfp = fopen(mfn=mktemp("/tmp/ldXXXXXX"),"wr") ) ! 75: ==NULL) { ! 76: unlink( mfn ); ! 77: fatal( "can't open temp file" ); ! 78: } ! 79: ! 80: mtemp = malloc( sizeof(mod_t) ); ! 81: continue; ! 82: ! 83: case 'd': ! 84: /* ! 85: * -d: Define commons (even if undefined symbols). ! 86: */ ! 87: dcomm++; ! 88: continue; ! 89: ! 90: case 'e': ! 91: /* ! 92: * -e ent: Set entry point to given symbol/octal number. ! 93: */ ! 94: if ( ++i >= argc ) ! 95: usage( "Bad -e option" ); ! 96: ! 97: else { ! 98: undef( argv[i] ); ! 99: entrys = argv[i]; ! 100: } ! 101: continue; ! 102: ! 103: case 'i': ! 104: continue; ! 105: ! 106: case 'k': ! 107: /* ! 108: * -k[sys]: Kernel process - use system symbol table. ! 109: */ ! 110: oldh.l_flag |= LF_KER; ! 111: ! 112: if ( argv[i][2] != '\0' ) ! 113: rdsystem( &argv[i][2] ); ! 114: else ! 115: rdsystem( "/coherent" ); ! 116: continue; ! 117: ! 118: case 'l': ! 119: /* ! 120: * -l<lib>: Use standard library <lib>. ! 121: */ ! 122: lp = malloc( strlen(argv[i])+16 ); ! 123: sprintf( lp, "/lib/lib%s.a", &argv[i][2] ); ! 124: ! 125: if ( rdfile(lp) ) ! 126: ; ! 127: ! 128: else { ! 129: sprintf( lp, "/usr/lib/lib%s.a", &argv[i][2] ); ! 130: if ( rdfile(lp) ) ! 131: ; ! 132: else ! 133: fatal( "can't open lib%s.a", ! 134: &argv[i][2]); ! 135: } ! 136: continue; ! 137: ! 138: case 'm': ! 139: /* ! 140: * -m: Perform in-memory load if possible. ! 141: */ ! 142: memld++; ! 143: continue; ! 144: ! 145: case 'n': ! 146: /* ! 147: * -n: Bind output shared. ! 148: */ ! 149: oldh.l_flag |= LF_SHR; ! 150: #ifdef IAPX86 ! 151: /* ! 152: * Special case, no -n without -i on IBM PC ! 153: */ ! 154: oldh.l_flag |= LF_SEP; ! 155: #endif ! 156: continue; ! 157: ! 158: case 'o': ! 159: /* ! 160: * -o file: Place output in named file (default l.out). ! 161: */ ! 162: if ( ++i >= argc ) ! 163: usage( "bad -o option" ); ! 164: else ! 165: ofname = argv[i]; ! 166: continue; ! 167: ! 168: case 'r': ! 169: /* ! 170: * -r: Retain relocation information. ! 171: */ ! 172: reloc++; ! 173: #ifdef IAPX86 ! 174: /* ! 175: * Special case, -r disables -i. ! 176: */ ! 177: oldh.l_flag &= ~LF_SEP; ! 178: #endif ! 179: continue; ! 180: ! 181: case 's': ! 182: /* ! 183: * -s: Discard symbol table. ! 184: */ ! 185: nosym++; ! 186: continue; ! 187: ! 188: case 'u': ! 189: /* ! 190: * -u sym: Undefine 'sym' (forcing library search). ! 191: */ ! 192: if ( ++i >= argc ) ! 193: usage( "bad -u option" ); ! 194: else ! 195: undef( argv[i] ); ! 196: continue; ! 197: ! 198: case 'w': ! 199: /* ! 200: * -w: Watch everything happen. ! 201: */ ! 202: watch++; ! 203: message( "watch!" ); ! 204: continue; ! 205: ! 206: case 'X': ! 207: /* ! 208: * -X: Discard C internal local symbols. ! 209: */ ! 210: noilcl++; ! 211: continue; ! 212: ! 213: case 'x': ! 214: /* ! 215: * -x: Discard all local symbols. ! 216: */ ! 217: nolcl++; ! 218: continue; ! 219: ! 220: case 'C': ! 221: /* ! 222: * -C: Bind output combined code/data. ! 223: * (otherwise it will be separate code/data as ! 224: * required in 286 protected mode) ! 225: */ ! 226: oldh.l_flag &= ~LF_SEP; ! 227: continue; ! 228: } ! 229: } ! 230: ! 231: if ( oldh.l_machine == 0 ) ! 232: fatal( "no input found" ); ! 233: ! 234: /* ! 235: * all modules have been read ! 236: * resolve meanings of various flags ! 237: */ ! 238: ! 239: /* ! 240: * Relocation or undefined symbols... ! 241: */ ! 242: if ( reloc || nundef ) { ! 243: ! 244: /* ! 245: * Requires symbol table be retained ! 246: */ ! 247: nosym = 0; ! 248: ! 249: if ( oldh.l_flag & LF_SEP ) { ! 250: ! 251: message("link failed, the following symbols are undefined:"); ! 252: ! 253: for ( i = 0; i < NHASH; i++ ) { ! 254: for ( sp=symtable[i]; sp!=NULL; sp=sp->next ) { ! 255: if(sp->s.ls_type==(L_GLOBAL|L_REF) ! 256: && sp->s.ls_addr==0) ! 257: spmsg(sp,""); ! 258: } ! 259: } ! 260: ! 261: if ( nundef ) ! 262: exit( 1 ); ! 263: } ! 264: } ! 265: ! 266: /* ! 267: * No relocation, no undefined symbols ! 268: */ ! 269: else { ! 270: /* ! 271: * Must define commons ! 272: */ ! 273: dcomm++; ! 274: ! 275: /* ! 276: * Discarding reloc info ! 277: */ ! 278: if ( oseg[L_REL].size != 0 ) { ! 279: oldh.l_flag |= LF_NRB; /* make note */ ! 280: oseg[L_REL].size = 0; ! 281: } ! 282: } ! 283: ! 284: /* ! 285: * To define common symbols... ! 286: */ ! 287: if ( dcomm ) ! 288: oseg[L_BSSD].size += commons; /* we need this much room */ ! 289: ! 290: /* ! 291: * Discard symbol table. ! 292: */ ! 293: if ( nosym ) ! 294: oseg[L_SYM].size = 0; ! 295: ! 296: if ( watch ) ! 297: message( "# undefined=%d", nundef ); ! 298: ! 299: /* ! 300: * Set segment bases ! 301: */ ! 302: baseall( oseg, &oldh ); ! 303: ! 304: #ifdef IAPX86 ! 305: if ( oldh.l_machine == M_8086 ) { ! 306: if ( (oseg[L_SHRI].size + ! 307: oseg[L_PRVI].size + ! 308: oseg[L_BSSI].size) >= MAXSEG86 ) ! 309: fatal("FATAL: code segment too large"); ! 310: ! 311: if ( (oseg[L_SHRD].size + ! 312: oseg[L_PRVD].size + ! 313: oseg[L_BSSD].size) >= (MAXSEG86 - DEFSTACK) ) ! 314: fatal("FATAL: data segment too large"); ! 315: ! 316: if ( (oseg[L_SHRD].size + ! 317: oseg[L_PRVD].size + ! 318: oseg[L_BSSD].size) >= (MAXSEG86 - DEFSTACK - WARNSIZE) ) ! 319: message( ! 320: "Warning: data segment may be too large to execute"); ! 321: } ! 322: #endif ! 323: ! 324: /* ! 325: * Open output file ! 326: */ ! 327: if ( ((ofp = fopen(ofname, "w")) == NULL) ! 328: && ((unlink(ofname) != 0) || ((ofp = fopen(ofname, "w")) == NULL)) ) ! 329: fatal( "cannot create %s", ofname ); ! 330: ! 331: stat( ofname, &statbuf ); ! 332: chmod( ofname, statbuf.st_mode & ~(S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6))); ! 333: setbuf( ofp, NULL ); ! 334: ! 335: /* ! 336: * set disk offsets of segments ! 337: * if not bigger than a breadbox, build output file in memory; ! 338: * otherwise, open the file for each segment, ! 339: * to get independent buffering ! 340: */ ! 341: daddr = segoffs( oseg, 0L ); ! 342: ! 343: if ( watch ) ! 344: message( "size: %ld", daddr ); ! 345: ! 346: #if BREADBOX ! 347: if ( memld || (daddr < BREADBOX) ) ! 348: outbuf = malloc( (int) daddr ); ! 349: #endif ! 350: for ( i = 0; i < NLSEG; i++ ) { ! 351: ! 352: if ( (i == L_BSSI) || (i == L_BSSD) ) ! 353: continue; ! 354: ! 355: sgp = &oseg[i]; ! 356: ! 357: if ( sgp->size == 0 ) ! 358: continue; ! 359: ! 360: #if BREADBOX ! 361: if ( outbuf != NULL ) { ! 362: if ( (outputf[i] = malloc(sizeof(FILE))) == NULL ) ! 363: fatal("out of space"); ! 364: ! 365: outputf[i]->_cc = sgp->size; ! 366: outputf[i]->_cp = &outbuf[sgp->daddr]; ! 367: outputf[i]->_pt = &abort; ! 368: } ! 369: else ! 370: #endif ! 371: { ! 372: if ( (outputf[i] = fopen(ofname, "r+w")) == NULL ) ! 373: fatal( "cannot open %s (seg %d)", ofname, i ); ! 374: ! 375: fseek( outputf[i], sgp->daddr, 0 ); ! 376: ! 377: if ( i == L_SHRI ) ! 378: setbuf( outputf[i], pbuf1 ); ! 379: ! 380: if ( i == L_PRVD ) ! 381: setbuf( outputf[i], pbuf2 ); ! 382: } ! 383: } ! 384: ! 385: /* ! 386: * Define internal symbols which have been referenced ! 387: */ ! 388: if ( dcomm ) { ! 389: i = oldh.l_flag & LF_KER; ! 390: endbind( etext_s, L_PRVI, i ); ! 391: endbind( edata_s, L_PRVD, i ); ! 392: endbind( end_s, L_BSSD, i ); ! 393: } ! 394: ! 395: /* ! 396: * Run through symbol table fixing everything up ! 397: */ ! 398: symno = 0; ! 399: for ( i=0; i < NHASH; i++ ) { ! 400: ! 401: for ( sp = symtable[i]; sp != NULL; sp = sp->next ) { ! 402: ! 403: /* ! 404: * Make defined symbol relative to virtual 0 ! 405: */ ! 406: if ( (segn = sp->s.ls_type & ~L_GLOBAL) < L_SYM ) { ! 407: sp->s.ls_addr += oseg[segn].vbase; ! 408: } ! 409: ! 410: else if ( segn == L_SYM ) { ! 411: spmsg( sp, "references symbol segment" ); ! 412: } ! 413: ! 414: /* ! 415: * Leave absolutes alone ! 416: */ ! 417: else if ( sp->s.ls_type != (L_GLOBAL|L_REF) ) { ! 418: ; ! 419: } ! 420: ! 421: /* ! 422: * Undefined global ! 423: */ ! 424: else if ( sp->s.ls_addr == 0 ) { ! 425: if ( ! reloc ) ! 426: spmsg( sp, "undefined" ); ! 427: } ! 428: ! 429: /* ! 430: * Define commons ! 431: */ ! 432: else if ( dcomm ) { ! 433: addr = sp->s.ls_addr; ! 434: sp->s.ls_addr = oseg[L_BSSD].vbase ! 435: +oseg[L_BSSD].size ! 436: -commons; ! 437: commons -= addr; ! 438: sp->s.ls_type = L_GLOBAL | L_BSSD; ! 439: } ! 440: ! 441: /* ! 442: * Assign symbol number ! 443: */ ! 444: sp->symno = symno++; ! 445: ! 446: /* ! 447: * Output to symbol segment ! 448: */ ! 449: if ( ! nosym ) { ! 450: canint( sp->s.ls_type ); ! 451: canvaddr( sp->s.ls_addr ); ! 452: putstruc( &sp->s, sizeof(sp->s), ! 453: outputf[L_SYM], &oseg[L_SYM] ); ! 454: canint( sp->s.ls_type ); ! 455: canvaddr( sp->s.ls_addr ); ! 456: } ! 457: } ! 458: } ! 459: ! 460: /* ! 461: * get entry point (cannot precede symbol table fixup) ! 462: */ ! 463: oldh.l_entry = (entrys != NULL) ! 464: ? lentry(entrys) ! 465: : (oldh.l_flag & LF_KER) ? drvbase[oldh.l_machine] : 0; ! 466: /* ! 467: * Pass 2 ! 468: */ ! 469: if ( mdisk ) { ! 470: ! 471: free( mtemp ); ! 472: ! 473: if ((mp=malloc(sizeof(mod_t)+ mxmsym*sizeof(sym_t *))) == NULL) ! 474: fatal("out of space - M"); ! 475: ! 476: rewind( mfp ); ! 477: ! 478: for ( i = 0; i < nmod; i++ ) { ! 479: ! 480: if ( fread( mp, sizeof(mod_t), 1 ,mfp ) != 1 ) ! 481: baddisk: fatal( "disk error" ); ! 482: ! 483: if ( fread( mp->sym, sizeof(sym_t *), mp->nsym, mfp ) ! 484: != mp->nsym) ! 485: goto baddisk; ! 486: ! 487: loadmod( mp ); ! 488: } ! 489: ! 490: unlink( mfn ); ! 491: } ! 492: ! 493: else { ! 494: for ( mp = modhead; mp != NULL; mp = mp->next ) ! 495: loadmod( mp ); ! 496: } ! 497: ! 498: /* ! 499: * All over but the flushing ! 500: */ ! 501: canint( oldh.l_magic ); ! 502: canint( oldh.l_flag ); ! 503: canint( oldh.l_machine ); ! 504: canvaddr( oldh.l_entry ); ! 505: ! 506: for ( i = 0; i < NLSEG; i++ ) { ! 507: oldh.l_ssize[i] = oseg[i].size; ! 508: cansize(oldh.l_ssize[i]); ! 509: } ! 510: ! 511: if ( outbuf == NULL ) ! 512: fwrite(&oldh, sizeof(oldh), 1, ofp); ! 513: ! 514: else { ! 515: for ( i = 0; i < sizeof(oldh); i++ ) ! 516: outbuf[i] = *((char *)&oldh + i); ! 517: fwrite( outbuf, 1, (int)daddr, ofp ); ! 518: } ! 519: ! 520: /* ! 521: * Make executable if no undefined symbols, and common storage defined. ! 522: */ ! 523: if ( (nundef == 0) || (dcomm != 0) ) { ! 524: chmod(ofname, statbuf.st_mode|S_IEXEC|(S_IEXEC>>3)|(S_IEXEC>>6)); ! 525: return( 0 ); ! 526: } ! 527: ! 528: /* ! 529: * Supposed to be left relocatable. ! 530: */ ! 531: else if ( reloc ) ! 532: return( 0 ); ! 533: ! 534: /* ! 535: * Undefined symbols left. ! 536: */ ! 537: else ! 538: return( nundef ); ! 539: } ! 540: ! 541: /* ! 542: * Set virtual bases in array of segments ! 543: * according to flags in header. ! 544: */ ! 545: void ! 546: baseall( sega, ldhp ) ! 547: register seg_t sega[]; ! 548: register ldh_t *ldhp; ! 549: { ! 550: register uaddr_t addr; ! 551: ! 552: addr = (ldhp->l_flag & LF_KER) ? drvbase[ldhp->l_machine] : 0; ! 553: ! 554: /* ! 555: * Shared code segment first. ! 556: */ ! 557: addr = setbase( &sega[L_SHRI], ldhp, addr ); ! 558: ! 559: /* ! 560: * Shared data segment next if shared but not separate. ! 561: */ ! 562: if ( (ldhp->l_flag & (LF_SHR|LF_SEP)) == LF_SHR ) ! 563: addr = setbase( &sega[L_SHRD], ldhp, addr ); ! 564: ! 565: /* ! 566: * Round up to page boundary if shared. ! 567: */ ! 568: if ( ldhp->l_flag & LF_SHR ) ! 569: addr = newpage(ldhp, addr); ! 570: ! 571: /* ! 572: * Private code segment next. ! 573: */ ! 574: addr = setbase( &sega[L_PRVI], ldhp, addr ); ! 575: ! 576: /* ! 577: * Private data segment next if shared but not separate. ! 578: */ ! 579: if ( (ldhp->l_flag & (LF_SHR|LF_SEP)) == LF_SHR ) ! 580: addr = setbase( &sega[L_PRVD], ldhp, addr ); ! 581: ! 582: /* ! 583: * Uninitialized code segment next. ! 584: */ ! 585: addr = setbase( &sega[L_BSSI], ldhp, addr ); ! 586: ! 587: /* ! 588: * Set data offset if separate code/data. ! 589: */ ! 590: if ( ldhp->l_flag & LF_SEP ) ! 591: addr = (ldhp->l_flag & LF_KER) ? drvbase[ldhp->l_machine] : 0; ! 592: ! 593: /* ! 594: * Shared data segment next if not shared. ! 595: */ ! 596: if ( (ldhp->l_flag & (LF_SHR|LF_SEP)) != LF_SHR ) ! 597: addr = setbase( &sega[L_SHRD], ldhp, addr ); ! 598: ! 599: /* ! 600: * Round up to page boundary if shared and separate. ! 601: */ ! 602: if ( (ldhp->l_flag & (LF_SHR|LF_SEP)) == (LF_SHR|LF_SEP) ) ! 603: addr = newpage( ldhp, addr ); ! 604: ! 605: /* ! 606: * Private data segment next unless shared and not separate. ! 607: */ ! 608: if ( (ldhp->l_flag & (LF_SHR|LF_SEP)) != LF_SHR ) ! 609: addr = setbase( &sega[L_PRVD], ldhp, addr ); ! 610: ! 611: /* ! 612: * Uninitialized data segment next. ! 613: */ ! 614: setbase( &sega[L_BSSD], ldhp, addr ); ! 615: } ! 616: ! 617: /* ! 618: * Set virtual base in given segment and return next address ! 619: * Check for wraparound and driver space overflow ! 620: */ ! 621: uaddr_t ! 622: setbase( segp, ldhp, addr ) ! 623: register seg_t *segp; ! 624: register ldh_t *ldhp; ! 625: register uaddr_t addr; ! 626: { ! 627: segp->vbase = addr; ! 628: addr += segp->size; ! 629: ! 630: /* ! 631: * Address wrap-around. ! 632: */ ! 633: if ( addr < segp->vbase ) { ! 634: fatal("address wraparound"); ! 635: } ! 636: ! 637: /* ! 638: * User process. ! 639: */ ! 640: else if ( ! (ldhp->l_flag & LF_KER) ) { ! 641: ; ! 642: } ! 643: ! 644: /* ! 645: * Invalid kernel process. ! 646: */ ! 647: else if (addr > drvtop[ldhp->l_machine]) { ! 648: fatal("driver larger than %dKb", ! 649: (drvtop[ldhp->l_machine] ! 650: -drvbase[ldhp->l_machine])/1024); ! 651: } ! 652: ! 653: return (addr); ! 654: } ! 655: ! 656: /* ! 657: * Set segment disk offsets, given sizes ! 658: * return size of module ! 659: */ ! 660: fsize_t ! 661: segoffs(sega, offs) ! 662: seg_t sega[]; ! 663: register fsize_t offs; ! 664: { ! 665: register seg_t *sgp; ! 666: ! 667: offs += sizeof(ldh_t); ! 668: ! 669: for ( sgp = &sega[0]; sgp < &sega[NLSEG]; sgp++ ) { ! 670: ! 671: /* ! 672: * Uninitialized code/data do not affect module size. ! 673: */ ! 674: if ( (sgp == &sega[L_BSSI]) || (sgp == &sega[L_BSSD]) ) ! 675: continue; ! 676: ! 677: /* ! 678: * Record segment address. ! 679: * Calculate module size. ! 680: */ ! 681: else { ! 682: sgp->daddr = offs; ! 683: offs += sgp->size; ! 684: } ! 685: } ! 686: ! 687: /* ! 688: * Return module size. ! 689: */ ! 690: return (offs); ! 691: } ! 692: ! 693: /* ! 694: * Bump address to next hardware segment boundary ! 695: */ ! 696: uaddr_t ! 697: newpage( ldhp, addr ) ! 698: ldh_t *ldhp; ! 699: uaddr_t addr; ! 700: { ! 701: register uaddr_t inc = segsize[ldhp->l_machine]-1; ! 702: ! 703: return ((addr+inc)&~inc); ! 704: } ! 705: ! 706: /* ! 707: * Determine entry point; either octal address or symbol name. ! 708: */ ! 709: uaddr_t ! 710: lentry(str) ! 711: char *str; ! 712: { ! 713: char id[NCPLN], *s = &id[0]; ! 714: uaddr_t oaddr=0; ! 715: int notoct=0; ! 716: register sym_t *sp; ! 717: ! 718: /* ! 719: * Scan string. ! 720: */ ! 721: for ( ; *str; str++ ) { ! 722: ! 723: if ( s < &id[NCPLN] ) ! 724: *s++ = *str; ! 725: ! 726: /* ! 727: * Accumulate octal digits. ! 728: */ ! 729: if ( ('0' <= *str) && (*str <= '7') ) ! 730: oaddr = oaddr*8 + *str - '0'; ! 731: ! 732: /* ! 733: * Not an octal digit. ! 734: */ ! 735: else ! 736: ++notoct; ! 737: } ! 738: ! 739: /* ! 740: * Octal string: return numeric value. ! 741: */ ! 742: if (!notoct) ! 743: return (oaddr); ! 744: ! 745: /* ! 746: * Extend string with nulls. ! 747: */ ! 748: while ( s < &id[NCPLN] ) ! 749: *s++ = 0; ! 750: ! 751: /* ! 752: * Search for string in symbol table. ! 753: */ ! 754: for ( sp = symtable[hash(id)]; sp != NULL; sp = sp->next ) { ! 755: if ( (sp->s.ls_type & L_GLOBAL) ! 756: && (sp->s.ls_type != (L_GLOBAL|L_REF)) ! 757: && eq(sp->s.ls_id, id) ) ! 758: return( sp->s.ls_addr ); ! 759: } ! 760: ! 761: /* ! 762: * Symbol not found. ! 763: */ ! 764: message("entry point %.*s undefined", NCPLN, id); ! 765: return (0); ! 766: } ! 767: ! 768: /* ! 769: * Define referenced internal symbol (as end of given segment) ! 770: */ ! 771: void ! 772: endbind( sp, sn, ldrv ) ! 773: register sym_t *sp; ! 774: int sn, ldrv; ! 775: { ! 776: if ( sp == NULL ) { ! 777: return; ! 778: } ! 779: ! 780: else if ((sp->s.ls_type == (L_GLOBAL|L_REF)) && (sp->s.ls_addr == 0)) { ! 781: sp->s.ls_type = L_GLOBAL|sn; ! 782: sp->s.ls_addr = oseg[sn].size; ! 783: } ! 784: ! 785: else if ( ldrv ) { ! 786: return; ! 787: } ! 788: ! 789: else { ! 790: spmsg(sp, "redefines builtin"); ! 791: } ! 792: } ! 793: ! 794: /* ! 795: * Add reference to symbol table ! 796: */ ! 797: void ! 798: undef( s ) ! 799: char * s; ! 800: { ! 801: lds_t lds; ! 802: int i; ! 803: ! 804: /* ! 805: * Copy reference, extending with NULL. ! 806: */ ! 807: for ( i = 0; i < NCPLN; i++ ) { ! 808: lds.ls_id[i] = *s; ! 809: if ( *s != '\0' ) ! 810: s++; ! 811: } ! 812: ! 813: /* ! 814: * Define symbol as global reference. ! 815: */ ! 816: lds.ls_type = L_GLOBAL|L_REF; ! 817: lds.ls_addr = 0; ! 818: ! 819: /* ! 820: * Add [undefined] to symbol table. ! 821: */ ! 822: addsym(&lds, NULL); ! 823: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.