![[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.