Return to cvexefmt.h CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit

Annotation of mstools/samples/sdktools/image/symedit/cvexefmt.h, revision 1.1

1.1     ! root        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: 
        !             9: /***    The master copy of this file resides in the CodeView project.
        !            10:  *      All Microsoft projects are required to use the master copy without
        !            11:  *      modification.  Modification of the master version or a copy
        !            12:  *      without consultation with all parties concerned is extremely
        !            13:  *      risky.
        !            14:  *
        !            15:  */
        !            16: 
        !            17: 
        !            18: 
        !            19: 
        !            20: //  The following structures and constants describe the format of the
        !            21: //  CodeView Debug OMF for that will be accepted by CodeView 4.0 and
        !            22: //  later.  These are executables with signatures of NB05, NB06 and NB07.
        !            23: //  There is some confusion about the signatures NB03 and NB04 so none
        !            24: //  of the utilites will accept executables with these signatures.
        !            25: 
        !            26: //  All of the structures described below must start on a long word boundary
        !            27: //  to maintain natural alignment.  Pad space can be inserted during the
        !            28: //  write operation and the addresses adjusted without affecting the contents
        !            29: //  of the structures.
        !            30: 
        !            31: 
        !            32: //  Type of subsection entry.
        !            33: 
        !            34: #define sstModule           0x120
        !            35: #define sstTypes            0x121
        !            36: #define sstPublic           0x122
        !            37: #define sstPublicSym        0x123   // publics as symbol (waiting for link)
        !            38: #define sstSymbols          0x124
        !            39: #define sstAlignSym         0x125
        !            40: #define sstSrcLnSeg         0x126   // because link doesn't emit SrcModule
        !            41: #define sstSrcModule        0x127
        !            42: #define sstLibraries        0x128
        !            43: #define sstGlobalSym        0x129
        !            44: #define sstGlobalPub        0x12a
        !            45: #define sstGlobalTypes      0x12b
        !            46: #define sstMPC              0x12c
        !            47: #define sstSegMap           0x12d
        !            48: #define sstSegName          0x12e
        !            49: #define sstPreComp          0x12f   // precompiled types
        !            50: #define sstPreCompMap       0x130   // map precompiled types in global types
        !            51: #define sstOffsetMap16      0x131
        !            52: #define sstOffsetMap32      0x132
        !            53: #define sstFileIndex        0x133
        !            54: #define sstStaticSym        0x134
        !            55: 
        !            56: 
        !            57: 
        !            58: typedef enum OMFHash {
        !            59:     OMFHASH_NONE,           // no hashing
        !            60:     OMFHASH_SUMUC16,        // upper case sum of chars in 16 bit table
        !            61:     OMFHASH_SUMUC32,        // upper case sum of chars in 32 bit table
        !            62:     OMFHASH_ADDR16,         // sorted by increasing address in 16 bit table
        !            63:     OMFHASH_ADDR32          // sorted by increasing address in 32 bit table
        !            64: } OMFHASH;
        !            65: 
        !            66: //  CodeView Debug OMF signature.  The signature at the end of the file is
        !            67: //  a negative offset from the end of the file to another signature.  At
        !            68: //  the negative offset (base address) is another signature whose filepos
        !            69: //  field points to the first OMFDirHeader in a chain of directories.
        !            70: //  The NB05 signature is used by the link utility to indicated a completely
        !            71: //  unpacked file.  The NB06 signature is used by ilink to indicate that the
        !            72: //  executable has had CodeView information from an incremental link appended
        !            73: //  to the executable.  The NB07 signature is used by cvpack to indicate that
        !            74: //  the CodeView Debug OMF has been packed.  CodeView will only process
        !            75: //  executables with the NB07 signature.
        !            76: 
        !            77: 
        !            78: typedef struct OMFSignature {
        !            79:     char            Signature[4];   // "NB05", "NB06" or "NB07"
        !            80:     long            filepos;        // offset in file
        !            81: } OMFSignature;
        !            82: 
        !            83: 
        !            84: 
        !            85: //  directory information structure
        !            86: //  This structure contains the information describing the directory.
        !            87: //  It is pointed to by the signature at the base address or the directory
        !            88: //  link field of a preceeding directory.  The directory entries immediately
        !            89: //  follow this structure.
        !            90: 
        !            91: 
        !            92: typedef struct OMFDirHeader {
        !            93:     unsigned short  cbDirHeader;    // length of this structure
        !            94:     unsigned short  cbDirEntry;     // number of bytes in each directory entry
        !            95:     unsigned long   cDir;           // number of directorie entries
        !            96:     long            lfoNextDir;     // offset from base of next directory
        !            97:     unsigned long   flags;          // status flags
        !            98: } OMFDirHeader;
        !            99: 
        !           100: 
        !           101: 
        !           102: 
        !           103: //  directory structure
        !           104: //  The data in this structure is used to reference the data for each
        !           105: //  subsection of the CodeView Debug OMF information.  Tables that are
        !           106: //  not associated with a specific module will have a module index of
        !           107: //  oxffff.  These tables are the global types table, the global symbol
        !           108: //  table, the global public table and the library table.
        !           109: 
        !           110: 
        !           111: typedef struct OMFDirEntry {
        !           112:     unsigned short  SubSection;     // subsection type (sst...)
        !           113:     unsigned short  iMod;           // module index
        !           114:     long            lfo;            // large file offset of subsection
        !           115:     unsigned long   cb;             // number of bytes in subsection
        !           116: } OMFDirEntry;
        !           117: 
        !           118: 
        !           119: 
        !           120: //  information decribing each segment in a module
        !           121: 
        !           122: typedef struct OMFSegDesc {
        !           123:     unsigned short  Seg;            // segment index
        !           124:     unsigned short  pad;            // pad to maintain alignment
        !           125:     unsigned long   Off;            // offset of code in segment
        !           126:     unsigned long   cbSeg;          // number of bytes in segment
        !           127: } OMFSegDesc;
        !           128: 
        !           129: 
        !           130: 
        !           131: 
        !           132: //  per module information
        !           133: //  There is one of these subsection entries for each module
        !           134: //  in the executable.  The entry is generated by link/ilink.
        !           135: //  This table will probably require padding because of the
        !           136: //  variable length module name.
        !           137: 
        !           138: typedef struct OMFModule {
        !           139:     unsigned short  ovlNumber;      // overlay number
        !           140:     unsigned short  iLib;           // library that the module was linked from
        !           141:     unsigned short  cSeg;           // count of number of segments in module
        !           142:     char            Style[2];       // debugging style "CV"
        !           143:     OMFSegDesc      SegInfo[1];     // describes segments in module
        !           144:     char            Name[];         // length prefixed module name padded to
        !           145:                                     // long word boundary
        !           146: } OMFModule;
        !           147: 
        !           148: 
        !           149: 
        !           150: //  Symbol hash table format
        !           151: //  This structure immediately preceeds the global publics table
        !           152: //  and global symbol tables.
        !           153: 
        !           154: typedef struct  OMFSymHash {
        !           155:     unsigned short  symhash;        // symbol hash function index
        !           156:     unsigned short  addrhash;       // address hash function index
        !           157:     unsigned long   cbSymbol;       // length of symbol information
        !           158:     unsigned long   cbHSym;         // length of symbol hash data
        !           159:     unsigned long   cbHAddr;        // length of address hashdata
        !           160: } OMFSymHash;
        !           161: 
        !           162: 
        !           163: 
        !           164: //  Global types subsection format
        !           165: //  This structure immediately preceeds the global types table.
        !           166: //  The offsets in the typeOffset array are relative to the address
        !           167: //  of ctypes.  Each type entry following the typeOffset array must
        !           168: //  begin on a long word boundary.
        !           169: 
        !           170: typedef struct OMFTypeFlags {
        !           171:     unsigned long   sig     :8;
        !           172:     unsigned long   unused  :24;
        !           173: } OMFTypeFlags;
        !           174: 
        !           175: 
        !           176: typedef struct OMFGlobalTypes {
        !           177:     OMFTypeFlags    flags;
        !           178:     unsigned long   cTypes;         // number of types
        !           179:     unsigned long   typeOffset[];   // array of offsets to types
        !           180: } OMFGlobalTypes;
        !           181: 
        !           182: 
        !           183: 
        !           184: 
        !           185: //  Precompiled types mapping table
        !           186: //  This table should be ignored by all consumers except the incremental
        !           187: //  packer.
        !           188: 
        !           189: 
        !           190: typedef struct OMFPreCompMap {
        !           191:     unsigned short  FirstType;      // first precompiled type index
        !           192:     unsigned short  cTypes;         // number of precompiled types
        !           193:     unsigned long   signature;      // precompiled types signature
        !           194:     unsigned short  pad;
        !           195:     CV_typ_t        map[];          // mapping of precompiled types
        !           196: } OMFPreCompMap;
        !           197: 
        !           198: 
        !           199: 
        !           200: 
        !           201: //  Source line to address mapping table.
        !           202: //  This table is generated by the link/ilink utility from line number
        !           203: //  information contained in the object file OMF data.  This table contains
        !           204: //  only the code contribution for one segment from one source file.
        !           205: 
        !           206: 
        !           207: typedef struct OMFSourceLine {
        !           208:     unsigned short  Seg;            // linker segment index
        !           209:     unsigned short  cLnOff;         // count of line/offset pairs
        !           210:     unsigned long   offset[1];      // array of offsets in segment
        !           211:     unsigned short  lineNbr[1];     // array of line lumber in source
        !           212: } OMFSourceLine;
        !           213: 
        !           214: typedef OMFSourceLine FAR * LPSL;
        !           215: 
        !           216: 
        !           217: //  Source file description
        !           218: //  This table is generated by the linker
        !           219: 
        !           220: 
        !           221: typedef struct OMFSourceFile {
        !           222:     unsigned short  cSeg;           // number of segments from source file
        !           223:     unsigned short  reserved;       // reserved
        !           224:     unsigned long   baseSrcLn[1];   // base of OMFSourceLine tables
        !           225:                                     // this array is followed by array
        !           226:                                     // of segment start/end pairs followed by
        !           227:                                     // an array of linker indices
        !           228:                                     // for each segment in the file
        !           229:     unsigned short  cFName;         // length of source file name
        !           230:     char            Name;           // name of file padded to long boundary
        !           231: } OMFSourceFile;
        !           232: 
        !           233: typedef OMFSourceFile FAR * LPSF;
        !           234: 
        !           235: 
        !           236: //  Source line to address mapping header structure
        !           237: //  This structure describes the number and location of the
        !           238: //  OMFAddrLine tables for a module.  The offSrcLine entries are
        !           239: //  relative to the beginning of this structure.
        !           240: 
        !           241: 
        !           242: typedef struct OMFSourceModule {
        !           243:     unsigned short  cFile;          // number of OMFSourceTables
        !           244:     unsigned short  cSeg;           // number of segments in module
        !           245:     unsigned long   baseSrcFile[1]; // base of OMFSourceFile table
        !           246:                                     // this array is followed by array
        !           247:                                     // of segment start/end pairs followed
        !           248:                                     // by an array of linker indices
        !           249:                                     // for each segment in the module
        !           250: } OMFSourceModule;
        !           251: 
        !           252: typedef OMFSourceModule FAR * LPSM;
        !           253: 
        !           254: //  sstLibraries
        !           255: 
        !           256: typedef struct OMFLibrary {
        !           257:     unsigned char   cbLibs;     // count of library names
        !           258:     char            Libs[1];    // array of length prefixed lib names (first entry zero length)
        !           259: } OMFLibrary;
        !           260: 
        !           261: 
        !           262: //  Pcode support.  This subsection contains debug information generated
        !           263: //  by the MPC utility used to process Pcode executables.  Currently
        !           264: //  it contains a mapping table from segment index (zero based) to 
        !           265: //  frame paragraph.  MPC converts segmented exe's to non-segmented
        !           266: //  exe's for DOS support.  To avoid backpatching all CV info, this
        !           267: //  table is provided for the mapping.  Additional info may be provided
        !           268: //  in the future for profiler support.
        !           269: 
        !           270: typedef struct OMFMpcDebugInfo {
        !           271:     unsigned short  cSeg;       // number of segments in module
        !           272:     unsigned short  mpSegFrame[1];  // map seg (zero based) to frame 
        !           273: } OMFMpcDebugInfo;
        !           274: 
        !           275: //  The following structures and constants describe the format of the
        !           276: //  CodeView Debug OMF for linkers that emit executables with the NB02
        !           277: //  signature.  Current utilities with the exception of cvpack and cvdump
        !           278: //  will not accept or emit executables with the NB02 signature.  Cvdump
        !           279: //  will dump an unpacked executable with the NB02 signature.  Cvpack will
        !           280: //  read an executable with the NB02 signature but the packed executable
        !           281: //  will be written with the table format, contents and signature of NB07.
        !           282: 
        !           283: 
        !           284: 
        !           285: 
        !           286: 
        !           287: //  subsection type constants
        !           288: 
        !           289: #define SSTMODULE       0x101   // Basic info. about object module
        !           290: #define SSTPUBLIC       0x102   // Public symbols
        !           291: #define SSTTYPES        0x103   // Type information
        !           292: #define SSTSYMBOLS      0x104   // Symbol Data
        !           293: #define SSTSRCLINES     0x105   // Source line information
        !           294: #define SSTLIBRARIES    0x106   // Names of all library files used
        !           295: #define SSTIMPORTS      0x107   // Symbols for DLL fixups
        !           296: #define SSTCOMPACTED    0x108   // Compacted types section
        !           297: #define SSTSRCLNSEG     0x109   // Same as source lines, contains segment
        !           298: 
        !           299: 
        !           300: typedef struct DirEntry{
        !           301:     unsigned short  SubSectionType;
        !           302:     unsigned short  ModuleIndex;
        !           303:     long            lfoStart;
        !           304:     unsigned short  Size;
        !           305: } DirEntry;
        !           306: 
        !           307: 
        !           308: //  information decribing each segment in a module
        !           309: 
        !           310: typedef struct oldnsg {
        !           311:     unsigned short  Seg;            // segment index
        !           312:     unsigned short  Off;            // offset of code in segment
        !           313:     unsigned short  cbSeg;          // number of bytes in segment
        !           314: } oldnsg;
        !           315: 
        !           316: 
        !           317: //   old subsection module information
        !           318: 
        !           319: typedef struct oldsmd {
        !           320:     oldnsg          SegInfo;        // describes first segment in module
        !           321:     unsigned short  ovlNbr;         // overlay number
        !           322:     unsigned short  iLib;
        !           323:     unsigned char   cSeg;           // Number of segments in module
        !           324:     char            reserved;
        !           325:     unsigned char   cbName[1];      // length prefixed name of module
        !           326:     oldnsg          arnsg[];        // cSeg-1 structures exist for alloc text or comdat code
        !           327: } oldsmd;
        !           328: 
        !           329: typedef struct{
        !           330:     unsigned short  Seg;
        !           331:     unsigned long   Off;
        !           332:     unsigned long   cbSeg;
        !           333: } oldnsg32;
        !           334: 
        !           335: typedef struct {
        !           336:     oldnsg32        SegInfo;        // describes first segment in module
        !           337:     unsigned short  ovlNbr;         // overlay number
        !           338:     unsigned short  iLib;
        !           339:     unsigned char   cSeg;           // Number of segments in module
        !           340:     char            reserved;
        !           341:     unsigned char   cbName[1];      // length prefixed name of module
        !           342:     oldnsg32        arnsg[];        // cSeg-1 structures exist for alloc text or comdat code
        !           343: } oldsmd32;

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.