![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ld2.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 ld2.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / ld |
1.1 ! root 1: static char ID[] = "@(#) ld2.c: 1.16 12/1/83"; ! 2: #include "system.h" ! 3: ! 4: #include <stdio.h> ! 5: #include "reloc.h" ! 6: #include "linenum.h" ! 7: #include "structs.h" ! 8: #include "y.tab.h" ! 9: ! 10: #if TRVEC ! 11: #include "tv.h" ! 12: #include "ldtv.h" ! 13: #endif ! 14: ! 15: #include "extrns.h" ! 16: #include "list.h" ! 17: #include "params.h" ! 18: #include "sgsmacros.h" ! 19: #include "patch.h" ! 20: ! 21: ! 22: #define BASIC_TYPES (STYP_TEXT | STYP_DATA | STYP_BSS) ! 23: #define K8 0x2000L ! 24: static ITEMID dotacid; ! 25: static OUTSECT *dotosptr; ! 26: /*eject*/ ! 27: pboslist() ! 28: { ! 29: ! 30: /* ! 31: * Process the BLDOUTSC List ! 32: */ ! 33: ! 34: register OUTSECT *osptr; ! 35: register INSECT *insptr; ! 36: register INFILE *inflptr; ! 37: #if !ONEPROC ! 38: ACTITEM a; ! 39: #endif ! 40: OUTSECT *dfn_scn_grp(); ! 41: long check_sect(); ! 42: ! 43: ! 44: /* ! 45: * Process the list of output sections. Output sections can be ! 46: * defined in two places: ! 47: * ! 48: * 1. PASS 1: user-supplied; bldcnt will be > 0, and the bldoutsc ! 49: * list head will be NULL ! 50: * 2. PASS 2: default-generation; bldcnt will be 0, and the ! 51: * bldoutsc list will describe the output ! 52: * sections ! 53: * ! 54: * These two uses are mutually exclusive ! 55: */ ! 56: ! 57: #if DEBUG ! 58: if( dflag > 2 ) ! 59: fprintf( stderr, "\nBLDOSCN data structures:" ); ! 60: #endif ! 61: #if !ONEPROC ! 62: while( bldcnt-- ) { ! 63: ! 64: fread( &a, 1, sizeof(ACTITEM), trnfdes ); ! 65: a.dfnscn.aiinflnm = (char *) ((int) a.dfnscn.aiinflnm + (int) strbase); ! 66: ! 67: osptr = dfn_scn_grp(&a, 0); ! 68: copy(osptr->oshdr.s_name, a.dfnscn.ainame, 8); ! 69: #if TRVEC ! 70: /* ! 71: * User can define attributes of TV in two ways: ! 72: * (1) using TV { } directive ! 73: * (2) using SECTIONS { .tv : {} } directive ! 74: * so force them to agree ! 75: */ ! 76: if ( equal(a.dfnscn.ainame, _TV, 8) ) { /* defining .tv */ ! 77: if ( tvspec.tvbndadr == -1L ) ! 78: tvspec.tvbndadr = a.dfnscn.aibndadr; ! 79: else ! 80: a.dfnscn.aibndadr = tvspec.tvbndadr; ! 81: } ! 82: #endif ! 83: if( a.dfnscn.aitype == AIDFNSCN ) ! 84: numoutsc++; ! 85: ! 86: osptr->oshdr.s_paddr = -1L; ! 87: listadd(l_OS, &outsclst, osptr); ! 88: } ! 89: #endif ! 90: ! 91: /* ! 92: * We now know everything there is to know about the ! 93: * transfer vector: ! 94: * At the end of ploadfil(), we knew how big it ! 95: * had to be. ! 96: * Here we know whether it was defined by ld or ! 97: * whether it is defined by .tv input sections ! 98: * together with a .tv SECTION directive ! 99: * Go check everything and complete tvspec definition. ! 100: */ ! 101: ! 102: #if TRVEC ! 103: if ( tvflag ) ! 104: tvupdat(); /* update definition of tv */ ! 105: #endif ! 106: ! 107: if( bldoutsc.head ) { ! 108: register ACTITEM *aptr, *a2ptr; ! 109: ! 110: aptr = (ACTITEM *) bldoutsc.head; ! 111: while( aptr ) { ! 112: ! 113: osptr = dfn_scn_grp(aptr, 1); ! 114: ! 115: copy(osptr->oshdr.s_name, aptr->dfnscn.ainame, 8); ! 116: if( aptr->dfnscn.aitype == AIDFNSCN ) ! 117: numoutsc++; ! 118: ! 119: osptr->oshdr.s_paddr = -1L; ! 120: listadd(l_OS, &outsclst, osptr); ! 121: ! 122: a2ptr = aptr; ! 123: aptr = aptr->dfnscn.ainext; ! 124: free( (char *) a2ptr); ! 125: } ! 126: } ! 127: ! 128: /* ! 129: * Make sure all input sections are allocated ! 130: * into some output section. ! 131: */ ! 132: ! 133: for( inflptr = (INFILE *) infilist.head; inflptr; inflptr = inflptr->flnext ) { ! 134: for( insptr = inflptr->flishead; insptr; insptr=insptr->isnext ) { ! 135: if (insptr->isoutsec <= 0) { ! 136: if ((osptr = fndoutsec(insptr->ishdr.s_name)) != NULL) ! 137: inscadd(insptr,osptr); ! 138: else { ! 139: osptr = (OUTSECT *) myalloc(sizeof(OUTSECT)); ! 140: numoutsc++; ! 141: copy(osptr->oshdr.s_name, insptr->ishdr.s_name, 8); ! 142: osptr->osfill = globfill; ! 143: osptr->oshdr.s_paddr = -1l; ! 144: listadd(l_OS,&outsclst,osptr); ! 145: inscadd(insptr,osptr); ! 146: } ! 147: } ! 148: } ! 149: } ! 150: ! 151: /* ! 152: * for each output section, check the flags, and for a group, ! 153: * check the size. ! 154: */ ! 155: ! 156: for( osptr = (OUTSECT *) outsclst.head; osptr; osptr = osptr->osnext ) ! 157: { ! 158: #if PAGING ! 159: ACTITEM *aptr; ! 160: ADDRESS textbegin, textsize; ! 161: textbegin = hflag + FILHSZ + SCNHSZ * numoutsc + memorg; ! 162: #endif ! 163: if (osptr->oshdr.s_flags & STYP_GROUP) { ! 164: OUTSECT *op; ! 165: for( op = ((OUTSECT *) osptr->osinclhd); op; op = op->osnext ) { ! 166: #if PAGING ! 167: if (bond_t_d && !Nflag && equal(op->oshdr.s_name,_DATA,8)) { ! 168: osptr->osalign = 0L; ! 169: aptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 170: aptr->bond.aitype = AIBOND; ! 171: aptr->bond.aiinflnm = "*default.bond.file*"; ! 172: aptr->bond.aiinlnno = 3; ! 173: aptr->bond.aioutsec = osptr; ! 174: aptr->bond.aiadrbnd = ((textsize + textbegin) / BOUNDARY + 1) ! 175: * BOUNDARY + (textsize + textbegin) % K8; ! 176: listadd(l_AI,&bondlist,aptr); ! 177: } ! 178: #endif ! 179: osptr->oshdr.s_size += check_sect( op ); ! 180: } ! 181: if (osptr->oshdr.s_size > MAXSCNSIZE) ! 182: lderror(1,0,NULL, "GROUP containing section %.8s is too big", ! 183: osptr->osinclhd->ishdr.s_name); ! 184: } else { ! 185: #if PAGING ! 186: if (bond_t_d && !Nflag && equal(osptr->oshdr.s_name,_TEXT,8)) { ! 187: textsize = osptr->oshdr.s_size; ! 188: aptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 189: aptr->bond.aitype = AIBOND; ! 190: aptr->bond.aiinflnm = "*default.bond.file*"; ! 191: aptr->bond.aiinlnno = 2; ! 192: aptr->bond.aioutsec = osptr; ! 193: aptr->bond.aiadrbnd = textbegin; ! 194: listadd(l_AI,&bondlist,aptr); ! 195: } ! 196: #endif ! 197: check_sect( osptr ); ! 198: } ! 199: } ! 200: ! 201: /* ! 202: * If .tv is user-defined, we now know the true size of ! 203: * the section ( the sum of the sizes of the input ! 204: * sections) which we didn't know before. Now call the ! 205: * the final update routine to insure .tv symtab entry ! 206: * is correct ! 207: */ ! 208: ! 209: #if TRVEC ! 210: if ( tvflag ) ! 211: tvupdt2(); /* final update of tvrange and tvlength */ ! 212: #endif ! 213: ! 214: #if DEBUG ! 215: if (dflag) ! 216: dmp_outsects(); ! 217: #endif ! 218: } ! 219: /*eject*/ ! 220: OUTSECT * ! 221: dfn_scn_grp(aptr, dflt) ! 222: ! 223: ACTITEM *aptr; /* DFNSCN or DFNGRP entry */ ! 224: int dflt; /* user-supplied or ld-default entry */ ! 225: { ! 226: ! 227: /* ! 228: * Process one AIDFNSCN or AIDFNGRP data structure from ! 229: * the list of output sections ! 230: */ ! 231: ! 232: OUTSECT *osptr, *op; ! 233: INFILE *inflptr; ! 234: INSECT *insptr; ! 235: ENODE *ep; ! 236: long val; ! 237: int fill, fillflag; ! 238: ACTITEM *a2ptr; ! 239: #if !ONEPROC ! 240: ACTITEM b; ! 241: #endif ! 242: ! 243: #if DEBUG ! 244: if( dflag > 2 ) ! 245: fprintf( stderr, "\n\t%04x %s (%s) %d (%s) %04x (%s)\n\t\t%08lx %d %08lx %08lx %d %d (%04x,%04x)", ! 246: aptr->dfnscn.ainext, ! 247: (aptr->dfnscn.aitype == AIDFNSCN) ? "AIDFNSCN" : "AIDFNGRP", ! 248: aptr->dfnscn.aiinflnm, ! 249: aptr->dfnscn.aiinlnno, aptr->dfnscn.ainame, aptr->dfnscn.aifill, ! 250: aptr->dfnscn.aiowname, aptr->dfnscn.aibndadr, aptr->dfnscn.aiattown, ! 251: aptr->dfnscn.aialign, aptr->dfnscn.aiblock, (unsigned) aptr->dfnscn.aifillfg, ! 252: (unsigned) aptr->dfnscn.aisctype, aptr->dfnscn.sectspec.head, aptr->dfnscn.sectspec.tail ); ! 253: #endif ! 254: ! 255: osptr = (OUTSECT *) myalloc(sizeof(OUTSECT)); ! 256: if (aptr->dfnscn.aibndadr != -1L) { /* section bonded */ ! 257: a2ptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 258: a2ptr->bond.aitype = AIBOND; ! 259: a2ptr->bond.aiinflnm = aptr->dfnscn.aiinflnm; ! 260: a2ptr->bond.aiinlnno = aptr->dfnscn.aiinlnno; ! 261: a2ptr->bond.aioutsec = osptr; ! 262: a2ptr->bond.aiadrbnd = aptr->dfnscn.aibndadr; ! 263: listadd(l_AI,&bondlist,a2ptr); ! 264: } ! 265: else if (aptr->dfnscn.aiowname[0] != '\0') { /*owner specified */ ! 266: a2ptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 267: a2ptr->dfownr.aitype = AIDFOWNR; ! 268: a2ptr->dfownr.aiinflnm = aptr->dfnscn.aiinflnm; ! 269: a2ptr->dfownr.aiinlnno = aptr->dfnscn.aiinlnno; ! 270: a2ptr->dfownr.aioutsec = osptr; ! 271: copy(a2ptr->dfownr.ainamown, aptr->dfnscn.aiowname, 8); ! 272: listadd(l_AI,&ownlist,a2ptr); ! 273: } ! 274: else if (aptr->dfnscn.aiattown != 0) { /* attr of owner */ ! 275: a2ptr = (ACTITEM *) myalloc(sizeof(ACTITEM)); ! 276: a2ptr->ownatr.aitype = AIOWNATR; ! 277: a2ptr->ownatr.aiinflnm = aptr->dfnscn.aiinflnm; ! 278: a2ptr->ownatr.aiinlnno = aptr->dfnscn.aiinlnno; ! 279: a2ptr->ownatr.aioutsec = osptr; ! 280: a2ptr->ownatr.aiownatt = aptr->dfnscn.aiattown; ! 281: listadd(l_AI,&atownlst,a2ptr); ! 282: } ! 283: ! 284: if (aptr->dfnscn.aitype == AIDFNGRP) ! 285: osptr->oshdr.s_flags = STYP_GROUP; ! 286: else ! 287: osptr->oshdr.s_flags = aptr->dfnscn.aisctype; ! 288: osptr->osalign = aptr->dfnscn.aialign; ! 289: osptr->osblock = aptr->dfnscn.aiblock; ! 290: osptr->osfill = aptr->dfnscn.aifill; ! 291: osptr->osflags |= aptr->dfnscn.aifillfg; ! 292: ! 293: /* ! 294: * A DFNSCN need have no subordinate entries, since the following is ! 295: * legal: ! 296: * .text : {} ! 297: */ ! 298: ! 299: if( aptr->dfnscn.sectspec.head == NULL ) ! 300: return( osptr ); ! 301: ! 302: /* ! 303: * A DFNGRP is a sequence of one or more DFNSCN entries ! 304: */ ! 305: ! 306: if( aptr->dfnscn.aitype == AIDFNGRP ) { ! 307: a2ptr = (ACTITEM *) aptr->dfnscn.sectspec.head; ! 308: do { ! 309: if( ! dflt ) { ! 310: #if !ONEPROC ! 311: fread( &b, 1, sizeof(ACTITEM), trnfdes ); ! 312: b.dfnscn.aiinflnm = (char *) ((int) b.dfnscn.aiinflnm + (int) strbase); ! 313: a2ptr = &b; ! 314: #endif ! 315: } ! 316: ! 317: op = dfn_scn_grp(a2ptr, dflt); ! 318: ! 319: op->oshdr.s_paddr = -1L; ! 320: listadd(l_GRP, osptr, op); ! 321: numoutsc++; ! 322: copy(op->oshdr.s_name, a2ptr->dfnscn.ainame, 8); ! 323: ! 324: if( (a2ptr = a2ptr->dfnscn.ainext) == NULL ) ! 325: return( osptr ); ! 326: } ! 327: while( 1 ); ! 328: } ! 329: ! 330: /* ! 331: * Process a DFNSCN with one or more subordinate entries, of type ! 332: * AIADFILE, AIADDSCN, or AIEVEXPR ! 333: */ ! 334: ! 335: a2ptr = (ACTITEM *) aptr->dfnscn.sectspec.head; ! 336: do { ! 337: if( ! dflt ) { ! 338: #if !ONEPROC ! 339: fread( &b, 1, sizeof(ACTITEM), trnfdes ); ! 340: b.adfile.aiinflnm = (char *) ((int) b.adfile.aiinflnm + (int) strbase); ! 341: a2ptr = &b; ! 342: #endif ! 343: } ! 344: ! 345: switch( a2ptr->adfile.aitype ) { ! 346: ! 347: case AIADFILE: ! 348: ! 349: if( ! dflt ) ! 350: a2ptr->adfile.aifilnam = (char *) ((int) a2ptr->adfile.aifilnam + (int) strbase); ! 351: ! 352: #if DEBUG ! 353: if( dflag > 2 ) ! 354: fprintf( stderr, "\n\t%04x AIADFILE (%s) %d (%s) %d %d %d", ! 355: a2ptr->adfile.ainext, a2ptr->adfile.aiinflnm, ! 356: a2ptr->adfile.aiinlnno, a2ptr->adfile.aifilnam, a2ptr->adfile.ainadscs, ! 357: a2ptr->adfile.aifill2, (unsigned) a2ptr->adfile.aifilflg ); ! 358: #endif ! 359: ! 360: if( (inflptr = fndinfil(a2ptr->adfile.aifilnam)) == NULL ) ! 361: break; ! 362: if( a2ptr->adfile.ainadscs == 0 ) { ! 363: insptr = inflptr->flishead; ! 364: while( insptr ) { ! 365: if( insptr->isoutsec == NULL ) { ! 366: inscadd(insptr, osptr); ! 367: insptr->isfill = a2ptr->adfile.aifill2; ! 368: insptr->isfillfg = a2ptr->adfile.aifilflg; ! 369: } ! 370: insptr = insptr->isnext; ! 371: /* ! 372: * In case inflptr is library, ! 373: * get next one ! 374: */ ! 375: if( (insptr == NULL) && (inflptr->flfiloff > 0L) ) ! 376: while( (inflptr = inflptr->flnext) ) ! 377: if (strcmp(a2ptr->adfile.aifilnam,inflptr->flname) == 0) { ! 378: insptr = inflptr->flishead; ! 379: break; ! 380: } ! 381: } ! 382: } ! 383: else { ! 384: fill = a2ptr->adfile.aifill2; ! 385: fillflag = a2ptr->adfile.aifilflg; ! 386: } ! 387: break; ! 388: ! 389: case AIADDSCN: ! 390: ! 391: if( ! dflt ) ! 392: a2ptr->addscn.aiscfile = (char *) ((int) a2ptr->addscn.aiscfile + (int) strbase); ! 393: ! 394: #if DEBUG ! 395: if( dflag > 2 ) ! 396: fprintf( stderr, "\n\t%04x AIADDSCN (%s) %d (%s) %04x (%s)", ! 397: a2ptr->addscn.ainext, a2ptr->addscn.aiinflnm, ! 398: a2ptr->addscn.aiinlnno, a2ptr->addscn.ainame, a2ptr->addscn.aifill, ! 399: a2ptr->addscn.aiscfile ); ! 400: #endif ! 401: ! 402: if( (inflptr = fndinfil(a2ptr->addscn.aiscfile)) == NULL ) ! 403: break; ! 404: insptr = inflptr->flishead; ! 405: while(insptr) { ! 406: if (equal(a2ptr->addscn.ainame,insptr->ishdr.s_name,8)) { ! 407: if (insptr->isoutsec) { ! 408: lderror(1, a2ptr->addscn.aiinlnno, a2ptr->addscn.aiinflnm, ! 409: "adding %s(%.8s) to multiple output sections", ! 410: inflptr->flname, ! 411: insptr->ishdr.s_name); ! 412: goto contin1; ! 413: } ! 414: inscadd(insptr,osptr); ! 415: insptr->isfill = fill; ! 416: insptr->isfillfg = fillflag; ! 417: insptr = NULL; ! 418: if (inflptr->flfiloff > 0L) ! 419: /* ! 420: * In case inflptr is library, ! 421: * get next one ! 422: */ ! 423: while( (inflptr = inflptr->flnext) ) ! 424: if (strcmp(a2ptr->addscn.aiscfile,inflptr->flname) == 0) { ! 425: insptr = inflptr->flishead; ! 426: break; ! 427: } ! 428: if ( insptr != NULL ) ! 429: continue; ! 430: else ! 431: goto contin1; ! 432: } ! 433: insptr = insptr->isnext; ! 434: } ! 435: lderror(1, a2ptr->addscn.aiinlnno, a2ptr->addscn.aiinflnm, ! 436: "%s(%.8s) not found", ! 437: a2ptr->addscn.aiscfile,a2ptr->addscn.ainame); ! 438: break; ! 439: ! 440: case AIEVEXPR: ! 441: ! 442: #if DEBUG ! 443: if( dflag > 2 ) ! 444: fprintf( stderr, "\n\t%04x AIEVEXPR (%s) %d %04x\n\t\tROOT:", ! 445: a2ptr->evexpr.ainext, a2ptr->evexpr.aiinflnm, ! 446: a2ptr->evexpr.aiinlnno, a2ptr->evexpr.aiexptr ); ! 447: #endif ! 448: ! 449: #if ONEPROC ! 450: aptr = a2ptr; ! 451: #else ! 452: aptr = ldexp( &b ); ! 453: #endif ! 454: ! 455: a2ptr = a2ptr->adfile.ainext; ! 456: ep = aptr->evexpr.aiexptr; ! 457: cur_dot = osptr->oshdr.s_size; ! 458: ! 459: if (ep->gnode.exleft->gnode.exop != DOT) { ! 460: /* ! 461: * LHS of assnment is regular symbol ! 462: */ ! 463: dotacid = 0; ! 464: dotosptr = osptr; ! 465: chgdot(ep->gnode.exright); ! 466: listadd(l_AI, &explist, aptr); ! 467: } ! 468: else { ! 469: /* ! 470: * LHS is DOT symbol ! 471: */ ! 472: curexp = aptr; ! 473: val = eval(ep->gnode.exright); ! 474: if (val < cur_dot) ! 475: lderror(1, aptr->evexpr.aiinlnno, aptr->evexpr.aiinflnm, ! 476: "attempt to decrement DOT"); ! 477: else ! 478: osptr->oshdr.s_size = val; ! 479: ! 480: clrexp( aptr ); ! 481: } ! 482: goto contin2; ! 483: } ! 484: ! 485: contin1: ! 486: a2ptr = a2ptr->adfile.ainext; ! 487: contin2: ! 488: if (a2ptr == NULL) ! 489: return( osptr ); ! 490: ! 491: } ! 492: while( 1 ); ! 493: } ! 494: /*eject*/ ! 495: inscadd(pin,pout) ! 496: INSECT *pin; ! 497: OUTSECT *pout; ! 498: { ! 499: ! 500: /* ! 501: * Add an input section to an output section. ! 502: * ! 503: * The text, relocation, and lineno info of the input section ! 504: * are allocated at the end of the output section. ! 505: */ ! 506: ! 507: long btype; ! 508: ! 509: pin->isoutsec = pout; ! 510: pin->isdispl = pout->oshdr.s_size; ! 511: pin->islndisp = ((long) pout->oshdr.s_nlnno * (long) LINESZ); ! 512: pout->oshdr.s_size += pin->ishdr.s_size; ! 513: pout->oshdr.s_nlnno += pin->ishdr.s_nlnno; ! 514: ! 515: if (rflag) { ! 516: pin->isrldisp = ((long) pout->oshdr.s_nreloc * (long) RELSZ); ! 517: pout->oshdr.s_nreloc += pin->ishdr.s_nreloc; ! 518: } ! 519: ! 520: btype = pin->ishdr.s_flags & BASIC_TYPES; ! 521: if (btype) ! 522: pout->oshdr.s_flags |= btype; ! 523: else if ( equal( _TEXT, pin->ishdr.s_name, 8 )) ! 524: pout->oshdr.s_flags |= STYP_TEXT; ! 525: else if ( equal( _DATA, pin->ishdr.s_name, 8 )) ! 526: pout->oshdr.s_flags |= STYP_DATA; ! 527: else if ( equal( _BSS, pin->ishdr.s_name, 8 )) ! 528: pout->oshdr.s_flags |= STYP_BSS; ! 529: ! 530: pout->osflags |= (pin->ishdr.s_flags & STYP_DSECT) ? OSDSECT : OSREG; ! 531: if (pin->ishdr.s_flags & STYP_INFO) ! 532: pout->osflags |= OSINFO; ! 533: if (pin->ishdr.s_flags & STYP_COPY) ! 534: pout->osflags |= OSCOPY; ! 535: ! 536: listadd(l_INC,pout,pin); ! 537: } ! 538: /*eject*/ ! 539: INFILE * ! 540: fndinfil(fnam) ! 541: char *fnam; ! 542: { ! 543: ! 544: /* ! 545: * Locate the input file structure by a given name, and ! 546: * return a pointer to the structure. ! 547: * ! 548: * Note: fnam must be a null terminated string. ! 549: */ ! 550: ! 551: register INFILE *p; ! 552: ! 553: p = (INFILE *) infilist.head; ! 554: while (p) { ! 555: if (strcmp(fnam,p->flname) == 0) ! 556: return(p); ! 557: p = p->flnext; ! 558: } ! 559: ! 560: return(NULL); ! 561: } ! 562: /*eject*/ ! 563: chgdot(p) ! 564: ENODE *p; ! 565: { ! 566: register SYMTAB *sym; ! 567: ITEMID add_dot(); ! 568: ! 569: /* ! 570: * This function is called when an assignment is encountered ! 571: * within an output section specification, and the LHS of the ! 572: * assnment is to a symbol other than DOT. Any occurances of ! 573: * DOT within the RHS expression must be replaced by a reference ! 574: * to a dummy symbol table entry, which will have the correct ! 575: * value after the output section is relocated. ! 576: */ ! 577: ! 578: switch(p->gnode.exop) { ! 579: case DOT: ! 580: if( dotacid == 0 ) ! 581: dotacid = add_dot(cur_dot, dotosptr); ! 582: p->nnode.exsymptr = dotacid; ! 583: break; ! 584: case NAME: ! 585: case INT: ! 586: break; ! 587: default: ! 588: if (p->gnode.exleft) ! 589: chgdot(p->gnode.exleft); ! 590: if (p->gnode.exright) ! 591: chgdot(p->gnode.exright); ! 592: } ! 593: } ! 594: /*eject*/ ! 595: add_pad() ! 596: { ! 597: ! 598: /* ! 599: * If the "-B" flag was specified, add any necessary "padding sections" ! 600: * to the outpt file ! 601: */ ! 602: ! 603: register ANODE *ap; /* ptr into avlist */ ! 604: ANODE *newap; /* ptr to padding section node */ ! 605: register OUTSECT *osp; ! 606: register INSECT *isp; ! 607: int no_need_pad, /* = 1 iff don't need padding */ ! 608: counter; /* used to make unique names */ ! 609: char padname[8]; /* padding section name */ ! 610: ! 611: /* ! 612: * Look for an output section which meets one of two conditions: ! 613: * ! 614: * 1. The section is comprised entirely of uninitialized .bss ! 615: * sections ! 616: * 2. The section is of zero length ! 617: * ! 618: * For every output section of these types, add an additional output ! 619: * section immediatly after it. This "padding section" has only two ! 620: * non-zero/non-NULL/non-trivial characteristics: ! 621: * 1. It is composed of Bflag bytes of zero ! 622: * 2. It is written under control of BLOCK(Bflag) ! 623: * ! 624: * Note that padding sections have a virtual/physical address ! 625: * of -1 (to generate errors from any user program or utility ! 626: * attempting to use these values), and flags indicating that ! 627: * it is a padding section ! 628: */ ! 629: ! 630: counter = 0; ! 631: for( ap = (ANODE *) avlist.head; ap; ap = ap->adnext ) { ! 632: if( ap->adtype != ADSECT ) ! 633: continue; ! 634: ! 635: osp = ap->adscnptr; ! 636: no_need_pad = (osp->osflags & FILL); ! 637: for( isp = osp->osinclhd; isp; isp = isp->isincnxt ) ! 638: if( (isp->ishdr.s_scnptr > 0) || (isp->isfillfg) ) ! 639: no_need_pad = 1; ! 640: if( ap->adsize == 0L ) ! 641: no_need_pad = 0; ! 642: ! 643: if( no_need_pad ) ! 644: continue; ! 645: ! 646: osp = (OUTSECT *) myalloc(sizeof(OUTSECT)); ! 647: numoutsc++; ! 648: sprintf( padname, "-pad%2d-", counter++ ); ! 649: copy( osp->oshdr.s_name, padname, 8 ); ! 650: osp->oshdr.s_paddr = -1L; ! 651: osp->oshdr.s_vaddr = -1L; ! 652: osp->oshdr.s_size = Bflag; ! 653: osp->oshdr.s_flags = STYP_PAD; ! 654: osp->osblock = Bflag; ! 655: ! 656: newap = (ANODE *) myalloc(sizeof(ANODE)); ! 657: newap->adtype = ADPAD; ! 658: newap->adsize = Bflag; ! 659: newap->adscnptr = osp; ! 660: ! 661: listins( l_ADR, &avlist, ap, newap ); ! 662: } ! 663: ! 664: #if DEBUG ! 665: if( dflag > 1 ) { ! 666: fprintf( stderr, "\nadd_pad" ); ! 667: dump_mem(); ! 668: } ! 669: #endif ! 670: ! 671: } ! 672: /*eject*/ ! 673: updatsms() ! 674: { ! 675: ! 676: /* ! 677: * After allocation, this function sets ! 678: * 1. The section number of all output sections ! 679: * 2. The virtual addresses of all input sections (isnewvad) ! 680: * 3. The file offset of output sections ! 681: * ! 682: * In addition, the relocated value for all global symbols is ! 683: * computed and stored in the symbol table, along with the new ! 684: * section number. ! 685: * ! 686: * The virtual addresses of output sections are set by ! 687: * audit_regions in allocation. ! 688: */ ! 689: ! 690: register SYMTAB *symp; ! 691: register OUTSECT *osp; ! 692: register INSECT *isp; ! 693: int snum, init; ! 694: long vaddr, indx; ! 695: long filoffst, lnnoptr, nrelocs; ! 696: ANODE *ap; ! 697: INFILE *fp; ! 698: ! 699: /* ! 700: * Compute the starting file offset of the first output section ! 701: * ! 702: * ********** NOTE NOTE NOTE NOTE ********** ! 703: * ! 704: * Increase the size of the optional header by the amount of ! 705: * space needed to generate a patch list ! 706: * ! 707: * ********** NOTE NOTE NOTE NOTE ********** ! 708: */ ! 709: ! 710: hflag += psize(); ! 711: filoffst = (long) FILHSZ + hflag + SCNHSZ * numoutsc; ! 712: ! 713: nrelocs = 0L; ! 714: snum = 0; ! 715: ! 716: for( ap = (ANODE *) avlist.head; ap; ap = ap->adnext ) { ! 717: if (ap->adtype == ADSECT) { ! 718: osp = ap->adscnptr; ! 719: /* ! 720: ***** Special processing ***** ! 721: * ! 722: * The description of the _TV output section is ! 723: * changed, so as to make it equivalent to that ! 724: * section of the transfer vector actually used ! 725: * in this ld run ! 726: * ! 727: * Note that in the default case - no ASSIGN or ! 728: * RANGE commands, the entire transfer vector ! 729: * is used, and hence this code produces no ! 730: * change. ! 731: * ! 732: * When ASSIGN and RANGE commands are present, ! 733: * the actual section of the transfer vector ! 734: * used is typically a subset of the entire ! 735: * vector. Output only the piece used ! 736: */ ! 737: #if TRVEC ! 738: if( tvflag && equal(osp->oshdr.s_name,_TV,8) ) { ! 739: osp->oshdr.s_paddr += ! 740: (tvspec.tvrange[0] * TVENTSZ); ! 741: osp->oshdr.s_vaddr += ! 742: (tvspec.tvrange[0] * TVENTSZ); ! 743: osp->oshdr.s_size = ! 744: ((tvspec.tvrange[1]-tvspec.tvrange[0]+1)*TVENTSZ); ! 745: } ! 746: #endif ! 747: init = (osp->osflags & FILL); /* section is initialized*/ ! 748: osp->ossecnum = ++snum; ! 749: vaddr = osp->oshdr.s_vaddr; ! 750: for( isp = osp->osinclhd; isp; isp = isp->isincnxt ) { ! 751: isp->isnewvad = vaddr + isp->isdispl; ! 752: isp->isnewpad = osp->oshdr.s_paddr + isp->isdispl; ! 753: if (isp->ishdr.s_scnptr > 0 || isp->isfillfg) ! 754: init = 1; ! 755: } ! 756: ! 757: if ((osp->oshdr.s_flags & STYP_NOLOAD) || (osp->oshdr.s_flags & STYP_DSECT)) ! 758: init = 0; ! 759: if (init) { ! 760: filoffst += alignment(osp->osblock,filoffst); ! 761: osp->oshdr.s_scnptr = filoffst; ! 762: filoffst += osp->oshdr.s_size; ! 763: if (rflag) ! 764: nrelocs += (long) osp->oshdr.s_nreloc; ! 765: if (filoffst % 2) ! 766: ++filoffst; ! 767: } ! 768: else ! 769: osp->oshdr.s_scnptr = 0L; ! 770: } ! 771: else if( ap->adtype == ADPAD ) { ! 772: osp = ap->adscnptr; ! 773: osp->ossecnum = ++snum; ! 774: filoffst += alignment(osp->osblock,filoffst); ! 775: osp->oshdr.s_scnptr = filoffst; ! 776: filoffst += osp->oshdr.s_size; ! 777: if( filoffst % 2 ) ! 778: ++filoffst; ! 779: } ! 780: } ! 781: ! 782: /* ! 783: * Do the same for the "dummy" sections (DSECTS) ! 784: */ ! 785: ! 786: for( osp = (OUTSECT *) dsectlst.head; osp; osp = osp->osdsnext ) { ! 787: osp->ossecnum = ++snum; ! 788: for( isp = osp->osinclhd; isp; isp = isp->isincnxt ) { ! 789: isp->isnewvad = osp->oshdr.s_vaddr + isp->isdispl; ! 790: isp->isnewpad = osp->oshdr.s_paddr + isp->isdispl; ! 791: } ! 792: if ( osp->oshdr.s_flags & (STYP_COPY | STYP_INFO)) { ! 793: filoffst += alignment(osp->osblock,filoffst); ! 794: osp->oshdr.s_scnptr = filoffst; ! 795: filoffst += osp->oshdr.s_size; ! 796: if ( rflag ) ! 797: nrelocs += (long) osp->oshdr.s_nreloc; ! 798: if ( filoffst % 2) ! 799: ++filoffst; ! 800: } else { ! 801: osp->oshdr.s_nreloc = 0; ! 802: osp->oshdr.s_nlnno = 0; ! 803: } ! 804: } ! 805: ! 806: /* ! 807: * Loop through sections a 2nd time to set the ! 808: * file pointer to relocation and line numbers for each section ! 809: */ ! 810: ! 811: lnnoptr = filoffst + nrelocs * (long) RELSZ; ! 812: for( ap = (ANODE *) avlist.head; ap; ap = ap->adnext ) { ! 813: if (ap->adtype == ADSECT) { ! 814: osp = ap->adscnptr; ! 815: if (osp->oshdr.s_flags & STYP_NOLOAD) { ! 816: osp->oshdr.s_nreloc = 0; ! 817: osp->oshdr.s_nlnno = 0; ! 818: continue; ! 819: } ! 820: if( rflag && (osp->oshdr.s_nreloc != 0) ) { ! 821: osp->oshdr.s_relptr = filoffst; ! 822: filoffst += ((long)osp->oshdr.s_nreloc * ! 823: (long) RELSZ); ! 824: } ! 825: #if UNIX || XL ! 826: if( (!sflag && !xflag) && (osp->oshdr.s_nlnno != 0) ) { ! 827: #else ! 828: if( (!sflag ) && (osp->oshdr.s_nlnno != 0) ) { ! 829: #endif ! 830: osp->oshdr.s_lnnoptr = lnnoptr; ! 831: lnnoptr += ((long)osp->oshdr.s_nlnno * ! 832: (long) LINESZ); ! 833: } ! 834: } ! 835: } ! 836: ! 837: /* ! 838: * Do the same for the "copy" sections (COPY) ! 839: */ ! 840: ! 841: for( osp = (OUTSECT *) dsectlst.head; osp; osp = osp->osdsnext ) { ! 842: if ( osp->oshdr.s_flags & (STYP_COPY | STYP_INFO)) { ! 843: if ( rflag && (osp->oshdr.s_nreloc != 0) ) { ! 844: osp->oshdr.s_relptr = filoffst; ! 845: filoffst += ((long) osp->oshdr.s_nreloc ! 846: * (long) RELSZ); ! 847: } ! 848: if ( (! sflag) && (osp->oshdr.s_nlnno != 0) ) { ! 849: osp->oshdr.s_lnnoptr = lnnoptr; ! 850: lnnoptr += ((long) osp->oshdr.s_nlnno * ! 851: (long) LINESZ); ! 852: } ! 853: } ! 854: } ! 855: ! 856: symtborg = filoffst = lnnoptr; ! 857: fp = (INFILE *) infilist.head; ! 858: indx = 0; ! 859: while (fp) { ! 860: fp->flsymndx = indx; ! 861: indx += fp->flnlsyms; ! 862: fp = fp->flnext; ! 863: } ! 864: ! 865: symp = NULL; ! 866: while( (symp = loopsym(symp, 1)) != NULL ) { ! 867: if( symp->sment.n_scnum > 0 ) { ! 868: isp = symp->smscnptr; ! 869: symp->sment.n_scnum = isp->isoutsec->ossecnum; ! 870: symp->smnewval = symp->sment.n_value ! 871: + isp->isnewpad - isp->ishdr.s_paddr; ! 872: symp->smnewvirt = symp->smnewval ! 873: - isp->isnewpad + isp->isnewvad; ! 874: if( symp->smlocflg ) { ! 875: symp->smoutndx += isp->isfilptr->flsymndx; ! 876: } ! 877: else { ! 878: symp->smoutndx = indx++; ! 879: indx += symp->sment.n_numaux; ! 880: } ! 881: } ! 882: else { ! 883: if ((symp->sment.n_zeroes == 0) || ! 884: (strncmp( symp->sment.n_name, ".dot", 4 ) != 0)) ! 885: symp->smoutndx = indx++; ! 886: symp->smnewval = symp->sment.n_value; ! 887: symp->smnewvirt = symp->sment.n_value; ! 888: indx += symp->sment.n_numaux; ! 889: } ! 890: } ! 891: #if FLEXNAMES ! 892: tnumsyms = indx; ! 893: #endif ! 894: } ! 895: /*eject*/ ! 896: OUTSECT * ! 897: findoscn(number) ! 898: int number; /* number of desired section */ ! 899: { ! 900: ! 901: /* ! 902: * Look through the output section list, outsclst, ! 903: * for a section with the specified number. Return ! 904: * a pointer to that element of the list. If no ! 905: * section exists with that number, return NULL. ! 906: */ ! 907: ! 908: register OUTSECT *osptr; ! 909: ! 910: osptr = (OUTSECT *) outsclst.head; ! 911: while ( osptr != NULL ) { ! 912: if ( osptr->ossecnum == number ) ! 913: return (osptr); ! 914: osptr = osptr->osnext; ! 915: } ! 916: ! 917: return (NULL); ! 918: } ! 919: /*eject*/ ! 920: split_scns() ! 921: { ! 922: ! 923: /* ! 924: * Run though the output section list. If the size of any output ! 925: * section is greater then MAXSCNSZ, split the output section into ! 926: * two (or more) output sections ! 927: * ! 928: * The name of a new section is the first char of the old name, ! 929: * followed by a number, followed by the rest of the old ! 930: * name. Only eight characters are kept. ! 931: */ ! 932: ! 933: OUTSECT *osp, *newosp, *nxtosp; ! 934: INSECT *isp, *nxtisp; ! 935: char *oldname, newname[20]; /* 8 + 4 + extra */ ! 936: int scnnumber; ! 937: long newdisp, startdisp; /* OUTSECT displacements */ ! 938: ! 939: /* ! 940: * "osp" scans down the outsclst, and "nxtosp" will ! 941: * always point to the next section on the original ! 942: * list. If we have to split osp, the new node ! 943: * will be newosp, and nxtosp will not change. ! 944: */ ! 945: ! 946: for( osp = (OUTSECT *) outsclst.head; osp; osp = nxtosp ) { ! 947: nxtosp = osp->osnext; ! 948: ! 949: /* begin KLUDGE */ ! 950: adjsize(osp); ! 951: /* end KLUDGE */ ! 952: ! 953: if (osp->oshdr.s_flags & STYP_DSECT) ! 954: continue; ! 955: ! 956: if( (osp->osinclhd == osp->osincltl) || (osp->oshdr.s_size <= MAXSCNSZ) ) { ! 957: /* Either there is only one input section in the ! 958: * output section, or the output section is ! 959: * within the permissible size ! 960: */ ! 961: if( (isp = osp->osinclhd) == NULL ) ! 962: continue; ! 963: if( isp->ishdr.s_size > MAXSCNSIZE ) { ! 964: lderror(1,0,NULL, "section %.8s in file %s too big", ! 965: isp->ishdr.s_name, isp->isfilptr->flname); ! 966: osp->osinclhd = osp->osincltl = NULL; ! 967: } ! 968: continue; ! 969: } ! 970: ! 971: /* ! 972: * An output section is too large, and must be split. ! 973: * ! 974: * Walk through the list of input sections, to build ! 975: * two (or more) output sections which are all within ! 976: * the permissible size range ! 977: */ ! 978: ! 979: osp->oshdr.s_nreloc = 0; ! 980: osp->oshdr.s_nlnno = 0; ! 981: isp = osp->osinclhd; ! 982: osp->osinclhd = osp->osincltl = NULL; ! 983: scnnumber = 0; ! 984: oldname = osp->oshdr.s_name; ! 985: ! 986: newdisp = 0L; ! 987: if( isp != NULL ) ! 988: startdisp = osp->oshdr.s_size = isp->isdispl; ! 989: else ! 990: startdisp = osp->oshdr.s_size = 0L; ! 991: ! 992: /* ! 993: * "isp" points to the current input section which we ! 994: * are trying to add to the output section given by ! 995: * "osp" ! 996: */ ! 997: ! 998: for(; isp; isp = nxtisp ) { ! 999: nxtisp = isp->isincnxt; ! 1000: if( osp->oshdr.s_size + isp->ishdr.s_size <= MAXSCNSZ ) { ! 1001: newdisp = isp->isdispl - startdisp; ! 1002: if( osp->oshdr.s_size > newdisp ) ! 1003: lderror(1,0, NULL, ! 1004: "internal error: split_scns, size of %.8s exceeds its new displacement", ! 1005: osp->oshdr.s_name); ! 1006: ! 1007: osp->oshdr.s_size = newdisp; ! 1008: isp->isincnxt = NULL; ! 1009: inscadd(isp, osp); ! 1010: } ! 1011: else if ( osp->oshdr.s_size != 0 ) { ! 1012: nxtisp = isp; /* back up to reprocess */ ! 1013: newosp = (OUTSECT *) myalloc(sizeof(OUTSECT)); ! 1014: numoutsc++; ! 1015: sprintf(newname, "%c%x%.6s", *oldname, ! 1016: scnnumber++, oldname + 1); ! 1017: copy(newosp->oshdr.s_name, newname, 8); ! 1018: newosp->oshdr.s_paddr = -1L; ! 1019: newosp->osnext = osp->osnext; ! 1020: osp->osnext = newosp; ! 1021: if( (OUTSECT *) outsclst.tail == osp ) ! 1022: outsclst.tail = (char *) newosp; ! 1023: osp = newosp; ! 1024: newdisp = 0L; ! 1025: startdisp = isp->isdispl; ! 1026: } ! 1027: else if ( isp->ishdr.s_size <= MAXSCNSIZE ) { ! 1028: isp->isincnxt = NULL; ! 1029: inscadd(isp, osp); ! 1030: } ! 1031: else ! 1032: lderror(1,0,NULL, "section %.8s in file %s is too big", ! 1033: isp->ishdr.s_name, isp->isfilptr->flname); ! 1034: } ! 1035: ! 1036: } ! 1037: ! 1038: } ! 1039: /*eject*/ ! 1040: psize() ! 1041: { ! 1042: /* ! 1043: * Determine the size of the patch list. This is done by looking for ! 1044: * all output sections having the name of ".patchnn", where nn is a ! 1045: * two-digit number ! 1046: * ! 1047: * This routine returns, as an int value, the size of the patch list ! 1048: */ ! 1049: ! 1050: register int index, space; ! 1051: char pname[10]; ! 1052: OUTSECT *fndoutsec(); ! 1053: ! 1054: if( ! pflag ) ! 1055: return( 0 ); ! 1056: else ! 1057: space = sizeof(long); ! 1058: ! 1059: /* ! 1060: * Patch sections, if they exist, must be named consecutively, starting ! 1061: * at ".patch00" ! 1062: */ ! 1063: ! 1064: for( index = 0; index < 100; index++ ) { ! 1065: if (index < 10) ! 1066: sprintf(pname, ".patch0%d", index); ! 1067: else ! 1068: sprintf( pname, ".patch%d", index ); ! 1069: if( fndoutsec(pname) == NULL ) ! 1070: break; ! 1071: space += PESIZE; ! 1072: } ! 1073: ! 1074: return( space ); ! 1075: } ! 1076: /*eject*/ ! 1077: OUTSECT * ! 1078: fndoutsec(nam) ! 1079: char *nam; ! 1080: { ! 1081: register OUTSECT *p, *q; ! 1082: ! 1083: for( p = (OUTSECT *) outsclst.head; p; p=p->osnext ) { ! 1084: if (p->oshdr.s_flags & STYP_GROUP) ! 1085: for( q = (OUTSECT *) p->osinclhd; q; q=q->osnext ) { ! 1086: if (equal(nam,q->oshdr.s_name,8)) ! 1087: return(q); ! 1088: } ! 1089: else ! 1090: if (equal(nam,p->oshdr.s_name,8)) ! 1091: return(p); ! 1092: } ! 1093: return(NULL); ! 1094: } ! 1095: ! 1096: ! 1097: ! 1098: ! 1099: #if ILDOPT ! 1100: add_extra() ! 1101: { ! 1102: ! 1103: /* If the "-ild" flag was specified, add sections to the output file to ! 1104: * cover any remaining configured memory. ! 1105: */ ! 1106: ! 1107: register ANODE *ap, *newap; /* ptr into avlist */ ! 1108: OUTSECT *osp1, *osp2; /* ptrs to the new output section headers */ ! 1109: int counter; /* used to make unique names */ ! 1110: char sectname[9]; /* new section name */ ! 1111: ! 1112: /* For each remaining area of available memory, create a fake output section ! 1113: * that fits in that area. The purpose of this is to cover all of configured ! 1114: * memory so that the incremental ld will be able to determine the memory ! 1115: * configuration. Increase numoutsc to leave room for the .history section ! 1116: * header. ! 1117: */ ! 1118: ! 1119: numoutsc++; ! 1120: counter = 0; ! 1121: for (ap = (ANODE *) avlist.head; ap; ap = ap->adnext) { ! 1122: if (counter > 99) ! 1123: break; ! 1124: if (ap->adtype != ADAVAIL) ! 1125: continue; ! 1126: if ( ap != (ANODE *) avlist.head && ap->adprev->adtype != ADAVAIL && ! 1127: ap->adprev->adscnptr != NULL && ! 1128: (ap->adprev->adscnptr->oshdr.s_flags & STYP_NOLOAD) && ! 1129: ap != (ANODE *) avlist.tail && ap->adnext->adtype != ADAVAIL && ! 1130: ap->adnext->adscnptr != NULL && ! 1131: (ap->adnext->adscnptr->oshdr.s_flags & STYP_NOLOAD) ) ! 1132: continue; ! 1133: ! 1134: ap->adtype = ADSECT; ! 1135: newap = (ANODE *) myalloc( sizeof(ANODE) + 2 * sizeof(OUTSECT)); ! 1136: osp1 = (OUTSECT *) (newap + 1); ! 1137: osp2 = osp1 + 1; ! 1138: numoutsc += 2; ! 1139: if (counter < 10) ! 1140: sprintf(sectname, ".i_l_d0%d", counter++); ! 1141: else ! 1142: sprintf( sectname, ".i_l_d%d", counter++); ! 1143: copy( osp1->oshdr.s_name, sectname, 8 ); ! 1144: osp1->oshdr.s_flags = STYP_DSECT; ! 1145: ap->adscnptr = osp1; ! 1146: ! 1147: if (counter < 10) ! 1148: sprintf( sectname, ".i_l_d0%d", counter++); ! 1149: else ! 1150: sprintf( sectname, ".i_l_d%d", counter++ ); ! 1151: copy( osp2->oshdr.s_name, sectname, 8 ); ! 1152: osp2->oshdr.s_paddr = ap->adpaddr; ! 1153: osp2->oshdr.s_vaddr = ap->adpaddr; ! 1154: osp2->oshdr.s_size = ap->adsize; ! 1155: osp2->oshdr.s_flags = STYP_DSECT; ! 1156: osp2->osflags = 0; ! 1157: ! 1158: newap->adtype = ADSECT; ! 1159: newap->adpaddr = ap->adpaddr; ! 1160: newap->adsize = ap->adsize; ! 1161: newap->adscnptr = osp2; ! 1162: newap->admemp = ap->admemp; ! 1163: newap->adregp = ap->adregp; ! 1164: listins( l_ADR, &avlist, ap, newap ); ! 1165: } ! 1166: } ! 1167: #endif ! 1168: ! 1169: ! 1170: ! 1171: ! 1172: long ! 1173: check_sect( osptr ) ! 1174: OUTSECT *osptr; ! 1175: { ! 1176: ! 1177: /* ! 1178: * check the flags in the output section. if all the input sections are dummy ! 1179: * sections, the output section should be a dummy section. ! 1180: * If no input section was a regular section and one was a copy section ! 1181: * the output will be a copy section. If any input section was an info ! 1182: * section, the output section will have the info flag on. (Most flags ! 1183: * are not mutually exclusive.) ! 1184: * if a bss section is combined with data or text, the bss section is ! 1185: * initialized, and becomes data. ! 1186: * return the size of the section if the output section is not a dummy ! 1187: * (the size is used in allocating space for a group). ! 1188: */ ! 1189: ! 1190: if ((osptr->osflags & OSDSECT) && !(osptr->osflags & OSREG)) { ! 1191: osptr->oshdr.s_flags |= STYP_DSECT; ! 1192: /* remember COPY section also has OSDSECT on */ ! 1193: if (osptr->osflags & OSCOPY) ! 1194: osptr->oshdr.s_flags |= STYP_COPY; ! 1195: } ! 1196: if (osptr->osflags & OSINFO) ! 1197: osptr->oshdr.s_flags |= STYP_INFO; ! 1198: ! 1199: if ((osptr->oshdr.s_flags & STYP_BSS) && ! 1200: ((osptr->oshdr.s_flags & (STYP_TEXT | STYP_DATA)) || ! 1201: (osptr->osflags & FILL))) { ! 1202: osptr->oshdr.s_flags ^= STYP_BSS; ! 1203: osptr->oshdr.s_flags |= STYP_DATA; ! 1204: } ! 1205: ! 1206: if ( !(osptr->oshdr.s_flags & BASIC_TYPES)) ! 1207: if (equal( _TEXT, osptr->oshdr.s_name, 8 )) ! 1208: osptr->oshdr.s_flags |= STYP_TEXT; ! 1209: else if (equal( _DATA, osptr->oshdr.s_name, 8 )) ! 1210: osptr->oshdr.s_flags |= STYP_DATA; ! 1211: else if (equal( _BSS, osptr->oshdr.s_name, 8 )) ! 1212: osptr->oshdr.s_flags |= STYP_BSS; ! 1213: ! 1214: return ((osptr->oshdr.s_flags & STYP_DSECT) ? 0L : osptr->oshdr.s_size); ! 1215: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.