![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPEFInternals.h 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.h 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: File: zPEF.h
37:
38: Contains: PEF format declarations.
39:
40: Version: Maxwell
41:
42: Copyright: � 1992-1996 by Apple Computer, Inc., all rights reserved.
43:
44: File Ownership:
45:
46: DRI: Alan Lillich
47:
48: Other Contact: <<unknown>>
49:
50: Technology: Core Runtime
51:
52: Writers:
53:
54: (AWL) Alan Lillich
55: (ELE) Erik Eidt
56:
57: Change History (most recent first):
58:
59: <7> 2/28/96 AWL Adapt for new container handler model.
60: <6> 4/12/95 AWL Fix bit field problem.
61: <5> 8/29/94 AWL Remove "never" share mode.
62: <4> 8/23/94 AWL Update section sharing constants.
63: <3> 4/28/94 AWL Simplify cross address space use for booting.
64: <2> 4/11/94 AWL Use 68K alignment for the export symbol structure.
65: <1> 2/15/94 AWL Initial checkin for kernel based CFM.
66:
67: -------------------------------------------------------------------------------------
68:
69: <7> 8/26/93 AWL Move CFTypes.h and CFLoader.h up with other Apple private headers.
70: <5> 7/8/93 AWL (&ELE) Fixed version field names in import file IDs
71: <4> 6/9/93 JRG ELE & AWL Changes:
72: <4> 06/08/93 AWL (&ELE) Added more standard section types and packed data opcodes.
73: <3> 9/23/92 ELE added precomputed hash table for improved runtime performance.
74:
75: Version 1.3 Erik Eidt 9/23/92 updated for new hash table capabilities
76: Version 1.2 Erik Eidt 7/8/92 updated for new relocations and other loader section size optimizations
77: Version 1.1 Cheryl Lins 5/27/92 updated for PEF 1.2 definition
78: Version 1.0 Cheryl Lins 4/7/92 initial version
79: */
80:
81:
82: #ifndef __IOPEFINTERNALS__
83: #define __IOPEFINTERNALS__ 1
84:
85: #include <driverkit/ppc/IOMacOSTypes.h>
86: #include "IOPEFLoader.h"
87:
88:
89: typedef signed int PEF_SBits32; // ! Can't use SInt32, it is "signed long".
90: typedef unsigned int PEF_UBits32; // ! Can't use UInt32, it is "unsigned long".
91:
92:
93: #pragma options align=mac68k
94:
95: /*========== File Header ==========*/
96:
97: typedef struct {
98: UInt16 magic1; /* magic flag describing execution machine and environment */
99: UInt16 magic2; /* magic flag describing execution machine and environment */
100: OSType fileTypeID; /* OSType identifier = 'pef' */
101: OSType architectureID; /* OSType identifier = 'pwpc' */
102: UInt32 versionNumber; /* version number of this file format */
103: UInt32 dateTimeStamp; /* Macintosh date/time stamp */
104: UInt32 oldDefVersion; /* old definition version number */
105: UInt32 oldImpVersion; /* old implementation version number */
106: UInt32 currentVersion; /* current version number */
107: SInt16 numberSections; /* number of sections */
108: SInt16 loadableSections; /* number of sections that are loadable for execution,
109: also the section # of first non-loadable section */
110: BytePtr memoryAddress; /* the location this container was last loaded */
111: } FileHeader, *FileHeaderPtr;
112:
113: #define kPEFVersion 1 /* current version number */
114: #define kPEFMagic1 0x4A6F /* value of magic1 for PEF */
115: #define kPEFMagic2 0x7921 /* value of magic2 for PEF */
116: #define kPEFTypeID 0x70656666 /* value of fileTypeID for 'peff' */
117: #define kPowerPCID 0x70777063 /* value of architecture ID 'pwpc' */
118:
119: /*========== Section Header ==========*/
120:
121: typedef struct {
122: ByteCount sectionName; /* offset into global string table for section name */
123: BytePtr sectionAddress; /* preferred base address for the section */
124: ByteCount execSize; /* section size in bytes during execution in memory including zero initialization */
125: ByteCount initSize; /* section size in bytes during execution in memory before zero initialization */
126: ByteCount rawSize; /* section size in bytes in container before loading */
127: ByteCount containerOffset;/* container offest to section's raw data */
128: UInt8 regionKind; /* section/region classification */
129: UInt8 shareKind; /* sharing classification */
130: UInt8 alignment; /* execution alignment requirement (0=byte,1=half,2=word,3=doubleword,4=quadword..) */
131: UInt8 reservedA;
132: } SectionHeader, *SectionHeaderPtr;
133:
134: /* TCFLSectionKind */
135: #define kPEFCodeSection 0
136: #define kPEFDataSection 1
137: #define kPEFPIDataSection 2
138: #define kPEFConstantSection 3
139: #define kPEFLoaderSection 4
140: #define kPEFDebugSection 5
141: #define kPEFExecDataSection 6
142: #define kPEFExceptionSection 7
143: #define kPEFTracebackSection 8
144:
145: /* TCFLShareKind */
146: #define kPEFContextShare 1
147: #define kPEFGlobalShare 4
148: #define kPEFProtectedShare 5
149:
150: /* Defines for PIDataSections */
151: #define kPEFZero 0
152: #define kPEFBlock 1
153: #define kPEFRepeat 2
154: #define kPEFRepeatBlock 3
155: #define kPEFRepeatZero 4
156: #define kPEFNoOpcode 0x0fff
157: #define kPEFOpcodeShift 5
158: #define kPEFFirstOperandMask 31
159:
160:
161: /*========== Loader Header ==========*/
162:
163: typedef struct {
164: SInt32 entryPointSection; /* section number containing entry point descriptor */
165: ByteCount entryPointOffset; /* offset to entry point descriptor within section */
166:
167: SInt32 initPointSection; /* section number containing entry point descriptor */
168: ByteCount initPointOffset; /* offset to entry point descriptor within section */
169:
170: SInt32 termPointSection; /* section number containing entry point descriptor */
171: ByteCount termPointOffset; /* offset to entry point descriptor within section */
172:
173: ItemCount numImportFiles; /* number of import file id entries */
174: ItemCount numImportSyms; /* number of import symbol table entries */
175: ItemCount numSections; /* number of sections with load-time relocations */
176: ByteCount relocationsOffset; /* offset to relocation descriptions table */
177:
178: ByteCount stringsOffset; /* offset to loader string table */
179:
180: ByteCount hashSlotTable; /* offset to hash slot table */
181: ItemCount hashSlotTabSize; /* number of hash slot entries */
182: ItemCount numExportSyms; /* number of export symbol table entries */
183: } LoaderHeader, *LoaderHeaderPtr;
184:
185: /*========== Loader Section Header ==========*/
186:
187: typedef struct {
188: SInt16 sectionNumber; /* reference to primary section number */
189: SInt16 reservedA; /* if TSectNum were 16 bits, which it isn't */
190: ItemCount numRelocations; /* number of loader relocations for this section */
191: ByteCount relocationsOffset; /* offset to relocation descriptions for this section */
192: } LoaderRelExpHeader, *LoaderRelExpHeaderPtr;
193:
194: /*========== Loader Import File ID's Entry ==========*/
195:
196: typedef struct {
197: ByteCount fileNameOffset; /* offset into loader string table for file name */
198: UInt32 oldImpVersion; /* oldest compatible implementation library */
199: UInt32 linkedVersion; /* current version at link time */
200: ItemCount numImports; /* number of imports from this file */
201: ItemCount impFirst; /* number of the first imports from this file (relative to all imports) */
202: UInt8 options; /* call this libraries initialization routine before mine */
203: UInt8 reservedA;
204: UInt16 reservedB;
205: } LoaderImportFileID, *LoaderImportFileIDPtr;
206:
207: #define kPEFInitBeforeMask 0x80
208: #define kPEFWeakLibraryMask 0x40
209: #define kPEFDeferredBindMask 0x20
210:
211: /*========== Loader Import Symbol Table Entry ==========*/
212:
213: typedef struct {
214: PEF_UBits32 symClass : 8; // Actually ot type TCFLSymbolClass.
215: PEF_UBits32 nameOffset : 24;
216: } LoaderImport, *LoaderImportPtr;
217:
218: #define kPEFWeakSymbolMask 0x80
219:
220: /*========== Loader Export Hash Slot Table Entry ==========*/
221:
222: typedef struct {
223: PEF_UBits32 chainCount : 14;
224: PEF_UBits32 chainIndex : 18;
225: } HashSlotEntry, *HashSlotEntryPtr;
226:
227: #define PEFHashHighBits(hashword,bitCount) ((hashword) >> (bitCount))
228: #define PEFHashMaskBits(hashword,bitCount) (((UInt32)(1) << (bitCount)) - 1)
229:
230: #define GetPEFHashSlot(hashword,bitCount) \
231: ( (ItemCount) (((hashword) ^ PEFHashHighBits((hashword),(bitCount))) & PEFHashMaskBits((hashword),(bitCount))) )
232:
233: /*========== Loader Export Hash Chain Table Entry ==========*/
234:
235: typedef struct {
236: UInt32 hashword; /* (hashword >> 16) == nameLength !! */
237: } HashChainEntry, *HashChainEntryPtr;
238:
239: /*========== Loader Export Symbol Table Entry ==========*/
240:
241: /* Section number controls how 'address' is interpreted.
242: >=0: section number exporting the symbol; 'address' is offset from start of the section to
243: the symbol being exported (ie address of a routine or data item)
244: -1: value is absolute (non-relocatable)
245: -2: value is a physical address (non-relocatable)
246: -3: re-export imported symbol whose number is in 'address'
247: */
248:
249: /* this struct is stored in the file, non-aligned: size = 10 */
250: typedef struct {
251: PEF_UBits32 symClass : 8; // Actually ot type TCFLSymbolClass.
252: PEF_UBits32 nameOffset : 24;
253: ByteCount offset; /* offset into section to exported symbol */
254: SInt16 sectionNumber;
255: } LoaderExport, *LoaderExportPtr;
256:
257: #define SIZEOF_LoaderExport (sizeof (TUnsigned32)*2 + sizeof (SInt16))
258:
259:
260: #define kPEFAbsoluteExport -1
261: #define kPEFPhysicalExport -2
262: #define kPEFReExportImport -3
263:
264: /*========== Loader Relocation Entry ==========*/
265:
266: typedef UInt16 RelocInstr;
267:
268: typedef union {
269: struct { unsigned op:7, rest:9; } opcode;
270: struct { unsigned op:2, delta_d4:8, cnt:6; } deltadata;
271: struct { unsigned op:7, cnt_m1:9; } run;
272: struct { unsigned op:7, idx:9; } glp;
273: struct { unsigned op:4, delta_m1:12; } delta;
274: struct { unsigned op:4, icnt_m1:4, rcnt_m1:8; } rpt;
275: struct { unsigned op:6, idx_top:10; } large1;
276: struct { unsigned op:6, cnt_m1:4, idx_top:6; } large2;
277: UInt16 instr;
278: UInt16 bot;
279: } Relocation;
280:
281: // opcode definitions which can be used with
282: // Relocation.opcode.op:7, if masked properly
283: // by the up coming table
284: // (NOTE: a half word of 0 is garunteed to be an unused relocation instruction)
285:
286: #define krDDAT 0x00 // type deltadata
287:
288: #define krCODE 0x20 // type run
289: #define krDATA 0x21 // type run
290: #define krDESC 0x22 // type run
291: #define krDSC2 0x23 // type run
292: #define krVTBL 0x24 // type run
293: #define krSYMR 0x25 // type run
294: // 0x26
295: // 0x2F
296:
297: #define krSYMB 0x30 // type glp
298: #define krCDIS 0x31 // type glp
299: #define krDTIS 0x32 // type glp
300: #define krSECN 0x33 // type glp
301: // 0x34
302: // 0x3F
303:
304: #define krDELT 0x40 // type delta
305: #define krRPT 0x48 // type rpt
306:
307: #define krLABS 0x50 // type large1
308: #define krLSYM 0x52 // type large1
309: // 0x54
310: // 0x56
311:
312: #define krLRPT 0x58 // type large2
313: #define krLSEC 0x5A // type large2
314: // 0x5C
315: // 0x5E
316:
317: // LSEC usage:
318: // LSEC 0, n -- Long SECN
319: // LSEC 1, n -- Long CDIS
320: // LSEC 2, n -- Long DTIS
321: // LSEC 3, n -- free
322: // LSEC 15, n -- free
323:
324: // constants that indicate the maximum sizes of fields
325: // (before packing, ie: subtracting one, in some cases)
326:
327: #define ksDELTA 4096 // delta max for DELTA from
328:
329: #define ksDDDMAX 1023 // delta max for DELTA-DAT (DDAT) form
330: #define ksDDRMAX 63 // run max for DELTA-DAT (DDAT) form
331:
332: #define ksCODE 512 // count max for CODE form
333: #define ksDATA 512 // count max for DATA form
334: #define ksDEMAX 512 // count max for DESC form
335: #define ksVTMAX 512 // count max for VTBL form
336: #define ksISMAX 512 // count max for IMPS form
337: #define ksRPTMAX 256 // count max for RPT form
338:
339: #define IsLARG(op) (((op) & 0x70) == 0x50)
340:
341: #define RELOPSHFT 9
342:
343: #define ksDVDMAX 0 // (63) delta max for DELTA-VTBL (DVBL) form
344: #define ksDVRMAX 0 // (256) run max for DELTA-VTBL (DVBL) form
345:
346: #define krXXXX 0xff
347:
348:
349: /*
350: From: PEFBinaryFormat.i
351: Revision: 9
352: */
353:
354: enum {
355: /* The packed data opcodes. */
356: kPEFPkDataZero = 0, /* Zero fill "count" bytes. */
357: kPEFPkDataBlock = 1, /* Block copy "count" bytes. */
358: kPEFPkDataRepeat = 2, /* Repeat "count" bytes "count2"+1 times. */
359: kPEFPkDataRepeatBlock = 3, /* Interleaved repeated and unique data. */
360: kPEFPkDataRepeatZero = 4 /* Interleaved zero and unique data. */
361: };
362:
363:
364: enum {
365: kPEFPkDataOpcodeShift = 5,
366: kPEFPkDataCount5Mask = 0x1F,
367: kPEFPkDataMaxCount5 = 31,
368: kPEFPkDataVCountShift = 7,
369: kPEFPkDataVCountMask = 0x7F,
370: kPEFPkDataVCountEndMask = 0x80
371: };
372:
373: #define PEFPkDataOpcode(byte) ( ((UInt8)(byte)) >> kPEFPkDataOpcodeShift )
374:
375: #define PEFPkDataCount5(byte) ( ((UInt8)(byte)) & kPEFPkDataCount5Mask )
376:
377: #define PEFPkDataComposeInstr(opcode,count5) \
378: ( (((UInt8)(opcode)) << kPEFPkDataOpcodeShift) | ((UInt8)(count5)) )
379:
380:
381:
382:
383:
384: /*
385: File: CodeFragmentContainerPriv.h
386:
387: Contains: Physical container routines of the ModernOS version of CFM.
388:
389: Version: Maxwell
390:
391: DRI: Alan Lillich
392:
393: Copyright: � 1984-1996 by Apple Computer, Inc.
394: All rights reserved.
395:
396: Warning: *** APPLE INTERNAL USE ONLY ***
397: This file contains unreleased SPI's
398:
399: BuildInfo: Built by: Simon Douglas
400: With Interfacer: 2.0d13 (PowerPC native)
401: From: CodeFragmentContainerPriv.i
402: Revision: 9
403: Dated: 10/9/96
404: Last change by: AWL
405: Last comment: Remove special SMP sharing, using prepare option instead.
406:
407: Bugs: Report bugs to Radar component �System Interfaces�, �Latest�
408: List the version information (from above) in the Problem Description.
409:
410: */
411: /*
412: -------------------------------------------------------------------------------------------
413: This file contains what used to be called the CFLoader interface. The name was changed to
414: fit the newer convention of having CodeFragment as a common prefix, and to reduce pervasive
415: confusion between the Code Fragment Manager and the Code Fragment Loaders, promulgated by
416: the long history of the Segment Loader. This file defines the abstract interface to the
417: physical representation of code fragments.
418: !!! This version has minimal comments, the main purpose is to get things compiled.
419: */
420:
421:
422: /*
423: �
424: ===========================================================================================
425: General Types and Constants
426: ===========================
427: */
428: typedef SInt32 CFContSignedIndex;
429: typedef UInt32 CFContStringHash;
430: #define CFContStringHashLength(hashValue) ((hashValue) >> 16)
431: struct CFContHashedName {
432: CFContStringHash nameHash; /* ! Includes the name length.*/
433: BytePtr nameText;
434: };
435: typedef struct CFContHashedName CFContHashedName;
436:
437: /*
438: ------------------------------------------
439: Declarations for code fragment containers.
440: */
441:
442: enum {
443: kCFContContainerInfoVersion = 0x00010001
444: };
445:
446: struct CFContContainerInfo {
447: CFContHashedName cfragName;
448: UInt32 modDate; /* !!! Abstract type?*/
449: OSType architecture;
450: CFragVersionNumber currentVersion;
451: CFragVersionNumber oldImpVersion;
452: CFragVersionNumber oldDefVersion;
453: UInt32 reservedA;
454: void * reservedB;
455: };
456: typedef struct CFContContainerInfo CFContContainerInfo;
457:
458: /*
459: ----------------------------------------
460: Declarations for code fragment sections.
461: */
462: struct CFContLogicalLocation {
463: CFContSignedIndex section; /* "Real" sections use zero based indices, special ones are negative.*/
464: ByteCount offset;
465: };
466: typedef struct CFContLogicalLocation CFContLogicalLocation;
467:
468:
469: enum {
470: kCFContNoSectionIndex = -1,
471: kCFContAbsoluteSectionIndex = -2,
472: kCFContReexportSectionIndex = -3
473: };
474:
475: typedef UInt8 CFContSectionSharing;
476:
477: enum {
478: kCFContShareSectionInClosure = 0, /* ! Not supported at present!*/
479: kCFContShareSectionInProcess = 1,
480: kCFContShareSectionAcrossSystem = 4,
481: kCFContShareSectionWithProtection = 5
482: };
483:
484: typedef UInt8 CFContMemoryAccess;
485:
486: enum {
487: kCFContMemReadMask = 0x01, /* Readable memory can also be executed.*/
488: kCFContMemWriteMask = 0x02,
489: kCFContMemExecuteMask = 0x04, /* ! Affects cache actions, not protection!*/
490: kCFContReadOnlyData = kCFContMemReadMask,
491: kCFContWriteableData = kCFContMemReadMask | kCFContMemWriteMask,
492: kCFContNormalCode = kCFContMemReadMask | kCFContMemExecuteMask,
493: kCFContExcludedMemory = 0
494: };
495:
496: typedef UInt32 CFContSectionOptions;
497:
498: enum {
499: /* Values for CFContSectionOptions.*/
500: kPackedCFContSectionMask = 0x01, /* Stored contents are compressed.*/
501: kRelocatedCFContSectionMask = 0x02, /* Section contents have relocations.*/
502: kEmptyFillCFContSectionMask = 0x04, /* The extension part may be left untouched.*/
503: kResidentCFContSectionMask = 0x08,
504: kPrefaultCFContSectionMask = 0x10
505: };
506:
507:
508: enum {
509: kCFContSectionInfoVersion = 0x00010001
510: };
511:
512: struct CFContSectionInfo {
513: CFContHashedName sectionName;
514: CFContMemoryAccess access;
515: CFContSectionSharing sharing;
516: UInt8 alignment; /* ! The power of 2, a.k.a. number of low order zero bits.*/
517: UInt8 reservedA;
518: CFContSectionOptions options;
519: ByteCount containerOffset;
520: ByteCount containerLength;
521: ByteCount unpackedLength;
522: ByteCount totalLength;
523: LogicalAddress defaultAddress;
524: UInt32 reservedB;
525: void * reservedC;
526: };
527: typedef struct CFContSectionInfo CFContSectionInfo;
528:
529: /*
530: ----------------------------------
531: Declarations for exported symbols.
532: */
533: typedef UInt32 CFContExportedSymbolOptions;
534: /*
535: ! enum { // Values for CFContExportedSymbolOptions.
536: ! // ! No options at present.
537: ! };
538: */
539:
540: enum {
541: kCFContExportedSymbolInfoVersion = 0x00010001
542: };
543:
544: struct CFContExportedSymbolInfo {
545: CFContHashedName symbolName;
546: CFContLogicalLocation location;
547: CFContExportedSymbolOptions options;
548: CFragSymbolClass symbolClass;
549: UInt8 reservedA;
550: UInt16 reservedB;
551: UInt32 reservedC;
552: void * reservedD;
553: };
554: typedef struct CFContExportedSymbolInfo CFContExportedSymbolInfo;
555:
556: /*
557: ------------------------------------------------
558: Declarations for imported libraries and symbols.
559: */
560: typedef UInt32 CFContImportedLibraryOptions;
561:
562: enum {
563: /* Values for CFContImportedLibraryOptions.*/
564: kCFContWeakLibraryMask = 0x01, /* ! Same as kCFContWeakSymbolMask to reduce errors.*/
565: kCFContInitBeforeMask = 0x02,
566: kCFContDeferredBindMask = 0x04
567: };
568:
569:
570: enum {
571: kCFContImportedLibraryInfoVersion = 0x00010001
572: };
573:
574: struct CFContImportedLibraryInfo {
575: CFContHashedName libraryName;
576: CFragVersionNumber linkedVersion;
577: CFragVersionNumber oldImpVersion;
578: CFContImportedLibraryOptions options;
579: };
580: typedef struct CFContImportedLibraryInfo CFContImportedLibraryInfo;
581:
582: typedef UInt32 CFContImportedSymbolOptions;
583:
584: enum {
585: /* Values for CFContImportedSymbolOptions.*/
586: kCFContWeakSymbolMask = 0x01 /* ! Same as kCFContWeakLibraryMask to reduce errors.*/
587: };
588:
589:
590: enum {
591: kCFContImportedSymbolInfoVersion = 0x00010001
592: };
593:
594: struct CFContImportedSymbolInfo {
595: CFContHashedName symbolName;
596: ItemCount libraryIndex;
597: CFContImportedSymbolOptions options;
598: CFragSymbolClass symbolClass;
599: UInt8 reservedA;
600: UInt16 reservedB;
601: UInt32 reservedC;
602: void * reservedD;
603: };
604: typedef struct CFContImportedSymbolInfo CFContImportedSymbolInfo;
605:
606: /*
607: -------------------------------------------------
608: Declarations for dealing with container handlers.
609: */
610: typedef UInt32 CFContOpenOptions;
611:
612: enum {
613: /* Values for CFContOpenOptions.*/
614: kCFContPrepareInPlaceMask = 0x01,
615: kCFContMinimalOpenMask = 0x02
616: };
617:
618: typedef UInt32 CFContCloseOptions;
619:
620: enum {
621: /* Values for CFContCloseOptions.*/
622: kCFContPartialCloseMask = 0x01
623: };
624:
625: typedef struct OpaqueCFContHandlerRef* CFContHandlerRef;
626: typedef struct CFContHandlerProcs CFContHandlerProcs;
627: typedef CFContHandlerProcs *CFContHandlerProcsPtr;
628: typedef LogicalAddress (*CFContAllocateMem)(ByteCount size);
629: typedef void (*CFContReleaseMem)(LogicalAddress address);
630: /*
631: �
632: ===========================================================================================
633: Container Handler Routines
634: ==========================
635: */
636: typedef OSStatus (*CFCont_OpenContainer)(LogicalAddress mappedAddress, LogicalAddress runningAddress, ByteCount containerLength, KernelProcessID runningProcessID, const CFContHashedName *cfragName, CFContOpenOptions options, CFContAllocateMem Allocate, CFContReleaseMem Release, CFContHandlerRef *containerRef, CFContHandlerProcsPtr *handlerProcs);
637: typedef OSStatus (*CFCont_CloseContainer)(CFContHandlerRef containerRef, CFContCloseOptions options);
638: typedef OSStatus (*CFCont_GetContainerInfo)(CFContHandlerRef containerRef, PBVersion infoVersion, CFContContainerInfo *containerInfo);
639: /* -------------------------------------------------------------------------------------------*/
640: typedef OSStatus (*CFCont_GetSectionCount)(CFContHandlerRef containerRef, ItemCount *sectionCount);
641: typedef OSStatus (*CFCont_GetSectionInfo)(CFContHandlerRef containerRef, ItemCount sectionIndex, PBVersion infoVersion, CFContSectionInfo *sectionInfo);
642: typedef OSStatus (*CFCont_FindSectionInfo)(CFContHandlerRef containerRef, const CFContHashedName *sectionName, PBVersion infoVersion, ItemCount *sectionIndex, CFContSectionInfo *sectionInfo);
643: typedef OSStatus (*CFCont_SetSectionAddress)(CFContHandlerRef containerRef, ItemCount sectionIndex, LogicalAddress mappedAddress, LogicalAddress runningAddress);
644: /* -------------------------------------------------------------------------------------------*/
645: typedef OSStatus (*CFCont_GetAnonymousSymbolLocations)(CFContHandlerRef containerRef, CFContLogicalLocation *mainLocation, CFContLogicalLocation *initLocation, CFContLogicalLocation *termLocation);
646: /* -------------------------------------------------------------------------------------------*/
647: typedef OSStatus (*CFCont_GetExportedSymbolCount)(CFContHandlerRef containerRef, ItemCount *exportCount);
648: typedef OSStatus (*CFCont_GetExportedSymbolInfo)(CFContHandlerRef containerRef, CFContSignedIndex exportedIndex, PBVersion infoVersion, CFContExportedSymbolInfo *exportInfo);
649: typedef OSStatus (*CFCont_FindExportedSymbolInfo)(CFContHandlerRef containerRef, const CFContHashedName *exportName, PBVersion infoVersion, ItemCount *exportIndex, CFContExportedSymbolInfo *exportInfo);
650: /* -------------------------------------------------------------------------------------------*/
651: typedef OSStatus (*CFCont_GetImportCounts)(CFContHandlerRef containerRef, ItemCount *libraryCount, ItemCount *symbolCount);
652: typedef OSStatus (*CFCont_GetImportedLibraryInfo)(CFContHandlerRef containerRef, ItemCount libraryIndex, PBVersion infoVersion, CFContImportedLibraryInfo *libraryInfo);
653: typedef OSStatus (*CFCont_GetImportedSymbolInfo)(CFContHandlerRef containerRef, ItemCount symbolIndex, PBVersion infoVersion, CFContImportedSymbolInfo *symbolInfo);
654: typedef OSStatus (*CFCont_SetImportedSymbolAddress)(CFContHandlerRef containerRef, ItemCount symbolIndex, LogicalAddress symbolAddress);
655: /* -------------------------------------------------------------------------------------------*/
656: typedef OSStatus (*CFCont_UnpackSection)(CFContHandlerRef containerRef, ItemCount sectionIndex, ByteCount sectionOffset, LogicalAddress bufferAddress, ByteCount bufferLength);
657: typedef OSStatus (*CFCont_RelocateSection)(CFContHandlerRef containerRef, ItemCount sectionIndex);
658: typedef OSStatus (*CFCont_RelocateImportsOnly)(CFContHandlerRef containerRef, ItemCount sectionIndex, ItemCount libraryIndex);
659: typedef OSStatus (*CFCont_MakeSectionExecutable)(CFContHandlerRef containerRef, ItemCount sectionIndex);
660: typedef OSStatus (*CFCont_AllocateSection)(CFContHandlerRef containerRef, ItemCount sectionIndex, LogicalAddress *mappedAddress, LogicalAddress *runningAddress);
661: typedef OSStatus (*CFCont_ReleaseSection)(CFContHandlerRef containerRef, ItemCount sectionIndex);
662: /* -------------------------------------------------------------------------------------------*/
663:
664: #if 0
665: struct CFContHandlerInfo {
666: OrderedItemName orderedName;
667: OrderRequirements orderedReq;
668: CFCont_OpenContainer OpenHandler;
669: };
670: typedef struct CFContHandlerInfo CFContHandlerInfo;
671: #endif
672:
673: struct CFContHandlerProcs {
674: ItemCount procCount;
675: CFragShortVersionPair abiVersion;
676:
677: CFCont_OpenContainer OpenContainer; /* 1*/
678: CFCont_CloseContainer CloseContainer; /* 2*/
679: CFCont_GetContainerInfo GetContainerInfo; /* 3*/
680:
681: CFCont_GetSectionCount GetSectionCount; /* 4*/
682: CFCont_GetSectionInfo GetSectionInfo; /* 5*/
683: CFCont_FindSectionInfo FindSectionInfo; /* 6*/
684: CFCont_SetSectionAddress SetSectionAddress; /* 7*/
685:
686: CFCont_GetAnonymousSymbolLocations GetAnonymousSymbolLocations; /* 8*/
687:
688: CFCont_GetExportedSymbolCount GetExportedSymbolCount; /* 9*/
689: CFCont_GetExportedSymbolInfo GetExportedSymbolInfo; /* 10*/
690: CFCont_FindExportedSymbolInfo FindExportedSymbolInfo; /* 11*/
691:
692: CFCont_GetImportCounts GetImportCounts; /* 12*/
693: CFCont_GetImportedLibraryInfo GetImportedLibraryInfo; /* 13*/
694: CFCont_GetImportedSymbolInfo GetImportedSymbolInfo; /* 14*/
695: CFCont_SetImportedSymbolAddress SetImportedSymbolAddress; /* 15*/
696:
697: CFCont_UnpackSection UnpackSection; /* 16*/
698: CFCont_RelocateSection RelocateSection; /* 17*/
699: CFCont_RelocateImportsOnly RelocateImportsOnly; /* 18*/
700: CFCont_MakeSectionExecutable MakeSectionExecutable; /* 19 (Opt.)*/
701: CFCont_AllocateSection AllocateSection; /* 20 (Opt.)*/
702: CFCont_ReleaseSection ReleaseSection; /* 21 (Opt.)*/
703: };
704:
705:
706: enum {
707: kCFContMinimumProcCount = 18,
708: kCFContCurrentProcCount = 21,
709: kCFContHandlerABIVersion = 0x00010001
710: };
711:
712: /*
713: -----------------------------------------------------------------------------------------
714: The ABI version is a pair of UInt16s used as simple counters. The high order part is the
715: current version number, the low order part is the oldest compatible definition version.
716: number. This pair is to be used by the specific container handlers to describe what
717: version of the container handler ABI they support.
718: 0x00010001
719: ----------
720: The initial release of this ABI. (The old CFLoader ABI does not count.)
721: �
722: ===========================================================================================
723: General Routines
724: ================
725: */
726: extern CFContStringHash CFContHashName(BytePtr nameText, ByteCount nameLength);
727:
728: #if 0
729:
730: /* -------------------------------------------------------------------------------------------*/
731: extern OSStatus CFContOpenContainer(LogicalAddress mappedAddress, LogicalAddress runningAddress, ByteCount containerLength, KernelProcessID runningProcessID, const CFContHashedName *cfragName, CFContOpenOptions options, CFContAllocateMem Allocate, CFContReleaseMem Release, CFContHandlerRef *containerRef, CFContHandlerProcsPtr *handlerProcs);
732:
733: /* -------------------------------------------------------------------------------------------*/
734: extern OSStatus CFContRegisterContainerHandler(const OrderedItemName *orderedName, const OrderRequirements *orderedReq, CFCont_OpenContainer OpenHandler, OrderedItemName *rejectingHandler);
735:
736: extern OSStatus CFContUnregisterContainerHandler(const OrderedItemName *orderedName);
737:
738: extern OSStatus CFContGetContainerHandlers(ItemCount requestedCount, ItemCount *totalCount, CFContHandlerInfo *handlers);
739:
740: /* -------------------------------------------------------------------------------------------*/
741: #endif
742:
743:
744:
745:
746:
747:
748: /*
749: File: PEFLoader.h
750:
751: Contains: PEF Loader Interface.
752:
753: Version: Maxwell
754:
755: Copyright: � 1992-1996 by Apple Computer, Inc., all rights reserved.
756:
757: File Ownership:
758:
759: DRI: Alan Lillich
760:
761: Other Contact: <<unknown>>
762:
763: Technology: Core Runtime
764:
765: Writers:
766:
767: (AWL) Alan Lillich
768: (ELE) Erik Eidt
769:
770: Change History (most recent first):
771:
772: <7> 8/23/96 AWL (1379028) Propagate changes from CodeFragmentContainerPriv.
773: <6> 2/28/96 AWL Adapt for new container handler model.
774: <5> 6/20/94 AWL Move private PEF loader info struct here to be visible to the
775: booting "wacky" PEF loader.
776: <4> 6/8/94 AWL Make all CFL routines visible for direct use in special cases
777: such as booting.
778: <3> 5/16/94 AWL Fix typo.
779: <2> 2/25/94 AWL Update for Q&D solution to loading across address spaces.
780: <1> 2/15/94 AWL Initial checkin for kernel based CFM.
781: */
782:
783: // ===========================================================================================
784:
785: enum {
786: kBuiltinSectionArraySize = 4
787: };
788:
789: struct PEFPrivateInfo { // !!! Clean up field names, collapse Booleans, etc.
790: CFContAllocateMem Allocate;
791: CFContReleaseMem Release;
792: BytePtr mappedContainer;
793: BytePtr runningContainer;
794: ItemCount sectionCount; // Just the instantiated sections.
795: SectionHeader * sections;
796: BytePtr stringTable;
797: ItemCount ldrSectionNo;
798: LoaderHeader * ldrHeader;
799: BytePtr ldrStringTable;
800: LoaderRelExpHeader * ldrSections;
801: LoaderImportFileID * ldrImportFiles;
802: LoaderImport * ldrImportSymbols;
803: HashSlotEntry * ldrHashSlot;
804: HashChainEntry * ldrHashChain;
805: LoaderExport * ldrExportSymbols;
806: BytePtr ldrRelocations;
807: BytePtr * mappedOrigins; // Mapped base address for each section.
808: ByteCount * runningOffsets; // Running offset from presumed address.
809: BytePtr * imports;
810: BytePtr originArray [kBuiltinSectionArraySize]; // ! Only used if big enough.
811: ByteCount offsetArray [kBuiltinSectionArraySize]; // ! Only used if big enough.
812: Boolean loadInPlace;
813: Boolean resolved;
814: };
815:
816: typedef struct PEFPrivateInfo PEFPrivateInfo;
817:
818:
819: // ===========================================================================================
820:
821:
822: extern OSStatus PEF_OpenContainer ( LogicalAddress mappedAddress,
823: LogicalAddress runningAddress,
824: ByteCount containerLength,
825: KernelProcessID runningProcessID,
826: const CFContHashedName * cfragName,
827: CFContOpenOptions options,
828: CFContAllocateMem Allocate,
829: CFContReleaseMem Release,
830: CFContHandlerRef * containerRef_o,
831: CFContHandlerProcs * * handlerProcs_o );
832:
833: extern OSStatus PEF_CloseContainer ( CFContHandlerRef containerRef,
834: CFContCloseOptions options );
835:
836: extern OSStatus PEF_GetContainerInfo ( CFContHandlerRef containerRef,
837: PBVersion infoVersion,
838: CFContContainerInfo * containerInfo );
839:
840: // -------------------------------------------------------------------------------------------
841:
842: extern OSStatus PEF_GetSectionCount ( CFContHandlerRef containerRef,
843: ItemCount * sectionCount );
844:
845: extern OSStatus PEF_GetSectionInfo ( CFContHandlerRef containerRef,
846: ItemCount sectionIndex,
847: PBVersion infoVersion,
848: CFContSectionInfo * sectionInfo );
849:
850: extern OSStatus PEF_FindSectionInfo ( CFContHandlerRef containerRef,
851: const CFContHashedName * sectionName,
852: PBVersion infoVersion,
853: ItemCount * sectionIndex, // May be null.
854: CFContSectionInfo * sectionInfo ); // May be null.
855:
856: extern OSStatus PEF_SetSectionAddress ( CFContHandlerRef containerRef,
857: ItemCount sectionIndex,
858: LogicalAddress mappedAddress,
859: LogicalAddress runningAddress );
860:
861: // -------------------------------------------------------------------------------------------
862:
863: extern OSStatus PEF_GetAnonymousSymbolLocations ( CFContHandlerRef containerRef,
864: CFContLogicalLocation * mainLocation, // May be null.
865: CFContLogicalLocation * initLocation, // May be null.
866: CFContLogicalLocation * termLocation ); // May be null.
867:
868: // -------------------------------------------------------------------------------------------
869:
870: extern OSStatus PEF_GetExportedSymbolCount ( CFContHandlerRef containerRef,
871: ItemCount * exportCount );
872:
873: extern OSStatus PEF_GetExportedSymbolInfo ( CFContHandlerRef containerRef,
874: CFContSignedIndex exportIndex,
875: PBVersion infoVersion,
876: CFContExportedSymbolInfo * exportInfo );
877:
878: extern OSStatus PEF_FindExportedSymbolInfo ( CFContHandlerRef containerRef,
879: const CFContHashedName * exportName,
880: PBVersion infoVersion,
881: ItemCount * exportIndex, // May be null.
882: CFContExportedSymbolInfo * exportInfo ); // May be null.
883:
884: // -------------------------------------------------------------------------------------------
885:
886: extern OSStatus PEF_GetImportCounts ( CFContHandlerRef containerRef,
887: ItemCount * libraryCount, // May be null.
888: ItemCount * symbolCount ); // May be null.
889:
890: extern OSStatus PEF_GetImportedLibraryInfo ( CFContHandlerRef containerRef,
891: ItemCount libraryIndex,
892: PBVersion infoVersion,
893: CFContImportedLibraryInfo * libraryInfo );
894:
895: extern OSStatus PEF_GetImportedSymbolInfo ( CFContHandlerRef containerRef,
896: ItemCount symbolIndex,
897: PBVersion infoVersion,
898: CFContImportedSymbolInfo * symbolInfo );
899:
900: extern OSStatus PEF_SetImportedSymbolAddress ( CFContHandlerRef containerRef,
901: ItemCount symbolIndex,
902: LogicalAddress symbolAddress );
903:
904: // -------------------------------------------------------------------------------------------
905:
906: extern OSStatus PEF_UnpackSection ( CFContHandlerRef containerRef,
907: ItemCount sectionIndex,
908: ByteCount sectionOffset,
909: LogicalAddress bufferAddress,
910: ByteCount bufferLength );
911:
912: extern OSStatus PEF_RelocateSection ( CFContHandlerRef containerRef,
913: ItemCount sectionIndex );
914:
915: extern OSStatus PEF_RelocateImportsOnly ( CFContHandlerRef containerRef,
916: ItemCount sectionIndex,
917: ItemCount libraryIndex );
918:
919: struct CFragInitBlock {
920: void * contextID;
921: void * closureID;
922: void * connectionID;
923: SInt32 where; // locator rec
924: LogicalAddress address;
925: ByteCount length;
926: Boolean inPlace;
927: UInt8 resvA;
928: UInt16 resvB;
929: char * libName;
930: UInt32 resvC;
931: };
932: typedef struct CFragInitBlock CFragInitBlock;
933:
934: #pragma options align=reset
935:
936: #endif // __IOPEFINTERNALS__
937:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.