/*** cvinfo.h - Generic CodeView information definitions * * Structures, constants, etc. for accessing and interpreting * CodeView information. * */ /*** The master copy of this file resides in the CodeView project. * 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. * */ #pragma pack(1) typedef unsigned long CV_uoff32_t; typedef long CV_off32_t; typedef unsigned short CV_uoff16_t; typedef short CV_off16_t; typedef unsigned short CV_typ_t; #define CV_SIGNATURE_C6 0L // Actual signature is >64K #define CV_SIGNATURE_C7 1L // First explicit signature #define CV_SIGNATURE_RESERVED 2L // All signatures from 2 to 64K are reserved #define CV_MAXOFFSET 0xffffffff /** CodeView Symbol and Type OMF type information is broken up into two * ranges. Type indices less than 0x1000 describe frequently used * type information that is frequently used. Type indices above * 0x1000 are used to describe more complex features such as function, * 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. */ #define CV_MMASK 0x700 // mode mask #define CV_TMASK 0x0f0 // type mask #define CV_SMASK 0x007 // subtype mask #define CV_MSHIFT 8 // primitive mode right shift count #define CV_TSHIFT 4 // primitive type right shift count #define CV_SSHIFT 0 // primitive subtype right shift count // macros to extract primitive mode, type and size #define CV_MODE(typ) (((typ) & CV_MMASK) >> CV_MSHIFT) #define CV_TYPE(typ) (((typ) & CV_TMASK) >> CV_TSHIFT) #define CV_SUBT(typ) (((typ) & CV_SMASK) >> CV_SSHIFT) // macros to insert new primitive mode, type and size #define CV_NEWMODE(typ, nm) (((typ) & ~CV_MMASK) | ((nm) << CV_MSHIFT)) #define CV_NEWTYPE(typ, nt) (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIFT)) #define CV_NEWSUBT(typ, ns) (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT)) // pointer mode enumeration values typedef enum CV_prmode_e { CV_TM_DIRECT = 0, // mode is not a pointer CV_TM_NPTR = 1, // mode is a near pointer CV_TM_FPTR = 2, // mode is a far pointer CV_TM_HPTR = 3, // mode is a huge pointer CV_TM_NPTR32 = 4, // mode is a 32 bit near pointer CV_TM_FPTR32 = 5, // mode is a 32 bit far pointer CV_TM_NPTR64 = 6, // mode is a 64 bit near pointer } CV_prmode_e; // type enumeration values typedef enum CV_type_e { 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 } CV_type_e; // subtype enumeration values for CV_SPECIAL typedef enum CV_special_e { 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_special_e; // subtype enumeration values for CV_SPECIAL2 typedef enum CV_special2_e { CV_S2_BIT = 0x00, CV_S2_PASCHAR = 0x01, // Pascal CHAR } CV_special2_e; // subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN typedef enum CV_integral_e { CV_IN_1BYTE = 0x00, CV_IN_2BYTE = 0x01, CV_IN_4BYTE = 0x02, CV_IN_8BYTE = 0x03, } CV_integral_e; // subtype enumeration values for CV_REAL and CV_COMPLEX typedef enum CV_real_e { CV_RC_REAL32 = 0x00, CV_RC_REAL64 = 0x01, CV_RC_REAL80 = 0x02, CV_RC_REAL128 = 0x03, CV_RC_REAL48 = 0x04 } CV_real_e; // subtype enumeration values for CV_INT (really int) typedef enum CV_int_e { CV_RI_CHAR = 0x00, CV_RI_WCHAR = 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_int_e; // macros to check the type of a primitive #define CV_TYP_IS_DIRECT(typ) (CV_MODE(typ) == CV_TM_DIRECT) #define CV_TYP_IS_PTR(typ) (CV_MODE(typ) != CV_TM_DIRECT) #define CV_TYP_IS_NPTR(typ) (CV_MODE(typ) == CV_TM_NPTR) #define CV_TYP_IS_FPTR(typ) (CV_MODE(typ) == CV_TM_FPTR) #define CV_TYP_IS_HPTR(typ) (CV_MODE(typ) == CV_TM_HPTR) #define CV_TYP_IS_NPTR32(typ) (CV_MODE(typ) == CV_TM_NPTR32) #define CV_TYP_IS_FPTR32(typ) (CV_MODE(typ) == CV_TM_FPTR32) #define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) == CV_SIGNED) && CV_TYP_IS_DIRECT(typ)) || \ (typ == T_INT2) || (typ == T_INT4)|| (typ == T_RCHAR)) #define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED) && CV_TYP_IS_DIRECT(typ)) || \ (typ == T_UINT2) || (typ == T_UINT4)|| (typ == T_RCHAR)) #define CV_TYP_IS_REAL(typ) ((CV_TYPE(typ) == CV_REAL) && CV_TYP_IS_DIRECT(typ)) #define CV_FIRST_NONPRIM 0x1000 #define CV_IS_PRIMITIVE(typ) ((typ) < CV_FIRST_NONPRIM) // selected values for type_index - for a more complete definition, see // Microsoft Symbol and Type OMF document // Special Types #define T_NOTYPE 0x0000 // uncharacterized type (no type) #define T_ABS 0x0001 // absolute symbol #define T_SEGMENT 0x0002 // segment type #define T_VOID 0x0003 // void #define T_PVOID 0x0103 // near pointer to void #define T_PFVOID 0x0203 // far pointer to void #define T_PHVOID 0x0303 // huge pointer to void #define T_32PVOID 0x0403 // 16:32 near pointer to void #define T_32PFVOID 0x0503 // 16:32 far pointer to void #define T_CURRENCY 0x0004 // BASIC 8 byte currency value #define T_NBASICSTR 0x0005 // Near BASIC string #define T_FBASICSTR 0x0006 // Far BASIC string #define T_NOTTRANS 0x0007 // type not translated by cvpack #define T_BIT 0x0060 // bit #define T_PASCHAR 0x0061 // Pascal CHAR // Character types #define T_CHAR 0x0010 // 8 bit signed #define T_UCHAR 0x0020 // 8 bit unsigned #define T_PCHAR 0x0110 // near pointer to 8 bit signed #define T_PUCHAR 0x0120 // near pointer to 8 bit unsigned #define T_PFCHAR 0x0210 // far pointer to 8 bit signed #define T_PFUCHAR 0x0220 // far pointer to 8 bit unsigned #define T_PHCHAR 0x0310 // huge pointer to 8 bit signed #define T_PHUCHAR 0x0320 // huge pointer to 8 bit unsigned #define T_32PCHAR 0x0410 // 16:32 near pointer to 8 bit signed #define T_32PUCHAR 0x0420 // 16:32 near pointer to 8 bit unsigned #define T_32PFCHAR 0x0510 // 16:32 far pointer to 8 bit signed #define T_32PFUCHAR 0x0520 // 16:32 far pointer to 8 bit unsigned // really a character types #define T_RCHAR 0x0070 // really a char #define T_PRCHAR 0x0170 // 16:16 near pointer to a real char #define T_PFRCHAR 0x0270 // 16:16 far pointer to a real char #define T_PHRCHAR 0x0370 // 16:16 huge pointer to a real char #define T_32PRCHAR 0x0470 // 16:32 near pointer to a real char #define T_32PFRCHAR 0x0570 // 16:32 far pointer to a real char // really a wide character types #define T_WCHAR 0x0071 // wide char #define T_PWCHAR 0x0171 // 16:16 near pointer to a wide char #define T_PFWCHAR 0x0271 // 16:16 far pointer to a wide char #define T_PHWCHAR 0x0371 // 16:16 huge pointer to a wide char #define T_32PWCHAR 0x0471 // 16:32 near pointer to a wide char #define T_32PFWCHAR 0x0571 // 16:32 far pointer to a wide char // 16 bit short types #define T_SHORT 0x0011 // 16 bit signed #define T_USHORT 0x0021 // 16 bit unsigned #define T_PSHORT 0x0111 // near pointer to 16 bit signed #define T_PUSHORT 0x0121 // near pointer to 16 bit unsigned #define T_PFSHORT 0x0211 // far pointer to 16 bit signed #define T_PFUSHORT 0x0221 // far pointer to 16 bit unsigned #define T_PHSHORT 0x0311 // huge pointer to 16 bit signed #define T_PHUSHORT 0x0321 // huge pointer to 16 bit unsigned #define T_32PSHORT 0x0411 // 16:32 near pointer to 16 bit signed #define T_32PUSHORT 0x0421 // 16:32 near pointer to 16 bit unsigned #define T_32PFSHORT 0x0511 // 16:32 far pointer to 16 bit signed #define T_32PFUSHORT 0x0521 // 16:32 far pointer to 16 bit unsigned // 16 bit int types #define T_INT2 0x0072 // 16 bit signed int #define T_UINT2 0x0073 // 16 bit unsigned int #define T_PINT2 0x0172 // near pointer to 16 bit signed int #define T_PUINT2 0x0173 // near pointer to 16 bit unsigned int #define T_PFINT2 0x0272 // far pointer to 16 bit signed int #define T_PFUINT2 0x0273 // far pointer to 16 bit unsigned int #define T_PHINT2 0x0372 // huge pointer to 16 bit signed int #define T_PHUINT2 0x0373 // huge pointer to 16 bit unsigned int #define T_32PINT2 0x0472 // 16:32 near pointer to 16 bit signed int #define T_32PUINT2 0x0473 // 16:32 near pointer to 16 bit unsigned int #define T_32PFINT2 0x0572 // 16:32 far pointer to 16 bit signed int #define T_32PFUINT2 0x0573 // 16:32 far pointer to 16 bit unsigned int // 32 bit long types #define T_LONG 0x0012 // 32 bit signed #define T_ULONG 0x0022 // 32 bit unsigned #define T_PLONG 0x0112 // near pointer to 32 bit signed #define T_PLONG 0x0112 // near pointer to 32 bit signed #define T_PULONG 0x0122 // near pointer to 32 bit unsigned #define T_PFLONG 0x0212 // far pointer to 32 bit signed #define T_PFULONG 0x0222 // far pointer to 32 bit unsigned #define T_PHLONG 0x0312 // huge pointer to 32 bit signed #define T_PHULONG 0x0322 // huge pointer to 32 bit unsigned #define T_32PLONG 0x0411 // 16:32 near pointer to 32 bit signed #define T_32PULONG 0x0421 // 16:32 near pointer to 32 bit unsigned #define T_32PFLONG 0x0511 // 16:32 far pointer to 32 bit signed #define T_32PFULONG 0x0521 // 16:32 far pointer to 32 bit unsigned // 32 bit int types #define T_INT4 0x0074 // 32 bit signed int #define T_UINT4 0x0075 // 32 bit unsigned int #define T_PINT4 0x0174 // near pointer to 32 bit signed int #define T_PUINT4 0x0175 // near pointer to 32 bit unsigned int #define T_PFINT4 0x0274 // far pointer to 32 bit signed int #define T_PFUINT4 0x0275 // far pointer to 32 bit unsigned int #define T_PHINT4 0x0374 // huge pointer to 32 bit signed int #define T_PHUINT4 0x0375 // huge pointer to 32 bit unsigned int #define T_32PINT4 0x0474 // 16:32 near pointer to 32 bit signed int #define T_32PUINT4 0x0475 // 16:32 near pointer to 32 bit unsigned int #define T_32PFINT4 0x0574 // 16:32 far pointer to 32 bit signed int #define T_32PFUINT4 0x0575 // 16:32 far pointer to 32 bit unsigned int // 64 bit quad types #define T_QUAD 0x0013 // 64 bit signed #define T_UQUAD 0x0023 // 64 bit unsigned #define T_PQUAD 0x0113 // near pointer to 64 bit signed #define T_PUQUAD 0x0123 // near pointer to 64 bit unsigned #define T_PFQUAD 0x0213 // far pointer to 64 bit signed #define T_PFUQUAD 0x0223 // far pointer to 64 bit unsigned #define T_PHQUAD 0x0313 // huge pointer to 64 bit signed #define T_PHUQUAD 0x0323 // huge pointer to 64 bit unsigned // 64 bit int types #define T_INT8 0x0076 // 64 bit signed int #define T_UINT8 0x0077 // 64 bit unsigned int #define T_PINT8 0x0176 // near pointer to 64 bit signed int #define T_PUINT8 0x0177 // near pointer to 64 bit unsigned int #define T_PFINT8 0x0276 // far pointer to 64 bit signed int #define T_PFUINT8 0x0277 // far pointer to 64 bit unsigned int #define T_PHINT8 0x0376 // huge pointer to 64 bit signed int #define T_PHUINT8 0x0377 // huge pointer to 64 bit unsigned int #define T_32PINT8 0x0476 // 16:32 near pointer to 64 bit signed int #define T_32PUINT8 0x0477 // 16:32 near pointer to 64 bit unsigned int #define T_32PFINT8 0x0576 // 16:32 far pointer to 64 bit signed int #define T_32PFUINT8 0x0577 // 16:32 far pointer to 64 bit unsigned int // 32 bit real types #define T_REAL32 0x0040 // 32 bit real #define T_PREAL32 0x0140 // near pointer to 32 bit real #define T_PFREAL32 0x0240 // far pointer to 32 bit real #define T_PHREAL32 0x0340 // huge pointer to 32 bit real #define T_32PREAL32 0x0440 // 16:32 near pointer to 32 bit real #define T_32PFREAL32 0x0540 // 16:32 far pointer to 32 bit real // 48 bit real types #define T_REAL48 0x0044 // 48 bit real #define T_PREAL48 0x0144 // near pointer to 48 bit real #define T_PFREAL48 0x0244 // far pointer to 48 bit real #define T_PHREAL48 0x0344 // huge pointer to 48 bit real #define T_32PREAL48 0x0444 // 16:32 near pointer to 48 bit real #define T_32PFREAL48 0x0544 // 16:32 far pointer to 48 bit real // 64 bit real types #define T_REAL64 0x0041 // 64 bit real #define T_PREAL64 0x0141 // near pointer to 64 bit real #define T_PFREAL64 0x0241 // far pointer to 64 bit real #define T_PHREAL64 0x0341 // huge pointer to 64 bit real #define T_32PREAL64 0x0441 // 16:32 near pointer to 64 bit real #define T_32PFREAL64 0x0541 // 16:32 far pointer to 64 bit real // 80 bit real types #define T_REAL80 0x0042 // 80 bit real #define T_PREAL80 0x0142 // near pointer to 80 bit real #define T_PFREAL80 0x0242 // far pointer to 80 bit real #define T_PHREAL80 0x0342 // huge pointer to 80 bit real #define T_32PREAL80 0x0442 // 16:32 near pointer to 80 bit real #define T_32PFREAL80 0x0542 // 16:32 far pointer to 80 bit real // 128 bit real types #define T_REAL128 0x0043 // 128 bit real #define T_PREAL128 0x0143 // near pointer to 128 bit real #define T_PFREAL128 0x0243 // far pointer to 128 bit real #define T_PHREAL128 0x0343 // huge pointer to 128 bit real #define T_32PREAL128 0x0443 // 16:32 near pointer to 128 bit real #define T_32PFREAL128 0x0543 // 16:32 far pointer to 128 bit real // 32 bit complex types #define T_CPLX32 0x0050 // 32 bit complex #define T_PCPLX32 0x0150 // near pointer to 32 bit complex #define T_PFCPLX32 0x0250 // far pointer to 32 bit complex #define T_PHCPLX32 0x0350 // huge pointer to 32 bit complex #define T_32PCPLX32 0x0450 // 16:32 near pointer to 32 bit complex #define T_32PFCPLX32 0x0550 // 16:32 far pointer to 32 bit complex // 48 bit complex types #define T_CPLX48 0x0054 // 48 bit complex #define T_PCPLX48 0x0154 // near pointer to 48 bit complex #define T_PFCPLX48 0x0254 // far pointer to 48 bit complex #define T_PHCPLX48 0x0354 // huge pointer to 48 bit complex #define T_32PCPLX48 0x0454 // 16:32 near pointer to 48 bit complex #define T_32PFCPLX48 0x0554 // 16:32 far pointer to 48 bit complex // 64 bit complex types #define T_CPLX64 0x0051 // 64 bit complex #define T_PCPLX64 0x0151 // near pointer to 64 bit complex #define T_PFCPLX64 0x0251 // far pointer to 64 bit complex #define T_PHCPLX64 0x0351 // huge pointer to 64 bit complex #define T_32PCPLX64 0x0451 // 16:32 near pointer to 64 bit complex #define T_32PFCPLX64 0x0551 // 16:32 far pointer to 64 bit complex // 80 bit complex types #define T_CPLX80 0x0052 // 80 bit complex #define T_PCPLX80 0x0152 // near pointer to 80 bit complex #define T_PFCPLX80 0x0252 // far pointer to 80 bit complex #define T_PHCPLX80 0x0352 // huge pointer to 80 bit complex #define T_32PCPLX80 0x0452 // 16:32 near pointer to 80 bit complex #define T_32PFCPLX80 0x0552 // 16:32 far pointer to 80 bit complex // 128 bit complex types #define T_CPLX128 0x0053 // 128 bit complex #define T_PCPLX128 0x0153 // near pointer to 128 bit complex #define T_PFCPLX128 0x0253 // far pointer to 128 bit complex #define T_PHCPLX128 0x0353 // huge pointer to 128 bit real #define T_32PCPLX128 0x0453 // 16:32 near pointer to 128 bit complex #define T_32PFCPLX128 0x0553 // 16:32 far pointer to 128 bit complex // boolean types #define T_BOOL08 0x0030 // 8 bit boolean #define T_BOOL16 0x0031 // 16 bit boolean #define T_BOOL32 0x0032 // 32 bit boolean #define T_PBOOL08 0x0130 // near pointer to 8 bit boolean #define T_PBOOL16 0x0131 // near pointer to 16 bit boolean #define T_PBOOL32 0x0132 // near pointer to 32 bit boolean #define T_PFBOOL08 0x0230 // far pointer to 8 bit boolean #define T_PFBOOL16 0x0231 // far pointer to 16 bit boolean #define T_PFBOOL32 0x0232 // far pointer to 32 bit boolean #define T_PHBOOL08 0x0330 // huge pointer to 8 bit boolean #define T_PHBOOL16 0x0331 // huge pointer to 16 bit boolean #define T_PHBOOL32 0x0332 // huge pointer to 32 bit boolean #define T_32PBOOL08 0x0430 // 16:32 near pointer to 8 bit boolean #define T_32PFBOOL08 0x0530 // 16:32 far pointer to 8 bit boolean #define T_32PBOOL16 0x0431 // 16:32 near pointer to 18 bit boolean #define T_32PFBOOL16 0x0531 // 16:32 far pointer to 16 bit boolean #define T_32PBOOL32 0x0432 // 16:32 near pointer to 32 bit boolean #define T_32PFBOOL32 0x0532 // 16:32 far pointer to 32 bit boolean #define T_NCVPTR 0x01f0 // CV Internal type for created near pointers #define T_FCVPTR 0x02f0 // CV Internal type for created far pointers #define T_HCVPTR 0x03f0 // CV Internal type for created huge pointers /** 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.. */ // leaf indices starting records but referenced from symbol records #define LF_MODIFIER 0x0001 #define LF_POINTER 0x0002 #define LF_ARRAY 0x0003 #define LF_CLASS 0x0004 #define LF_STRUCTURE 0x0005 #define LF_UNION 0x0006 #define LF_ENUM 0x0007 #define LF_PROCEDURE 0x0008 #define LF_MFUNCTION 0x0009 #define LF_VTSHAPE 0x000a #define LF_COBOL0 0x000b #define LF_COBOL1 0x000c #define LF_BARRAY 0x000d #define LF_LABEL 0x000e #define LF_NULL 0x000f #define LF_NOTTRAN 0x0010 #define LF_DIMARRAY 0x0011 #define LF_VFTPATH 0x0012 #define LF_PRECOMP 0x0013 // not refereced from symbol #define LF_ENDPRECOMP 0x0014 // not refereced from symbol // leaf indices starting records but referenced only from type records #define LF_SKIP 0x0200 #define LF_ARGLIST 0x0201 #define LF_DEFARG 0x0202 #define LF_LIST 0x0203 #define LF_FIELDLIST 0x0204 #define LF_DERIVED 0x0205 #define LF_BITFIELD 0x0206 #define LF_METHODLIST 0x0207 #define LF_DIMCONU 0x0208 #define LF_DIMCONLU 0x0209 #define LF_DIMVARU 0x020a #define LF_DIMVARLU 0x020b #define LF_REFSYM 0x020c #define LF_BCLASS 0x0400 #define LF_VBCLASS 0x0401 #define LF_IVBCLASS 0x0402 #define LF_ENUMERATE 0x0403 #define LF_FRIENDFCN 0x0404 #define LF_INDEX 0x0405 #define LF_MEMBER 0x0406 #define LF_STMEMBER 0x0407 #define LF_METHOD 0x0408 #define LF_NESTTYPE 0x0409 #define LF_VFUNCTAB 0x040a #define LF_FRIENDCLS 0x040b #define LF_NUMERIC 0x8000 #define LF_CHAR 0x8000 #define LF_SHORT 0x8001 #define LF_USHORT 0x8002 #define LF_LONG 0x8003 #define LF_ULONG 0x8004 #define LF_REAL32 0x8005 #define LF_REAL64 0x8006 #define LF_REAL80 0x8007 #define LF_REAL128 0x8008 #define LF_QUADWORD 0x8009 #define LF_UQUADWORD 0x800a #define LF_REAL48 0x800b #define LF_PAD0 0xf0 #define LF_PAD1 0xf1 #define LF_PAD2 0xf2 #define LF_PAD3 0xf3 #define LF_PAD4 0xf4 #define LF_PAD5 0xf5 #define LF_PAD6 0xf6 #define LF_PAD7 0xf7 #define LF_PAD8 0xf8 #define LF_PAD9 0xf9 #define LF_PAD10 0xfa #define LF_PAD11 0xfb #define LF_PAD12 0xfc #define LF_PAD13 0xfd #define LF_PAD14 0xfe #define LF_PAD15 0xff // end of leaf indices // Type enum for pointer records // Pointers can be one of the following types typedef enum CV_ptrtype_e { CV_PTR_NEAR = 0x00, // near pointer CV_PTR_FAR = 0x01, // far pointer CV_PTR_HUGE = 0x02, // huge pointer 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, // 16:32 near pointer CV_PTR_FAR32 = 0x0b, // 16:32 far pointer CV_PTR_UNUSEDPTR = 0x0c // first unused pointer type } CV_ptrtype_e; // Mode enum for pointers // Pointers can have one of the following modes typedef enum CV_ptrmode_e { 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 } CV_ptrmode_e; // Enumeration for function call type typedef enum CV_call_e { CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack CV_CALL_SKIPPED = 0x06, // skipped (unused) call index CV_CALL_NEAR_STD = 0x07, // near standard call CV_CALL_FAR_STD = 0x08, // far standard call CV_CALL_NEAR_SYS = 0x09, // near sys call CV_CALL_FAR_SYS = 0x0a, // far sys call CV_CALL_THISCALL = 0x0b, // this call (this passed in register) CV_CALL_RESERVED = 0x0c // first unused call enumeration } CV_call_e; // Values for the access protection of class attributes typedef enum CV_access_e { CV_private = 1, CV_protected = 2, CV_public = 3 } CV_access_e; // enumeration for method properties typedef enum CV_methodprop_e { CV_MTvanilla = 0x00, CV_MTvirtual = 0x01, CV_MTstatic = 0x02, CV_MTfriend = 0x03, CV_MTintro = 0x04, CV_MTpurevirt = 0x05, CV_MTpureintro = 0x06, } CV_methodprop_e; // enumeration for virtual shape table entries typedef enum CV_VTS_desc_e { 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, } CV_VTS_desc_e; // enumeration for LF_LABEL address modes typedef enum CV_LABEL_TYPE_e { CV_LABEL_NEAR = 0, // near return CV_LABEL_FAR = 4, // far return } CV_LABEL_TYPE_e; // enumeration for LF_MODIFIER values typedef struct CV_modifier_t { unsigned short MOD_const :1; unsigned short MOD_volatile :1; unsigned short MOD_unused :14; } CV_modifier_t; // bit field structure describing class/struct/union/enum properties typedef struct CV_prop_t { unsigned short packed :1; // true if structure is packed unsigned short ctor :1; // true if constructors or destructors present unsigned short ovlops :1; // true if overloaded operators present unsigned short isnested :1; // true if this is a nested class unsigned short cnested :1; // true if this class contains nested types unsigned short opassign :1; // true if overloaded assignment (=) unsigned short opcast :1; // true if casting methods unsigned short fwdref :1; // true if forward reference (incomplete defn) unsigned short reserved :8; } CV_prop_t; // class field attribute typedef struct CV_fldattr_t { unsigned short access :2; // access protection CV_access_t unsigned short mprop :3; // method properties CV_methodprop_t unsigned short pseudo :1; // compiler generated fcn and does not exist unsigned short noinherit :1; // true if class cannot be inherited unsigned short noconstruct :1; // true if class cannot be constructed unsigned short unused :8; // unused } CV_fldattr_t; // Structures to access to the type records typedef struct TYPTYPE { unsigned short len; unsigned short leaf; unsigned char data[]; } TYPTYPE; // general types record typedef enum CV_PMEMBER { CV_PDM16_NONVIRT = 0x00, // 16:16 data no virtual fcn or base (null = -1) CV_PDM16_VFCN = 0x01, // 16:16 data with virtual functions null = 0 CV_PDM16_VBASE = 0x02, // 16:16 data with virtual bases null = (,,-1) CV_PDM32_NVVFCN = 0x03, // 16:32 data w/wo virtual functions null = 0x80000000 CV_PDM32_VBASE = 0x04, // 16:32 data with virtual bases (,,-1L) CV_PMF16_NEARNVSA = 0x05, // 16:16 near method nonvirtual single address point CV_PMF16_NEARNVMA = 0x06, // 16:16 near method nonvirtual multiple address points CV_PMF16_NEARVBASE = 0x07, // 16:16 near method virtual bases CV_PMF16_FARNVSA = 0x08, // 16:16 far method nonvirtual single address point CV_PMF16_FARNVMA = 0x09, // 16:16 far method nonvirtual multiple address points CV_PMF16_FARVBASE = 0x0a, // 16:16 far method virtual bases CV_PMF32_NVSA = 0x0b, // 16:32 method nonvirtual single address point CV_PMF32_NVMA = 0x0c, // 16:32 method nonvirtual multiple address point CV_PMF32_VBASE = 0x0d, // 16:32 method virtual bases } CV_PMEMBER; // memory representation of pointer to member. These representations are // indexed by the enumeration above in the LF_POINTER record // representation of a 16:16 pointer to data for a class with no // virtual functions or virtual bases typedef struct CV_PDMR16_NONVIRT { CV_off16_t mdisp; // displacement to data (NULL = -1) }; // representation of a 16:16 pointer to data for a class with virtual // functions typedef struct CV_PMDR16_VFCN { CV_off16_t mdisp; // displacement to data ( NULL = 0) }; // representation of a 16:16 pointer to data for a class with // virtual bases typedef struct CV_PDMR16_VBASE { CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement to vbptr CV_off16_t vdisp; // displacement within vbase table // NULL = (,,0xffff) }; // representation of a 16:32 near pointer to data for a class with // or without virtual functions and no virtual bases typedef struct CV_PDMR32_NVVFCN { CV_off32_t mdisp; // displacement to data (NULL = 0x80000000) }; // representation of a 16:32 near pointer to data for a class // with virtual bases typedef struct CV_PDMR32_VBASE { CV_off32_t mdisp; // displacement to data CV_off32_t pdisp; // this pointer displacement CV_off32_t vdisp; // vbase table displacement // NULL = (,,0xffffffff) }; // representation of a 16:16 pointer to near member function for a // class with no virtual functions or bases and a single address point typedef struct CV_PMFR16_NEARNVSA { CV_uoff16_t off; // near address of function (NULL = 0) }; // representation of a 16:16 pointer to far member function for a // class with no virtual bases and a single address point typedef struct CV_PMFR16_FARNVSA { CV_uoff16_t off; // offset of function (NULL = 0:0) unsigned short seg; // segment of function }; // representation of a 16:16 near pointer to member functions of a // class with no virtual bases and multiple address points typedef struct CV_PMFR16_NEARNVMA { CV_uoff16_t off; // offset of function (NULL = 0,x) signed short disp; }; // representation of a 16:16 far pointer to member functions of a // class with no virtual bases and multiple address points typedef struct CV_PMFR16_FARNVMA { CV_uoff16_t off; // offset of function (NULL = 0:0,x) unsigned short seg; signed short disp; }; // representation of a 16:16 near pointer to member function of a // class with virtual bases typedef struct CV_PMFR16_NEARVBASE { CV_uoff16_t off; // offset of function (NULL = 0,x,x,x) CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement CV_off16_t vdisp; // vbase table displacement }; // representation of a 16:16 far pointer to member function of a // class with virtual bases typedef struct CV_PMFR16_FARVBASE { CV_uoff16_t off; // offset of function (NULL = 0:0,x,x,x) unsigned short seg; CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement CV_off16_t vdisp; // vbase table displacement }; // representation of a 16:32 near pointer to member function for a // class with no virtual bases and a single address point typedef struct CV_PMFR32_NVSA { CV_uoff32_t off; // near address of function (NULL = 0L) }; // representation of a 16:32 near pointer to member function for a // class with no virtual bases and multiple address points typedef struct CV_PMFR32_NVMA { CV_uoff32_t off; // near address of function (NULL = 0L,x) CV_off32_t disp; }; // representation of a 16:32 near pointer to member function for a // class with virtual bases typedef struct CV_PMFR32_VBASE { CV_uoff32_t off; // near address of function (NULL = 0L,x,x,x) CV_off32_t mdisp; // displacement to data CV_off32_t pdisp; // this pointer displacement CV_off32_t vdisp; // vbase table displacement }; // Easy leaf - used for generic casting to reference leaf field // of a subfield of a complex list typedef struct lfEasy { unsigned short leaf; // LF_... } lfEasy; /** The following type records are basically variant records of the * above structure. The "unsigned short leaf" of the above structure and * the "unsigned short leaf" of the following type definitions are the same * symbol. When the OMF record is locked via the MHOMFLock API * call, the address of the "unsigned short leaf" is returned */ // Type record for LF_MODIFIER typedef struct lfModifier { unsigned short leaf; // LF_MODIFIER CV_modifier_t attr; // modifier attribute modifier_t CV_typ_t type; // modified type } lfModifier; // type record for LF_POINTER typedef struct lfPointer { struct lfPointerBody { unsigned short leaf; // LF_POINTER struct { unsigned char ptrtype :5; // ordinal specifying pointer type (ptrtype-t) unsigned char ptrmode :3; // ordinal specifying pointer mode (ptrmode_t) unsigned char isflat32 :1; // true if 0:32 pointer unsigned char isvolatile :1; // TRUE if volatile pointer unsigned char isconst :1; // TRUE if const pointer unsigned char unused :5; } attr; CV_typ_t utype; // type index of the underlying type }; union { struct { CV_typ_t pmclass; // index of containing class for pointer to member unsigned short pmenum; // enumeration specifying pm format } pm; unsigned short bseg; // base segment if PTR_BASE_SEG unsigned char Sym[1]; // copy of base symbol record (including length) struct { unsigned short index; // type index if CV_PTR_BASE_TYPE unsigned char name[1]; // name of base type } btype; } pbase; } lfPointer; // type record for LF_ARRAY typedef struct lfArray { unsigned short leaf; // LF_ARRAY CV_typ_t elemtype; // type index of element type CV_typ_t idxtype; // type index of indexing type unsigned char data[]; // variable length data specifying // size in bytes and name } lfArray; // type record for LF_CLASS, LF_STRUCTURE typedef struct lfClass { unsigned short leaf; // LF_CLASS, LF_STRUCT unsigned short count; // count of number of elements in class CV_typ_t field; // type index of LF_FIELD descriptor list CV_prop_t property; // property attribute field (prop_t) CV_typ_t derived; // type index of derived from list if not zero CV_typ_t vshape; // type index of vshape table for this class unsigned char data[]; // data describing length of structure in // bytes and name } lfClass; typedef lfClass lfStructure; // type record for LF_UNION typedef struct lfUnion { unsigned short leaf; // LF_UNION unsigned short count; // count of number of elements in class CV_typ_t field; // type index of LF_FIELD descriptor list CV_prop_t property; // property attribute field unsigned char data[]; // variable length data describing length of // structure and name } lfUnion; // type record for LF_ENUM typedef struct lfEnum { unsigned short leaf; // LF_ENUM unsigned short count; // count of number of elements in class CV_typ_t utype; // underlying type of the enum CV_typ_t field; // type index of LF_FIELD descriptor list CV_prop_t property; // property attribute field unsigned char Name[1]; // length prefixed name of enum } lfEnum; // Type record for LF_PROCEDURE typedef struct lfProc { unsigned short leaf; // LF_PROCEDURE CV_typ_t rvtype; // type index of return value unsigned char calltype; // calling convention (CV_call_t) unsigned char reserved; // reserved for future use unsigned short parmcount; // number of parameters CV_typ_t arglist; // type index of argument list } lfProc; // Type record for member function typedef struct lfMFunc { unsigned short leaf; // LF_MFUNCTION CV_typ_t rvtype; // type index of return value CV_typ_t classtype; // type index of containing class CV_typ_t thistype; // type index of this pointer (model specific) unsigned char calltype; // calling convention (call_t) unsigned char reserved; // reserved for future use unsigned short parmcount; // number of parameters CV_typ_t arglist; // type index of argument list long thisadjust; // this adjuster (long because pad required anyway) } lfMFunc; // type record for virtual function table shape typedef struct lfVTShape { unsigned short leaf; // LF_VTSHAPE unsigned short count; // number of entries in vfunctable unsigned char desc[]; // 4 bit (CV_VTS_desc) descriptors } lfVTShape; // type record for cobol0 typedef struct lfCobol0 { unsigned short leaf; // LF_COBOL0 CV_typ_t type; unsigned char data[]; } lfCobol0; // type record for cobol1 typedef struct lfCobol1 { unsigned short leaf; // LF_COBOL1 unsigned char data[]; } lfCobol1; // type record for basic array typedef struct lfBArray { unsigned short leaf; // LF_BARRAY CV_typ_t utype; // type index of underlying type } lfBArray; // type record for assembler labels typedef struct lfLabel { unsigned short leaf; // LF_LABEL unsigned short mode; // addressing mode of label } lfLabel; // type record for dimensioned arrays typedef struct lfDimArray { unsigned short leaf; // LF_DIMARRAY CV_typ_t utype; // underlying type of the array CV_typ_t diminfo; // dimension information char name[1]; // length prefixed name } lfDimArray; // type record describing path to virtual function table typedef struct lfVFTPath { unsigned short leaf; // LF_VFTPATH unsigned short count; // count of number of bases in path CV_typ_t base[1]; // bases from root to leaf } lfVFTPath; // type record describing inclusion of precompiled types typedef struct lfPreComp { unsigned short leaf; // LF_PRECOMP unsigned short start; // starting type index included unsigned short count; // number of types in inclusion unsigned long signature; // signature unsigned char name[]; // length prefixed name of included type file } lfPreComp; // type record describing end of precompiled types that can be // included by another file typedef struct lfEndPreComp { unsigned short leaf; // LF_ENDPRECOMP unsigned long signature; // signature } lfEndPreComp; // description of type records that can be referenced from // type records referenced by symbols // type record for skip record typedef struct lfSkip { unsigned short leaf; // LF_SKIP CV_typ_t type; // next valid index unsigned char data[]; // pad data } lfSkip; // argument list leaf typedef struct lfArgList { unsigned short leaf; // LF_ARGLIST unsigned short count; // number of arguments CV_typ_t arg[]; // number of arguments } lfArgList; // derived class list leaf typedef struct lfDerived { unsigned short leaf; // LF_DERIVED unsigned short count; // number of arguments CV_typ_t drvdcls[]; // type indices of derived classes } lfDerived; // leaf for default arguments typedef struct lfDefArg { unsigned short leaf; // LF_DEFARG CV_typ_t type; // type of resulting expression unsigned char expr[]; // length prefixed expression string } lfDefArg; // 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. typedef struct lfList { unsigned short leaf; // LF_LIST char data[]; // data format specified by indexing type } lfList; // field list leaf // This is the header leaf for a complex list of class and structure // subfields. typedef struct lfFieldList { unsigned short leaf; // LF_FIELDLIST char data[]; // field list sub lists } lfFieldList; // type record for non-static methods and friends in method list typedef struct mlMethod { CV_fldattr_t attr; // method attribute CV_typ_t index; // index to type record for procedure unsigned long vbaseoff[0]; // offset in vfunctable if intro virtual } mlMethod; typedef struct lfMethodList { unsigned short leaf; unsigned char mList[]; // really a mlMethod type } lfMethodList; // type record for LF_BITFIELD typedef struct lfBitfield { unsigned short leaf; // LF_BITFIELD unsigned char length; unsigned char position; CV_typ_t type; // type of bitfield } lfBitfield; // type record for dimensioned array with constant bounds typedef struct lfDimCon { unsigned short leaf; // LF_DIMCONU or LF_DIMCONLU unsigned short rank; // number of dimensions CV_typ_t typ; // type of index unsigned char dim[]; // array of dimension information with // either upper bounds or lower/upper bound } lfDimCon; // type record for dimensioned array with variable bounds typedef struct lfDimVar { unsigned short leaf; // LF_DIMVARU or LF_DIMVARLU unsigned short rank; // number of dimensions CV_typ_t typ; // type of index unsigned char dim[]; // array of type indices for either // variable upper bound or variable // lower/upper bound. The referenced // types must be LF_REFSYM or T_VOID } lfDimVar; // type record for referenced symbol typedef struct lfRefSym { unsigned short leaf; // LF_REFSYM unsigned char Sym[1]; // copy of referenced symbol record // (including length) } lfRefSym; /** 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 typedef struct lfChar { unsigned short leaf; // LF_CHAR signed char val; // signed 8-bit value } lfChar; // signed short leaf typedef struct lfShort { unsigned short leaf; // LF_SHORT short val; // signed 16-bit value } lfShort; // unsigned short leaf typedef struct lfUShort { unsigned short leaf; // LF_unsigned short unsigned short val; // unsigned 16-bit value } lfUShort; // signed long leaf typedef struct lfLong { unsigned short leaf; // LF_LONG long val; // signed 32-bit value } lfLong; // unsigned long leaf typedef struct lfULong { unsigned short leaf; // LF_ULONG unsigned long val; // unsigned 32-bit value } lfULong; // real 32-bit leaf typedef struct lfReal32 { unsigned short leaf; // LF_REAL32 float val; // 32-bit real value } lfReal32; // real 48-bit leaf typedef struct lfReal48 { unsigned short leaf; // LF_REAL48 unsigned char val[6]; // 48-bit real value } lfReal48; // real 64-bit leaf typedef struct lfReal64 { unsigned short leaf; // LF_REAL64 double val; // 64-bit real value } lfReal64; // real 80-bit leaf typedef struct lfReal80 { unsigned short leaf; // LF_REAL80 long double val; // real 80-bit value } lfReal80; // real 128-bit leaf typedef struct lfReal128 { unsigned short leaf; // LF_REAL128 char val[16]; // real 128-bit value } lfReal128; //*********************************************************************** // 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. typedef struct lfIndex { unsigned short leaf; // LF_INDEX CV_typ_t index; // type index of referenced leaf } lfIndex; // subfield record for base class field typedef struct lfBClass { unsigned short leaf; // LF_BCLASS CV_typ_t index; // type index of base class CV_fldattr_t attr; // attribute unsigned char offset[]; // variable length offset of base within class } lfBClass; // subfield record for direct and indirect virtual base class field typedef struct lfVBClass { unsigned short leaf; // LF_VBCLASS | LV_IVBCLASS CV_typ_t index; // type index of direct virtual base class CV_typ_t vbptr; // type index of virtual base pointer CV_fldattr_t attr; // attribute unsigned char vbpoff[]; // virtual base pointer offset from address point // followed by virtual base offset from vbtable } lfVBClass; // subfield record for friend class typedef struct lfFriendCls { unsigned short leaf; // LF_FRIENDCLS CV_typ_t index; // index to type record of friend class } lfFriendCls; // subfield record for friend function typedef struct lfFriendFcn { unsigned short leaf; // LF_FRIENDFCN CV_typ_t index; // index to type record of friend function char Name[1]; // name of friend function } lfFriendFcn; // subfield record for non-static data members typedef struct lfMember { unsigned short leaf; // LF_MEMBER CV_typ_t index; // index of type record for field CV_fldattr_t attr; // attribute mask unsigned char offset[]; // variable length offset of field followed // by length prefixed name of field } lfMember; // type record for static data members typedef struct lfSTMember { unsigned short leaf; // LF_STMEMBER CV_typ_t index; // index of type record for field CV_fldattr_t attr; // attribute mask char Name[1]; // length prefixed name of field } lfSTMember; // subfield record for virtual function table pointer typedef struct lfVFuncTab { unsigned short leaf; // LF_VFUNCTAB CV_typ_t type; // type index of pointer } lfVFuncTab; // subfield record for method list typedef struct lfMethod { unsigned short leaf; // LF_METHOD unsigned short count; // number of occurances of function CV_typ_t mList; // index to LF_METHODLIST record char Name[1]; // length prefixed name of method } lfMethod; // subfield record for enumerate typedef struct lfEnumerate { unsigned short leaf; // LF_ENUMERATE CV_fldattr_t attr; // access unsigned char value[]; // variable length value field followed // by length prefixed name } lfEnumerate; // type record for nested (scoped) type definition typedef struct lfNestType { unsigned short leaf; // LF_NESTTYPE CV_typ_t index; // index of nested type definition unsigned char Name[1]; // length prefixed type name } lfNestType; // type record for pad leaf typedef struct lfPad { unsigned char leaf; } SYM_PAD; // Symbol definitions typedef enum SYM_ENUM_e { S_COMPILE = 0x0001, // Compile flags symbol S_REGISTER = 0x0002, // Register variable S_CONSTANT = 0x0003, // constant symbol S_UDT = 0x0004, // User defined type S_SSEARCH = 0x0005, // Start Search S_END = 0x0006, // Block, procedure, "with" or thunk end S_SKIP = 0x0007, // Reserve symbol space in $$Symbols table S_CVRESERVE = 0x0008, // Reserve symbol for CV internal use S_OBJNAME = 0x0009, // path to object file name S_BPREL16 = 0x0100, // BP-relative S_LDATA16 = 0x0101, // Module-local symbol S_GDATA16 = 0x0102, // Global data symbol S_PUB16 = 0x0103, // a public symbol S_LPROC16 = 0x0104, // Local procedure start S_GPROC16 = 0x0105, // Global procedure start S_THUNK16 = 0x0106, // Thunk Start S_BLOCK16 = 0x0107, // block start S_WITH16 = 0x0108, // with start S_LABEL16 = 0x0109, // code label S_CEXMODEL16 = 0x010a, // change execution model S_VFTABLE16 = 0x010b, // address of virtual function table S_BPREL32 = 0x0200, // BP-relative S_LDATA32 = 0x0201, // Module-local symbol S_GDATA32 = 0x0202, // Global data symbol S_PUB32 = 0x0203, // a public symbol (CV internal reserved) S_LPROC32 = 0x0204, // Local procedure start S_GPROC32 = 0x0205, // Global procedure start S_THUNK32 = 0x0206, // Thunk Start S_BLOCK32 = 0x0207, // block start S_WITH32 = 0x0208, // with start S_LABEL32 = 0x0209, // code label S_CEXMODEL32 = 0x020a, // change execution model S_VFTABLE32 = 0x020b, // address of virtual function table } SYM_ENUM_e; // enum describing the compile flag source language typedef enum { CV_CFL_C = 0x00, CV_CFL_CXX = 0x01, CV_CFL_FORTRAN = 0x02, CV_CFL_MASM = 0x03, CV_CFL_PASCAL = 0x04, CV_CFL_BASIC = 0x05, CV_CFL_COBOL = 0x06 } CV_CFL_LANG; // enum describing target processor typedef enum CV_CPU_TYPE_e { CV_CFL_8080 = 0x00, CV_CFL_8086 = 0x01, CV_CFL_80286 = 0x02, CV_CFL_80386 = 0x03, CV_CFL_80486 = 0x04, CV_CFL_MIPSR4000 = 0x10, CV_CFL_M68000 = 0x20, CV_CFL_M68010 = 0x21, CV_CFL_M68020 = 0x22, CV_CFL_M68030 = 0x23, CV_CFL_M68040 = 0x24, } CV_CPU_TYPE_e; // enum describing compile flag ambiant data model typedef enum { CV_CFL_DNEAR = 0x00, CV_CFL_DFAR = 0x01, CV_CFL_DHUGE = 0x02 } CV_CFL_DATA; // enum describing compile flag ambiant code model typedef enum CV_CFL_CODE_e { CV_CFL_CNEAR = 0x00, CV_CFL_CFAR = 0x01, CV_CFL_CHUGE = 0x02 } CV_CFL_CODE_e; // enum describing compile flag target floating point package typedef enum CV_CFL_FPKG_e { CV_CFL_NDP = 0x00, CV_CFL_EMU = 0x01, CV_CFL_ALT = 0x02 } CV_CFL_FPKG_e; typedef struct SYMTYPE { unsigned short reclen; // Record length unsigned short rectyp; // Record type char data[]; } SYMTYPE; // non-model specific symbol types typedef struct REGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_REGISTER unsigned short typind; // Type index unsigned short reg; // register enumerate unsigned char name[1]; // Length-prefixed name } REGSYM; typedef struct CONSTSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_CONSTANT CV_typ_t typind; // Type index (containing enum if enumerate) unsigned short value; // numeric leaf containing value unsigned char name[]; // Length-prefixed name } CONSTSYM; typedef struct UDTSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_UDT CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } UDTSYM; typedef struct SEARCHSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_SSEARCH unsigned long startsym; // offset of the procedure unsigned short seg; // segment of symbol } SEARCHSYM; typedef struct CFLAGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_COMPILE unsigned char machine; // target processor struct { unsigned char language :8; // language index unsigned char pcode :1; // true if pcode present unsigned char floatprec :2; // floating precision unsigned char floatpkg :2; // float package unsigned char ambdata :3; // ambiant data model unsigned char ambcode :3; // ambiant code model unsigned char mode32 :1; // true if compiled 32 bit mode unsigned char pad :4; // reserved } flags; unsigned char ver[1]; // Length-prefixed compiler version string } CFLAGSYM; typedef struct OBJNAMESYM { unsigned short reclen; // Record length unsigned short rectyp; // S_OBJNAME unsigned long signature; // signature unsigned char name[1]; // Length-prefixed name } OBJNAMESYM; // symbol types for 16:16 memory model typedef struct BPRELSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_BPREL16 CV_off16_t off; // BP-relative offset CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } BPRELSYM16; typedef struct DATASYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_LDATA or S_GDATA CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } DATASYM16; typedef DATASYM16 PUBSYM16; typedef struct PROCSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC16 or S_LPROC16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol unsigned short len; // Proc length unsigned short DbgStart; // Debug start offset unsigned short DbgEnd; // Debug end offset CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol CV_typ_t typind; // Type index char rtntyp; // Return type (NEAR/FAR) unsigned char name[1]; // Length-prefixed name } PROCSYM16; typedef struct THUNKSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned short len; // length of thunk unsigned char ord; // ordinal specifying type of thunk unsigned char name[1]; // name of thunk unsigned char variant[0]; // variant portion of thunk } THUNKSYM16; typedef enum { THUNK_ORDINAL_NOTYPE, THUNK_ORDINAL_ADJUSTOR, THUNK_ORDINAL_VCALL } THUNK_ORDINAL; typedef struct LABELSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_LABEL16 CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol char rtntyp; // Return type (NEAR/FAR) unsigned char name[1]; // Length-prefixed name } LABELSYM16; typedef enum CV_RETURN_TYPE_e { CV_RETURN_NEAR = 0, // near return CV_RETURN_FAR = 4, // far return } CV_RETURN_TYPE_e; typedef struct BLOCKSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned short len; // Block length CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned char name[1]; // Length-prefixed name } BLOCKSYM16; typedef struct WITHSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned short len; // Block length CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned char expr[1]; // Length-prefixed expression } WITHSYM16; typedef enum CEXM_MODEL_e { CEXM_MDL_table = 0x00, // not executable CEXM_MDL_native = 0x20, // native CEXM_MDL_pcode = 0x40 // pcode } CEXM_MODEL_e; typedef struct CEXMSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_CEXMODEL16 CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned short model; // execution model union variant { struct { CV_uoff16_t pcdtable; // offset to pcode function table CV_uoff16_t pcdspi; // offset to segment pcode information } pcode; }; } CEXMSYM16; typedef struct VPATHSYM16 { unsigned short reclen; // record length unsigned short rectyp; // S_VFTPATH16 CV_uoff16_t off; // offset of virtual function table unsigned short seg; // segment of virtual function table CV_typ_t root; // type index of the root of path CV_typ_t path; // type index of the path record } VPATHSYM16; typedef struct BPRELSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_BPREL32 CV_off32_t off; // BP-relative offset CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } BPRELSYM32; typedef struct DATASYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_LDATA32, S_GDATA32 or S_PUB32 CV_uoff32_t off; unsigned short seg; CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } DATASYM32; typedef DATASYM32 PUBSYM32; typedef struct PROCSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC32 or S_LPROC32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol unsigned long len; // Proc length unsigned long DbgStart; // Debug start offset unsigned long DbgEnd; // Debug end offset CV_uoff32_t off; unsigned short seg; CV_typ_t typind; // Type index char rtntyp; // Return type (NEAR/FAR) unsigned char name[1]; // Length-prefixed name } PROCSYM32; typedef struct THUNKSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol CV_uoff32_t off; unsigned short seg; unsigned short len; // length of thunk unsigned char ord; // ordinal specifying type of thunk unsigned char name[1]; // Length-prefixed name unsigned char variant[0]; // variant portion of thunk } THUNKSYM32; typedef struct LABELSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_LABEL32 CV_uoff32_t off; unsigned short seg; char rtntyp; // Return type (NEAR/FAR) unsigned char name[1]; // Length-prefixed name } LABELSYM32; typedef struct BLOCKSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long len; // Block length CV_uoff32_t off; // Offset in code segment unsigned short seg; // segment of label unsigned char name[1]; // Length-prefixed name } BLOCKSYM32; typedef struct WITHSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long len; // Block length CV_uoff32_t off; // Offset in code segment unsigned short seg; // segment of label unsigned char expr[1]; // Length-prefixed expression string } WITHSYM32; typedef struct VPATHSYM32 { unsigned short reclen; // record length unsigned short rectyp; // S_VFTPATH16 CV_uoff32_t off; // offset of virtual function table unsigned short seg; // segment of virtual function table CV_typ_t root; // type index of the root of path CV_typ_t path; // type index of the path record } VPATHSYM32; // generic block definition symbols // these are similar to the equivalent 16:16 or 16:32 symbols but // only define the length, type and linkage fields typedef struct PROCSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC16 or S_LPROC16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol } PROCSYM; typedef struct THUNKSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol } THUNKSYM; typedef struct BLOCKSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end } BLOCKSYM; typedef struct WITHSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end } WITHSYM; typedef enum CV_HREG_e { CV_REG_NONE = 0, CV_REG_AL = 1, CV_REG_CL = 2, CV_REG_DL = 3, CV_REG_BL = 4, CV_REG_AH = 5, CV_REG_CH = 6, CV_REG_DH = 7, CV_REG_BH = 8, CV_REG_AX = 9, CV_REG_CX = 10, CV_REG_DX = 11, CV_REG_BX = 12, CV_REG_SP = 13, CV_REG_BP = 14, CV_REG_SI = 15, CV_REG_DI = 16, CV_REG_EAX = 17, CV_REG_ECX = 18, CV_REG_EDX = 19, CV_REG_EBX = 20, CV_REG_ESP = 21, CV_REG_EBP = 22, CV_REG_ESI = 23, CV_REG_EDI = 24, CV_REG_ES = 25, CV_REG_CS = 26, CV_REG_SS = 27, CV_REG_DS = 28, CV_REG_FS = 29, CV_REG_GS = 30, CV_REG_IP = 31, CV_REG_FLAGS = 32, CV_REG_EIP = 33, CV_REG_TEMP = 40, // PCODE Temp CV_REG_TEMPH = 41, // PCODE TempH CV_REG_QUOTE = 42, // PCODE Quote CV_REG_PCDR3 = 43, // PCODE reserved CV_REG_PCDR4 = 44, // PCODE reserved CV_REG_PCDR5 = 45, // PCODE reserved CV_REG_PCDR6 = 46, // PCODE reserved CV_REG_PCDR7 = 47, // PCODE reserved CV_REG_ST0 = 128, CV_REG_ST1 = 129, CV_REG_ST2 = 130, CV_REG_ST3 = 131, CV_REG_ST4 = 132, CV_REG_ST5 = 133, CV_REG_ST6 = 134, CV_REG_ST7 = 135, CV_REG_CTRL = 136, CV_REG_STAT = 137, CV_REG_TAG = 138, CV_REG_FPIP = 139, CV_REG_FPCS = 140, CV_REG_FPDO = 141, CV_REG_FPDS = 142, CV_REG_ISEM = 143, CV_R68_D0 = 0, CV_R68_D1 = 1, CV_R68_D2 = 2, CV_R68_D3 = 3, CV_R68_D4 = 4, CV_R68_D5 = 5, CV_R68_D6 = 6, CV_R68_D7 = 7, CV_R68_A0 = 8, CV_R68_A1 = 9, CV_R68_A2 = 10, CV_R68_A3 = 11, CV_R68_A4 = 12, CV_R68_A5 = 13, CV_R68_A6 = 14, CV_R68_A7 = 15, CV_R68_CCR = 16, CV_R68_SR = 17, CV_R68_USP = 18, CV_R68_MSP = 19, CV_R68_SFC = 20, CV_R68_DFC = 21, CV_R68_CACR = 22, CV_R68_VBR = 23, CV_R68_CAAR = 24, CV_R68_ISP = 25, CV_R68_PC = 26, //reserved 27 CV_R68_FPCR = 28, CV_R68_FPSR = 29, CV_R68_FPIAR= 30, //reserved 31 CV_R68_FP0 = 32, CV_R68_FP1 = 33, CV_R68_FP2 = 34, CV_R68_FP3 = 35, CV_R68_FP4 = 36, CV_R68_FP5 = 37, CV_R68_FP6 = 38, CV_R68_FP7 = 39, //reserved 40-50 CV_R68_PSR = 51, CV_R68_PCSR = 52, CV_R68_VAL = 53, CV_R68_CRP = 54, CV_R68_SRP = 55, CV_R68_DRP = 56, CV_R68_TC = 57, CV_R68_AC = 58, CV_R68_SCC = 59, CV_R68_CAL = 60, CV_R68_TT0 = 61, CV_R68_TT1 = 62, //reserved 63 CV_R68_BAD0 = 64, CV_R68_BAD1 = 65, CV_R68_BAD2 = 66, CV_R68_BAD3 = 67, CV_R68_BAD4 = 68, CV_R68_BAD5 = 69, CV_R68_BAD6 = 70, CV_R68_BAD7 = 71, CV_R68_BAC0 = 72, CV_R68_BAC1 = 73, CV_R68_BAC2 = 74, CV_R68_BAC3 = 75, CV_R68_BAC4 = 76, CV_R68_BAC5 = 77, CV_R68_BAC6 = 78, CV_R68_BAC7 = 79, } CV_HREG_e; #pragma pack()