home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / sdktools / image / include / cvexefmt.h < prev    next >
C/C++ Source or Header  |  1994-09-08  |  16KB  |  407 lines
  1. /***    cvexefmt.h - format of CodeView information in exe
  2.  *
  3.  *      Structures, constants, etc. for reading CodeView information
  4.  *      from the executable.
  5.  *
  6.  */
  7.  
  8. //  The following structures and constants describe the format of the
  9. //  CodeView Debug OMF for that will be accepted by CodeView 4.0 and
  10. //  later.  These are executables with signatures of NB05, NB06 and NB08.
  11. //  There is some confusion about the signatures NB03 and NB04 so none
  12. //  of the utilites will accept executables with these signatures.  NB07 is
  13. //  the signature for QCWIN 1.0 packed executables.
  14.  
  15. //  All of the structures described below must start on a long word boundary
  16. //  to maintain natural alignment.  Pad space can be inserted during the
  17. //  write operation and the addresses adjusted without affecting the contents
  18. //  of the structures.
  19.  
  20. #ifndef _CV_INFO_INCLUDED
  21. #include "cvinfo.h"
  22. #endif
  23.  
  24. #ifndef    FAR
  25. #if _M_IX86 >= 300
  26. #define    FAR
  27. #else
  28. #define FAR far
  29. #endif
  30. #endif
  31.  
  32.  
  33. //  Type of subsection entry.
  34.  
  35. #define sstModule           0x120
  36. #define sstTypes            0x121
  37. #define sstPublic           0x122
  38. #define sstPublicSym        0x123   // publics as symbol (waiting for link)
  39. #define sstSymbols          0x124
  40. #define sstAlignSym         0x125
  41. #define sstSrcLnSeg         0x126   // because link doesn't emit SrcModule
  42. #define sstSrcModule        0x127
  43. #define sstLibraries        0x128
  44. #define sstGlobalSym        0x129
  45. #define sstGlobalPub        0x12a
  46. #define sstGlobalTypes      0x12b
  47. #define sstMPC              0x12c
  48. #define sstSegMap           0x12d
  49. #define sstSegName          0x12e
  50. #define sstPreComp          0x12f   // precompiled types
  51. #define sstPreCompMap       0x130   // map precompiled types in global types
  52. #define sstOffsetMap16      0x131
  53. #define sstOffsetMap32      0x132
  54. #define sstFileIndex        0x133   // Index of file names
  55. #define sstStaticSym        0x134
  56.  
  57. typedef enum OMFHash {
  58.     OMFHASH_NONE,           // no hashing
  59.     OMFHASH_SUMUC16,        // upper case sum of chars in 16 bit table
  60.     OMFHASH_SUMUC32,        // upper case sum of chars in 32 bit table
  61.     OMFHASH_ADDR16,         // sorted by increasing address in 16 bit table
  62.     OMFHASH_ADDR32          // sorted by increasing address in 32 bit table
  63. } OMFHASH;
  64.  
  65. //  CodeView Debug OMF signature.  The signature at the end of the file is
  66. //  a negative offset from the end of the file to another signature.  At
  67. //  the negative offset (base address) is another signature whose filepos
  68. //  field points to the first OMFDirHeader in a chain of directories.
  69. //  The NB05 signature is used by the link utility to indicated a completely
  70. //  unpacked file.  The NB06 signature is used by ilink to indicate that the
  71. //  executable has had CodeView information from an incremental link appended
  72. //  to the executable.  The NB08 signature is used by cvpack to indicate that
  73. //  the CodeView Debug OMF has been packed.  CodeView will only process
  74. //  executables with the NB08 signature.
  75.  
  76.  
  77. typedef struct OMFSignature {
  78.     char        Signature[4];   // "NBxx"
  79.     long        filepos;        // offset in file
  80. } OMFSignature;
  81.  
  82.  
  83.  
  84. //  directory information structure
  85. //  This structure contains the information describing the directory.
  86. //  It is pointed to by the signature at the base address or the directory
  87. //  link field of a preceeding directory.  The directory entries immediately
  88. //  follow this structure.
  89.  
  90.  
  91. typedef struct OMFDirHeader {
  92.     unsigned short  cbDirHeader;    // length of this structure
  93.     unsigned short  cbDirEntry;     // number of bytes in each directory entry
  94.     unsigned long   cDir;           // number of directorie entries
  95.     long            lfoNextDir;     // offset from base of next directory
  96.     unsigned long   flags;          // status flags
  97. } OMFDirHeader;
  98.  
  99.  
  100.  
  101.  
  102. //  directory structure
  103. //  The data in this structure is used to reference the data for each
  104. //  subsection of the CodeView Debug OMF information.  Tables that are
  105. //  not associated with a specific module will have a module index of
  106. //  oxffff.  These tables are the global types table, the global symbol
  107. //  table, the global public table and the library table.
  108.  
  109.  
  110. typedef struct OMFDirEntry {
  111.     unsigned short  SubSection;     // subsection type (sst...)
  112.     unsigned short  iMod;           // module index
  113.     long            lfo;            // large file offset of subsection
  114.     unsigned long   cb;             // number of bytes in subsection
  115. } OMFDirEntry;
  116.  
  117.  
  118.  
  119. //  information decribing each segment in a module
  120.  
  121. typedef struct OMFSegDesc {
  122.     unsigned short  Seg;            // segment index
  123.     unsigned short  pad;            // pad to maintain alignment
  124.     unsigned long   Off;            // offset of code in segment
  125.     unsigned long   cbSeg;          // number of bytes in segment
  126. } OMFSegDesc;
  127.  
  128.  
  129.  
  130.  
  131. //  per module information
  132. //  There is one of these subsection entries for each module
  133. //  in the executable.  The entry is generated by link/ilink.
  134. //  This table will probably require padding because of the
  135. //  variable length module name.
  136.  
  137. typedef struct OMFModule {
  138.     unsigned short  ovlNumber;      // overlay number
  139.     unsigned short  iLib;           // library that the module was linked from
  140.     unsigned short  cSeg;           // count of number of segments in module
  141.     char            Style[2];       // debugging style "CV"
  142.     OMFSegDesc      SegInfo[1];     // describes segments in module
  143.     char            Name[];         // length prefixed module name padded to
  144.                                     // long word boundary
  145. } OMFModule;
  146.  
  147.  
  148.  
  149. //  Symbol hash table format
  150. //  This structure immediately preceeds the global publics table
  151. //  and global symbol tables.
  152.  
  153. typedef struct OMFSymHash {
  154.     unsigned short  symhash;        // symbol hash function index
  155.     unsigned short  addrhash;       // address hash function index
  156.     unsigned long   cbSymbol;       // length of symbol information
  157.     unsigned long   cbHSym;         // length of symbol hash data
  158.     unsigned long   cbHAddr;        // length of address hashdata
  159. } OMFSymHash;
  160.  
  161.  
  162.  
  163. //  Global types subsection format
  164. //  This structure immediately preceeds the global types table.
  165. //  The offsets in the typeOffset array are relative to the address
  166. //  of ctypes.  Each type entry following the typeOffset array must
  167. //  begin on a long word boundary.
  168.  
  169. typedef struct OMFTypeFlags {
  170.     unsigned long   sig     :8;
  171.     unsigned long   unused  :24;
  172. } OMFTypeFlags;
  173.  
  174.  
  175. typedef struct OMFGlobalTypes {
  176.     OMFTypeFlags    flags;
  177.     unsigned long   cTypes;         // number of types
  178.     unsigned long   typeOffset[];   // array of offsets to types
  179. } OMFGlobalTypes;
  180.  
  181.  
  182.  
  183.  
  184. //  Precompiled types mapping table
  185. //  This table should be ignored by all consumers except the incremental
  186. //  packer.
  187.  
  188.  
  189. typedef struct OMFPreCompMap {
  190.     unsigned short  FirstType;      // first precompiled type index
  191.     unsigned short  cTypes;         // number of precompiled types
  192.     unsigned long   signature;      // precompiled types signature
  193.     unsigned short  pad;
  194.     CV_typ_t        map[];          // mapping of precompiled types
  195. } OMFPreCompMap;
  196.  
  197.  
  198.  
  199.  
  200. //  Source line to address mapping table.
  201. //  This table is generated by the link/ilink utility from line number
  202. //  information contained in the object file OMF data.  This table contains
  203. //  only the code contribution for one segment from one source file.
  204.  
  205.  
  206. typedef struct OMFSourceLine {
  207.     unsigned short  Seg;            // linker segment index
  208.     unsigned short  cLnOff;         // count of line/offset pairs
  209.     unsigned long   offset[1];      // array of offsets in segment
  210.     unsigned short  lineNbr[1];     // array of line lumber in source
  211. } OMFSourceLine;
  212.  
  213. typedef OMFSourceLine FAR * LPSL;
  214.  
  215.  
  216. //  Source file description
  217. //  This table is generated by the linker
  218.  
  219.  
  220. typedef struct OMFSourceFile {
  221.     unsigned short  cSeg;           // number of segments from source file
  222.     unsigned short  reserved;       // reserved
  223.     unsigned long   baseSrcLn[1];   // base of OMFSourceLine tables
  224.                                     // this array is followed by array
  225.                                     // of segment start/end pairs followed by
  226.                                     // an array of linker indices
  227.                                     // for each segment in the file
  228.     unsigned short  cFName;         // length of source file name
  229.     char            Name;           // name of file padded to long boundary
  230. } OMFSourceFile;
  231.  
  232. typedef OMFSourceFile FAR * LPSF;
  233.  
  234.  
  235. //  Source line to address mapping header structure
  236. //  This structure describes the number and location of the
  237. //  OMFAddrLine tables for a module.  The offSrcLine entries are
  238. //  relative to the beginning of this structure.
  239.  
  240.  
  241. typedef struct OMFSourceModule {
  242.     unsigned short  cFile;          // number of OMFSourceTables
  243.     unsigned short  cSeg;           // number of segments in module
  244.     unsigned long   baseSrcFile[1]; // base of OMFSourceFile table
  245.                                     // this array is followed by array
  246.                                     // of segment start/end pairs followed
  247.                                     // by an array of linker indices
  248.                                     // for each segment in the module
  249. } OMFSourceModule;
  250.  
  251. typedef OMFSourceModule FAR * LPSM;
  252.  
  253. //  sstLibraries
  254.  
  255. typedef struct OMFLibrary {
  256.     unsigned char   cbLibs;     // count of library names
  257.     char            Libs[1];    // array of length prefixed lib names (first entry zero length)
  258. } OMFLibrary;
  259.  
  260.  
  261. // sstFileIndex - An index of all of the files contributing to an
  262. //  executable.
  263.  
  264. typedef struct OMFFileIndex {
  265.     unsigned short  cmodules;       // Number of modules
  266.     unsigned short  cfilerefs;      // Number of file references
  267.     unsigned short  modulelist[1];  // Index to beginning of list of files
  268.                                     // for module i. (0 for module w/o files)
  269.     unsigned short  cfiles[1];      // Number of file names associated
  270.                                     // with module i.
  271.     unsigned long   ulNames[1];     // Offsets from the beginning of this
  272.                                     // table to the file names
  273.     char            Names[];        // The length prefixed names of files
  274. } OMFFileIndex;
  275.  
  276.  
  277. //  Offset mapping table
  278. //  This table provides a mapping from logical to physical offsets.
  279. //  This mapping is applied between the logical to physical mapping
  280. //  described by the seg map table.
  281.  
  282. typedef struct OMFOffsetMap16 {
  283.     unsigned long   csegment;       // Count of physical segments
  284.  
  285.     // The next six items are repeated for each segment
  286.  
  287.     unsigned long   crangeLog;      // Count of logical offset ranges
  288.     unsigned short  rgoffLog[1];    // Array of logical offsets
  289.     short           rgbiasLog[1];   // Array of logical->physical bias
  290.     unsigned long   crangePhys;     // Count of physical offset ranges
  291.     unsigned short  rgoffPhys[1];   // Array of physical offsets
  292.     short           rgbiasPhys[1];  // Array of physical->logical bias
  293. } OMFOffsetMap16;
  294.  
  295. typedef struct OMFOffsetMap32 {
  296.     unsigned long   csection;       // Count of physical sections
  297.  
  298.     // The next six items are repeated for each section
  299.  
  300.     unsigned long   crangeLog;      // Count of logical offset ranges
  301.     unsigned long   rgoffLog[1];    // Array of logical offsets
  302.     long            rgbiasLog[1];   // Array of logical->physical bias
  303.     unsigned long   crangePhys;     // Count of physical offset ranges
  304.     unsigned long   rgoffPhys[1];   // Array of physical offsets
  305.     long            rgbiasPhys[1];  // Array of physical->logical bias
  306. } OMFOffsetMap32;
  307.  
  308. //  Pcode support.  This subsection contains debug information generated
  309. //  by the MPC utility used to process Pcode executables.  Currently
  310. //  it contains a mapping table from segment index (zero based) to
  311. //  frame paragraph.  MPC converts segmented exe's to non-segmented
  312. //  exe's for DOS support.  To avoid backpatching all CV info, this
  313. //  table is provided for the mapping.  Additional info may be provided
  314. //  in the future for profiler support.
  315.  
  316. typedef struct OMFMpcDebugInfo {
  317.     unsigned short  cSeg;           // number of segments in module
  318.     unsigned short  mpSegFrame[1];  // map seg (zero based) to frame
  319. } OMFMpcDebugInfo;
  320.  
  321. //  The following structures and constants describe the format of the
  322. //  CodeView Debug OMF for linkers that emit executables with the NB02
  323. //  signature.  Current utilities with the exception of cvpack and cvdump
  324. //  will not accept or emit executables with the NB02 signature.  Cvdump
  325. //  will dump an unpacked executable with the NB02 signature.  Cvpack will
  326. //  read an executable with the NB02 signature but the packed executable
  327. //  will be written with the table format, contents and signature of NB08.
  328.  
  329.  
  330. //  subsection type constants
  331.  
  332. #define SSTMODULE       0x101    // Basic info. about object module
  333. #define SSTPUBLIC       0x102    // Public symbols
  334. #define SSTTYPES        0x103    // Type information
  335. #define SSTSYMBOLS      0x104    // Symbol Data
  336. #define SSTSRCLINES     0x105    // Source line information
  337. #define SSTLIBRARIES    0x106    // Names of all library files used
  338. #define SSTIMPORTS      0x107    // Symbols for DLL fixups
  339. #define SSTCOMPACTED    0x108    // Compacted types section
  340. #define SSTSRCLNSEG     0x109    // Same as source lines, contains segment
  341.  
  342.  
  343. typedef struct DirEntry{
  344.     unsigned short  SubSectionType;
  345.     unsigned short  ModuleIndex;
  346.     long            lfoStart;
  347.     unsigned short  Size;
  348. } DirEntry;
  349.  
  350.  
  351. //  information decribing each segment in a module
  352.  
  353. typedef struct oldnsg {
  354.     unsigned short  Seg;         // segment index
  355.     unsigned short  Off;         // offset of code in segment
  356.     unsigned short  cbSeg;       // number of bytes in segment
  357. } oldnsg;
  358.  
  359.  
  360. //  old subsection module information
  361.  
  362. typedef struct oldsmd {
  363.     oldnsg          SegInfo;     // describes first segment in module
  364.     unsigned short  ovlNbr;      // overlay number
  365.     unsigned short  iLib;
  366.     unsigned char   cSeg;        // Number of segments in module
  367.     char            reserved;
  368.     unsigned char   cbName[1];   // length prefixed name of module
  369.     oldnsg          arnsg[];     // cSeg-1 structures exist for alloc text or comdat code
  370. } oldsmd;
  371.  
  372. typedef struct{
  373.     unsigned short  Seg;
  374.     unsigned long   Off;
  375.     unsigned long   cbSeg;
  376. } oldnsg32;
  377.  
  378. typedef struct {
  379.     oldnsg32        SegInfo;     // describes first segment in module
  380.     unsigned short  ovlNbr;      // overlay number
  381.     unsigned short  iLib;
  382.     unsigned char   cSeg;        // Number of segments in module
  383.     char            reserved;
  384.     unsigned char   cbName[1];   // length prefixed name of module
  385.     oldnsg32        arnsg[];     // cSeg-1 structures exist for alloc text or comdat code
  386. } oldsmd32;
  387.  
  388. // OMFSegMap - This table contains the mapping between the logical segment indices
  389. // used in the symbol table and the physical segments where the program is loaded
  390.  
  391. typedef struct OMFSegMapDesc {
  392.     unsigned short  flags;       // descriptor flags bit field.
  393.     unsigned short  ovl;         // the logical overlay number
  394.     unsigned short  group;       // group index into the descriptor array
  395.     unsigned short  frame;       // logical segment index - interpreted via flags
  396.     unsigned short  iSegName;    // segment or group name - index into sstSegName
  397.     unsigned short  iClassName;  // class name - index into sstSegName
  398.     unsigned long   offset;      // byte offset of the logical within the physical segment
  399.     unsigned long   cbSeg;       // byte count of the logical segment or group
  400. } OMFSegMapDesc;
  401.  
  402. typedef struct OMFSegMap {
  403.     unsigned short  cSeg;        // total number of segment descriptors
  404.     unsigned short  cSegLog;     // number of logical segment descriptors
  405.     OMFSegMapDesc   rgDesc[0];   // array of segment descriptors
  406. } OMFSegMap;
  407.