开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
PEFBinaryFormat.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：69k
源码类别：

多媒体编程

开发平台：

Visual C++

PEFBinaryFormat.h：源码内容
  1. /*
  2.      File:       PEFBinaryFormat.h
  3.  
  4.      Contains:   PEF Types and Macros
  5.  
  6.      Version:    Technology: Master Interfaces
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1993-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  19. #ifndef __PEFBINARYFORMAT__
  20. #define __PEFBINARYFORMAT__
  22. #ifndef __MACTYPES__
  23. #include "MacTypes.h"
  24. #endif
  29. #if PRAGMA_ONCE
  30. #pragma once
  31. #endif
  33. #ifdef __cplusplus
  34. extern "C" {
  35. #endif
  37. #if PRAGMA_IMPORT
  38. #pragma import on
  39. #endif
  41. #if PRAGMA_STRUCT_ALIGN
  42.     #pragma options align=mac68k
  43. #elif PRAGMA_STRUCT_PACKPUSH
  44.     #pragma pack(push, 2)
  45. #elif PRAGMA_STRUCT_PACK
  46.     #pragma pack(2)
  47. #endif
  51. /* -------------------------------------------------------------------------------------------- */
  52. /* Almost all types are padded for natural alignment.  However the PEFExportedSymbol type is    */
  53. /* 10 bytes long, containing two 32 bit fields and one 16 bit field.  Arrays of it must be      */
  54. /* packed, so it requires "68K" alignment.  Setting this globally to 68K should also help       */
  55. /* ensure consistent treatment across compilers.                                                */
  59. /* ======================================================================================== */
  60. /* Overall Structure */
  61. /* ================= */
  65. /* -------------------------------------------------------------------------------------------- */
  66. /* This header contains a complete set of types and macros for dealing with the PEF executable  */
  67. /* format.  While some description is provided, this header is not meant as a primary source    */
  68. /* of documentation on PEF.  An excellent specification of PEF can be found in the Macintosh    */
  69. /* Runtime Architectures book.  This header is primarily a physical format description.  Thus   */
  70. /* it depends on as few other headers as possible and structure fields have obvious sizes.      */
  71. /*                                                                                              */
  72. /* The physical storage for a PEF executable is known as a "container".  This refers to just    */
  73. /* the executable itself, not the file etc.  E.g. if five DLLs are packaged in a single file's  */
  74. /* data fork, that one data fork has five containers within it.                                 */
  75. /*                                                                                              */
  76. /* A PEF container consists of an overall header, followed by one or more section headers,      */
  77. /* followed by the section name table, followed by the contents for the sections.  Some kinds   */
  78. /* of sections have specific internal representation.  The "loader" section is the most common  */
  79. /* of these special sections.  It contains information on the exports, imports, and runtime     */
  80. /* relocations required to prepare the executable.  PEF containers are self contained, all      */
  81. /* portions are located via relative offsets.                                                   */
  82. /*                                                                                              */
  83. /*                                                                                              */
  84. /*          +-------------------------------+                                                   */
  85. /*          |       Container Header        |   40 bytes                                        */
  86. /*          +-------------------------------+                                                   */
  87. /*          |       Section 0 header        |   28 bytes each                                   */
  88. /*          |...............................|                                                   */
  89. /*          |           - - - -             |                                                   */
  90. /*          |...............................|                                                   */
  91. /*          |       Section n-1 header      |                                                   */
  92. /*          +-------------------------------+                                                   */
  93. /*          |       Section Name Table      |                                                   */
  94. /*          +-------------------------------+                                                   */
  95. /*          |       Section x raw data      |                                                   */
  96. /*          +-------------------------------+                                                   */
  97. /*          |           - - - -             |                                                   */
  98. /*          +-------------------------------+                                                   */
  99. /*          |       Section y raw data      |                                                   */
  100. /*          +-------------------------------+                                                   */
  101. /*                                                                                              */
  102. /*                                                                                              */
  103. /* The sections are implicitly numbered from 0 to n according to the order of their headers.    */
  104. /* The headers of the instantiated sections must precede those of the non-instantiated          */
  105. /* sections.  The ordering of the raw data is independent of the section header ordering.       */
  106. /* Each section header contains the offset for that section's raw data.                         */
  110. /* =========================================================================================== */
  111. /* Container Header */
  112. /* ================ */
  117. struct PEFContainerHeader {
  118.     OSType                          tag1;                       /* Must contain 'Joy!'.*/
  119.     OSType                          tag2;                       /* Must contain 'peff'.  (Yes, with two 'f's.)*/
  120.     OSType                          architecture;               /* The ISA for code sections.  Constants in CodeFragments.h.*/
  121.     UInt32                          formatVersion;              /* The physical format version.*/
  122.     UInt32                          dateTimeStamp;              /* Macintosh format creation/modification stamp.*/
  123.     UInt32                          oldDefVersion;              /* Old definition version number for the code fragment.*/
  124.     UInt32                          oldImpVersion;              /* Old implementation version number for the code fragment.*/
  125.     UInt32                          currentVersion;             /* Current version number for the code fragment.*/
  126.     UInt16                          sectionCount;               /* Total number of section headers that follow.*/
  127.     UInt16                          instSectionCount;           /* Number of instantiated sections.*/
  128.     UInt32                          reservedA;                  /* Reserved, must be written as zero.*/
  129. };
  130. typedef struct PEFContainerHeader       PEFContainerHeader;
  131. enum {
  132.     kPEFTag1                    = FOUR_CHAR_CODE('Joy!'),       /* For non-Apple compilers: 0x4A6F7921.*/
  133.     kPEFTag2                    = FOUR_CHAR_CODE('peff'),       /* For non-Apple compilers: 0x70656666.*/
  134.     kPEFVersion                 = 0x00000001
  135. };
  138. enum {
  139.     kPEFFirstSectionHeaderOffset = sizeof(PEFContainerHeader)
  140. };
  142. #define PEFFirstSectionNameOffset(container)    
  143.             ( kPEFFirstSectionHeaderOffset + ((container)->sectionCount * sizeof ( PEFSectionHeader )) )
  147. /* =========================================================================================== */
  148. /* Section Headers */
  149. /* =============== */
  154. struct PEFSectionHeader {
  155.     SInt32                          nameOffset;                 /* Offset of name within the section name table, -1 => none.*/
  156.     UInt32                          defaultAddress;             /* Default address, affects relocations.*/
  157.     UInt32                          totalLength;                /* Fully expanded size in bytes of the section contents.*/
  158.     UInt32                          unpackedLength;             /* Size in bytes of the "initialized" part of the contents.*/
  159.     UInt32                          containerLength;            /* Size in bytes of the raw data in the container.*/
  160.     UInt32                          containerOffset;            /* Offset of section's raw data.*/
  161.     UInt8                           sectionKind;                /* Kind of section contents/usage.*/
  162.     UInt8                           shareKind;                  /* Sharing level, if a writeable section.*/
  163.     UInt8                           alignment;                  /* Preferred alignment, expressed as log 2.*/
  164.     UInt8                           reservedA;                  /* Reserved, must be zero.*/
  165. };
  166. typedef struct PEFSectionHeader         PEFSectionHeader;
  167. enum {
  168.                                                                 /* Values for the sectionKind field.*/
  169.                                                                 /*    Section kind values for instantiated sections.*/
  170.     kPEFCodeSection             = 0,                            /* Code, presumed pure & position independent.*/
  171.     kPEFUnpackedDataSection     = 1,                            /* Unpacked writeable data.*/
  172.     kPEFPackedDataSection       = 2,                            /* Packed writeable data.*/
  173.     kPEFConstantSection         = 3,                            /* Read-only data.*/
  174.     kPEFExecDataSection         = 6,                            /* Intermixed code and writeable data.*/
  175.                                                                 /* Section kind values for non-instantiated sections.*/
  176.     kPEFLoaderSection           = 4,                            /* Loader tables.*/
  177.     kPEFDebugSection            = 5,                            /* Reserved for future use.*/
  178.     kPEFExceptionSection        = 7,                            /* Reserved for future use.*/
  179.     kPEFTracebackSection        = 8                             /* Reserved for future use.*/
  180. };
  183. enum {
  184.                                                                 /* Values for the shareKind field.*/
  185.     kPEFProcessShare            = 1,                            /* Shared within a single process.*/
  186.     kPEFGlobalShare             = 4,                            /* Shared across the entire system.*/
  187.     kPEFProtectedShare          = 5                             /* Readable across the entire system, writeable only to privileged code.*/
  188. };
  193. /* =========================================================================================== */
  194. /* Packed Data Contents */
  195. /* ==================== */
  199. /* -------------------------------------------------------------------------------------------- */
  200. /* The raw contents of a packed data section are a sequence of byte codes.  The basic format    */
  201. /* has a 3 bit opcode followed by a 5 bit count.  Additional bytes might be used to contain     */
  202. /* counts larger than 31, and to contain a second or third count.  Further additional bytes     */
  203. /* contain actual data values to transfer.                                                      */
  204. /*                                                                                              */
  205. /* All counts are represented in a variable length manner.  A zero in the initial 5 bit count   */
  206. /* indicates the actual value follows.  In this case, and for the second and third counts, the  */
  207. /* count is represented as a variable length sequence of bytes.  The bytes are stored in big    */
  208. /* endian manner, most significant part first.  The high order bit is set in all but the last   */
  209. /* byte.  The value is accumulated by shifting the current value up 7 bits and adding in the    */
  210. /* low order 7 bits of the next byte.                                                           */
  213. enum {
  214.                                                                 /* The packed data opcodes.*/
  215.     kPEFPkDataZero              = 0,                            /* Zero fill "count" bytes.*/
  216.     kPEFPkDataBlock             = 1,                            /* Block copy "count" bytes.*/
  217.     kPEFPkDataRepeat            = 2,                            /* Repeat "count" bytes "count2"+1 times.*/
  218.     kPEFPkDataRepeatBlock       = 3,                            /* Interleaved repeated and unique data.*/
  219.     kPEFPkDataRepeatZero        = 4                             /* Interleaved zero and unique data.*/
  220. };
  223. enum {
  224.     kPEFPkDataOpcodeShift       = 5,
  225.     kPEFPkDataCount5Mask        = 0x1F,
  226.     kPEFPkDataMaxCount5         = 31,
  227.     kPEFPkDataVCountShift       = 7,
  228.     kPEFPkDataVCountMask        = 0x7F,
  229.     kPEFPkDataVCountEndMask     = 0x80
  230. };
  233. #define PEFPkDataOpcode(byte) ( ((UInt8)(byte)) >> kPEFPkDataOpcodeShift )
  235. #define PEFPkDataCount5(byte) ( ((UInt8)(byte)) & kPEFPkDataCount5Mask )
  237. #define PEFPkDataComposeInstr(opcode,count5)        
  238.             ( (((UInt8)(opcode)) << kPEFPkDataOpcodeShift) | ((UInt8)(count5)) )
  242. /* -------------------------------------------------------------------------------------------- */
  243. /* The following code snippet can be used to input a variable length count.                     */
  244. /*                                                                                              */
  245. /*      count = 0;                                                                              */
  246. /*      do {                                                                                    */
  247. /*          byte = *bytePtr++;                                                                  */
  248. /*          count = (count << kPEFPkDataVCountShift) | (byte & kPEFPkDataVCountMask);           */
  249. /*      } while ( (byte & kPEFPkDataVCountEndMask) != 0 );                                      */
  250. /*                                                                                              */
  251. /* The following code snippet can be used to output a variable length count to a byte array.    */
  252. /* This is more complex than the input code because the chunks are output in big endian order.  */
  253. /* Think about handling values like 0 or 0x030000.                                              */
  254. /*                                                                                              */
  255. /*      count = 1;.                                                                             */
  256. /*      tempValue = value >> kPEFPkDataCountShift;                                              */
  257. /*      while ( tempValue != 0 ) {                                                              */
  258. /*          count += 1;                                                                         */
  259. /*          tempValue = tempValue >> kPEFPkDataCountShift;                                      */
  260. /*      }                                                                                       */
  261. /*                                                                                              */
  262. /*      bytePtr += count;                                                                       */
  263. /*      tempPtr = bytePtr - 1;                                                                  */
  264. /*      *tempPtr-- = value;     // ! No need to mask, only the low order byte is stored.        */
  265. /*      for ( count -= 1; count != 0; count -= 1 ) {                                            */
  266. /*          value = value >> kPEFPkDataCountShift;                                              */
  267. /*          *tempPtr-- = value | kPEFPkDataCountEndMask;                                        */
  268. /*      }                                                                                       */
  272. /* =========================================================================================== */
  273. /* Loader Section */
  274. /* ============== */
  278. /* -------------------------------------------------------------------------------------------- */
  279. /* The loader section contains information needed to prepare the code fragment for execution.   */
  280. /* This includes this fragment's exports, the import libraries and the imported symbols from    */
  281. /* each library, and the relocations for the writeable sections.                                */
  282. /*                                                                                              */
  283. /*          +-----------------------------------+               <-- containerOffset --------+   */
  284. /*          |       Loader Info Header          |   56 bytes                                |   */
  285. /*          |-----------------------------------|                                           |   */
  286. /*          |       Imported Library 0          |   24 bytes each                           |   */
  287. /*          |...................................|                                           |   */
  288. /*          |           - - -                   |                                           |   */
  289. /*          |...................................|                                           |   */
  290. /*          |       Imported Library l-1        |                                           |   */
  291. /*          |-----------------------------------|                                           |   */
  292. /*          |       Imported Symbol 0           |   4 bytes each                            |   */
  293. /*          |...................................|                                           |   */
  294. /*          |           - - -                   |                                           |   */
  295. /*          |...................................|                                           |   */
  296. /*          |       Imported Symbol i-1         |                                           |   */
  297. /*          |-----------------------------------|                                           |   */
  298. /*          |       Relocation Header 0         |   12 bytes each                           |   */
  299. /*          |...................................|                                           |   */
  300. /*          |           - - -                   |                                           |   */
  301. /*          |...................................|                                           |   */
  302. /*          |       Relocation Header r-1       |                                           |   */
  303. /*          |-----------------------------------|               <-- + relocInstrOffset -----|   */
  304. /*          |       Relocation Instructions     |                                           |   */
  305. /*          |-----------------------------------|               <-- + loaderStringsOffset --|   */
  306. /*          |       Loader String Table         |                                           |   */
  307. /*          |-----------------------------------|               <-- + exportHashOffset -----+   */
  308. /*          |       Export Hash Slot 0          |   4 bytes each                                */
  309. /*          |...................................|                                               */
  310. /*          |           - - -                   |                                               */
  311. /*          |...................................|                                               */
  312. /*          |       Export Hash Slot h-1        |                                               */
  313. /*          |-----------------------------------|                                               */
  314. /*          |       Export Symbol Key 0         |   4 bytes each                                */
  315. /*          |...................................|                                               */
  316. /*          |           - - -                   |                                               */
  317. /*          |...................................|                                               */
  318. /*          |       Export Symbol Key e-1       |                                               */
  319. /*          |-----------------------------------|                                               */
  320. /*          |       Export Symbol 0             |   10 bytes each                               */
  321. /*          |...................................|                                               */
  322. /*          |           - - -                   |                                               */
  323. /*          |...................................|                                               */
  324. /*          |       Export Symbol e-1           |                                               */
  325. /*          +-----------------------------------+                                               */
  330. struct PEFLoaderInfoHeader {
  331.     SInt32                          mainSection;                /* Section containing the main symbol, -1 => none.*/
  332.     UInt32                          mainOffset;                 /* Offset of main symbol.*/
  333.     SInt32                          initSection;                /* Section containing the init routine's TVector, -1 => none.*/
  334.     UInt32                          initOffset;                 /* Offset of the init routine's TVector.*/
  335.     SInt32                          termSection;                /* Section containing the term routine's TVector, -1 => none.*/
  336.     UInt32                          termOffset;                 /* Offset of the term routine's TVector.*/
  337.     UInt32                          importedLibraryCount;       /* Number of imported libraries.  ('l')*/
  338.     UInt32                          totalImportedSymbolCount;   /* Total number of imported symbols.  ('i')*/
  339.     UInt32                          relocSectionCount;          /* Number of sections with relocations.  ('r')*/
  340.     UInt32                          relocInstrOffset;           /* Offset of the relocation instructions.*/
  341.     UInt32                          loaderStringsOffset;        /* Offset of the loader string table.*/
  342.     UInt32                          exportHashOffset;           /* Offset of the export hash table.*/
  343.     UInt32                          exportHashTablePower;       /* Export hash table size as log 2.  (Log2('h'))*/
  344.     UInt32                          exportedSymbolCount;        /* Number of exported symbols.  ('e')*/
  345. };
  346. typedef struct PEFLoaderInfoHeader      PEFLoaderInfoHeader;
  349. /* =========================================================================================== */
  350. /* Imported Libraries */
  351. /* ------------------ */
  355. struct PEFImportedLibrary {
  356.     UInt32                          nameOffset;                 /* Loader string table offset of library's name.*/
  357.     UInt32                          oldImpVersion;              /* Oldest compatible implementation version.*/
  358.     UInt32                          currentVersion;             /* Current version at build time.*/
  359.     UInt32                          importedSymbolCount;        /* Imported symbol count for this library.*/
  360.     UInt32                          firstImportedSymbol;        /* Index of first imported symbol from this library.*/
  361.     UInt8                           options;                    /* Option bits for this library.*/
  362.     UInt8                           reservedA;                  /* Reserved, must be zero.*/
  363.     UInt16                          reservedB;                  /* Reserved, must be zero.*/
  364. };
  365. typedef struct PEFImportedLibrary       PEFImportedLibrary;
  366. enum {
  367.                                                                 /* Bits for the PEFImportedLibrary options field.*/
  368.     kPEFWeakImportLibMask       = 0x40,                         /* The imported library is allowed to be missing.*/
  369.     kPEFInitLibBeforeMask       = 0x80                          /* The imported library must be initialized first.*/
  370. };
  375. /* =========================================================================================== */
  376. /* Imported Symbols */
  377. /* ---------------- */
  381. /* -------------------------------------------------------------------------------------------- */
  382. /* The PEFImportedSymbol type has the following bit field layout.                               */
  383. /*                                                                                              */
  384. /*                                                                     3                        */
  385. /*       0             7 8                                             1                        */
  386. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  387. /*      | symbol class  | offset of symbol name in loader string table  |                       */
  388. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  389. /*      |<-- 8 bits --->|<-- 24 bits ---------------------------------->|                       */
  394. struct PEFImportedSymbol {
  395.     UInt32                          classAndName;
  396. };
  397. typedef struct PEFImportedSymbol        PEFImportedSymbol;
  398. enum {
  399.     kPEFImpSymClassShift        = 24,
  400.     kPEFImpSymNameOffsetMask    = 0x00FFFFFF,
  401.     kPEFImpSymMaxNameOffset     = 0x00FFFFFF                    /* 16,777,215*/
  402. };
  404. #define PEFImportedSymbolClass(classAndName)        ((UInt8) ((classAndName) >> kPEFImpSymClassShift))
  405. #define PEFImportedSymbolNameOffset(classAndName)   ((classAndName) & kPEFImpSymNameOffsetMask)
  407. #define PEFComposeImportedSymbol(class,nameOffset)      
  408.             ( ( ((UInt32)(class)) << kPEFImpSymClassShift ) | ( (UInt32)(nameOffset) ) )
  410. enum {
  411.                                                                 /* Imported and exported symbol classes.*/
  412.     kPEFCodeSymbol              = 0x00,
  413.     kPEFDataSymbol              = 0x01,
  414.     kPEFTVectorSymbol           = 0x02,
  415.     kPEFTOCSymbol               = 0x03,
  416.     kPEFGlueSymbol              = 0x04,
  417.     kPEFUndefinedSymbol         = 0x0F,
  418.     kPEFWeakImportSymMask       = 0x80
  419. };
  424. /* =========================================================================================== */
  425. /* Exported Symbol Hash Table */
  426. /* -------------------------- */
  430. /* -------------------------------------------------------------------------------------------- */
  431. /* Exported symbols are described in four parts, optimized for speed of lookup.  These parts    */
  432. /* are the "export hash table", the "export key table", the "export symbol table", and the      */
  433. /* "export name table".  Overall they contain a flattened representation of a fairly normal     */
  434. /* hashed symbol table.                                                                         */
  435. /*                                                                                              */
  436. /* The export hash table is an array of small fixed size elements.  The number of elements is   */
  437. /* a power of 2.  A 32 bit hash word for a symbol is converted into an index into this array.   */
  438. /* Each hash slot contains a count of the number of exported symbols that map to this slot and  */
  439. /* the index of the first of those symbols in the key and symbol tables.  Of course some hash   */
  440. /* slots will have a zero count.                                                                */
  441. /*                                                                                              */
  442. /* The key and symbol tables are also arrays of fixed size elements, one for each exported      */
  443. /* symbol.  Their entries are grouped by hash slot, those elements mapping to the same hash     */
  444. /* slot are contiguous.  The key table contains just the full 32 bit hash word for each         */
  445. /* exported symbol.  The symbol table contains the offset of the symbol's name in the string    */
  446. /* table and other information about the exported symbol.                                       */
  447. /*                                                                                              */
  448. /* To look up an export you take the hashword and compute the hash slot index.  You then scan   */
  449. /* the indicated portion of the key table for matching hashwords.  If a hashword matches, you   */
  450. /* look at the corresponding symbol table entry to find the full symbol name.  If the names     */
  451. /* match the symbol is found.                                                                   */
  455. /* -------------------------------------------------------------------------------------------- */
  456. /* The following function may be used to compute the hash table size.  Signed values are used   */
  457. /* just to avoid potential code generation overhead for unsigned division.                      */
  458. /*                                                                                              */
  459. /*      UInt8   PEFComputeHashTableExponent ( SInt32    exportCount )                           */
  460. /*      {                                                                                       */
  461. /*          SInt32  exponent;                                                                   */
  462. /*                                                                                              */
  463. /*          const SInt32    kExponentLimit      = 16;   // Arbitrary, but must not exceed 30.   */
  464. /*          const SInt32    kAverageChainLimit  = 10;   // Arbitrary, for space/time tradeoff.  */
  465. /*                                                                                              */
  466. /*          for ( exponent = 0; exponent < kExponentLimit; exponent += 1 ) {                    */
  467. /*              if ( (exportCount / (1 << exponent)) < kAverageChainLimit ) break;              */
  468. /*          }                                                                                   */
  469. /*                                                                                              */
  470. /*          return exponent;                                                                    */
  471. /*                                                                                              */
  472. /*      }   // PEFComputeHashTableExponent ()                                                   */
  476. /* -------------------------------------------------------------------------------------------- */
  477. /* The PEFExportedSymbolHashSlot type has the following bit field layout.                       */
  478. /*                                                                                              */
  479. /*                                 1 1                                 3                        */
  480. /*       0                         3 4                                 1                        */
  481. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  482. /*      | symbol count              | index of first export key         |                       */
  483. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  484. /*      |<-- 14 bits -------------->|<-- 18 bits ---------------------->|                       */
  489. struct PEFExportedSymbolHashSlot {
  490.     UInt32                          countAndStart;
  491. };
  492. typedef struct PEFExportedSymbolHashSlot PEFExportedSymbolHashSlot;
  493. enum {
  494.     kPEFHashSlotSymCountShift   = 18,
  495.     kPEFHashSlotFirstKeyMask    = 0x0003FFFF,
  496.     kPEFHashSlotMaxSymbolCount  = 0x00003FFF,                   /*  16,383*/
  497.     kPEFHashSlotMaxKeyIndex     = 0x0003FFFF                    /* 262,143*/
  498. };
  500. #define PEFHashTableIndex(fullHashWord,hashTablePower)  
  501.             ( ( (fullHashWord) ^ ((fullHashWord) >> (hashTablePower)) ) & ((1 << (hashTablePower)) - 1) )
  503. #define PEFHashSlotSymbolCount(countAndStart)   ((UInt32) ((countAndStart) >> kPEFHashSlotSymCountShift))
  504. #define PEFHashSlotFirstKey(countAndStart)      ((countAndStart) & kPEFHashSlotFirstKeyMask)
  506. #define PEFComposeExportedSymbolHashSlot(symbolCount,firstKey)  
  507.             ( ( ((UInt32)(symbolCount)) << kPEFHashSlotSymCountShift ) | ( (UInt32)(firstKey) ) )
  511. /* =========================================================================================== */
  512. /* Exported Symbol Hash Key */
  513. /* ------------------------ */
  518. struct PEFSplitHashWord {
  519.     UInt16                          nameLength;
  520.     UInt16                          hashValue;
  521. };
  522. typedef struct PEFSplitHashWord         PEFSplitHashWord;
  524. struct PEFExportedSymbolKey {
  525.     union {
  526.         UInt32                          fullHashWord;
  527.         PEFSplitHashWord                splitHashWord;
  528.     }                                 u;
  529. };
  530. typedef struct PEFExportedSymbolKey     PEFExportedSymbolKey;
  531. enum {
  532.     kPEFHashLengthShift         = 16,
  533.     kPEFHashValueMask           = 0x0000FFFF,
  534.     kPEFHashMaxLength           = 0x0000FFFF                    /* 65,535*/
  535. };
  537. #define PEFHashNameLength(fullHashWord) ((UInt32) ((fullHashWord) >> kPEFHashLengthShift))
  538. #define PEFHashValue(fullHashWord)  ((fullHashWord) & kPEFHashValueMask)
  540. #define PEFComposeFullHashWord(nameLength,hashValue)    
  541.             ( ( ((UInt32)(nameLength)) << kPEFHashLengthShift ) | ( (UInt32)(hashValue) ) )
  545. /* ---------------------------------------------------------------------------------------------------- */
  546. /* The following function computes the full 32 bit hash word.                                           */
  547. /*                                                                                                      */
  548. /*      UInt32  PEFComputeHashWord  ( BytePtr   nameText,       // ! First "letter", not length byte.   */
  549. /*                                    UInt32    nameLength )    // ! The text may be zero terminated.   */
  550. /*      {                                                                                               */
  551. /*          BytePtr charPtr     = nameText;                                                             */
  552. /*          SInt32  hashValue   = 0;        // ! Signed to match old published algorithm.               */
  553. /*          UInt32  length      = 0;                                                                    */
  554. /*          UInt32  limit;                                                                              */
  555. /*          UInt32  result;                                                                             */
  556. /*          UInt8   currChar;                                                                           */
  557. /*                                                                                                      */
  558. /*          #define PseudoRotate(x)  ( ( (x) << 1 ) - ( (x) >> 16 ) )                                   */
  559. /*                                                                                                      */
  560. /*          for ( limit = nameLength; limit > 0; limit -= 1 ) {                                         */
  561. /*              currChar = *charPtr++;                                                                  */
  562. /*              if ( currChar == NULL ) break;                                                          */
  563. /*              length += 1;                                                                            */
  564. /*              hashValue = PseudoRotate ( hashValue ) ^ currChar;                                      */
  565. /*          }                                                                                           */
  566. /*                                                                                                      */
  567. /*          result  = (length << kPEFHashLengthShift) |                                                 */
  568. /*                    ((UInt16) ((hashValue ^ (hashValue >> 16)) & kPEFHashValueMask));                 */
  569. /*                                                                                                      */
  570. /*          return result;                                                                              */
  571. /*                                                                                                      */
  572. /*      }   // PEFComputeHashWord ()                                                                    */
  576. /* =========================================================================================== */
  577. /* Exported Symbols */
  578. /* ---------------- */
  583. struct PEFExportedSymbol {                                      /* ! This structure is 10 bytes long and arrays are packed.*/
  584.     UInt32                          classAndName;               /* A combination of class and name offset.*/
  585.     UInt32                          symbolValue;                /* Typically the symbol's offset within a section.*/
  586.     SInt16                          sectionIndex;               /* The index of the section, or pseudo-section, for the symbol.*/
  587. };
  588. typedef struct PEFExportedSymbol        PEFExportedSymbol;
  590. /* -------------------------------------------------------------------------------------------- */
  591. /* The classAndName field of the PEFExportedSymbol type has the following bit field layout.     */
  592. /*                                                                                              */
  593. /*                                                                     3                        */
  594. /*       0             7 8                                             1                        */
  595. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  596. /*      | symbol class  | offset of symbol name in loader string table  |                       */
  597. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                       */
  598. /*      |<-- 8 bits --->|<-- 24 bits ---------------------------------->|                       */
  601. enum {
  602.     kPEFExpSymClassShift        = 24,
  603.     kPEFExpSymNameOffsetMask    = 0x00FFFFFF,
  604.     kPEFExpSymMaxNameOffset     = 0x00FFFFFF                    /* 16,777,215*/
  605. };
  607. #define PEFExportedSymbolClass(classAndName)        ((UInt8) ((classAndName) >> kPEFExpSymClassShift))
  608. #define PEFExportedSymbolNameOffset(classAndName)   ((classAndName) & kPEFExpSymNameOffsetMask)
  610. #define PEFComposeExportedSymbol(class,nameOffset)      
  611.             ( ( ((UInt32)(class)) << kPEFExpSymClassShift ) | ( (UInt32)(nameOffset) ) )
  613. enum {
  614.                                                                 /* Negative section indices indicate pseudo-sections.*/
  615.     kPEFAbsoluteExport          = -2,                           /* The symbol value is an absolute address.*/
  616.     kPEFReexportedImport        = -3                            /* The symbol value is the index of a reexported import.*/
  617. };
  622. /* =========================================================================================== */
  623. /* Loader Relocations */
  624. /* ================== */
  628. /* -------------------------------------------------------------------------------------------- */
  629. /* The relocations for a section are defined by a sequence of instructions for an abstract      */
  630. /* machine that is specifically geared to performing relocations commonly needed for the "CFM"  */
  631. /* code generation model.  These instructions occur in 16 bit chunks.  Most instructions have   */
  632. /* just a single chunk.  Instructions that are larger than 16 bits have an opcode and some of   */
  633. /* the operands in the first chunk, with other operands in following chunks.                    */
  634. /*                                                                                              */
  635. /* ! Note that the multi-chunk relocations have separate "Compose" macros for each chunk.  The  */
  636. /* ! macros have the same basic name with a positional suffix of "_1st", "_2nd", etc.           */
  641. typedef UInt16                          PEFRelocChunk;
  643. struct PEFLoaderRelocationHeader {
  644.     UInt16                          sectionIndex;               /* Index of the section to be fixed up.*/
  645.     UInt16                          reservedA;                  /* Reserved, must be zero.*/
  646.     UInt32                          relocCount;                 /* Number of 16 bit relocation chunks.*/
  647.     UInt32                          firstRelocOffset;           /* Offset of first relocation instruction.*/
  648. };
  649. typedef struct PEFLoaderRelocationHeader PEFLoaderRelocationHeader;
  651. /* -------------------------------------------------------------------------------------------- */
  652. /* ! Note that the relocCount field is the number of 16 bit relocation chunks, i.e. 1/2 the     */
  653. /* ! total number of bytes of relocation instructions.  While most relocation instructions are  */
  654. /* ! 16 bits long, some are longer so the number of complete relocation instructions may be     */
  655. /* ! less than the relocCount value.                                                            */
  659. /* ------------------------------------------------------------------------------------ */
  660. /* The PEFRelocField macro is a utility for extracting relocation instruction fields.   */
  663. #define PEFRFShift(offset,length)   (16 - ((offset) + (length)))
  664. #define PEFRFMask(length)           ((1 << (length)) - 1)
  666. #define PEFRelocField(chunk,offset,length)  
  667.             ( ( (chunk) >> (16 - ((offset) + (length))) ) & ((1 << (length)) - 1) )
  671. /* =========================================================================================== */
  672. /* Basic Relocation Opcodes */
  673. /* ------------------------ */
  676. /* -------------------------------------------------------------------------------------------- */
  677. /* The number of opcode bits varies from 2 to 7.  The enumeration and switch table given here   */
  678. /* are defined in terms of the most significant 7 bits of the first instruction chunk.  An      */
  679. /* instruction is decoded by using the most significant 7 bits as an index into the opcode      */
  680. /* table, which in turn contains appropriately masked forms of the most significant 7 bits.     */
  681. /* The macro PEFRelocBasicOpcode assumes a declaration of the form.                             */
  682. /*                                                                                              */
  683. /*      UInt8 kPEFRelocBasicOpcodes [kPEFRelocBasicOpcodeRange] = { PEFMaskedBasicOpcodes };    */
  686. enum {
  687.     kPEFRelocBasicOpcodeRange   = 128
  688. };
  690. #define PEFRelocBasicOpcode(firstChunk) (kPEFRelocBasicOpcodes[(firstChunk)>>9])
  694. /* -------------------------------------------------------------------------------------------- */
  695. /* The relocation opcodes, clustered by major and minor groups.  The instructions within a      */
  696. /* cluster all have the same bit field layout.  The enumeration values use the high order 7     */
  697. /* bits of the relocation instruction.  Unused low order bits are set to zero.                  */
  699. enum {
  700.     kPEFRelocBySectDWithSkip    = 0x00,                         /* Binary: 00x_xxxx*/
  701.     kPEFRelocBySectC            = 0x20,                         /* Binary: 010_0000, group is "RelocRun"*/
  702.     kPEFRelocBySectD            = 0x21,                         /* Binary: 010_0001*/
  703.     kPEFRelocTVector12          = 0x22,                         /* Binary: 010_0010*/
  704.     kPEFRelocTVector8           = 0x23,                         /* Binary: 010_0011*/
  705.     kPEFRelocVTable8            = 0x24,                         /* Binary: 010_0100*/
  706.     kPEFRelocImportRun          = 0x25,                         /* Binary: 010_0101*/
  707.     kPEFRelocSmByImport         = 0x30,                         /* Binary: 011_0000, group is "RelocSmIndex"*/
  708.     kPEFRelocSmSetSectC         = 0x31,                         /* Binary: 011_0001*/
  709.     kPEFRelocSmSetSectD         = 0x32,                         /* Binary: 011_0010*/
  710.     kPEFRelocSmBySection        = 0x33,                         /* Binary: 011_0011*/
  711.     kPEFRelocIncrPosition       = 0x40,                         /* Binary: 100_0xxx*/
  712.     kPEFRelocSmRepeat           = 0x48,                         /* Binary: 100_1xxx*/
  713.     kPEFRelocSetPosition        = 0x50,                         /* Binary: 101_000x*/
  714.     kPEFRelocLgByImport         = 0x52,                         /* Binary: 101_001x*/
  715.     kPEFRelocLgRepeat           = 0x58,                         /* Binary: 101_100x*/
  716.     kPEFRelocLgSetOrBySection   = 0x5A,                         /* Binary: 101_101x*/
  717.     kPEFRelocUndefinedOpcode    = 0xFF                          /* Used in masking table for all undefined values.*/
  718. };
  722. /* ---------------------------------------------------------------------------- */
  723. /* The RelocLgSetOrBySection instruction has an additional 4 bits of subopcode  */
  724. /* beyond the 7 used by the dispatch table.  To be precise it has 6 plus 4 but  */
  725. /* the dispatch table ignores the 7th bit, so the subdispatch is on all 4 extra */
  726. /* subopcode bits.                                                              */
  728. enum {
  729.     kPEFRelocLgBySectionSubopcode = 0x00,                       /* Binary: 0000*/
  730.     kPEFRelocLgSetSectCSubopcode = 0x01,                        /* Binary: 0001*/
  731.     kPEFRelocLgSetSectDSubopcode = 0x02                         /* Binary: 0010*/
  732. };
  734. #define PEFRelocLgSetOrBySubopcode(chunk) (((chunk) >> 6) & 0x0F)
  738. /* -------------------------------------------------------------------------------------------- */
  739. /* The initial values for the opcode "masking" table.  This has the enumeration values from     */
  740. /* above with appropriate replications for "don't care" bits.  It is almost certainly shorter   */
  741. /* and faster to look up the masked value in a table than to use a branch tree.                 */
  744. #define PEFMaskedBasicOpcodes                                                                                                                   
  745.                                                                                                                                                 
  746.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x00 .. 0x03 */  
  747.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x04 .. 0x07 */  
  748.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x08 .. 0x0B */  
  749.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x0C .. 0x0F */  
  750.                                                                                                                                                 
  751.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x10 .. 0x13 */  
  752.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x14 .. 0x17 */  
  753.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x18 .. 0x1B */  
  754.             kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   kPEFRelocBySectDWithSkip,   /* 0x1C .. 0x1F */  
  755.                                                                                                                                                 
  756.             kPEFRelocBySectC,           kPEFRelocBySectD,           kPEFRelocTVector12,         kPEFRelocTVector8,          /* 0x20 .. 0x23 */  
  757.             kPEFRelocVTable8,           kPEFRelocImportRun,         kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x24 .. 0x27 */  
  758.                                                                                                                                                 
  759.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x28 .. 0x2B */  
  760.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x2C .. 0x2F */  
  761.                                                                                                                                                 
  762.             kPEFRelocSmByImport,        kPEFRelocSmSetSectC,        kPEFRelocSmSetSectD,        kPEFRelocSmBySection,       /* 0x30 .. 0x33 */  
  763.                                                                                                                                                 
  764.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x34 .. 0x37 */  
  765.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x38 .. 0x3B */  
  766.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x3C .. 0x3F */  
  767.                                                                                                                                                 
  768.             kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      /* 0x40 .. 0x43 */  
  769.             kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      kPEFRelocIncrPosition,      /* 0x44 .. 0x47 */  
  770.                                                                                                                                                 
  771.             kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          /* 0x48 .. 0x4B */  
  772.             kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          kPEFRelocSmRepeat,          /* 0x4C .. 0x4F */  
  773.                                                                                                                                                 
  774.             kPEFRelocSetPosition,       kPEFRelocSetPosition,       kPEFRelocLgByImport,        kPEFRelocLgByImport,        /* 0x50 .. 0x53 */  
  775.                                                                                                                                                 
  776.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x54 .. 0x57 */  
  777.                                                                                                                                                 
  778.             kPEFRelocLgRepeat,          kPEFRelocLgRepeat,          kPEFRelocLgSetOrBySection,  kPEFRelocLgSetOrBySection,  /* 0x58 .. 0x5B */  
  779.                                                                                                                                                 
  780.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x5C .. 0x5F */  
  781.                                                                                                                                                 
  782.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x60 .. 0x63 */  
  783.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x64 .. 0x67 */  
  784.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x68 .. 0x6B */  
  785.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x6C .. 0x6F */  
  786.                                                                                                                                                 
  787.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x70 .. 0x73 */  
  788.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x74 .. 0x77 */  
  789.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   /* 0x78 .. 0x7B */  
  790.             kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode,   kPEFRelocUndefinedOpcode    /* 0x7C .. 0x7F */
  794. /* =========================================================================================== */
  795. /* RelocBySectDWithSkip Instruction */
  796. /* -------------------------------- */
  800. /* -------------------------------------------------------------------------------------------- */
  801. /* The "RelocBySectDWithSkip" instruction has the following bit field layout.                   */
  802. /*                                                                                              */
  803. /*                           1         1                                                        */
  804. /*       0 1 2             9 0         5                                                        */
  805. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  806. /*      |0 0| skip count    | rel count |                                                       */
  807. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  808. /*      | 2 |<-- 8 bits --->|<--  6 --->|                                                       */
  809. /*                                                                                              */
  810. /* ! Note that the stored skip count and reloc count are the actual values!                     */
  812. enum {
  813.     kPEFRelocWithSkipMaxSkipCount = 255,
  814.     kPEFRelocWithSkipMaxRelocCount = 63
  815. };
  817. #define PEFRelocWithSkipSkipCount(chunk)    PEFRelocField ( (chunk), 2, 8 )
  818. #define PEFRelocWithSkipRelocCount(chunk)   PEFRelocField ( (chunk), 10, 6 )
  820. #define PEFRelocComposeWithSkip(skipCount,relocCount)   
  821.             ( 0x0000 | (((UInt16)(skipCount)) << 6) | ((UInt16)(relocCount)) )
  825. /* =========================================================================================== */
  826. /* RelocRun Group */
  827. /* -------------- */
  831. /* -------------------------------------------------------------------------------------------- */
  832. /* The "RelocRun" group includes the "RelocBySectC", "RelocBySectD", "RelocTVector12",          */
  833. /* "RelocTVector8", "RelocVTable8", and "RelocImportRun" instructions.  This group has the      */
  834. /* following bit field layout.                                                                  */
  835. /*                                                                                              */
  836. /*                                     1                                                        */
  837. /*       0   2 3     6 7               5                                                        */
  838. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  839. /*      |0 1 0| subop.| run length      |                                                       */
  840. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  841. /*      |  3  |<- 4 ->|<-- 9 bits ----->|                                                       */
  842. /*                                                                                              */
  843. /* ! Note that the stored run length is the actual value minus 1, but the macros deal with the  */
  844. /* ! actual value!                                                                              */
  846. enum {
  847.     kPEFRelocRunMaxRunLength    = 512
  848. };
  850. #define PEFRelocRunSubopcode(chunk) PEFRelocField ( (chunk), 3, 4 )
  851. #define PEFRelocRunRunLength(chunk) (PEFRelocField ( (chunk), 7, 9 ) + 1)
  853. #define PEFRelocComposeRun(subopcode,runLength) 
  854.             ( 0x4000 | (((UInt16)(subopcode)) << 9) | ((UInt16)((runLength)-1)) )
  856. #define PEFRelocComposeBySectC(runLength)       PEFRelocComposeRun ( 0, (runLength) )
  857. #define PEFRelocComposeBySectD(runLength)       PEFRelocComposeRun ( 1, (runLength) )
  858. #define PEFRelocComposeTVector12(runLength)     PEFRelocComposeRun ( 2, (runLength) )
  859. #define PEFRelocComposeTVector8(runLength)      PEFRelocComposeRun ( 3, (runLength) )
  860. #define PEFRelocComposeVTable8(runLength)       PEFRelocComposeRun ( 4, (runLength) )
  861. #define PEFRelocComposeImportRun(runLength)     PEFRelocComposeRun ( 5, (runLength) )
  865. /* =========================================================================================== */
  866. /* RelocSmIndex Group */
  867. /* ------------------ */
  871. /* ---------------------------------------------------------------------------------------- */
  872. /* The "RelocSmIndex" group includes the "RelocSmByImport", "RelocSmSetSectC",              */
  873. /* "RelocSmSetSectD" and "RelocSmBySection" instructions.  This group has the following bit */
  874. /* field layout.                                                                            */
  875. /*                                                                                          */
  876. /*                                     1                                                    */
  877. /*       0   2 3     6 7               5                                                    */
  878. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                   */
  879. /*      |0 1 1| subop.| index           |                                                   */
  880. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                   */
  881. /*      |  3  |<- 4 ->|<-- 9 bits ----->|                                                   */
  882. /*                                                                                          */
  883. /* ! Note that the stored index is the actual value!                                        */
  885. enum {
  886.     kPEFRelocSmIndexMaxIndex    = 511
  887. };
  889. #define PEFRelocSmIndexSubopcode(chunk) PEFRelocField ( (chunk), 3, 4 )
  890. #define PEFRelocSmIndexIndex(chunk)     PEFRelocField ( (chunk), 7, 9 )
  892. #define PEFRelocComposeSmIndex(subopcode,index) 
  893.             ( 0x6000 | (((UInt16)(subopcode)) << 9) | ((UInt16)(index)) )
  895. #define PEFRelocComposeSmByImport(index)    PEFRelocComposeSmIndex ( 0, (index) )
  896. #define PEFRelocComposeSmSetSectC(index)    PEFRelocComposeSmIndex ( 1, (index) )
  897. #define PEFRelocComposeSmSetSectD(index)    PEFRelocComposeSmIndex ( 2, (index) )
  898. #define PEFRelocComposeSmBySection(index)   PEFRelocComposeSmIndex ( 3, (index) )
  902. /* =========================================================================================== */
  903. /* RelocIncrPosition Instruction */
  904. /* ----------------------------- */
  908. /* -------------------------------------------------------------------------------------------- */
  909. /* The "RelocIncrPosition" instruction has the following bit field layout.                      */
  910. /*                                                                                              */
  911. /*                                     1                                                        */
  912. /*       0     3 4                     5                                                        */
  913. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  914. /*      |1 0 0 0| offset                |                                                       */
  915. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  916. /*      |<- 4 ->|<-- 12 bits ---------->|                                                       */
  917. /*                                                                                              */
  918. /* ! Note that the stored offset is the actual value minus 1, but the macros deal with the      */
  919. /* ! actual value!                                                                              */
  921. enum {
  922.     kPEFRelocIncrPositionMaxOffset = 4096
  923. };
  925. #define PEFRelocIncrPositionOffset(chunk)   (PEFRelocField ( (chunk), 4, 12 ) + 1)
  927. #define PEFRelocComposeIncrPosition(offset) 
  928.             ( 0x8000 | ((UInt16)((offset)-1)) )
  932. /* =========================================================================================== */
  933. /* RelocSmRepeat Instruction */
  934. /* ------------------------- */
  938. /* -------------------------------------------------------------------------------------------- */
  939. /* The "RelocSmRepeat" instruction has the following bit field layout.                          */
  940. /*                                                                                              */
  941. /*                                     1                                                        */
  942. /*       0     3 4     7 8             5                                                        */
  943. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  944. /*      |1 0 0 1| chnks | repeat count  |                                                       */
  945. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                                                       */
  946. /*      |<- 4 ->|<- 4 ->|<-- 8 bits --->|                                                       */
  947. /*                                                                                              */
  948. /* ! Note that the stored chunk count and repeat count are the actual values minus 1, but the   */
  949. /* ! macros deal with the actual values!                                                        */
  951. enum {
  952.     kPEFRelocSmRepeatMaxChunkCount = 16,
  953.     kPEFRelocSmRepeatMaxRepeatCount = 256
  954. };
  956. #define PEFRelocSmRepeatChunkCount(chunk)   (PEFRelocField ( (chunk), 4, 4 ) + 1)
  957. #define PEFRelocSmRepeatRepeatCount(chunk)  (PEFRelocField ( (chunk), 8, 8 ) + 1)
  959. #define PEFRelocComposeSmRepeat(chunkCount,repeatCount) 
  960.             ( 0x9000 | ((((UInt16)(chunkCount))-1) << 8) | (((UInt16)(repeatCount))-1) )
  964. /* =========================================================================================== */
  965. /* RelocSetPosition Instruction */
  966. /* ---------------------------- */
  970. /* -------------------------------------------------------------------------------------------- */
  971. /* The "RelocSetPosition" instruction has the following bit field layout.                       */
  972. /*                                                                                              */
  973. /*                                     1                                   1                    */
  974. /*       0         5 6                 5     0                             5                    */
  975. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  976. /*      |1 0 1 0 0 0| offset (high)     |   | offset (low)                  |                   */
  977. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  978. /*      |<-- 6 ---->|<-- 10 bits ------>|   |<-- 16 bits ------------------>|                   */
  979. /*                                                                                              */
  980. /* ! Note that the stored offset is the actual value!                                           */
  982. enum {
  983.     kPEFRelocSetPosMaxOffset    = 0x03FFFFFF                    /* 67,108,863*/
  984. };
  986. #define PEFRelocSetPosOffsetHigh(chunk) PEFRelocField ( (chunk), 6, 10 )
  988. #define PEFRelocSetPosFullOffset(firstChunk,secondChunk)    
  989.             ( ((((UInt32)(firstChunk)) & 0x03FF) << 16) | ((UInt32)(secondChunk)) )
  991. #define PEFRelocComposeSetPosition_1st(fullOffset)  
  992.             ( 0xA000 | ((UInt16) (((UInt32)(fullOffset)) >> 16) ) )
  993. #define PEFRelocComposeSetPosition_2nd(fullOffset)  
  994.             ( (UInt16) ((UInt32)(fullOffset) & 0xFFFF) )
  998. /* =========================================================================================== */
  999. /* RelocLgByImport Instruction */
  1000. /* --------------------------- */
  1004. /* -------------------------------------------------------------------------------------------- */
  1005. /* The "RelocLgByImport" instruction has the following bit field layout.                        */
  1006. /*                                                                                              */
  1007. /*                                     1                                   1                    */
  1008. /*       0         5 6                 5     0                             5                    */
  1009. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1010. /*      |1 0 1 0 0 1| index (high)      |   | index (low)                   |                   */
  1011. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1012. /*      |<-- 6 ---->|<-- 10 bits ------>|   |<-- 16 bits ------------------>|                   */
  1013. /*                                                                                              */
  1014. /* ! Note that the stored offset is the actual value!                                           */
  1016. enum {
  1017.     kPEFRelocLgByImportMaxIndex = 0x03FFFFFF                    /* 67,108,863*/
  1018. };
  1020. #define PEFRelocLgByImportIndexHigh(chunk)  PEFRelocField ( (chunk), 6, 10 )
  1022. #define PEFRelocLgByImportFullIndex(firstChunk,secondChunk) 
  1023.             ( ((((UInt32)(firstChunk)) & 0x03FF) << 16) | ((UInt32)(secondChunk)) )
  1025. #define PEFRelocComposeLgByImport_1st(fullIndex)    
  1026.             ( 0xA400 | ((UInt16) (((UInt32)(fullIndex)) >> 16) ) )
  1027. #define PEFRelocComposeLgByImport_2nd(fullIndex)    
  1028.             ( (UInt16) ((UInt32)(fullIndex) & 0xFFFF) )
  1032. /* =========================================================================================== */
  1033. /* RelocLgRepeat Instruction */
  1034. /* ------------------------- */
  1038. /* -------------------------------------------------------------------------------------------- */
  1039. /* The "RelocLgRepeat" instruction has the following bit field layout.                          */
  1040. /*                                                                                              */
  1041. /*                           1         1                                   1                    */
  1042. /*       0         5 6     9 0         5     0                             5                    */
  1043. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1044. /*      |1 0 1 1 0 0| chnks | rpt (high)|   | repeat count (low)            |                   */
  1045. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1046. /*      |<--  6 --->|<- 4 ->|<--  6 --->|   |<-- 16 bits ------------------>|                   */
  1047. /*                                                                                              */
  1048. /* ! Note that the stored chunk count is the actual value minus 1, but the macros deal with     */
  1049. /* ! the actual value!  The stored repeat count is the actual value!                            */
  1051. enum {
  1052.     kPEFRelocLgRepeatMaxChunkCount = 16,
  1053.     kPEFRelocLgRepeatMaxRepeatCount = 0x003FFFFF                /* 4,194,303*/
  1054. };
  1056. #define PEFRelocLgRepeatChunkCount(chunk)       (PEFRelocField ( (chunk), 6, 4 ) + 1)
  1057. #define PEFRelocLgRepeatRepeatCountHigh(chunk)  PEFRelocField ( (chunk), 10, 6 )
  1059. #define PEFRelocLgRepeatFullRepeatCount(firstChunk,secondChunk) 
  1060.             ( ((((UInt32)(firstChunk)) & 0x003F) << 16) | ((UInt32)(secondChunk)) )
  1062. #define PEFRelocComposeLgRepeat_1st(chunkCount,fullRepeatCount) 
  1063.             ( 0xB000 | ((((UInt16)(chunkCount))-1) << 6) | ((UInt16) (((UInt32)(fullRepeatCount)) >>16 ) ) )
  1064. #define PEFRelocComposeLgRepeat_2nd(chunkCount,fullRepeatCount) 
  1065.             ( (UInt16) ((UInt32)(fullRepeatCount) & 0xFFFF) )
  1069. /* =========================================================================================== */
  1070. /* RelocLgSetOrBySection Group */
  1071. /* --------------------------- */
  1075. /* -------------------------------------------------------------------------------------------- */
  1076. /* The "RelocLgSetOrBySection" instruction is really a group including the "RelocLgBySection",  */
  1077. /* "RelocLgSetSectC" and "RelocLgSetSectD" instructions.  This group has the following bit      */
  1078. /* field layout.                                                                                */
  1079. /*                                                                                              */
  1080. /*                           1         1                                   1                    */
  1081. /*       0         5 6     9 0         5     0                             5                    */
  1082. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1083. /*      |1 0 1 1 0 1| subop | idx (high)|   | index (low)                   |                   */
  1084. /*      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                   */
  1085. /*      |<--  6 --->|<- 4 ->|<--  6 --->|   |<-- 16 bits ------------------>|                   */
  1086. /*                                                                                              */
  1087. /* ! Note that the stored index is the actual value!                                            */
  1089. enum {
  1090.     kPEFRelocLgSetOrBySectionMaxIndex = 0x003FFFFF              /* 4,194,303*/
  1091. };
  1093. #define PEFRelocLgSetOrBySectionSubopcode(chunk)    PEFRelocField ( (chunk), 6, 4 )
  1094. #define PEFRelocLgSetOrBySectionIndexHigh(chunk)    PEFRelocField ( (chunk), 10, 6 )
  1096. #define PEFRelocLgSetOrBySectionFullIndex(firstChunk,secondChunk)   
  1097.             ( ((((UInt32)(firstChunk)) & 0x003F) << 16) | ((UInt32)(secondChunk)) )
  1099. #define PEFRelocComposeLgSetOrBySection_1st(subopcode,fullIndex)    
  1100.             ( 0xB400 | (((UInt16)(subopcode)) << 6) | ((UInt16) (((UInt32)(fullIndex)) >> 16) ) )
  1101. #define PEFRelocComposeLgSetOrBySection_2nd(subopcode,fullIndex)    
  1102.             ( (UInt16) ((UInt32)(fullIndex) & 0xFFFF) )
  1104. #define PEFRelocComposeLgBySection(fullIndex)   PEFRelocComposeLgSetOrBySection ( 0x00, (fullIndex) )
  1105. #define PEFRelocComposeLgSetSectC(fullIndex)    PEFRelocComposeLgSetOrBySection ( 0x01, (fullIndex) )
  1106. #define PEFRelocComposeLgSetSectD(fullIndex)    PEFRelocComposeLgSetOrBySection ( 0x02, (fullIndex) )
  1110. #if PRAGMA_STRUCT_ALIGN
  1111.     #pragma options align=reset
  1112. #elif PRAGMA_STRUCT_PACKPUSH
  1113.     #pragma pack(pop)
  1114. #elif PRAGMA_STRUCT_PACK
  1115.     #pragma pack()
  1116. #endif
  1118. #ifdef PRAGMA_IMPORT_OFF
  1119. #pragma import off
  1120. #elif PRAGMA_IMPORT
  1121. #pragma import reset
  1122. #endif
  1124. #ifdef __cplusplus
  1125. }
  1126. #endif
  1128. #endif /* __PEFBINARYFORMAT__ */