pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
.NET Decompiler with support for PDB generation, ReadyToRun, Metadata (&more) - cross-platform!
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1709 Commits
18 Branches
85 Tags
83 MiB
 
 
 
 
Tree: 7d674c9290
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7d674c9290'
${ noResults }
ILSpy/Mono.Cecil/symbols/pdb/Microsoft.Cci.Pdb/CvInfo.cs

2435 lines
85 KiB
Raw Blame History

//-----------------------------------------------------------------------------
//
// Copyright (c) Microsoft. All rights reserved.
// This code is licensed under the Microsoft Public License.
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//-----------------------------------------------------------------------------
//
// 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,
}
}