![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / ld|
Return to tv.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 ! root 1: static char ID[] = "@(#) tv.c: 1.15 5/1/83"; ! 2: ! 3: #include <stdio.h> ! 4: ! 5: #include "system.h" ! 6: ! 7: #if TS || RT ! 8: #include <ar.h> ! 9: #else ! 10: #include <archive.h> ! 11: #endif ! 12: ! 13: #include "reloc.h" ! 14: #include "sdpsrc/hd/define2.h" ! 15: #include "structs.h" ! 16: #include "tv.h" ! 17: #include "ldtv.h" ! 18: #include "ldfcn.h" ! 19: #include "extrns.h" ! 20: #include "list.h" ! 21: #include "sgsmacros.h" ! 22: #include "bool.h" ! 23: #include "ldmacros.h" ! 24: ! 25: static FILE *tvstream = NULL; ! 26: #if AR16WR ! 27: static char *tvbuf; ! 28: #endif ! 29: static FILE *tvread = NULL; ! 30: static int tvnxt; /* next available tv slot */ ! 31: long gettvnxt(); /* finds next usable slot */ ! 32: /*eject*/ ! 33: tvspecdef() ! 34: { ! 35: #if TRVEC ! 36: /* ! 37: * Complete definition of tvspec ! 38: * called just after reading transfer file ! 39: */ ! 40: ! 41: register unsigned spare; ! 42: ! 43: #if !ONEPROC ! 44: tvspec.tvinflnm = (char *) ((int) tvspec.tvinflnm + (int) strbase); ! 45: #endif ! 46: spare = (unsigned) tvspec.tvosptr; ! 47: tvspec.tvosptr = (OUTSECT *) myalloc(sizeof(OUTSECT)); ! 48: tvspec.tvosptr->oshdr.s_size = ((long) spare) * TVENTSZ; ! 49: if ( aflag ) { ! 50: /* ! 51: * Define the Output Section which will be used to ! 52: * contain the tv ! 53: */ ! 54: tvspec.tvosptr->osflags = FILL; ! 55: tvspec.tvosptr->osalign = 16; ! 56: copy(tvspec.tvosptr->oshdr.s_name, _TV, 8); ! 57: tvspec.tvosptr->oshdr.s_paddr = -1L; /*none given */ ! 58: if (tvspec.tvrange[0]==0) /* leave slot 0 empty */ ! 59: tvspec.tvosptr->oshdr.s_size += TVENTSZ; ! 60: } ! 61: ! 62: #endif ! 63: } ! 64: ! 65: #if TRVEC ! 66: tvreloc() ! 67: { ! 68: ! 69: register INSECT *sptr; ! 70: register int numreloc; /* nbr of relocation entries */ ! 71: register SYMTAB *pglob; /* ptr to ld symbol entry */ ! 72: AUXTAB *paux; /* ptr to auxillary entry */ ! 73: AUXENT aux; /* auxillary entry */ ! 74: SYMENT lsym; /* local symbol table entry */ ! 75: SCNHDR shdr; /* section header */ ! 76: RELOC rentry; /* local relocation entry */ ! 77: LDFILE *rfd,rfdbuf, *ifd, ifdbuf; ! 78: INFILE *infl, *pnfl; ! 79: char *symname; ! 80: ! 81: /* ! 82: * the functions in DMERT's shared libraries have 0 in the tvndx ! 83: * field. To insure that all functions needing tv slots have P_TV ! 84: * in the tvndx field, scan all relocation entries for references ! 85: * to functions in shared libraries. ! 86: */ ! 87: ! 88: rfd = &rfdbuf; ! 89: ifd = &ifdbuf; ! 90: IOPTR(ifd) = NULL; ! 91: pnfl = NULL; ! 92: infl = (INFILE *)infilist.head; ! 93: while (infl != NULL) { ! 94: ! 95: OFFSET(ifd) = OFFSET(rfd) = infl->flfiloff; ! 96: if ( IOPTR(ifd) == NULL) { ! 97: if ((IOPTR(ifd) = fopen(infl->flname, "r")) == NULL || ! 98: (IOPTR(rfd) = fopen(infl->flname, "r")) == NULL ) ! 99: lderror(2,0,NULL, "Can't open %s", infl->flname); ! 100: if (infl->flfiloff == 0L) ! 101: TYPE(ifd) = TYPE(rfd) = 0; ! 102: else ! 103: TYPE(ifd) = TYPE(rfd) = USH_ARTYPE; ! 104: } ! 105: if (TYPE(ifd) == ARTYPE) { ! 106: if (FSEEK(ifd, 0L, BEGINNING) != OKFSEEK) ! 107: lderror(2,0,NULL, "internal error: fail to seek to the member of %s", ! 108: infl->flname); ! 109: } ! 110: if (FREAD(&(HEADER(ifd)),FILHSZ,1,ifd) != 1 ) ! 111: lderror(2,0,NULL, "fail to read file header of %s", infl->flname); ! 112: if (HEADER(ifd).f_flags & F_RELFLG) { ! 113: pnfl = infl; ! 114: infl = infl->flnext; ! 115: continue; ! 116: } ! 117: ! 118: HEADER(rfd) = HEADER(ifd); ! 119: ! 120: for( sptr = infl->flishead; sptr != NULL; sptr = sptr->isnext ) { ! 121: if( (numreloc = sptr->ishdr.s_nreloc) > 0 ) { ! 122: if (FSEEK(rfd,(long) (FILHSZ+HEADER(rfd).f_opthdr+ ! 123: (sptr->isecnum-1) * SCNHSZ),BEGINNING) != OKFSEEK || ! 124: FREAD(&shdr,SCNHSZ,1,rfd) != 1 || ! 125: FSEEK(rfd,shdr.s_relptr,BEGINNING) != OKFSEEK) { ! 126: lderror(1,0,NULL, "Seek to relocation entries for section %.8s in file %s failed", ! 127: sptr->ishdr.s_name, infl->flname); ! 128: numreloc = 0; ! 129: } ! 130: } ! 131: while( numreloc-- ) { ! 132: if (fread(&rentry, RELSZ, 1, IOPTR(rfd)) != 1) ! 133: lderror(2,0,NULL,"fail to read reloc entries of file %s", ! 134: infl->flname); ! 135: if( ! (ISTVRELOC(rentry.r_type)) ) ! 136: continue; ! 137: if (FSEEK(ifd,HEADER(ifd).f_symptr+ ! 138: rentry.r_symndx * SYMESZ,BEGINNING) != OKFSEEK || ! 139: FREAD(&lsym,SYMESZ,1,ifd) != 1) ! 140: lderror(2,0,NULL,"fail to read symtb entry %ld of file %s", ! 141: rentry.r_symndx,infl->flname); ! 142: if ( lsym.n_sclass != C_EXT ) ! 143: continue; /* ignore statics */ ! 144: ! 145: symname = SYMNAME( lsym ); ! 146: pglob = findsym( symname ); ! 147: ! 148: if ( pglob->sment.n_scnum > 0) { ! 149: if( pglob->sment.n_numaux > 0 ) { ! 150: paux = getaux(pglob->smauxid); ! 151: if (paux->axent.x_sym.x_tvndx == 0) { ! 152: paux->axent.x_sym.x_tvndx = P_TV; ! 153: tvspec.tvosptr->oshdr.s_size += TVENTSZ; ! 154: PUTAUX(paux, 1); ! 155: } ! 156: else ! 157: PUTAUX(paux, 0); ! 158: PUTSYM( pglob, 0 ); ! 159: } else { ! 160: zero(&aux, AUXESZ); ! 161: aux.x_sym.x_tvndx = P_TV; ! 162: tvspec.tvosptr->oshdr.s_size += TVENTSZ; ! 163: putaux( makeaux(pglob, &aux, 0), 1); ! 164: PUTSYM( pglob, 1 ); ! 165: } ! 166: ! 167: } else ! 168: PUTSYM( pglob, 0 ); ! 169: } ! 170: } ! 171: ! 172: pnfl = infl; ! 173: infl = infl->flnext; ! 174: ! 175: /* see if next input is from the same archive */ ! 176: if ((pnfl->flfiloff > 0L) && (infl != NULL)) ! 177: if (strcmp(pnfl->flname, infl->flname) == 0 && ! 178: (pnfl->flfiloff < infl->flfiloff)) ! 179: continue; ! 180: ! 181: fclose(IOPTR(ifd)); ! 182: fclose(IOPTR(rfd)); ! 183: IOPTR(ifd) = NULL; ! 184: } ! 185: ! 186: } ! 187: #endif ! 188: ! 189: ! 190: ! 191: tvupdat() ! 192: { ! 193: #if TRVEC ! 194: /* ! 195: * If _TV section is not user-defined but needs to ! 196: * be, add it to the list of output sections ! 197: * ! 198: * Check if _TV section needs to be bonded. If so, add it to ! 199: * the bondlist ! 200: */ ! 201: ! 202: OUTSECT *osptr; ! 203: ! 204: if ( (osptr = fndoutsec(_TV)) != NULL ) { ! 205: ++usrdeftv; ! 206: /* redo work done in tvspecdef() */ ! 207: free( tvspec.tvosptr ); ! 208: tvspec.tvosptr = osptr; ! 209: tvspec.tvosptr->osflags = FILL; ! 210: tvspec.tvosptr->osalign = 16; ! 211: tvspec.tvosptr->oshdr.s_paddr = -1L; ! 212: } else { ! 213: /* ! 214: * User defined no .tv output section but .tv ! 215: * input sections may be present ! 216: */ ! 217: if ( ! aflag ) ! 218: return; ! 219: if ( usrdeftv ) /* there are .tv input sections */ ! 220: if ( tvspec.tvrange[0] == 0 ) ! 221: tvspec.tvosptr->oshdr.s_size -= TVENTSZ; ! 222: ++numoutsc; ! 223: listadd(l_OS, &outsclst, tvspec.tvosptr); ! 224: ! 225: if( tvspec.tvbndadr != -1L ) { ! 226: register ACTITEM *aptr; ! 227: ! 228: aptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 229: aptr->bond.aitype = AIBOND; ! 230: aptr->bond.aiinflnm = tvspec.tvinflnm; ! 231: aptr->bond.aiinlnno = tvspec.tvinlnno; ! 232: aptr->bond.aioutsec = tvspec.tvosptr; ! 233: aptr->bond.aiadrbnd = tvspec.tvbndadr; ! 234: listadd(l_AI, &bondlist, aptr); ! 235: } ! 236: } ! 237: #endif ! 238: } ! 239: /*eject*/ ! 240: tvupdt2() ! 241: { ! 242: #if TRVEC ! 243: OUTSECT *osptr; ! 244: long *lptr; ! 245: ! 246: if ( usrdeftv ) { ! 247: osptr = fndoutsec(_TV); ! 248: /* ! 249: * Assume RANGE(0,N) ! 250: */ ! 251: tvspec.tvlength = osptr->oshdr.s_size / TVENTSZ; ! 252: if ( tvspec.tvrange[1] == 0 ) /* no RANGE directive */ ! 253: tvspec.tvrange[1] = tvspec.tvlength - 1; ! 254: } else { ! 255: /* ! 256: * Make sure that TV directive is adequate ! 257: * and fill in missing spaces ! 258: */ ! 259: ! 260: lptr = &tvspec.tvosptr->oshdr.s_size; ! 261: if ((tvspec.tvrange[1]!=0) ! 262: &&((long)((tvspec.tvrange[1]-tvspec.tvrange[0]+(tvspec.tvrange[0]? 1 : 2))*TVENTSZ)<*lptr)) ! 263: lderror(2,0,tvspec.tvinflnm, "tv range allows %d entries; %d needed", ! 264: tvspec.tvrange[1]-tvspec.tvrange[0]+1, ! 265: (int) (*lptr/TVENTSZ)); ! 266: if( (((long) tvspec.tvlength) * TVENTSZ) >= *lptr ) ! 267: *lptr = ((long) tvspec.tvlength) * TVENTSZ; ! 268: else if( tvspec.tvlength == 0 ) ! 269: tvspec.tvlength = *lptr / TVENTSZ; ! 270: else ! 271: lderror(1,0,NULL, "tv needs %ld entries; only %d allowed", ! 272: *lptr/TVENTSZ, tvspec.tvlength); ! 273: if (tvspec.tvrange[1] == 0) ! 274: tvspec.tvrange[1] = tvspec.tvlength - 1; ! 275: } ! 276: #endif ! 277: } ! 278: /*eject*/ ! 279: tvinit() ! 280: { ! 281: #if TRVEC ! 282: ! 283: /* ! 284: * Initialize for writing the transfer vector ! 285: */ ! 286: ! 287: register SYMTAB *pglob; ! 288: register AUXTAB *paux; ! 289: register int indx; ! 290: SCNHDR *psect; ! 291: TVENTRY outslot; ! 292: AUXENT aux; ! 293: long offset; /* where to write slot */ ! 294: int changed; ! 295: ! 296: ! 297: if( (tvstream = fopen(outfilnm, "r+")) == NULL ) ! 298: lderror(2,0,NULL, "can't open %s to write the tv", ! 299: outfilnm); ! 300: #if AR16WR ! 301: tvbuf = myalloc( BUFSIZ ); ! 302: setbuf( tvstream, tvbuf ); ! 303: #endif ! 304: ! 305: fseek(tvstream, tvspec.tvosptr->oshdr.s_scnptr, 0); ! 306: for ( indx = tvspec.tvrange[0]; indx <= tvspec.tvrange[1]; ++indx) ! 307: fwrite(&tvspec.tvfill, TVENTSZ, 1, tvstream); ! 308: ! 309: /* ! 310: * For each tv slot assignment directive, write out that slot ! 311: * if it is legal and update the ld symbol table appropriately. ! 312: * ! 313: * TV slot assignment directives are of the form "func=n" where ! 314: * func is a function name and n is a transfer vector index. Another ! 315: * directive specifies a RANGE for the current load, meaning that ! 316: * all functions defined in this load are to be assigned slots within ! 317: * the given range. Slot assignment directives for functions outside ! 318: * the given range are for use in resolving references to functions ! 319: * defined in another subsystem. Ld depends on the veracity and ! 320: * competence of the user to insure that this is, after all, the ! 321: * slot index assigned to this function in another subsystem load. ! 322: * ! 323: * Certain conditions result in errors. ! 324: * 1) If the user specifies a LENGTH for the total transfer vector, ! 325: * a) if more slots are required than the given LENGTH allows, ! 326: * or b) if an ASSIGN directive is issued which lies beyond the ! 327: * specified LENGTH ! 328: * then ERROR ! 329: * 2) If the user ASSIGNs a slot S to a function which is undefined ! 330: * in the current load, then ! 331: * if R1 <= S <= R2 ! 332: * then ERROR ! 333: * {where R1 is n in the directive RANGE(n,m) or 0; ! 334: * R2 is m in the directive RANGE(n,m) or LENGTH; } ! 335: * 3) If the user ASSIGNs a slot to a function which is defined ! 336: * in the current load, then ! 337: * if NOT R1 <= S <= R2 ! 338: * then ERROR ! 339: * ! 340: * Otherwise the assigned function slot is either used to update ! 341: * the ld symbol table and/or written to the a.out file or, if the ! 342: * assigned function is unreferenced in the current load, ignored. ! 343: */ ! 344: ! 345: #if ONEPROC ! 346: while (tvslot1) { ! 347: #else ! 348: tvslot1 = (TVASSIGN *) myalloc(sizeof(TVASSIGN)); ! 349: ! 350: while( tvslotcnt-- ) { ! 351: fread( tvslot1, sizeof(TVASSIGN), 1, trnfdes); ! 352: #endif ! 353: ! 354: /* ! 355: * If the symbol has never been referenced, ignore ! 356: * the ASSIGN command ! 357: */ ! 358: if( (pglob = findsym(tvslot1->funname)) == NULL ) { ! 359: #if ONEPROC ! 360: tvslot1 = tvslot1->nxtslot; ! 361: #endif ! 362: continue; ! 363: } ! 364: ! 365: changed = 0; ! 366: if( pglob->sment.n_scnum == 0 ) { ! 367: /* ! 368: * The symbol is referenced but not defined ! 369: */ ! 370: if( (tvslot1->slot >= tvspec.tvrange[0]) && ! 371: (tvslot1->slot <= tvspec.tvrange[1]) ) { ! 372: PUTSYM(pglob, 0); ! 373: lderror(2,0,tvspec.tvinflnm, ! 374: "Undefined symbol assigned a tv slot within tv range"); ! 375: } ! 376: else { ! 377: if( pglob->sment.n_numaux == 0 ) { ! 378: zero(&aux, AUXESZ); ! 379: paux = makeaux(pglob, &aux, 0); ! 380: changed = 1; ! 381: } else { ! 382: paux = getaux(pglob->smauxid); ! 383: } ! 384: paux->axent.x_sym.x_tvndx = P_TV; ! 385: PUTAUX(paux, 1); ! 386: } ! 387: } ! 388: else { ! 389: /* ! 390: * The symbol is defined ! 391: */ ! 392: if( (tvslot1->slot < tvspec.tvrange[0]) || ! 393: (tvslot1->slot > tvspec.tvrange[1]) ) { ! 394: PUTSYM(pglob, 0); ! 395: lderror(2,0,tvspec.tvinflnm, ! 396: "Defined symbol assigned a tv slot outside tv range"); ! 397: } ! 398: } ! 399: ! 400: /* ! 401: * Update ld symbol table aux entry ! 402: */ ! 403: ! 404: if (pglob->sment.n_numaux <= 0) { ! 405: if (pglob->sment.n_type == 0) { ! 406: zero( &aux, AUXESZ ); ! 407: paux = makeaux(pglob, &aux, 0); ! 408: changed = 1; ! 409: paux->axent.x_sym.x_tvndx = N_TV; ! 410: } else ! 411: lderror(2,0,tvspec.tvinflnm, ! 412: "attempt to assign tv slot to illegal symbol"); ! 413: } else ! 414: paux = getaux(pglob->smauxid); ! 415: /* ! 416: * If a function has been defined but never referenced ! 417: * through a tv, then the tvndx is still N_TV, not P_TV ! 418: * thus we need to test for both as the user may be ! 419: * defining the function for use in another subsystem ! 420: * and this code would otherwise generate an error message ! 421: */ ! 422: if( paux->axent.x_sym.x_tvndx != P_TV && paux->axent.x_sym.x_tvndx != N_TV ) { ! 423: PUTAUX(paux,0); ! 424: PUTSYM(pglob, changed); ! 425: lderror(2,0,tvspec.tvinflnm, ! 426: "Two tv slot assignments for function %.8s: %d and %d", ! 427: SYMNAME( pglob->sment ), ! 428: paux->axent.x_sym.x_tvndx, ! 429: tvslot1->slot); ! 430: } else { ! 431: paux->axent.x_sym.x_tvndx = tvslot1->slot; ! 432: PUTAUX(paux, 1); ! 433: } ! 434: ! 435: /* ! 436: * Determine if it is necessary to actually write the ! 437: * tv slot to the output file: does the slot fall ! 438: * within the specified tv range ! 439: */ ! 440: ! 441: if( (tvslot1->slot < tvspec.tvrange[0]) || ! 442: (tvslot1->slot > tvspec.tvrange[1]) ) { ! 443: PUTSYM(pglob, changed); ! 444: #if ONEPROC ! 445: tvslot1 = tvslot1->nxtslot; ! 446: #endif ! 447: continue; ! 448: } ! 449: ! 450: offset = (long) (tvspec.tvosptr->oshdr.s_scnptr + (TVENTSZ * ! 451: (tvslot1->slot - tvspec.tvrange[0]))); ! 452: fseek(tvstream, offset-ftell(tvstream), 1); ! 453: ! 454: setslot(pglob, psect, &outslot); ! 455: ! 456: PUTSYM(pglob, changed); ! 457: fwrite(&outslot, TVENTSZ, 1, tvstream); ! 458: #if ONEPROC ! 459: tvslot1 = tvslot1->nxtslot; ! 460: #endif ! 461: } ! 462: ! 463: fflush(tvstream); ! 464: ! 465: /* ! 466: * Don't use slot 0 as it is illegal in C to have any ! 467: * type of valid pointer with a zero value ! 468: */ ! 469: ! 470: tvnxt = (tvspec.tvrange[0] != 0) ? tvspec.tvrange[0] : 1; ! 471: ! 472: /* ! 473: * Position tv file pointers: ! 474: * tvstream : start of the tv (range) ! 475: * tvread : start of first legal tv slot ! 476: */ ! 477: if( (tvread=fopen(outfilnm,"r")) == NULL ) ! 478: lderror(2,0,NULL,"Cannot open %s to read tv",outfilnm); ! 479: fseek(tvstream, tvspec.tvosptr->oshdr.s_scnptr, 0); ! 480: fseek(tvread, ((long)(tvspec.tvosptr->oshdr.s_scnptr + ! 481: (tvspec.tvrange[0] ? 0 : TVENTSZ))), 0); ! 482: ! 483: return; ! 484: ! 485: #endif ! 486: } ! 487: /*eject*/ ! 488: tvslot(pglob, psym, infile, cs) ! 489: SYMTAB *pglob; /* symbol is in ld symbol table entry */ ! 490: struct syment *psym; /* symtab entry is from input file */ ! 491: FILE *infile; /* input file stream */ ! 492: unsigned short cs; /* segment value; used only for psym */ ! 493: { ! 494: ! 495: /* ! 496: * Check whether the given symbol needs a slot ! 497: * in the tv. If it does and one has not be assigned, ! 498: * assign the symbol a slot and write that entry to the ! 499: * tv in the output file ! 500: * ! 501: * The symbol is passed in either a gsym or syment symbol table ! 502: * entry data structure. For a gsym, look in the aux entry; for a ! 503: * syment, read the next syment from the input file. ! 504: * In the latter case, reseek the input file pointer to the original ! 505: * position ! 506: * ! 507: * The return value is: ! 508: * ! 509: * -1 symbol doesn't need tv slot ! 510: * 0 symbol needs tv slot, but this is ! 511: * not an absolute load ! 512: * >0 tv slot needed and assigned ! 513: */ ! 514: ! 515: int ret; ! 516: long offset; /* where to write next */ ! 517: AUXTAB *paux; ! 518: TVENTRY tvent; ! 519: AUXENT aux; ! 520: ! 521: if( ! tvflag ) ! 522: return ( -1 ); ! 523: ! 524: #if TRVEC ! 525: if( pglob != NULL ) ! 526: psym = &pglob->sment; ! 527: ! 528: /* ! 529: * We are assured that all symbols needing tv slots have already ! 530: * been detected in loadobjf() and their tvndx set to P_TV. ! 531: * Except for static functions which are detected in psymtab ! 532: * but their tvndx left at N_TV ! 533: */ ! 534: ! 535: if( psym->n_numaux == 0 ) ! 536: return ( -1 ); ! 537: ! 538: if( pglob != NULL ) { ! 539: /* ! 540: * This routine was given an ld symbol table entry ! 541: */ ! 542: paux = getaux(pglob->smauxid); ! 543: if (paux->axent.x_sym.x_tvndx == 0 ) { ! 544: PUTAUX(paux, 0); ! 545: return ( -1 ); ! 546: } ! 547: if( paux->axent.x_sym.x_tvndx == P_TV ) { ! 548: /* ! 549: * This symbol is referenced through a tv: ! 550: * ! 551: * tvndx == P_TV ! 552: */ ! 553: if( ! aflag ) { ! 554: PUTAUX(paux, 0); ! 555: return ( 0 ); ! 556: } ! 557: if( pglob->smscnptr != NULL ) { ! 558: ! 559: slotassign(&tvent, pglob, &cs); ! 560: ! 561: } ! 562: else { ! 563: /* ! 564: * tv ref to undefined symbol ! 565: */ ! 566: PUTAUX(paux, 0); ! 567: return( -1 ); ! 568: } ! 569: if ( (offset = gettvnxt()) == 0L) ! 570: lderror(2,0,NULL,"Internal error: out of tv slots"); ! 571: fseek(tvstream, offset-ftell(tvstream), 1); ! 572: paux->axent.x_sym.x_tvndx = tvnxt; ! 573: PUTAUX(paux, 1); ! 574: } ! 575: else { ! 576: if( paux->axent.x_sym.x_tvndx == N_TV ) ! 577: ret = 0; ! 578: else ! 579: /* ! 580: * The symbol already has a tv assigned: ! 581: * ! 582: * tvndx > 0 ! 583: */ ! 584: ret = paux->axent.x_sym.x_tvndx; ! 585: PUTAUX(paux, 0); ! 586: return ( ret ); ! 587: } ! 588: } ! 589: else { ! 590: /* ! 591: * This routine was given an input symbol table entry ! 592: */ ! 593: fread(&aux, AUXESZ, 1, infile); ! 594: fseek(infile, (long) -AUXESZ, 1); ! 595: if( aux.x_sym.x_tvndx != N_TV ) ! 596: return ( -1 ); ! 597: if( ! aflag ) ! 598: return ( 0 ); ! 599: if ( (offset = gettvnxt()) == 0L) ! 600: lderror(2,0,NULL,"Internal error: out of tv slots"); ! 601: fseek(tvstream, offset-ftell(tvstream), 1); ! 602: ! 603: settventry(&tvent, psym, &cs); ! 604: } ! 605: ! 606: fwrite(&tvent, TVENTSZ, 1, tvstream); ! 607: ! 608: return ( tvnxt++ ); ! 609: ! 610: #endif ! 611: } ! 612: /*eject*/ ! 613: long ! 614: gettvnxt() ! 615: { ! 616: #if TRVEC ! 617: ! 618: /* ! 619: * This routine is called only when it is certain that we need to write ! 620: * out a tv entry. tvinit() has written assigned slots and filled all ! 621: * empty slots with 0. The first time this routine is called tvnxt equals ! 622: * tvspec.tvrange[0], tvread is open for reading, the read/write ! 623: * pointer is at the beginning of the transfer vector. ! 624: * ! 625: * It begins reading transfer vector entries until it finds ! 626: * one which is unused. It then seeks TVENTSZ backwards and returns ! 627: * the file offset of the available slot. It increments tvnxt whenever ! 628: * it finds an unavailable slot. When next called, it will be in a position ! 629: * to proceed reading slots, being positioned correctly and knowing ! 630: * the value of tvnxt. ! 631: */ ! 632: ! 633: long inslot; ! 634: ! 635: for( ; tvnxt <= tvspec.tvrange[1]; ++tvnxt ) { ! 636: fread(&inslot, TVENTSZ, 1, tvread); ! 637: if( inslot == -1L ) ! 638: return( (long)(ftell(tvread)-TVENTSZ) ); ! 639: } ! 640: ! 641: return(0); ! 642: #endif ! 643: } ! 644: /*eject*/ ! 645: tvfinish() ! 646: { ! 647: #if TRVEC ! 648: long offset; ! 649: SYMTAB *psym; ! 650: ! 651: if( tvspec.tvfnfill[0] != '\0' ) { ! 652: if( (psym = findsym(tvspec.tvfnfill)) == NULL ) ! 653: lderror(1, tvspec.tvinlnno, tvspec.tvinflnm, ! 654: "tv fill symbol %s does not exist", tvspec.tvfnfill); ! 655: else { ! 656: ! 657: filltvassign(psym); ! 658: ! 659: PUTSYM(psym, 0); ! 660: ! 661: /* ! 662: * update x_tvfill in .tv aux entry ! 663: */ ! 664: if ( (psym=findsym(_TV)) == NULL) ! 665: lderror(0,0,NULL,"No .tv in symbol table"); ! 666: else { ! 667: AUXTAB *paux; ! 668: union { ! 669: TVENTRY ent; ! 670: long l; ! 671: } fill; ! 672: ! 673: fill.ent = tvspec.tvfill; ! 674: paux = getaux(psym->smauxid); ! 675: paux->axent.x_tv.x_tvfill = fill.l; ! 676: PUTAUX(paux, 1); ! 677: PUTSYM(psym, 0); ! 678: } ! 679: ! 680: if ( tvspec.tvrange[0] == 0 ) { /* fill slot 0 */ ! 681: fseek(tvstream, tvspec.tvosptr->oshdr.s_scnptr, 0); ! 682: fwrite(&tvspec.tvfill, TVENTSZ, 1, tvstream); ! 683: } ! 684: ! 685: for( offset = gettvnxt(); tvnxt <= tvspec.tvrange[1]; ) { ! 686: fseek(tvstream, offset-ftell(tvstream), 1); ! 687: fwrite(&tvspec.tvfill, TVENTSZ, 1, tvstream); ! 688: ++tvnxt; ! 689: offset = gettvnxt(); ! 690: } /* for */ ! 691: } /* else */ ! 692: } /* if tvfnfill[0] */ ! 693: ! 694: fclose(tvstream); ! 695: #if AR16WR ! 696: free( tvbuf ); ! 697: #endif ! 698: fclose(tvread); ! 699: ! 700: #endif ! 701: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.