diff --git a/pykd/dbgclient.h b/pykd/dbgclient.h index 9b8d0bc..fe4e174 100644 --- a/pykd/dbgclient.h +++ b/pykd/dbgclient.h @@ -503,6 +503,10 @@ void changeDebuggerStatus() ///////////////////////////////////////////////////////////////////////////////// +void initDbgClientPyExports(); + +///////////////////////////////////////////////////////////////////////////////// + }; // namespace pykd diff --git a/pykd/dbgclientpyinit.cpp b/pykd/dbgclientpyinit.cpp new file mode 100644 index 0000000..b377041 --- /dev/null +++ b/pykd/dbgclientpyinit.cpp @@ -0,0 +1,437 @@ +// +// Debug client class (and global function) initialization +// + +#include "stdafx.h" + +#include "dbgclient.h" +#include "dbgmem.h" +#include "process.h" +#include "bpoint.h" + +namespace pykd { + +//////////////////////////////////////////////////////////////////////////////// + +BOOST_PYTHON_FUNCTION_OVERLOADS( dprint_, dprint, 1, 2 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( dprintln_, dprintln, 1, 2 ); + +BOOST_PYTHON_FUNCTION_OVERLOADS( loadChars_, loadChars, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadWChars_, loadWChars, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadBytes_, loadBytes, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadWords_, loadWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadDWords_, loadDWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadQWords_, loadQWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignBytes_, loadSignBytes, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignWords_, loadSignWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignDWords_, loadSignDWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignQWords_, loadSignQWords, 2, 3 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( compareMemory_, compareMemory, 3, 4 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( getLocals_, getLocals, 0, 1 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( setSoftwareBp_, setSoftwareBp, 1, 2 ); +BOOST_PYTHON_FUNCTION_OVERLOADS( setHardwareBp_, setHardwareBp, 3, 4 ); + +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadChars, DebugClient::loadChars, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadWChars, DebugClient::loadWChars, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadBytes, DebugClient::loadBytes, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadWords, DebugClient::loadWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadDWords, DebugClient::loadDWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadQWords, DebugClient::loadQWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignBytes, DebugClient::loadSignBytes, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignWords, DebugClient::loadSignWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignDWords, DebugClient::loadSignDWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignQWords, DebugClient::loadSignQWords, 2, 3 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_compareMemory, DebugClient::compareMemory, 3, 4 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_getLocals, DebugClient::getLocals, 0, 1 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_setSoftwareBp, DebugClient::setSoftwareBp, 1, 2 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_setHardwareBp, DebugClient::setHardwareBp, 3, 4 ); + +//////////////////////////////////////////////////////////////////////////////// + +void initDbgClientPyExports() +{ + python::class_("dbgClient", "Class representing a debugging session", python::no_init ) + .def( "addr64", &DebugClient::addr64, + "Extend address to 64 bits formats" ) + .def( "breakin", &DebugClient::breakin, + "Break into debugger" ) + .def( "compareMemory", &DebugClient::compareMemory, DebugClient_compareMemory( python::args( "offset1", "offset2", "length", "phyAddr" ), + "Compare two memory buffers by virtual or physical addresses" ) ) + .def( "loadDump", &DebugClient::loadDump, + "Load crash dump" ) + .def( "startProcess", &DebugClient::startProcess, + "Start process for debugging" ) + .def( "attachProcess", &DebugClient::attachProcess, + "Attach debugger to a exsisting process" ) + .def( "attachKernel", &DebugClient::attachKernel, + "Attach debugger to a target's kernel" ) + .def( "detachProcess", &DebugClient::detachProcess, + "Detach debugger from the current process" ) + .def( "expr", &DebugClient::evaluate, + "Evaluate windbg expression" ) + .def( "findSymbol", &DebugClient::findSymbol, + "Find symbol by the target virtual memory offset" ) + .def( "getCurrentProcess", &DebugClient::getCurrentProcess, + "Return pointer to current process's block" ) + .def( "getCurrentStack", &DebugClient::getCurrentStack, + "Return a current stack as a list of stackFrame objects" ) + .def( "getDebuggeeType", &DebugClient::getDebuggeeType, + "Return type of the debuggee" ) + .def( "getImplicitThread", &DebugClient::getImplicitThread, + "Return implicit thread for current process" ) + .def( "getExecutionStatus", &DebugClient::getExecutionStatus, + "Return information about the execution status of the debugger" ) + .def( "getOffset", &DebugClient::getOffset, + "Return traget virtual address for specified symbol" ) + .def( "getPdbFile", &DebugClient::getPdbFile, + "Return full path to PDB (Program DataBase, debug information) file" ) + .def( "getProcessorMode", &DebugClient::getProcessorMode, + "Return current processor mode as string: X86, ARM, IA64 or X64" ) + .def( "getProcessorType", &DebugClient::getProcessorType, + "Return type of physical processor: X86, ARM, IA64 or X64" ) + .def( "getThreadList", &DebugClient::getThreadList, + "Return list of threads (each item is numeric identifier of thread)" ) + .def( "go", &DebugClient::changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_GO" ) + .def( "is64bitSystem", &DebugClient::is64bitSystem, + "Check if target system has 64 address space" ) + .def( "isDumpAnalyzing", &DebugClient::isDumpAnalyzing, + "Check if it is a dump analyzing ( not living debuggee )" ) + .def( "isKernelDebugging", &DebugClient::isKernelDebugging, + "Check if kernel dubugging is running" ) + .def( "isValid", &DebugClient::isVaValid, + "Check if the virtual address is valid" ) + .def( "killProcess", &DebugClient::terminateProcess, + "Stop debugging and terminate current process" ) + .def( "loadBytes", &DebugClient::loadBytes, DebugClient_loadBytes( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned bytes" ) ) + .def( "loadWords", &DebugClient::loadWords, DebugClient_loadWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned shorts" ) ) + .def( "loadDWords", &DebugClient::loadDWords, DebugClient_loadDWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned long ( double word )" ) ) + .def( "loadQWords", &DebugClient::loadQWords, DebugClient_loadQWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned long long ( quad word )" ) ) + .def( "loadSignBytes", &DebugClient::loadSignBytes, DebugClient_loadSignBytes( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed bytes" ) ) + .def( "loadSignWords", &DebugClient::loadSignWords, DebugClient_loadSignWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed shorts" ) ) + .def( "loadSignDWords", &DebugClient::loadSignDWords, DebugClient_loadSignDWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed longs" ) ) + .def( "loadSignQWords", &DebugClient::loadSignQWords, DebugClient_loadSignQWords( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed long longs" ) ) + .def( "loadChars", &DebugClient::loadChars, DebugClient_loadChars( python::args( "offset", "count", "phyAddr" ), + "Load string from target memory" ) ) + .def( "loadWChars", &DebugClient::loadWChars, DebugClient_loadWChars( python::args( "offset", "count", "phyAddr" ), + "Load string from target memory" ) ) + .def( "loadCStr", &DebugClient::loadCStr, + "Load string from the target buffer containing 0-terminated ansi-string" ) + .def( "loadWStr", &DebugClient::loadWStr, + "Load string from the target buffer containing 0-terminated unicode-string" ) + .def( "loadUnicodeString", &DebugClient::loadUnicodeStr, + "Return string represention of windows UNICODE_STRING type" ) + .def( "loadAnsiString", &DebugClient::loadAnsiStr, + "Return string represention of windows ANSI_STRING type" ) + .def( "loadPtrList", &DebugClient::loadPtrList, + "Return list of pointers, each points to next" ) + .def( "loadPtrArray", &DebugClient::loadPtrArray, + "Read the block of the target's memory and return it as a list of pointers" ) + .def( "ptrByte", &DebugClient::ptrByte, + "Read an unsigned 1-byte integer from the target memory" ) + .def( "ptrWord", &DebugClient::ptrWord, + "Read an unsigned 2-byte integer from the target memory" ) + .def( "ptrDWord", &DebugClient::ptrDWord, + "Read an unsigned 4-byte integer from the target memory" ) + .def( "ptrQWord", &DebugClient::ptrQWord, + "Read an unsigned 8-byte integer from the target memory" ) + .def( "ptrMWord", &DebugClient::ptrMWord, + "Read an unsigned mashine's word wide integer from the target memory" ) + .def( "ptrSignByte", &DebugClient::ptrSignByte, + "Read an signed 1-byte integer from the target memory" ) + .def( "ptrSignWord", &DebugClient::ptrSignWord, + "Read an signed 2-byte integer from the target memory" ) + .def( "ptrSignDWord", &DebugClient::ptrSignDWord, + "Read an signed 4-byte integer from the target memory" ) + .def( "ptrSignQWord", &DebugClient::ptrSignQWord, + "Read an signed 8-byte integer from the target memory" ) + .def( "ptrSignMWord", &DebugClient::ptrSignMWord, + "Read an signed mashine's word wide integer from the target memory" ) + .def( "ptrPtr", &DebugClient::ptrPtr, + "Read an pointer value from the target memory" ) + .def("typedVar",&DebugClient::getTypedVarByName, + "Return a typedVar class instance" ) + .def("typedVar",&DebugClient::getTypedVarByTypeInfo, + "Return a typedVar class instance" ) + .def("typedVar",&DebugClient::getTypedVarByTypeName, + "Return a typedVar class instance" ) + .def( "loadExt", &pykd::DebugClient::loadExtension, + "Load a debuger extension" ) + .def( "loadModule", &pykd::DebugClient::loadModuleByName, + "Return instance of Module class" ) + .def( "loadModule", &pykd::DebugClient::loadModuleByOffset, + "Return instance of the Module class which posseses specified address" ) + .def( "dbgCommand", &pykd::DebugClient::dbgCommand, + "Run a debugger's command and return it's result as a string" ) + .def( "dprint", &pykd::DebugClient::dprint, + "Print out string. If dml = True string is printed with dml highlighting ( only for windbg )" ) + .def( "dprintln", &pykd::DebugClient::dprintln, + "Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )" ) + .def( "ptrSize", &DebugClient::ptrSize, + "Return effective pointer size" ) + .def ( "rdmsr", &DebugClient::loadMSR, + "Return MSR value" ) + .def( "reg", &DebugClient::getRegByName, + "Return a CPU regsiter value by the register's name" ) + .def( "reg", &DebugClient::getRegByIndex, + "Return a CPU regsiter value by the register's value" ) + .def( "setCurrentProcess", &DebugClient::setCurrentProcess, + "Set current process by address" ) + .def( "setExecutionStatus", &DebugClient::setExecutionStatus, + "Requests that the debugger engine enter an executable state" ) + .def( "setImplicitThread", &DebugClient::setImplicitThread, + "Set implicit thread for current process" ) + .def( "setProcessorMode", &DebugClient::setProcessorMode, + "Set current processor mode by string (X86, ARM, IA64 or X64)" ) + .def( "step", &DebugClient::changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_STEP_OVER" ) + .def( "symbolsPath", &DebugClient::dbgSymPath, + "Return symbol path" ) + .def( "trace", &DebugClient::changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_STEP_INTO" ) + .def("typedVarList", &DebugClient::getTypedVarListByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) + .def("typedVarList", &DebugClient::getTypedVarListByType, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) + .def("typedVarArray", &DebugClient::getTypedVarArrayByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) + .def("typedVarArray", &DebugClient::getTypedVarArrayByType, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) + .def("containingRecord", &DebugClient::containingRecordByName, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) + .def("containingRecord", &DebugClient::containingRecordByType, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) + .def( "waitForEvent", &DebugClient::waitForEvent, + "Wait for events that breaks into the debugger" ) + .def( "wrmsr", &DebugClient::setMSR, + "Set MSR value" ) + .def( "getNumberProcessors", &DebugClient::getNumberProcessors, + "Get the number of actual processors in the machine" ) + .def( "getPageSize", &DebugClient::getPageSize, + "Get the page size for the currently executing processor context" ) + .def( "getContext", &DebugClient::getThreadContext, + "Get context of current thread (register values)" ) + .def( "getLocals", &DebugClient::getLocals, DebugClient_getLocals( python::args( "ctx" ), + "Get list of local variables" ) ) + .def( "setBp", &DebugClient::setSoftwareBp, DebugClient_setSoftwareBp( python::args( "offset", "callback" ), + "Set software breakpoint on executiont" ) ) + .def( "setBp", &DebugClient::setHardwareBp, DebugClient_setHardwareBp( python::args( "offset", "size", "accsessType", "callback" ), + "Set hardware breakpoint" ) ) + .def( "getAllBp", &DebugClient::getAllBp, + "Get all breapoint IDs" ) + .def( "removeBp", &DebugClient::removeBp, + "Remove breapoint by IDs" ) + .def( "removeBp", &DebugClient::removeAllBp, + "Remove all breapoints" ) + .def( "addSynSymbol", &DebugClient::addSyntheticSymbol, + "Add new synthetic symbol for virtual address" ) + .def( "delAllSynSymbols", &DebugClient::delAllSyntheticSymbols, + "Delete all synthetic symbol for all modules") + .def( "delSynSymbol", &DebugClient::delSyntheticSymbol, + "Delete synthetic symbols by virtual address" ) + .def( "delSynSymbolsMask", &DebugClient::delSyntheticSymbolsMask, + "Delete synthetic symbols by mask of module and symbol name"); + + python::def( "addr64", &addr64, + "Extend address to 64 bits formats" ); + python::def( "breakin", &breakin, + "Break into debugger" ); + python::def( "compareMemory", &compareMemory, compareMemory_( python::args( "offset1", "offset2", "length", "phyAddr" ), + "Compare two memory buffers by virtual or physical addresses" ) ); + python::def( "createDbgClient", (DebugClientPtr(*)())&DebugClient::createDbgClient, + "create a new instance of the dbgClient class" ); + python::def( "loadDump", &loadDump, + "Load crash dump (only for console)"); + python::def( "startProcess", &startProcess, + "Start process for debugging (only for console)"); + python::def( "attachProcess", &attachProcess, + "Attach debugger to a exsisting process" ); + python::def( "attachKernel", &attachKernel, + "Attach debugger to a kernel target" ); + python::def( "detachProcess", &detachProcess, + "Detach denugger from the current process" ); + python::def( "expr", &evaluate, + "Evaluate windbg expression" ); + python::def( "findSymbol", &findSymbol, + "Find symbol by the target virtual memory offset" ); + python::def( "getCurrentProcess", &getCurrentProcess, + "Return pointer to current process's block" ); + python::def( "getCurrentStack", &getCurrentStack, + "Return a current stack as a list of stackFrame objects" ); + python::def( "getDebuggeeType", &getDebuggeeType, + "Return type of the debuggee" ); + python::def( "getImplicitThread", &getImplicitThread, + "Return implicit thread for current process" ); + python::def( "getExecutionStatus", &getExecutionStatus, + "Return information about the execution status of the debugger" ); + python::def( "getOffset", &getOffset, + "Return traget virtual address for specified symbol" ); + python::def( "getPdbFile", &getPdbFile, + "Return full path to PDB (Program DataBase, debug information) file" ); + python::def( "go", &changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_GO" ); + python::def( "getProcessorMode", &getProcessorMode, + "Return current processor mode as string: X86, ARM, IA64 or X64" ); + python::def( "getProcessorType", &getProcessorType, + "Return type of physical processor: X86, ARM, IA64 or X64" ); + python::def( "getThreadList", &getThreadList, + "Return list of threads (each item is numeric identifier of thread)" ); + python::def( "is64bitSystem", &is64bitSystem, + "Check if target system has 64 address space" ); + python::def( "isDumpAnalyzing", &isDumpAnalyzing, + "Check if it is a dump analyzing ( not living debuggee )" ); + python::def( "isKernelDebugging", &isKernelDebugging, + "Check if kernel dubugging is running" ); + python::def( "isWindbgExt", &WindbgGlobalSession::isInit, + "Check if script works in windbg context" ); + python::def( "isValid", &isVaValid, + "Check if the virtual address is valid" ); + python::def( "killProcess", &terminateProcess, + "Stop debugging and terminate current process" ); + python::def( "loadBytes", &loadBytes, loadBytes_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as liat of unsigned bytes" ) ); + python::def( "loadWords", &loadWords, loadWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned shorts" ) ); + python::def( "loadDWords", &loadDWords, loadDWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned long ( double word )" ) ); + python::def( "loadQWords", &loadQWords, loadQWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of unsigned long long ( quad word )" ) ); + python::def( "loadSignBytes", &loadSignBytes, loadSignBytes_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed bytes" ) ); + python::def( "loadSignWords", &loadSignWords, loadSignWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed words" ) ); + python::def( "loadSignDWords", &loadSignDWords, loadSignDWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed longs" ) ); + python::def( "loadSignQWords", &loadSignQWords, loadSignQWords_( python::args( "offset", "count", "phyAddr" ), + "Read the block of the target's memory and return it as list of signed long longs" ) ); + python::def( "loadChars", &loadChars, loadChars_( python::args( "address", "count", "phyAddr" ), + "Load string from target memory" ) ); + python::def( "loadWChars", &loadWChars, loadWChars_( python::args( "address", "count", "phyAddr" ), + "Load string from target memory" ) ); + python::def( "loadCStr", &loadCStr, + "Load string from the target buffer containing 0-terminated ansi-string" ); + python::def( "loadWStr", &loadWStr, + "Load string from the target buffer containing 0-terminated unicode-string" ); + python::def( "loadUnicodeString", &loadUnicodeStr, + "Return string represention of windows UNICODE_STRING type" ); + python::def( "loadAnsiString", &loadAnsiStr, + "Return string represention of windows ANSU_STRING type" ); + python::def( "loadPtrList", &loadPtrList, + "Return list of pointers, each points to next" ); + python::def( "loadPtrArray", &loadPtrArray, + "Read the block of the target's memory and return it as a list of pointers" ); + python::def( "ptrByte", &ptrByte, + "Read an unsigned 1-byte integer from the target memory" ); + python::def( "ptrWord", &ptrWord, + "Read an unsigned 2-byte integer from the target memory" ); + python::def( "ptrDWord", (ULONG64(*)(ULONG64))&ptrDWord, + "Read an unsigned 4-byte integer from the target memory" ); + python::def( "ptrQWord", (ULONG64(*)(ULONG64))&ptrQWord, + "Read an unsigned 8-byte integer from the target memory" ); + python::def( "ptrMWord", (ULONG64(*)(ULONG64))&ptrMWord, + "Read an unsigned mashine's word wide integer from the target memory" ); + python::def( "ptrSignByte", &ptrSignByte, + "Read an signed 1-byte integer from the target memory" ); + python::def( "ptrSignWord", &ptrSignWord, + "Read an signed 2-byte integer from the target memory" ); + python::def( "ptrSignDWord", &ptrSignDWord, + "Read an signed 4-byte integer from the target memory" ); + python::def( "ptrSignQWord", &ptrSignQWord, + "Read an signed 8-byte integer from the target memory" ); + python::def( "ptrSignMWord", &ptrSignMWord, + "Read an signed mashine's word wide integer from the target memory" ); + python::def( "ptrPtr", (ULONG64(*)(ULONG64))&ptrPtr, + "Read an pointer value from the target memory" ); + boost::python::def( "addSynSymbol", &addSyntheticSymbol, + "Add new synthetic symbol for virtual address" ); + boost::python::def( "delAllSynSymbols", &delAllSyntheticSymbols, + "Delete all synthetic symbol for all modules"); + boost::python::def( "delSynSymbol", &delSyntheticSymbol, + "Delete synthetic symbols by virtual address" ); + boost::python::def( "delSynSymbolsMask", &delSyntheticSymbolsMask, + "Delete synthetic symbols by mask of module and symbol name"); + python::def( "loadExt", &pykd::loadExtension, + "Load a debuger extension" ); + python::def( "loadModule", &loadModuleByName, + "Return instance of Module class" ); + python::def( "loadModule", &loadModuleByOffset, + "Return instance of the Module class which posseses specified address" ); + python::def( "dbgCommand", &pykd::dbgCommand, + "Run a debugger's command and return it's result as a string" ), + python::def( "dprint", &pykd::dprint, dprint_( boost::python::args( "str", "dml" ), + "Print out string. If dml = True string is printed with dml highlighting ( only for windbg )" ) ); + python::def( "dprintln", &pykd::dprintln, dprintln_( boost::python::args( "str", "dml" ), + "Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )" ) ); + python::def( "ptrSize", &ptrSize, + "Return effective pointer size" ); + python::def ( "rdmsr", &DebugClient::loadMSR, + "Return MSR value" ); + python::def( "reg", &getRegByName, + "Return a CPU regsiter value by the register's name" ); + python::def( "reg", &getRegByIndex, + "Return a CPU regsiter value by the register's value" ); + python::def( "setExecutionStatus", &setExecutionStatus, + "Requests that the debugger engine enter an executable state" ); + python::def( "setCurrentProcess", &setCurrentProcess, + "Set current process by address" ); + python::def( "setImplicitThread", &setImplicitThread, + "Set implicit thread for current process" ); + python::def( "setProcessorMode", &setProcessorMode, + "Set current processor mode by string (X86, ARM, IA64 or X64)" ); + python::def( "step", &changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_STEP_OVER" ); + python::def( "symbolsPath", &dbgSymPath, + "Return symbol path" ); + python::def( "wrmsr", &setMSR, + "Set MSR value" ); + python::def( "trace", &changeDebuggerStatus, + "Change debugger status to DEBUG_STATUS_STEP_INTO" ); + python::def("typedVarList", &getTypedVarListByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ); + python::def("typedVarList", &getTypedVarListByType, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ); + python::def("typedVarArray", &getTypedVarArrayByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ); + python::def("typedVarArray", &getTypedVarArrayByType, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ); + python::def("containingRecord", &containingRecordByName, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ); + python::def("containingRecord", &containingRecordByType, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ); + python::def( "waitForEvent", &waitForEvent, + "Wait for events that breaks into the debugger" ); + python::def( "getNumberProcessors", &getNumberProcessors, + "Get the number of actual processors in the machine" ); + python::def( "getPageSize", &getPageSize, + "Get the page size for the currently executing processor context" ); + python::def( "getContext", &getThreadContext, + "Get context of current thread (register values)" ); + python::def( "getLocals", &getLocals, getLocals_( python::args( "ctx" ), + "Get list of local variables" ) ); + python::def( "setBp", &setSoftwareBp, setSoftwareBp_( python::args( "offset", "callback" ), + "Set software breakpoint on executiont" ) ); + python::def( "setBp", &setHardwareBp, setHardwareBp_( python::args( "offset", "size", "accsessType", "callback" ) , + "Set hardware breakpoint" ) ); + python::def( "getAllBp", &getAllBp, + "Get all breapoint IDs" ); + python::def( "removeBp", &removeBp, + "Remove breapoint by IDs" ); + python::def( "removeBp", &removeAllBp, + "Remove all breapoints" ); +} + +}; // namespace pykd + +//////////////////////////////////////////////////////////////////////////////// diff --git a/pykd/dbgext.cpp b/pykd/dbgext.cpp index 6ec0839..c8581b7 100644 --- a/pykd/dbgext.cpp +++ b/pykd/dbgext.cpp @@ -1,34 +1,16 @@ -#include "stdafx.h" -#include +#include "stdafx.h" #include #include "windbg.h" -#include "module.h" -#include "diawrapper.h" #include "dbgclient.h" -#include "dbgio.h" #include "dbgpath.h" -#include "dbgcmd.h" -#include "dbgevent.h" -#include "typeinfo.h" -#include "typedvar.h" -#include "dbgmem.h" -#include "intbase.h" -#include "process.h" -#include "bpoint.h" -#include "stkframe.h" -#include "pykdver.h" using namespace pykd; //////////////////////////////////////////////////////////////////////////////// -static const std::string pykdVersion = PYKD_VERSION_BUILD_STR; - -//////////////////////////////////////////////////////////////////////////////// - BOOL WINAPI DllMain( __in HINSTANCE /*hinstDLL*/, __in DWORD fdwReason, @@ -50,924 +32,7 @@ BOOL WINAPI DllMain( //////////////////////////////////////////////////////////////////////////////// -static python::dict genDict(const pyDia::Symbol::ValueNameEntry srcValues[], size_t cntValues) -{ - python::dict resDict; - for (size_t i = 0; i < cntValues; ++i) - resDict[srcValues[i].first] = srcValues[i].second; - return resDict; -} - -//////////////////////////////////////////////////////////////////////////////// - -std::string -getDebuggerImage() -{ - std::vector buffer(MAX_PATH); - GetModuleFileNameExA( GetCurrentProcess(), NULL, &buffer[0], (DWORD)buffer.size() ); - return std::string( &buffer[0] ); -} - -//////////////////////////////////////////////////////////////////////////////// - -BOOST_PYTHON_FUNCTION_OVERLOADS( dprint_, dprint, 1, 2 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( dprintln_, dprintln, 1, 2 ); - -BOOST_PYTHON_FUNCTION_OVERLOADS( loadChars_, loadChars, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadWChars_, loadWChars, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadBytes_, loadBytes, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadWords_, loadWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadDWords_, loadDWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadQWords_, loadQWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignBytes_, loadSignBytes, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignWords_, loadSignWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignDWords_, loadSignDWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( loadSignQWords_, loadSignQWords, 2, 3 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( compareMemory_, compareMemory, 3, 4 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( getLocals_, getLocals, 0, 1 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( setSoftwareBp_, setSoftwareBp, 1, 2 ); -BOOST_PYTHON_FUNCTION_OVERLOADS( setHardwareBp_, setHardwareBp, 3, 4 ); - -BOOST_PYTHON_FUNCTION_OVERLOADS( pyDia_GlobalScope_loadExe, pyDia::GlobalScope::loadExe, 1, 2 ); - -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadChars, DebugClient::loadChars, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadWChars, DebugClient::loadWChars, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadBytes, DebugClient::loadBytes, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadWords, DebugClient::loadWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadDWords, DebugClient::loadDWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadQWords, DebugClient::loadQWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignBytes, DebugClient::loadSignBytes, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignWords, DebugClient::loadSignWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignDWords, DebugClient::loadSignDWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_loadSignQWords, DebugClient::loadSignQWords, 2, 3 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_compareMemory, DebugClient::compareMemory, 3, 4 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_getLocals, DebugClient::getLocals, 0, 1 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_setSoftwareBp, DebugClient::setSoftwareBp, 1, 2 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( DebugClient_setHardwareBp, DebugClient::setHardwareBp, 3, 4 ); -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( StackFrame_getLocals, StackFrame::getLocals, 0, 1 ); - -BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( pyDia_Symbol_findChildrenEx, pyDia::Symbol::findChildrenEx, 1, 3 ); - -#define DEF_PY_CONST_ULONG(x) \ - python::scope().attr(#x) = ULONG(##x) - -BOOST_PYTHON_MODULE( pykd ) -{ - python::scope().attr("version") = pykdVersion; - - python::class_( "intBase", "intBase", python::no_init ) - .def( python::init() ) - .def( "__eq__", &intBase::eq ) - .def( "__ne__", &intBase::ne) - .def( "__lt__", &intBase::lt) - .def( "__gt__", &intBase::gt ) - .def( "__le__", &intBase::le ) - .def( "__ge__", &intBase::ge ) - .def( "__add__", &intBase::add ) - .def( "__radd__", &intBase::add ) - .def( "__sub__", &intBase::sub ) - .def( "__rsub__", &intBase::rsub ) - .def( "__mul__", &intBase::mul ) - .def( "__rmul__", &intBase::mul ) - .def( "__div__", &intBase::div ) - .def( "__rdiv__", &intBase::rdiv ) - .def( "__mod__", &intBase::mod ) - .def( "__rmod__", &intBase::rmod ) - .def( "__rshift__", &intBase::rshift ) - .def( "__rrshift__", &intBase::rrshift ) - .def( "__lshift__", &intBase::lshift ) - .def( "__rlshift__", &intBase::rlshift ) - .def( "__and__", &intBase::and ) - .def( "__rand__", &intBase::and ) - .def( "__or__", &intBase::or ) - .def( "__ror__", &intBase::or ) - .def( "__xor__", &intBase::xor ) - .def( "__rxor__", &intBase::xor ) - .def( "__neg__", &intBase::neg ) - .def( "__pos__", &intBase::pos ) - .def( "__invert__", &intBase::invert ) - .def( "__nonzero__", &intBase::nonzero ) - .def( "__str__", &intBase::str ) - .def( "__hex__", &intBase::hex ) - .def( "__long__", &intBase::long_ ) - .def( "__int__", &intBase::int_ ) - .def( "__index__", &intBase::long_ ) - .def( "__hash__", &intBase::long_ ); - - python::implicitly_convertible(); - python::implicitly_convertible(); - - python::class_("dbgClient", "Class representing a debugging session", python::no_init ) - .def( "addr64", &DebugClient::addr64, - "Extend address to 64 bits formats" ) - .def( "breakin", &DebugClient::breakin, - "Break into debugger" ) - .def( "compareMemory", &DebugClient::compareMemory, DebugClient_compareMemory( python::args( "offset1", "offset2", "length", "phyAddr" ), - "Compare two memory buffers by virtual or physical addresses" ) ) - .def( "loadDump", &DebugClient::loadDump, - "Load crash dump" ) - .def( "startProcess", &DebugClient::startProcess, - "Start process for debugging" ) - .def( "attachProcess", &DebugClient::attachProcess, - "Attach debugger to a exsisting process" ) - .def( "attachKernel", &DebugClient::attachKernel, - "Attach debugger to a target's kernel" ) - .def( "detachProcess", &DebugClient::detachProcess, - "Detach debugger from the current process" ) - .def( "expr", &DebugClient::evaluate, - "Evaluate windbg expression" ) - .def( "findSymbol", &DebugClient::findSymbol, - "Find symbol by the target virtual memory offset" ) - .def( "getCurrentProcess", &DebugClient::getCurrentProcess, - "Return pointer to current process's block" ) - .def( "getCurrentStack", &DebugClient::getCurrentStack, - "Return a current stack as a list of stackFrame objects" ) - .def( "getDebuggeeType", &DebugClient::getDebuggeeType, - "Return type of the debuggee" ) - .def( "getImplicitThread", &getImplicitThread, - "Return implicit thread for current process" ) - .def( "getExecutionStatus", &DebugClient::getExecutionStatus, - "Return information about the execution status of the debugger" ) - .def( "getOffset", &DebugClient::getOffset, - "Return traget virtual address for specified symbol" ) - .def( "getPdbFile", &DebugClient::getPdbFile, - "Return full path to PDB (Program DataBase, debug information) file" ) - .def( "getProcessorMode", &DebugClient::getProcessorMode, - "Return current processor mode as string: X86, ARM, IA64 or X64" ) - .def( "getProcessorType", &DebugClient::getProcessorType, - "Return type of physical processor: X86, ARM, IA64 or X64" ) - .def( "getThreadList", &DebugClient::getThreadList, - "Return list of threads (each item is numeric identifier of thread)" ) - .def( "go", &DebugClient::changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_GO" ) - .def( "is64bitSystem", &DebugClient::is64bitSystem, - "Check if target system has 64 address space" ) - .def( "isDumpAnalyzing", &DebugClient::isDumpAnalyzing, - "Check if it is a dump analyzing ( not living debuggee )" ) - .def( "isKernelDebugging", &DebugClient::isKernelDebugging, - "Check if kernel dubugging is running" ) - .def( "isValid", &DebugClient::isVaValid, - "Check if the virtual address is valid" ) - .def( "killProcess", &DebugClient::terminateProcess, - "Stop debugging and terminate current process" ) - .def( "loadBytes", &DebugClient::loadBytes, DebugClient_loadBytes( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned bytes" ) ) - .def( "loadWords", &DebugClient::loadWords, DebugClient_loadWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned shorts" ) ) - .def( "loadDWords", &DebugClient::loadDWords, DebugClient_loadDWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned long ( double word )" ) ) - .def( "loadQWords", &DebugClient::loadQWords, DebugClient_loadQWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned long long ( quad word )" ) ) - .def( "loadSignBytes", &DebugClient::loadSignBytes, DebugClient_loadSignBytes( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed bytes" ) ) - .def( "loadSignWords", &DebugClient::loadSignWords, DebugClient_loadSignWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed shorts" ) ) - .def( "loadSignDWords", &DebugClient::loadSignDWords, DebugClient_loadSignDWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed longs" ) ) - .def( "loadSignQWords", &DebugClient::loadSignQWords, DebugClient_loadSignQWords( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed long longs" ) ) - .def( "loadChars", &DebugClient::loadChars, DebugClient_loadChars( python::args( "offset", "count", "phyAddr" ), - "Load string from target memory" ) ) - .def( "loadWChars", &DebugClient::loadWChars, DebugClient_loadWChars( python::args( "offset", "count", "phyAddr" ), - "Load string from target memory" ) ) - .def( "loadCStr", &DebugClient::loadCStr, - "Load string from the target buffer containing 0-terminated ansi-string" ) - .def( "loadWStr", &DebugClient::loadWStr, - "Load string from the target buffer containing 0-terminated unicode-string" ) - .def( "loadUnicodeString", &DebugClient::loadUnicodeStr, - "Return string represention of windows UNICODE_STRING type" ) - .def( "loadAnsiString", &DebugClient::loadAnsiStr, - "Return string represention of windows ANSI_STRING type" ) - .def( "loadPtrList", &DebugClient::loadPtrList, - "Return list of pointers, each points to next" ) - .def( "loadPtrArray", &DebugClient::loadPtrArray, - "Read the block of the target's memory and return it as a list of pointers" ) - .def( "ptrByte", &DebugClient::ptrByte, - "Read an unsigned 1-byte integer from the target memory" ) - .def( "ptrWord", &DebugClient::ptrWord, - "Read an unsigned 2-byte integer from the target memory" ) - .def( "ptrDWord", &DebugClient::ptrDWord, - "Read an unsigned 4-byte integer from the target memory" ) - .def( "ptrQWord", &DebugClient::ptrQWord, - "Read an unsigned 8-byte integer from the target memory" ) - .def( "ptrMWord", &DebugClient::ptrMWord, - "Read an unsigned mashine's word wide integer from the target memory" ) - .def( "ptrSignByte", &DebugClient::ptrSignByte, - "Read an signed 1-byte integer from the target memory" ) - .def( "ptrSignWord", &DebugClient::ptrSignWord, - "Read an signed 2-byte integer from the target memory" ) - .def( "ptrSignDWord", &DebugClient::ptrSignDWord, - "Read an signed 4-byte integer from the target memory" ) - .def( "ptrSignQWord", &DebugClient::ptrSignQWord, - "Read an signed 8-byte integer from the target memory" ) - .def( "ptrSignMWord", &DebugClient::ptrSignMWord, - "Read an signed mashine's word wide integer from the target memory" ) - .def( "ptrPtr", &DebugClient::ptrPtr, - "Read an pointer value from the target memory" ) - .def("typedVar",&DebugClient::getTypedVarByName, - "Return a typedVar class instance" ) - .def("typedVar",&DebugClient::getTypedVarByTypeInfo, - "Return a typedVar class instance" ) - .def("typedVar",&DebugClient::getTypedVarByTypeName, - "Return a typedVar class instance" ) - .def( "loadExt", &pykd::DebugClient::loadExtension, - "Load a debuger extension" ) - .def( "loadModule", &pykd::DebugClient::loadModuleByName, - "Return instance of Module class" ) - .def( "loadModule", &pykd::DebugClient::loadModuleByOffset, - "Return instance of the Module class which posseses specified address" ) - .def( "dbgCommand", &pykd::DebugClient::dbgCommand, - "Run a debugger's command and return it's result as a string" ) - .def( "dprint", &pykd::DebugClient::dprint, - "Print out string. If dml = True string is printed with dml highlighting ( only for windbg )" ) - .def( "dprintln", &pykd::DebugClient::dprintln, - "Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )" ) - .def( "ptrSize", &DebugClient::ptrSize, - "Return effective pointer size" ) - .def ( "rdmsr", &DebugClient::loadMSR, - "Return MSR value" ) - .def( "reg", &DebugClient::getRegByName, - "Return a CPU regsiter value by the register's name" ) - .def( "reg", &DebugClient::getRegByIndex, - "Return a CPU regsiter value by the register's value" ) - .def( "setCurrentProcess", &DebugClient::setCurrentProcess, - "Set current process by address" ) - .def( "setExecutionStatus", &DebugClient::setExecutionStatus, - "Requests that the debugger engine enter an executable state" ) - .def( "setImplicitThread", &DebugClient::setImplicitThread, - "Set implicit thread for current process" ) - .def( "setProcessorMode", &DebugClient::setProcessorMode, - "Set current processor mode by string (X86, ARM, IA64 or X64)" ) - .def( "step", &DebugClient::changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_STEP_OVER" ) - .def( "symbolsPath", &DebugClient::dbgSymPath, - "Return symbol path" ) - .def( "trace", &DebugClient::changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_STEP_INTO" ) - .def("typedVarList", &DebugClient::getTypedVarListByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) - .def("typedVarList", &DebugClient::getTypedVarListByType, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) - .def("typedVarArray", &DebugClient::getTypedVarArrayByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) - .def("typedVarArray", &DebugClient::getTypedVarArrayByType, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) - .def("containingRecord", &DebugClient::containingRecordByName, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) - .def("containingRecord", &DebugClient::containingRecordByType, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) - .def( "waitForEvent", &DebugClient::waitForEvent, - "Wait for events that breaks into the debugger" ) - .def( "wrmsr", &DebugClient::setMSR, - "Set MSR value" ) - .def( "getNumberProcessors", &DebugClient::getNumberProcessors, - "Get the number of actual processors in the machine" ) - .def( "getPageSize", &DebugClient::getPageSize, - "Get the page size for the currently executing processor context" ) - .def( "getContext", &DebugClient::getThreadContext, - "Get context of current thread (register values)" ) - .def( "getLocals", &DebugClient::getLocals, DebugClient_getLocals( python::args( "ctx" ), - "Get list of local variables" ) ) - .def( "setBp", &DebugClient::setSoftwareBp, DebugClient_setSoftwareBp( python::args( "offset", "callback" ), - "Set software breakpoint on executiont" ) ) - .def( "setBp", &DebugClient::setHardwareBp, DebugClient_setHardwareBp( python::args( "offset", "size", "accsessType", "callback" ), - "Set hardware breakpoint" ) ) - .def( "getAllBp", &DebugClient::getAllBp, - "Get all breapoint IDs" ) - .def( "removeBp", &DebugClient::removeBp, - "Remove breapoint by IDs" ) - .def( "removeBp", &DebugClient::removeAllBp, - "Remove all breapoints" ) - .def( "addSynSymbol", &DebugClient::addSyntheticSymbol, - "Add new synthetic symbol for virtual address" ) - .def( "delAllSynSymbols", &DebugClient::delAllSyntheticSymbols, - "Delete all synthetic symbol for all modules") - .def( "delSynSymbol", &DebugClient::delSyntheticSymbol, - "Delete synthetic symbols by virtual address" ) - .def( "delSynSymbolsMask", &DebugClient::delSyntheticSymbolsMask, - "Delete synthetic symbols by mask of module and symbol name"); - - python::def( "addr64", &addr64, - "Extend address to 64 bits formats" ); - python::def( "breakin", &breakin, - "Break into debugger" ); - python::def( "compareMemory", &compareMemory, compareMemory_( python::args( "offset1", "offset2", "length", "phyAddr" ), - "Compare two memory buffers by virtual or physical addresses" ) ); - python::def( "createDbgClient", (DebugClientPtr(*)())&DebugClient::createDbgClient, - "create a new instance of the dbgClient class" ); - python::def( "loadDump", &loadDump, - "Load crash dump (only for console)"); - python::def( "startProcess", &startProcess, - "Start process for debugging (only for console)"); - python::def( "attachProcess", &attachProcess, - "Attach debugger to a exsisting process" ); - python::def( "attachKernel", &attachKernel, - "Attach debugger to a kernel target" ); - python::def( "detachProcess", &detachProcess, - "Detach denugger from the current process" ); - python::def( "expr", &evaluate, - "Evaluate windbg expression" ); - python::def( "findSymbol", &findSymbol, - "Find symbol by the target virtual memory offset" ); - python::def( "getCurrentProcess", &getCurrentProcess, - "Return pointer to current process's block" ); - python::def( "getCurrentStack", &getCurrentStack, - "Return a current stack as a list of stackFrame objects" ); - python::def( "getDebuggeeType", &getDebuggeeType, - "Return type of the debuggee" ); - python::def( "getImplicitThread", &getImplicitThread, - "Return implicit thread for current process" ); - python::def( "debuggerPath", &getDebuggerImage, - "Return full path to the process image that uses pykd" ); - python::def( "getExecutionStatus", &getExecutionStatus, - "Return information about the execution status of the debugger" ); - python::def( "getOffset", &getOffset, - "Return traget virtual address for specified symbol" ); - python::def( "getPdbFile", &getPdbFile, - "Return full path to PDB (Program DataBase, debug information) file" ); - python::def( "go", &changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_GO" ); - python::def( "getProcessorMode", &getProcessorMode, - "Return current processor mode as string: X86, ARM, IA64 or X64" ); - python::def( "getProcessorType", &getProcessorType, - "Return type of physical processor: X86, ARM, IA64 or X64" ); - python::def( "getThreadList", &getThreadList, - "Return list of threads (each item is numeric identifier of thread)" ); - python::def( "is64bitSystem", &is64bitSystem, - "Check if target system has 64 address space" ); - python::def( "isDumpAnalyzing", &isDumpAnalyzing, - "Check if it is a dump analyzing ( not living debuggee )" ); - python::def( "isKernelDebugging", &isKernelDebugging, - "Check if kernel dubugging is running" ); - python::def( "isWindbgExt", &WindbgGlobalSession::isInit, - "Check if script works in windbg context" ); - python::def( "isValid", &isVaValid, - "Check if the virtual address is valid" ); - python::def( "killProcess", &terminateProcess, - "Stop debugging and terminate current process" ); - python::def( "loadBytes", &loadBytes, loadBytes_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as liat of unsigned bytes" ) ); - python::def( "loadWords", &loadWords, loadWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned shorts" ) ); - python::def( "loadDWords", &loadDWords, loadDWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned long ( double word )" ) ); - python::def( "loadQWords", &loadQWords, loadQWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of unsigned long long ( quad word )" ) ); - python::def( "loadSignBytes", &loadSignBytes, loadSignBytes_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed bytes" ) ); - python::def( "loadSignWords", &loadSignWords, loadSignWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed words" ) ); - python::def( "loadSignDWords", &loadSignDWords, loadSignDWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed longs" ) ); - python::def( "loadSignQWords", &loadSignQWords, loadSignQWords_( python::args( "offset", "count", "phyAddr" ), - "Read the block of the target's memory and return it as list of signed long longs" ) ); - python::def( "loadChars", &loadChars, loadChars_( python::args( "address", "count", "phyAddr" ), - "Load string from target memory" ) ); - python::def( "loadWChars", &loadWChars, loadWChars_( python::args( "address", "count", "phyAddr" ), - "Load string from target memory" ) ); - python::def( "loadCStr", &loadCStr, - "Load string from the target buffer containing 0-terminated ansi-string" ); - python::def( "loadWStr", &loadWStr, - "Load string from the target buffer containing 0-terminated unicode-string" ); - python::def( "loadUnicodeString", &loadUnicodeStr, - "Return string represention of windows UNICODE_STRING type" ); - python::def( "loadAnsiString", &loadAnsiStr, - "Return string represention of windows ANSU_STRING type" ); - python::def( "loadPtrList", &loadPtrList, - "Return list of pointers, each points to next" ); - python::def( "loadPtrArray", &loadPtrArray, - "Read the block of the target's memory and return it as a list of pointers" ); - python::def( "ptrByte", &ptrByte, - "Read an unsigned 1-byte integer from the target memory" ); - python::def( "ptrWord", &ptrWord, - "Read an unsigned 2-byte integer from the target memory" ); - python::def( "ptrDWord", (ULONG64(*)(ULONG64))&ptrDWord, - "Read an unsigned 4-byte integer from the target memory" ); - python::def( "ptrQWord", (ULONG64(*)(ULONG64))&ptrQWord, - "Read an unsigned 8-byte integer from the target memory" ); - python::def( "ptrMWord", (ULONG64(*)(ULONG64))&ptrMWord, - "Read an unsigned mashine's word wide integer from the target memory" ); - python::def( "ptrSignByte", &ptrSignByte, - "Read an signed 1-byte integer from the target memory" ); - python::def( "ptrSignWord", &ptrSignWord, - "Read an signed 2-byte integer from the target memory" ); - python::def( "ptrSignDWord", &ptrSignDWord, - "Read an signed 4-byte integer from the target memory" ); - python::def( "ptrSignQWord", &ptrSignQWord, - "Read an signed 8-byte integer from the target memory" ); - python::def( "ptrSignMWord", &ptrSignMWord, - "Read an signed mashine's word wide integer from the target memory" ); - python::def( "ptrPtr", (ULONG64(*)(ULONG64))&ptrPtr, - "Read an pointer value from the target memory" ); - boost::python::def( "addSynSymbol", &addSyntheticSymbol, - "Add new synthetic symbol for virtual address" ); - boost::python::def( "delAllSynSymbols", &delAllSyntheticSymbols, - "Delete all synthetic symbol for all modules"); - boost::python::def( "delSynSymbol", &delSyntheticSymbol, - "Delete synthetic symbols by virtual address" ); - boost::python::def( "delSynSymbolsMask", &delSyntheticSymbolsMask, - "Delete synthetic symbols by mask of module and symbol name"); - python::def( "loadExt", &pykd::loadExtension, - "Load a debuger extension" ); - python::def( "loadModule", &loadModuleByName, - "Return instance of Module class" ); - python::def( "loadModule", &loadModuleByOffset, - "Return instance of the Module class which posseses specified address" ); - python::def( "dbgCommand", &pykd::dbgCommand, - "Run a debugger's command and return it's result as a string" ), - python::def( "dprint", &pykd::dprint, dprint_( boost::python::args( "str", "dml" ), - "Print out string. If dml = True string is printed with dml highlighting ( only for windbg )" ) ); - python::def( "dprintln", &pykd::dprintln, dprintln_( boost::python::args( "str", "dml" ), - "Print out string and insert end of line symbol. If dml = True string is printed with dml highlighting ( only for windbg )" ) ); - python::def( "ptrSize", &ptrSize, - "Return effective pointer size" ); - python::def ( "rdmsr", &DebugClient::loadMSR, - "Return MSR value" ); - python::def( "reg", &getRegByName, - "Return a CPU regsiter value by the register's name" ); - python::def( "reg", &getRegByIndex, - "Return a CPU regsiter value by the register's value" ); - python::def( "setExecutionStatus", &setExecutionStatus, - "Requests that the debugger engine enter an executable state" ); - python::def( "setCurrentProcess", &setCurrentProcess, - "Set current process by address" ); - python::def( "setImplicitThread", &setImplicitThread, - "Set implicit thread for current process" ); - python::def( "setProcessorMode", &setProcessorMode, - "Set current processor mode by string (X86, ARM, IA64 or X64)" ); - python::def( "step", &changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_STEP_OVER" ); - python::def( "symbolsPath", &dbgSymPath, - "Return symbol path" ); - python::def( "wrmsr", &setMSR, - "Set MSR value" ); - python::def( "trace", &changeDebuggerStatus, - "Change debugger status to DEBUG_STATUS_STEP_INTO" ); - python::def("typedVarList", &getTypedVarListByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ); - python::def("typedVarList", &getTypedVarListByType, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ); - python::def("typedVarArray", &getTypedVarArrayByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ); - python::def("typedVarArray", &getTypedVarArrayByType, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ); - python::def("containingRecord", &containingRecordByName, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ); - python::def("containingRecord", &containingRecordByType, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ); - python::def( "waitForEvent", &waitForEvent, - "Wait for events that breaks into the debugger" ); - python::def( "getNumberProcessors", &getNumberProcessors, - "Get the number of actual processors in the machine" ); - python::def( "getPageSize", &getPageSize, - "Get the page size for the currently executing processor context" ); - python::def( "getContext", &getThreadContext, - "Get context of current thread (register values)" ); - python::def( "getLocals", &getLocals, getLocals_( python::args( "ctx" ), - "Get list of local variables" ) ); - python::def( "setBp", &setSoftwareBp, setSoftwareBp_( python::args( "offset", "callback" ), - "Set software breakpoint on executiont" ) ); - python::def( "setBp", &setHardwareBp, setHardwareBp_( python::args( "offset", "size", "accsessType", "callback" ) , - "Set hardware breakpoint" ) ); - python::def( "getAllBp", &getAllBp, - "Get all breapoint IDs" ); - python::def( "removeBp", &removeBp, - "Remove breapoint by IDs" ); - python::def( "removeBp", &removeAllBp, - "Remove all breapoints" ); - - python::class_, boost::noncopyable >("typeInfo", "Class representing typeInfo", python::no_init ) - .def( "name", &TypeInfo::getName ) - .def( "size", &TypeInfo::getSize ) - .def( "offset", &TypeInfo::getOffset ) - .def( "bitOffset", &TypeInfo::getBitOffset ) - .def( "bitWidth", &TypeInfo::getBitWidth ) - .def( "field", &TypeInfo::getField ) - .def( "asMap", &TypeInfo::asMap ) - .def( "deref", &TypeInfo::deref ) - .def( "__str__", &TypeInfo::print ) - .def( "__getattr__", &TypeInfo::getField ); - - python::class_, boost::noncopyable >("typedVar", - "Class of non-primitive type object, child class of typeClass. Data from target is copied into object instance", python::no_init ) - .def("__init__", python::make_constructor(TypedVar::getTypedVarByName) ) - .def("__init__", python::make_constructor(TypedVar::getTypedVarByTypeName) ) - .def("__init__", python::make_constructor(TypedVar::getTypedVarByTypeInfo) ) - .def("getAddress", &TypedVar::getAddress, - "Return virtual address" ) - .def("sizeof", &TypedVar::getSize, - "Return size of a variable in the target memory" ) - .def("offset", &TypedVar::getOffset, - "Return offset to parent" ) - .def("field", &TypedVar::getField, - "Return field of structure as an object attribute" ) - .def( "dataKind", &TypedVar::getDataKind, - "Retrieves the variable classification of a data: DataIsXxx") - .def("deref", &TypedVar::deref, - "Return value by pointer" ) - .def("__getattr__", &TypedVar::getField, - "Return field of structure as an object attribute" ) - .def( "__str__", &TypedVar::print ) - .def("__len__", &TypedVar::getElementCount ) - .def("__getitem__", &TypedVar::getElementByIndex ) - .def("__getitem__", &TypedVar::getElementByIndexPtr ); - - python::class_ >("module", "Class representing executable module", python::no_init ) - .def("begin", &Module::getBase, - "Return start address of the module" ) - .def("end", &Module::getEnd, - "Return end address of the module" ) - .def("size", &Module::getSize, - "Return size of the module" ) - .def("name", &Module::getName, - "Return name of the module" ) - .def("image", &Module::getImageName, - "Return name of the image of the module" ) - .def("pdb", &Module::getPdbName, - "Return the full path to the module's pdb file ( symbol information )" ) - .def("reload", &Module::reloadSymbols, - "(Re)load symbols for the module" ) - .def("offset", &Module::getSymbol, - "Return offset of the symbol" ) - .def("rva", &Module::getSymbolRva, - "Return rva of the symbol" ) - .def("type", &Module::getTypeByName, - "Return typeInfo class by type name" ) - .def("typedVar", &Module::getTypedVarByAddr, - "Return a typedVar class instance" ) - .def("typedVar",&Module::getTypedVarByName, - "Return a typedVar class instance" ) - .def("typedVar",&Module::getTypedVarByType, - "Return a typedVar class instance" ) - .def("typedVar",&Module::getTypedVarByTypeName, - "Return a typedVar class instance" ) - .def("typedVarList", &Module::getTypedVarListByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) - .def("typedVarList", &Module::getTypedVarListByType, - "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) - .def("typedVarArray", &Module::getTypedVarArrayByTypeName, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) - .def("typedVarArray", &Module::getTypedVarArrayByType, - "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) - .def("containingRecord", &Module::containingRecordByName, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) - .def("containingRecord", &Module::containingRecordByType, - "Return instance of the typedVar class. It's value are loaded from the target memory." - "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) - .def("checksum",&Module::getCheckSumm, - "Return a image file checksum: IMAGE_OPTIONAL_HEADER.CheckSum" ) - .def("timestamp",&Module::getTimeDataStamp, - "Return a low 32 bits of the time stamp of the image: IMAGE_FILE_HEADER.TimeDateStamp" ) - .def("__getattr__", &Module::getSymbol, - "Return address of the symbol" ); - - python::class_( "dout", "dout", python::no_init ) - .def( "write", &DbgOut::write ); - - python::class_( "din", "din", python::no_init ) - .def( "readline", &DbgIn::readline ); - - python::class_("ext", python::no_init ) - .def( "call", &DbgExtension::call, - "Call debug extension command end return it's result as a string" ); - - python::class_( - "eventHandler", "Base class for overriding and handling debug notifications" ) - .def( python::init<>() ) - .def( python::init() ) - .def( "onBreakpoint", &pykd::EventHandlerWrap::onBreakpoint, - "Triggered breakpoint event. Parameter is int: ID of breakpoint\n" - "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) - .def( "onException", &pykd::EventHandlerWrap::onException, - "Exception event. Parameter is dict:\n" - "{\"Code\":int, \"Flags\":int, \"Record\":int, \"Address\":int," - " \"Parameters\":[int], \"FirstChance\":bool}\n" - "Detailed information: http://msdn.microsoft.com/en-us/library/aa363082(VS.85).aspx \n" - "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) - .def( "onLoadModule", &pykd::EventHandlerWrap::onLoadModule, - "Load module event. Parameter is instance of module.\n" - "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) - .def( "onUnloadModule", &pykd::EventHandlerWrap::onUnloadModule, - "Unload module event. Parameter is base address of unloaded module.\n" - "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ); - - python::class_("disasm", "Class disassemble a processor instructions" ) - .def( python::init<>( "constructor" ) ) - .def( python::init( boost::python::args("offset"), "constructor" ) ) - .def( "disasm", &Disasm::disassemble, "Disassemble next instruction" ) - .def( "asm", &Disasm::assembly, "Insert assemblied instuction to current offset" ) - .def( "begin", &Disasm::begin, "Return begin offset" ) - .def( "current", &Disasm::current, "Return current offset" ) - .def( "length", &Disasm::length, "Return current instruction length" ) - .def( "instruction", &Disasm::instruction, "Returm current disassembled instruction" ) - .def( "ea", &Disasm::ea, "Return effective address for last disassembled instruction or 0" ) - .def( "reset", &Disasm::reset, "Reset current offset to begin" ); - - python::class_( "stackFrame", - "Class representing a frame of the call stack", python::no_init ) - .def_readonly( "instructionOffset", &StackFrame::m_instructionOffset, - "Return a frame's instruction offset" ) - .def_readonly( "returnOffset", &StackFrame::m_returnOffset, - "Return a frame's return offset" ) - .def_readonly( "frameOffset", &StackFrame::m_frameOffset, - "Return a frame's offset" ) - .def_readonly( "stackOffset", &StackFrame::m_stackOffset, - "Return a frame's stack offset" ) - .def_readonly( "frameNumber", &StackFrame::m_frameNumber, - "Return a frame's number" ) - .def( "getLocals", &StackFrame::getLocals, StackFrame_getLocals( python::args( "ctx" ), - "Get list of local variables for this stack frame" ) ) - .def( "__str__", &StackFrame::print, - "Return stacks frame as string"); - - python::class_( - "Context", "Context of thread (register values)", python::no_init ) - .def( "ip", &ThreadContext::getIp, - "Get instruction pointer register" ) - .def( "retreg", &ThreadContext::getRetReg, - "Get primary return value register" ) - .def( "csp", &ThreadContext::getSp, - "Get current stack pointer" ) - .def( "get", &ThreadContext::getValue, - "Get register value by ID (CV_REG_XXX)" ) - .def( "processorType", &ThreadContext::getProcessorType, - "Get processor ThreadContext as string") - .def( "fork", &ThreadContext::forkByStackFrame, - "Create new thread context by stackFrame") - .def("__len__", &ThreadContext::getCount, - "Return count of registers") - .def("__getitem__", &ThreadContext::getByIndex, - "Return tuple by index"); - - python::class_ >( - "cpuReg", "CPU regsiter class", boost::python::no_init ) - .def( "name", &CpuReg::name, "The name of the regsiter" ) - .def( "index", &CpuReg::index, "The index of thr register" ); - - python::def( "diaLoadPdb", &pyDia::GlobalScope::loadPdb, - "Open pdb file for querying debug symbols. Return DiaSymbol of global scope"); - python::def( "diaLoadExe", &pyDia::GlobalScope::loadExe, pyDia_GlobalScope_loadExe( python::args( "fileName", "searchPath" ) , - "Load the debug symbols associated with the executable file. Return DiaSymbol of global scope") ); - - python::class_( - "DiaSymbol", "class wrapper for MS DIA Symbol", python::no_init ) - .def( "findEx", &pyDia::Symbol::findChildrenEx, pyDia_Symbol_findChildrenEx( python::args( "symTag", "name", "cmpFlags" ) , - "Retrieves the children of the symbol" ) ) - .def( "find", &pyDia::Symbol::findChildren, - "Retrieves the children of the symbol" ) - .def( "size", &pyDia::Symbol::getSize, - "Retrieves the number of bits or bytes of memory used by the object represented by this symbol" ) - .def( "name", &pyDia::Symbol::getName, - "Retrieves the name of the symbol" ) - .def( "undecoratedName", &pyDia::Symbol::getUndecoratedName, - "Retrieves the undecorated name for a C++ decorated, or linkage, name" ) - .def( "type", &pyDia::Symbol::getType, - "Retrieves the symbol that represents the type for this symbol" ) - .def( "indexType", &pyDia::Symbol::getIndexType, - "Retrieves a reference to the class parent of the symbol" ) - .def( "rva", &pyDia::Symbol::getRva, - "Retrieves the relative virtual address (RVA) of the location") - .def( "symTag", &pyDia::Symbol::getSymTag, - "Retrieves the symbol type classifier: SymTagXxx" ) - .def( "locType", &pyDia::Symbol::getLocType, - "Retrieves the location type of a data symbol: LocIsXxx" ) - .def( "offset", &pyDia::Symbol::getOffset, - "Retrieves the offset of the symbol location" ) - .def( "count", &pyDia::Symbol::getCount, - "Retrieves the number of items in a list or array" ) - .def( "value", (python::object(pyDia::Symbol::*)())&pyDia::Symbol::getValue, - "Retrieves the value of a constant") - .def( "isBasic", &pyDia::Symbol::isBasicType, - "Retrieves a flag of basic type for symbol") - .def( "baseType", &pyDia::Symbol::getBaseType, - "Retrieves the base type for this symbol") - .def( "bitPos", &pyDia::Symbol::getBitPosition, - "Retrieves the base type for this symbol") - .def( "indexId", &pyDia::Symbol::getIndexId, - "Retrieves the unique symbol identifier") - .def( "udtKind", &pyDia::Symbol::getUdtKind, - "Retrieves the variety of a user-defined type") - .def( "dataKind", &pyDia::Symbol::getDataKind, - "Retrieves the variable classification of a data symbol") - .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("machineType", &pyDia::Symbol::getMachineType, - "Retrieves the type of the target CPU: IMAGE_FILE_MACHINE_XXX") - .def( "__str__", &pyDia::Symbol::print) - .def("__getitem__", &pyDia::Symbol::getChildByName) - .def("__len__", &pyDia::Symbol::getChildCount ) - .def("__getitem__", &pyDia::Symbol::getChildByIndex ) - .def("__eq__", &pyDia::Symbol::eq) - .def("__hash__", &pyDia::Symbol::getIndexId); - - python::class_ >( - "DiaScope", "class wrapper for MS DIA Symbol", python::no_init ) - .def("findByRva", &pyDia::GlobalScope::findByRva, - "Find symbol by RVA. Return tuple: (DiaSymbol, offset)") - .def("symbolById", &pyDia::GlobalScope::getSymbolById, - "Retrieves a symbol by its unique identifier: DiaSymbol::indexId()"); - - // 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); - DEF_PY_CONST_ULONG(SymTagExe); - DEF_PY_CONST_ULONG(SymTagCompiland); - DEF_PY_CONST_ULONG(SymTagCompilandDetails); - DEF_PY_CONST_ULONG(SymTagCompilandEnv); - DEF_PY_CONST_ULONG(SymTagFunction); - DEF_PY_CONST_ULONG(SymTagBlock); - DEF_PY_CONST_ULONG(SymTagData); - DEF_PY_CONST_ULONG(SymTagAnnotation); - DEF_PY_CONST_ULONG(SymTagLabel); - DEF_PY_CONST_ULONG(SymTagPublicSymbol); - DEF_PY_CONST_ULONG(SymTagUDT); - DEF_PY_CONST_ULONG(SymTagEnum); - DEF_PY_CONST_ULONG(SymTagFunctionType); - DEF_PY_CONST_ULONG(SymTagPointerType); - DEF_PY_CONST_ULONG(SymTagArrayType); - DEF_PY_CONST_ULONG(SymTagBaseType); - DEF_PY_CONST_ULONG(SymTagTypedef); - DEF_PY_CONST_ULONG(SymTagBaseClass); - DEF_PY_CONST_ULONG(SymTagFriend); - DEF_PY_CONST_ULONG(SymTagFunctionArgType); - DEF_PY_CONST_ULONG(SymTagFuncDebugStart); - DEF_PY_CONST_ULONG(SymTagFuncDebugEnd); - DEF_PY_CONST_ULONG(SymTagUsingNamespace); - DEF_PY_CONST_ULONG(SymTagVTableShape); - DEF_PY_CONST_ULONG(SymTagVTable); - DEF_PY_CONST_ULONG(SymTagCustom); - DEF_PY_CONST_ULONG(SymTagThunk); - DEF_PY_CONST_ULONG(SymTagCustomType); - DEF_PY_CONST_ULONG(SymTagManagedType); - DEF_PY_CONST_ULONG(SymTagDimension); - python::scope().attr("diaSymTagName") = - genDict(pyDia::Symbol::symTagName, _countof(pyDia::Symbol::symTagName)); - - DEF_PY_CONST_ULONG(DataIsUnknown); - DEF_PY_CONST_ULONG(DataIsLocal); - DEF_PY_CONST_ULONG(DataIsStaticLocal); - DEF_PY_CONST_ULONG(DataIsParam); - DEF_PY_CONST_ULONG(DataIsObjectPtr); - DEF_PY_CONST_ULONG(DataIsFileStatic); - DEF_PY_CONST_ULONG(DataIsGlobal); - DEF_PY_CONST_ULONG(DataIsMember); - DEF_PY_CONST_ULONG(DataIsStaticMember); - DEF_PY_CONST_ULONG(DataIsConstant); - python::scope().attr("diaDataKind") = - genDict(pyDia::Symbol::dataKindName, _countof(pyDia::Symbol::dataKindName)); - - // search options for symbol and file names - DEF_PY_CONST_ULONG(nsfCaseSensitive); - DEF_PY_CONST_ULONG(nsfCaseInsensitive); - DEF_PY_CONST_ULONG(nsfFNameExt); - DEF_PY_CONST_ULONG(nsfRegularExpression); - DEF_PY_CONST_ULONG(nsfUndecoratedName); - DEF_PY_CONST_ULONG(nsCaseSensitive); - DEF_PY_CONST_ULONG(nsCaseInsensitive); - DEF_PY_CONST_ULONG(nsFNameExt); - DEF_PY_CONST_ULONG(nsRegularExpression); - DEF_PY_CONST_ULONG(nsCaseInRegularExpression); - - // location type - DEF_PY_CONST_ULONG(LocIsNull); - DEF_PY_CONST_ULONG(LocIsStatic); - DEF_PY_CONST_ULONG(LocIsTLS); - DEF_PY_CONST_ULONG(LocIsRegRel); - DEF_PY_CONST_ULONG(LocIsThisRel); - DEF_PY_CONST_ULONG(LocIsEnregistered); - DEF_PY_CONST_ULONG(LocIsBitField); - DEF_PY_CONST_ULONG(LocIsSlot); - DEF_PY_CONST_ULONG(LocIsIlRel); - DEF_PY_CONST_ULONG(LocInMetaData); - DEF_PY_CONST_ULONG(LocIsConstant); - python::scope().attr("diaLocTypeName") = - genDict(pyDia::Symbol::locTypeName, _countof(pyDia::Symbol::locTypeName)); - - DEF_PY_CONST_ULONG(btNoType); - DEF_PY_CONST_ULONG(btVoid); - DEF_PY_CONST_ULONG(btChar); - DEF_PY_CONST_ULONG(btWChar); - DEF_PY_CONST_ULONG(btInt); - DEF_PY_CONST_ULONG(btUInt); - DEF_PY_CONST_ULONG(btFloat); - DEF_PY_CONST_ULONG(btBCD); - DEF_PY_CONST_ULONG(btBool); - DEF_PY_CONST_ULONG(btLong); - DEF_PY_CONST_ULONG(btULong); - DEF_PY_CONST_ULONG(btCurrency); - DEF_PY_CONST_ULONG(btDate); - DEF_PY_CONST_ULONG(btVariant); - DEF_PY_CONST_ULONG(btComplex); - DEF_PY_CONST_ULONG(btBit); - DEF_PY_CONST_ULONG(btBSTR); - DEF_PY_CONST_ULONG(btHresult); - python::scope().attr("diaBasicType") = - genDict(pyDia::Symbol::basicTypeName, pyDia::Symbol::cntBasicTypeName); - - DEF_PY_CONST_ULONG(UdtStruct); - DEF_PY_CONST_ULONG(UdtClass); - DEF_PY_CONST_ULONG(UdtUnion); - 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: - - // wrapper for standart python exceptions - python::register_exception_translator( &PyException::exceptionTranslate ); - - - pykd::exception( "BaseException", "Pykd base exception class" ); - pykd::exception( "MemoryException", "Target memory access exception class" ); - pykd::exception( "WaitEventException", "Debug interface access exception" ); - pykd::exception( "SymbolException", "Symbol exception" ); - pykd::exception( "DiaException", "Debug interface access exception" ); - pykd::exception( "TypeException", "type exception" ); - pykd::exception( "AddSynSymbolException", "synthetic symbol exception" ); - - DEF_PY_CONST_ULONG( DEBUG_CLASS_UNINITIALIZED ); - DEF_PY_CONST_ULONG( DEBUG_CLASS_KERNEL ); - DEF_PY_CONST_ULONG( DEBUG_CLASS_USER_WINDOWS ); - - DEF_PY_CONST_ULONG( DEBUG_KERNEL_CONNECTION ); - DEF_PY_CONST_ULONG( DEBUG_KERNEL_LOCAL ); - DEF_PY_CONST_ULONG( DEBUG_KERNEL_EXDI_DRIVER ); - DEF_PY_CONST_ULONG( DEBUG_KERNEL_SMALL_DUMP ); - DEF_PY_CONST_ULONG( DEBUG_KERNEL_DUMP ); - DEF_PY_CONST_ULONG( DEBUG_KERNEL_FULL_DUMP ); - - DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_PROCESS ); - DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_PROCESS_SERVER ); - DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_SMALL_DUMP ); - DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_DUMP ); - - // exception codes - DEF_PY_CONST_ULONG(EXCEPTION_ACCESS_VIOLATION); - DEF_PY_CONST_ULONG(EXCEPTION_DATATYPE_MISALIGNMENT); - DEF_PY_CONST_ULONG(EXCEPTION_BREAKPOINT); - DEF_PY_CONST_ULONG(EXCEPTION_SINGLE_STEP); - DEF_PY_CONST_ULONG(EXCEPTION_ARRAY_BOUNDS_EXCEEDED); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_DENORMAL_OPERAND); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_DIVIDE_BY_ZERO); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_INEXACT_RESULT); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_INVALID_OPERATION); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_OVERFLOW); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_STACK_CHECK); - DEF_PY_CONST_ULONG(EXCEPTION_FLT_UNDERFLOW); - DEF_PY_CONST_ULONG(EXCEPTION_INT_DIVIDE_BY_ZERO); - DEF_PY_CONST_ULONG(EXCEPTION_INT_OVERFLOW); - DEF_PY_CONST_ULONG(EXCEPTION_PRIV_INSTRUCTION); - DEF_PY_CONST_ULONG(EXCEPTION_IN_PAGE_ERROR); - DEF_PY_CONST_ULONG(EXCEPTION_ILLEGAL_INSTRUCTION); - DEF_PY_CONST_ULONG(EXCEPTION_NONCONTINUABLE_EXCEPTION); - DEF_PY_CONST_ULONG(EXCEPTION_STACK_OVERFLOW); - DEF_PY_CONST_ULONG(EXCEPTION_INVALID_DISPOSITION); - DEF_PY_CONST_ULONG(EXCEPTION_GUARD_PAGE); - DEF_PY_CONST_ULONG(EXCEPTION_INVALID_HANDLE); - - // debug status - DEF_PY_CONST_ULONG(DEBUG_STATUS_NO_CHANGE); - DEF_PY_CONST_ULONG(DEBUG_STATUS_GO); - DEF_PY_CONST_ULONG(DEBUG_STATUS_GO_HANDLED); - DEF_PY_CONST_ULONG(DEBUG_STATUS_GO_NOT_HANDLED); - DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_OVER); - DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_INTO); - DEF_PY_CONST_ULONG(DEBUG_STATUS_BREAK); - DEF_PY_CONST_ULONG(DEBUG_STATUS_NO_DEBUGGEE); - DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_BRANCH); - DEF_PY_CONST_ULONG(DEBUG_STATUS_RESTART_REQUESTED); - DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_GO); - DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_BRANCH); - DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_OVER); - DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_INTO); - - // breakpoints constatns - DEF_PY_CONST_ULONG(DEBUG_BREAKPOINT_CODE); - DEF_PY_CONST_ULONG(DEBUG_BREAKPOINT_DATA); - - DEF_PY_CONST_ULONG(DEBUG_BREAK_READ); - DEF_PY_CONST_ULONG(DEBUG_BREAK_WRITE); - DEF_PY_CONST_ULONG(DEBUG_BREAK_EXECUTE); - DEF_PY_CONST_ULONG(DEBUG_BREAK_IO); -} - -#undef DEF_PY_CONST_ULONG +extern "C" void initpykd(); //////////////////////////////////////////////////////////////////////////////// diff --git a/pykd/pykd_2008.vcproj b/pykd/pykd_2008.vcproj index 604aa19..3e08b10 100644 --- a/pykd/pykd_2008.vcproj +++ b/pykd/pykd_2008.vcproj @@ -365,6 +365,10 @@ RelativePath=".\dbgclient.cpp" > + + @@ -429,6 +433,10 @@ RelativePath=".\pykd.def" > + + diff --git a/pykd/pymod.cpp b/pykd/pymod.cpp new file mode 100644 index 0000000..6c093db --- /dev/null +++ b/pykd/pymod.cpp @@ -0,0 +1,542 @@ +// +// Python module initialization +// + +#include "stdafx.h" + +#include + +#include "module.h" +#include "diawrapper.h" +#include "dbgclient.h" +#include "dbgio.h" +#include "dbgpath.h" +#include "dbgcmd.h" +#include "dbgevent.h" +#include "typeinfo.h" +#include "typedvar.h" +#include "dbgmem.h" +#include "intbase.h" +#include "process.h" +#include "bpoint.h" +#include "stkframe.h" +#include "pykdver.h" + +using namespace pykd; + +//////////////////////////////////////////////////////////////////////////////// + +static const std::string pykdVersion = PYKD_VERSION_BUILD_STR; + +//////////////////////////////////////////////////////////////////////////////// + +static python::dict genDict(const pyDia::Symbol::ValueNameEntry srcValues[], size_t cntValues) +{ + python::dict resDict; + for (size_t i = 0; i < cntValues; ++i) + resDict[srcValues[i].first] = srcValues[i].second; + return resDict; +} + +//////////////////////////////////////////////////////////////////////////////// + +std::string +getDebuggerImage() +{ + std::vector buffer(MAX_PATH); + GetModuleFileNameExA( GetCurrentProcess(), NULL, &buffer[0], (DWORD)buffer.size() ); + return std::string( &buffer[0] ); +} + +//////////////////////////////////////////////////////////////////////////////// + + +BOOST_PYTHON_FUNCTION_OVERLOADS( pyDia_GlobalScope_loadExe, pyDia::GlobalScope::loadExe, 1, 2 ); + +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( StackFrame_getLocals, StackFrame::getLocals, 0, 1 ); +BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS( pyDia_Symbol_findChildrenEx, pyDia::Symbol::findChildrenEx, 1, 3 ); + +#define DEF_PY_CONST_ULONG(x) \ + python::scope().attr(#x) = ULONG(##x) + +BOOST_PYTHON_MODULE( pykd ) +{ + python::scope().attr("version") = pykdVersion; + + python::def( "debuggerPath", &getDebuggerImage, + "Return full path to the process image that uses pykd" ); + + python::class_( "intBase", "intBase", python::no_init ) + .def( python::init() ) + .def( "__eq__", &intBase::eq ) + .def( "__ne__", &intBase::ne) + .def( "__lt__", &intBase::lt) + .def( "__gt__", &intBase::gt ) + .def( "__le__", &intBase::le ) + .def( "__ge__", &intBase::ge ) + .def( "__add__", &intBase::add ) + .def( "__radd__", &intBase::add ) + .def( "__sub__", &intBase::sub ) + .def( "__rsub__", &intBase::rsub ) + .def( "__mul__", &intBase::mul ) + .def( "__rmul__", &intBase::mul ) + .def( "__div__", &intBase::div ) + .def( "__rdiv__", &intBase::rdiv ) + .def( "__mod__", &intBase::mod ) + .def( "__rmod__", &intBase::rmod ) + .def( "__rshift__", &intBase::rshift ) + .def( "__rrshift__", &intBase::rrshift ) + .def( "__lshift__", &intBase::lshift ) + .def( "__rlshift__", &intBase::rlshift ) + .def( "__and__", &intBase::and ) + .def( "__rand__", &intBase::and ) + .def( "__or__", &intBase::or ) + .def( "__ror__", &intBase::or ) + .def( "__xor__", &intBase::xor ) + .def( "__rxor__", &intBase::xor ) + .def( "__neg__", &intBase::neg ) + .def( "__pos__", &intBase::pos ) + .def( "__invert__", &intBase::invert ) + .def( "__nonzero__", &intBase::nonzero ) + .def( "__str__", &intBase::str ) + .def( "__hex__", &intBase::hex ) + .def( "__long__", &intBase::long_ ) + .def( "__int__", &intBase::int_ ) + .def( "__index__", &intBase::long_ ) + .def( "__hash__", &intBase::long_ ); + + python::implicitly_convertible(); + python::implicitly_convertible(); + + initDbgClientPyExports(); + + python::class_, boost::noncopyable >("typeInfo", "Class representing typeInfo", python::no_init ) + .def( "name", &TypeInfo::getName ) + .def( "size", &TypeInfo::getSize ) + .def( "offset", &TypeInfo::getOffset ) + .def( "bitOffset", &TypeInfo::getBitOffset ) + .def( "bitWidth", &TypeInfo::getBitWidth ) + .def( "field", &TypeInfo::getField ) + .def( "asMap", &TypeInfo::asMap ) + .def( "deref", &TypeInfo::deref ) + .def( "__str__", &TypeInfo::print ) + .def( "__getattr__", &TypeInfo::getField ); + + python::class_, boost::noncopyable >("typedVar", + "Class of non-primitive type object, child class of typeClass. Data from target is copied into object instance", python::no_init ) + .def("__init__", python::make_constructor(TypedVar::getTypedVarByName) ) + .def("__init__", python::make_constructor(TypedVar::getTypedVarByTypeName) ) + .def("__init__", python::make_constructor(TypedVar::getTypedVarByTypeInfo) ) + .def("getAddress", &TypedVar::getAddress, + "Return virtual address" ) + .def("sizeof", &TypedVar::getSize, + "Return size of a variable in the target memory" ) + .def("offset", &TypedVar::getOffset, + "Return offset to parent" ) + .def("field", &TypedVar::getField, + "Return field of structure as an object attribute" ) + .def( "dataKind", &TypedVar::getDataKind, + "Retrieves the variable classification of a data: DataIsXxx") + .def("deref", &TypedVar::deref, + "Return value by pointer" ) + .def("__getattr__", &TypedVar::getField, + "Return field of structure as an object attribute" ) + .def( "__str__", &TypedVar::print ) + .def("__len__", &TypedVar::getElementCount ) + .def("__getitem__", &TypedVar::getElementByIndex ) + .def("__getitem__", &TypedVar::getElementByIndexPtr ); + + python::class_ >("module", "Class representing executable module", python::no_init ) + .def("begin", &Module::getBase, + "Return start address of the module" ) + .def("end", &Module::getEnd, + "Return end address of the module" ) + .def("size", &Module::getSize, + "Return size of the module" ) + .def("name", &Module::getName, + "Return name of the module" ) + .def("image", &Module::getImageName, + "Return name of the image of the module" ) + .def("pdb", &Module::getPdbName, + "Return the full path to the module's pdb file ( symbol information )" ) + .def("reload", &Module::reloadSymbols, + "(Re)load symbols for the module" ) + .def("offset", &Module::getSymbol, + "Return offset of the symbol" ) + .def("rva", &Module::getSymbolRva, + "Return rva of the symbol" ) + .def("type", &Module::getTypeByName, + "Return typeInfo class by type name" ) + .def("typedVar", &Module::getTypedVarByAddr, + "Return a typedVar class instance" ) + .def("typedVar",&Module::getTypedVarByName, + "Return a typedVar class instance" ) + .def("typedVar",&Module::getTypedVarByType, + "Return a typedVar class instance" ) + .def("typedVar",&Module::getTypedVarByTypeName, + "Return a typedVar class instance" ) + .def("typedVarList", &Module::getTypedVarListByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) + .def("typedVarList", &Module::getTypedVarListByType, + "Return a list of the typedVar class instances. Each item represents an item of the linked list in the target memory" ) + .def("typedVarArray", &Module::getTypedVarArrayByTypeName, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) + .def("typedVarArray", &Module::getTypedVarArrayByType, + "Return a list of the typedVar class instances. Each item represents an item of the counted array in the target memory" ) + .def("containingRecord", &Module::containingRecordByName, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) + .def("containingRecord", &Module::containingRecordByType, + "Return instance of the typedVar class. It's value are loaded from the target memory." + "The start address is calculated by the same method as the standard macro CONTAINING_RECORD does" ) + .def("checksum",&Module::getCheckSumm, + "Return a image file checksum: IMAGE_OPTIONAL_HEADER.CheckSum" ) + .def("timestamp",&Module::getTimeDataStamp, + "Return a low 32 bits of the time stamp of the image: IMAGE_FILE_HEADER.TimeDateStamp" ) + .def("__getattr__", &Module::getSymbol, + "Return address of the symbol" ); + + python::class_( "dout", "dout", python::no_init ) + .def( "write", &DbgOut::write ); + + python::class_( "din", "din", python::no_init ) + .def( "readline", &DbgIn::readline ); + + python::class_("ext", python::no_init ) + .def( "call", &DbgExtension::call, + "Call debug extension command end return it's result as a string" ); + + python::class_( + "eventHandler", "Base class for overriding and handling debug notifications" ) + .def( python::init<>() ) + .def( python::init() ) + .def( "onBreakpoint", &pykd::EventHandlerWrap::onBreakpoint, + "Triggered breakpoint event. Parameter is int: ID of breakpoint\n" + "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) + .def( "onException", &pykd::EventHandlerWrap::onException, + "Exception event. Parameter is dict:\n" + "{\"Code\":int, \"Flags\":int, \"Record\":int, \"Address\":int," + " \"Parameters\":[int], \"FirstChance\":bool}\n" + "Detailed information: http://msdn.microsoft.com/en-us/library/aa363082(VS.85).aspx \n" + "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) + .def( "onLoadModule", &pykd::EventHandlerWrap::onLoadModule, + "Load module event. Parameter is instance of module.\n" + "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ) + .def( "onUnloadModule", &pykd::EventHandlerWrap::onUnloadModule, + "Unload module event. Parameter is base address of unloaded module.\n" + "For ignore event method must return DEBUG_STATUS_NO_CHANGE value" ); + + python::class_("disasm", "Class disassemble a processor instructions" ) + .def( python::init<>( "constructor" ) ) + .def( python::init( boost::python::args("offset"), "constructor" ) ) + .def( "disasm", &Disasm::disassemble, "Disassemble next instruction" ) + .def( "asm", &Disasm::assembly, "Insert assemblied instuction to current offset" ) + .def( "begin", &Disasm::begin, "Return begin offset" ) + .def( "current", &Disasm::current, "Return current offset" ) + .def( "length", &Disasm::length, "Return current instruction length" ) + .def( "instruction", &Disasm::instruction, "Returm current disassembled instruction" ) + .def( "ea", &Disasm::ea, "Return effective address for last disassembled instruction or 0" ) + .def( "reset", &Disasm::reset, "Reset current offset to begin" ); + + python::class_( "stackFrame", + "Class representing a frame of the call stack", python::no_init ) + .def_readonly( "instructionOffset", &StackFrame::m_instructionOffset, + "Return a frame's instruction offset" ) + .def_readonly( "returnOffset", &StackFrame::m_returnOffset, + "Return a frame's return offset" ) + .def_readonly( "frameOffset", &StackFrame::m_frameOffset, + "Return a frame's offset" ) + .def_readonly( "stackOffset", &StackFrame::m_stackOffset, + "Return a frame's stack offset" ) + .def_readonly( "frameNumber", &StackFrame::m_frameNumber, + "Return a frame's number" ) + .def( "getLocals", &StackFrame::getLocals, StackFrame_getLocals( python::args( "ctx" ), + "Get list of local variables for this stack frame" ) ) + .def( "__str__", &StackFrame::print, + "Return stacks frame as string"); + + python::class_( + "Context", "Context of thread (register values)", python::no_init ) + .def( "ip", &ThreadContext::getIp, + "Get instruction pointer register" ) + .def( "retreg", &ThreadContext::getRetReg, + "Get primary return value register" ) + .def( "csp", &ThreadContext::getSp, + "Get current stack pointer" ) + .def( "get", &ThreadContext::getValue, + "Get register value by ID (CV_REG_XXX)" ) + .def( "processorType", &ThreadContext::getProcessorType, + "Get processor ThreadContext as string") + .def( "fork", &ThreadContext::forkByStackFrame, + "Create new thread context by stackFrame") + .def("__len__", &ThreadContext::getCount, + "Return count of registers") + .def("__getitem__", &ThreadContext::getByIndex, + "Return tuple by index"); + + python::class_ >( + "cpuReg", "CPU regsiter class", boost::python::no_init ) + .def( "name", &CpuReg::name, "The name of the regsiter" ) + .def( "index", &CpuReg::index, "The index of thr register" ); + + python::def( "diaLoadPdb", &pyDia::GlobalScope::loadPdb, + "Open pdb file for querying debug symbols. Return DiaSymbol of global scope"); + python::def( "diaLoadExe", &pyDia::GlobalScope::loadExe, pyDia_GlobalScope_loadExe( python::args( "fileName", "searchPath" ) , + "Load the debug symbols associated with the executable file. Return DiaSymbol of global scope") ); + + python::class_( + "DiaSymbol", "class wrapper for MS DIA Symbol", python::no_init ) + .def( "findEx", &pyDia::Symbol::findChildrenEx, pyDia_Symbol_findChildrenEx( python::args( "symTag", "name", "cmpFlags" ) , + "Retrieves the children of the symbol" ) ) + .def( "find", &pyDia::Symbol::findChildren, + "Retrieves the children of the symbol" ) + .def( "size", &pyDia::Symbol::getSize, + "Retrieves the number of bits or bytes of memory used by the object represented by this symbol" ) + .def( "name", &pyDia::Symbol::getName, + "Retrieves the name of the symbol" ) + .def( "undecoratedName", &pyDia::Symbol::getUndecoratedName, + "Retrieves the undecorated name for a C++ decorated, or linkage, name" ) + .def( "type", &pyDia::Symbol::getType, + "Retrieves the symbol that represents the type for this symbol" ) + .def( "indexType", &pyDia::Symbol::getIndexType, + "Retrieves a reference to the class parent of the symbol" ) + .def( "rva", &pyDia::Symbol::getRva, + "Retrieves the relative virtual address (RVA) of the location") + .def( "symTag", &pyDia::Symbol::getSymTag, + "Retrieves the symbol type classifier: SymTagXxx" ) + .def( "locType", &pyDia::Symbol::getLocType, + "Retrieves the location type of a data symbol: LocIsXxx" ) + .def( "offset", &pyDia::Symbol::getOffset, + "Retrieves the offset of the symbol location" ) + .def( "count", &pyDia::Symbol::getCount, + "Retrieves the number of items in a list or array" ) + .def( "value", (python::object(pyDia::Symbol::*)())&pyDia::Symbol::getValue, + "Retrieves the value of a constant") + .def( "isBasic", &pyDia::Symbol::isBasicType, + "Retrieves a flag of basic type for symbol") + .def( "baseType", &pyDia::Symbol::getBaseType, + "Retrieves the base type for this symbol") + .def( "bitPos", &pyDia::Symbol::getBitPosition, + "Retrieves the base type for this symbol") + .def( "indexId", &pyDia::Symbol::getIndexId, + "Retrieves the unique symbol identifier") + .def( "udtKind", &pyDia::Symbol::getUdtKind, + "Retrieves the variety of a user-defined type") + .def( "dataKind", &pyDia::Symbol::getDataKind, + "Retrieves the variable classification of a data symbol") + .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("machineType", &pyDia::Symbol::getMachineType, + "Retrieves the type of the target CPU: IMAGE_FILE_MACHINE_XXX") + .def( "__str__", &pyDia::Symbol::print) + .def("__getitem__", &pyDia::Symbol::getChildByName) + .def("__len__", &pyDia::Symbol::getChildCount ) + .def("__getitem__", &pyDia::Symbol::getChildByIndex ) + .def("__eq__", &pyDia::Symbol::eq) + .def("__hash__", &pyDia::Symbol::getIndexId); + + python::class_ >( + "DiaScope", "class wrapper for MS DIA Symbol", python::no_init ) + .def("findByRva", &pyDia::GlobalScope::findByRva, + "Find symbol by RVA. Return tuple: (DiaSymbol, offset)") + .def("symbolById", &pyDia::GlobalScope::getSymbolById, + "Retrieves a symbol by its unique identifier: DiaSymbol::indexId()"); + + // 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); + DEF_PY_CONST_ULONG(SymTagExe); + DEF_PY_CONST_ULONG(SymTagCompiland); + DEF_PY_CONST_ULONG(SymTagCompilandDetails); + DEF_PY_CONST_ULONG(SymTagCompilandEnv); + DEF_PY_CONST_ULONG(SymTagFunction); + DEF_PY_CONST_ULONG(SymTagBlock); + DEF_PY_CONST_ULONG(SymTagData); + DEF_PY_CONST_ULONG(SymTagAnnotation); + DEF_PY_CONST_ULONG(SymTagLabel); + DEF_PY_CONST_ULONG(SymTagPublicSymbol); + DEF_PY_CONST_ULONG(SymTagUDT); + DEF_PY_CONST_ULONG(SymTagEnum); + DEF_PY_CONST_ULONG(SymTagFunctionType); + DEF_PY_CONST_ULONG(SymTagPointerType); + DEF_PY_CONST_ULONG(SymTagArrayType); + DEF_PY_CONST_ULONG(SymTagBaseType); + DEF_PY_CONST_ULONG(SymTagTypedef); + DEF_PY_CONST_ULONG(SymTagBaseClass); + DEF_PY_CONST_ULONG(SymTagFriend); + DEF_PY_CONST_ULONG(SymTagFunctionArgType); + DEF_PY_CONST_ULONG(SymTagFuncDebugStart); + DEF_PY_CONST_ULONG(SymTagFuncDebugEnd); + DEF_PY_CONST_ULONG(SymTagUsingNamespace); + DEF_PY_CONST_ULONG(SymTagVTableShape); + DEF_PY_CONST_ULONG(SymTagVTable); + DEF_PY_CONST_ULONG(SymTagCustom); + DEF_PY_CONST_ULONG(SymTagThunk); + DEF_PY_CONST_ULONG(SymTagCustomType); + DEF_PY_CONST_ULONG(SymTagManagedType); + DEF_PY_CONST_ULONG(SymTagDimension); + python::scope().attr("diaSymTagName") = + genDict(pyDia::Symbol::symTagName, _countof(pyDia::Symbol::symTagName)); + + DEF_PY_CONST_ULONG(DataIsUnknown); + DEF_PY_CONST_ULONG(DataIsLocal); + DEF_PY_CONST_ULONG(DataIsStaticLocal); + DEF_PY_CONST_ULONG(DataIsParam); + DEF_PY_CONST_ULONG(DataIsObjectPtr); + DEF_PY_CONST_ULONG(DataIsFileStatic); + DEF_PY_CONST_ULONG(DataIsGlobal); + DEF_PY_CONST_ULONG(DataIsMember); + DEF_PY_CONST_ULONG(DataIsStaticMember); + DEF_PY_CONST_ULONG(DataIsConstant); + python::scope().attr("diaDataKind") = + genDict(pyDia::Symbol::dataKindName, _countof(pyDia::Symbol::dataKindName)); + + // search options for symbol and file names + DEF_PY_CONST_ULONG(nsfCaseSensitive); + DEF_PY_CONST_ULONG(nsfCaseInsensitive); + DEF_PY_CONST_ULONG(nsfFNameExt); + DEF_PY_CONST_ULONG(nsfRegularExpression); + DEF_PY_CONST_ULONG(nsfUndecoratedName); + DEF_PY_CONST_ULONG(nsCaseSensitive); + DEF_PY_CONST_ULONG(nsCaseInsensitive); + DEF_PY_CONST_ULONG(nsFNameExt); + DEF_PY_CONST_ULONG(nsRegularExpression); + DEF_PY_CONST_ULONG(nsCaseInRegularExpression); + + // location type + DEF_PY_CONST_ULONG(LocIsNull); + DEF_PY_CONST_ULONG(LocIsStatic); + DEF_PY_CONST_ULONG(LocIsTLS); + DEF_PY_CONST_ULONG(LocIsRegRel); + DEF_PY_CONST_ULONG(LocIsThisRel); + DEF_PY_CONST_ULONG(LocIsEnregistered); + DEF_PY_CONST_ULONG(LocIsBitField); + DEF_PY_CONST_ULONG(LocIsSlot); + DEF_PY_CONST_ULONG(LocIsIlRel); + DEF_PY_CONST_ULONG(LocInMetaData); + DEF_PY_CONST_ULONG(LocIsConstant); + python::scope().attr("diaLocTypeName") = + genDict(pyDia::Symbol::locTypeName, _countof(pyDia::Symbol::locTypeName)); + + DEF_PY_CONST_ULONG(btNoType); + DEF_PY_CONST_ULONG(btVoid); + DEF_PY_CONST_ULONG(btChar); + DEF_PY_CONST_ULONG(btWChar); + DEF_PY_CONST_ULONG(btInt); + DEF_PY_CONST_ULONG(btUInt); + DEF_PY_CONST_ULONG(btFloat); + DEF_PY_CONST_ULONG(btBCD); + DEF_PY_CONST_ULONG(btBool); + DEF_PY_CONST_ULONG(btLong); + DEF_PY_CONST_ULONG(btULong); + DEF_PY_CONST_ULONG(btCurrency); + DEF_PY_CONST_ULONG(btDate); + DEF_PY_CONST_ULONG(btVariant); + DEF_PY_CONST_ULONG(btComplex); + DEF_PY_CONST_ULONG(btBit); + DEF_PY_CONST_ULONG(btBSTR); + DEF_PY_CONST_ULONG(btHresult); + python::scope().attr("diaBasicType") = + genDict(pyDia::Symbol::basicTypeName, pyDia::Symbol::cntBasicTypeName); + + DEF_PY_CONST_ULONG(UdtStruct); + DEF_PY_CONST_ULONG(UdtClass); + DEF_PY_CONST_ULONG(UdtUnion); + 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: + + // wrapper for standart python exceptions + python::register_exception_translator( &PyException::exceptionTranslate ); + + + pykd::exception( "BaseException", "Pykd base exception class" ); + pykd::exception( "MemoryException", "Target memory access exception class" ); + pykd::exception( "WaitEventException", "Debug interface access exception" ); + pykd::exception( "SymbolException", "Symbol exception" ); + pykd::exception( "DiaException", "Debug interface access exception" ); + pykd::exception( "TypeException", "type exception" ); + pykd::exception( "AddSynSymbolException", "synthetic symbol exception" ); + + DEF_PY_CONST_ULONG( DEBUG_CLASS_UNINITIALIZED ); + DEF_PY_CONST_ULONG( DEBUG_CLASS_KERNEL ); + DEF_PY_CONST_ULONG( DEBUG_CLASS_USER_WINDOWS ); + + DEF_PY_CONST_ULONG( DEBUG_KERNEL_CONNECTION ); + DEF_PY_CONST_ULONG( DEBUG_KERNEL_LOCAL ); + DEF_PY_CONST_ULONG( DEBUG_KERNEL_EXDI_DRIVER ); + DEF_PY_CONST_ULONG( DEBUG_KERNEL_SMALL_DUMP ); + DEF_PY_CONST_ULONG( DEBUG_KERNEL_DUMP ); + DEF_PY_CONST_ULONG( DEBUG_KERNEL_FULL_DUMP ); + + DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_PROCESS ); + DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_PROCESS_SERVER ); + DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_SMALL_DUMP ); + DEF_PY_CONST_ULONG( DEBUG_USER_WINDOWS_DUMP ); + + // exception codes + DEF_PY_CONST_ULONG(EXCEPTION_ACCESS_VIOLATION); + DEF_PY_CONST_ULONG(EXCEPTION_DATATYPE_MISALIGNMENT); + DEF_PY_CONST_ULONG(EXCEPTION_BREAKPOINT); + DEF_PY_CONST_ULONG(EXCEPTION_SINGLE_STEP); + DEF_PY_CONST_ULONG(EXCEPTION_ARRAY_BOUNDS_EXCEEDED); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_DENORMAL_OPERAND); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_DIVIDE_BY_ZERO); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_INEXACT_RESULT); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_INVALID_OPERATION); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_OVERFLOW); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_STACK_CHECK); + DEF_PY_CONST_ULONG(EXCEPTION_FLT_UNDERFLOW); + DEF_PY_CONST_ULONG(EXCEPTION_INT_DIVIDE_BY_ZERO); + DEF_PY_CONST_ULONG(EXCEPTION_INT_OVERFLOW); + DEF_PY_CONST_ULONG(EXCEPTION_PRIV_INSTRUCTION); + DEF_PY_CONST_ULONG(EXCEPTION_IN_PAGE_ERROR); + DEF_PY_CONST_ULONG(EXCEPTION_ILLEGAL_INSTRUCTION); + DEF_PY_CONST_ULONG(EXCEPTION_NONCONTINUABLE_EXCEPTION); + DEF_PY_CONST_ULONG(EXCEPTION_STACK_OVERFLOW); + DEF_PY_CONST_ULONG(EXCEPTION_INVALID_DISPOSITION); + DEF_PY_CONST_ULONG(EXCEPTION_GUARD_PAGE); + DEF_PY_CONST_ULONG(EXCEPTION_INVALID_HANDLE); + + // debug status + DEF_PY_CONST_ULONG(DEBUG_STATUS_NO_CHANGE); + DEF_PY_CONST_ULONG(DEBUG_STATUS_GO); + DEF_PY_CONST_ULONG(DEBUG_STATUS_GO_HANDLED); + DEF_PY_CONST_ULONG(DEBUG_STATUS_GO_NOT_HANDLED); + DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_OVER); + DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_INTO); + DEF_PY_CONST_ULONG(DEBUG_STATUS_BREAK); + DEF_PY_CONST_ULONG(DEBUG_STATUS_NO_DEBUGGEE); + DEF_PY_CONST_ULONG(DEBUG_STATUS_STEP_BRANCH); + DEF_PY_CONST_ULONG(DEBUG_STATUS_RESTART_REQUESTED); + DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_GO); + DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_BRANCH); + DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_OVER); + DEF_PY_CONST_ULONG(DEBUG_STATUS_REVERSE_STEP_INTO); + + // breakpoints constatns + DEF_PY_CONST_ULONG(DEBUG_BREAKPOINT_CODE); + DEF_PY_CONST_ULONG(DEBUG_BREAKPOINT_DATA); + + DEF_PY_CONST_ULONG(DEBUG_BREAK_READ); + DEF_PY_CONST_ULONG(DEBUG_BREAK_WRITE); + DEF_PY_CONST_ULONG(DEBUG_BREAK_EXECUTE); + DEF_PY_CONST_ULONG(DEBUG_BREAK_IO); +} + +#undef DEF_PY_CONST_ULONG + +//////////////////////////////////////////////////////////////////////////////// \ No newline at end of file