![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPEFInternals.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport|
Return to IOPEFInternals.c CVS log | Up to [Apple XNU] / XNU / iokit / Families / IONDRVSupport |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1997 Apple Computer, Inc. ! 24: * ! 25: * ! 26: * HISTORY ! 27: * ! 28: * sdouglas 22 Oct 97 - first checked in. ! 29: * sdouglas 21 July 98 - start IOKit ! 30: */ ! 31: ! 32: ! 33: ! 34: /* ! 35: File: PEFLoader.c ! 36: ! 37: Contains: PEF loader implementation. ! 38: ! 39: Version: Maxwell ! 40: ! 41: Copyright: � 1994-1996 by Apple Computer, Inc., all rights reserved. ! 42: ! 43: File Ownership: ! 44: ! 45: DRI: Alan Lillich ! 46: ! 47: Other Contact: <<unknown>> ! 48: ! 49: Technology: Core Runtime ! 50: ! 51: Writers: ! 52: ! 53: (AWL) Alan Lillich ! 54: (ELE) Erik Eidt ! 55: ! 56: Change History (most recent first): ! 57: ! 58: <26> 10/4/96 AWL Disable partial unpacking tests. ! 59: <25> 9/26/96 AWL Fix assertions to have the right polarity. ! 60: <24> 9/18/96 AWL Simplify UnpackPartialSection. ! 61: <23> 8/27/96 AWL Support partial unpacking in PEF_UnpackSection. ! 62: <22> 8/23/96 AWL (1379028) Propagate changes from CodeFragmentContainerPriv. ! 63: <21> 8/16/96 AWL Isolate memory utilities to work with both CFM and ProtoCFM. ! 64: <20> 4/18/96 AWL (1342167) Fix problems with relocations for in-place sections. ! 65: <19> 4/2/96 AWL (1336962) Fix checks for missing optional parameters. ! 66: <18> 3/7/96 AWL Remove unused variable in PEF_UnpackSection. ! 67: <17> 2/28/96 AWL Adapt for new container handler model. ! 68: <16> 1/19/96 AWL Changes for D11. ! 69: <15> 10/10/95 AWL Minor cleanup for CodeWarrior's strict checking. ! 70: <14> 6/14/95 AWL Pick up flags from CFMWhere ASAP. ! 71: <13> 5/23/95 AWL Introduce temporary hack to workaround build problem for 68K ! 72: ModernOS booting code. *** THIS BREAKS REAL 68K BUILDS! *** ! 73: <12> 2/8/95 AWL Update debug output calls. ! 74: <11> 12/14/94 AWL Changes for Maxwell D4 build. ! 75: <10> 12/2/94 AWL Disable reexported import optimization because of problems with ! 76: missing weak libraries. It could be put back later with the ! 77: addition of a "resolvedImports" bit vector. ! 78: <9> 9/9/94 AWL Switch to the "real" API and SPI headers. ! 79: <8> 9/2/94 AWL Error codes are now in Errors.h. ! 80: <7> 7/28/94 AWL Return cfragSymbolNotFound instead of paramErr from ! 81: PLFindExportInfo. (#1177313) ! 82: <6> 7/12/94 AWL Fix load-in-place processing in SetRegionAddress. ! 83: <5> 6/20/94 AWL Allow the CFL info pointer to be NULL for a "get procs" call to ! 84: OpenContainer. ! 85: <4> 5/9/94 AWL Change PLGetSpecialSectionInfo to handle some of the wierdness ! 86: in nonloaded sections. ! 87: <3> 4/28/94 AWL Simplify cross address space use for booting. Fix problem with ! 88: load in place, should not require SetRegionAddress. ! 89: <2> 2/25/94 AWL Update for Q&D solution to loading across address spaces. ! 90: Fix problem in PLGetSpecialSectionInfo switch statement. ! 91: <1> 2/15/94 AWL Initial checkin for kernel based CFM. ! 92: ! 93: ------------------------------------------------------------------------------------ ! 94: ! 95: <31> 09/15/93 AWL (&ELE) Add CFL prefix to hash functions. ! 96: <30> 09/08/93 ELE (&AWL) Fix sneaky little typo that causes load failure. ! 97: <29> 08/30/93 AWL Add declaration so that 68K native CFM compiles. ! 98: <28> 08/26/93 AWL Move CFTypes.h and CFLoader.h up with other Apple private ! 99: headers. ! 100: <26> 07/08/93 AWL (&ELE) Fixed version field names in import file IDs. ! 101: Remove version < 0 checks as versions are unsigned. ! 102: <25> 06/16/93 ELE ELE & AWL Change to New Pool allocation. ! 103: <24> 06/09/93 ELE ELE & AWL Fix bug in GetSpecialSection for debugger. ! 104: <23> 06/09/93 JRG ELE & AWL Changes: ! 105: <22> 06/08/93 ELE (&AWL) Shift to allocation bottleneck. Added support for ! 106: packed data sections. Switched to new CFLoader section ! 107: attribute bits. ! 108: <21> 02/15/93 ELE Changed NewPtr->NewPtrSys ! 109: <20> 02/03/93 ELE Added architecture pass thru to GetVersion per CFL Spec. ! 110: <19> 12/23/92 ELE Fixed bug where init routine was being returned for the ! 111: term routine. ! 112: <17> 10/29/92 ELE GetVersion - added dateStamp. ! 113: <16> 10/01/92 ELE fix bug in use in place, update of header! ! 114: <15> 10/01/92 ELE fix bug in use in place! ! 115: <14> 09/28/92 ELE needed to update field expIndex from Find/GetExportInfo. ! 116: <13> 09/23/92 ELE updated to new PEF format, updated to new CF Loader SPI. ! 117: <12> 09/23/92 ELE Latest version. ! 118: ! 119: */ ! 120: ! 121: ! 122: #include "IOPEFInternals.h" ! 123: ! 124: // =========================================================================================== ! 125: ! 126: #define PEF_Assert(a) if( !(a)) kprintf("PEF_Assert:") ! 127: #define PEF_BlockMove(src,dst,len) memcpy(dst,src,len) ! 128: #define PEF_BlockClear(dst,len) memset(dst,0,len) ! 129: extern Boolean PCFM_CompareBytes ( const Byte * left, ! 130: const Byte * right, ! 131: ByteCount count ); ! 132: #define PEF_CompareBytes(a,b,c) PCFM_CompareBytes(a,b,c) ! 133: ! 134: #define EnableCFMDebugging 0 ! 135: ! 136: // =========================================================================================== ! 137: ! 138: ! 139: enum { ! 140: kPEFHandlerProcCount = 18 ! 141: }; ! 142: ! 143: static CFContHandlerProcs PEFHandlerProcs = { ! 144: kPEFHandlerProcCount, ! 145: kCFContHandlerABIVersion, ! 146: ! 147: PEF_OpenContainer, // 1 ! 148: PEF_CloseContainer, // 2 ! 149: PEF_GetContainerInfo, // 3 ! 150: ! 151: PEF_GetSectionCount, // 4 ! 152: PEF_GetSectionInfo, // 5 ! 153: PEF_FindSectionInfo, // 6 ! 154: PEF_SetSectionAddress, // 7 ! 155: ! 156: PEF_GetAnonymousSymbolLocations, // 8 ! 157: ! 158: PEF_GetExportedSymbolCount, // 9 ! 159: PEF_GetExportedSymbolInfo, // 10 ! 160: PEF_FindExportedSymbolInfo, // 11 ! 161: ! 162: PEF_GetImportCounts, // 12 ! 163: PEF_GetImportedLibraryInfo, // 13 ! 164: PEF_GetImportedSymbolInfo, // 14 ! 165: PEF_SetImportedSymbolAddress, // 15 ! 166: ! 167: PEF_UnpackSection, // 16 ! 168: PEF_RelocateSection, // 17 ! 169: PEF_RelocateImportsOnly, // 18 ! 170: }; ! 171: ! 172: ! 173: #if EnableCFMDebugging ! 174: static char gDebugMessage [256]; ! 175: #endif ! 176: ! 177: // =========================================================================================== ! 178: ! 179: const unsigned char opcode [128] = { ! 180: krDDAT,krDDAT,krDDAT,krDDAT, krDDAT,krDDAT,krDDAT,krDDAT, ! 181: krDDAT,krDDAT,krDDAT,krDDAT, krDDAT,krDDAT,krDDAT,krDDAT, ! 182: krDDAT,krDDAT,krDDAT,krDDAT, krDDAT,krDDAT,krDDAT,krDDAT, ! 183: krDDAT,krDDAT,krDDAT,krDDAT, krDDAT,krDDAT,krDDAT,krDDAT, ! 184: ! 185: krCODE,krDATA,krDESC,krDSC2, krVTBL,krSYMR,krXXXX,krXXXX, ! 186: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 187: krSYMB,krCDIS,krDTIS,krSECN, krXXXX,krXXXX,krXXXX,krXXXX, ! 188: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 189: ! 190: krDELT,krDELT,krDELT,krDELT, krDELT,krDELT,krDELT,krDELT, ! 191: krRPT ,krRPT ,krRPT ,krRPT , krRPT ,krRPT ,krRPT ,krRPT , ! 192: krLABS,krLABS,krLSYM,krLSYM, krXXXX,krXXXX,krXXXX,krXXXX, ! 193: krLRPT,krLRPT,krLSEC,krLSEC, krXXXX,krXXXX,krXXXX,krXXXX, ! 194: ! 195: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 196: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 197: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 198: krXXXX,krXXXX,krXXXX,krXXXX, krXXXX,krXXXX,krXXXX,krXXXX, ! 199: }; ! 200: ! 201: // � ! 202: // =========================================================================================== ! 203: // GetNameLength () ! 204: // ================ ! 205: ! 206: ! 207: static ByteCount GetNameLength ( BytePtr nameStart ) ! 208: { ! 209: BytePtr nameEnd = nameStart; ! 210: ! 211: ! 212: if ( nameStart != NULL ) { ! 213: while ( *nameEnd != 0 ) nameEnd += 1; ! 214: } ! 215: ! 216: return (nameEnd - nameStart); ! 217: ! 218: ! 219: } // GetNameLength () ! 220: ! 221: ! 222: // � ! 223: // =========================================================================================== ! 224: // FindRelocationInfo () ! 225: // ===================== ! 226: ! 227: ! 228: static LoaderRelExpHeader * FindRelocationInfo ( PEFPrivateInfo * pefPrivate, ! 229: ItemCount sectionIndex ) ! 230: { ! 231: LoaderRelExpHeader * relocInfo = NULL; ! 232: const ItemCount loopLimit = pefPrivate->ldrHeader->numSections; ! 233: ItemCount relocIndex; ! 234: ! 235: ! 236: for ( relocIndex = 0; relocIndex < loopLimit; relocIndex += 1 ) { ! 237: relocInfo = &pefPrivate->ldrSections[relocIndex]; ! 238: if ( sectionIndex == relocInfo->sectionNumber ) return relocInfo; ! 239: } ! 240: return NULL; ! 241: ! 242: ! 243: } // FindRelocationInfo () ! 244: ! 245: ! 246: // � ! 247: // =========================================================================================== ! 248: // GetSectionName () ! 249: // ================= ! 250: ! 251: ! 252: static void GetSectionName ( PEFPrivateInfo * pefPrivate, ! 253: SectionHeader * sectionHeader, ! 254: CFContHashedName * sectionName ) ! 255: { ! 256: CFContStringHash nameHash = 0; ! 257: BytePtr nameText = NULL; ! 258: ByteCount nameLength; ! 259: ! 260: ! 261: if ( sectionHeader->sectionName != -1 ) { ! 262: nameText = pefPrivate->stringTable + sectionHeader->sectionName; ! 263: nameLength = GetNameLength ( nameText ); ! 264: nameHash = CFContHashName ( nameText, nameLength ); ! 265: } ! 266: ! 267: sectionName->nameHash = nameHash; ! 268: sectionName->nameText = nameText; ! 269: ! 270: ! 271: } // GetSectionName () ! 272: ! 273: ! 274: // � ! 275: // =========================================================================================== ! 276: // PEF_OpenContainer () ! 277: // ==================== ! 278: ! 279: ! 280: OSStatus PEF_OpenContainer ( LogicalAddress mappedAddress, ! 281: LogicalAddress runningAddress, ! 282: ByteCount containerLength, ! 283: KernelProcessID runningProcessID, ! 284: const CFContHashedName * cfragName, ! 285: CFContOpenOptions options, ! 286: CFContAllocateMem Allocate, ! 287: CFContReleaseMem Release, ! 288: CFContHandlerRef * containerRef, ! 289: CFContHandlerProcsPtr * handlerProcs ) ! 290: { ! 291: #pragma unused ( containerLength ) ! 292: #pragma unused ( runningProcessID ) ! 293: #pragma unused ( cfragName ) ! 294: ! 295: OSStatus err = -1;//cfragCFMInternalErr; ! 296: FileHeader * fileHeader = (FileHeader *) mappedAddress; ! 297: PEFPrivateInfo * pefPrivate = NULL; ! 298: SectionHeader * loaderSection = NULL; ! 299: SInt32 sectionIndex; ! 300: ! 301: ! 302: if ( (sizeof ( PEF_SBits32 ) != 4) | (sizeof ( PEF_UBits32 ) != 4) ) goto InternalError; // ! Is "int" 32 bits? ! 303: ! 304: if ( (Allocate == NULL) || ! 305: (Release == NULL) || ! 306: (containerRef == NULL) || ! 307: (handlerProcs == NULL) ) goto ParameterError; ! 308: ! 309: *containerRef = NULL; // Clear for errors, only set on OK path. ! 310: *handlerProcs = NULL; ! 311: ! 312: ! 313: // --------------------------------------------------------------------------------- ! 314: // Allow the container address to be null as a special case to get the loader procs. ! 315: // Otherwise validate the header as acceptable PEF. ! 316: ! 317: if ( mappedAddress == NULL ) goto OK; ! 318: ! 319: if ( (fileHeader->magic1 != kPEFMagic1) || ! 320: (fileHeader->magic2 != kPEFMagic2) || ! 321: (fileHeader->fileTypeID != kPEFTypeID) || ! 322: (fileHeader->versionNumber != kPEFVersion) ) goto FragmentFormatError; ! 323: ! 324: ! 325: // ----------------------------------------------- ! 326: // Allocate and initialize the private info block. ! 327: ! 328: pefPrivate = (PEFPrivateInfo *) ((*Allocate) ( sizeof ( PEFPrivateInfo ) )); ! 329: if ( pefPrivate == NULL ) goto PrivateMemoryError; ! 330: ! 331: PEF_BlockClear ( pefPrivate, sizeof ( *pefPrivate ) ); ! 332: ! 333: pefPrivate->Allocate = Allocate; ! 334: pefPrivate->Release = Release; ! 335: pefPrivate->mappedContainer = (BytePtr) mappedAddress; ! 336: pefPrivate->runningContainer = (BytePtr) runningAddress; ! 337: pefPrivate->sectionCount = fileHeader->loadableSections; ! 338: pefPrivate->sections = (SectionHeader *) (fileHeader + 1); ! 339: pefPrivate->stringTable = (BytePtr) (&pefPrivate->sections[fileHeader->numberSections]); ! 340: pefPrivate->loadInPlace = ((options & kCFContPrepareInPlaceMask) != 0); ! 341: ! 342: // ----------------------------------------------------- ! 343: // Find the loader section and extract important fields. ! 344: ! 345: for ( sectionIndex = 0; sectionIndex < fileHeader->numberSections; sectionIndex += 1 ) { ! 346: loaderSection = & pefPrivate->sections[sectionIndex]; ! 347: if ( loaderSection->regionKind == kPEFLoaderSection ) break; ! 348: } ! 349: if ( sectionIndex == fileHeader->numberSections ) goto FragmentCorruptError; ! 350: ! 351: pefPrivate->ldrSectionNo = sectionIndex; ! 352: pefPrivate->ldrHeader = (LoaderHeader *) ((BytePtr)mappedAddress + loaderSection->containerOffset); ! 353: pefPrivate->ldrStringTable = (BytePtr)pefPrivate->ldrHeader + pefPrivate->ldrHeader->stringsOffset; ! 354: ! 355: pefPrivate->ldrImportFiles = (LoaderImportFileID *) (pefPrivate->ldrHeader + 1); ! 356: pefPrivate->ldrImportSymbols = (LoaderImport *) (pefPrivate->ldrImportFiles + pefPrivate->ldrHeader->numImportFiles); ! 357: pefPrivate->ldrSections = (LoaderRelExpHeader *) (pefPrivate->ldrImportSymbols + pefPrivate->ldrHeader->numImportSyms); ! 358: pefPrivate->ldrRelocations = (BytePtr)pefPrivate->ldrHeader + pefPrivate->ldrHeader->relocationsOffset; ! 359: ! 360: pefPrivate->ldrHashSlot = (HashSlotEntry *) ((BytePtr)pefPrivate->ldrHeader + pefPrivate->ldrHeader->hashSlotTable); ! 361: pefPrivate->ldrHashChain = (HashChainEntry *) (pefPrivate->ldrHashSlot + (1 << pefPrivate->ldrHeader->hashSlotTabSize)); ! 362: pefPrivate->ldrExportSymbols = (LoaderExport *) (pefPrivate->ldrHashChain + pefPrivate->ldrHeader->numExportSyms); ! 363: ! 364: // ---------------------------------------------------- ! 365: // Set up the array to store resolved import addresses. ! 366: ! 367: if ( pefPrivate->ldrHeader->numImportSyms > 0 ) { ! 368: pefPrivate->imports = (BytePtr *) ((*Allocate) ( pefPrivate->ldrHeader->numImportSyms * sizeof ( BytePtr ) )); ! 369: if ( pefPrivate->imports == NULL ) goto PrivateMemoryError; ! 370: } ! 371: ! 372: // ----------------------------------------------------------------- ! 373: // Set up the pointers to the arrays of section origins and offsets. ! 374: ! 375: if (pefPrivate->sectionCount <= kBuiltinSectionArraySize) { ! 376: pefPrivate->mappedOrigins = & pefPrivate->originArray[0]; ! 377: pefPrivate->runningOffsets = & pefPrivate->offsetArray[0]; ! 378: } else { ! 379: pefPrivate->mappedOrigins = (BytePtr *) ((*Allocate) ( pefPrivate->sectionCount * sizeof ( BytePtr ) )); ! 380: if ( pefPrivate->mappedOrigins == NULL ) goto PrivateMemoryError; ! 381: pefPrivate->runningOffsets = (ByteCount *) ((*Allocate) ( pefPrivate->sectionCount * sizeof ( ByteCount ) )); ! 382: if ( pefPrivate->runningOffsets == NULL ) goto PrivateMemoryError; ! 383: } ! 384: ! 385: // --------------------------------------------------------------------------------------- ! 386: // Fill in the origin and offset arrays. The origin array gives the base address of the ! 387: // section instance as visible in the loader's address space. I.e. it tells the loader ! 388: // where it can access the loaded section contents. The offset array tells what to add ! 389: // for relocations refering to that section. So it must be based on running addresses and ! 390: // must "remove" the presumed running address. If the section will be used in place we ! 391: // must compute the final values here. Otherwise SetRegionAddress will be called later to ! 392: // provide the mapped and running addresses. Validate load in place restrictions too. ! 393: ! 394: // ??? We really ought to consider getting rid of the preset for in-place usage and make ! 395: // ??? that case as close as possible to the normal case. ! 396: ! 397: // ! Note that although the ByteCount type used in the offset arrays is unsigned, ignoring ! 398: // ! overflow lets things work right for a full -4GB to +4GB offset range. ! 399: ! 400: for ( sectionIndex = 0; sectionIndex < pefPrivate->sectionCount; sectionIndex += 1 ) { ! 401: ! 402: SectionHeader * section = & pefPrivate->sections[sectionIndex]; ! 403: ! 404: pefPrivate->mappedOrigins[sectionIndex] = (BytePtr) -1; // ! Just a diagnostic tag. ! 405: pefPrivate->runningOffsets[sectionIndex] = - ((ByteCount) section->sectionAddress); // Subtract the presumed address. ! 406: ! 407: if ( pefPrivate->loadInPlace ) { ! 408: if ( (section->regionKind == kPEFPIDataSection) || (section->execSize != section->rawSize) ) goto FragmentUsageError; ! 409: section->sectionAddress = pefPrivate->runningContainer + section->containerOffset; ! 410: pefPrivate->mappedOrigins[sectionIndex] = pefPrivate->mappedContainer + section->containerOffset; ! 411: pefPrivate->runningOffsets[sectionIndex] += (ByteCount) section->sectionAddress; // Add in the new address. ! 412: } ! 413: ! 414: } ! 415: ! 416: if ( options & kCFContPrepareInPlaceMask ) fileHeader->memoryAddress = runningAddress; ! 417: ! 418: ! 419: OK: ! 420: err = noErr; ! 421: *handlerProcs = &PEFHandlerProcs; ! 422: *containerRef = (CFContHandlerRef) pefPrivate; ! 423: ! 424: EXIT: ! 425: return err; ! 426: ! 427: ERROR: ! 428: (void) PEF_CloseContainer ( (CFContHandlerRef) pefPrivate, kNilOptions ); ! 429: goto EXIT; ! 430: ! 431: InternalError: ! 432: err = cfragCFMInternalErr; ! 433: goto ERROR; ! 434: ! 435: ParameterError: ! 436: err = paramErr; ! 437: goto ERROR; ! 438: ! 439: FragmentFormatError: ! 440: err = cfragFragmentFormatErr; ! 441: goto ERROR; ! 442: ! 443: PrivateMemoryError: ! 444: err = cfragNoPrivateMemErr; ! 445: goto ERROR; ! 446: ! 447: FragmentCorruptError: ! 448: err = cfragFragmentCorruptErr; ! 449: goto ERROR; ! 450: ! 451: FragmentUsageError: ! 452: err = cfragFragmentUsageErr; ! 453: goto ERROR; ! 454: ! 455: ! 456: } // PEF_OpenContainer () ! 457: ! 458: ! 459: // � ! 460: // =========================================================================================== ! 461: // PEF_CloseContainer () ! 462: // ===================== ! 463: ! 464: ! 465: OSStatus PEF_CloseContainer ( CFContHandlerRef containerRef, ! 466: CFContCloseOptions options ) ! 467: { ! 468: OSStatus err = cfragCFMInternalErr; ! 469: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 470: CFContReleaseMem Release = NULL; ! 471: ! 472: ! 473: if ( pefPrivate == NULL ) goto OK; // Simplifies error cleanup from PEF_OpenContainer. ! 474: ! 475: ! 476: Release = pefPrivate->Release; ! 477: ! 478: if ( pefPrivate->sectionCount > kBuiltinSectionArraySize ) { ! 479: if ( pefPrivate->mappedOrigins != NULL ) { ! 480: (*Release) ( pefPrivate->mappedOrigins ); ! 481: pefPrivate->mappedOrigins = NULL; ! 482: } ! 483: if ( pefPrivate->runningOffsets != NULL ) { ! 484: (*Release) ( pefPrivate->runningOffsets ); ! 485: pefPrivate->runningOffsets = NULL; ! 486: } ! 487: } ! 488: ! 489: if ( pefPrivate->imports != NULL ) { ! 490: (*Release) ( pefPrivate->imports ); ! 491: pefPrivate->imports = NULL; ! 492: } ! 493: ! 494: pefPrivate->resolved = 0; // ! Disables reexported import optimization. ! 495: ! 496: if ( ! (options & kCFContPartialCloseMask) ) (*Release) ( pefPrivate ); ! 497: ! 498: ! 499: OK: ! 500: err = noErr; ! 501: return err; ! 502: ! 503: } // PEF_CloseContainer () ! 504: ! 505: ! 506: // � ! 507: // =========================================================================================== ! 508: // PEF_GetContainerInfo () ! 509: // ======================= ! 510: ! 511: ! 512: OSStatus PEF_GetContainerInfo ( CFContHandlerRef containerRef, ! 513: PBVersion infoVersion, ! 514: CFContContainerInfo * containerInfo ) ! 515: { ! 516: OSStatus err = cfragCFMInternalErr; ! 517: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 518: FileHeader * fileHeader = NULL; ! 519: ! 520: ! 521: if ( (pefPrivate == NULL) || (containerInfo == NULL) ) goto ParameterError; ! 522: if ( infoVersion != kCFContContainerInfoVersion ) goto ParameterError; ! 523: ! 524: ! 525: fileHeader = (FileHeader *) pefPrivate->mappedContainer; ! 526: ! 527: containerInfo->cfragName.nameHash = 0; // PEF does not have an embedded name. ! 528: containerInfo->cfragName.nameText = NULL; ! 529: ! 530: containerInfo->modDate = fileHeader->dateTimeStamp; ! 531: containerInfo->architecture = fileHeader->architectureID; ! 532: containerInfo->currentVersion = fileHeader->currentVersion; ! 533: containerInfo->oldImpVersion = fileHeader->oldImpVersion; ! 534: containerInfo->oldDefVersion = fileHeader->oldDefVersion; ! 535: ! 536: err = noErr; ! 537: ! 538: EXIT: ! 539: return err; ! 540: ! 541: ERROR: ! 542: goto EXIT; ! 543: ! 544: ParameterError: ! 545: err = paramErr; ! 546: goto ERROR; ! 547: ! 548: ! 549: } // PEF_GetContainerInfo () ! 550: ! 551: ! 552: // � ! 553: // =========================================================================================== ! 554: // PEF_GetSectionCount () ! 555: // ====================== ! 556: ! 557: ! 558: OSStatus PEF_GetSectionCount ( CFContHandlerRef containerRef, ! 559: ItemCount * sectionCount ) ! 560: { ! 561: OSStatus err = cfragCFMInternalErr; ! 562: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 563: ! 564: ! 565: if ( (pefPrivate == NULL) || (sectionCount == NULL) ) goto ParameterError; ! 566: ! 567: *sectionCount = pefPrivate->sectionCount; ! 568: ! 569: err = noErr; ! 570: ! 571: EXIT: ! 572: return err; ! 573: ! 574: ERROR: ! 575: goto EXIT; ! 576: ! 577: ParameterError: ! 578: err = paramErr; ! 579: goto ERROR; ! 580: ! 581: ! 582: } // PEF_GetSectionCount () ! 583: ! 584: ! 585: // � ! 586: // =========================================================================================== ! 587: // PEF_GetSectionInfo () ! 588: // ===================== ! 589: ! 590: ! 591: OSStatus PEF_GetSectionInfo ( CFContHandlerRef containerRef, ! 592: ItemCount sectionIndex, ! 593: PBVersion infoVersion, ! 594: CFContSectionInfo * sectionInfo ) ! 595: { ! 596: OSStatus err = cfragCFMInternalErr; ! 597: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 598: SectionHeader * sectionHeader = NULL; ! 599: ! 600: ! 601: if ( (pefPrivate == NULL) || (sectionInfo == NULL) ) goto ParameterError; ! 602: if ( infoVersion != kCFContSectionInfoVersion ) goto ParameterError; ! 603: if ( sectionIndex >= pefPrivate->sectionCount ) goto ParameterError; ! 604: ! 605: ! 606: sectionHeader = &pefPrivate->sections[sectionIndex]; ! 607: ! 608: GetSectionName ( pefPrivate, sectionHeader, §ionInfo->sectionName ); ! 609: ! 610: sectionInfo->sharing = sectionHeader->shareKind; ! 611: sectionInfo->alignment = sectionHeader->alignment; ! 612: sectionInfo->reservedA = 0; ! 613: sectionInfo->containerOffset = sectionHeader->containerOffset; ! 614: sectionInfo->containerLength = sectionHeader->rawSize; ! 615: sectionInfo->unpackedLength = sectionHeader->initSize; ! 616: sectionInfo->totalLength = sectionHeader->execSize; ! 617: sectionInfo->defaultAddress = sectionHeader->sectionAddress; ! 618: ! 619: sectionInfo->options = kNilOptions; ! 620: if ( FindRelocationInfo ( pefPrivate, sectionIndex ) != NULL ) sectionInfo->options |= kRelocatedCFContSectionMask; ! 621: ! 622: switch ( pefPrivate->sections[sectionIndex].regionKind ) { ! 623: case kPEFCodeSection : ! 624: sectionInfo->access = kCFContNormalCode; ! 625: break; ! 626: case kPEFDataSection : ! 627: sectionInfo->access = kCFContWriteableData; ! 628: break; ! 629: case kPEFPIDataSection : ! 630: sectionInfo->access = kCFContWriteableData; ! 631: sectionInfo->options |= kPackedCFContSectionMask; ! 632: break; ! 633: case kPEFConstantSection : ! 634: sectionInfo->access = kCFContReadOnlyData; ! 635: break; ! 636: case kPEFExecDataSection : ! 637: sectionInfo->access = kCFContWriteableData | kCFContMemExecuteMask; ! 638: break; ! 639: default : ! 640: sectionInfo->access = kCFContReadOnlyData; // ! Not necessarily right, but safe. ! 641: break; ! 642: } ! 643: ! 644: err = noErr; ! 645: ! 646: EXIT: ! 647: return err; ! 648: ! 649: ERROR: ! 650: goto EXIT; ! 651: ! 652: ParameterError: ! 653: err = paramErr; ! 654: goto ERROR; ! 655: ! 656: ! 657: } // PEF_GetSectionInfo () ! 658: ! 659: ! 660: // � ! 661: // =========================================================================================== ! 662: // PEF_FindSectionInfo () ! 663: // ====================== ! 664: ! 665: ! 666: OSStatus PEF_FindSectionInfo ( CFContHandlerRef containerRef, ! 667: const CFContHashedName * sectionName, ! 668: PBVersion infoVersion, ! 669: ItemCount * sectionIndex, // May be null. ! 670: CFContSectionInfo * sectionInfo ) // May be null. ! 671: { ! 672: OSStatus err = cfragCFMInternalErr; ! 673: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 674: SectionHeader * sectionHeader = NULL; ! 675: CFContHashedName hashedName; ! 676: ! 677: ItemCount tempIndex; ! 678: CFContSectionInfo tempInfo; ! 679: ! 680: ! 681: if ( pefPrivate == NULL ) goto ParameterError; ! 682: if ( (sectionInfo != NULL) && (infoVersion != kCFContSectionInfoVersion) ) goto ParameterError; ! 683: ! 684: if ( sectionIndex == NULL ) sectionIndex = &tempIndex; ! 685: if ( sectionInfo == NULL ) sectionInfo = &tempInfo; ! 686: ! 687: ! 688: for ( tempIndex = 0; tempIndex < pefPrivate->sectionCount; tempIndex += 1 ) { ! 689: sectionHeader = &pefPrivate->sections[tempIndex]; ! 690: GetSectionName ( pefPrivate, sectionHeader, &hashedName ); ! 691: if ( (hashedName.nameHash == sectionName->nameHash) && ! 692: (PEF_CompareBytes ( hashedName.nameText, sectionName->nameText, CFContStringHashLength ( hashedName.nameHash ) )) ) break; ! 693: } ! 694: if ( tempIndex == pefPrivate->sectionCount ) goto NoSectionError; ! 695: *sectionIndex = tempIndex; ! 696: ! 697: err = PEF_GetSectionInfo ( containerRef, tempIndex, infoVersion, sectionInfo ); ! 698: if ( err != noErr ) goto ERROR; ! 699: ! 700: err = noErr; ! 701: ! 702: EXIT: ! 703: return err; ! 704: ! 705: ERROR: ! 706: goto EXIT; ! 707: ! 708: ParameterError: ! 709: err = paramErr; ! 710: goto ERROR; ! 711: ! 712: NoSectionError: ! 713: err = cfragNoSectionErr; ! 714: goto ERROR; ! 715: ! 716: ! 717: } // PEF_FindSectionInfo () ! 718: ! 719: ! 720: // � ! 721: // =========================================================================================== ! 722: // PEF_SetSectionAddress () ! 723: // ======================== ! 724: ! 725: ! 726: OSStatus PEF_SetSectionAddress ( CFContHandlerRef containerRef, ! 727: ItemCount sectionIndex, ! 728: LogicalAddress mappedAddress, ! 729: LogicalAddress runningAddress ) ! 730: { ! 731: OSErr err = cfragCFMInternalErr; ! 732: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 733: SectionHeader * section = NULL; ! 734: ! 735: ! 736: if ( (pefPrivate == NULL) || (sectionIndex >= pefPrivate->sectionCount) ) goto ParameterError; ! 737: ! 738: ! 739: // -------------------------------------------------------------------------------------- ! 740: // For a load in place usage we've already set the addresses, make sure these match. ! 741: // Otherwise set both addresses. Note that the "presumed" address is already subtracted. ! 742: ! 743: section = & pefPrivate->sections[sectionIndex]; ! 744: ! 745: if ( ! pefPrivate->loadInPlace ) { ! 746: ! 747: pefPrivate->mappedOrigins[sectionIndex] = (BytePtr) mappedAddress; ! 748: pefPrivate->runningOffsets[sectionIndex] += (ByteCount) runningAddress; ! 749: ! 750: } else { ! 751: ! 752: if ( (runningAddress != section->sectionAddress) || ! 753: (mappedAddress != pefPrivate->mappedOrigins[sectionIndex]) ) goto UsageError; ! 754: ! 755: } ! 756: ! 757: err = noErr; ! 758: ! 759: EXIT: ! 760: return err; ! 761: ! 762: ERROR: ! 763: goto EXIT; ! 764: ! 765: ParameterError: ! 766: err = paramErr; ! 767: goto ERROR; ! 768: ! 769: UsageError: ! 770: err = cfragFragmentUsageErr; ! 771: goto ERROR; ! 772: ! 773: ! 774: } // PEF_SetSectionAddress () ! 775: ! 776: ! 777: // � ! 778: // =========================================================================================== ! 779: // PEF_GetAnonymousSymbolLocations () ! 780: // ================================== ! 781: ! 782: ! 783: extern OSStatus PEF_GetAnonymousSymbolLocations ( CFContHandlerRef containerRef, ! 784: CFContLogicalLocation * mainLocation, // May be null. ! 785: CFContLogicalLocation * initLocation, // May be null. ! 786: CFContLogicalLocation * termLocation ) // May be null. ! 787: { ! 788: OSStatus err = cfragCFMInternalErr; ! 789: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 790: LoaderHeader * ldrHeader = NULL; ! 791: ! 792: CFContLogicalLocation tempLocation; ! 793: ! 794: ! 795: if ( (pefPrivate == NULL) ) goto ParameterError; ! 796: ! 797: if ( mainLocation == NULL ) mainLocation = &tempLocation; ! 798: if ( initLocation == NULL ) initLocation = &tempLocation; ! 799: if ( termLocation == NULL ) termLocation = &tempLocation; ! 800: ! 801: ! 802: ldrHeader = pefPrivate->ldrHeader; ! 803: ! 804: mainLocation->section = ldrHeader->entryPointSection; ! 805: mainLocation->offset = ldrHeader->entryPointOffset; ! 806: ! 807: initLocation->section = ldrHeader->initPointSection; ! 808: initLocation->offset = ldrHeader->initPointOffset; ! 809: ! 810: termLocation->section = ldrHeader->termPointSection; ! 811: termLocation->offset = ldrHeader->termPointOffset; ! 812: ! 813: err = noErr; ! 814: ! 815: EXIT: ! 816: return err; ! 817: ! 818: ERROR: ! 819: goto EXIT; ! 820: ! 821: ParameterError: ! 822: err = paramErr; ! 823: goto ERROR; ! 824: ! 825: ! 826: } // PEF_GetAnonymousSymbolLocations () ! 827: ! 828: ! 829: // � ! 830: // =========================================================================================== ! 831: // PEF_GetExportedSymbolCount () ! 832: // ============================= ! 833: ! 834: ! 835: extern OSStatus PEF_GetExportedSymbolCount ( CFContHandlerRef containerRef, ! 836: ItemCount * exportCount ) ! 837: { ! 838: OSStatus err = cfragCFMInternalErr; ! 839: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 840: ! 841: ! 842: if ( (pefPrivate == NULL) || (exportCount == NULL) ) goto ParameterError; ! 843: ! 844: *exportCount = pefPrivate->ldrHeader->numExportSyms; ! 845: ! 846: err = noErr; ! 847: ! 848: EXIT: ! 849: return err; ! 850: ! 851: ERROR: ! 852: goto EXIT; ! 853: ! 854: ParameterError: ! 855: err = paramErr; ! 856: goto ERROR; ! 857: ! 858: ! 859: } // PEF_GetExportedSymbolCount () ! 860: ! 861: ! 862: // � ! 863: // =========================================================================================== ! 864: // PEF_GetExportedSymbolInfo () ! 865: // ============================ ! 866: ! 867: ! 868: OSStatus PEF_GetExportedSymbolInfo ( CFContHandlerRef containerRef, ! 869: CFContSignedIndex exportIndex, ! 870: PBVersion infoVersion, ! 871: CFContExportedSymbolInfo * exportInfo ) ! 872: { ! 873: OSStatus err = cfragCFMInternalErr; ! 874: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 875: LoaderExport * exportedSymbol = NULL; ! 876: ! 877: ! 878: if ( (pefPrivate == NULL) || (exportInfo == NULL) ) goto ParameterError; ! 879: if ( exportIndex >= pefPrivate->ldrHeader->numExportSyms ) goto ParameterError; ! 880: if ( infoVersion != kCFContExportedSymbolInfoVersion ) goto ParameterError; ! 881: ! 882: ! 883: if ( exportIndex >= 0 ) { ! 884: ! 885: exportedSymbol = &pefPrivate->ldrExportSymbols[exportIndex]; ! 886: ! 887: exportInfo->symbolName.nameHash = pefPrivate->ldrHashChain[exportIndex].hashword; ! 888: exportInfo->symbolName.nameText = &pefPrivate->ldrStringTable[exportedSymbol->nameOffset]; ! 889: ! 890: exportInfo->symbolClass = exportedSymbol->symClass; ! 891: exportInfo->reservedA = 0; ! 892: exportInfo->reservedB = 0; ! 893: exportInfo->options = kNilOptions; ! 894: ! 895: exportInfo->location.section = exportedSymbol->sectionNumber; ! 896: ! 897: #if 1 // *** Disable the reexported import optimization. ! 898: exportInfo->location.offset = exportedSymbol->offset; ! 899: #else ! 900: // This is the buggy optimization. It has problems with missing weak libraries. ! 901: // Addition of a "resolvedImports" bit vector is probably the way to fix it, but it ! 902: // may not be much of an optimization then. ! 903: if ( (! pefPrivate->resolved) || (exportedSymbol->sectionNumber != kReExportImport) ) { ! 904: exportInfo->location.offset = exportedSymbol->address; ! 905: } else { ! 906: exportInfo->location.section = kPhysicalExport; ! 907: exportInfo->location.offset = pefPrivate->imports[exportedSymbol->address]; ! 908: } ! 909: #endif ! 910: ! 911: } else { ! 912: ! 913: CFContLogicalLocation mainLocation; ! 914: CFContLogicalLocation initLocation; ! 915: CFContLogicalLocation termLocation; ! 916: ! 917: err = PEF_GetAnonymousSymbolLocations ( containerRef, &mainLocation, &initLocation, &termLocation ); ! 918: if ( err != noErr ) goto ERROR; ! 919: ! 920: switch ( exportIndex ) { ! 921: case kMainCFragSymbolIndex : ! 922: exportInfo->location = mainLocation; ! 923: exportInfo->symbolClass = 0xFF; // !!! Ought to have a kUnknownCFragSymbol constant. ! 924: break; ! 925: case kInitCFragSymbolIndex : ! 926: exportInfo->location = initLocation; ! 927: exportInfo->symbolClass = kTVectorCFragSymbol; // ! Very well better be! ! 928: break; ! 929: case kTermCFragSymbolIndex : ! 930: exportInfo->location = termLocation; ! 931: exportInfo->symbolClass = kTVectorCFragSymbol; // ! Very well better be! ! 932: break; ! 933: default : ! 934: goto ParameterError; ! 935: } ! 936: ! 937: exportInfo->symbolName.nameHash = 0; ! 938: exportInfo->symbolName.nameText = NULL; ! 939: ! 940: exportInfo->reservedA = 0; ! 941: exportInfo->reservedB = 0; ! 942: exportInfo->options = kNilOptions; ! 943: ! 944: } ! 945: ! 946: err = noErr; ! 947: ! 948: EXIT: ! 949: return err; ! 950: ! 951: ERROR: ! 952: goto EXIT; ! 953: ! 954: ParameterError: ! 955: err = paramErr; ! 956: goto ERROR; ! 957: ! 958: ! 959: } // PEF_GetExportedSymbolInfo () ! 960: ! 961: ! 962: // � ! 963: // =========================================================================================== ! 964: // PEF_FindExportedSymbolInfo () ! 965: // ============================= ! 966: ! 967: ! 968: OSStatus PEF_FindExportedSymbolInfo ( CFContHandlerRef containerRef, ! 969: const CFContHashedName * exportName, ! 970: PBVersion infoVersion, ! 971: ItemCount * exportIndex_o, // May be null. ! 972: CFContExportedSymbolInfo * exportInfo ) // May be null. ! 973: { ! 974: OSStatus err = cfragCFMInternalErr; ! 975: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 976: LoaderExport * exportedSymbol = NULL; ! 977: CFContStringHash * hashwordList = NULL; ! 978: CFContStringHash * nextHashword = NULL; ! 979: HashSlotEntry * hashSlot = NULL; ! 980: ByteCount nameLength = CFContStringHashLength ( exportName->nameHash ); ! 981: ItemCount exportIndex; ! 982: ItemCount slotIndex; ! 983: ItemCount chainLimit; ! 984: Boolean nameMatch; ! 985: ! 986: ! 987: if ( pefPrivate == NULL ) goto ParameterError; ! 988: if ( infoVersion != kCFContExportedSymbolInfoVersion ) goto ParameterError; ! 989: ! 990: ! 991: hashwordList = &pefPrivate->ldrHashChain[0].hashword; ! 992: ! 993: slotIndex = GetPEFHashSlot ( exportName->nameHash, pefPrivate->ldrHeader->hashSlotTabSize ); ! 994: hashSlot = &pefPrivate->ldrHashSlot[slotIndex]; ! 995: ! 996: exportIndex = hashSlot->chainIndex; ! 997: chainLimit = exportIndex + hashSlot->chainCount; ! 998: nextHashword = &hashwordList[exportIndex]; ! 999: ! 1000: while ( exportIndex < chainLimit ) { ! 1001: ! 1002: if ( *nextHashword == exportName->nameHash ) { ! 1003: exportedSymbol = &pefPrivate->ldrExportSymbols[exportIndex]; ! 1004: nameMatch = PEF_CompareBytes ( exportName->nameText, ! 1005: &pefPrivate->ldrStringTable[exportedSymbol->nameOffset], ! 1006: nameLength ); ! 1007: if ( nameMatch ) goto Found; ! 1008: } ! 1009: ! 1010: exportIndex += 1; ! 1011: nextHashword += 1; // ! Pointer arithmetic. ! 1012: } ! 1013: goto NotFoundError; ! 1014: ! 1015: Found: ! 1016: if ( exportIndex_o != NULL ) *exportIndex_o = exportIndex; ! 1017: if ( exportInfo != NULL ) { ! 1018: err = PEF_GetExportedSymbolInfo ( containerRef, exportIndex, infoVersion, exportInfo ); ! 1019: if ( err != noErr ) goto ERROR; ! 1020: } ! 1021: ! 1022: err = noErr; ! 1023: ! 1024: EXIT: ! 1025: return err; ! 1026: ! 1027: ERROR: ! 1028: goto EXIT; ! 1029: ! 1030: ParameterError: ! 1031: err = paramErr; ! 1032: goto ERROR; ! 1033: ! 1034: NotFoundError: ! 1035: err = cfragNoSymbolErr; ! 1036: goto ERROR; ! 1037: ! 1038: ! 1039: } // PEF_FindExportedSymbolInfo () ! 1040: ! 1041: ! 1042: // � ! 1043: // =========================================================================================== ! 1044: // PEF_GetImportCounts () ! 1045: // ====================== ! 1046: ! 1047: ! 1048: OSStatus PEF_GetImportCounts ( CFContHandlerRef containerRef, ! 1049: ItemCount * libraryCount, // May be null. ! 1050: ItemCount * symbolCount ) // May be null. ! 1051: { ! 1052: OSStatus err = cfragCFMInternalErr; ! 1053: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1054: ! 1055: ! 1056: if ( pefPrivate == NULL ) goto ParameterError; ! 1057: ! 1058: if ( libraryCount != NULL ) *libraryCount = pefPrivate->ldrHeader->numImportFiles; ! 1059: if ( symbolCount != NULL ) *symbolCount = pefPrivate->ldrHeader->numImportSyms; ! 1060: ! 1061: err = noErr; ! 1062: ! 1063: EXIT: ! 1064: return err; ! 1065: ! 1066: ERROR: ! 1067: goto EXIT; ! 1068: ! 1069: ParameterError: ! 1070: err = paramErr; ! 1071: goto ERROR; ! 1072: ! 1073: ! 1074: } // PEF_GetImportCounts () ! 1075: ! 1076: ! 1077: // � ! 1078: // =========================================================================================== ! 1079: // PEF_GetImportedLibraryInfo () ! 1080: // ============================= ! 1081: ! 1082: ! 1083: OSStatus PEF_GetImportedLibraryInfo ( CFContHandlerRef containerRef, ! 1084: ItemCount libraryIndex, ! 1085: PBVersion infoVersion, ! 1086: CFContImportedLibraryInfo * libraryInfo ) ! 1087: { ! 1088: OSStatus err = cfragCFMInternalErr; ! 1089: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1090: LoaderImportFileID * importedLibrary = NULL; ! 1091: BytePtr nameText = NULL; ! 1092: ByteCount nameLength; ! 1093: ! 1094: ! 1095: if ( (pefPrivate == NULL) || (libraryInfo == NULL) ) goto ParameterError; ! 1096: if ( infoVersion != kCFContImportedLibraryInfoVersion ) goto ParameterError; ! 1097: if ( libraryIndex >= pefPrivate->ldrHeader->numImportFiles ) goto ParameterError; ! 1098: ! 1099: ! 1100: importedLibrary = &pefPrivate->ldrImportFiles[libraryIndex]; ! 1101: ! 1102: nameText = &pefPrivate->ldrStringTable[importedLibrary->fileNameOffset]; ! 1103: nameLength = GetNameLength ( nameText ); ! 1104: ! 1105: libraryInfo->libraryName.nameHash = CFContHashName ( nameText, nameLength ); ! 1106: libraryInfo->libraryName.nameText = nameText; ! 1107: ! 1108: libraryInfo->linkedVersion = importedLibrary->linkedVersion; ! 1109: libraryInfo->oldImpVersion = importedLibrary->oldImpVersion; ! 1110: libraryInfo->options = kNilOptions; ! 1111: ! 1112: if ( importedLibrary->options & kPEFInitBeforeMask ) libraryInfo->options |= kCFContInitBeforeMask; ! 1113: if ( importedLibrary->options & kPEFWeakLibraryMask ) libraryInfo->options |= kCFContWeakLibraryMask; ! 1114: if ( importedLibrary->options & kPEFDeferredBindMask ) libraryInfo->options |= kCFContDeferredBindMask; ! 1115: ! 1116: err = noErr; ! 1117: ! 1118: EXIT: ! 1119: return err; ! 1120: ! 1121: ERROR: ! 1122: goto EXIT; ! 1123: ! 1124: ParameterError: ! 1125: err = paramErr; ! 1126: goto ERROR; ! 1127: ! 1128: ! 1129: } // PEF_GetImportedLibraryInfo () ! 1130: ! 1131: ! 1132: // � ! 1133: // =========================================================================================== ! 1134: // PEF_GetImportedSymbolInfo () ! 1135: // ============================ ! 1136: ! 1137: ! 1138: OSStatus PEF_GetImportedSymbolInfo ( CFContHandlerRef containerRef, ! 1139: ItemCount symbolIndex, ! 1140: PBVersion infoVersion, ! 1141: CFContImportedSymbolInfo * symbolInfo ) ! 1142: { ! 1143: OSStatus err = cfragCFMInternalErr; ! 1144: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1145: LoaderImport * importedSymbol = NULL; ! 1146: LoaderImportFileID * importedLibrary = NULL; ! 1147: BytePtr nameText = NULL; ! 1148: ByteCount nameLength; ! 1149: ItemCount libraryCount; ! 1150: ItemCount libraryIndex; ! 1151: ! 1152: ! 1153: if ( (pefPrivate == NULL) || (symbolInfo == NULL) ) goto ParameterError; ! 1154: if ( infoVersion != kCFContImportedSymbolInfoVersion ) goto ParameterError; ! 1155: if ( symbolIndex >= pefPrivate->ldrHeader->numImportSyms ) goto ParameterError; ! 1156: ! 1157: ! 1158: importedSymbol = &pefPrivate->ldrImportSymbols[symbolIndex]; ! 1159: libraryCount = pefPrivate->ldrHeader->numImportFiles; ! 1160: ! 1161: nameText = &pefPrivate->ldrStringTable[importedSymbol->nameOffset]; ! 1162: nameLength = GetNameLength ( nameText ); ! 1163: ! 1164: symbolInfo->symbolName.nameHash = CFContHashName ( nameText, nameLength ); ! 1165: symbolInfo->symbolName.nameText = nameText; ! 1166: ! 1167: symbolInfo->symbolClass = importedSymbol->symClass & 0x0F; ! 1168: symbolInfo->reservedA = 0; ! 1169: symbolInfo->reservedB = 0; ! 1170: symbolInfo->options = 0; ! 1171: ! 1172: if ( importedSymbol->symClass & kPEFWeakSymbolMask ) symbolInfo->options |= kCFContWeakSymbolMask; ! 1173: ! 1174: for ( libraryIndex = 0; libraryIndex < libraryCount; libraryIndex += 1 ) { ! 1175: importedLibrary = &pefPrivate->ldrImportFiles[libraryIndex]; ! 1176: if ( (importedLibrary->impFirst <= symbolIndex) && ! 1177: (symbolIndex < (importedLibrary->impFirst + importedLibrary->numImports)) ) { ! 1178: break; ! 1179: } ! 1180: } ! 1181: if ( libraryIndex == libraryCount ) goto FragmentCorruptError; ! 1182: ! 1183: symbolInfo->libraryIndex = libraryIndex; ! 1184: ! 1185: err = noErr; ! 1186: ! 1187: EXIT: ! 1188: return err; ! 1189: ! 1190: ERROR: ! 1191: goto EXIT; ! 1192: ! 1193: ParameterError: ! 1194: err = paramErr; ! 1195: goto ERROR; ! 1196: ! 1197: FragmentCorruptError: ! 1198: err = cfragFragmentCorruptErr; ! 1199: goto ERROR; ! 1200: ! 1201: ! 1202: } // PEF_GetImportedSymbolInfo () ! 1203: ! 1204: ! 1205: // � ! 1206: // =========================================================================================== ! 1207: // PEF_SetImportedSymbolAddress () ! 1208: // =============================== ! 1209: ! 1210: ! 1211: OSStatus PEF_SetImportedSymbolAddress ( CFContHandlerRef containerRef, ! 1212: ItemCount symbolIndex, ! 1213: LogicalAddress symbolAddress ) ! 1214: { ! 1215: OSStatus err = cfragCFMInternalErr; ! 1216: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1217: ! 1218: ! 1219: if ( pefPrivate == NULL ) goto ParameterError; ! 1220: if ( symbolIndex >= pefPrivate->ldrHeader->numImportSyms ) goto ParameterError; ! 1221: ! 1222: ! 1223: pefPrivate->imports[symbolIndex] = symbolAddress; ! 1224: ! 1225: err = noErr; ! 1226: ! 1227: EXIT: ! 1228: return err; ! 1229: ! 1230: ERROR: ! 1231: goto EXIT; ! 1232: ! 1233: ParameterError: ! 1234: err = paramErr; ! 1235: goto ERROR; ! 1236: ! 1237: ! 1238: } // PEF_SetImportedSymbolAddress () ! 1239: ! 1240: ! 1241: // � ! 1242: // =========================================================================================== ! 1243: // GetPackedDataCount () ! 1244: // ===================== ! 1245: ! 1246: ! 1247: static UInt32 GetPackedDataCount ( UInt8 * * byteHandle ) ! 1248: { ! 1249: UInt32 count = 0; ! 1250: UInt8 * bytePtr = *byteHandle; ! 1251: UInt8 currByte; ! 1252: ! 1253: ! 1254: do { ! 1255: currByte = *bytePtr++; ! 1256: count = (count << kPEFPkDataVCountShift) | (currByte & kPEFPkDataVCountMask); ! 1257: } while ( (currByte & kPEFPkDataVCountEndMask) != 0 ); ! 1258: ! 1259: *byteHandle = bytePtr; ! 1260: ! 1261: return count; ! 1262: ! 1263: ! 1264: } // GetPackedDataCount () ! 1265: ! 1266: ! 1267: // � ! 1268: // =========================================================================================== ! 1269: // UnpackFullSection () ! 1270: // ==================== ! 1271: ! 1272: ! 1273: // ------------------------------------------------------------------------------------------ ! 1274: // This is the "normal" case from CFM, unpacking all of the packed portion. Along the way we ! 1275: // make sure we're not writing beyond the end of the unpacked data. At the end we make sure ! 1276: // that all we didn't read past the end of the packed data, and that all of the output was ! 1277: // written. ! 1278: ! 1279: // ! Note that the xyzEnd pointers are the actual end of the range, not one byte beyond. This ! 1280: // ! routine will work if the output end address is 0xFFFFFFFF, but not if the packed end is. ! 1281: ! 1282: // ! Don't do range comparisons as "(lowAddr + length) > highAddr", because this might wrap ! 1283: // ! the end high end of the address space. Always do "(highAddr - lowAddr) > length". ! 1284: ! 1285: // ??? We should gather some statistics on actual usage to see whether it is worthwhile to ! 1286: // ??? have local customized code for common cases. E.g. block fill of 1, 2, or 4 bytes, or ! 1287: // ??? of interleaved repeats with 1/2/4 byte common or custom portions. ! 1288: ! 1289: ! 1290: static OSStatus UnpackFullSection ( BytePtr packedBase, ! 1291: BytePtr packedEnd, ! 1292: BytePtr outputBase, ! 1293: BytePtr outputEnd ) ! 1294: { ! 1295: OSStatus err = cfragCFMInternalErr; ! 1296: BytePtr packedPos = packedBase; ! 1297: BytePtr outputPos = outputBase; ! 1298: BytePtr outPosLimit = outputEnd + 1; // ! Might be zero if outputEnd is 0xFFFFFFFF. ! 1299: ! 1300: UInt8 currByte; ! 1301: UInt8 opcode; ! 1302: UInt32 count1; ! 1303: UInt32 count2; ! 1304: UInt32 count3; ! 1305: ! 1306: ! 1307: if ( (packedEnd + 1) == 0 ) goto FragmentUsageError; ! 1308: ! 1309: ! 1310: while ( packedPos <= packedEnd ) { ! 1311: ! 1312: ! 1313: currByte = *packedPos++; ! 1314: opcode = currByte >> kPEFPkDataOpcodeShift; ! 1315: count1 = currByte & kPEFPkDataCount5Mask; ! 1316: ! 1317: if ( count1 == 0 ) count1 = GetPackedDataCount ( &packedPos ); ! 1318: ! 1319: ! 1320: switch ( opcode ) { ! 1321: ! 1322: ! 1323: case kPEFPkDataZero : ! 1324: ! 1325: if ( (outPosLimit - outputPos) < count1 ) goto FragmentCorruptError; ! 1326: ! 1327: PEF_BlockClear ( outputPos, count1 ); ! 1328: outputPos += count1; ! 1329: ! 1330: break; ! 1331: ! 1332: ! 1333: case kPEFPkDataBlock : ! 1334: ! 1335: if ( (outPosLimit - outputPos) < count1 ) goto FragmentCorruptError; ! 1336: ! 1337: PEF_BlockMove ( packedPos, outputPos, count1 ); ! 1338: packedPos += count1; ! 1339: outputPos += count1; ! 1340: ! 1341: break; ! 1342: ! 1343: ! 1344: case kPEFPkDataRepeat : // ??? Need a BlockFill routine? ! 1345: ! 1346: count2 = GetPackedDataCount ( &packedPos ) + 1; // ! Stored count is 1 less. ! 1347: ! 1348: if ( (outPosLimit - outputPos) < (count1 * count2) ) goto FragmentCorruptError; ! 1349: ! 1350: if ( count1 == 1 ) { // ??? Is this worth the bother? Other sizes? ! 1351: ! 1352: currByte = *packedPos++; ! 1353: for ( ; count2 != 0; count2 -= 1 ) *outputPos++ = currByte; ! 1354: ! 1355: } else { ! 1356: ! 1357: for ( ; count2 != 0; count2 -= 1 ) { ! 1358: PEF_BlockMove ( packedPos, outputPos, count1 ); ! 1359: outputPos += count1; ! 1360: } ! 1361: packedPos += count1; ! 1362: ! 1363: } ! 1364: ! 1365: break; ! 1366: ! 1367: ! 1368: case kPEFPkDataRepeatBlock : ! 1369: ! 1370: count2 = GetPackedDataCount ( &packedPos ); ! 1371: count3 = GetPackedDataCount ( &packedPos ); ! 1372: ! 1373: if ( (outPosLimit - outputPos) < (((count1 + count2) * count3) + count1) ) goto FragmentCorruptError; ! 1374: ! 1375: { ! 1376: BytePtr commonPos = packedPos; ! 1377: ! 1378: packedPos += count1; // Skip the common part. ! 1379: ! 1380: for ( ; count3 != 0; count3 -= 1 ) { ! 1381: ! 1382: PEF_BlockMove ( commonPos, outputPos, count1 ); ! 1383: outputPos += count1; ! 1384: ! 1385: PEF_BlockMove ( packedPos, outputPos, count2 ); ! 1386: packedPos += count2; ! 1387: outputPos += count2; ! 1388: ! 1389: } ! 1390: ! 1391: PEF_BlockMove ( commonPos, outputPos, count1 ); ! 1392: outputPos += count1; ! 1393: ! 1394: } ! 1395: ! 1396: break; ! 1397: ! 1398: ! 1399: case kPEFPkDataRepeatZero : ! 1400: ! 1401: count2 = GetPackedDataCount ( &packedPos ); ! 1402: count3 = GetPackedDataCount ( &packedPos ); ! 1403: ! 1404: if ( (outPosLimit - outputPos) < (((count1 + count2) * count3) + count1) ) goto FragmentCorruptError; ! 1405: ! 1406: PEF_BlockClear ( outputPos, count1 ); ! 1407: outputPos += count1; ! 1408: ! 1409: for ( ; count3 != 0; count3 -= 1 ) { ! 1410: ! 1411: PEF_BlockMove ( packedPos, outputPos, count2 ); ! 1412: packedPos += count2; ! 1413: outputPos += count2; ! 1414: ! 1415: PEF_BlockClear ( outputPos, count1 ); ! 1416: outputPos += count1; ! 1417: ! 1418: } ! 1419: ! 1420: break; ! 1421: ! 1422: ! 1423: default : ! 1424: goto FragmentCorruptError; ! 1425: ! 1426: } ! 1427: ! 1428: } ! 1429: ! 1430: ! 1431: if ( (packedPos != (packedEnd + 1)) || (outputPos != outPosLimit) ) goto FragmentCorruptError; ! 1432: ! 1433: err = noErr; ! 1434: ! 1435: EXIT: ! 1436: return err; ! 1437: ! 1438: ERROR: ! 1439: goto EXIT; ! 1440: ! 1441: ! 1442: FragmentUsageError: ! 1443: err = cfragFragmentUsageErr; ! 1444: goto ERROR; ! 1445: ! 1446: FragmentCorruptError: ! 1447: err = cfragFragmentCorruptErr; ! 1448: goto ERROR; ! 1449: ! 1450: ! 1451: } // UnpackFullSection () ! 1452: ! 1453: ! 1454: // � ! 1455: // =========================================================================================== ! 1456: // UnpackPartialSection () ! 1457: // ======================= ! 1458: ! 1459: ! 1460: // ------------------------------------------------------------------------------------------- ! 1461: // This is the case where we want to extract some arbitrary portion of a section as it would ! 1462: // be when instantiated but not relocated. We have to interpret the packed part up to the ! 1463: // desired output start, then continue begin unpacking for real. If we run out of packed data ! 1464: // before filling the output, we fill the rest of the output with zeroes. ! 1465: ! 1466: // ! We have to be very careful in the skip logic because the current operation probably spans ! 1467: // ! the skip/output boundary. We have to be similarly careful at the output end because the ! 1468: // ! current operation probably spans the tail of the output. Don't forget that the partial ! 1469: // ! output at the start could also fill the output and overflow the tail! ! 1470: ! 1471: // ! Note that the xyzEnd pointers are the actual end of the range, not one byte beyond. This ! 1472: // ! routine might not work if outputEnd is 0xFFFFFFFF. This is because outputPos points to ! 1473: // ! the next byte to be written. The loops that are controlled by "outputPos < outputBase" ! 1474: // ! or "outputPos <= outputEnd" would fail in this case if outputPos were "outputEnd + 1", ! 1475: // ! i.e. outputPos would be zero. ! 1476: ! 1477: // ! Don't do range comparisons as "(lowAddr + length) > highAddr", because this might wrap ! 1478: // ! the end high end of the address space. Always do "(highAddr - lowAddr) > length". ! 1479: ! 1480: ! 1481: // ------------------------------------------------------------------------------------------- ! 1482: ! 1483: ! 1484: static void PartialBlockClear ( BytePtr outputBase, ! 1485: ByteCount outputStartOffset, ! 1486: ByteCount outputEndOffset, ! 1487: ByteCount outputOffset, ! 1488: ByteCount count ) ! 1489: { ! 1490: ! 1491: if ( ((outputOffset + count) <= outputStartOffset) || (outputOffset > outputEndOffset) ) return; // Nothing to output. ! 1492: ! 1493: if ( outputOffset < outputStartOffset ) { ! 1494: count -= (outputStartOffset - outputOffset); ! 1495: outputOffset = outputStartOffset; ! 1496: } ! 1497: ! 1498: if ( count > (outputEndOffset - outputOffset + 1) ) count = outputEndOffset - outputOffset + 1; ! 1499: ! 1500: PEF_BlockClear ( outputBase + (outputOffset - outputStartOffset), count ); ! 1501: ! 1502: } // PartialBlockClear (); ! 1503: ! 1504: ! 1505: // ------------------------------------------------------------------------------------------- ! 1506: ! 1507: ! 1508: static void PartialBlockMove ( BytePtr source, ! 1509: BytePtr outputBase, ! 1510: ByteCount outputStartOffset, ! 1511: ByteCount outputEndOffset, ! 1512: ByteCount outputOffset, ! 1513: ByteCount count ) ! 1514: { ! 1515: ! 1516: if ( ((outputOffset + count) <= outputStartOffset) || (outputOffset > outputEndOffset) ) return; // Nothing to output. ! 1517: ! 1518: if ( outputOffset < outputStartOffset ) { ! 1519: const ByteCount skipCount = outputStartOffset - outputOffset; ! 1520: source += skipCount; ! 1521: count -= skipCount; ! 1522: outputOffset = outputStartOffset; ! 1523: } ! 1524: ! 1525: if ( count > (outputEndOffset - outputOffset + 1) ) count = outputEndOffset - outputOffset + 1; ! 1526: ! 1527: PEF_BlockMove ( source, outputBase + (outputOffset - outputStartOffset), count ); ! 1528: ! 1529: } // PartialBlockClear (); ! 1530: ! 1531: ! 1532: // ------------------------------------------------------------------------------------------- ! 1533: ! 1534: ! 1535: static OSStatus UnpackPartialSection ( BytePtr packedBase, ! 1536: BytePtr packedEnd, ! 1537: BytePtr outputBase, ! 1538: BytePtr outputEnd, ! 1539: ByteCount outputStartOffset ) ! 1540: { ! 1541: OSStatus err = cfragCFMInternalErr; ! 1542: const ByteCount outputEndOffset = outputStartOffset + (outputEnd - outputBase); ! 1543: BytePtr packedPos = NULL; ! 1544: BytePtr packedBoundary = NULL; ! 1545: ByteCount outputOffset; ! 1546: ByteCount outputBoundary; ! 1547: ! 1548: UInt8 currByte; ! 1549: UInt8 opcode; ! 1550: UInt32 count1; ! 1551: UInt32 count2; ! 1552: UInt32 count3; ! 1553: ! 1554: ! 1555: if ( ((packedEnd + 1) == 0) || ((outputEnd + 1) == 0) ) goto FragmentUsageError; ! 1556: ! 1557: ! 1558: // -------------------------------------------------------------------------------------- ! 1559: // Skip the packed data until we get within the output range. We know there is something ! 1560: // to unpack, otherwise the zero fill of the output would be done by the caller. This ! 1561: // loop sets outputOffset to the end of what would be unpacked, until the outputOffset is ! 1562: // beyond the outputStartOffset. I.e. until we hit the first operation that would create ! 1563: // actual output. ! 1564: ! 1565: outputOffset = 0; ! 1566: packedPos = packedBase; ! 1567: ! 1568: do { ! 1569: ! 1570: packedBoundary = packedPos; // The start of the current operation. ! 1571: outputBoundary = outputOffset; ! 1572: ! 1573: currByte = *packedPos++; ! 1574: opcode = currByte >> kPEFPkDataOpcodeShift; ! 1575: count1 = currByte & kPEFPkDataCount5Mask; ! 1576: ! 1577: if ( count1 == 0 ) count1 = GetPackedDataCount ( &packedPos ); ! 1578: ! 1579: switch ( opcode ) { ! 1580: ! 1581: case kPEFPkDataZero : ! 1582: outputOffset += count1; ! 1583: break; ! 1584: ! 1585: case kPEFPkDataBlock : ! 1586: packedPos += count1; ! 1587: outputOffset += count1; ! 1588: break; ! 1589: ! 1590: case kPEFPkDataRepeat : ! 1591: count2 = GetPackedDataCount ( &packedPos ) + 1; // ! Stored count is 1 less. ! 1592: packedPos += count1; ! 1593: outputOffset += count1 * count2; ! 1594: break; ! 1595: ! 1596: ! 1597: case kPEFPkDataRepeatBlock : ! 1598: count2 = GetPackedDataCount ( &packedPos ); ! 1599: count3 = GetPackedDataCount ( &packedPos ); ! 1600: packedPos += count1 + (count2 * count3); ! 1601: outputOffset += count1 + ((count1 + count2) * count3); ! 1602: break; ! 1603: ! 1604: ! 1605: case kPEFPkDataRepeatZero : ! 1606: count2 = GetPackedDataCount ( &packedPos ); ! 1607: count3 = GetPackedDataCount ( &packedPos ); ! 1608: packedPos += count2 * count3; ! 1609: outputOffset += count1 + ((count1 + count2) * count3); ! 1610: break; ! 1611: ! 1612: ! 1613: default : ! 1614: goto FragmentCorruptError; ! 1615: ! 1616: } ! 1617: ! 1618: } while ( outputOffset <= outputStartOffset ); ! 1619: ! 1620: ! 1621: //---------------------------------------------------------------------------------------- ! 1622: // Now do the actual unpacking. This uses a copy of the full unpack logic with special ! 1623: // block copy/clear routines. These special routines do the bounds checking, only writing ! 1624: // output where actually allowed. This involves "unnecessary" checks for the "middle" ! 1625: // operations that are fully within the range, but vastly simplifies the boundary cases. ! 1626: ! 1627: packedPos = packedBoundary; // Reset to the operation that spans the output start. ! 1628: outputOffset = outputBoundary; ! 1629: ! 1630: do { ! 1631: ! 1632: currByte = *packedPos++; ! 1633: opcode = currByte >> kPEFPkDataOpcodeShift; ! 1634: count1 = currByte & kPEFPkDataCount5Mask; ! 1635: ! 1636: if ( count1 == 0 ) count1 = GetPackedDataCount ( &packedPos ); ! 1637: ! 1638: switch ( opcode ) { ! 1639: ! 1640: case kPEFPkDataZero : ! 1641: PartialBlockClear ( outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1642: outputOffset += count1; ! 1643: break; ! 1644: ! 1645: case kPEFPkDataBlock : ! 1646: PartialBlockMove ( packedPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1647: packedPos += count1; ! 1648: outputOffset += count1; ! 1649: break; ! 1650: ! 1651: case kPEFPkDataRepeat : // ??? Need a BlockFill routine? ! 1652: count2 = GetPackedDataCount ( &packedPos ) + 1; // ! Stored count is 1 less. ! 1653: for ( ; count2 != 0; count2 -= 1 ) { ! 1654: PartialBlockMove ( packedPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1655: outputOffset += count1; ! 1656: } ! 1657: packedPos += count1; ! 1658: break; ! 1659: ! 1660: case kPEFPkDataRepeatBlock : ! 1661: ! 1662: count2 = GetPackedDataCount ( &packedPos ); ! 1663: count3 = GetPackedDataCount ( &packedPos ); ! 1664: ! 1665: { ! 1666: BytePtr commonPos = packedPos; ! 1667: ! 1668: packedPos += count1; // Skip the common part. ! 1669: ! 1670: for ( ; count3 != 0; count3 -= 1 ) { ! 1671: ! 1672: PartialBlockMove ( commonPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1673: outputOffset += count1; ! 1674: ! 1675: PartialBlockMove ( packedPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count2 ); ! 1676: packedPos += count2; ! 1677: outputOffset += count2; ! 1678: ! 1679: } ! 1680: ! 1681: PartialBlockMove ( commonPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1682: outputOffset += count1; ! 1683: ! 1684: } ! 1685: ! 1686: break; ! 1687: ! 1688: case kPEFPkDataRepeatZero : ! 1689: ! 1690: count2 = GetPackedDataCount ( &packedPos ); ! 1691: count3 = GetPackedDataCount ( &packedPos ); ! 1692: ! 1693: PartialBlockClear ( outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1694: outputOffset += count1; ! 1695: ! 1696: for ( ; count3 != 0; count3 -= 1 ) { ! 1697: ! 1698: PartialBlockMove ( packedPos, outputBase, outputStartOffset, outputEndOffset, outputOffset, count2 ); ! 1699: packedPos += count2; ! 1700: outputOffset += count2; ! 1701: ! 1702: PartialBlockClear ( outputBase, outputStartOffset, outputEndOffset, outputOffset, count1 ); ! 1703: outputOffset += count1; ! 1704: ! 1705: } ! 1706: ! 1707: break; ! 1708: ! 1709: default : ! 1710: goto FragmentCorruptError; ! 1711: ! 1712: } ! 1713: ! 1714: } while ( (outputOffset <= outputEndOffset) && (packedPos <= packedEnd) ); ! 1715: ! 1716: ! 1717: // ------------------------------------------ ! 1718: // Finally block clear anything that is left. ! 1719: ! 1720: if ( outputOffset <= outputEndOffset ) { ! 1721: PEF_BlockClear ( outputBase + (outputOffset - outputStartOffset), outputEndOffset - outputOffset + 1 ); ! 1722: } ! 1723: ! 1724: err = noErr; ! 1725: ! 1726: EXIT: ! 1727: return err; ! 1728: ! 1729: ERROR: ! 1730: goto EXIT; ! 1731: ! 1732: ! 1733: FragmentUsageError: ! 1734: err = cfragFragmentUsageErr; ! 1735: goto ERROR; ! 1736: ! 1737: FragmentCorruptError: ! 1738: err = cfragFragmentCorruptErr; ! 1739: goto ERROR; ! 1740: ! 1741: ! 1742: } // UnpackPartialSection () ! 1743: ! 1744: ! 1745: // � ! 1746: // =========================================================================================== ! 1747: // PEF_UnpackSection () ! 1748: // ==================== ! 1749: ! 1750: ! 1751: OSStatus PEF_UnpackSection ( CFContHandlerRef containerRef, ! 1752: ItemCount sectionIndex, ! 1753: ByteCount sectionOffset, ! 1754: LogicalAddress bufferAddress, ! 1755: ByteCount bufferLength ) ! 1756: { ! 1757: OSStatus err = cfragCFMInternalErr; ! 1758: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1759: SectionHeader * section = NULL; ! 1760: BytePtr packedBase = NULL; ! 1761: BytePtr packedEnd = NULL; ! 1762: BytePtr outputBase = bufferAddress; ! 1763: BytePtr outputEnd = outputBase + bufferLength - 1; ! 1764: ! 1765: ! 1766: if ( pefPrivate == NULL ) goto ParameterError; ! 1767: if ( sectionIndex >= pefPrivate->sectionCount ) goto ParameterError; ! 1768: if ( (bufferAddress == NULL) && (bufferLength != 0) ) goto ParameterError; ! 1769: ! 1770: section = &pefPrivate->sections[sectionIndex]; ! 1771: if ( (sectionOffset + bufferLength) > section->execSize ) goto ParameterError; ! 1772: ! 1773: packedBase = pefPrivate->mappedContainer + section->containerOffset; ! 1774: packedEnd = packedBase + section->rawSize - 1; ! 1775: ! 1776: ! 1777: if ( (sectionOffset == 0) && (bufferLength == section->initSize) ) { ! 1778: ! 1779: err = UnpackFullSection ( packedBase, packedEnd, outputBase, outputEnd ); ! 1780: if ( err != noErr ) goto ERROR; ! 1781: ! 1782: if ( false && EnableCFMDebugging && (section->execSize > 8) ) { // Force some tests of partial unpacking. ! 1783: ! 1784: UInt32 word; ! 1785: BytePtr partContents = (*pefPrivate->Allocate) ( section->execSize - 2 ); ! 1786: ! 1787: PEF_Assert ( partContents != NULL ); ! 1788: ! 1789: err = PEF_UnpackSection ( containerRef, sectionIndex, 1, &word, 4 ); ! 1790: PEF_Assert ( err == noErr ); ! 1791: ! 1792: err = PEF_UnpackSection ( containerRef, sectionIndex, section->execSize / 2, &word, 4 ); ! 1793: PEF_Assert ( err == noErr ); ! 1794: ! 1795: err = PEF_UnpackSection ( containerRef, sectionIndex, section->execSize - 5, &word, 4 ); ! 1796: PEF_Assert ( err == noErr ); ! 1797: ! 1798: err = PEF_UnpackSection ( containerRef, sectionIndex, 1, partContents, section->execSize - 2 ); ! 1799: PEF_Assert ( err == noErr ); ! 1800: ! 1801: (*pefPrivate->Release) ( partContents ); ! 1802: } ! 1803: ! 1804: } else { ! 1805: ! 1806: if ( section->initSize < sectionOffset ) { ! 1807: PEF_BlockClear ( bufferAddress, bufferLength ); ! 1808: } else { ! 1809: err = UnpackPartialSection ( packedBase, packedEnd, outputBase, outputEnd, sectionOffset ); ! 1810: if ( err != noErr ) goto ERROR; ! 1811: } ! 1812: ! 1813: if ( EnableCFMDebugging ) { // See if the partial output agrees with full output. ! 1814: ! 1815: BytePtr fullContents = (*pefPrivate->Allocate) ( section->execSize ); ! 1816: ! 1817: PEF_Assert ( fullContents != NULL ); ! 1818: PEF_BlockClear ( fullContents, section->execSize ); ! 1819: ! 1820: err = UnpackFullSection ( packedBase, packedEnd, fullContents, fullContents + section->initSize - 1 ); ! 1821: PEF_Assert ( err == noErr ); ! 1822: ! 1823: PEF_Assert ( PEF_CompareBytes ( fullContents + sectionOffset, bufferAddress, bufferLength ) ); ! 1824: ! 1825: (*pefPrivate->Release) ( fullContents ); ! 1826: ! 1827: } ! 1828: ! 1829: } ! 1830: ! 1831: err = noErr; ! 1832: ! 1833: EXIT: ! 1834: return err; ! 1835: ! 1836: ERROR: ! 1837: goto EXIT; ! 1838: ! 1839: ! 1840: ParameterError: ! 1841: err = paramErr; ! 1842: goto ERROR; ! 1843: ! 1844: ! 1845: } // PEF_UnpackSection () ! 1846: ! 1847: ! 1848: // � ! 1849: // =========================================================================================== ! 1850: // PEF_RelocateSection () ! 1851: // ====================== ! 1852: ! 1853: ! 1854: // *** This needs cleaning up. ! 1855: ! 1856: ! 1857: OSStatus PEF_RelocateSection ( CFContHandlerRef containerRef, ! 1858: ItemCount sectionIndex ) ! 1859: { ! 1860: OSStatus err = cfragCFMInternalErr; ! 1861: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 1862: ! 1863: BytePtr * raddr; ! 1864: ByteCount dataA; ! 1865: int cnt; // ! Must be signed. ! 1866: ByteCount codeA; ! 1867: LoaderRelExpHeader * ldRelHdr; ! 1868: Relocation *reloc, *rlend; ! 1869: Relocation r; ! 1870: long rpt; // ! Must be signed. ! 1871: long secn; ! 1872: long rsymi; ! 1873: BytePtr *imports; ! 1874: ByteCount *regions; ! 1875: long i; ! 1876: long relNum; ! 1877: BytePtr regStart; ! 1878: SectionHeader * section; ! 1879: ! 1880: ! 1881: if ( pefPrivate == NULL ) goto ParameterError; ! 1882: if ( sectionIndex >= pefPrivate->sectionCount ) goto ParameterError; ! 1883: ! 1884: regStart = pefPrivate->mappedOrigins[sectionIndex]; ! 1885: section = & pefPrivate->sections [sectionIndex]; ! 1886: ! 1887: pefPrivate->resolved = 1; // !!! Really means relocated, and should be set on exit. ! 1888: ! 1889: for (i = 0; ; i++) { ! 1890: if ( i >= pefPrivate->sectionCount ) return noErr; // No relocations for this section. ! 1891: ldRelHdr = & pefPrivate->ldrSections [i]; ! 1892: if ( ldRelHdr->sectionNumber == sectionIndex ) break; ! 1893: } ! 1894: ! 1895: regions = pefPrivate->runningOffsets; ! 1896: imports = pefPrivate->imports; ! 1897: ! 1898: reloc = (Relocation *) (pefPrivate->ldrRelocations + ldRelHdr->relocationsOffset); ! 1899: rlend = (Relocation *) ((RelocInstr *) reloc + ldRelHdr->numRelocations); ! 1900: raddr = (BytePtr *) regStart; // ! Change the stride from 1 to 4. ! 1901: rsymi = 0; ! 1902: codeA = regions [0]; ! 1903: dataA = regions [1]; ! 1904: rpt = 0; ! 1905: ! 1906: #if 0 ! 1907: sprintf ( gDebugMessage, "PLPrepareRegion: start @ %.8X\n", raddr ); ! 1908: PutSerialMesssage ( gDebugMessage ); ! 1909: #endif ! 1910: ! 1911: relNum = 0; ! 1912: while (reloc < rlend) { ! 1913: ! 1914: r = *reloc; ! 1915: reloc = (Relocation *) ((RelocInstr *) reloc + 1); ! 1916: ! 1917: switch ( opcode [r.opcode.op] ) { ! 1918: case krDDAT : ! 1919: raddr = (BytePtr *) ((BytePtr)raddr + (r.deltadata.delta_d4 * 4)); // ! Reduce stride to 1. ! 1920: cnt = r.deltadata.cnt; ! 1921: while (--cnt >= 0) { ! 1922: *raddr++ += dataA; ! 1923: } ! 1924: break; ! 1925: ! 1926: case krCODE : ! 1927: cnt = r.run.cnt_m1 + 1; ! 1928: while (--cnt >= 0) { ! 1929: *raddr++ += codeA; ! 1930: } ! 1931: break; ! 1932: ! 1933: case krDATA : ! 1934: cnt = r.run.cnt_m1 + 1; ! 1935: while (--cnt >= 0) { ! 1936: *raddr++ += dataA; ! 1937: } ! 1938: break; ! 1939: ! 1940: case krDESC : ! 1941: cnt = r.run.cnt_m1 + 1; ! 1942: while (--cnt >= 0) { ! 1943: *raddr++ += codeA; ! 1944: *raddr++ += dataA; ! 1945: raddr++; ! 1946: } ! 1947: break; ! 1948: ! 1949: case krDSC2 : ! 1950: cnt = r.run.cnt_m1 + 1; ! 1951: while (--cnt >= 0) { ! 1952: *raddr++ += codeA; ! 1953: *raddr++ += dataA; ! 1954: } ! 1955: break; ! 1956: ! 1957: case krVTBL : ! 1958: cnt = r.run.cnt_m1 + 1; ! 1959: while (--cnt >= 0) { ! 1960: *raddr++ += dataA; ! 1961: raddr++; ! 1962: } ! 1963: break; ! 1964: ! 1965: case krSYMR : ! 1966: cnt = r.run.cnt_m1 + 1; ! 1967: while (--cnt >= 0) { ! 1968: *raddr++ += (ByteCount) imports [rsymi++]; ! 1969: } ! 1970: break; ! 1971: ! 1972: case krSYMB : ! 1973: rsymi = r.glp.idx; ! 1974: *raddr++ += (ByteCount) imports [rsymi++]; ! 1975: break; ! 1976: ! 1977: case krCDIS : ! 1978: codeA = regions [r.glp.idx]; ! 1979: break; ! 1980: ! 1981: case krDTIS : ! 1982: dataA = regions [r.glp.idx]; ! 1983: break; ! 1984: ! 1985: case krSECN : ! 1986: *raddr++ += regions [r.glp.idx]; ! 1987: break; ! 1988: ! 1989: case krDELT : ! 1990: raddr = (BytePtr *) ((BytePtr) raddr + r.delta.delta_m1 + 1); // ! Reduce stride to 1. ! 1991: #if 0 ! 1992: sprintf ( gDebugMessage, "PLPrepareRegion: delta to %.8X\n", raddr ); ! 1993: PutSerialMesssage ( gDebugMessage ); ! 1994: #endif ! 1995: break; ! 1996: ! 1997: case krRPT : ! 1998: if (--rpt == 0) break; // count was 1 --> rpt done ! 1999: if (rpt < 0) // first time rpt encountered? ! 2000: rpt = r.rpt.rcnt_m1 + 1; // yes- initialize rpt count ! 2001: cnt = r.rpt.icnt_m1 + 2; // yes or no - back up cnt instrs ! 2002: reloc = (Relocation *) ((RelocInstr *) reloc - cnt); ! 2003: break; ! 2004: ! 2005: case krLABS : ! 2006: raddr = (BytePtr *) ((r.large1.idx_top << 16) + reloc->bot + regStart); ! 2007: reloc = (Relocation *) ((RelocInstr *) reloc + 1); ! 2008: #if 0 ! 2009: sprintf ( gDebugMessage, "PLPrepareRegion: abs to %.8X\n", raddr ); ! 2010: PutSerialMesssage ( gDebugMessage ); ! 2011: #endif ! 2012: break; ! 2013: ! 2014: case krLSYM : ! 2015: rsymi = (r.large1.idx_top << 16) + reloc->bot; ! 2016: reloc = (Relocation *) ((RelocInstr *) reloc + 1); ! 2017: *raddr++ += (ByteCount) imports [rsymi++]; ! 2018: break; ! 2019: ! 2020: case krLRPT : ! 2021: if (--rpt == 0) { ! 2022: reloc = (Relocation *) ((RelocInstr *) reloc + 1); ! 2023: break; ! 2024: } ! 2025: if (rpt < 0) ! 2026: rpt = (r.large2.idx_top << 16) + reloc->bot; ! 2027: cnt = r.large2.cnt_m1 + 2; ! 2028: reloc = (Relocation *) ((RelocInstr *) reloc - cnt); ! 2029: break; ! 2030: ! 2031: case krLSEC : ! 2032: secn = (r.large2.idx_top << 16) + reloc->bot; ! 2033: switch (r.large2.cnt_m1) { ! 2034: case 0 : *raddr++ += regions [secn]; break; ! 2035: case 1 : codeA = regions [secn]; break; ! 2036: case 2 : dataA = regions [secn]; break; ! 2037: } ! 2038: reloc = (Relocation *) ((RelocInstr *) reloc + 1); ! 2039: break; ! 2040: ! 2041: default : ! 2042: goto FragmentCorruptError; ! 2043: } ! 2044: } ! 2045: ! 2046: ! 2047: #if 0 ! 2048: sprintf ( gDebugMessage, "PLPrepareRegion: end @ %.8X\n", raddr ); ! 2049: PutSerialMesssage ( gDebugMessage ); ! 2050: #endif ! 2051: ! 2052: err = noErr; ! 2053: ! 2054: EXIT: ! 2055: return err; ! 2056: ! 2057: ERROR: ! 2058: goto EXIT; ! 2059: ! 2060: ParameterError: ! 2061: err = paramErr; ! 2062: goto ERROR; ! 2063: ! 2064: FragmentCorruptError: ! 2065: err = cfragFragmentCorruptErr; ! 2066: goto ERROR; ! 2067: ! 2068: ! 2069: } // PEF_RelocateSection () ! 2070: ! 2071: ! 2072: // � ! 2073: // =========================================================================================== ! 2074: // PEF_RelocateImportsOnly () ! 2075: // ========================== ! 2076: ! 2077: ! 2078: OSStatus PEF_RelocateImportsOnly ( CFContHandlerRef containerRef, ! 2079: ItemCount sectionIndex, ! 2080: ItemCount libraryIndex ) ! 2081: { ! 2082: OSStatus err = cfragCFMInternalErr; ! 2083: PEFPrivateInfo * pefPrivate = (PEFPrivateInfo *) containerRef; ! 2084: ! 2085: ! 2086: if ( pefPrivate == NULL ) goto ParameterError; ! 2087: if ( sectionIndex >= pefPrivate->sectionCount ) goto ParameterError; ! 2088: if ( libraryIndex >= pefPrivate->ldrHeader->numImportFiles ) goto ParameterError; ! 2089: ! 2090: ! 2091: if ( pefPrivate == NULL ) goto ParameterError; ! 2092: ! 2093: ! 2094: return unimpErr; // !!! Fix this! ! 2095: ! 2096: EXIT: ! 2097: return err; ! 2098: ! 2099: ERROR: ! 2100: goto EXIT; ! 2101: ! 2102: ParameterError: ! 2103: err = paramErr; ! 2104: goto ERROR; ! 2105: ! 2106: ! 2107: } // PEF_RelocateImportsOnly () ! 2108:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.