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