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