diff --git a/pykd/dbgext.cpp b/pykd/dbgext.cpp index 763c2eb..a9ab56b 100644 --- a/pykd/dbgext.cpp +++ b/pykd/dbgext.cpp @@ -165,12 +165,21 @@ BOOST_PYTHON_MODULE( pykd ) "Retrieves the unique symbol identifier") .def( "udtKind", &pyDia::Symbol::getUdtKind, "Retrieves the variety of a user-defined type") + .def("registerId", &pyDia::Symbol::getRegisterId, + "Retrieves the register designator of the location:\n" + "CV_REG_XXX (for IMAGE_FILE_MACHINE_I386) or CV_AMD64_XXX (for IMAGE_FILE_MACHINE_AMD64)") .def( "__str__", &pyDia::Symbol::print) .def("__getitem__", &pyDia::Symbol::getChildByName) .def("__len__", &pyDia::Symbol::getChildCount ) .def("__getitem__", &pyDia::Symbol::getChildByIndex); - python::class_ >("DiaScope", "class wrapper for MS DIA Symbol" ); + python::class_ >("DiaScope", "class wrapper for MS DIA Symbol" ) + .def("machineType", &pyDia::GlobalScope::getMachineType, "Retrieves the type of the target CPU: IMAGE_FILE_MACHINE_XXX"); + + // CPU type: + DEF_PY_CONST_ULONG(IMAGE_FILE_MACHINE_I386); + DEF_PY_CONST_ULONG(IMAGE_FILE_MACHINE_IA64); + DEF_PY_CONST_ULONG(IMAGE_FILE_MACHINE_AMD64); // type of symbol DEF_PY_CONST_ULONG(SymTagNull); @@ -261,6 +270,13 @@ BOOST_PYTHON_MODULE( pykd ) python::scope().attr("diaUdtKind") = genDict(pyDia::Symbol::udtKindName, pyDia::Symbol::cntUdtKindName); + // i386/amd64 cpu registers +#include "diaregs.h" + python::scope().attr("diaI386Regs") = + genDict(pyDia::Symbol::i386RegName, pyDia::Symbol::cntI386RegName); + python::scope().attr("diaAmd64Regs") = + genDict(pyDia::Symbol::amd64RegName, pyDia::Symbol::cntAmd64RegName); + // exception: // base exception diff --git a/pykd/diadata.cpp b/pykd/diadata.cpp new file mode 100644 index 0000000..e8bd333 --- /dev/null +++ b/pykd/diadata.cpp @@ -0,0 +1,476 @@ +#include "stdafx.h" + +#include "diawrapper.h" +#include "utils.h" + +namespace pyDia { + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_SYM_TAG_VAL(x) Symbol::ValueNameEntry(SymTag##x, #x) +const Symbol::ValueNameEntry Symbol::symTagName[SymTagMax] = { + _DEF_SYM_TAG_VAL(Null), + _DEF_SYM_TAG_VAL(Exe), + _DEF_SYM_TAG_VAL(Compiland), + _DEF_SYM_TAG_VAL(CompilandDetails), + _DEF_SYM_TAG_VAL(CompilandEnv), + _DEF_SYM_TAG_VAL(Function), + _DEF_SYM_TAG_VAL(Block), + _DEF_SYM_TAG_VAL(Data), + _DEF_SYM_TAG_VAL(Annotation), + _DEF_SYM_TAG_VAL(Label), + _DEF_SYM_TAG_VAL(PublicSymbol), + _DEF_SYM_TAG_VAL(UDT), + _DEF_SYM_TAG_VAL(Enum), + _DEF_SYM_TAG_VAL(FunctionType), + _DEF_SYM_TAG_VAL(PointerType), + _DEF_SYM_TAG_VAL(ArrayType), + _DEF_SYM_TAG_VAL(BaseType), + _DEF_SYM_TAG_VAL(Typedef), + _DEF_SYM_TAG_VAL(BaseClass), + _DEF_SYM_TAG_VAL(Friend), + _DEF_SYM_TAG_VAL(FunctionArgType), + _DEF_SYM_TAG_VAL(FuncDebugStart), + _DEF_SYM_TAG_VAL(FuncDebugEnd), + _DEF_SYM_TAG_VAL(UsingNamespace), + _DEF_SYM_TAG_VAL(VTableShape), + _DEF_SYM_TAG_VAL(VTable), + _DEF_SYM_TAG_VAL(Custom), + _DEF_SYM_TAG_VAL(Thunk), + _DEF_SYM_TAG_VAL(CustomType), + _DEF_SYM_TAG_VAL(ManagedType), + _DEF_SYM_TAG_VAL(Dimension) +}; +#undef _DEF_SYM_TAG_VAL + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_LOC_TYPE(x) Symbol::ValueNameEntry(LocIs##x, #x) +const Symbol::ValueNameEntry Symbol::locTypeName[LocTypeMax] = { + _DEF_LOC_TYPE(Null), + _DEF_LOC_TYPE(Static), + _DEF_LOC_TYPE(TLS), + _DEF_LOC_TYPE(RegRel), + _DEF_LOC_TYPE(ThisRel), + _DEF_LOC_TYPE(Enregistered), + _DEF_LOC_TYPE(BitField), + _DEF_LOC_TYPE(Slot), + _DEF_LOC_TYPE(IlRel), + Symbol::ValueNameEntry(LocInMetaData, "InMetaData"), + _DEF_LOC_TYPE(Constant) +}; +#undef _DEF_LOC_TYPE + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_BASIC_TYPE(x) Symbol::ValueNameEntry(bt##x, #x) +const Symbol::ValueNameEntry Symbol::basicTypeName[] = { + _DEF_BASIC_TYPE(NoType), + _DEF_BASIC_TYPE(Void), + _DEF_BASIC_TYPE(Char), + _DEF_BASIC_TYPE(WChar), + _DEF_BASIC_TYPE(Int), + _DEF_BASIC_TYPE(UInt), + _DEF_BASIC_TYPE(Float), + _DEF_BASIC_TYPE(BCD), + _DEF_BASIC_TYPE(Bool), + _DEF_BASIC_TYPE(Long), + _DEF_BASIC_TYPE(ULong), + _DEF_BASIC_TYPE(Currency), + _DEF_BASIC_TYPE(Date), + _DEF_BASIC_TYPE(Variant), + _DEF_BASIC_TYPE(Complex), + _DEF_BASIC_TYPE(Bit), + _DEF_BASIC_TYPE(BSTR), + _DEF_BASIC_TYPE(Hresult) +}; +#undef _DEF_BASIC_TYPE + +const size_t Symbol::cntBasicTypeName = _countof(Symbol::basicTypeName); + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_UDT_KIND(x) Symbol::ValueNameEntry(Udt##x, #x) +const Symbol::ValueNameEntry Symbol::udtKindName[] = { + _DEF_UDT_KIND(Struct), + _DEF_UDT_KIND(Class), + _DEF_UDT_KIND(Union) +}; +#undef _DEF_UDT_KIND + +const size_t Symbol::cntUdtKindName = _countof(udtKindName); + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_I386_REG(x) Symbol::ValueNameEntry(CV_REG_##x, #x) +const Symbol::ValueNameEntry Symbol::i386RegName[] = { + _DEF_I386_REG(AL), + _DEF_I386_REG(CL), + _DEF_I386_REG(DL), + _DEF_I386_REG(BL), + _DEF_I386_REG(AH), + _DEF_I386_REG(CH), + _DEF_I386_REG(DH), + _DEF_I386_REG(BH), + _DEF_I386_REG(AX), + _DEF_I386_REG(CX), + _DEF_I386_REG(DX), + _DEF_I386_REG(BX), + _DEF_I386_REG(SP), + _DEF_I386_REG(BP), + _DEF_I386_REG(SI), + _DEF_I386_REG(DI), + _DEF_I386_REG(EAX), + _DEF_I386_REG(ECX), + _DEF_I386_REG(EDX), + _DEF_I386_REG(EBX), + _DEF_I386_REG(ESP), + _DEF_I386_REG(EBP), + _DEF_I386_REG(ESI), + _DEF_I386_REG(EDI), + _DEF_I386_REG(ES), + _DEF_I386_REG(CS), + _DEF_I386_REG(SS), + _DEF_I386_REG(DS), + _DEF_I386_REG(FS), + _DEF_I386_REG(GS), + _DEF_I386_REG(IP), + _DEF_I386_REG(FLAGS ), + _DEF_I386_REG(EIP), + _DEF_I386_REG(EFLAGS), + _DEF_I386_REG(TEMP), + _DEF_I386_REG(TEMPH), + _DEF_I386_REG(QUOTE), + _DEF_I386_REG(PCDR3), + _DEF_I386_REG(PCDR4), + _DEF_I386_REG(PCDR5), + _DEF_I386_REG(PCDR6), + _DEF_I386_REG(PCDR7), + _DEF_I386_REG(CR0), + _DEF_I386_REG(CR1), + _DEF_I386_REG(CR2), + _DEF_I386_REG(CR3), + _DEF_I386_REG(CR4), + _DEF_I386_REG(DR0), + _DEF_I386_REG(DR1), + _DEF_I386_REG(DR2), + _DEF_I386_REG(DR3), + _DEF_I386_REG(DR4), + _DEF_I386_REG(DR5), + _DEF_I386_REG(DR6), + _DEF_I386_REG(DR7), + _DEF_I386_REG(GDTR), + _DEF_I386_REG(GDTL), + _DEF_I386_REG(IDTR), + _DEF_I386_REG(IDTL), + _DEF_I386_REG(LDTR), + _DEF_I386_REG(TR) +}; +#undef _DEF_I386_REG + +const size_t Symbol::cntI386RegName = _countof(i386RegName); + +//////////////////////////////////////////////////////////////////////////////// + +#define _DEF_AMD64_REG(x) Symbol::ValueNameEntry(CV_AMD64_##x, #x) +const Symbol::ValueNameEntry Symbol::amd64RegName[] = { + _DEF_AMD64_REG(AL), + _DEF_AMD64_REG(CL), + _DEF_AMD64_REG(DL), + _DEF_AMD64_REG(BL), + _DEF_AMD64_REG(AH), + _DEF_AMD64_REG(CH), + _DEF_AMD64_REG(DH), + _DEF_AMD64_REG(BH), + _DEF_AMD64_REG(AX), + _DEF_AMD64_REG(CX), + _DEF_AMD64_REG(DX), + _DEF_AMD64_REG(BX), + _DEF_AMD64_REG(SP), + _DEF_AMD64_REG(BP), + _DEF_AMD64_REG(SI), + _DEF_AMD64_REG(DI), + _DEF_AMD64_REG(EAX), + _DEF_AMD64_REG(ECX), + _DEF_AMD64_REG(EDX), + _DEF_AMD64_REG(EBX), + _DEF_AMD64_REG(ESP), + _DEF_AMD64_REG(EBP), + _DEF_AMD64_REG(ESI), + _DEF_AMD64_REG(EDI), + _DEF_AMD64_REG(ES), + _DEF_AMD64_REG(CS), + _DEF_AMD64_REG(SS), + _DEF_AMD64_REG(DS), + _DEF_AMD64_REG(FS), + _DEF_AMD64_REG(GS), + _DEF_AMD64_REG(FLAGS), + _DEF_AMD64_REG(RIP), + _DEF_AMD64_REG(EFLAGS), + _DEF_AMD64_REG(CR0), + _DEF_AMD64_REG(CR1), + _DEF_AMD64_REG(CR2), + _DEF_AMD64_REG(CR3), + _DEF_AMD64_REG(CR4), + _DEF_AMD64_REG(CR8), + _DEF_AMD64_REG(DR0), + _DEF_AMD64_REG(DR1), + _DEF_AMD64_REG(DR2), + _DEF_AMD64_REG(DR3), + _DEF_AMD64_REG(DR4), + _DEF_AMD64_REG(DR5), + _DEF_AMD64_REG(DR6), + _DEF_AMD64_REG(DR7), + _DEF_AMD64_REG(DR8), + _DEF_AMD64_REG(DR9), + _DEF_AMD64_REG(DR10), + _DEF_AMD64_REG(DR11), + _DEF_AMD64_REG(DR12), + _DEF_AMD64_REG(DR13), + _DEF_AMD64_REG(DR14), + _DEF_AMD64_REG(DR15), + _DEF_AMD64_REG(GDTR), + _DEF_AMD64_REG(GDTL), + _DEF_AMD64_REG(IDTR), + _DEF_AMD64_REG(IDTL), + _DEF_AMD64_REG(LDTR), + _DEF_AMD64_REG(TR), + _DEF_AMD64_REG(ST0), + _DEF_AMD64_REG(ST1), + _DEF_AMD64_REG(ST2), + _DEF_AMD64_REG(ST3), + _DEF_AMD64_REG(ST4), + _DEF_AMD64_REG(ST5), + _DEF_AMD64_REG(ST6), + _DEF_AMD64_REG(ST7), + _DEF_AMD64_REG(CTRL), + _DEF_AMD64_REG(STAT), + _DEF_AMD64_REG(TAG), + _DEF_AMD64_REG(FPIP), + _DEF_AMD64_REG(FPCS), + _DEF_AMD64_REG(FPDO), + _DEF_AMD64_REG(FPDS), + _DEF_AMD64_REG(ISEM), + _DEF_AMD64_REG(FPEIP), + _DEF_AMD64_REG(FPEDO), + _DEF_AMD64_REG(MM0), + _DEF_AMD64_REG(MM1), + _DEF_AMD64_REG(MM2), + _DEF_AMD64_REG(MM3), + _DEF_AMD64_REG(MM4), + _DEF_AMD64_REG(MM5), + _DEF_AMD64_REG(MM6), + _DEF_AMD64_REG(MM7), + _DEF_AMD64_REG(XMM0), + _DEF_AMD64_REG(XMM1), + _DEF_AMD64_REG(XMM2), + _DEF_AMD64_REG(XMM3), + _DEF_AMD64_REG(XMM4), + _DEF_AMD64_REG(XMM5), + _DEF_AMD64_REG(XMM6), + _DEF_AMD64_REG(XMM7), + _DEF_AMD64_REG(XMM0_0), + _DEF_AMD64_REG(XMM0_1), + _DEF_AMD64_REG(XMM0_2), + _DEF_AMD64_REG(XMM0_3), + _DEF_AMD64_REG(XMM1_0), + _DEF_AMD64_REG(XMM1_1), + _DEF_AMD64_REG(XMM1_2), + _DEF_AMD64_REG(XMM1_3), + _DEF_AMD64_REG(XMM2_0), + _DEF_AMD64_REG(XMM2_1), + _DEF_AMD64_REG(XMM2_2), + _DEF_AMD64_REG(XMM2_3), + _DEF_AMD64_REG(XMM3_0), + _DEF_AMD64_REG(XMM3_1), + _DEF_AMD64_REG(XMM3_2), + _DEF_AMD64_REG(XMM3_3), + _DEF_AMD64_REG(XMM4_0), + _DEF_AMD64_REG(XMM4_1), + _DEF_AMD64_REG(XMM4_2), + _DEF_AMD64_REG(XMM4_3), + _DEF_AMD64_REG(XMM5_0), + _DEF_AMD64_REG(XMM5_1), + _DEF_AMD64_REG(XMM5_2), + _DEF_AMD64_REG(XMM5_3), + _DEF_AMD64_REG(XMM6_0), + _DEF_AMD64_REG(XMM6_1), + _DEF_AMD64_REG(XMM6_2), + _DEF_AMD64_REG(XMM6_3), + _DEF_AMD64_REG(XMM7_0), + _DEF_AMD64_REG(XMM7_1), + _DEF_AMD64_REG(XMM7_2), + _DEF_AMD64_REG(XMM7_3), + _DEF_AMD64_REG(XMM0L), + _DEF_AMD64_REG(XMM1L), + _DEF_AMD64_REG(XMM2L), + _DEF_AMD64_REG(XMM3L), + _DEF_AMD64_REG(XMM4L), + _DEF_AMD64_REG(XMM5L), + _DEF_AMD64_REG(XMM6L), + _DEF_AMD64_REG(XMM7L), + _DEF_AMD64_REG(XMM0H), + _DEF_AMD64_REG(XMM1H), + _DEF_AMD64_REG(XMM2H), + _DEF_AMD64_REG(XMM3H), + _DEF_AMD64_REG(XMM4H), + _DEF_AMD64_REG(XMM5H), + _DEF_AMD64_REG(XMM6H), + _DEF_AMD64_REG(XMM7H), + _DEF_AMD64_REG(MXCSR), + _DEF_AMD64_REG(EMM0L), + _DEF_AMD64_REG(EMM1L), + _DEF_AMD64_REG(EMM2L), + _DEF_AMD64_REG(EMM3L), + _DEF_AMD64_REG(EMM4L), + _DEF_AMD64_REG(EMM5L), + _DEF_AMD64_REG(EMM6L), + _DEF_AMD64_REG(EMM7L), + _DEF_AMD64_REG(EMM0H), + _DEF_AMD64_REG(EMM1H), + _DEF_AMD64_REG(EMM2H), + _DEF_AMD64_REG(EMM3H), + _DEF_AMD64_REG(EMM4H), + _DEF_AMD64_REG(EMM5H), + _DEF_AMD64_REG(EMM6H), + _DEF_AMD64_REG(EMM7H), + _DEF_AMD64_REG(MM00), + _DEF_AMD64_REG(MM01), + _DEF_AMD64_REG(MM10), + _DEF_AMD64_REG(MM11), + _DEF_AMD64_REG(MM20), + _DEF_AMD64_REG(MM21), + _DEF_AMD64_REG(MM30), + _DEF_AMD64_REG(MM31), + _DEF_AMD64_REG(MM40), + _DEF_AMD64_REG(MM41), + _DEF_AMD64_REG(MM50), + _DEF_AMD64_REG(MM51), + _DEF_AMD64_REG(MM60), + _DEF_AMD64_REG(MM61), + _DEF_AMD64_REG(MM70), + _DEF_AMD64_REG(MM71), + _DEF_AMD64_REG(XMM8), + _DEF_AMD64_REG(XMM9), + _DEF_AMD64_REG(XMM10), + _DEF_AMD64_REG(XMM11), + _DEF_AMD64_REG(XMM12), + _DEF_AMD64_REG(XMM13), + _DEF_AMD64_REG(XMM14), + _DEF_AMD64_REG(XMM15), + _DEF_AMD64_REG(XMM8_0), + _DEF_AMD64_REG(XMM8_1), + _DEF_AMD64_REG(XMM8_2), + _DEF_AMD64_REG(XMM8_3), + _DEF_AMD64_REG(XMM9_0), + _DEF_AMD64_REG(XMM9_1), + _DEF_AMD64_REG(XMM9_2), + _DEF_AMD64_REG(XMM9_3), + _DEF_AMD64_REG(XMM10_0), + _DEF_AMD64_REG(XMM10_1), + _DEF_AMD64_REG(XMM10_2), + _DEF_AMD64_REG(XMM10_3), + _DEF_AMD64_REG(XMM11_0), + _DEF_AMD64_REG(XMM11_1), + _DEF_AMD64_REG(XMM11_2), + _DEF_AMD64_REG(XMM11_3), + _DEF_AMD64_REG(XMM12_0), + _DEF_AMD64_REG(XMM12_1), + _DEF_AMD64_REG(XMM12_2), + _DEF_AMD64_REG(XMM12_3), + _DEF_AMD64_REG(XMM13_0), + _DEF_AMD64_REG(XMM13_1), + _DEF_AMD64_REG(XMM13_2), + _DEF_AMD64_REG(XMM13_3), + _DEF_AMD64_REG(XMM14_0), + _DEF_AMD64_REG(XMM14_1), + _DEF_AMD64_REG(XMM14_2), + _DEF_AMD64_REG(XMM14_3), + _DEF_AMD64_REG(XMM15_0), + _DEF_AMD64_REG(XMM15_1), + _DEF_AMD64_REG(XMM15_2), + _DEF_AMD64_REG(XMM15_3), + _DEF_AMD64_REG(XMM8L), + _DEF_AMD64_REG(XMM9L), + _DEF_AMD64_REG(XMM10L), + _DEF_AMD64_REG(XMM11L), + _DEF_AMD64_REG(XMM12L), + _DEF_AMD64_REG(XMM13L), + _DEF_AMD64_REG(XMM14L), + _DEF_AMD64_REG(XMM15L), + _DEF_AMD64_REG(XMM8H), + _DEF_AMD64_REG(XMM9H), + _DEF_AMD64_REG(XMM10H), + _DEF_AMD64_REG(XMM11H), + _DEF_AMD64_REG(XMM12H), + _DEF_AMD64_REG(XMM13H), + _DEF_AMD64_REG(XMM14H), + _DEF_AMD64_REG(XMM15H), + _DEF_AMD64_REG(EMM8L), + _DEF_AMD64_REG(EMM9L), + _DEF_AMD64_REG(EMM10L), + _DEF_AMD64_REG(EMM11L), + _DEF_AMD64_REG(EMM12L), + _DEF_AMD64_REG(EMM13L), + _DEF_AMD64_REG(EMM14L), + _DEF_AMD64_REG(EMM15L), + _DEF_AMD64_REG(EMM8H), + _DEF_AMD64_REG(EMM9H), + _DEF_AMD64_REG(EMM10H), + _DEF_AMD64_REG(EMM11H), + _DEF_AMD64_REG(EMM12H), + _DEF_AMD64_REG(EMM13H), + _DEF_AMD64_REG(EMM14H), + _DEF_AMD64_REG(EMM15H), + _DEF_AMD64_REG(SIL), + _DEF_AMD64_REG(DIL), + _DEF_AMD64_REG(BPL), + _DEF_AMD64_REG(SPL), + _DEF_AMD64_REG(RAX), + _DEF_AMD64_REG(RBX), + _DEF_AMD64_REG(RCX), + _DEF_AMD64_REG(RDX), + _DEF_AMD64_REG(RSI), + _DEF_AMD64_REG(RDI), + _DEF_AMD64_REG(RBP), + _DEF_AMD64_REG(RSP), + _DEF_AMD64_REG(R8), + _DEF_AMD64_REG(R9), + _DEF_AMD64_REG(R10), + _DEF_AMD64_REG(R11), + _DEF_AMD64_REG(R12), + _DEF_AMD64_REG(R13), + _DEF_AMD64_REG(R14), + _DEF_AMD64_REG(R15), + _DEF_AMD64_REG(R8B), + _DEF_AMD64_REG(R9B), + _DEF_AMD64_REG(R10B), + _DEF_AMD64_REG(R11B), + _DEF_AMD64_REG(R12B), + _DEF_AMD64_REG(R13B), + _DEF_AMD64_REG(R14B), + _DEF_AMD64_REG(R15B), + _DEF_AMD64_REG(R8W), + _DEF_AMD64_REG(R9W), + _DEF_AMD64_REG(R10W), + _DEF_AMD64_REG(R11W), + _DEF_AMD64_REG(R12W), + _DEF_AMD64_REG(R13W), + _DEF_AMD64_REG(R14W), + _DEF_AMD64_REG(R15W), + _DEF_AMD64_REG(R8D), + _DEF_AMD64_REG(R9D), + _DEF_AMD64_REG(R10D), + _DEF_AMD64_REG(R11D), + _DEF_AMD64_REG(R12D), + _DEF_AMD64_REG(R13D), + _DEF_AMD64_REG(R14D), + _DEF_AMD64_REG(R15D) +}; +#undef _DEF_AMD64_REG + +const size_t Symbol::cntAmd64RegName= _countof(amd64RegName); + +//////////////////////////////////////////////////////////////////////////////// + +} diff --git a/pykd/diaregs.h b/pykd/diaregs.h new file mode 100644 index 0000000..fcd259d --- /dev/null +++ b/pykd/diaregs.h @@ -0,0 +1,482 @@ + // i386 + DEF_PY_CONST_ULONG(CV_REG_NONE); + DEF_PY_CONST_ULONG(CV_REG_AL); + DEF_PY_CONST_ULONG(CV_REG_CL); + DEF_PY_CONST_ULONG(CV_REG_DL); + DEF_PY_CONST_ULONG(CV_REG_BL); + DEF_PY_CONST_ULONG(CV_REG_AH); + DEF_PY_CONST_ULONG(CV_REG_CH); + DEF_PY_CONST_ULONG(CV_REG_DH); + DEF_PY_CONST_ULONG(CV_REG_BH); + DEF_PY_CONST_ULONG(CV_REG_AX); + DEF_PY_CONST_ULONG(CV_REG_CX); + DEF_PY_CONST_ULONG(CV_REG_DX); + DEF_PY_CONST_ULONG(CV_REG_BX); + DEF_PY_CONST_ULONG(CV_REG_SP); + DEF_PY_CONST_ULONG(CV_REG_BP); + DEF_PY_CONST_ULONG(CV_REG_SI); + DEF_PY_CONST_ULONG(CV_REG_DI); + DEF_PY_CONST_ULONG(CV_REG_EAX); + DEF_PY_CONST_ULONG(CV_REG_ECX); + DEF_PY_CONST_ULONG(CV_REG_EDX); + DEF_PY_CONST_ULONG(CV_REG_EBX); + DEF_PY_CONST_ULONG(CV_REG_ESP); + DEF_PY_CONST_ULONG(CV_REG_EBP); + DEF_PY_CONST_ULONG(CV_REG_ESI); + DEF_PY_CONST_ULONG(CV_REG_EDI); + DEF_PY_CONST_ULONG(CV_REG_ES); + DEF_PY_CONST_ULONG(CV_REG_CS); + DEF_PY_CONST_ULONG(CV_REG_SS); + DEF_PY_CONST_ULONG(CV_REG_DS); + DEF_PY_CONST_ULONG(CV_REG_FS); + DEF_PY_CONST_ULONG(CV_REG_GS); + DEF_PY_CONST_ULONG(CV_REG_IP); + DEF_PY_CONST_ULONG(CV_REG_FLAGS ); + DEF_PY_CONST_ULONG(CV_REG_EIP); + DEF_PY_CONST_ULONG(CV_REG_EFLAGS); + DEF_PY_CONST_ULONG(CV_REG_TEMP); + DEF_PY_CONST_ULONG(CV_REG_TEMPH); + DEF_PY_CONST_ULONG(CV_REG_QUOTE); + DEF_PY_CONST_ULONG(CV_REG_PCDR3); + DEF_PY_CONST_ULONG(CV_REG_PCDR4); + DEF_PY_CONST_ULONG(CV_REG_PCDR5); + DEF_PY_CONST_ULONG(CV_REG_PCDR6); + DEF_PY_CONST_ULONG(CV_REG_PCDR7); + DEF_PY_CONST_ULONG(CV_REG_CR0); + DEF_PY_CONST_ULONG(CV_REG_CR1); + DEF_PY_CONST_ULONG(CV_REG_CR2); + DEF_PY_CONST_ULONG(CV_REG_CR3); + DEF_PY_CONST_ULONG(CV_REG_CR4); + DEF_PY_CONST_ULONG(CV_REG_DR0); + DEF_PY_CONST_ULONG(CV_REG_DR1); + DEF_PY_CONST_ULONG(CV_REG_DR2); + DEF_PY_CONST_ULONG(CV_REG_DR3); + DEF_PY_CONST_ULONG(CV_REG_DR4); + DEF_PY_CONST_ULONG(CV_REG_DR5); + DEF_PY_CONST_ULONG(CV_REG_DR6); + DEF_PY_CONST_ULONG(CV_REG_DR7); + DEF_PY_CONST_ULONG(CV_REG_GDTR); + DEF_PY_CONST_ULONG(CV_REG_GDTL); + DEF_PY_CONST_ULONG(CV_REG_IDTR); + DEF_PY_CONST_ULONG(CV_REG_IDTL); + DEF_PY_CONST_ULONG(CV_REG_LDTR); + DEF_PY_CONST_ULONG(CV_REG_TR); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO1); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO2); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO3); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO4); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO5); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO6); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO7); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO8); + DEF_PY_CONST_ULONG(CV_REG_PSEUDO9); + DEF_PY_CONST_ULONG(CV_REG_ST0); + DEF_PY_CONST_ULONG(CV_REG_ST1); + DEF_PY_CONST_ULONG(CV_REG_ST2); + DEF_PY_CONST_ULONG(CV_REG_ST3); + DEF_PY_CONST_ULONG(CV_REG_ST4); + DEF_PY_CONST_ULONG(CV_REG_ST5); + DEF_PY_CONST_ULONG(CV_REG_ST6); + DEF_PY_CONST_ULONG(CV_REG_ST7); + DEF_PY_CONST_ULONG(CV_REG_CTRL); + DEF_PY_CONST_ULONG(CV_REG_STAT); + DEF_PY_CONST_ULONG(CV_REG_TAG); + DEF_PY_CONST_ULONG(CV_REG_FPIP); + DEF_PY_CONST_ULONG(CV_REG_FPCS); + DEF_PY_CONST_ULONG(CV_REG_FPDO); + DEF_PY_CONST_ULONG(CV_REG_FPDS); + DEF_PY_CONST_ULONG(CV_REG_ISEM); + DEF_PY_CONST_ULONG(CV_REG_FPEIP); + DEF_PY_CONST_ULONG(CV_REG_FPEDO); + DEF_PY_CONST_ULONG(CV_REG_MM0); + DEF_PY_CONST_ULONG(CV_REG_MM1); + DEF_PY_CONST_ULONG(CV_REG_MM2); + DEF_PY_CONST_ULONG(CV_REG_MM3); + DEF_PY_CONST_ULONG(CV_REG_MM4); + DEF_PY_CONST_ULONG(CV_REG_MM5); + DEF_PY_CONST_ULONG(CV_REG_MM6); + DEF_PY_CONST_ULONG(CV_REG_MM7); + DEF_PY_CONST_ULONG(CV_REG_XMM0); + DEF_PY_CONST_ULONG(CV_REG_XMM1); + DEF_PY_CONST_ULONG(CV_REG_XMM2); + DEF_PY_CONST_ULONG(CV_REG_XMM3); + DEF_PY_CONST_ULONG(CV_REG_XMM4); + DEF_PY_CONST_ULONG(CV_REG_XMM5); + DEF_PY_CONST_ULONG(CV_REG_XMM6); + DEF_PY_CONST_ULONG(CV_REG_XMM7); + DEF_PY_CONST_ULONG(CV_REG_XMM00); + DEF_PY_CONST_ULONG(CV_REG_XMM01); + DEF_PY_CONST_ULONG(CV_REG_XMM02); + DEF_PY_CONST_ULONG(CV_REG_XMM03); + DEF_PY_CONST_ULONG(CV_REG_XMM10); + DEF_PY_CONST_ULONG(CV_REG_XMM11); + DEF_PY_CONST_ULONG(CV_REG_XMM12); + DEF_PY_CONST_ULONG(CV_REG_XMM13); + DEF_PY_CONST_ULONG(CV_REG_XMM20); + DEF_PY_CONST_ULONG(CV_REG_XMM21); + DEF_PY_CONST_ULONG(CV_REG_XMM22); + DEF_PY_CONST_ULONG(CV_REG_XMM23); + DEF_PY_CONST_ULONG(CV_REG_XMM30); + DEF_PY_CONST_ULONG(CV_REG_XMM31); + DEF_PY_CONST_ULONG(CV_REG_XMM32); + DEF_PY_CONST_ULONG(CV_REG_XMM33); + DEF_PY_CONST_ULONG(CV_REG_XMM40); + DEF_PY_CONST_ULONG(CV_REG_XMM41); + DEF_PY_CONST_ULONG(CV_REG_XMM42); + DEF_PY_CONST_ULONG(CV_REG_XMM43); + DEF_PY_CONST_ULONG(CV_REG_XMM50); + DEF_PY_CONST_ULONG(CV_REG_XMM51); + DEF_PY_CONST_ULONG(CV_REG_XMM52); + DEF_PY_CONST_ULONG(CV_REG_XMM53); + DEF_PY_CONST_ULONG(CV_REG_XMM60); + DEF_PY_CONST_ULONG(CV_REG_XMM61); + DEF_PY_CONST_ULONG(CV_REG_XMM62); + DEF_PY_CONST_ULONG(CV_REG_XMM63); + DEF_PY_CONST_ULONG(CV_REG_XMM70); + DEF_PY_CONST_ULONG(CV_REG_XMM71); + DEF_PY_CONST_ULONG(CV_REG_XMM72); + DEF_PY_CONST_ULONG(CV_REG_XMM73); + DEF_PY_CONST_ULONG(CV_REG_XMM0L); + DEF_PY_CONST_ULONG(CV_REG_XMM1L); + DEF_PY_CONST_ULONG(CV_REG_XMM2L); + DEF_PY_CONST_ULONG(CV_REG_XMM3L); + DEF_PY_CONST_ULONG(CV_REG_XMM4L); + DEF_PY_CONST_ULONG(CV_REG_XMM5L); + DEF_PY_CONST_ULONG(CV_REG_XMM6L); + DEF_PY_CONST_ULONG(CV_REG_XMM7L); + DEF_PY_CONST_ULONG(CV_REG_XMM0H); + DEF_PY_CONST_ULONG(CV_REG_XMM1H); + DEF_PY_CONST_ULONG(CV_REG_XMM2H); + DEF_PY_CONST_ULONG(CV_REG_XMM3H); + DEF_PY_CONST_ULONG(CV_REG_XMM4H); + DEF_PY_CONST_ULONG(CV_REG_XMM5H); + DEF_PY_CONST_ULONG(CV_REG_XMM6H); + DEF_PY_CONST_ULONG(CV_REG_XMM7H); + DEF_PY_CONST_ULONG(CV_REG_MXCSR); + DEF_PY_CONST_ULONG(CV_REG_EDXEAX); + DEF_PY_CONST_ULONG(CV_REG_EMM0L); + DEF_PY_CONST_ULONG(CV_REG_EMM1L); + DEF_PY_CONST_ULONG(CV_REG_EMM2L); + DEF_PY_CONST_ULONG(CV_REG_EMM3L); + DEF_PY_CONST_ULONG(CV_REG_EMM4L); + DEF_PY_CONST_ULONG(CV_REG_EMM5L); + DEF_PY_CONST_ULONG(CV_REG_EMM6L); + DEF_PY_CONST_ULONG(CV_REG_EMM7L); + DEF_PY_CONST_ULONG(CV_REG_EMM0H); + DEF_PY_CONST_ULONG(CV_REG_EMM1H); + DEF_PY_CONST_ULONG(CV_REG_EMM2H); + DEF_PY_CONST_ULONG(CV_REG_EMM3H); + DEF_PY_CONST_ULONG(CV_REG_EMM4H); + DEF_PY_CONST_ULONG(CV_REG_EMM5H); + DEF_PY_CONST_ULONG(CV_REG_EMM6H); + DEF_PY_CONST_ULONG(CV_REG_EMM7H); + DEF_PY_CONST_ULONG(CV_REG_MM00); + DEF_PY_CONST_ULONG(CV_REG_MM01); + DEF_PY_CONST_ULONG(CV_REG_MM10); + DEF_PY_CONST_ULONG(CV_REG_MM11); + DEF_PY_CONST_ULONG(CV_REG_MM20); + DEF_PY_CONST_ULONG(CV_REG_MM21); + DEF_PY_CONST_ULONG(CV_REG_MM30); + DEF_PY_CONST_ULONG(CV_REG_MM31); + DEF_PY_CONST_ULONG(CV_REG_MM40); + DEF_PY_CONST_ULONG(CV_REG_MM41); + DEF_PY_CONST_ULONG(CV_REG_MM50); + DEF_PY_CONST_ULONG(CV_REG_MM51); + DEF_PY_CONST_ULONG(CV_REG_MM60); + DEF_PY_CONST_ULONG(CV_REG_MM61); + DEF_PY_CONST_ULONG(CV_REG_MM70); + DEF_PY_CONST_ULONG(CV_REG_MM71); + + // amd64 + DEF_PY_CONST_ULONG(CV_AMD64_AL); + DEF_PY_CONST_ULONG(CV_AMD64_CL); + DEF_PY_CONST_ULONG(CV_AMD64_DL); + DEF_PY_CONST_ULONG(CV_AMD64_BL); + DEF_PY_CONST_ULONG(CV_AMD64_AH); + DEF_PY_CONST_ULONG(CV_AMD64_CH); + DEF_PY_CONST_ULONG(CV_AMD64_DH); + DEF_PY_CONST_ULONG(CV_AMD64_BH); + DEF_PY_CONST_ULONG(CV_AMD64_AX); + DEF_PY_CONST_ULONG(CV_AMD64_CX); + DEF_PY_CONST_ULONG(CV_AMD64_DX); + DEF_PY_CONST_ULONG(CV_AMD64_BX); + DEF_PY_CONST_ULONG(CV_AMD64_SP); + DEF_PY_CONST_ULONG(CV_AMD64_BP); + DEF_PY_CONST_ULONG(CV_AMD64_SI); + DEF_PY_CONST_ULONG(CV_AMD64_DI); + DEF_PY_CONST_ULONG(CV_AMD64_EAX); + DEF_PY_CONST_ULONG(CV_AMD64_ECX); + DEF_PY_CONST_ULONG(CV_AMD64_EDX); + DEF_PY_CONST_ULONG(CV_AMD64_EBX); + DEF_PY_CONST_ULONG(CV_AMD64_ESP); + DEF_PY_CONST_ULONG(CV_AMD64_EBP); + DEF_PY_CONST_ULONG(CV_AMD64_ESI); + DEF_PY_CONST_ULONG(CV_AMD64_EDI); + DEF_PY_CONST_ULONG(CV_AMD64_ES); + DEF_PY_CONST_ULONG(CV_AMD64_CS); + DEF_PY_CONST_ULONG(CV_AMD64_SS); + DEF_PY_CONST_ULONG(CV_AMD64_DS); + DEF_PY_CONST_ULONG(CV_AMD64_FS); + DEF_PY_CONST_ULONG(CV_AMD64_GS); + DEF_PY_CONST_ULONG(CV_AMD64_FLAGS); + DEF_PY_CONST_ULONG(CV_AMD64_RIP); + DEF_PY_CONST_ULONG(CV_AMD64_EFLAGS); + DEF_PY_CONST_ULONG(CV_AMD64_CR0); + DEF_PY_CONST_ULONG(CV_AMD64_CR1); + DEF_PY_CONST_ULONG(CV_AMD64_CR2); + DEF_PY_CONST_ULONG(CV_AMD64_CR3); + DEF_PY_CONST_ULONG(CV_AMD64_CR4); + DEF_PY_CONST_ULONG(CV_AMD64_CR8); + DEF_PY_CONST_ULONG(CV_AMD64_DR0); + DEF_PY_CONST_ULONG(CV_AMD64_DR1); + DEF_PY_CONST_ULONG(CV_AMD64_DR2); + DEF_PY_CONST_ULONG(CV_AMD64_DR3); + DEF_PY_CONST_ULONG(CV_AMD64_DR4); + DEF_PY_CONST_ULONG(CV_AMD64_DR5); + DEF_PY_CONST_ULONG(CV_AMD64_DR6); + DEF_PY_CONST_ULONG(CV_AMD64_DR7); + DEF_PY_CONST_ULONG(CV_AMD64_DR8); + DEF_PY_CONST_ULONG(CV_AMD64_DR9); + DEF_PY_CONST_ULONG(CV_AMD64_DR10); + DEF_PY_CONST_ULONG(CV_AMD64_DR11); + DEF_PY_CONST_ULONG(CV_AMD64_DR12); + DEF_PY_CONST_ULONG(CV_AMD64_DR13); + DEF_PY_CONST_ULONG(CV_AMD64_DR14); + DEF_PY_CONST_ULONG(CV_AMD64_DR15); + DEF_PY_CONST_ULONG(CV_AMD64_GDTR); + DEF_PY_CONST_ULONG(CV_AMD64_GDTL); + DEF_PY_CONST_ULONG(CV_AMD64_IDTR); + DEF_PY_CONST_ULONG(CV_AMD64_IDTL); + DEF_PY_CONST_ULONG(CV_AMD64_LDTR); + DEF_PY_CONST_ULONG(CV_AMD64_TR); + DEF_PY_CONST_ULONG(CV_AMD64_ST0); + DEF_PY_CONST_ULONG(CV_AMD64_ST1); + DEF_PY_CONST_ULONG(CV_AMD64_ST2); + DEF_PY_CONST_ULONG(CV_AMD64_ST3); + DEF_PY_CONST_ULONG(CV_AMD64_ST4); + DEF_PY_CONST_ULONG(CV_AMD64_ST5); + DEF_PY_CONST_ULONG(CV_AMD64_ST6); + DEF_PY_CONST_ULONG(CV_AMD64_ST7); + DEF_PY_CONST_ULONG(CV_AMD64_CTRL); + DEF_PY_CONST_ULONG(CV_AMD64_STAT); + DEF_PY_CONST_ULONG(CV_AMD64_TAG); + DEF_PY_CONST_ULONG(CV_AMD64_FPIP); + DEF_PY_CONST_ULONG(CV_AMD64_FPCS); + DEF_PY_CONST_ULONG(CV_AMD64_FPDO); + DEF_PY_CONST_ULONG(CV_AMD64_FPDS); + DEF_PY_CONST_ULONG(CV_AMD64_ISEM); + DEF_PY_CONST_ULONG(CV_AMD64_FPEIP); + DEF_PY_CONST_ULONG(CV_AMD64_FPEDO); + DEF_PY_CONST_ULONG(CV_AMD64_MM0); + DEF_PY_CONST_ULONG(CV_AMD64_MM1); + DEF_PY_CONST_ULONG(CV_AMD64_MM2); + DEF_PY_CONST_ULONG(CV_AMD64_MM3); + DEF_PY_CONST_ULONG(CV_AMD64_MM4); + DEF_PY_CONST_ULONG(CV_AMD64_MM5); + DEF_PY_CONST_ULONG(CV_AMD64_MM6); + DEF_PY_CONST_ULONG(CV_AMD64_MM7); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM0H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM1H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM2H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM3H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM4H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM5H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM6H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM7H); + DEF_PY_CONST_ULONG(CV_AMD64_MXCSR); + DEF_PY_CONST_ULONG(CV_AMD64_EMM0L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM1L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM2L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM3L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM4L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM5L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM6L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM7L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM0H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM1H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM2H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM3H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM4H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM5H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM6H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM7H); + DEF_PY_CONST_ULONG(CV_AMD64_MM00); + DEF_PY_CONST_ULONG(CV_AMD64_MM01); + DEF_PY_CONST_ULONG(CV_AMD64_MM10); + DEF_PY_CONST_ULONG(CV_AMD64_MM11); + DEF_PY_CONST_ULONG(CV_AMD64_MM20); + DEF_PY_CONST_ULONG(CV_AMD64_MM21); + DEF_PY_CONST_ULONG(CV_AMD64_MM30); + DEF_PY_CONST_ULONG(CV_AMD64_MM31); + DEF_PY_CONST_ULONG(CV_AMD64_MM40); + DEF_PY_CONST_ULONG(CV_AMD64_MM41); + DEF_PY_CONST_ULONG(CV_AMD64_MM50); + DEF_PY_CONST_ULONG(CV_AMD64_MM51); + DEF_PY_CONST_ULONG(CV_AMD64_MM60); + DEF_PY_CONST_ULONG(CV_AMD64_MM61); + DEF_PY_CONST_ULONG(CV_AMD64_MM70); + DEF_PY_CONST_ULONG(CV_AMD64_MM71); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15_0); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15_1); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15_2); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15_3); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15L); + DEF_PY_CONST_ULONG(CV_AMD64_XMM8H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM9H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM10H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM11H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM12H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM13H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM14H); + DEF_PY_CONST_ULONG(CV_AMD64_XMM15H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM8L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM9L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM10L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM11L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM12L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM13L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM14L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM15L); + DEF_PY_CONST_ULONG(CV_AMD64_EMM8H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM9H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM10H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM11H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM12H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM13H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM14H); + DEF_PY_CONST_ULONG(CV_AMD64_EMM15H); + DEF_PY_CONST_ULONG(CV_AMD64_SIL); + DEF_PY_CONST_ULONG(CV_AMD64_DIL); + DEF_PY_CONST_ULONG(CV_AMD64_BPL); + DEF_PY_CONST_ULONG(CV_AMD64_SPL); + DEF_PY_CONST_ULONG(CV_AMD64_RAX); + DEF_PY_CONST_ULONG(CV_AMD64_RBX); + DEF_PY_CONST_ULONG(CV_AMD64_RCX); + DEF_PY_CONST_ULONG(CV_AMD64_RDX); + DEF_PY_CONST_ULONG(CV_AMD64_RSI); + DEF_PY_CONST_ULONG(CV_AMD64_RDI); + DEF_PY_CONST_ULONG(CV_AMD64_RBP); + DEF_PY_CONST_ULONG(CV_AMD64_RSP); + DEF_PY_CONST_ULONG(CV_AMD64_R8); + DEF_PY_CONST_ULONG(CV_AMD64_R9); + DEF_PY_CONST_ULONG(CV_AMD64_R10); + DEF_PY_CONST_ULONG(CV_AMD64_R11); + DEF_PY_CONST_ULONG(CV_AMD64_R12); + DEF_PY_CONST_ULONG(CV_AMD64_R13); + DEF_PY_CONST_ULONG(CV_AMD64_R14); + DEF_PY_CONST_ULONG(CV_AMD64_R15); + DEF_PY_CONST_ULONG(CV_AMD64_R8B); + DEF_PY_CONST_ULONG(CV_AMD64_R9B); + DEF_PY_CONST_ULONG(CV_AMD64_R10B); + DEF_PY_CONST_ULONG(CV_AMD64_R11B); + DEF_PY_CONST_ULONG(CV_AMD64_R12B); + DEF_PY_CONST_ULONG(CV_AMD64_R13B); + DEF_PY_CONST_ULONG(CV_AMD64_R14B); + DEF_PY_CONST_ULONG(CV_AMD64_R15B); + DEF_PY_CONST_ULONG(CV_AMD64_R8W); + DEF_PY_CONST_ULONG(CV_AMD64_R9W); + DEF_PY_CONST_ULONG(CV_AMD64_R10W); + DEF_PY_CONST_ULONG(CV_AMD64_R11W); + DEF_PY_CONST_ULONG(CV_AMD64_R12W); + DEF_PY_CONST_ULONG(CV_AMD64_R13W); + DEF_PY_CONST_ULONG(CV_AMD64_R14W); + DEF_PY_CONST_ULONG(CV_AMD64_R15W); + DEF_PY_CONST_ULONG(CV_AMD64_R8D); + DEF_PY_CONST_ULONG(CV_AMD64_R9D); + DEF_PY_CONST_ULONG(CV_AMD64_R10D); + DEF_PY_CONST_ULONG(CV_AMD64_R11D); + DEF_PY_CONST_ULONG(CV_AMD64_R12D); + DEF_PY_CONST_ULONG(CV_AMD64_R13D); + DEF_PY_CONST_ULONG(CV_AMD64_R14D); + DEF_PY_CONST_ULONG(CV_AMD64_R15D); diff --git a/pykd/diawrapper.cpp b/pykd/diawrapper.cpp index cf4ce9b..dfe084a 100644 --- a/pykd/diawrapper.cpp +++ b/pykd/diawrapper.cpp @@ -14,94 +14,6 @@ const std::string Exception::descPrefix("pyDia: "); //////////////////////////////////////////////////////////////////////////////// -#define _DEF_SYM_TAG_VAL(x) Symbol::ValueNameEntry(SymTag##x, #x) -const Symbol::ValueNameEntry Symbol::symTagName[SymTagMax] = { - _DEF_SYM_TAG_VAL(Null), - _DEF_SYM_TAG_VAL(Exe), - _DEF_SYM_TAG_VAL(Compiland), - _DEF_SYM_TAG_VAL(CompilandDetails), - _DEF_SYM_TAG_VAL(CompilandEnv), - _DEF_SYM_TAG_VAL(Function), - _DEF_SYM_TAG_VAL(Block), - _DEF_SYM_TAG_VAL(Data), - _DEF_SYM_TAG_VAL(Annotation), - _DEF_SYM_TAG_VAL(Label), - _DEF_SYM_TAG_VAL(PublicSymbol), - _DEF_SYM_TAG_VAL(UDT), - _DEF_SYM_TAG_VAL(Enum), - _DEF_SYM_TAG_VAL(FunctionType), - _DEF_SYM_TAG_VAL(PointerType), - _DEF_SYM_TAG_VAL(ArrayType), - _DEF_SYM_TAG_VAL(BaseType), - _DEF_SYM_TAG_VAL(Typedef), - _DEF_SYM_TAG_VAL(BaseClass), - _DEF_SYM_TAG_VAL(Friend), - _DEF_SYM_TAG_VAL(FunctionArgType), - _DEF_SYM_TAG_VAL(FuncDebugStart), - _DEF_SYM_TAG_VAL(FuncDebugEnd), - _DEF_SYM_TAG_VAL(UsingNamespace), - _DEF_SYM_TAG_VAL(VTableShape), - _DEF_SYM_TAG_VAL(VTable), - _DEF_SYM_TAG_VAL(Custom), - _DEF_SYM_TAG_VAL(Thunk), - _DEF_SYM_TAG_VAL(CustomType), - _DEF_SYM_TAG_VAL(ManagedType), - _DEF_SYM_TAG_VAL(Dimension) -}; -#undef _DEF_SYM_TAG_VAL - -#define _DEF_LOC_TYPE(x) Symbol::ValueNameEntry(LocIs##x, #x) -const Symbol::ValueNameEntry Symbol::locTypeName[LocTypeMax] = { - _DEF_LOC_TYPE(Null), - _DEF_LOC_TYPE(Static), - _DEF_LOC_TYPE(TLS), - _DEF_LOC_TYPE(RegRel), - _DEF_LOC_TYPE(ThisRel), - _DEF_LOC_TYPE(Enregistered), - _DEF_LOC_TYPE(BitField), - _DEF_LOC_TYPE(Slot), - _DEF_LOC_TYPE(IlRel), - Symbol::ValueNameEntry(LocInMetaData, "InMetaData"), - _DEF_LOC_TYPE(Constant) -}; -#undef _DEF_LOC_TYPE - -#define _DEF_BASIC_TYPE(x) Symbol::ValueNameEntry(bt##x, #x) -const Symbol::ValueNameEntry Symbol::basicTypeName[] = { - _DEF_BASIC_TYPE(NoType), - _DEF_BASIC_TYPE(Void), - _DEF_BASIC_TYPE(Char), - _DEF_BASIC_TYPE(WChar), - _DEF_BASIC_TYPE(Int), - _DEF_BASIC_TYPE(UInt), - _DEF_BASIC_TYPE(Float), - _DEF_BASIC_TYPE(BCD), - _DEF_BASIC_TYPE(Bool), - _DEF_BASIC_TYPE(Long), - _DEF_BASIC_TYPE(ULong), - _DEF_BASIC_TYPE(Currency), - _DEF_BASIC_TYPE(Date), - _DEF_BASIC_TYPE(Variant), - _DEF_BASIC_TYPE(Complex), - _DEF_BASIC_TYPE(Bit), - _DEF_BASIC_TYPE(BSTR), - _DEF_BASIC_TYPE(Hresult) -}; -#undef _DEF_BASIC_TYPE - -const size_t Symbol::cntBasicTypeName = _countof(Symbol::basicTypeName); - -#define _DEF_UDT_KIND(x) Symbol::ValueNameEntry(Udt##x, #x) -const Symbol::ValueNameEntry Symbol::udtKindName[] = { - _DEF_UDT_KIND(Struct), - _DEF_UDT_KIND(Class), - _DEF_UDT_KIND(Union) -}; -#undef _DEF_UDT_KIND -const size_t Symbol::cntUdtKindName = _countof(udtKindName); - -//////////////////////////////////////////////////////////////////////////////// - #define callSymbol(method) \ callSymbolT( &IDiaSymbol::##method, __FUNCTION__, #method) @@ -170,7 +82,7 @@ std::list< Symbol > Symbol::findChildrenImpl( DiaSymbolPtr child; ULONG celt; while ( SUCCEEDED(symbols->Next(1, &child, &celt)) && (celt == 1) ) - childList.push_back( Symbol(child) ); + childList.push_back( Symbol(child, m_machineType) ); return childList; } @@ -194,14 +106,14 @@ std::string Symbol::getName() Symbol Symbol::getType() { - return Symbol( callSymbol(get_type) ); + return Symbol( callSymbol(get_type), m_machineType ); } //////////////////////////////////////////////////////////////////////////////// Symbol Symbol::getIndexType() { - return Symbol( callSymbol(get_arrayIndexType) ); + return Symbol( callSymbol(get_arrayIndexType), m_machineType ); } //////////////////////////////////////////////////////////////////////////////// @@ -329,6 +241,13 @@ ULONG Symbol::getUdtKind() //////////////////////////////////////////////////////////////////////////////// +ULONG Symbol::getRegisterId() +{ + return callSymbol(get_registerId); +} + +//////////////////////////////////////////////////////////////////////////////// + Symbol Symbol::getChildByName(const std::string &_name) { throwIfNull(__FUNCTION__); @@ -359,7 +278,7 @@ Symbol Symbol::getChildByName(const std::string &_name) if (S_OK != hres) throw Exception("Call IDiaEnumSymbols::Item", hres); - return Symbol(child); + return Symbol(child, m_machineType); } //////////////////////////////////////////////////////////////////////////////// @@ -418,30 +337,23 @@ Symbol Symbol::getChildByIndex(ULONG _index) if (S_OK != hres) throw Exception("Call IDiaEnumSymbols::Item", hres); - return Symbol(child); + return Symbol(child, m_machineType); } //////////////////////////////////////////////////////////////////////////////// std::string Symbol::print() { - return printImpl(m_symbol); + return printImpl(m_symbol, m_machineType); } //////////////////////////////////////////////////////////////////////////////// -std::string Symbol::printImpl(IDiaSymbol *_symbol, ULONG indent) +std::string Symbol::printImpl(IDiaSymbol *_symbol, DWORD machineType, ULONG indent /*= 0*/) { std::stringstream sstream; for (ULONG i =0; i < indent; ++i) sstream << " "; - - if (indent >= 3) - { - sstream << "<...>"; - return sstream.str(); - } - if (_symbol) { DWORD dwValue; @@ -452,24 +364,113 @@ std::string Symbol::printImpl(IDiaSymbol *_symbol, ULONG indent) ULONGLONG ullValue; HRESULT hres; - hres = _symbol->get_offset(&lValue); - if (S_OK == hres) - sstream << ".[" << std::dec << lValue << + "] "; + DWORD locType = LocIsNull; + hres = _symbol->get_locationType(&locType); + bool bLocation = (S_OK == hres); + if (bLocation) + { + hres = _symbol->get_offset(&lValue); + + const bool bNegOffset = lValue < 0; + lValue = bNegOffset ? -1 * lValue : lValue; + + switch (locType) + { + case LocIsBitField: + case LocIsThisRel: + assert(S_OK == hres); + sstream << (bNegOffset ? "-" : "+") << "0x" << std::hex << lValue; + if (LocIsBitField == locType) + { + hres = _symbol->get_bitPosition(&dwValue); + if (S_OK == hres) + sstream << ", Bit position: " << dwValue; + } + break; + + case LocIsEnregistered: + case LocIsRegRel: + hres = _symbol->get_registerId(&dwValue); + if (S_OK == hres) + { + const char *regName = NULL; + if (IMAGE_FILE_MACHINE_I386 == machineType) + { + for (ULONG i = 0; i < cntI386RegName; ++i) + { + if (dwValue == i386RegName[i].first) + { + regName = i386RegName[i].second; + break; + } + } + } + else if (IMAGE_FILE_MACHINE_AMD64 == machineType) + { + for (ULONG i = 0; i < cntI386RegName; ++i) + { + if (dwValue == i386RegName[i].first) + { + regName = i386RegName[i].second; + break; + } + } + } + if (!regName) + { + sstream << locTypeName[locType].second; + } + else + { + if (LocIsEnregistered == locType) + { + sstream << regName; + } + else + { + sstream << "[" << regName; + sstream << (bNegOffset ? "-" : "+") << "0x" << std::hex << lValue; + sstream << "]"; + } + } + } + else + { + sstream << locTypeName[locType].second; + } + break; + + default: + if (S_OK == _symbol->get_relativeVirtualAddress(&dwValue)) + sstream << "RVA:0x" << std::hex << dwValue; + else if (locType < _countof(locTypeName)) + sstream << "Location: " << locTypeName[locType].second; + if (S_OK == hres) + { + sstream << ", Offset: "; + sstream << (bNegOffset ? "-" : "+") << "0x" << std::hex << lValue; + } + break; + } + } hres = _symbol->get_symTag(&dwValue); if ((S_OK == hres) && dwValue < _countof(symTagName)) { + if (bLocation) + sstream << ", "; + sstream << symTagName[dwValue].second; if (SymTagUDT == symTagName[dwValue].first) { hres = _symbol->get_udtKind(&dwValue); if ((S_OK == hres) && (dwValue < cntUdtKindName)) - sstream << ":" << udtKindName[dwValue].second; + sstream << ": " << udtKindName[dwValue].second; } } else { - sstream << "!unknown!"; + sstream << "!invalid symTag!"; } sstream << ", "; @@ -484,23 +485,6 @@ std::string Symbol::printImpl(IDiaSymbol *_symbol, ULONG indent) if (S_OK == hres) sstream << ", Length: 0x" << std::hex << ullValue; - hres = _symbol->get_locationType(&dwValue); - if ((S_OK == hres) && dwValue < _countof(locTypeName)) - { - sstream << ", Location: " << locTypeName[dwValue].second; - - if (LocIsBitField == locTypeName[dwValue].first) - { - hres = _symbol->get_bitPosition(&dwValue); - if (S_OK == hres) - sstream << ", Bit position: " << dwValue; - } - - hres = _symbol->get_relativeVirtualAddress(&dwValue); - if (S_OK == hres) - sstream << ", RVA: 0x" << std::hex << dwValue; - } - bValue = false; try { @@ -595,7 +579,7 @@ std::string Symbol::printImpl(IDiaSymbol *_symbol, ULONG indent) for (ULONG i =0; i < indent; ++i) sstream << " "; sstream << "Type: " << std::endl; - sstream << printImpl(pType, indent + 1).c_str(); + sstream << printImpl(pType, machineType, indent + 1).c_str(); } } } @@ -609,12 +593,27 @@ std::string Symbol::printImpl(IDiaSymbol *_symbol, ULONG indent) &symbols); if (S_OK == hres) { - DiaSymbolPtr child; - ULONG celt; - while ( SUCCEEDED(symbols->Next(1, &child, &celt)) && (celt == 1) ) + if (indent <= 2) { - sstream << std::endl << printImpl(child, indent + 1).c_str(); - child.Release(); + DiaSymbolPtr child; + ULONG celt; + while ( SUCCEEDED(symbols->Next(1, &child, &celt)) && (celt == 1) ) + { + sstream << std::endl << printImpl(child, machineType, indent + 1).c_str(); + child.Release(); + } + } + else + { + lValue = 0; + symbols->get_Count(&lValue); + if (lValue) + { + sstream << std::endl; + for (ULONG i =0; i < indent+1; ++i) + sstream << " "; + sstream << "<...>"; + } } } @@ -628,10 +627,11 @@ GlobalScope::GlobalScope( __inout DiaDataSourcePtr &_scope, __inout DiaSessionPtr &_session, __inout DiaSymbolPtr &_globalScope -) : Symbol(_globalScope) +) : Symbol(_globalScope, CV_CFL_80386) , m_source( _scope.Detach() ) , m_session( _session.Detach() ) { + m_symbol->get_machineType(&m_machineType); } //////////////////////////////////////////////////////////////////////////////// diff --git a/pykd/diawrapper.h b/pykd/diawrapper.h index 3ecde8e..54448e3 100644 --- a/pykd/diawrapper.h +++ b/pykd/diawrapper.h @@ -109,6 +109,8 @@ public: ULONG getUdtKind(); + ULONG getRegisterId(); + Symbol getChildByName(const std::string &_name); ULONG getChildCount(); Symbol getChildByIndex(ULONG _index); @@ -128,9 +130,15 @@ public: static const ValueNameEntry udtKindName[]; static const size_t cntUdtKindName; + static const ValueNameEntry i386RegName[]; + static const size_t cntI386RegName; + + static const ValueNameEntry amd64RegName[]; + static const size_t cntAmd64RegName; + protected: - static std::string printImpl(IDiaSymbol *_symbol, ULONG indent = 0); + static std::string printImpl(IDiaSymbol *_symbol, DWORD machineType, ULONG indent = 0); template TRet callSymbolT( @@ -155,15 +163,20 @@ protected: throw Exception(std::string(desc) + " failed, DIA object is not initialized"); } - Symbol(__inout DiaSymbolPtr &_symbol) { + Symbol(__inout DiaSymbolPtr &_symbol, DWORD machineType) + : m_machineType(machineType) + { m_symbol = _symbol.Detach(); } - Symbol(__in IDiaSymbol *_symbol) { + Symbol(__in IDiaSymbol *_symbol, DWORD machineType) + : m_machineType(machineType) + { m_symbol = _symbol; } DiaSymbolPtr m_symbol; + DWORD m_machineType; }; //////////////////////////////////////////////////////////////////////////////// @@ -176,6 +189,10 @@ public: // create GlobalScope instance static GlobalScope openPdb(const std::string &filePath); + ULONG getMachineType() const { + return m_machineType; + } + private: GlobalScope( diff --git a/pykd/pykd_2008.vcproj b/pykd/pykd_2008.vcproj index 2d8a601..5a4b04a 100644 --- a/pykd/pykd_2008.vcproj +++ b/pykd/pykd_2008.vcproj @@ -1,7 +1,7 @@ + + @@ -435,6 +439,10 @@ RelativePath=".\dbgobj.h" > + + diff --git a/test/scripts/diatest.py b/test/scripts/diatest.py index 075d76a..74be14d 100644 --- a/test/scripts/diatest.py +++ b/test/scripts/diatest.py @@ -8,60 +8,60 @@ import pykd class DiaTest( unittest.TestCase ): def testFind(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertNotEqual(0, len(globalScope)) - symFunction = globalScope.find("FuncWithName0") + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertNotEqual(0, len(gScope)) + symFunction = gScope.find("FuncWithName0") self.assertTrue(1 == len( symFunction )) - symFunction = globalScope.findEx(pykd.SymTagNull, - "FuNc*Name?", - pykd.nsCaseInRegularExpression) + symFunction = gScope.findEx(pykd.SymTagNull, + "FuNc*Name?", + pykd.nsCaseInRegularExpression) self.assertTrue(len(symFunction) > 1) def testSize(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual(1, globalScope["g_ucharValue"].type().size()) - self.assertEqual(2, globalScope["g_ushortValue"].type().size()) - self.assertEqual(4, globalScope["g_ulongValue"].type().size()) - self.assertEqual(8, globalScope["g_ulonglongValue"].type().size()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual(1, gScope["g_ucharValue"].type().size()) + self.assertEqual(2, gScope["g_ushortValue"].type().size()) + self.assertEqual(4, gScope["g_ulongValue"].type().size()) + self.assertEqual(8, gScope["g_ulonglongValue"].type().size()) def testValue(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual(0x5555, globalScope["g_constNumValue"].value()) - self.assertEqual(True, globalScope["g_constBoolValue"].value()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual(0x5555, gScope["g_constNumValue"].value()) + self.assertEqual(True, gScope["g_constBoolValue"].value()) def testName(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual("g_constNumValue", globalScope["g_constNumValue"].name()) - self.assertEqual("FuncWithName0", globalScope["FuncWithName0"].name()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual("g_constNumValue", gScope["g_constNumValue"].name()) + self.assertEqual("FuncWithName0", gScope["FuncWithName0"].name()) def testRva(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - _rva = globalScope["FuncWithName0"].rva() + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + _rva = gScope["FuncWithName0"].rva() self.assertNotEqual(0, _rva) self.assertTrue( _rva < (target.module.end() - target.module.begin()) ) - _rva = globalScope["g_string"].rva() + _rva = gScope["g_string"].rva() self.assertNotEqual(0, _rva) self.assertTrue( _rva < (target.module.end() - target.module.begin()) ) def testSymTag(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual(pykd.SymTagFunction, globalScope["FuncWithName0"].symTag()) - self.assertEqual(pykd.SymTagData, globalScope["g_string"].symTag()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual(pykd.SymTagFunction, gScope["FuncWithName0"].symTag()) + self.assertEqual(pykd.SymTagData, gScope["g_string"].symTag()) def testLocType(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual(pykd.LocIsConstant, globalScope["g_constNumValue"].locType()) - self.assertEqual(pykd.LocIsStatic, globalScope["FuncWithName1"].locType()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual(pykd.LocIsConstant, gScope["g_constNumValue"].locType()) + self.assertEqual(pykd.LocIsStatic, gScope["FuncWithName1"].locType()) def testBasicType(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertFalse(globalScope["g_string"].type().isBasic()) - self.assertEqual(pykd.btBool, globalScope["g_constBoolValue"].type().baseType()) - self.assertEqual(pykd.btULong, globalScope["g_ulongValue"].type().baseType()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertFalse(gScope["g_string"].type().isBasic()) + self.assertEqual(pykd.btBool, gScope["g_constBoolValue"].type().baseType()) + self.assertEqual(pykd.btULong, gScope["g_ulongValue"].type().baseType()) def testBits(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - structWithBits = globalScope["structWithBits"] + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + structWithBits = gScope["structWithBits"] bitField = structWithBits["m_bit0_4"] self.assertEqual(pykd.LocIsBitField, bitField.locType()) self.assertEqual(0, bitField.bitPos()) @@ -76,21 +76,21 @@ class DiaTest( unittest.TestCase ): self.assertEqual(2, bitField.size()) def testIndexId(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertNotEqual( globalScope["classChild"].indexId(), - globalScope["classBase"].indexId() ) - self.assertNotEqual( globalScope["FuncWithName0"].indexId(), - globalScope["FuncWithName1"].indexId() ) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertNotEqual( gScope["classChild"].indexId(), + gScope["classBase"].indexId() ) + self.assertNotEqual( gScope["FuncWithName0"].indexId(), + gScope["FuncWithName1"].indexId() ) def testUdtKind(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - self.assertEqual(pykd.UdtStruct, globalScope["structWithBits"].udtKind()) - self.assertEqual(pykd.UdtUnion, globalScope["unionTest"].udtKind()) - self.assertEqual(pykd.UdtClass, globalScope["classBase"].udtKind()) + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertEqual(pykd.UdtStruct, gScope["structWithBits"].udtKind()) + self.assertEqual(pykd.UdtUnion, gScope["unionTest"].udtKind()) + self.assertEqual(pykd.UdtClass, gScope["classBase"].udtKind()) def testOffset(self): - globalScope = pykd.diaOpenPdb( str(target.module.pdb()) ) - structTest = globalScope["structTest"] + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + structTest = gScope["structTest"] self.assertEqual( 0, structTest["m_field0"].offset() ) self.assertTrue( structTest["m_field0"].offset() < structTest["m_field1"].offset() ) @@ -99,3 +99,8 @@ class DiaTest( unittest.TestCase ): self.assertTrue( structTest["m_field2"].offset() < structTest["m_field3"].offset() ) self.assertTrue(structTest["m_field3"].offset() < structTest.size()) + + def testMachine(self): + gScope = pykd.diaOpenPdb( str(target.module.pdb()) ) + self.assertTrue( (gScope.machineType() == pykd.IMAGE_FILE_MACHINE_I386) or + (gScope.machineType() == pykd.IMAGE_FILE_MACHINE_AMD64) ) diff --git a/test/targetapp/targetapp.cpp b/test/targetapp/targetapp.cpp index 4e60463..0447dc1 100644 --- a/test/targetapp/targetapp.cpp +++ b/test/targetapp/targetapp.cpp @@ -67,12 +67,12 @@ void FuncWithName0() reinterpret_cast(&_classChild)->virtFunc2(); } -void FuncWithName1() +void FuncWithName1(int a) { unionTest _unionTest; _unionTest.m_value = 0; structTest _structTest; - _structTest.m_field1 = 1; + _structTest.m_field1 = a; struct2 _struct2; RtlZeroMemory(&_struct2, sizeof(_struct2)); } @@ -84,7 +84,7 @@ int _tmain(int argc, _TCHAR* argv[]) // Let test scripts to execute __debugbreak(); FuncWithName0(); - FuncWithName1(); + FuncWithName1(2); } catch(std::exception & ex) {