//----------------------------------------------------------------------------- // // Copyright (C) Microsoft Corporation. All Rights Reserved. // //----------------------------------------------------------------------------- // // File: CvInfo.cs // // Generic CodeView information definitions // // Structures, constants, etc. for accessing and interpreting // CodeView information. // // The master copy of this file resides in the langapi project (in C++). // All Microsoft projects are required to use the master copy without // modification. Modification of the master version or a copy // without consultation with all parties concerned is extremely // risky. // // When this file is modified, the corresponding documentation file // omfdeb.doc in the langapi project must be updated. // // This is a read-only copy of the C++ file converted to C#. // using System; namespace Microsoft.Cci.Pdb { internal struct FLOAT10 { internal byte Data_0; internal byte Data_1; internal byte Data_2; internal byte Data_3; internal byte Data_4; internal byte Data_5; internal byte Data_6; internal byte Data_7; internal byte Data_8; internal byte Data_9; }; internal enum CV_SIGNATURE { C6=0, // Actual signature is >64K C7=1, // First explicit signature C11=2, // C11 (vc5.x) 32-bit types C13=4, // C13 (vc7.x) zero terminated names RESERVERD=5, // All signatures from 5 to 64K are reserved }; // CodeView Symbol and Type OMF type information is broken up into two // ranges. Type indices less than 0x1000 describe type information // that is frequently used. Type indices above 0x1000 are used to // describe more complex features such as functions, arrays and // structures. // // Primitive types have predefined meaning that is encoded in the // values of the various bit fields in the value. // // A CodeView primitive type is defined as: // // 1 1 // 1 089 7654 3 210 // r mode type r sub // // Where // mode is the pointer mode // type is a type indicator // sub is a subtype enumeration // r is a reserved field // // See Microsoft Symbol and Type OMF (Version 4.0) for more // information. // // pointer mode enumeration values internal enum CV_prmode { CV_TM_DIRECT=0, // mode is not a pointer CV_TM_NPTR32=4, // mode is a 32 bit near pointer CV_TM_NPTR64=6, // mode is a 64 bit near pointer CV_TM_NPTR128=7, // mode is a 128 bit near pointer }; // type enumeration values internal enum CV_type { CV_SPECIAL=0x00, // special type size values CV_SIGNED=0x01, // signed integral size values CV_UNSIGNED=0x02, // unsigned integral size values CV_BOOLEAN=0x03, // Boolean size values CV_REAL=0x04, // real number size values CV_COMPLEX=0x05, // complex number size values CV_SPECIAL2=0x06, // second set of special types CV_INT=0x07, // integral (int) values CV_CVRESERVED=0x0f, }; // subtype enumeration values for CV_SPECIAL internal enum CV_special { CV_SP_NOTYPE=0x00, CV_SP_ABS=0x01, CV_SP_SEGMENT=0x02, CV_SP_VOID=0x03, CV_SP_CURRENCY=0x04, CV_SP_NBASICSTR=0x05, CV_SP_FBASICSTR=0x06, CV_SP_NOTTRANS=0x07, CV_SP_HRESULT=0x08, }; // subtype enumeration values for CV_SPECIAL2 internal enum CV_special2 { CV_S2_BIT=0x00, CV_S2_PASCHAR=0x01, // Pascal CHAR }; // subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN internal enum CV_integral { CV_IN_1BYTE=0x00, CV_IN_2BYTE=0x01, CV_IN_4BYTE=0x02, CV_IN_8BYTE=0x03, CV_IN_16BYTE=0x04, }; // subtype enumeration values for CV_REAL and CV_COMPLEX internal enum CV_real { CV_RC_REAL32=0x00, CV_RC_REAL64=0x01, CV_RC_REAL80=0x02, CV_RC_REAL128=0x03, }; // subtype enumeration values for CV_INT (really int) internal enum CV_int { CV_RI_CHAR=0x00, CV_RI_INT1=0x00, CV_RI_WCHAR=0x01, CV_RI_UINT1=0x01, CV_RI_INT2=0x02, CV_RI_UINT2=0x03, CV_RI_INT4=0x04, CV_RI_UINT4=0x05, CV_RI_INT8=0x06, CV_RI_UINT8=0x07, CV_RI_INT16=0x08, CV_RI_UINT16=0x09, }; internal struct CV_PRIMITIVE_TYPE { const uint CV_MMASK = 0x700; // mode mask const uint CV_TMASK = 0x0f0; // type mask const uint CV_SMASK = 0x00f; // subtype mask const int CV_MSHIFT = 8; // primitive mode right shift count const int CV_TSHIFT = 4; // primitive type right shift count const int CV_SSHIFT = 0; // primitive subtype right shift count // function to extract primitive mode, type and size internal static CV_prmode CV_MODE(TYPE_ENUM typ) { return (CV_prmode)((((uint)typ) & CV_MMASK) >> CV_MSHIFT); } internal static CV_type CV_TYPE(TYPE_ENUM typ) { return (CV_type)((((uint)typ) & CV_TMASK) >> CV_TSHIFT); } internal static uint CV_SUBT(TYPE_ENUM typ) { return ((((uint)typ) & CV_SMASK) >> CV_SSHIFT); } // functions to check the type of a primitive internal static bool CV_TYP_IS_DIRECT(TYPE_ENUM typ) { return (CV_MODE(typ) == CV_prmode.CV_TM_DIRECT); } internal static bool CV_TYP_IS_PTR(TYPE_ENUM typ) { return (CV_MODE(typ) != CV_prmode.CV_TM_DIRECT); } internal static bool CV_TYP_IS_SIGNED(TYPE_ENUM typ) { return (((CV_TYPE(typ) == CV_type.CV_SIGNED) && CV_TYP_IS_DIRECT(typ)) || (typ == TYPE_ENUM.T_INT1) || (typ == TYPE_ENUM.T_INT2) || (typ == TYPE_ENUM.T_INT4) || (typ == TYPE_ENUM.T_INT8) || (typ == TYPE_ENUM.T_INT16) || (typ == TYPE_ENUM.T_RCHAR)); } internal static bool CV_TYP_IS_UNSIGNED(TYPE_ENUM typ) { return (((CV_TYPE(typ) == CV_type.CV_UNSIGNED) && CV_TYP_IS_DIRECT(typ)) || (typ == TYPE_ENUM.T_UINT1) || (typ == TYPE_ENUM.T_UINT2) || (typ == TYPE_ENUM.T_UINT4) || (typ == TYPE_ENUM.T_UINT8) || (typ == TYPE_ENUM.T_UINT16)); } internal static bool CV_TYP_IS_REAL(TYPE_ENUM typ) { return ((CV_TYPE(typ) == CV_type.CV_REAL) && CV_TYP_IS_DIRECT(typ)); } const uint CV_FIRST_NONPRIM = 0x1000; internal static bool CV_IS_PRIMITIVE(TYPE_ENUM typ) { return ((uint)(typ) < CV_FIRST_NONPRIM); } internal static bool CV_TYP_IS_COMPLEX(TYPE_ENUM typ) { return ((CV_TYPE(typ) == CV_type.CV_COMPLEX) && CV_TYP_IS_DIRECT(typ)); } internal static bool CV_IS_INTERNAL_PTR(TYPE_ENUM typ) { return (CV_IS_PRIMITIVE(typ) && CV_TYPE(typ) == CV_type.CV_CVRESERVED && CV_TYP_IS_PTR(typ)); } } // selected values for type_index - for a more complete definition, see // Microsoft Symbol and Type OMF document // Special Types internal enum TYPE_ENUM { // Special Types T_NOTYPE=0x0000, // uncharacterized type (no type) T_ABS=0x0001, // absolute symbol T_SEGMENT=0x0002, // segment type T_VOID=0x0003, // void T_HRESULT=0x0008, // OLE/COM HRESULT T_32PHRESULT=0x0408, // OLE/COM HRESULT __ptr32// T_64PHRESULT=0x0608, // OLE/COM HRESULT __ptr64// T_PVOID=0x0103, // near pointer to void T_PFVOID=0x0203, // far pointer to void T_PHVOID=0x0303, // huge pointer to void T_32PVOID=0x0403, // 32 bit pointer to void T_64PVOID=0x0603, // 64 bit pointer to void T_CURRENCY=0x0004, // BASIC 8 byte currency value T_NOTTRANS=0x0007, // type not translated by cvpack T_BIT=0x0060, // bit T_PASCHAR=0x0061, // Pascal CHAR // Character types T_CHAR=0x0010, // 8 bit signed T_32PCHAR=0x0410, // 32 bit pointer to 8 bit signed T_64PCHAR=0x0610, // 64 bit pointer to 8 bit signed T_UCHAR=0x0020, // 8 bit unsigned T_32PUCHAR=0x0420, // 32 bit pointer to 8 bit unsigned T_64PUCHAR=0x0620, // 64 bit pointer to 8 bit unsigned // really a character types T_RCHAR=0x0070, // really a char T_32PRCHAR=0x0470, // 32 bit pointer to a real char T_64PRCHAR=0x0670, // 64 bit pointer to a real char // really a wide character types T_WCHAR=0x0071, // wide char T_32PWCHAR=0x0471, // 32 bit pointer to a wide char T_64PWCHAR=0x0671, // 64 bit pointer to a wide char // 8 bit int types T_INT1=0x0068, // 8 bit signed int T_32PINT1=0x0468, // 32 bit pointer to 8 bit signed int T_64PINT1=0x0668, // 64 bit pointer to 8 bit signed int T_UINT1=0x0069, // 8 bit unsigned int T_32PUINT1=0x0469, // 32 bit pointer to 8 bit unsigned int T_64PUINT1=0x0669, // 64 bit pointer to 8 bit unsigned int // 16 bit short types T_SHORT=0x0011, // 16 bit signed T_32PSHORT=0x0411, // 32 bit pointer to 16 bit signed T_64PSHORT=0x0611, // 64 bit pointer to 16 bit signed T_USHORT=0x0021, // 16 bit unsigned T_32PUSHORT=0x0421, // 32 bit pointer to 16 bit unsigned T_64PUSHORT=0x0621, // 64 bit pointer to 16 bit unsigned // 16 bit int types T_INT2=0x0072, // 16 bit signed int T_32PINT2=0x0472, // 32 bit pointer to 16 bit signed int T_64PINT2=0x0672, // 64 bit pointer to 16 bit signed int T_UINT2=0x0073, // 16 bit unsigned int T_32PUINT2=0x0473, // 32 bit pointer to 16 bit unsigned int T_64PUINT2=0x0673, // 64 bit pointer to 16 bit unsigned int // 32 bit long types T_LONG=0x0012, // 32 bit signed T_ULONG=0x0022, // 32 bit unsigned T_32PLONG=0x0412, // 32 bit pointer to 32 bit signed T_32PULONG=0x0422, // 32 bit pointer to 32 bit unsigned T_64PLONG=0x0612, // 64 bit pointer to 32 bit signed T_64PULONG=0x0622, // 64 bit pointer to 32 bit unsigned // 32 bit int types T_INT4=0x0074, // 32 bit signed int T_32PINT4=0x0474, // 32 bit pointer to 32 bit signed int T_64PINT4=0x0674, // 64 bit pointer to 32 bit signed int T_UINT4=0x0075, // 32 bit unsigned int T_32PUINT4=0x0475, // 32 bit pointer to 32 bit unsigned int T_64PUINT4=0x0675, // 64 bit pointer to 32 bit unsigned int // 64 bit quad types T_QUAD=0x0013, // 64 bit signed T_32PQUAD=0x0413, // 32 bit pointer to 64 bit signed T_64PQUAD=0x0613, // 64 bit pointer to 64 bit signed T_UQUAD=0x0023, // 64 bit unsigned T_32PUQUAD=0x0423, // 32 bit pointer to 64 bit unsigned T_64PUQUAD=0x0623, // 64 bit pointer to 64 bit unsigned // 64 bit int types T_INT8=0x0076, // 64 bit signed int T_32PINT8=0x0476, // 32 bit pointer to 64 bit signed int T_64PINT8=0x0676, // 64 bit pointer to 64 bit signed int T_UINT8=0x0077, // 64 bit unsigned int T_32PUINT8=0x0477, // 32 bit pointer to 64 bit unsigned int T_64PUINT8=0x0677, // 64 bit pointer to 64 bit unsigned int // 128 bit octet types T_OCT=0x0014, // 128 bit signed T_32POCT=0x0414, // 32 bit pointer to 128 bit signed T_64POCT=0x0614, // 64 bit pointer to 128 bit signed T_UOCT=0x0024, // 128 bit unsigned T_32PUOCT=0x0424, // 32 bit pointer to 128 bit unsigned T_64PUOCT=0x0624, // 64 bit pointer to 128 bit unsigned // 128 bit int types T_INT16=0x0078, // 128 bit signed int T_32PINT16=0x0478, // 32 bit pointer to 128 bit signed int T_64PINT16=0x0678, // 64 bit pointer to 128 bit signed int T_UINT16=0x0079, // 128 bit unsigned int T_32PUINT16=0x0479, // 32 bit pointer to 128 bit unsigned int T_64PUINT16=0x0679, // 64 bit pointer to 128 bit unsigned int // 32 bit real types T_REAL32=0x0040, // 32 bit real T_32PREAL32=0x0440, // 32 bit pointer to 32 bit real T_64PREAL32=0x0640, // 64 bit pointer to 32 bit real // 64 bit real types T_REAL64=0x0041, // 64 bit real T_32PREAL64=0x0441, // 32 bit pointer to 64 bit real T_64PREAL64=0x0641, // 64 bit pointer to 64 bit real // 80 bit real types T_REAL80=0x0042, // 80 bit real T_32PREAL80=0x0442, // 32 bit pointer to 80 bit real T_64PREAL80=0x0642, // 64 bit pointer to 80 bit real // 128 bit real types T_REAL128=0x0043, // 128 bit real T_32PREAL128=0x0443, // 32 bit pointer to 128 bit real T_64PREAL128=0x0643, // 64 bit pointer to 128 bit real // 32 bit complex types T_CPLX32=0x0050, // 32 bit complex T_32PCPLX32=0x0450, // 32 bit pointer to 32 bit complex T_64PCPLX32=0x0650, // 64 bit pointer to 32 bit complex // 64 bit complex types T_CPLX64=0x0051, // 64 bit complex T_32PCPLX64=0x0451, // 32 bit pointer to 64 bit complex T_64PCPLX64=0x0651, // 64 bit pointer to 64 bit complex // 80 bit complex types T_CPLX80=0x0052, // 80 bit complex T_32PCPLX80=0x0452, // 32 bit pointer to 80 bit complex T_64PCPLX80=0x0652, // 64 bit pointer to 80 bit complex // 128 bit complex types T_CPLX128=0x0053, // 128 bit complex T_32PCPLX128=0x0453, // 32 bit pointer to 128 bit complex T_64PCPLX128=0x0653, // 64 bit pointer to 128 bit complex // boolean types T_BOOL08=0x0030, // 8 bit boolean T_32PBOOL08=0x0430, // 32 bit pointer to 8 bit boolean T_64PBOOL08=0x0630, // 64 bit pointer to 8 bit boolean T_BOOL16=0x0031, // 16 bit boolean T_32PBOOL16=0x0431, // 32 bit pointer to 18 bit boolean T_64PBOOL16=0x0631, // 64 bit pointer to 18 bit boolean T_BOOL32=0x0032, // 32 bit boolean T_32PBOOL32=0x0432, // 32 bit pointer to 32 bit boolean T_64PBOOL32=0x0632, // 64 bit pointer to 32 bit boolean T_BOOL64=0x0033, // 64 bit boolean T_32PBOOL64=0x0433, // 32 bit pointer to 64 bit boolean T_64PBOOL64=0x0633, // 64 bit pointer to 64 bit boolean }; // No leaf index can have a value of 0x0000. The leaf indices are // separated into ranges depending upon the use of the type record. // The second range is for the type records that are directly referenced // in symbols. The first range is for type records that are not // referenced by symbols but instead are referenced by other type // records. All type records must have a starting leaf index in these // first two ranges. The third range of leaf indices are used to build // up complex lists such as the field list of a class type record. No // type record can begin with one of the leaf indices. The fourth ranges // of type indices are used to represent numeric data in a symbol or // type record. These leaf indices are greater than 0x8000. At the // point that type or symbol processor is expecting a numeric field, the // next two bytes in the type record are examined. If the value is less // than 0x8000, then the two bytes contain the numeric value. If the // value is greater than 0x8000, then the data follows the leaf index in // a format specified by the leaf index. The final range of leaf indices // are used to force alignment of subfields within a complex type record.. // internal enum LEAF { // leaf indices starting records but referenced from symbol records LF_VTSHAPE=0x000a, LF_COBOL1=0x000c, LF_LABEL=0x000e, LF_NULL=0x000f, LF_NOTTRAN=0x0010, LF_ENDPRECOMP=0x0014, // not referenced from symbol LF_TYPESERVER_ST=0x0016, // not referenced from symbol // leaf indices starting records but referenced only from type records LF_LIST=0x0203, LF_REFSYM=0x020c, LF_ENUMERATE_ST=0x0403, // 32-bit type index versions of leaves, all have the 0x1000 bit set // LF_TI16_MAX=0x1000, LF_MODIFIER=0x1001, LF_POINTER=0x1002, LF_ARRAY_ST=0x1003, LF_CLASS_ST=0x1004, LF_STRUCTURE_ST=0x1005, LF_UNION_ST=0x1006, LF_ENUM_ST=0x1007, LF_PROCEDURE=0x1008, LF_MFUNCTION=0x1009, LF_COBOL0=0x100a, LF_BARRAY=0x100b, LF_DIMARRAY_ST=0x100c, LF_VFTPATH=0x100d, LF_PRECOMP_ST=0x100e, // not referenced from symbol LF_OEM=0x100f, // oem definable type string LF_ALIAS_ST=0x1010, // alias (typedef) type LF_OEM2=0x1011, // oem definable type string // leaf indices starting records but referenced only from type records LF_SKIP=0x1200, LF_ARGLIST=0x1201, LF_DEFARG_ST=0x1202, LF_FIELDLIST=0x1203, LF_DERIVED=0x1204, LF_BITFIELD=0x1205, LF_METHODLIST=0x1206, LF_DIMCONU=0x1207, LF_DIMCONLU=0x1208, LF_DIMVARU=0x1209, LF_DIMVARLU=0x120a, LF_BCLASS=0x1400, LF_VBCLASS=0x1401, LF_IVBCLASS=0x1402, LF_FRIENDFCN_ST=0x1403, LF_INDEX=0x1404, LF_MEMBER_ST=0x1405, LF_STMEMBER_ST=0x1406, LF_METHOD_ST=0x1407, LF_NESTTYPE_ST=0x1408, LF_VFUNCTAB=0x1409, LF_FRIENDCLS=0x140a, LF_ONEMETHOD_ST=0x140b, LF_VFUNCOFF=0x140c, LF_NESTTYPEEX_ST=0x140d, LF_MEMBERMODIFY_ST=0x140e, LF_MANAGED_ST=0x140f, // Types w/ SZ names LF_ST_MAX=0x1500, LF_TYPESERVER=0x1501, // not referenced from symbol LF_ENUMERATE=0x1502, LF_ARRAY=0x1503, LF_CLASS=0x1504, LF_STRUCTURE=0x1505, LF_UNION=0x1506, LF_ENUM=0x1507, LF_DIMARRAY=0x1508, LF_PRECOMP=0x1509, // not referenced from symbol LF_ALIAS=0x150a, // alias (typedef) type LF_DEFARG=0x150b, LF_FRIENDFCN=0x150c, LF_MEMBER=0x150d, LF_STMEMBER=0x150e, LF_METHOD=0x150f, LF_NESTTYPE=0x1510, LF_ONEMETHOD=0x1511, LF_NESTTYPEEX=0x1512, LF_MEMBERMODIFY=0x1513, LF_MANAGED=0x1514, LF_TYPESERVER2=0x1515, LF_NUMERIC=0x8000, LF_CHAR=0x8000, LF_SHORT=0x8001, LF_USHORT=0x8002, LF_LONG=0x8003, LF_ULONG=0x8004, LF_REAL32=0x8005, LF_REAL64=0x8006, LF_REAL80=0x8007, LF_REAL128=0x8008, LF_QUADWORD=0x8009, LF_UQUADWORD=0x800a, LF_COMPLEX32=0x800c, LF_COMPLEX64=0x800d, LF_COMPLEX80=0x800e, LF_COMPLEX128=0x800f, LF_VARSTRING=0x8010, LF_OCTWORD=0x8017, LF_UOCTWORD=0x8018, LF_DECIMAL=0x8019, LF_DATE=0x801a, LF_UTF8STRING=0x801b, LF_PAD0=0xf0, LF_PAD1=0xf1, LF_PAD2=0xf2, LF_PAD3=0xf3, LF_PAD4=0xf4, LF_PAD5=0xf5, LF_PAD6=0xf6, LF_PAD7=0xf7, LF_PAD8=0xf8, LF_PAD9=0xf9, LF_PAD10=0xfa, LF_PAD11=0xfb, LF_PAD12=0xfc, LF_PAD13=0xfd, LF_PAD14=0xfe, LF_PAD15=0xff, }; // end of leaf indices // Type enum for pointer records // Pointers can be one of the following types internal enum CV_ptrtype { CV_PTR_BASE_SEG=0x03, // based on segment CV_PTR_BASE_VAL=0x04, // based on value of base CV_PTR_BASE_SEGVAL=0x05, // based on segment value of base CV_PTR_BASE_ADDR=0x06, // based on address of base CV_PTR_BASE_SEGADDR=0x07, // based on segment address of base CV_PTR_BASE_TYPE=0x08, // based on type CV_PTR_BASE_SELF=0x09, // based on self CV_PTR_NEAR32=0x0a, // 32 bit pointer CV_PTR_64=0x0c, // 64 bit pointer CV_PTR_UNUSEDPTR=0x0d // first unused pointer type }; // Mode enum for pointers // Pointers can have one of the following modes internal enum CV_ptrmode { CV_PTR_MODE_PTR=0x00, // "normal" pointer CV_PTR_MODE_REF=0x01, // reference CV_PTR_MODE_PMEM=0x02, // pointer to data member CV_PTR_MODE_PMFUNC=0x03, // pointer to member function CV_PTR_MODE_RESERVED=0x04 // first unused pointer mode }; // enumeration for pointer-to-member types internal enum CV_pmtype { CV_PMTYPE_Undef=0x00, // not specified (pre VC8) CV_PMTYPE_D_Single=0x01, // member data, single inheritance CV_PMTYPE_D_Multiple=0x02, // member data, multiple inheritance CV_PMTYPE_D_Virtual=0x03, // member data, virtual inheritance CV_PMTYPE_D_General=0x04, // member data, most general CV_PMTYPE_F_Single=0x05, // member function, single inheritance CV_PMTYPE_F_Multiple=0x06, // member function, multiple inheritance CV_PMTYPE_F_Virtual=0x07, // member function, virtual inheritance CV_PMTYPE_F_General=0x08, // member function, most general }; // enumeration for method properties internal enum CV_methodprop { CV_MTvanilla=0x00, CV_MTvirtual=0x01, CV_MTstatic=0x02, CV_MTfriend=0x03, CV_MTintro=0x04, CV_MTpurevirt=0x05, CV_MTpureintro=0x06 }; // enumeration for virtual shape table entries internal enum CV_VTS_desc { CV_VTS_near=0x00, CV_VTS_far=0x01, CV_VTS_thin=0x02, CV_VTS_outer=0x03, CV_VTS_meta=0x04, CV_VTS_near32=0x05, CV_VTS_far32=0x06, CV_VTS_unused=0x07 }; // enumeration for LF_LABEL address modes internal enum CV_LABEL_TYPE { CV_LABEL_NEAR=0, // near return CV_LABEL_FAR=4 // far return }; // enumeration for LF_MODIFIER values [Flags] internal enum CV_modifier : ushort { MOD_const=0x0001, MOD_volatile=0x0002, MOD_unaligned=0x0004, }; // bit field structure describing class/struct/union/enum properties [Flags] internal enum CV_prop : ushort { packed=0x0001, // true if structure is packed ctor=0x0002, // true if constructors or destructors present ovlops=0x0004, // true if overloaded operators present isnested=0x0008, // true if this is a nested class cnested=0x0010, // true if this class contains nested types opassign=0x0020, // true if overloaded assignment (=) opcast=0x0040, // true if casting methods fwdref=0x0080, // true if forward reference (incomplete defn) scoped=0x0100, // scoped definition } // class field attribute [Flags] internal enum CV_fldattr { access=0x0003, // access protection CV_access_t mprop=0x001c, // method properties CV_methodprop_t pseudo=0x0020, // compiler generated fcn and does not exist noinherit=0x0040, // true if class cannot be inherited noconstruct=0x0080, // true if class cannot be constructed compgenx=0x0100, // compiler generated fcn and does exist } // Structures to access to the type records internal struct TYPTYPE { internal ushort len; internal ushort leaf; // byte data[]; // char *NextType (char * pType) { // return (pType + ((TYPTYPE *)pType)->len + sizeof(ushort)); // } }; // general types record // memory representation of pointer to member. These representations are // indexed by the enumeration above in the LF_POINTER record // representation of a 32 bit pointer to data for a class with // or without virtual functions and no virtual bases internal struct CV_PDMR32_NVVFCN { internal int mdisp; // displacement to data (NULL = 0x80000000) }; // representation of a 32 bit pointer to data for a class // with virtual bases internal struct CV_PDMR32_VBASE { internal int mdisp; // displacement to data internal int pdisp; // this pointer displacement internal int vdisp; // vbase table displacement // NULL = (,,0xffffffff) }; // representation of a 32 bit pointer to member function for a // class with no virtual bases and a single address point internal struct CV_PMFR32_NVSA { internal uint off; // near address of function (NULL = 0L) }; // representation of a 32 bit pointer to member function for a // class with no virtual bases and multiple address points internal struct CV_PMFR32_NVMA { internal uint off; // near address of function (NULL = 0L,x) internal int disp; }; // representation of a 32 bit pointer to member function for a // class with virtual bases internal struct CV_PMFR32_VBASE { internal uint off; // near address of function (NULL = 0L,x,x,x) internal int mdisp; // displacement to data internal int pdisp; // this pointer displacement internal int vdisp; // vbase table displacement }; ////////////////////////////////////////////////////////////////////////////// // // The following type records are basically variant records of the // above structure. The "ushort leaf" of the above structure and // the "ushort leaf" of the following type definitions are the same // symbol. // // Notes on alignment // Alignment of the fields in most of the type records is done on the // basis of the TYPTYPE record base. That is why in most of the lf* // records that the type is located on what appears to // be a offset mod 4 == 2 boundary. The exception to this rule are those // records that are in a list (lfFieldList, lfMethodList), which are // aligned to their own bases since they don't have the length field // // Type record for LF_MODIFIER internal struct LeafModifier { // internal ushort leaf; // LF_MODIFIER [TYPTYPE] internal uint type; // (type index) modified type internal CV_modifier attr; // modifier attribute modifier_t }; // type record for LF_POINTER [Flags] internal enum LeafPointerAttr : uint { ptrtype=0x0000001f, // ordinal specifying pointer type (CV_ptrtype) ptrmode=0x000000e0, // ordinal specifying pointer mode (CV_ptrmode) isflat32=0x00000100, // true if 0:32 pointer isvolatile=0x00000200, // TRUE if volatile pointer isconst=0x00000400, // TRUE if const pointer isunaligned=0x00000800, // TRUE if unaligned pointer isrestrict=0x00001000, // TRUE if restricted pointer (allow agressive opts) }; internal struct LeafPointer { internal struct LeafPointerBody { // internal ushort leaf; // LF_POINTER [TYPTYPE] internal uint utype; // (type index) type index of the underlying type internal LeafPointerAttr attr; }; #if false union { internal struct { uint pmclass; // (type index) index of containing class for pointer to member ushort pmenum; // enumeration specifying pm format (CV_pmtype) }; ushort bseg; // base segment if PTR_BASE_SEG byte[] Sym; // copy of base symbol record (including length) internal struct { uint index; // (type index) type index if CV_PTR_BASE_TYPE string name; // name of base type } btype; } pbase; #endif } // type record for LF_ARRAY internal struct LeafArray { // internal ushort leaf; // LF_ARRAY [TYPTYPE] internal uint elemtype; // (type index) type index of element type internal uint idxtype; // (type index) type index of indexing type internal byte[] data; // variable length data specifying size in bytes internal string name; }; // type record for LF_CLASS, LF_STRUCTURE internal struct LeafClass { // internal ushort leaf; // LF_CLASS, LF_STRUCT [TYPTYPE] internal ushort count; // count of number of elements in class internal ushort property; // (CV_prop_t) property attribute field (prop_t) internal uint field; // (type index) type index of LF_FIELD descriptor list internal uint derived; // (type index) type index of derived from list if not zero internal uint vshape; // (type index) type index of vshape table for this class internal byte[] data; // data describing length of structure in bytes internal string name; }; // type record for LF_UNION internal struct LeafUnion { // internal ushort leaf; // LF_UNION [TYPTYPE] internal ushort count; // count of number of elements in class internal ushort property; // (CV_prop_t) property attribute field internal uint field; // (type index) type index of LF_FIELD descriptor list internal byte[] data; // variable length data describing length of internal string name; }; // type record for LF_ALIAS internal struct LeafAlias { // internal ushort leaf; // LF_ALIAS [TYPTYPE] internal uint utype; // (type index) underlying type internal string name; // alias name }; // type record for LF_MANAGED internal struct LeafManaged { // internal ushort leaf; // LF_MANAGED [TYPTYPE] internal string name; // utf8, zero terminated managed type name }; // type record for LF_ENUM internal struct LeafEnum { // internal ushort leaf; // LF_ENUM [TYPTYPE] internal ushort count; // count of number of elements in class internal ushort property; // (CV_propt_t) property attribute field internal uint utype; // (type index) underlying type of the enum internal uint field; // (type index) type index of LF_FIELD descriptor list internal string name; // length prefixed name of enum }; // Type record for LF_PROCEDURE internal struct LeafProc { // internal ushort leaf; // LF_PROCEDURE [TYPTYPE] internal uint rvtype; // (type index) type index of return value internal byte calltype; // calling convention (CV_call_t) internal byte reserved; // reserved for future use internal ushort parmcount; // number of parameters internal uint arglist; // (type index) type index of argument list }; // Type record for member function internal struct LeafMFunc { // internal ushort leaf; // LF_MFUNCTION [TYPTYPE] internal uint rvtype; // (type index) type index of return value internal uint classtype; // (type index) type index of containing class internal uint thistype; // (type index) type index of this pointer (model specific) internal byte calltype; // calling convention (call_t) internal byte reserved; // reserved for future use internal ushort parmcount; // number of parameters internal uint arglist; // (type index) type index of argument list internal int thisadjust; // this adjuster (long because pad required anyway) }; // type record for virtual function table shape internal struct LeafVTShape { // internal ushort leaf; // LF_VTSHAPE [TYPTYPE] internal ushort count; // number of entries in vfunctable internal byte[] desc; // 4 bit (CV_VTS_desc) descriptors }; // type record for cobol0 internal struct LeafCobol0 { // internal ushort leaf; // LF_COBOL0 [TYPTYPE] internal uint type; // (type index) parent type record index internal byte[] data; }; // type record for cobol1 internal struct LeafCobol1 { // internal ushort leaf; // LF_COBOL1 [TYPTYPE] internal byte[] data; }; // type record for basic array internal struct LeafBArray { // internal ushort leaf; // LF_BARRAY [TYPTYPE] internal uint utype; // (type index) type index of underlying type }; // type record for assembler labels internal struct LeafLabel { // internal ushort leaf; // LF_LABEL [TYPTYPE] internal ushort mode; // addressing mode of label }; // type record for dimensioned arrays internal struct LeafDimArray { // internal ushort leaf; // LF_DIMARRAY [TYPTYPE] internal uint utype; // (type index) underlying type of the array internal uint diminfo; // (type index) dimension information internal string name; // length prefixed name }; // type record describing path to virtual function table internal struct LeafVFTPath { // internal ushort leaf; // LF_VFTPATH [TYPTYPE] internal uint count; // count of number of bases in path internal uint[] bases; // (type index) bases from root to leaf }; // type record describing inclusion of precompiled types internal struct LeafPreComp { // internal ushort leaf; // LF_PRECOMP [TYPTYPE] internal uint start; // starting type index included internal uint count; // number of types in inclusion internal uint signature; // signature internal string name; // length prefixed name of included type file }; // type record describing end of precompiled types that can be // included by another file internal struct LeafEndPreComp { // internal ushort leaf; // LF_ENDPRECOMP [TYPTYPE] internal uint signature; // signature }; // type record for OEM definable type strings internal struct LeafOEM { // internal ushort leaf; // LF_OEM [TYPTYPE] internal ushort cvOEM; // MS assigned OEM identified internal ushort recOEM; // OEM assigned type identifier internal uint count; // count of type indices to follow internal uint[] index; // (type index) array of type indices followed // by OEM defined data }; internal enum OEM_ID { OEM_MS_FORTRAN90=0xF090, OEM_ODI=0x0010, OEM_THOMSON_SOFTWARE=0x5453, OEM_ODI_REC_BASELIST=0x0000, }; internal struct LeafOEM2 { // internal ushort leaf; // LF_OEM2 [TYPTYPE] internal Guid idOem; // an oem ID (Guid) internal uint count; // count of type indices to follow internal uint[] index; // (type index) array of type indices followed // by OEM defined data }; // type record describing using of a type server internal struct LeafTypeServer { // internal ushort leaf; // LF_TYPESERVER [TYPTYPE] internal uint signature; // signature internal uint age; // age of database used by this module internal string name; // length prefixed name of PDB }; // type record describing using of a type server with v7 (GUID) signatures internal struct LeafTypeServer2 { // internal ushort leaf; // LF_TYPESERVER2 [TYPTYPE] internal Guid sig70; // guid signature internal uint age; // age of database used by this module internal string name; // length prefixed name of PDB }; // description of type records that can be referenced from // type records referenced by symbols // type record for skip record internal struct LeafSkip { // internal ushort leaf; // LF_SKIP [TYPTYPE] internal uint type; // (type index) next valid index internal byte[] data; // pad data }; // argument list leaf internal struct LeafArgList { // internal ushort leaf; // LF_ARGLIST [TYPTYPE] internal uint count; // number of arguments internal uint[] arg; // (type index) number of arguments }; // derived class list leaf internal struct LeafDerived { // internal ushort leaf; // LF_DERIVED [TYPTYPE] internal uint count; // number of arguments internal uint[] drvdcls; // (type index) type indices of derived classes }; // leaf for default arguments internal struct LeafDefArg { // internal ushort leaf; // LF_DEFARG [TYPTYPE] internal uint type; // (type index) type of resulting expression internal byte[] expr; // length prefixed expression string }; // list leaf // This list should no longer be used because the utilities cannot // verify the contents of the list without knowing what type of list // it is. New specific leaf indices should be used instead. internal struct LeafList { // internal ushort leaf; // LF_LIST [TYPTYPE] internal byte[] data; // data format specified by indexing type }; // field list leaf // This is the header leaf for a complex list of class and structure // subfields. internal struct LeafFieldList { // internal ushort leaf; // LF_FIELDLIST [TYPTYPE] internal char[] data; // field list sub lists }; // type record for non-static methods and friends in overloaded method list internal struct mlMethod { internal ushort attr; // (CV_fldattr_t) method attribute internal ushort pad0; // internal padding, must be 0 internal uint index; // (type index) index to type record for procedure internal uint[] vbaseoff; // offset in vfunctable if intro virtual }; internal struct LeafMethodList { // internal ushort leaf; // LF_METHODLIST [TYPTYPE] internal byte[] mList; // really a mlMethod type }; // type record for LF_BITFIELD internal struct LeafBitfield { // internal ushort leaf; // LF_BITFIELD [TYPTYPE] internal uint type; // (type index) type of bitfield internal byte length; internal byte position; }; // type record for dimensioned array with constant bounds internal struct LeafDimCon { // internal ushort leaf; // LF_DIMCONU or LF_DIMCONLU [TYPTYPE] internal uint typ; // (type index) type of index internal ushort rank; // number of dimensions internal byte[] dim; // array of dimension information with // either upper bounds or lower/upper bound }; // type record for dimensioned array with variable bounds internal struct LeafDimVar { // internal ushort leaf; // LF_DIMVARU or LF_DIMVARLU [TYPTYPE] internal uint rank; // number of dimensions internal uint typ; // (type index) type of index internal uint[] dim; // (type index) array of type indices for either // variable upper bound or variable // lower/upper bound. The count of type // indices is rank or rank*2 depending on // whether it is LFDIMVARU or LF_DIMVARLU. // The referenced types must be // LF_REFSYM or T_VOID }; // type record for referenced symbol internal struct LeafRefSym { // internal ushort leaf; // LF_REFSYM [TYPTYPE] internal byte[] Sym; // copy of referenced symbol record // (including length) }; // the following are numeric leaves. They are used to indicate the // size of the following variable length data. When the numeric // data is a single byte less than 0x8000, then the data is output // directly. If the data is more the 0x8000 or is a negative value, // then the data is preceeded by the proper index. // // signed character leaf internal struct LeafChar { // internal ushort leaf; // LF_CHAR [TYPTYPE] internal sbyte val; // signed 8-bit value }; // signed short leaf internal struct LeafShort { // internal ushort leaf; // LF_SHORT [TYPTYPE] internal short val; // signed 16-bit value }; // ushort leaf internal struct LeafUShort { // internal ushort leaf; // LF_ushort [TYPTYPE] internal ushort val; // unsigned 16-bit value }; // signed (32-bit) long leaf internal struct LeafLong { // internal ushort leaf; // LF_LONG [TYPTYPE] internal int val; // signed 32-bit value }; // uint leaf internal struct LeafULong { // internal ushort leaf; // LF_ULONG [TYPTYPE] internal uint val; // unsigned 32-bit value }; // signed quad leaf internal struct LeafQuad { // internal ushort leaf; // LF_QUAD [TYPTYPE] internal long val; // signed 64-bit value }; // unsigned quad leaf internal struct LeafUQuad { // internal ushort leaf; // LF_UQUAD [TYPTYPE] internal ulong val; // unsigned 64-bit value }; // signed int128 leaf internal struct LeafOct { // internal ushort leaf; // LF_OCT [TYPTYPE] internal ulong val0; internal ulong val1; // signed 128-bit value }; // unsigned int128 leaf internal struct LeafUOct { // internal ushort leaf; // LF_UOCT [TYPTYPE] internal ulong val0; internal ulong val1; // unsigned 128-bit value }; // real 32-bit leaf internal struct LeafReal32 { // internal ushort leaf; // LF_REAL32 [TYPTYPE] internal float val; // 32-bit real value }; // real 64-bit leaf internal struct LeafReal64 { // internal ushort leaf; // LF_REAL64 [TYPTYPE] internal double val; // 64-bit real value }; // real 80-bit leaf internal struct LeafReal80 { // internal ushort leaf; // LF_REAL80 [TYPTYPE] internal FLOAT10 val; // real 80-bit value }; // real 128-bit leaf internal struct LeafReal128 { // internal ushort leaf; // LF_REAL128 [TYPTYPE] internal ulong val0; internal ulong val1; // real 128-bit value }; // complex 32-bit leaf internal struct LeafCmplx32 { // internal ushort leaf; // LF_COMPLEX32 [TYPTYPE] internal float val_real; // real component internal float val_imag; // imaginary component }; // complex 64-bit leaf internal struct LeafCmplx64 { // internal ushort leaf; // LF_COMPLEX64 [TYPTYPE] internal double val_real; // real component internal double val_imag; // imaginary component }; // complex 80-bit leaf internal struct LeafCmplx80 { // internal ushort leaf; // LF_COMPLEX80 [TYPTYPE] internal FLOAT10 val_real; // real component internal FLOAT10 val_imag; // imaginary component }; // complex 128-bit leaf internal struct LeafCmplx128 { // internal ushort leaf; // LF_COMPLEX128 [TYPTYPE] internal ulong val0_real; internal ulong val1_real; // real component internal ulong val0_imag; internal ulong val1_imag; // imaginary component }; // variable length numeric field internal struct LeafVarString { // internal ushort leaf; // LF_VARSTRING [TYPTYPE] internal ushort len; // length of value in bytes internal byte[] value; // value }; // index leaf - contains type index of another leaf // a major use of this leaf is to allow the compilers to emit a // long complex list (LF_FIELD) in smaller pieces. internal struct LeafIndex { // internal ushort leaf; // LF_INDEX [TYPTYPE] internal ushort pad0; // internal padding, must be 0 internal uint index; // (type index) type index of referenced leaf }; // subfield record for base class field internal struct LeafBClass { // internal ushort leaf; // LF_BCLASS [TYPTYPE] internal ushort attr; // (CV_fldattr_t) attribute internal uint index; // (type index) type index of base class internal byte[] offset; // variable length offset of base within class }; // subfield record for direct and indirect virtual base class field internal struct LeafVBClass { // internal ushort leaf; // LF_VBCLASS | LV_IVBCLASS [TYPTYPE] internal ushort attr; // (CV_fldattr_t) attribute internal uint index; // (type index) type index of direct virtual base class internal uint vbptr; // (type index) type index of virtual base pointer internal byte[] vbpoff; // virtual base pointer offset from address point // followed by virtual base offset from vbtable }; // subfield record for friend class internal struct LeafFriendCls { // internal ushort leaf; // LF_FRIENDCLS [TYPTYPE] internal ushort pad0; // internal padding, must be 0 internal uint index; // (type index) index to type record of friend class }; // subfield record for friend function internal struct LeafFriendFcn { // internal ushort leaf; // LF_FRIENDFCN [TYPTYPE] internal ushort pad0; // internal padding, must be 0 internal uint index; // (type index) index to type record of friend function internal string name; // name of friend function }; // subfield record for non-static data members internal struct LeafMember { // internal ushort leaf; // LF_MEMBER [TYPTYPE] internal ushort attr; // (CV_fldattr_t)attribute mask internal uint index; // (type index) index of type record for field internal byte[] offset; // variable length offset of field internal string name; // length prefixed name of field }; // type record for static data members internal struct LeafSTMember { // internal ushort leaf; // LF_STMEMBER [TYPTYPE] internal ushort attr; // (CV_fldattr_t) attribute mask internal uint index; // (type index) index of type record for field internal string name; // length prefixed name of field }; // subfield record for virtual function table pointer internal struct LeafVFuncTab { // internal ushort leaf; // LF_VFUNCTAB [TYPTYPE] internal ushort pad0; // internal padding, must be 0 internal uint type; // (type index) type index of pointer }; // subfield record for virtual function table pointer with offset internal struct LeafVFuncOff { // internal ushort leaf; // LF_VFUNCOFF [TYPTYPE] internal ushort pad0; // internal padding, must be 0. internal uint type; // (type index) type index of pointer internal int offset; // offset of virtual function table pointer }; // subfield record for overloaded method list internal struct LeafMethod { // internal ushort leaf; // LF_METHOD [TYPTYPE] internal ushort count; // number of occurrences of function internal uint mList; // (type index) index to LF_METHODLIST record internal string name; // length prefixed name of method }; // subfield record for nonoverloaded method internal struct LeafOneMethod { // internal ushort leaf; // LF_ONEMETHOD [TYPTYPE] internal ushort attr; // (CV_fldattr_t) method attribute internal uint index; // (type index) index to type record for procedure internal uint[] vbaseoff; // offset in vfunctable if intro virtual internal string name; }; // subfield record for enumerate internal struct LeafEnumerate { // internal ushort leaf; // LF_ENUMERATE [TYPTYPE] internal ushort attr; // (CV_fldattr_t) access internal byte[] value; // variable length value field internal string name; }; // type record for nested (scoped) type definition internal struct LeafNestType { // internal ushort leaf; // LF_NESTTYPE [TYPTYPE] internal ushort pad0; // internal padding, must be 0 internal uint index; // (type index) index of nested type definition internal string name; // length prefixed type name }; // type record for nested (scoped) type definition, with attributes // new records for vC v5.0, no need to have 16-bit ti versions. internal struct LeafNestTypeEx { // internal ushort leaf; // LF_NESTTYPEEX [TYPTYPE] internal ushort attr; // (CV_fldattr_t) member access internal uint index; // (type index) index of nested type definition internal string name; // length prefixed type name }; // type record for modifications to members internal struct LeafMemberModify { // internal ushort leaf; // LF_MEMBERMODIFY [TYPTYPE] internal ushort attr; // (CV_fldattr_t) the new attributes internal uint index; // (type index) index of base class type definition internal string name; // length prefixed member name }; // type record for pad leaf internal struct LeafPad { internal byte leaf; }; // Symbol definitions internal enum SYM { S_END=0x0006, // Block, procedure, "with" or thunk end S_OEM=0x0404, // OEM defined symbol S_REGISTER_ST=0x1001, // Register variable S_CONSTANT_ST=0x1002, // constant symbol S_UDT_ST=0x1003, // User defined type S_COBOLUDT_ST=0x1004, // special UDT for cobol that does not symbol pack S_MANYREG_ST=0x1005, // multiple register variable S_BPREL32_ST=0x1006, // BP-relative S_LDATA32_ST=0x1007, // Module-local symbol S_GDATA32_ST=0x1008, // Global data symbol S_PUB32_ST=0x1009, // a internal symbol (CV internal reserved) S_LPROC32_ST=0x100a, // Local procedure start S_GPROC32_ST=0x100b, // Global procedure start S_VFTABLE32=0x100c, // address of virtual function table S_REGREL32_ST=0x100d, // register relative address S_LTHREAD32_ST=0x100e, // local thread storage S_GTHREAD32_ST=0x100f, // global thread storage S_LPROCMIPS_ST=0x1010, // Local procedure start S_GPROCMIPS_ST=0x1011, // Global procedure start // new symbol records for edit and continue information S_FRAMEPROC=0x1012, // extra frame and proc information S_COMPILE2_ST=0x1013, // extended compile flags and info // new symbols necessary for 16-bit enumerates of IA64 registers // and IA64 specific symbols S_MANYREG2_ST=0x1014, // multiple register variable S_LPROCIA64_ST=0x1015, // Local procedure start (IA64) S_GPROCIA64_ST=0x1016, // Global procedure start (IA64) // Local symbols for IL S_LOCALSLOT_ST=0x1017, // local IL sym with field for local slot index S_PARAMSLOT_ST=0x1018, // local IL sym with field for parameter slot index S_ANNOTATION=0x1019, // Annotation string literals // symbols to support managed code debugging S_GMANPROC_ST=0x101a, // Global proc S_LMANPROC_ST=0x101b, // Local proc S_RESERVED1=0x101c, // reserved S_RESERVED2=0x101d, // reserved S_RESERVED3=0x101e, // reserved S_RESERVED4=0x101f, // reserved S_LMANDATA_ST=0x1020, S_GMANDATA_ST=0x1021, S_MANFRAMEREL_ST=0x1022, S_MANREGISTER_ST=0x1023, S_MANSLOT_ST=0x1024, S_MANMANYREG_ST=0x1025, S_MANREGREL_ST=0x1026, S_MANMANYREG2_ST=0x1027, S_MANTYPREF=0x1028, // Index for type referenced by name from metadata S_UNAMESPACE_ST=0x1029, // Using namespace // Symbols w/ SZ name fields. All name fields contain utf8 encoded strings. S_ST_MAX=0x1100, // starting point for SZ name symbols S_OBJNAME=0x1101, // path to object file name S_THUNK32=0x1102, // Thunk Start S_BLOCK32=0x1103, // block start S_WITH32=0x1104, // with start S_LABEL32=0x1105, // code label S_REGISTER=0x1106, // Register variable S_CONSTANT=0x1107, // constant symbol S_UDT=0x1108, // User defined type S_COBOLUDT=0x1109, // special UDT for cobol that does not symbol pack S_MANYREG=0x110a, // multiple register variable S_BPREL32=0x110b, // BP-relative S_LDATA32=0x110c, // Module-local symbol S_GDATA32=0x110d, // Global data symbol S_PUB32=0x110e, // a internal symbol (CV internal reserved) S_LPROC32=0x110f, // Local procedure start S_GPROC32=0x1110, // Global procedure start S_REGREL32=0x1111, // register relative address S_LTHREAD32=0x1112, // local thread storage S_GTHREAD32=0x1113, // global thread storage S_LPROCMIPS=0x1114, // Local procedure start S_GPROCMIPS=0x1115, // Global procedure start S_COMPILE2=0x1116, // extended compile flags and info S_MANYREG2=0x1117, // multiple register variable S_LPROCIA64=0x1118, // Local procedure start (IA64) S_GPROCIA64=0x1119, // Global procedure start (IA64) S_LOCALSLOT=0x111a, // local IL sym with field for local slot index S_SLOT=S_LOCALSLOT, // alias for LOCALSLOT S_PARAMSLOT=0x111b, // local IL sym with field for parameter slot index // symbols to support managed code debugging S_LMANDATA=0x111c, S_GMANDATA=0x111d, S_MANFRAMEREL=0x111e, S_MANREGISTER=0x111f, S_MANSLOT=0x1120, S_MANMANYREG=0x1121, S_MANREGREL=0x1122, S_MANMANYREG2=0x1123, S_UNAMESPACE=0x1124, // Using namespace // ref symbols with name fields S_PROCREF=0x1125, // Reference to a procedure S_DATAREF=0x1126, // Reference to data S_LPROCREF=0x1127, // Local Reference to a procedure S_ANNOTATIONREF=0x1128, // Reference to an S_ANNOTATION symbol S_TOKENREF=0x1129, // Reference to one of the many MANPROCSYM's // continuation of managed symbols S_GMANPROC=0x112a, // Global proc S_LMANPROC=0x112b, // Local proc // short, light-weight thunks S_TRAMPOLINE=0x112c, // trampoline thunks S_MANCONSTANT=0x112d, // constants with metadata type info // native attributed local/parms S_ATTR_FRAMEREL=0x112e, // relative to virtual frame ptr S_ATTR_REGISTER=0x112f, // stored in a register S_ATTR_REGREL=0x1130, // relative to register (alternate frame ptr) S_ATTR_MANYREG=0x1131, // stored in >1 register // Separated code (from the compiler) support S_SEPCODE=0x1132, S_LOCAL=0x1133, // defines a local symbol in optimized code S_DEFRANGE=0x1134, // defines a single range of addresses in which symbol can be evaluated S_DEFRANGE2=0x1135, // defines ranges of addresses in which symbol can be evaluated S_SECTION=0x1136, // A COFF section in a PE executable S_COFFGROUP=0x1137, // A COFF group S_EXPORT=0x1138, // A export S_CALLSITEINFO=0x1139, // Indirect call site information S_FRAMECOOKIE=0x113a, // Security cookie information S_DISCARDED=0x113b, // Discarded by LINK /OPT:REF (experimental, see richards) S_RECTYPE_MAX, // one greater than last S_RECTYPE_LAST=S_RECTYPE_MAX - 1, }; // enum describing compile flag ambient data model internal enum CV_CFL_DATA { CV_CFL_DNEAR=0x00, CV_CFL_DFAR=0x01, CV_CFL_DHUGE=0x02 }; // enum describing compile flag ambiant code model internal enum CV_CFL_CODE { CV_CFL_CNEAR=0x00, CV_CFL_CFAR=0x01, CV_CFL_CHUGE=0x02 }; // enum describing compile flag target floating point package internal enum CV_CFL_FPKG { CV_CFL_NDP=0x00, CV_CFL_EMU=0x01, CV_CFL_ALT=0x02 }; // enum describing function return method [Flags] internal enum CV_PROCFLAGS : byte { CV_PFLAG_NOFPO=0x01, // frame pointer present CV_PFLAG_INT=0x02, // interrupt return CV_PFLAG_FAR=0x04, // far return CV_PFLAG_NEVER=0x08, // function does not return CV_PFLAG_NOTREACHED=0x10, // label isn't fallen into CV_PFLAG_CUST_CALL=0x20, // custom calling convention CV_PFLAG_NOINLINE=0x40, // function marked as noinline CV_PFLAG_OPTDBGINFO=0x80, // function has debug information for optimized code }; // Extended proc flags // internal struct CV_EXPROCFLAGS { internal byte flags; // (CV_PROCFLAGS) internal byte reserved; // must be zero }; // local variable flags [Flags] internal enum CV_LVARFLAGS : ushort { fIsParam=0x0001, // variable is a parameter fAddrTaken=0x0002, // address is taken fCompGenx=0x0004, // variable is compiler generated fIsAggregate=0x0008, // the symbol is splitted in temporaries, // which are treated by compiler as // independent entities fIsAggregated=0x0010, // Counterpart of fIsAggregate - tells // that it is a part of a fIsAggregate symbol fIsAliased=0x0020, // variable has multiple simultaneous lifetimes fIsAlias=0x0040, // represents one of the multiple simultaneous lifetimes }; // represents an address range, used for optimized code debug info internal struct CV_lvar_addr_range { // defines a range of addresses internal uint offStart; internal ushort isectStart; internal uint cbRange; }; // enum describing function data return method internal enum CV_GENERIC_STYLE { CV_GENERIC_VOID=0x00, // void return type CV_GENERIC_REG=0x01, // return data is in registers CV_GENERIC_ICAN=0x02, // indirect caller allocated near CV_GENERIC_ICAF=0x03, // indirect caller allocated far CV_GENERIC_IRAN=0x04, // indirect returnee allocated near CV_GENERIC_IRAF=0x05, // indirect returnee allocated far CV_GENERIC_UNUSED=0x06 // first unused }; [Flags] internal enum CV_GENERIC_FLAG : ushort { cstyle=0x0001, // true push varargs right to left rsclean=0x0002, // true if returnee stack cleanup }; // flag bitfields for separated code attributes [Flags] internal enum CV_SEPCODEFLAGS : uint { fIsLexicalScope=0x00000001, // S_SEPCODE doubles as lexical scope fReturnsToParent=0x00000002, // code frag returns to parent }; // Generic layout for symbol records internal struct SYMTYPE { internal ushort reclen; // Record length internal ushort rectyp; // Record type // byte data[CV_ZEROLEN]; // SYMTYPE *NextSym (SYMTYPE * pSym) { // return (SYMTYPE *) ((char *)pSym + pSym->reclen + sizeof(ushort)); // } }; // non-model specific symbol types internal struct RegSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_REGISTER internal uint typind; // (type index) Type index or Metadata token internal ushort reg; // register enumerate internal string name; // Length-prefixed name }; internal struct AttrRegSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANREGISTER | S_ATTR_REGISTER internal uint typind; // (type index) Type index or Metadata token internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal ushort reg; // register enumerate internal string name; // Length-prefixed name }; internal struct ManyRegSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANYREG internal uint typind; // (type index) Type index or metadata token internal byte count; // count of number of registers internal byte[] reg; // count register enumerates, most-sig first internal string name; // length-prefixed name. }; internal struct ManyRegSym2 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANYREG2 internal uint typind; // (type index) Type index or metadata token internal ushort count; // count of number of registers, internal ushort[] reg; // count register enumerates, most-sig first internal string name; // length-prefixed name. }; internal struct AttrManyRegSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANMANYREG internal uint typind; // (type index) Type index or metadata token internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal byte count; // count of number of registers internal byte[] reg; // count register enumerates, most-sig first internal string name; // utf-8 encoded zero terminate name }; internal struct AttrManyRegSym2 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANMANYREG2 | S_ATTR_MANYREG internal uint typind; // (type index) Type index or metadata token internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal ushort count; // count of number of registers internal ushort[] reg; // count register enumerates, most-sig first internal string name; // utf-8 encoded zero terminate name }; internal struct ConstSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_CONSTANT or S_MANCONSTANT internal uint typind; // (type index) Type index (containing enum if enumerate) or metadata token internal ushort value; // numeric leaf containing value internal string name; // Length-prefixed name }; internal struct UdtSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_UDT | S_COBOLUDT internal uint typind; // (type index) Type index internal string name; // Length-prefixed name }; internal struct ManyTypRef { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANTYPREF internal uint typind; // (type index) Type index }; internal struct SearchSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_SSEARCH internal uint startsym; // offset of the procedure internal ushort seg; // segment of symbol }; [Flags] internal enum CFLAGSYM_FLAGS : ushort { pcode=0x0001, // true if pcode present floatprec=0x0006, // floating precision floatpkg=0x0018, // float package ambdata=0x00e0, // ambient data model ambcode=0x0700, // ambient code model mode32=0x0800, // true if compiled 32 bit mode }; internal struct CFlagSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_COMPILE internal byte machine; // target processor internal byte language; // language index internal ushort flags; // (CFLAGSYM_FLAGS) internal string ver; // Length-prefixed compiler version string }; [Flags] internal enum COMPILESYM_FLAGS : uint { iLanguage=0x000000ff, // language index fEC=0x00000100, // compiled for E/C fNoDbgInfo=0x00000200, // not compiled with debug info fLTCG=0x00000400, // compiled with LTCG fNoDataAlign=0x00000800, // compiled with -Bzalign fManagedPresent=0x00001000, // managed code/data present fSecurityChecks=0x00002000, // compiled with /GS fHotPatch=0x00004000, // compiled with /hotpatch fCVTCIL=0x00008000, // converted with CVTCIL fMSILModule=0x00010000, // MSIL netmodule }; internal struct CompileSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_COMPILE2 internal uint flags; // (COMPILESYM_FLAGS) internal ushort machine; // target processor internal ushort verFEMajor; // front end major version # internal ushort verFEMinor; // front end minor version # internal ushort verFEBuild; // front end build version # internal ushort verMajor; // back end major version # internal ushort verMinor; // back end minor version # internal ushort verBuild; // back end build version # internal string verSt; // Length-prefixed compiler version string, followed internal string[] verArgs; // block of zero terminated strings, ended by double-zero. }; internal struct ObjNameSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_OBJNAME internal uint signature; // signature internal string name; // Length-prefixed name }; internal struct EndArgSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_ENDARG }; internal struct ReturnSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_RETURN internal CV_GENERIC_FLAG flags; // flags internal byte style; // CV_GENERIC_STYLE return style // followed by return method data }; internal struct EntryThisSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_ENTRYTHIS internal byte thissym; // symbol describing this pointer on entry }; internal struct BpRelSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_BPREL32 internal int off; // BP-relative offset internal uint typind; // (type index) Type index or Metadata token internal string name; // Length-prefixed name }; internal struct FrameRelSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANFRAMEREL | S_ATTR_FRAMEREL internal int off; // Frame relative offset internal uint typind; // (type index) Type index or Metadata token internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal string name; // Length-prefixed name }; internal struct SlotSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_LOCALSLOT or S_PARAMSLOT internal uint index; // slot index internal uint typind; // (type index) Type index or Metadata token internal string name; // Length-prefixed name }; internal struct AttrSlotSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANSLOT internal uint index; // slot index internal uint typind; // (type index) Type index or Metadata token internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal string name; // Length-prefixed name }; internal struct AnnotationSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_ANNOTATION internal uint off; internal ushort seg; internal ushort csz; // Count of zero terminated annotation strings internal string[] rgsz; // Sequence of zero terminated annotation strings }; internal struct DatasSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_LDATA32, S_GDATA32 or S_PUB32, S_LMANDATA, S_GMANDATA internal uint typind; // (type index) Type index, or Metadata token if a managed symbol internal uint off; internal ushort seg; internal string name; // Length-prefixed name }; [Flags] internal enum CV_PUBSYMFLAGS : uint { fNone=0, fCode=0x00000001, // set if internal symbol refers to a code address fFunction=0x00000002, // set if internal symbol is a function fManaged=0x00000004, // set if managed code (native or IL) fMSIL=0x00000008, // set if managed IL code }; internal struct PubSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_PUB32 internal uint flags; // (CV_PUBSYMFLAGS) internal uint off; internal ushort seg; internal string name; // Length-prefixed name }; internal struct ProcSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_GPROC32 or S_LPROC32 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint len; // Proc length internal uint dbgStart; // Debug start offset internal uint dbgEnd; // Debug end offset internal uint typind; // (type index) Type index internal uint off; internal ushort seg; internal byte flags; // (CV_PROCFLAGS) Proc flags internal string name; // Length-prefixed name }; internal struct ManProcSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_GMANPROC, S_LMANPROC, S_GMANPROCIA64 or S_LMANPROCIA64 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint len; // Proc length internal uint dbgStart; // Debug start offset internal uint dbgEnd; // Debug end offset internal uint token; // COM+ metadata token for method internal uint off; internal ushort seg; internal byte flags; // (CV_PROCFLAGS) Proc flags internal ushort retReg; // Register return value is in (may not be used for all archs) internal string name; // optional name field }; internal struct ManProcSymMips { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_GMANPROCMIPS or S_LMANPROCMIPS internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint len; // Proc length internal uint dbgStart; // Debug start offset internal uint dbgEnd; // Debug end offset internal uint regSave; // int register save mask internal uint fpSave; // fp register save mask internal uint intOff; // int register save offset internal uint fpOff; // fp register save offset internal uint token; // COM+ token type internal uint off; internal ushort seg; internal byte retReg; // Register return value is in internal byte frameReg; // Frame pointer register internal string name; // optional name field }; internal struct ThunkSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_THUNK32 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint off; internal ushort seg; internal ushort len; // length of thunk internal byte ord; // THUNK_ORDINAL specifying type of thunk internal string name; // Length-prefixed name internal byte[] variant; // variant portion of thunk }; internal enum TRAMP { // Trampoline subtype trampIncremental, // incremental thunks trampBranchIsland, // Branch island thunks }; internal struct TrampolineSym { // Trampoline thunk symbol // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_TRAMPOLINE internal ushort trampType; // trampoline sym subtype internal ushort cbThunk; // size of the thunk internal uint offThunk; // offset of the thunk internal uint offTarget; // offset of the target of the thunk internal ushort sectThunk; // section index of the thunk internal ushort sectTarget; // section index of the target of the thunk }; internal struct LabelSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_LABEL32 internal uint off; internal ushort seg; internal byte flags; // (CV_PROCFLAGS) flags internal string name; // Length-prefixed name }; internal struct BlockSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_BLOCK32 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint len; // Block length internal uint off; // Offset in code segment internal ushort seg; // segment of label internal string name; // Length-prefixed name }; internal struct WithSym32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_WITH32 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint len; // Block length internal uint off; // Offset in code segment internal ushort seg; // segment of label internal string expr; // Length-prefixed expression string }; internal struct VpathSym32 { // internal ushort reclen; // record length // internal ushort rectyp; // S_VFTABLE32 internal uint root; // (type index) type index of the root of path internal uint path; // (type index) type index of the path record internal uint off; // offset of virtual function table internal ushort seg; // segment of virtual function table }; internal struct RegRel32 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_REGREL32 internal uint off; // offset of symbol internal uint typind; // (type index) Type index or metadata token internal ushort reg; // register index for symbol internal string name; // Length-prefixed name }; internal struct AttrRegRel { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_MANREGREL | S_ATTR_REGREL internal uint off; // offset of symbol internal uint typind; // (type index) Type index or metadata token internal ushort reg; // register index for symbol internal uint offCod; // first code address where var is live internal ushort segCod; internal ushort flags; // (CV_LVARFLAGS)local var flags internal string name; // Length-prefixed name }; internal struct ThreadSym32 { // internal ushort reclen; // record length // internal ushort rectyp; // S_LTHREAD32 | S_GTHREAD32 internal uint typind; // (type index) type index internal uint off; // offset into thread storage internal ushort seg; // segment of thread storage internal string name; // length prefixed name }; internal struct Slink32 { // internal ushort reclen; // record length // internal ushort rectyp; // S_SLINK32 internal uint framesize; // frame size of parent procedure internal int off; // signed offset where the static link was saved relative to the value of reg internal ushort reg; }; internal struct ProcSymMips { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_GPROCMIPS or S_LPROCMIPS internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint len; // Proc length internal uint dbgStart; // Debug start offset internal uint dbgEnd; // Debug end offset internal uint regSave; // int register save mask internal uint fpSave; // fp register save mask internal uint intOff; // int register save offset internal uint fpOff; // fp register save offset internal uint typind; // (type index) Type index internal uint off; // Symbol offset internal ushort seg; // Symbol segment internal byte retReg; // Register return value is in internal byte frameReg; // Frame pointer register internal string name; // Length-prefixed name }; internal struct ProcSymIa64 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_GPROCIA64 or S_LPROCIA64 internal uint parent; // pointer to the parent internal uint end; // pointer to this blocks end internal uint next; // pointer to next symbol internal uint len; // Proc length internal uint dbgStart; // Debug start offset internal uint dbgEnd; // Debug end offset internal uint typind; // (type index) Type index internal uint off; // Symbol offset internal ushort seg; // Symbol segment internal ushort retReg; // Register return value is in internal byte flags; // (CV_PROCFLAGS) Proc flags internal string name; // Length-prefixed name }; internal struct RefSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_PROCREF_ST, S_DATAREF_ST, or S_LPROCREF_ST internal uint sumName; // SUC of the name internal uint ibSym; // Offset of actual symbol in $$Symbols internal ushort imod; // Module containing the actual symbol internal ushort usFill; // align this record }; internal struct RefSym2 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_PROCREF, S_DATAREF, or S_LPROCREF internal uint sumName; // SUC of the name internal uint ibSym; // Offset of actual symbol in $$Symbols internal ushort imod; // Module containing the actual symbol internal string name; // hidden name made a first class member }; internal struct AlignSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_ALIGN }; internal struct OemSymbol { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_OEM internal Guid idOem; // an oem ID (GUID) internal uint typind; // (type index) Type index internal byte[] rgl; // user data, force 4-byte alignment }; [Flags] internal enum FRAMEPROCSYM_FLAGS : uint { fHasAlloca=0x00000001, // function uses _alloca() fHasSetJmp=0x00000002, // function uses setjmp() fHasLongJmp=0x00000004, // function uses longjmp() fHasInlAsm=0x00000008, // function uses inline asm fHasEH=0x00000010, // function has EH states fInlSpec=0x00000020, // function was speced as inline fHasSEH=0x00000040, // function has SEH fNaked=0x00000080, // function is __declspec(naked) fSecurityChecks=0x00000100, // function has buffer security check introduced by /GS. fAsyncEH=0x00000200, // function compiled with /EHa fGSNoStackOrdering=0x00000400, // function has /GS buffer checks, but stack ordering couldn't be done fWasInlined=0x00000800, // function was inlined within another function }; internal struct FrameProcSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_FRAMEPROC internal uint cbFrame; // count of bytes of total frame of procedure internal uint cbPad; // count of bytes of padding in the frame internal uint offPad; // offset (rel to frame) to where padding starts internal uint cbSaveRegs; // count of bytes of callee save registers internal uint offExHdlr; // offset of exception handler internal ushort secExHdlr; // section id of exception handler internal uint flags; // (FRAMEPROCSYM_FLAGS) } internal struct UnamespaceSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_UNAMESPACE internal string name; // name }; internal struct SepCodSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_SEPCODE internal uint parent; // pointer to the parent internal uint end; // pointer to this block's end internal uint length; // count of bytes of this block internal uint scf; // (CV_SEPCODEFLAGS) flags internal uint off; // sec:off of the separated code internal uint offParent; // secParent:offParent of the enclosing scope internal ushort sec; // (proc, block, or sepcode) internal ushort secParent; }; internal struct LocalSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_LOCAL internal uint id; // id of the local internal uint typind; // (type index) type index internal ushort flags; // (CV_LVARFLAGS) local var flags internal uint idParent; // This is is parent variable - fIsAggregated or fIsAlias internal uint offParent; // Offset in parent variable - fIsAggregated internal uint expr; // NI of expression that this temp holds internal uint pad0; // pad, must be zero internal uint pad1; // pad, must be zero internal string name; // Name of this symbol. } internal struct DefRangeSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_DEFRANGE internal uint id; // ID of the local symbol for which this formula holds internal uint program; // program to evaluate the value of the symbol internal CV_lvar_addr_range range; // Range of addresses where this program is valid }; internal struct DefRangeSym2 { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_DEFRANGE2 internal uint id; // ID of the local symbol for which this formula holds internal uint program; // program to evaluate the value of the symbol internal ushort count; // count of CV_lvar_addr_range records following internal CV_lvar_addr_range[] range;// Range of addresses where this program is valid }; internal struct SectionSym { // internal ushort reclen // Record length // internal ushort rectyp; // S_SECTION internal ushort isec; // Section number internal byte align; // Alignment of this section (power of 2) internal byte bReserved; // Reserved. Must be zero. internal uint rva; internal uint cb; internal uint characteristics; internal string name; // name }; internal struct CoffGroupSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_COFFGROUP internal uint cb; internal uint characteristics; internal uint off; // Symbol offset internal ushort seg; // Symbol segment internal string name; // name }; [Flags] internal enum EXPORTSYM_FLAGS : ushort { fConstant=0x0001, // CONSTANT fData=0x0002, // DATA fPrivate=0x0004, // PRIVATE fNoName=0x0008, // NONAME fOrdinal=0x0010, // Ordinal was explicitly assigned fForwarder=0x0020, // This is a forwarder } internal struct ExportSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_EXPORT internal ushort ordinal; internal ushort flags; // (EXPORTSYM_FLAGS) internal string name; // name of }; // // Symbol for describing indirect calls when they are using // a function pointer cast on some other type or temporary. // Typical content will be an LF_POINTER to an LF_PROCEDURE // type record that should mimic an actual variable with the // function pointer type in question. // // Since the compiler can sometimes tail-merge a function call // through a function pointer, there may be more than one // S_CALLSITEINFO record at an address. This is similar to what // you could do in your own code by: // // if (expr) // pfn = &function1; // else // pfn = &function2; // // (*pfn)(arg list); // internal struct CallsiteInfo { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_CALLSITEINFO internal int off; // offset of call site internal ushort ect; // section index of call site internal ushort pad0; // alignment padding field, must be zero internal uint typind; // (type index) type index describing function signature }; // Frame cookie information internal enum CV_cookietype { CV_COOKIETYPE_COPY=0, CV_COOKIETYPE_XOR_SP, CV_COOKIETYPE_XOR_BP, CV_COOKIETYPE_XOR_R13, }; // Symbol for describing security cookie's position and type // (raw, xor'd with esp, xor'd with ebp). internal struct FrameCookie { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_FRAMECOOKIE internal int off; // Frame relative offset internal ushort reg; // Register index internal int cookietype; // (CV_cookietype) Type of the cookie internal byte flags; // Flags describing this cookie }; internal enum CV_DISCARDED : uint { CV_DISCARDED_UNKNOWN=0, CV_DISCARDED_NOT_SELECTED=1, CV_DISCARDED_NOT_REFERENCED=2, }; internal struct DiscardedSym { // internal ushort reclen; // Record length [SYMTYPE] // internal ushort rectyp; // S_DISCARDED internal CV_DISCARDED iscarded; internal uint fileid; // First FILEID if line number info present internal uint linenum; // First line number internal byte[] data; // Original record(s) with invalid indices }; // // V7 line number data types // internal enum DEBUG_S_SUBSECTION_TYPE : uint { DEBUG_S_IGNORE=0x80000000, // if this bit is set in a subsection type then ignore the subsection contents DEBUG_S_SYMBOLS=0xf1, DEBUG_S_LINES=0xf2, DEBUG_S_STRINGTABLE=0xf3, DEBUG_S_FILECHKSMS=0xf4, DEBUG_S_FRAMEDATA=0xf5, }; // // Line flags (data present) // internal enum CV_LINE_SUBSECTION_FLAGS : ushort { CV_LINES_HAVE_COLUMNS=0x0001, } internal struct CV_LineSection { internal uint off; internal ushort sec; internal ushort flags; internal uint cod; } internal struct CV_SourceFile { internal uint index; // Index to file in checksum section. internal uint count; // Number of CV_Line records. internal uint linsiz; // Size of CV_Line recods. } [Flags] internal enum CV_Line_Flags : uint { linenumStart=0x00ffffff, // line where statement/expression starts deltaLineEnd=0x7f000000, // delta to line where statement ends (optional) fStatement=0x80000000, // true if a statement linenumber, else an expression line num }; internal struct CV_Line { internal uint offset; // Offset to start of code bytes for line number internal uint flags; // (CV_Line_Flags) }; internal struct CV_Column { internal ushort offColumnStart; internal ushort offColumnEnd; }; // File information internal enum CV_FILE_CHECKSUM_TYPE : byte { None=0, MD5=1, }; internal struct CV_FileCheckSum { internal uint name; // Index of name in name table. internal byte len; // Hash length internal byte type; // Hash type } [Flags] internal enum FRAMEDATA_FLAGS : uint { fHasSEH=0x00000001, fHasEH=0x00000002, fIsFunctionStart=0x00000004, }; internal struct FrameData { internal uint ulRvaStart; internal uint cbBlock; internal uint cbLocals; internal uint cbParams; internal uint cbStkMax; internal uint frameFunc; internal ushort cbProlog; internal ushort cbSavedRegs; internal uint flags; // (FRAMEDATA_FLAGS) }; internal struct XFixupData { internal ushort wType; internal ushort wExtra; internal uint rva; internal uint rvaTarget; }; internal enum DEBUG_S_SUBSECTION { SYMBOLS=0xF1, LINES=0xF2, STRINGTABLE=0xF3, FILECHKSMS=0xF4, FRAMEDATA=0xF5, } }