zjgcjy/pykd
1
0
Fork 0
mirror of https://github.com/ivellioscolin/pykd.git synced 2025-04-29 11:53:23 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

[0.2.x] fixed : issue #11654 ( problem with getting export symbols )

Browse Source 
git-svn-id: https://pykd.svn.codeplex.com/svn@83096 9b283d60-5439-405e-af05-b73fd8c4d996
This commit is contained in:
SND\kernelnet_cp 2013-03-28 14:07:42 +00:00 committed by Mikhail I. Izmestev
parent 429c7fd8a9
commit e1dade0a03
9 changed files with 61 additions and 649 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
pykd/dia/diaload.cpp
View File

@ -31,7 +31,8 @@ interface IDataProvider
// Load debug symbols using DIA // Load debug symbols using DIA
static SymbolSessionPtr createSession( static SymbolSessionPtr createSession(
IDataProvider &DataProvider, IDataProvider &DataProvider,
ULONGLONG loadBase ULONGLONG loadBase,
const std::string &symbolFileName
) )
{ {
HRESULT hres; HRESULT hres;
@ -60,7 +61,7 @@ static SymbolSessionPtr createSession(
if ( S_OK != hres ) if ( S_OK != hres )
throw DiaException("Call IDiaSymbol::get_globalScope", hres); throw DiaException("Call IDiaSymbol::get_globalScope", hres);
return SymbolSessionPtr( new DiaSession( _session, _globalScope ) ); return SymbolSessionPtr( new DiaSession( _session, _globalScope, symbolFileName ) );
} }
////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////
@ -219,7 +220,7 @@ protected:
SymbolSessionPtr loadSymbolFile(const std::string &filePath, ULONGLONG loadBase ) SymbolSessionPtr loadSymbolFile(const std::string &filePath, ULONGLONG loadBase )
{ {
diaLoad::DataFromPdb dataFromPdb(filePath); diaLoad::DataFromPdb dataFromPdb(filePath);
return diaLoad::createSession(dataFromPdb, loadBase); return diaLoad::createSession(dataFromPdb, loadBase, filePath);
} }
////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////
@ -227,14 +228,13 @@ SymbolSessionPtr loadSymbolFile(const std::string &filePath, ULONGLONG loadBase
SymbolSessionPtr loadSymbolFile( SymbolSessionPtr loadSymbolFile(
__in ULONGLONG loadBase, __in ULONGLONG loadBase,
__in const std::string &executable, __in const std::string &executable,
__out std::string &loadedSymbolFile,
__in_opt std::string symbolSearchPath /*= std::string()*/ __in_opt std::string symbolSearchPath /*= std::string()*/
) )
{ {
diaLoad::DataForExeByRva dataForExeByRva(loadBase, executable, symbolSearchPath); diaLoad::DataForExeByRva dataForExeByRva(loadBase, executable, symbolSearchPath);
SymbolSessionPtr symSession = diaLoad::createSession(dataForExeByRva, loadBase); SymbolSessionPtr symSession = diaLoad::createSession(dataForExeByRva, loadBase, dataForExeByRva.m_openedSymbolFile);
loadedSymbolFile = dataForExeByRva.m_openedSymbolFile;
return symSession; return symSession;
} }

588
pykd/dia/diawrapper.cpp
View File

@ -745,591 +745,3 @@ void DiaSession::getSourceLine( ULONG64 offset, std::string &fileName, ULONG &li
}; // pykd nemaspace end }; // pykd nemaspace end
//
//#include "diawrapper.h"
//#include "diacallback.h"
//#include "utils.h"
//
//namespace pyDia {
//
//////////////////////////////////////////////////////////////////////////////////
//
////PyObject *Exception::diaExceptTypeObject = NULL;
//
//const std::string Exception::descPrefix("pyDia: ");
//
//////////////////////////////////////////////////////////////////////////////////
//
//#define callSymbol(method) \
// callSymbolT( &IDiaSymbol::##method, #method)
//
//////////////////////////////////////////////////////////////////////////////////
//
//std::string Exception::makeFullDesc(const std::string &desc, HRESULT hres)
//{
// std::stringstream sstream;
// sstream << descPrefix << desc << " failed" << std::endl;
// sstream << "Return value is 0x" << std::hex << hres;
//
// PCHAR errMessage = NULL;
// FormatMessageA(
// FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
// NULL,
// hres,
// MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
// (PCHAR)&errMessage,
// 0,
// NULL);
// if (errMessage)
// {
// sstream << ": " << std::endl;
// sstream << errMessage;
// LocalFree(errMessage);
// }
// else
// {
// sstream << std::endl;
// }
//
// return sstream.str();
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtrList Symbol::findChildrenImpl(
// ULONG symTag,
// const std::string &name,
// DWORD nameCmpFlags
//)
//{
// DiaEnumSymbolsPtr symbols;
// HRESULT hres;
//
// if ( name.empty() )
// {
// hres = m_symbol->findChildren(
// static_cast<enum SymTagEnum>(symTag),
// NULL,
// nameCmpFlags,
// &symbols);
//
// }
// else
// {
// hres = m_symbol->findChildren(
// static_cast<enum SymTagEnum>(symTag),
// toWStr(name),
// nameCmpFlags,
// &symbols);
// }
//
// if (S_OK != hres)
// throw Exception("Call IDiaSymbol::findChildren", hres);
//
// SymbolPtrList childList;
//
// DiaSymbolPtr child;
// ULONG celt;
// while ( SUCCEEDED(symbols->Next(1, &child, &celt)) && (celt == 1) )
// childList.push_back( SymbolPtr( new Symbol(child, m_machineType) ) );
//
// return childList;
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONGLONG Symbol::getSize()
//{
// return callSymbol(get_length);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//std::string Symbol::getName()
//{
// autoBstr retValue( callSymbol(get_name) );
// return retValue.asStr();
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//std::string Symbol::getUndecoratedName()
//{
// autoBstr retValue( callSymbol(get_undecoratedName) );
// return retValue.asStr();
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr Symbol::getType()
//{
// return SymbolPtr( new Symbol(callSymbol(get_type), m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr Symbol::getIndexType()
//{
// return SymbolPtr( new Symbol(callSymbol(get_arrayIndexType), m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getSymTag()
//{
// return callSymbol(get_symTag);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getRva()
//{
// return callSymbol(get_relativeVirtualAddress);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONGLONG Symbol::getVa()
//{
// return callSymbol(get_virtualAddress);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getLocType()
//{
// return callSymbol(get_locationType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//LONG Symbol::getOffset()
//{
// return callSymbol(get_offset);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getCount()
//{
// return callSymbol(get_count);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//int Symbol::getVirtualBasePointerOffset()
//{
// return callSymbol(get_virtualBasePointerOffset);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getVirtualBaseDispIndex()
//{
// return callSymbol(get_virtualBaseDispIndex);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getVirtualBaseDispSize()
//{
// SymbolPtr baseTableType = SymbolPtr( new Symbol( callSymbol(get_virtualBaseTableType), m_machineType ) );
//
// return (ULONG)baseTableType->getType()->getSize();
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getSection()
//{
// return callSymbol(get_targetSection);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//void Symbol::getValueImpl(IDiaSymbol *_symbol, VARIANT &vtValue)
//{
// HRESULT hres = _symbol->get_value(&vtValue);
// if (S_OK != hres)
// throw Exception("Call IDiaSymbol::get_value", hres);
//}
//
//void Symbol::getValue( VARIANT &vtValue)
//{
// HRESULT hres = m_symbol->get_value(&vtValue);
// if (S_OK != hres)
// throw Exception("Call IDiaSymbol::get_value", hres);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//python::object Symbol::getValue()
//{
// VARIANT vtValue = { VT_EMPTY };
// getValueImpl(m_symbol, vtValue);
// switch (vtValue.vt)
// {
// case VT_I1:
// case VT_UI1:
// return python::object( static_cast<ULONG>(vtValue.bVal) );
//
// case VT_BOOL:
// return python::object( static_cast<bool>(!!vtValue.iVal) );
//
// case VT_I2:
// case VT_UI2:
// return python::object( static_cast<ULONG>(vtValue.iVal) );
//
// case VT_I4:
// case VT_UI4:
// case VT_INT:
// case VT_UINT:
// case VT_ERROR:
// case VT_HRESULT:
// return python::object( vtValue.lVal );
//
// case VT_I8:
// case VT_UI8:
// return python::object( vtValue.llVal );
//
// case VT_R4:
// return python::object( double(vtValue.fltVal) );
//
// case VT_R8:
// return python::object( vtValue.dblVal );
//
// case VT_BSTR:
// return python::object( autoBstr::asStr(vtValue.bstrVal).c_str() );
//
// }
// throw Exception("Unknown value type");
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//bool Symbol::isBasicType()
//{
// DWORD baseType = btNoType;
// return
// SUCCEEDED( m_symbol->get_baseType(&baseType) ) &&
// (btNoType != baseType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//bool Symbol::isVirtualBaseClass()
//{
// return !!callSymbol(get_virtualBaseClass);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//bool Symbol::isIndirectVirtualBaseClass()
//{
// return !!callSymbol(get_indirectVirtualBaseClass);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getBaseType()
//{
// return callSymbol(get_baseType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getBitPosition()
//{
// return callSymbol(get_bitPosition);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getIndexId()
//{
// return callSymbol(get_symIndexId);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getUdtKind()
//{
// return callSymbol(get_udtKind);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getDataKind()
//{
// return callSymbol(get_dataKind);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONG Symbol::getRegisterId()
//{
// return callSymbol(get_registerId);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//bool Symbol::isConstant()
//{
// return !!callSymbol(get_constType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr Symbol::getChildByName(const std::string &_name)
//{
// DiaEnumSymbolsPtr symbols;
// HRESULT hres =
// m_symbol->findChildren(
// SymTagNull,
// toWStr(_name),
// nsCaseSensitive,
// &symbols);
// if (S_OK != hres)
// throw Exception("Call IDiaSymbol::findChildren", hres);
//
// LONG count;
// hres = symbols->get_Count(&count);
// if (S_OK != hres)
// throw Exception("Call IDiaEnumSymbols::get_Count", hres);
//
// if (!count)
// throw Exception(_name + " not found");
//
// if (count != 1)
// throw Exception(_name + " is not unique");
//
// DiaSymbolPtr child;
// hres = symbols->Item(0, &child);
// if (S_OK != hres)
// throw Exception("Call IDiaEnumSymbols::Item", hres);
//
// return SymbolPtr( new Symbol(child, m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//std::string Symbol::print()
//{
// return printImpl(m_symbol, m_machineType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//bool Symbol::eq(Symbol &rhs)
//{
// return getIndexId() == rhs.getIndexId();
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//GlobalScope::GlobalScope(
// __inout DiaDataSourcePtr &dataSource,
// __inout DiaSessionPtr &_session,
// __inout DiaSymbolPtr &_globalScope
//) : Symbol(_globalScope, CV_CFL_80386)
// , m_dataSource( dataSource.Detach() )
// , m_session( _session.Detach() )
//{
// m_symbol->get_machineType(&m_machineType);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//GlobalScopePtr GlobalScope::loadPdb(const std::string &filePath)
//{
// class CLoaderFromPdb : public IScopeDataLoader {
// public:
// CLoaderFromPdb(const std::string &filePath) : m_filePath(filePath) {}
//
// virtual void loadData(IDiaDataSource *dataSource) override {
// HRESULT hres = dataSource->loadDataFromPdb( toWStr(m_filePath) );
// if ( S_OK != hres )
// throw Exception("Call IDiaDataSource::loadDataFromPdb", hres);
// }
//
// private:
// const std::string &m_filePath;
// } loaderFromPdb(filePath);
//
// return loadImpl(loaderFromPdb);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//GlobalScopePtr GlobalScope::loadExe(const std::string &filePath, PCSTR searchPath /*= NULL*/)
//{
// if (!searchPath)
// searchPath = "SRV**\\\\symbols\\symbols";
//
// class CLoaderForExe : public IScopeDataLoader {
// public:
// CLoaderForExe(const std::string &filePath, PCSTR searchPath)
// : m_filePath(filePath), m_searchPath(searchPath)
// {
// }
//
// virtual void loadData(IDiaDataSource *dataSource) override {
// LoadCallback loadCallback;
// HRESULT hres =
// dataSource->loadDataForExe( toWStr(m_filePath), toWStr(m_searchPath), &loadCallback );
// if ( S_OK != hres )
// throw Exception("Call IDiaDataSource::loadDataForExe", hres);
// }
//
// private:
// const std::string &m_filePath;
// const std::string m_searchPath;
// } loaderForExe(filePath, searchPath);
//
// return loadImpl(loaderForExe);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//GlobalScopePtr GlobalScope::loadImpl(IScopeDataLoader &ScopeDataLoader)
//{
// DiaDataSourcePtr dataSource;
//
// HRESULT hres =
// dataSource.CoCreateInstance(__uuidof(DiaSource), NULL, CLSCTX_INPROC_SERVER);
// if ( S_OK != hres )
// throw Exception("Call ::CoCreateInstance", hres);
//
// ScopeDataLoader.loadData(dataSource);
//
// DiaSessionPtr _session;
// hres = dataSource->openSession(&_session);
// if ( S_OK != hres )
// throw Exception("Call IDiaDataSource::openSession", hres);
//
// DiaSymbolPtr _globalScope;
// hres = _session->get_globalScope(&_globalScope);
// if ( S_OK != hres )
// throw Exception("Call IDiaSymbol::get_globalScope", hres);
//
// return GlobalScopePtr( new GlobalScope(dataSource, _session, _globalScope) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr GlobalScope::findByRvaImpl(
// __in ULONG rva,
// __in ULONG symTag,
// __out LONG &displacement
//)
//{
// DiaSymbolPtr child;
// HRESULT hres =
// m_session->findSymbolByRVAEx(
// rva,
// static_cast<enum SymTagEnum>(symTag),
// &child,
// &displacement);
// if (S_OK != hres)
// throw Exception("Call IDiaSession::findSymbolByRVAEx", hres);
// if (!child)
// throw Exception("Call IDiaSession::findSymbolByRVAEx", E_UNEXPECTED);
//
// return SymbolPtr( new Symbol(child, m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr GlobalScope::findByVaImpl(
// __in ULONGLONG va,
// __in ULONG symTag,
// __out LONG &displacement
//)
//{
// DiaSymbolPtr child;
// HRESULT hres =
// m_session->findSymbolByVAEx(
// va,
// static_cast<enum SymTagEnum>(symTag),
// &child,
// &displacement);
// if (S_OK != hres)
// throw Exception("Call IDiaSession::findSymbolByVAEx", hres);
// if (!child)
// throw Exception("Call IDiaSession::findSymbolByVAEx", E_UNEXPECTED);
//
// return SymbolPtr( new Symbol(child, m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//SymbolPtr GlobalScope::getSymbolById(ULONG symId)
//{
// DiaSymbolPtr _symbol;
// HRESULT hres = m_session->symbolById(symId, &_symbol);
// if (S_OK != hres)
// throw Exception("Call IDiaSession::findSymbolByRVAEx", hres);
// if (!_symbol)
// throw Exception("Call IDiaSession::findSymbolByRVAEx", E_UNEXPECTED);
//
// return SymbolPtr( new Symbol(_symbol, m_machineType) );
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//ULONGLONG GlobalScope::getLoadAddress()
//{
// ULONGLONG loadAddress;
// HRESULT hres = m_session->get_loadAddress(&loadAddress);
// if (S_OK != hres)
// throw Exception("Call IDiaSession::get_loadAddress", hres);
// return loadAddress;
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//void GlobalScope::setLoadAddress(ULONGLONG loadAddress)
//{
// HRESULT hres = m_session->put_loadAddress(loadAddress);
// if (S_OK != hres)
// throw Exception("Call IDiaSession::put_loadAddress", hres);
//}
//
//////////////////////////////////////////////////////////////////////////////////
//
//}

18
pykd/dia/diawrapper.h
View File

@ -222,27 +222,33 @@ class DiaSession : public SymbolSession
{ {
public: public:
DiaSession( IDiaSession* session, IDiaSymbol *globalScope ) : DiaSession( IDiaSession* session, IDiaSymbol *globalScope, const std::string symbolFile ) :
m_globalScope( globalScope ), m_globalScope( globalScope ),
m_globalSymbol( DiaSymbol::fromGlobalScope( globalScope ) ), m_globalSymbol( DiaSymbol::fromGlobalScope( globalScope ) ),
m_session( session ) m_session( session ),
m_symbolFileName( symbolFile )
{} {}
SymbolPtr getSymbolScope() { virtual SymbolPtr getSymbolScope() {
return m_globalSymbol; return m_globalSymbol;
} }
SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL ); virtual SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL );
ULONG findRvaByName( const std::string &name ); virtual void getSourceLine( ULONG64 offset, std::string &fileName, ULONG &lineNo, LONG &displacement );
void getSourceLine( ULONG64 offset, std::string &fileName, ULONG &lineNo, LONG &displacement ); virtual std::string getSymbolFileName() {
return m_symbolFileName;
}
private: private:
ULONG findRvaByName( const std::string &name );
DiaSymbolPtr m_globalScope; DiaSymbolPtr m_globalScope;
SymbolPtr m_globalSymbol; SymbolPtr m_globalSymbol;
DiaSessionPtr m_session; DiaSessionPtr m_session;
std::string m_symbolFileName;
}; };

8
pykd/dia/symexport.cpp
View File

@ -420,11 +420,11 @@ public:
m_exportDir = ExportSymbolDir::getExportSymbolDir(moduleBase); m_exportDir = ExportSymbolDir::getExportSymbolDir(moduleBase);
} }
SymbolPtr getSymbolScope() { virtual SymbolPtr getSymbolScope() {
return SymbolPtr( m_exportDir ); return SymbolPtr( m_exportDir );
} }
SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL ) { virtual SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL ) {
return m_exportDir->findByRva( rva, symTag, displacement ); return m_exportDir->findByRva( rva, symTag, displacement );
} }
@ -433,6 +433,10 @@ public:
throw SymbolException( "there is no source file" ); throw SymbolException( "there is no source file" );
} }
virtual std::string getSymbolFileName() {
return std::string("export symbols");
}
private: private:
ULONGLONG m_moduleBase; ULONGLONG m_moduleBase;

58
pykd/module.cpp
View File

@ -68,51 +68,46 @@ SymbolSessionPtr& Module::getSymSession()
try try
{ {
m_symSession = loadSymbolFile( m_base, m_imageName, m_symfile); m_symSession = loadSymbolFile( m_base, m_imageName);
if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
}
} }
catch(const SymbolException &) catch(const SymbolException &)
{ {}
}
if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
}
// TODO: read image file path and load using IDiaReadExeAtOffsetCallback // TODO: read image file path and load using IDiaReadExeAtOffsetCallback
try try
{ {
m_symfile = getModuleSymbolFileName(m_base); std::string symfile = getModuleSymbolFileName(m_base);
if (!m_symfile.empty() ) if (!symfile.empty() )
{ {
m_symSession = loadSymbolFile(m_symfile, m_base); m_symSession = loadSymbolFile(symfile, m_base);
}
if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
} }
} }
catch(const DbgException&) catch(const DbgException&)
{ {}
}
if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
}
try try
{ {
m_symSession = loadSymbolFromExports(m_base); m_symSession = loadSymbolFromExports(m_base);
m_symfile = "export symbols"; if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
}
} }
catch(const DbgException&) catch(const DbgException&)
{ {}
}
if (m_symSession)
{
m_symSessionCache.insert( std::make_pair( cacheKey, m_symSession ) );
return m_symSession;
}
m_symSessionCache.insert( std::make_pair( cacheKey, SymbolSessionPtr() ) ); m_symSessionCache.insert( std::make_pair( cacheKey, SymbolSessionPtr() ) );
@ -189,7 +184,12 @@ std::string Module::print()
sstr << "Module: " << m_name << std::endl; sstr << "Module: " << m_name << std::endl;
sstr << "Start: " << std::hex << m_base << " End: " << getEnd() << " Size: " << m_size << std::endl; sstr << "Start: " << std::hex << m_base << " End: " << getEnd() << " Size: " << m_size << std::endl;
sstr << "Image: " << m_imageName << std::endl; sstr << "Image: " << m_imageName << std::endl;
sstr << "Symbols: " << m_symfile << std::endl; if ( m_symSession )
sstr << "Symbols: " << m_symSession->getSymbolFileName() << std::endl;
else
sstr << "Symbols: not found" << std::endl;
sstr << "Timestamp: " << m_timeDataStamp << std::endl; sstr << "Timestamp: " << m_timeDataStamp << std::endl;
sstr << "Check Sum: " << m_checkSum << std::endl; sstr << "Check Sum: " << m_checkSum << std::endl;

6
pykd/module.h
View File

@ -82,7 +82,10 @@ public:
std::string getSymFile() { std::string getSymFile() {
prepareSymbolFile(); prepareSymbolFile();
return m_symfile; //return m_symfile;
if (m_symSession)
return m_symSession->getSymbolFileName();
return "";
} }
std::string getImageName() const { std::string getImageName() const {
@ -167,7 +170,6 @@ private:
std::string m_name; std::string m_name;
std::string m_imageName; std::string m_imageName;
std::string m_symfile;
ULONG64 m_base; ULONG64 m_base;
ULONG m_size; ULONG m_size;
ULONG m_timeDataStamp; ULONG m_timeDataStamp;

2
pykd/pykdver.h
View File

@ -2,7 +2,7 @@
#define PYKD_VERSION_MAJOR 0 #define PYKD_VERSION_MAJOR 0
#define PYKD_VERSION_MINOR 2 #define PYKD_VERSION_MINOR 2
#define PYKD_VERSION_SUBVERSION 0 #define PYKD_VERSION_SUBVERSION 0
#define PYKD_VERSION_BUILDNO 18 #define PYKD_VERSION_BUILDNO 19
#define __VER_STR2__(x) #x #define __VER_STR2__(x) #x

4
pykd/symengine.h
View File

@ -166,6 +166,8 @@ public:
virtual SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL ) = 0; virtual SymbolPtr findByRva( ULONG rva, ULONG symTag = SymTagNull, LONG* displacement = NULL ) = 0;
virtual void getSourceLine( ULONG64 offset, std::string &fileName, ULONG &lineNo, LONG &displacement ) = 0; virtual void getSourceLine( ULONG64 offset, std::string &fileName, ULONG &lineNo, LONG &displacement ) = 0;
virtual std::string getSymbolFileName() = 0;
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -177,7 +179,7 @@ SymbolSessionPtr loadSymbolFile(const std::string &filePath, ULONGLONG loadBase
SymbolSessionPtr loadSymbolFile( SymbolSessionPtr loadSymbolFile(
__in ULONGLONG loadBase, __in ULONGLONG loadBase,
__in const std::string &executable, __in const std::string &executable,
__out std::string &loadedSymbolFile, //__out std::string &loadedSymbolFile,
__in_opt std::string symbolSearchPath = std::string() __in_opt std::string symbolSearchPath = std::string()
); );

14
pykd/win/dbgeng.h
View File

@ -85,20 +85,6 @@ public:
__in ULONG64 Argument ); __in ULONG64 Argument );
DbgEngBind* operator->(); DbgEngBind* operator->();
//{
// if ( m_bind.get() != NULL )
// return m_bind.get();
// CComPtr<IDebugClient4> client = NULL;
// HRESULT hres = DebugCreate( __uuidof(IDebugClient4), (void **)&client );
// if ( FAILED( hres ) )
// throw DbgException("DebugCreate failed");
// m_bind.reset(new DbgEngBind(client, this) );
// return m_bind.get();
//}
void registerCallbacks( const DEBUG_EVENT_CALLBACK *callbacks ); void registerCallbacks( const DEBUG_EVENT_CALLBACK *callbacks );
void removeCallbacks( const DEBUG_EVENT_CALLBACK *callbacks ); void removeCallbacks( const DEBUG_EVENT_CALLBACK *callbacks );