/*
     File:       CarbonCore/PEFBinaryFormat.h
 
     Contains:   PEF Types and Macros
                 The contents of this header file are deprecated.
 
     Copyright:  © 1993-2011 by Apple Inc. All rights reserved.
*/


#ifndef __PEFBINARYFORMAT__
#define __PEFBINARYFORMAT__

#ifndef __MACTYPES__
#include <MacTypes.h>
#endif



#include <Availability.h>
#include <os/availability.h>

#if PRAGMA_ONCE
#pragma once
#endif

#pragma pack(push, 2)



/* -------------------------------------------------------------------------------------------- */
/* 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                      = 'Joy!', /* For non-Apple compilers: 0x4A6F7921.*/
  kPEFTag2                      = 'peff', /* For non-Apple compilers: 0x70656666.*/
  kPEFVersion                   = 0x00000001
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));


enum {
  kPEFFirstSectionHeaderOffset  = sizeof(PEFContainerHeader)
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));


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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* 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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));


enum {
  kPEFPkDataOpcodeShift         = 5,
  kPEFPkDataCount5Mask          = 0x1F,
  kPEFPkDataMaxCount5           = 31,
  kPEFPkDataVCountShift         = 7,
  kPEFPkDataVCountMask          = 0x7F,
  kPEFPkDataVCountEndMask       = 0x80
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));


#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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* 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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* 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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* 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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));



/* ---------------------------------------------------------------------------- */
/* 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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

#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) )



/* ======================================================================================== */
/* ======================================================================================== */



/* ======================================================================================== */
/* Vector Library Declarations */
/* =========================== */



/* -------------------------------------------------------------------------------------------- */
/* Mac OS X has special "vector" and "bridge" libraries to allow CFM managed clients to import  */
/* from the dyld managed implementation libraries.  The vector libraries are typically embedded */
/* within their respective implementation libraries.  Even if standalone, the vector libraries  */
/* are themselves normal dyld managed libraries.  The vector libraries contain an export symbol */
/* table and pointers to the actual implementations.  For functions, these pointers serve as    */
/* the PMacCG TVectors.  Because the dyld libraries are not part of the CFM search, we need a   */
/* separate library for CFM to find that then indicates where the vector library is.  These are */
/* the bridge libraries.  They are tiny, just the container header and container strings parts. */
/*                                                                                              */
/* Since the vector library is embedded in a Mach-O dylib, we use dyld services to obtain the   */
/* base address for the main portion and the exported symbol portion.  The binding pointers are */
/* found through offsets in the exported symbol records.                                        */
/*                                                                                              */
/*      +-----------------------------------+           <-- containerOrigin ------------+       */
/*      |       Container Header            |   76 bytes                                |       */
/*      |-----------------------------------|           <-- + containerStringsOffset ---|       */
/*      |       Container Strings           |                                           |       */
/*      |-----------------------------------|           <-- + exportHashOffset ---------+       */
/*      |       Export Hash Slot 0          |   4 bytes each                            |       */
/*      |...................................|                                           |       */
/*      |           - - -                   |                                           |       */
/*      |...................................|                                           |       */
/*      |       Export Hash Slot h-1        |                                           |       */
/*      |-----------------------------------|           <-- + exportKeyOffset ----------+       */
/*      |       Export Symbol Key 0         |   4 bytes each                            |       */
/*      |...................................|   Order must match the exported symbols   |       */
/*      |           - - -                   |                                           |       */
/*      |...................................|                                           |       */
/*      |       Export Symbol Key e-1       |                                           |       */
/*      |-----------------------------------|           <-- + exportNamesOffset --------+       */
/*      |       Export Names                |                                           |       */
/*      |-----------------------------------|                                           |       */
/*                                              (Disjoint parts)                        |       */
/*      |-----------------------------------|           <-- + exportSymbolOffset -------+       */
/*      |       Export Symbol 0             |   8 bytes each                                    */
/*      |...................................|   Order must match the export keys                */
/*      |           - - -                   |                                                   */
/*      |...................................|                                                   */
/*      |       Export Symbol e-1           |                                                   */
/*      +-----------------------------------+                                                   */
/*                                              (Disjoint parts)                                */
/*      |-----------------------------------|                                                   */
/*      |       Binding Pointer 0           |   4 bytes each                                    */
/*      |-----------------------------------|   Possibly disjoint, order does not matter        */
/*      |           - - -                   |                                                   */
/*      |-----------------------------------|                                                   */
/*      |       Binding Pointer e-1         |                                                   */
/*      +-----------------------------------+                                                   */

struct XLibContainerHeader {

                                              /* Structural description fields:*/

  OSType              tag1;                   /* Must contain 'ðMac'.*/
  OSType              tag2;                   /* Must contain 'vLib' or 'bLib'.*/
  UInt32              currentFormat;          /* The version of XLib types used to create this container.*/
  UInt32              containerStringsOffset; /* Container offset of the container string table.*/
  UInt32              exportHashOffset;       /* Offset of the export hash table.*/
  UInt32              exportKeyOffset;        /* Offset of the export key table.*/
  UInt32              exportSymbolOffset;     /* Offset of the export symbol table.*/
  UInt32              exportNamesOffset;      /* Offset of the export names.*/
  UInt32              exportHashTablePower;   /* Export hash table size as log 2.  (Log2('h'))*/
  UInt32              exportedSymbolCount;    /* Number of exported symbols.  ('e')*/

                                              /* Fragment description fields:*/

  UInt32              fragNameOffset;         /* The offset of the fragment name in the container string table.*/
  UInt32              fragNameLength;         /* The length of the fragment name in the container string table.*/
  UInt32              dylibPathOffset;        /* The offset of the dyld "install name" in the container string table.*/
  UInt32              dylibPathLength;        /* The length of the dyld "install name" in the container string table.*/
  OSType              cpuFamily;              /* The ISA for code sections.  Constants in CodeFragments.h.*/
  OSType              cpuModel;               /* Specific CPU model if applicable.*/
  UInt32              dateTimeStamp;          /* Mac format creation stamp.*/
  UInt32              currentVersion;         /* Current version number for the code fragment.*/
  UInt32              oldDefVersion;          /* Old definition version number for the code fragment.*/
  UInt32              oldImpVersion;          /* Old implementation version number for the code fragment.*/

};
typedef struct XLibContainerHeader      XLibContainerHeader;
enum {
  kXLibTag1                     = (int)0xF04D6163/*'ðMac' */, /* For non-Apple compilers: 0xF04D6163.*/
  kVLibTag2                     = 'VLib', /* For non-Apple compilers: 0x564C6962.*/
  kBLibTag2                     = 'BLib', /* For non-Apple compilers: 0x424C6962.*/
  kXLibVersion                  = 0x00000001
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));



typedef PEFExportedSymbolHashSlot       XLibExportedSymbolHashSlot;
typedef PEFExportedSymbolKey            XLibExportedSymbolKey;
struct XLibExportedSymbol {
  UInt32              classAndName;           /* A combination of class and name offset.*/
  UInt32              bpOffset;               /* Container offset of the export's dyld binding pointer.*/
};
typedef struct XLibExportedSymbol       XLibExportedSymbol;


/* =========================================================================================== */






#ifndef IncludePEF2Declarations
#define IncludePEF2Declarations 0
#endif  /* !defined(IncludePEF2Declarations) */

#if IncludePEF2Declarations


/* ======================================================================================== */
/* ======================================================================================== */


/* ======================================================================================== */
/* PEF2 Declarations */
/* ================= */



/* -------------------------------------------------------------------------------------------- */
/* PEF2 is a follow-on to the original PEF, incorporating changes that would break backward     */
/* compatibility.  The primary motivations for PEF2 are to incorporate new features cleanly, to */
/* relax some physical limitations, and to provide a more explicit path for future growth.      */
/*                                                                                              */
/* PEF2 is very similar to PEF, it is possible for any PEF container to be mechanically         */
/* converted to PEF2.  The converse is not necessarily true, containers that use new features   */
/* of PEF2 might not be convertable to PEF.                                                     */
/*                                                                                              */
/* One difference from PEF is that PEF2 has no implicit ordering, e.g. the section headers do   */
/* not necessarily immediately follow the container header.  Explicit offsets and lengths are   */
/* provided for all portions of the container so that tools can continue to parse PEF2 as new   */
/* versions of it are produced in the future.  The following overall layout is suggested for    */
/* locality of reference in typical usage with a packed data image:                             */
/*                                                                                              */
/*          +-----------------------------------+                                               */
/*          |       Container Header            |                                               */
/*          +-----------------------------------+                                               */
/*          |       Section 0 header            |                                               */
/*          |...................................|                                               */
/*          |           - - - -                 |                                               */
/*          |...................................|                                               */
/*          |       Section n-1 header          |                                               */
/*          +-----------------------------------+                                               */
/*          |       Container String Table      |                                               */
/*          +-----------------------------------+                                               */
/*          |       Loader section contents     |                                               */
/*          +-----------------------------------+                                               */
/*          |       Packed data contents        |                                               */
/*          +-----------------------------------+                                               */
/*          |       Code section contents       |                                               */
/*          +-----------------------------------+                                               */
/*                                                                                              */
/* If unpacked data is used for prebinding with copy-on-write mapping, the unpacked data should */
/* follow the code section.                                                                     */
/*                                                                                              */
/* Note that the rule regarding instantiated sections preceeding noninstantiated sections only  */
/* applies to the section headers, not the section contents.  Thus it is perfectly fine for the */
/* loader section contents to be first.                                                         */
/*                                                                                              */
/* The container string table holds the name of the fragment and the names of the sections.     */
/* The first 4 bytes of the container string table must be zero and always present.  An offset  */
/* of zero into the container string table is considered a null name.  Actual names are stored  */
/* as a PEF-style 32 bit hashword followed by the text of the name.  The encoding of the text   */
/* is given by the stringEncoding field of the container header.  The hashword is computed from */
/* the encoded name as a string of bytes.  The length in the hashword is the number of bytes in */
/* the encoded name, not the number of logical characters.                                      */



/* =========================================================================================== */
/* Container Header */
/* ================ */



struct PEF2ContainerHeader {
                                              /* Structural fields:*/
  OSType              tag1;                   /* Must contain 'Joy!'.*/
  OSType              tag2;                   /* Must contain 'PEF '.*/
  UInt32              currentFormat;          /* The version of PEF2 used to create this container.*/
  UInt32              oldestFormat;           /* Oldest compatible container handler.*/
  UInt32              containerHeaderSize;    /* The size of this header in bytes.*/
  UInt32              containerLength;        /* The total length of the container in bytes.*/
  UInt32              checksum;               /* A checksum for the entire container.*/
  UInt32              sectionHeadersOffset;   /* Container offset of the first section header.*/
  UInt32              sectionHeaderSize;      /* The size in bytes of each section header.*/
  UInt32              totalSectionCount;      /* Total number of section headers.*/
  UInt32              instSectionCount;       /* Number of instantiated sections.*/
  UInt32              loaderSectionIndex;     /* Index of the section containing runtime loader tables.*/
  UInt32              containerStringsOffset; /* Container offset of the container string table.*/
  UInt32              containerStringsLength; /* Length in bytes of the container string table.*/
  UInt32              options;                /* Array of 32 option bits.*/
  UInt32              preferredAddress;       /* Preferred container address, 0xFFFFFFFF indicates no preference.*/
  UInt8               alignment;              /* Required container alignment as LOG 2.*/
  UInt8               stringEncoding;         /* The encoding for all strings in the container.*/
  UInt16              reservedA;              /* Reserved, must be written as zero.*/
  UInt32              reservedB;              /* Reserved, must be written as zero.*/
  UInt32              reservedC;              /* Reserved, must be written as zero.*/
                                              /* Fragment description fields:*/
  UInt32              nameOffset;             /* The offset of the name in the container string table.*/
  OSType              architecture;           /* The ISA for code sections.  Constants in CodeFragments.h.*/
  UInt32              dateTimeStamp;          /* Macintosh format creation/modification stamp.*/
  UInt32              currentVersion;         /* Current version number for the code fragment.*/
  UInt32              oldDefVersion;          /* Old definition version number for the code fragment.*/
  UInt32              oldImpVersion;          /* Old implementation version number for the code fragment.*/
  UInt32              reservedD;              /* Reserved, must be written as zero.*/
  UInt32              reservedE;              /* Reserved, must be written as zero.*/
};
typedef struct PEF2ContainerHeader      PEF2ContainerHeader;
enum {
  kPEF2Tag1                     = kPEFTag1,
  kPEF2Tag2                     = 'PEF ', /* For non-Apple compilers: 0x50656620.*/
  kPEF2CurrentFormat            = 0x00000002, /* ! There is no version 0 or 1.*/
  kPEF2OldestHandler            = 0x00000002
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

enum {
                                        /* Values for the options field.*/
  kPEF2IsReexportLibraryMask    = 0x00000001, /* This fragment does nothing but reexport imports.*/
  kPEF2IsGlueLibraryMask        = 0x00000002 /* A special form of import library that provides a glue layer.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

enum {
                                        /* Values for the stringEncoding field.*/
  kPEF2StringsAreASCII          = 0,
  kPEF2StringsAreUnicode        = 1
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* Section Headers */
/* =============== */



struct PEF2SectionHeader {
  UInt32              nameOffset;             /* Offset of the name within the container string table.*/
  UInt32              presumedAddress;        /* Presumed 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 within the container.*/
  UInt32              options;                /* Array of 32 option bits.*/
  UInt8               shareKind;              /* Sharing level, if a writeable section.*/
  UInt8               alignment;              /* Required alignment, expressed as log 2.*/
  UInt16              reservedA;              /* Reserved, must be written as zero.*/
  UInt32              reservedB;              /* Reserved, must be written as zero.*/
  UInt32              reservedC;              /* Reserved, must be written as zero.*/
};
typedef struct PEF2SectionHeader        PEF2SectionHeader;
enum {
                                        /* Masks for instantiated section options.*/
                                        /* Bits that define the preparation and usage of the section's contents.*/
  kPEF2SectionHasCodeMask       = 0x00000001, /* Affects cache flushing operations.*/
  kPEF2SectionIsWriteableMask   = 0x00000002, /* Affects MMU access.*/
  kPEF2SectionHasRelocationsMask = 0x00000004, /* The section has runtime relocations.*/
  kPEF2SectionContentsArePackedMask = 0x00000100, /* The raw data is compressed.*/
  kPEF2SectionNoZeroFillMask    = 0x00000200, /* "Uninit" part is not zero filled.*/
  kPEF2SectionResidentMask      = 0x00000400, /* The section should be RAM resident.*/
                                        /* Bits that describe higher level semantics.*/
  kPEF2SectionFollowsPriorMask  = 0x00010000, /* Raw data is related to prior section.*/
  kPEF2SectionPrecedesNextMask  = 0x00020000, /* Raw data is related to next section.*/
  kPEF2SectionHasLoaderTablesMask = 0x01000000,
  kPEF2SectionHasDebugTablesMask = 0x02000000,
  kPEF2SectionHasExceptionTablesMask = 0x04000000,
  kPEF2SectionHasTracebackTablesMask = 0x08000000
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));

enum {
                                        /* Values for the shareKind field.*/
  kPEF2PrivateShare             = 0,    /* Shared only within a "private" closure.*/
  kPEF2ProcessShare             = 1,    /* Shared within a single process.*/
  kPEF2GlobalShare              = 4,    /* Shared across the entire system.*/
  kPEF2ProtectedShare           = 5     /* Readable across the entire system, writeable only to privileged code.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* Loader Section */
/* ============== */



/* -------------------------------------------------------------------------------------------- */
/* The PEF2 loader section is very similar to that of PEF.  The following overall layout is     */
/* not required, but suggested for typical locality of reference.  The loader header contains   */
/* explicit offsets and sizes for each of the subsections.                                      */
/*                                                                                              */
/*          +-----------------------------------+                                               */
/*          |       Loader Info Header          |                                               */
/*          |-----------------------------------|                                               */
/*          |       Imported Library 0          |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Imported Library l-1        |                                               */
/*          |-----------------------------------|                                               */
/*          |       Imported Symbol 0           |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Imported Symbol i-1         |                                               */
/*          |-----------------------------------|                                               */
/*          |       Loader Name Table           |                                               */
/*          |-----------------------------------|                                               */
/*          |       Export Hash Slot 0          |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Export Hash Slot h-1        |                                               */
/*          |-----------------------------------|                                               */
/*          |       Exported Symbol Key 0       |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Exported Symbol Key e-1     |                                               */
/*          |-----------------------------------|                                               */
/*          |       Exported Symbol 0           |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Exported Symbol e-1         |                                               */
/*          |-----------------------------------|                                               */
/*          |       Relocation Header 0         |                                               */
/*          |...................................|                                               */
/*          |           - - -                   |                                               */
/*          |...................................|                                               */
/*          |       Relocation Header r-1       |                                               */
/*          |-----------------------------------|                                               */
/*          |       Relocation Instructions     |                                               */
/*          +-----------------------------------+                                               */



struct PEF2LoaderInfoHeader {
  UInt32              headerSize;             /* Size in bytes of the loader info header.*/
  UInt32              options;                /* An array of 32 option bits.*/
  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.*/
  SInt32              notifySection;          /* Section containing the notification routine's TVector, -1 => none.*/
  UInt32              notifyOffset;           /* Offset of the notification routine's TVector.*/
  UInt32              importedLibrariesOffset; /* Offset of the imported library table.*/
  UInt32              importedLibrarySize;    /* The size in bytes of an imported library entry.*/
  UInt32              importedLibraryCount;   /* Number of imported libraries. ('l')*/
  UInt32              importedSymbolsOffset;  /* Offset of the imported symbol table.*/
  UInt32              importedSymbolSize;     /* The size in bytes of an imported symbol entry.*/
  UInt32              totalImportedSymbolCount; /* Total number of imported symbols.  ('s')*/
  UInt32              loaderNamesOffset;      /* Offset of the loader name table.*/
  UInt32              loaderNamesLength;      /* Total number of bytes in the loader name table.*/
  UInt32              exportHashTableOffset;  /* Offset of the export hash slot table.*/
  UInt8               exportHashTablePower;   /* Hash slot count as log 2.*/
  UInt8               reservedA;              /* Reserved, must be zero.*/
  UInt16              reservedB;              /* Reserved, must be zero.*/
  UInt32              exportedKeysOffset;     /* Offset of the exported symbol key table.*/
  UInt32              exportedSymbolsOffset;  /* Offset of the exported symbol table.*/
  UInt32              exportedSymbolSize;     /* The size in bytes of an exported symbol entry.*/
  UInt32              exportedSymbolCount;    /* Number of exported symbols. ('e')*/
  UInt32              relocHeadersOffset;     /* Offset of the relocation headers.*/
  UInt32              relocHeaderCount;       /* Number of sections with relocations.*/
  UInt32              relocInstrOffset;       /* Offset of the relocation instructions.*/
  UInt32              relocInstrLength;       /* Total number of bytes of relocation instructions.*/
  UInt32              reservedC;              /* Reserved, must be zero.*/
  UInt32              reservedD;              /* Reserved, must be zero.*/
};
typedef struct PEF2LoaderInfoHeader     PEF2LoaderInfoHeader;
enum {
                                        /* Masks for the option bits.*/
  kPEF2LdrInfoLargeImpSymMask   = 0x00000001, /* Selects large imported symbol entries.*/
  kPEF2LdrInfoLargeExpSymMask   = 0x00000002, /* Selects large exported symbol entries.*/
  kPEF2LdrInfoLargeExpHashMask  = 0x00000004 /* Selects large export hash table entries.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));




/* =========================================================================================== */
/* Imports and Exports */
/* ------------------- */



/* -------------------------------------------------------------------------------------------- */
/* Imports and exports in PEF2 have both small and large representations.  The small form is    */
/* identical to original PEF.  The large form removes count limitations by having full 32 bit   */
/* offsets.  The import and export name tables have the same representation as the container    */
/* string table, four bytes of zero at the start followed by pairs of 32 bit hashwords and      */
/* the names in the appropriate encoding.                                                       */



struct PEF2ImportedLibrary {
  UInt32              nameOffset;             /* Imported name 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.*/
  UInt32              options;                /* Option bits for this library.*/
  UInt32              reservedA;              /* Reserved, must be zero.*/
};
typedef struct PEF2ImportedLibrary      PEF2ImportedLibrary;
enum {
                                        /* Bits for the PEF2ImportedLibrary options field.*/
  kPEF2WeakImportLibMask        = kPEFWeakImportLibMask, /* The imported library is allowed to be missing.*/
  kPEF2InitLibBeforeMask        = kPEFInitLibBeforeMask /* The imported library must be initialized first.*/
} API_DEPRECATED( "Deprecated", macos(10.0,10.5));



typedef PEFImportedSymbol               PEF2SmImportedSymbol;
#define PEF2ComposeSmImportedSymbol PEFComposeImportedSymbol

struct PEF2LgImportedSymbol {
  UInt8               symClass;
  UInt8               flags;
  UInt16              reservedA;
  UInt32              nameOffset;
  UInt32              versionPair;
  UInt32              reservedB;
};
typedef struct PEF2LgImportedSymbol     PEF2LgImportedSymbol;

typedef PEFExportedSymbolHashSlot       PEF2SmExportedSymbolHashSlot;
typedef PEFExportedSymbolKey            PEF2ExportedSymbolKey;
typedef PEFExportedSymbol               PEF2SmExportedSymbol;
#define PEF2ComposeSmExportedSymbol PEFComposeExportedSymbol

struct PEF2LgExportedSymbolHashSlot {
  UInt32              chainCount;
  UInt32              chainOffset;
};
typedef struct PEF2LgExportedSymbolHashSlot PEF2LgExportedSymbolHashSlot;
struct PEF2LgExportedSymbol {
  UInt8               symClass;
  UInt8               flags;
  UInt16              reservedA;
  UInt32              nameOffset;
  UInt32              versionPair;
  SInt32              sectionIndex;
  UInt32              sectionOffset;
  UInt32              reservedB;
};
typedef struct PEF2LgExportedSymbol     PEF2LgExportedSymbol;


/* =========================================================================================== */
/* Loader Relocations */
/* ================== */



/* -------------------------------------------------------------------------------------------- */
/* The relocation header differs slightly in PEF2.  The relocation instructions identical.      */



struct PEF2LoaderRelocationHeader {
  UInt32              sectionIndex;           /* Index of the section to be fixed up.*/
  UInt32              relocLength;            /* Number of bytes of relocation items.*/
  UInt32              firstRelocOffset;       /* Byte offset of first relocation instruction.*/
  UInt32              reservedA;              /* Reserved, must be zero.*/
};
typedef struct PEF2LoaderRelocationHeader PEF2LoaderRelocationHeader;


/* =========================================================================================== */


#endif  /* IncludePEF2Declarations */



#pragma pack(pop)


#endif /* __PEFBINARYFORMAT__ */

