You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1111 lines
66 KiB
1111 lines
66 KiB
/* |
|
File: PEFBinaryFormat.h |
|
|
|
Contains: PEF Types and Macros |
|
|
|
Version: QuickTime 7.3 |
|
|
|
Copyright: (c) 2007 (c) 1993-2001 by Apple Computer, Inc., all rights reserved. |
|
|
|
Bugs?: For bug reports, consult the following page on |
|
the World Wide Web: |
|
|
|
http://developer.apple.com/bugreporter/ |
|
|
|
*/ |
|
|
|
|
|
#ifndef __PEFBINARYFORMAT__ |
|
#define __PEFBINARYFORMAT__ |
|
|
|
#ifndef __MACTYPES__ |
|
#include <MacTypes.h> |
|
#endif |
|
|
|
|
|
|
|
|
|
#if PRAGMA_ONCE |
|
#pragma once |
|
#endif |
|
|
|
#if PRAGMA_IMPORT |
|
#pragma import on |
|
#endif |
|
|
|
#if PRAGMA_STRUCT_ALIGN |
|
#pragma options align=mac68k |
|
#elif PRAGMA_STRUCT_PACKPUSH |
|
#pragma pack(push, 2) |
|
#elif PRAGMA_STRUCT_PACK |
|
#pragma pack(2) |
|
#endif |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* Almost all types are padded for natural alignment. However the PEFExportedSymbol type is */ |
|
/* 10 bytes long, containing two 32 bit fields and one 16 bit field. Arrays of it must be */ |
|
/* packed, so it requires "68K" alignment. Setting this globally to 68K should also help */ |
|
/* ensure consistent treatment across compilers. */ |
|
|
|
|
|
|
|
/* ======================================================================================== */ |
|
/* Overall Structure */ |
|
/* ================= */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* This header contains a complete set of types and macros for dealing with the PEF executable */ |
|
/* format. While some description is provided, this header is not meant as a primary source */ |
|
/* of documentation on PEF. An excellent specification of PEF can be found in the Macintosh */ |
|
/* Runtime Architectures book. This header is primarily a physical format description. Thus */ |
|
/* it depends on as few other headers as possible and structure fields have obvious sizes. */ |
|
/* */ |
|
/* The physical storage for a PEF executable is known as a "container". This refers to just */ |
|
/* the executable itself, not the file etc. E.g. if five DLLs are packaged in a single file's */ |
|
/* data fork, that one data fork has five containers within it. */ |
|
/* */ |
|
/* A PEF container consists of an overall header, followed by one or more section headers, */ |
|
/* followed by the section name table, followed by the contents for the sections. Some kinds */ |
|
/* of sections have specific internal representation. The "loader" section is the most common */ |
|
/* of these special sections. It contains information on the exports, imports, and runtime */ |
|
/* relocations required to prepare the executable. PEF containers are self contained, all */ |
|
/* portions are located via relative offsets. */ |
|
/* */ |
|
/* */ |
|
/* +-------------------------------+ */ |
|
/* | Container Header | 40 bytes */ |
|
/* +-------------------------------+ */ |
|
/* | Section 0 header | 28 bytes each */ |
|
/* |...............................| */ |
|
/* | - - - - | */ |
|
/* |...............................| */ |
|
/* | Section n-1 header | */ |
|
/* +-------------------------------+ */ |
|
/* | Section Name Table | */ |
|
/* +-------------------------------+ */ |
|
/* | Section x raw data | */ |
|
/* +-------------------------------+ */ |
|
/* | - - - - | */ |
|
/* +-------------------------------+ */ |
|
/* | Section y raw data | */ |
|
/* +-------------------------------+ */ |
|
/* */ |
|
/* */ |
|
/* The sections are implicitly numbered from 0 to n according to the order of their headers. */ |
|
/* The headers of the instantiated sections must precede those of the non-instantiated */ |
|
/* sections. The ordering of the raw data is independent of the section header ordering. */ |
|
/* Each section header contains the offset for that section's raw data. */ |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Container Header */ |
|
/* ================ */ |
|
|
|
|
|
|
|
struct PEFContainerHeader { |
|
OSType tag1; /* Must contain 'Joy!'.*/ |
|
OSType tag2; /* Must contain 'peff'. (Yes, with two 'f's.)*/ |
|
OSType architecture; /* The ISA for code sections. Constants in CodeFragments.h.*/ |
|
UInt32 formatVersion; /* The physical format version.*/ |
|
UInt32 dateTimeStamp; /* Macintosh format creation/modification stamp.*/ |
|
UInt32 oldDefVersion; /* Old definition version number for the code fragment.*/ |
|
UInt32 oldImpVersion; /* Old implementation version number for the code fragment.*/ |
|
UInt32 currentVersion; /* Current version number for the code fragment.*/ |
|
UInt16 sectionCount; /* Total number of section headers that follow.*/ |
|
UInt16 instSectionCount; /* Number of instantiated sections.*/ |
|
UInt32 reservedA; /* Reserved, must be written as zero.*/ |
|
}; |
|
typedef struct PEFContainerHeader PEFContainerHeader; |
|
enum { |
|
kPEFTag1 = FOUR_CHAR_CODE('Joy!'), /* For non-Apple compilers: 0x4A6F7921.*/ |
|
kPEFTag2 = FOUR_CHAR_CODE('peff'), /* For non-Apple compilers: 0x70656666.*/ |
|
kPEFVersion = 0x00000001 |
|
}; |
|
|
|
|
|
enum { |
|
kPEFFirstSectionHeaderOffset = sizeof(PEFContainerHeader) |
|
}; |
|
|
|
#define PEFFirstSectionNameOffset(container) \ |
|
( kPEFFirstSectionHeaderOffset + ((container)->sectionCount * sizeof ( PEFSectionHeader )) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Section Headers */ |
|
/* =============== */ |
|
|
|
|
|
|
|
struct PEFSectionHeader { |
|
SInt32 nameOffset; /* Offset of name within the section name table, -1 => none.*/ |
|
UInt32 defaultAddress; /* Default address, affects relocations.*/ |
|
UInt32 totalLength; /* Fully expanded size in bytes of the section contents.*/ |
|
UInt32 unpackedLength; /* Size in bytes of the "initialized" part of the contents.*/ |
|
UInt32 containerLength; /* Size in bytes of the raw data in the container.*/ |
|
UInt32 containerOffset; /* Offset of section's raw data.*/ |
|
UInt8 sectionKind; /* Kind of section contents/usage.*/ |
|
UInt8 shareKind; /* Sharing level, if a writeable section.*/ |
|
UInt8 alignment; /* Preferred alignment, expressed as log 2.*/ |
|
UInt8 reservedA; /* Reserved, must be zero.*/ |
|
}; |
|
typedef struct PEFSectionHeader PEFSectionHeader; |
|
enum { |
|
/* Values for the sectionKind field.*/ |
|
/* Section kind values for instantiated sections.*/ |
|
kPEFCodeSection = 0, /* Code, presumed pure & position independent.*/ |
|
kPEFUnpackedDataSection = 1, /* Unpacked writeable data.*/ |
|
kPEFPackedDataSection = 2, /* Packed writeable data.*/ |
|
kPEFConstantSection = 3, /* Read-only data.*/ |
|
kPEFExecDataSection = 6, /* Intermixed code and writeable data.*/ |
|
/* Section kind values for non-instantiated sections.*/ |
|
kPEFLoaderSection = 4, /* Loader tables.*/ |
|
kPEFDebugSection = 5, /* Reserved for future use.*/ |
|
kPEFExceptionSection = 7, /* Reserved for future use.*/ |
|
kPEFTracebackSection = 8 /* Reserved for future use.*/ |
|
}; |
|
|
|
|
|
enum { |
|
/* Values for the shareKind field.*/ |
|
kPEFProcessShare = 1, /* Shared within a single process.*/ |
|
kPEFGlobalShare = 4, /* Shared across the entire system.*/ |
|
kPEFProtectedShare = 5 /* Readable across the entire system, writeable only to privileged code.*/ |
|
}; |
|
|
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Packed Data Contents */ |
|
/* ==================== */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The raw contents of a packed data section are a sequence of byte codes. The basic format */ |
|
/* has a 3 bit opcode followed by a 5 bit count. Additional bytes might be used to contain */ |
|
/* counts larger than 31, and to contain a second or third count. Further additional bytes */ |
|
/* contain actual data values to transfer. */ |
|
/* */ |
|
/* All counts are represented in a variable length manner. A zero in the initial 5 bit count */ |
|
/* indicates the actual value follows. In this case, and for the second and third counts, the */ |
|
/* count is represented as a variable length sequence of bytes. The bytes are stored in big */ |
|
/* endian manner, most significant part first. The high order bit is set in all but the last */ |
|
/* byte. The value is accumulated by shifting the current value up 7 bits and adding in the */ |
|
/* low order 7 bits of the next byte. */ |
|
|
|
|
|
enum { |
|
/* The packed data opcodes.*/ |
|
kPEFPkDataZero = 0, /* Zero fill "count" bytes.*/ |
|
kPEFPkDataBlock = 1, /* Block copy "count" bytes.*/ |
|
kPEFPkDataRepeat = 2, /* Repeat "count" bytes "count2"+1 times.*/ |
|
kPEFPkDataRepeatBlock = 3, /* Interleaved repeated and unique data.*/ |
|
kPEFPkDataRepeatZero = 4 /* Interleaved zero and unique data.*/ |
|
}; |
|
|
|
|
|
enum { |
|
kPEFPkDataOpcodeShift = 5, |
|
kPEFPkDataCount5Mask = 0x1F, |
|
kPEFPkDataMaxCount5 = 31, |
|
kPEFPkDataVCountShift = 7, |
|
kPEFPkDataVCountMask = 0x7F, |
|
kPEFPkDataVCountEndMask = 0x80 |
|
}; |
|
|
|
|
|
#define PEFPkDataOpcode(byte) ( ((UInt8)(byte)) >> kPEFPkDataOpcodeShift ) |
|
|
|
#define PEFPkDataCount5(byte) ( ((UInt8)(byte)) & kPEFPkDataCount5Mask ) |
|
|
|
#define PEFPkDataComposeInstr(opcode,count5) \ |
|
( (((UInt8)(opcode)) << kPEFPkDataOpcodeShift) | ((UInt8)(count5)) ) |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The following code snippet can be used to input a variable length count. */ |
|
/* */ |
|
/* count = 0; */ |
|
/* do { */ |
|
/* byte = *bytePtr++; */ |
|
/* count = (count << kPEFPkDataVCountShift) | (byte & kPEFPkDataVCountMask); */ |
|
/* } while ( (byte & kPEFPkDataVCountEndMask) != 0 ); */ |
|
/* */ |
|
/* The following code snippet can be used to output a variable length count to a byte array. */ |
|
/* This is more complex than the input code because the chunks are output in big endian order. */ |
|
/* Think about handling values like 0 or 0x030000. */ |
|
/* */ |
|
/* count = 1;. */ |
|
/* tempValue = value >> kPEFPkDataCountShift; */ |
|
/* while ( tempValue != 0 ) { */ |
|
/* count += 1; */ |
|
/* tempValue = tempValue >> kPEFPkDataCountShift; */ |
|
/* } */ |
|
/* */ |
|
/* bytePtr += count; */ |
|
/* tempPtr = bytePtr - 1; */ |
|
/* *tempPtr-- = value; // ! No need to mask, only the low order byte is stored. */ |
|
/* for ( count -= 1; count != 0; count -= 1 ) { */ |
|
/* value = value >> kPEFPkDataCountShift; */ |
|
/* *tempPtr-- = value | kPEFPkDataCountEndMask; */ |
|
/* } */ |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Loader Section */ |
|
/* ============== */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The loader section contains information needed to prepare the code fragment for execution. */ |
|
/* This includes this fragment's exports, the import libraries and the imported symbols from */ |
|
/* each library, and the relocations for the writeable sections. */ |
|
/* */ |
|
/* +-----------------------------------+ <-- containerOffset --------+ */ |
|
/* | Loader Info Header | 56 bytes | */ |
|
/* |-----------------------------------| | */ |
|
/* | Imported Library 0 | 24 bytes each | */ |
|
/* |...................................| | */ |
|
/* | - - - | | */ |
|
/* |...................................| | */ |
|
/* | Imported Library l-1 | | */ |
|
/* |-----------------------------------| | */ |
|
/* | Imported Symbol 0 | 4 bytes each | */ |
|
/* |...................................| | */ |
|
/* | - - - | | */ |
|
/* |...................................| | */ |
|
/* | Imported Symbol i-1 | | */ |
|
/* |-----------------------------------| | */ |
|
/* | Relocation Header 0 | 12 bytes each | */ |
|
/* |...................................| | */ |
|
/* | - - - | | */ |
|
/* |...................................| | */ |
|
/* | Relocation Header r-1 | | */ |
|
/* |-----------------------------------| <-- + relocInstrOffset -----| */ |
|
/* | Relocation Instructions | | */ |
|
/* |-----------------------------------| <-- + loaderStringsOffset --| */ |
|
/* | Loader String Table | | */ |
|
/* |-----------------------------------| <-- + exportHashOffset -----+ */ |
|
/* | Export Hash Slot 0 | 4 bytes each */ |
|
/* |...................................| */ |
|
/* | - - - | */ |
|
/* |...................................| */ |
|
/* | Export Hash Slot h-1 | */ |
|
/* |-----------------------------------| */ |
|
/* | Export Symbol Key 0 | 4 bytes each */ |
|
/* |...................................| */ |
|
/* | - - - | */ |
|
/* |...................................| */ |
|
/* | Export Symbol Key e-1 | */ |
|
/* |-----------------------------------| */ |
|
/* | Export Symbol 0 | 10 bytes each */ |
|
/* |...................................| */ |
|
/* | - - - | */ |
|
/* |...................................| */ |
|
/* | Export Symbol e-1 | */ |
|
/* +-----------------------------------+ */ |
|
|
|
|
|
|
|
struct PEFLoaderInfoHeader { |
|
SInt32 mainSection; /* Section containing the main symbol, -1 => none.*/ |
|
UInt32 mainOffset; /* Offset of main symbol.*/ |
|
SInt32 initSection; /* Section containing the init routine's TVector, -1 => none.*/ |
|
UInt32 initOffset; /* Offset of the init routine's TVector.*/ |
|
SInt32 termSection; /* Section containing the term routine's TVector, -1 => none.*/ |
|
UInt32 termOffset; /* Offset of the term routine's TVector.*/ |
|
UInt32 importedLibraryCount; /* Number of imported libraries. ('l')*/ |
|
UInt32 totalImportedSymbolCount; /* Total number of imported symbols. ('i')*/ |
|
UInt32 relocSectionCount; /* Number of sections with relocations. ('r')*/ |
|
UInt32 relocInstrOffset; /* Offset of the relocation instructions.*/ |
|
UInt32 loaderStringsOffset; /* Offset of the loader string table.*/ |
|
UInt32 exportHashOffset; /* Offset of the export hash table.*/ |
|
UInt32 exportHashTablePower; /* Export hash table size as log 2. (Log2('h'))*/ |
|
UInt32 exportedSymbolCount; /* Number of exported symbols. ('e')*/ |
|
}; |
|
typedef struct PEFLoaderInfoHeader PEFLoaderInfoHeader; |
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Imported Libraries */ |
|
/* ------------------ */ |
|
|
|
|
|
struct PEFImportedLibrary { |
|
UInt32 nameOffset; /* Loader string table offset of library's name.*/ |
|
UInt32 oldImpVersion; /* Oldest compatible implementation version.*/ |
|
UInt32 currentVersion; /* Current version at build time.*/ |
|
UInt32 importedSymbolCount; /* Imported symbol count for this library.*/ |
|
UInt32 firstImportedSymbol; /* Index of first imported symbol from this library.*/ |
|
UInt8 options; /* Option bits for this library.*/ |
|
UInt8 reservedA; /* Reserved, must be zero.*/ |
|
UInt16 reservedB; /* Reserved, must be zero.*/ |
|
}; |
|
typedef struct PEFImportedLibrary PEFImportedLibrary; |
|
enum { |
|
/* Bits for the PEFImportedLibrary options field.*/ |
|
kPEFWeakImportLibMask = 0x40, /* The imported library is allowed to be missing.*/ |
|
kPEFInitLibBeforeMask = 0x80 /* The imported library must be initialized first.*/ |
|
}; |
|
|
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Imported Symbols */ |
|
/* ---------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The PEFImportedSymbol type has the following bit field layout. */ |
|
/* */ |
|
/* 3 */ |
|
/* 0 7 8 1 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | symbol class | offset of symbol name in loader string table | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 8 bits --->|<-- 24 bits ---------------------------------->| */ |
|
|
|
|
|
|
|
struct PEFImportedSymbol { |
|
UInt32 classAndName; |
|
}; |
|
typedef struct PEFImportedSymbol PEFImportedSymbol; |
|
enum { |
|
kPEFImpSymClassShift = 24, |
|
kPEFImpSymNameOffsetMask = 0x00FFFFFF, |
|
kPEFImpSymMaxNameOffset = 0x00FFFFFF /* 16,777,215*/ |
|
}; |
|
|
|
#define PEFImportedSymbolClass(classAndName) ((UInt8) ((classAndName) >> kPEFImpSymClassShift)) |
|
#define PEFImportedSymbolNameOffset(classAndName) ((classAndName) & kPEFImpSymNameOffsetMask) |
|
|
|
#define PEFComposeImportedSymbol(class,nameOffset) \ |
|
( ( ((UInt32)(class)) << kPEFImpSymClassShift ) | ( (UInt32)(nameOffset) ) ) |
|
|
|
enum { |
|
/* Imported and exported symbol classes.*/ |
|
kPEFCodeSymbol = 0x00, |
|
kPEFDataSymbol = 0x01, |
|
kPEFTVectorSymbol = 0x02, |
|
kPEFTOCSymbol = 0x03, |
|
kPEFGlueSymbol = 0x04, |
|
kPEFUndefinedSymbol = 0x0F, |
|
kPEFWeakImportSymMask = 0x80 |
|
}; |
|
|
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Exported Symbol Hash Table */ |
|
/* -------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* Exported symbols are described in four parts, optimized for speed of lookup. These parts */ |
|
/* are the "export hash table", the "export key table", the "export symbol table", and the */ |
|
/* "export name table". Overall they contain a flattened representation of a fairly normal */ |
|
/* hashed symbol table. */ |
|
/* */ |
|
/* The export hash table is an array of small fixed size elements. The number of elements is */ |
|
/* a power of 2. A 32 bit hash word for a symbol is converted into an index into this array. */ |
|
/* Each hash slot contains a count of the number of exported symbols that map to this slot and */ |
|
/* the index of the first of those symbols in the key and symbol tables. Of course some hash */ |
|
/* slots will have a zero count. */ |
|
/* */ |
|
/* The key and symbol tables are also arrays of fixed size elements, one for each exported */ |
|
/* symbol. Their entries are grouped by hash slot, those elements mapping to the same hash */ |
|
/* slot are contiguous. The key table contains just the full 32 bit hash word for each */ |
|
/* exported symbol. The symbol table contains the offset of the symbol's name in the string */ |
|
/* table and other information about the exported symbol. */ |
|
/* */ |
|
/* To look up an export you take the hashword and compute the hash slot index. You then scan */ |
|
/* the indicated portion of the key table for matching hashwords. If a hashword matches, you */ |
|
/* look at the corresponding symbol table entry to find the full symbol name. If the names */ |
|
/* match the symbol is found. */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The following function may be used to compute the hash table size. Signed values are used */ |
|
/* just to avoid potential code generation overhead for unsigned division. */ |
|
/* */ |
|
/* UInt8 PEFComputeHashTableExponent ( SInt32 exportCount ) */ |
|
/* { */ |
|
/* SInt32 exponent; */ |
|
/* */ |
|
/* const SInt32 kExponentLimit = 16; // Arbitrary, but must not exceed 30. */ |
|
/* const SInt32 kAverageChainLimit = 10; // Arbitrary, for space/time tradeoff. */ |
|
/* */ |
|
/* for ( exponent = 0; exponent < kExponentLimit; exponent += 1 ) { */ |
|
/* if ( (exportCount / (1 << exponent)) < kAverageChainLimit ) break; */ |
|
/* } */ |
|
/* */ |
|
/* return exponent; */ |
|
/* */ |
|
/* } // PEFComputeHashTableExponent () */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The PEFExportedSymbolHashSlot type has the following bit field layout. */ |
|
/* */ |
|
/* 1 1 3 */ |
|
/* 0 3 4 1 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | symbol count | index of first export key | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 14 bits -------------->|<-- 18 bits ---------------------->| */ |
|
|
|
|
|
|
|
struct PEFExportedSymbolHashSlot { |
|
UInt32 countAndStart; |
|
}; |
|
typedef struct PEFExportedSymbolHashSlot PEFExportedSymbolHashSlot; |
|
enum { |
|
kPEFHashSlotSymCountShift = 18, |
|
kPEFHashSlotFirstKeyMask = 0x0003FFFF, |
|
kPEFHashSlotMaxSymbolCount = 0x00003FFF, /* 16,383*/ |
|
kPEFHashSlotMaxKeyIndex = 0x0003FFFF /* 262,143*/ |
|
}; |
|
|
|
#define PEFHashTableIndex(fullHashWord,hashTablePower) \ |
|
( ( (fullHashWord) ^ ((fullHashWord) >> (hashTablePower)) ) & ((1 << (hashTablePower)) - 1) ) |
|
|
|
#define PEFHashSlotSymbolCount(countAndStart) ((UInt32) ((countAndStart) >> kPEFHashSlotSymCountShift)) |
|
#define PEFHashSlotFirstKey(countAndStart) ((countAndStart) & kPEFHashSlotFirstKeyMask) |
|
|
|
#define PEFComposeExportedSymbolHashSlot(symbolCount,firstKey) \ |
|
( ( ((UInt32)(symbolCount)) << kPEFHashSlotSymCountShift ) | ( (UInt32)(firstKey) ) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Exported Symbol Hash Key */ |
|
/* ------------------------ */ |
|
|
|
|
|
|
|
struct PEFSplitHashWord { |
|
UInt16 nameLength; |
|
UInt16 hashValue; |
|
}; |
|
typedef struct PEFSplitHashWord PEFSplitHashWord; |
|
struct PEFExportedSymbolKey { |
|
union { |
|
UInt32 fullHashWord; |
|
PEFSplitHashWord splitHashWord; |
|
} u; |
|
}; |
|
typedef struct PEFExportedSymbolKey PEFExportedSymbolKey; |
|
enum { |
|
kPEFHashLengthShift = 16, |
|
kPEFHashValueMask = 0x0000FFFF, |
|
kPEFHashMaxLength = 0x0000FFFF /* 65,535*/ |
|
}; |
|
|
|
#define PEFHashNameLength(fullHashWord) ((UInt32) ((fullHashWord) >> kPEFHashLengthShift)) |
|
#define PEFHashValue(fullHashWord) ((fullHashWord) & kPEFHashValueMask) |
|
|
|
#define PEFComposeFullHashWord(nameLength,hashValue) \ |
|
( ( ((UInt32)(nameLength)) << kPEFHashLengthShift ) | ( (UInt32)(hashValue) ) ) |
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */ |
|
/* The following function computes the full 32 bit hash word. */ |
|
/* */ |
|
/* UInt32 PEFComputeHashWord ( BytePtr nameText, // ! First "letter", not length byte. */ |
|
/* UInt32 nameLength ) // ! The text may be zero terminated. */ |
|
/* { */ |
|
/* BytePtr charPtr = nameText; */ |
|
/* SInt32 hashValue = 0; // ! Signed to match old published algorithm. */ |
|
/* UInt32 length = 0; */ |
|
/* UInt32 limit; */ |
|
/* UInt32 result; */ |
|
/* UInt8 currChar; */ |
|
/* */ |
|
/* #define PseudoRotate(x) ( ( (x) << 1 ) - ( (x) >> 16 ) ) */ |
|
/* */ |
|
/* for ( limit = nameLength; limit > 0; limit -= 1 ) { */ |
|
/* currChar = *charPtr++; */ |
|
/* if ( currChar == NULL ) break; */ |
|
/* length += 1; */ |
|
/* hashValue = PseudoRotate ( hashValue ) ^ currChar; */ |
|
/* } */ |
|
/* */ |
|
/* result = (length << kPEFHashLengthShift) | */ |
|
/* ((UInt16) ((hashValue ^ (hashValue >> 16)) & kPEFHashValueMask)); */ |
|
/* */ |
|
/* return result; */ |
|
/* */ |
|
/* } // PEFComputeHashWord () */ |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Exported Symbols */ |
|
/* ---------------- */ |
|
|
|
|
|
|
|
struct PEFExportedSymbol { /* ! This structure is 10 bytes long and arrays are packed.*/ |
|
UInt32 classAndName; /* A combination of class and name offset.*/ |
|
UInt32 symbolValue; /* Typically the symbol's offset within a section.*/ |
|
SInt16 sectionIndex; /* The index of the section, or pseudo-section, for the symbol.*/ |
|
}; |
|
typedef struct PEFExportedSymbol PEFExportedSymbol; |
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The classAndName field of the PEFExportedSymbol type has the following bit field layout. */ |
|
/* */ |
|
/* 3 */ |
|
/* 0 7 8 1 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | symbol class | offset of symbol name in loader string table | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 8 bits --->|<-- 24 bits ---------------------------------->| */ |
|
|
|
|
|
enum { |
|
kPEFExpSymClassShift = 24, |
|
kPEFExpSymNameOffsetMask = 0x00FFFFFF, |
|
kPEFExpSymMaxNameOffset = 0x00FFFFFF /* 16,777,215*/ |
|
}; |
|
|
|
#define PEFExportedSymbolClass(classAndName) ((UInt8) ((classAndName) >> kPEFExpSymClassShift)) |
|
#define PEFExportedSymbolNameOffset(classAndName) ((classAndName) & kPEFExpSymNameOffsetMask) |
|
|
|
#define PEFComposeExportedSymbol(class,nameOffset) \ |
|
( ( ((UInt32)(class)) << kPEFExpSymClassShift ) | ( (UInt32)(nameOffset) ) ) |
|
|
|
enum { |
|
/* Negative section indices indicate pseudo-sections.*/ |
|
kPEFAbsoluteExport = -2, /* The symbol value is an absolute address.*/ |
|
kPEFReexportedImport = -3 /* The symbol value is the index of a reexported import.*/ |
|
}; |
|
|
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Loader Relocations */ |
|
/* ================== */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The relocations for a section are defined by a sequence of instructions for an abstract */ |
|
/* machine that is specifically geared to performing relocations commonly needed for the "CFM" */ |
|
/* code generation model. These instructions occur in 16 bit chunks. Most instructions have */ |
|
/* just a single chunk. Instructions that are larger than 16 bits have an opcode and some of */ |
|
/* the operands in the first chunk, with other operands in following chunks. */ |
|
/* */ |
|
/* ! Note that the multi-chunk relocations have separate "Compose" macros for each chunk. The */ |
|
/* ! macros have the same basic name with a positional suffix of "_1st", "_2nd", etc. */ |
|
|
|
|
|
|
|
|
|
typedef UInt16 PEFRelocChunk; |
|
struct PEFLoaderRelocationHeader { |
|
UInt16 sectionIndex; /* Index of the section to be fixed up.*/ |
|
UInt16 reservedA; /* Reserved, must be zero.*/ |
|
UInt32 relocCount; /* Number of 16 bit relocation chunks.*/ |
|
UInt32 firstRelocOffset; /* Offset of first relocation instruction.*/ |
|
}; |
|
typedef struct PEFLoaderRelocationHeader PEFLoaderRelocationHeader; |
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* ! Note that the relocCount field is the number of 16 bit relocation chunks, i.e. 1/2 the */ |
|
/* ! total number of bytes of relocation instructions. While most relocation instructions are */ |
|
/* ! 16 bits long, some are longer so the number of complete relocation instructions may be */ |
|
/* ! less than the relocCount value. */ |
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------ */ |
|
/* The PEFRelocField macro is a utility for extracting relocation instruction fields. */ |
|
|
|
|
|
#define PEFRFShift(offset,length) (16 - ((offset) + (length))) |
|
#define PEFRFMask(length) ((1 << (length)) - 1) |
|
|
|
#define PEFRelocField(chunk,offset,length) \ |
|
( ( (chunk) >> (16 - ((offset) + (length))) ) & ((1 << (length)) - 1) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* Basic Relocation Opcodes */ |
|
/* ------------------------ */ |
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The number of opcode bits varies from 2 to 7. The enumeration and switch table given here */ |
|
/* are defined in terms of the most significant 7 bits of the first instruction chunk. An */ |
|
/* instruction is decoded by using the most significant 7 bits as an index into the opcode */ |
|
/* table, which in turn contains appropriately masked forms of the most significant 7 bits. */ |
|
/* The macro PEFRelocBasicOpcode assumes a declaration of the form. */ |
|
/* */ |
|
/* UInt8 kPEFRelocBasicOpcodes [kPEFRelocBasicOpcodeRange] = { PEFMaskedBasicOpcodes }; */ |
|
|
|
|
|
enum { |
|
kPEFRelocBasicOpcodeRange = 128 |
|
}; |
|
|
|
#define PEFRelocBasicOpcode(firstChunk) (kPEFRelocBasicOpcodes[(firstChunk)>>9]) |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The relocation opcodes, clustered by major and minor groups. The instructions within a */ |
|
/* cluster all have the same bit field layout. The enumeration values use the high order 7 */ |
|
/* bits of the relocation instruction. Unused low order bits are set to zero. */ |
|
|
|
enum { |
|
kPEFRelocBySectDWithSkip = 0x00, /* Binary: 00x_xxxx*/ |
|
kPEFRelocBySectC = 0x20, /* Binary: 010_0000, group is "RelocRun"*/ |
|
kPEFRelocBySectD = 0x21, /* Binary: 010_0001*/ |
|
kPEFRelocTVector12 = 0x22, /* Binary: 010_0010*/ |
|
kPEFRelocTVector8 = 0x23, /* Binary: 010_0011*/ |
|
kPEFRelocVTable8 = 0x24, /* Binary: 010_0100*/ |
|
kPEFRelocImportRun = 0x25, /* Binary: 010_0101*/ |
|
kPEFRelocSmByImport = 0x30, /* Binary: 011_0000, group is "RelocSmIndex"*/ |
|
kPEFRelocSmSetSectC = 0x31, /* Binary: 011_0001*/ |
|
kPEFRelocSmSetSectD = 0x32, /* Binary: 011_0010*/ |
|
kPEFRelocSmBySection = 0x33, /* Binary: 011_0011*/ |
|
kPEFRelocIncrPosition = 0x40, /* Binary: 100_0xxx*/ |
|
kPEFRelocSmRepeat = 0x48, /* Binary: 100_1xxx*/ |
|
kPEFRelocSetPosition = 0x50, /* Binary: 101_000x*/ |
|
kPEFRelocLgByImport = 0x52, /* Binary: 101_001x*/ |
|
kPEFRelocLgRepeat = 0x58, /* Binary: 101_100x*/ |
|
kPEFRelocLgSetOrBySection = 0x5A, /* Binary: 101_101x*/ |
|
kPEFRelocUndefinedOpcode = 0xFF /* Used in masking table for all undefined values.*/ |
|
}; |
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------- */ |
|
/* The RelocLgSetOrBySection instruction has an additional 4 bits of subopcode */ |
|
/* beyond the 7 used by the dispatch table. To be precise it has 6 plus 4 but */ |
|
/* the dispatch table ignores the 7th bit, so the subdispatch is on all 4 extra */ |
|
/* subopcode bits. */ |
|
|
|
enum { |
|
kPEFRelocLgBySectionSubopcode = 0x00, /* Binary: 0000*/ |
|
kPEFRelocLgSetSectCSubopcode = 0x01, /* Binary: 0001*/ |
|
kPEFRelocLgSetSectDSubopcode = 0x02 /* Binary: 0010*/ |
|
}; |
|
|
|
#define PEFRelocLgSetOrBySubopcode(chunk) (((chunk) >> 6) & 0x0F) |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The initial values for the opcode "masking" table. This has the enumeration values from */ |
|
/* above with appropriate replications for "don't care" bits. It is almost certainly shorter */ |
|
/* and faster to look up the masked value in a table than to use a branch tree. */ |
|
|
|
|
|
#define PEFMaskedBasicOpcodes \ |
|
\ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x00 .. 0x03 */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x04 .. 0x07 */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x08 .. 0x0B */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x0C .. 0x0F */ \ |
|
\ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x10 .. 0x13 */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x14 .. 0x17 */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x18 .. 0x1B */ \ |
|
kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, kPEFRelocBySectDWithSkip, /* 0x1C .. 0x1F */ \ |
|
\ |
|
kPEFRelocBySectC, kPEFRelocBySectD, kPEFRelocTVector12, kPEFRelocTVector8, /* 0x20 .. 0x23 */ \ |
|
kPEFRelocVTable8, kPEFRelocImportRun, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x24 .. 0x27 */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x28 .. 0x2B */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x2C .. 0x2F */ \ |
|
\ |
|
kPEFRelocSmByImport, kPEFRelocSmSetSectC, kPEFRelocSmSetSectD, kPEFRelocSmBySection, /* 0x30 .. 0x33 */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x34 .. 0x37 */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x38 .. 0x3B */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x3C .. 0x3F */ \ |
|
\ |
|
kPEFRelocIncrPosition, kPEFRelocIncrPosition, kPEFRelocIncrPosition, kPEFRelocIncrPosition, /* 0x40 .. 0x43 */ \ |
|
kPEFRelocIncrPosition, kPEFRelocIncrPosition, kPEFRelocIncrPosition, kPEFRelocIncrPosition, /* 0x44 .. 0x47 */ \ |
|
\ |
|
kPEFRelocSmRepeat, kPEFRelocSmRepeat, kPEFRelocSmRepeat, kPEFRelocSmRepeat, /* 0x48 .. 0x4B */ \ |
|
kPEFRelocSmRepeat, kPEFRelocSmRepeat, kPEFRelocSmRepeat, kPEFRelocSmRepeat, /* 0x4C .. 0x4F */ \ |
|
\ |
|
kPEFRelocSetPosition, kPEFRelocSetPosition, kPEFRelocLgByImport, kPEFRelocLgByImport, /* 0x50 .. 0x53 */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x54 .. 0x57 */ \ |
|
\ |
|
kPEFRelocLgRepeat, kPEFRelocLgRepeat, kPEFRelocLgSetOrBySection, kPEFRelocLgSetOrBySection, /* 0x58 .. 0x5B */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x5C .. 0x5F */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x60 .. 0x63 */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x64 .. 0x67 */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x68 .. 0x6B */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x6C .. 0x6F */ \ |
|
\ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x70 .. 0x73 */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x74 .. 0x77 */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, /* 0x78 .. 0x7B */ \ |
|
kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode, kPEFRelocUndefinedOpcode /* 0x7C .. 0x7F */ |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocBySectDWithSkip Instruction (DDAT) */ |
|
/* --------------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocBySectDWithSkip" (DDAT) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 1 */ |
|
/* 0 1 2 9 0 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |0 0| skip count | rel count | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | 2 |<-- 8 bits --->|<-- 6 --->| */ |
|
/* */ |
|
/* ! Note that the stored skip count and reloc count are the actual values! */ |
|
|
|
enum { |
|
kPEFRelocWithSkipMaxSkipCount = 255, |
|
kPEFRelocWithSkipMaxRelocCount = 63 |
|
}; |
|
|
|
#define PEFRelocWithSkipSkipCount(chunk) PEFRelocField ( (chunk), 2, 8 ) |
|
#define PEFRelocWithSkipRelocCount(chunk) PEFRelocField ( (chunk), 10, 6 ) |
|
|
|
#define PEFRelocComposeWithSkip(skipCount,relocCount) \ |
|
( 0x0000 | (((UInt16)(skipCount)) << 6) | ((UInt16)(relocCount)) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocRun Group (CODE, DATA, DESC, DSC2, VTBL, SYMR) */ |
|
/* --------------------------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocRun" group includes the "RelocBySectC" (CODE), "RelocBySectD" (DATA), */ |
|
/* "RelocTVector12" (DESC), "RelocTVector8" (DSC2), "RelocVTable8" (VTBL), and */ |
|
/* "RelocImportRun" (SYMR) instructions. This group has the following bit field layout. */ |
|
/* */ |
|
/* 1 */ |
|
/* 0 2 3 6 7 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |0 1 0| subop.| run length | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | 3 |<- 4 ->|<-- 9 bits ----->| */ |
|
/* */ |
|
/* ! Note that the stored run length is the actual value minus 1, but the macros deal with the */ |
|
/* ! actual value! */ |
|
|
|
enum { |
|
kPEFRelocRunMaxRunLength = 512 |
|
}; |
|
|
|
#define PEFRelocRunSubopcode(chunk) PEFRelocField ( (chunk), 3, 4 ) |
|
#define PEFRelocRunRunLength(chunk) (PEFRelocField ( (chunk), 7, 9 ) + 1) |
|
|
|
#define PEFRelocComposeRun(subopcode,runLength) \ |
|
( 0x4000 | (((UInt16)(subopcode)) << 9) | ((UInt16)((runLength)-1)) ) |
|
|
|
#define PEFRelocComposeBySectC(runLength) PEFRelocComposeRun ( 0, (runLength) ) |
|
#define PEFRelocComposeBySectD(runLength) PEFRelocComposeRun ( 1, (runLength) ) |
|
#define PEFRelocComposeTVector12(runLength) PEFRelocComposeRun ( 2, (runLength) ) |
|
#define PEFRelocComposeTVector8(runLength) PEFRelocComposeRun ( 3, (runLength) ) |
|
#define PEFRelocComposeVTable8(runLength) PEFRelocComposeRun ( 4, (runLength) ) |
|
#define PEFRelocComposeImportRun(runLength) PEFRelocComposeRun ( 5, (runLength) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocSmIndex Group (SYMB, CDIS, DTIS, SECN) */ |
|
/* ------------------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocSmIndex" group includes the "RelocSmByImport" (SYMB), "RelocSmSetSectC" (CDIS), */ |
|
/* "RelocSmSetSectD" (DTIS) and "RelocSmBySection" (SECN) instructions. This group has the */ |
|
/* following bit field layout. */ |
|
/* */ |
|
/* 1 */ |
|
/* 0 2 3 6 7 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |0 1 1| subop.| index | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* | 3 |<- 4 ->|<-- 9 bits ----->| */ |
|
/* */ |
|
/* ! Note that the stored index is the actual value! */ |
|
|
|
enum { |
|
kPEFRelocSmIndexMaxIndex = 511 |
|
}; |
|
|
|
#define PEFRelocSmIndexSubopcode(chunk) PEFRelocField ( (chunk), 3, 4 ) |
|
#define PEFRelocSmIndexIndex(chunk) PEFRelocField ( (chunk), 7, 9 ) |
|
|
|
#define PEFRelocComposeSmIndex(subopcode,index) \ |
|
( 0x6000 | (((UInt16)(subopcode)) << 9) | ((UInt16)(index)) ) |
|
|
|
#define PEFRelocComposeSmByImport(index) PEFRelocComposeSmIndex ( 0, (index) ) |
|
#define PEFRelocComposeSmSetSectC(index) PEFRelocComposeSmIndex ( 1, (index) ) |
|
#define PEFRelocComposeSmSetSectD(index) PEFRelocComposeSmIndex ( 2, (index) ) |
|
#define PEFRelocComposeSmBySection(index) PEFRelocComposeSmIndex ( 3, (index) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocIncrPosition Instruction (DELT) */ |
|
/* ------------------------------------ */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocIncrPosition" (DELT) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 */ |
|
/* 0 3 4 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 0 0| offset | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<- 4 ->|<-- 12 bits ---------->| */ |
|
/* */ |
|
/* ! Note that the stored offset is the actual value minus 1, but the macros deal with the */ |
|
/* ! actual value! */ |
|
|
|
enum { |
|
kPEFRelocIncrPositionMaxOffset = 4096 |
|
}; |
|
|
|
#define PEFRelocIncrPositionOffset(chunk) (PEFRelocField ( (chunk), 4, 12 ) + 1) |
|
|
|
#define PEFRelocComposeIncrPosition(offset) \ |
|
( 0x8000 | ((UInt16)((offset)-1)) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocSmRepeat Instruction (RPT) */ |
|
/* ------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocSmRepeat" (RPT) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 */ |
|
/* 0 3 4 7 8 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 0 1| chnks | repeat count | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<- 4 ->|<- 4 ->|<-- 8 bits --->| */ |
|
/* */ |
|
/* ! Note that the stored chunk count and repeat count are the actual values minus 1, but the */ |
|
/* ! macros deal with the actual values! */ |
|
|
|
enum { |
|
kPEFRelocSmRepeatMaxChunkCount = 16, |
|
kPEFRelocSmRepeatMaxRepeatCount = 256 |
|
}; |
|
|
|
#define PEFRelocSmRepeatChunkCount(chunk) (PEFRelocField ( (chunk), 4, 4 ) + 1) |
|
#define PEFRelocSmRepeatRepeatCount(chunk) (PEFRelocField ( (chunk), 8, 8 ) + 1) |
|
|
|
#define PEFRelocComposeSmRepeat(chunkCount,repeatCount) \ |
|
( 0x9000 | ((((UInt16)(chunkCount))-1) << 8) | (((UInt16)(repeatCount))-1) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocSetPosition Instruction (LABS) */ |
|
/* ----------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocSetPosition" (LABS) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 1 */ |
|
/* 0 5 6 5 0 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 1 0 0 0| offset (high) | | offset (low) | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 6 ---->|<-- 10 bits ------>| |<-- 16 bits ------------------>| */ |
|
/* */ |
|
/* ! Note that the stored offset is the actual value! */ |
|
|
|
enum { |
|
kPEFRelocSetPosMaxOffset = 0x03FFFFFF /* 67,108,863*/ |
|
}; |
|
|
|
#define PEFRelocSetPosOffsetHigh(chunk) PEFRelocField ( (chunk), 6, 10 ) |
|
|
|
#define PEFRelocSetPosFullOffset(firstChunk,secondChunk) \ |
|
( ((((UInt32)(firstChunk)) & 0x03FF) << 16) | ((UInt32)(secondChunk)) ) |
|
|
|
#define PEFRelocComposeSetPosition_1st(fullOffset) \ |
|
( 0xA000 | ((UInt16) (((UInt32)(fullOffset)) >> 16) ) ) |
|
#define PEFRelocComposeSetPosition_2nd(fullOffset) \ |
|
( (UInt16) ((UInt32)(fullOffset) & 0xFFFF) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocLgByImport Instruction (LSYM) */ |
|
/* ---------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocLgByImport" (LSYM) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 1 */ |
|
/* 0 5 6 5 0 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 1 0 0 1| index (high) | | index (low) | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 6 ---->|<-- 10 bits ------>| |<-- 16 bits ------------------>| */ |
|
/* */ |
|
/* ! Note that the stored offset is the actual value! */ |
|
|
|
enum { |
|
kPEFRelocLgByImportMaxIndex = 0x03FFFFFF /* 67,108,863*/ |
|
}; |
|
|
|
#define PEFRelocLgByImportIndexHigh(chunk) PEFRelocField ( (chunk), 6, 10 ) |
|
|
|
#define PEFRelocLgByImportFullIndex(firstChunk,secondChunk) \ |
|
( ((((UInt32)(firstChunk)) & 0x03FF) << 16) | ((UInt32)(secondChunk)) ) |
|
|
|
#define PEFRelocComposeLgByImport_1st(fullIndex) \ |
|
( 0xA400 | ((UInt16) (((UInt32)(fullIndex)) >> 16) ) ) |
|
#define PEFRelocComposeLgByImport_2nd(fullIndex) \ |
|
( (UInt16) ((UInt32)(fullIndex) & 0xFFFF) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocLgRepeat Instruction (LRPT) */ |
|
/* -------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocLgRepeat" (LRPT) instruction has the following bit field layout. */ |
|
/* */ |
|
/* 1 1 1 */ |
|
/* 0 5 6 9 0 5 0 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 1 1 0 0| chnks | rpt (high)| | repeat count (low) | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 6 --->|<- 4 ->|<-- 6 --->| |<-- 16 bits ------------------>| */ |
|
/* */ |
|
/* ! Note that the stored chunk count is the actual value minus 1, but the macros deal with */ |
|
/* ! the actual value! The stored repeat count is the actual value! */ |
|
|
|
enum { |
|
kPEFRelocLgRepeatMaxChunkCount = 16, |
|
kPEFRelocLgRepeatMaxRepeatCount = 0x003FFFFF /* 4,194,303*/ |
|
}; |
|
|
|
#define PEFRelocLgRepeatChunkCount(chunk) (PEFRelocField ( (chunk), 6, 4 ) + 1) |
|
#define PEFRelocLgRepeatRepeatCountHigh(chunk) PEFRelocField ( (chunk), 10, 6 ) |
|
|
|
#define PEFRelocLgRepeatFullRepeatCount(firstChunk,secondChunk) \ |
|
( ((((UInt32)(firstChunk)) & 0x003F) << 16) | ((UInt32)(secondChunk)) ) |
|
|
|
#define PEFRelocComposeLgRepeat_1st(chunkCount,fullRepeatCount) \ |
|
( 0xB000 | ((((UInt16)(chunkCount))-1) << 6) | ((UInt16) (((UInt32)(fullRepeatCount)) >>16 ) ) ) |
|
#define PEFRelocComposeLgRepeat_2nd(chunkCount,fullRepeatCount) \ |
|
( (UInt16) ((UInt32)(fullRepeatCount) & 0xFFFF) ) |
|
|
|
|
|
|
|
/* =========================================================================================== */ |
|
/* RelocLgSetOrBySection Group (LSEC) */ |
|
/* ---------------------------------- */ |
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------------------------- */ |
|
/* The "RelocLgSetOrBySection" (LSEC) instruction is a group including the "RelocLgBySection", */ |
|
/* "RelocLgSetSectC" and "RelocLgSetSectD" instructions. This group has the following bit */ |
|
/* field layout. */ |
|
/* */ |
|
/* 1 1 1 */ |
|
/* 0 5 6 9 0 5 0 5 */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |1 0 1 1 0 1| subop | idx (high)| | index (low) | */ |
|
/* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ |
|
/* |<-- 6 --->|<- 4 ->|<-- 6 --->| |<-- 16 bits ------------------>| */ |
|
/* */ |
|
/* ! Note that the stored index is the actual value! */ |
|
|
|
enum { |
|
kPEFRelocLgSetOrBySectionMaxIndex = 0x003FFFFF /* 4,194,303*/ |
|
}; |
|
|
|
#define PEFRelocLgSetOrBySectionSubopcode(chunk) PEFRelocField ( (chunk), 6, 4 ) |
|
#define PEFRelocLgSetOrBySectionIndexHigh(chunk) PEFRelocField ( (chunk), 10, 6 ) |
|
|
|
#define PEFRelocLgSetOrBySectionFullIndex(firstChunk,secondChunk) \ |
|
( ((((UInt32)(firstChunk)) & 0x003F) << 16) | ((UInt32)(secondChunk)) ) |
|
|
|
#define PEFRelocComposeLgSetOrBySection_1st(subopcode,fullIndex) \ |
|
( 0xB400 | (((UInt16)(subopcode)) << 6) | ((UInt16) (((UInt32)(fullIndex)) >> 16) ) ) |
|
#define PEFRelocComposeLgSetOrBySection_2nd(subopcode,fullIndex) \ |
|
( (UInt16) ((UInt32)(fullIndex) & 0xFFFF) ) |
|
|
|
#define PEFRelocComposeLgBySection(fullIndex) PEFRelocComposeLgSetOrBySection ( 0x00, (fullIndex) ) |
|
#define PEFRelocComposeLgSetSectC(fullIndex) PEFRelocComposeLgSetOrBySection ( 0x01, (fullIndex) ) |
|
#define PEFRelocComposeLgSetSectD(fullIndex) PEFRelocComposeLgSetOrBySection ( 0x02, (fullIndex) ) |
|
|
|
|
|
|
|
#if PRAGMA_STRUCT_ALIGN |
|
#pragma options align=reset |
|
#elif PRAGMA_STRUCT_PACKPUSH |
|
#pragma pack(pop) |
|
#elif PRAGMA_STRUCT_PACK |
|
#pragma pack() |
|
#endif |
|
|
|
#ifdef PRAGMA_IMPORT_OFF |
|
#pragma import off |
|
#elif PRAGMA_IMPORT |
|
#pragma import reset |
|
#endif |
|
|
|
|
|
#endif /* __PEFBINARYFORMAT__ */ |
|
|
|
|