int CMiniDumpReader::ReadModuleListStream()
{
LPVOID pStreamStart = NULL;
ULONG uStreamSize = 0;
MINIDUMP_DIRECTORY* pmd = NULL;
BOOL bRead = FALSE;
strconv_t strconv;
bRead = MiniDumpReadDumpStream(
m_pMiniDumpStartPtr,
ModuleListStream,
&pmd,
&pStreamStart,
&uStreamSize);
if(bRead)
{
MINIDUMP_MODULE_LIST* pModuleStream = (MINIDUMP_MODULE_LIST*)pStreamStart;
if(pModuleStream!=NULL)
{
ULONG32 uNumberOfModules = pModuleStream->NumberOfModules;
ULONG32 i;
for(i=0; i<uNumberOfModules; i++)
{
MINIDUMP_MODULE* pModule =
(MINIDUMP_MODULE*)((LPBYTE)pModuleStream->Modules+i*sizeof(MINIDUMP_MODULE));
CString sModuleName = GetMinidumpString(m_pMiniDumpStartPtr, pModule->ModuleNameRva);
LPCWSTR szModuleName = strconv.t2w(sModuleName);
DWORD64 dwBaseAddr = pModule->BaseOfImage;
DWORD64 dwImageSize = pModule->SizeOfImage;
CString sShortModuleName = sModuleName;
int pos = -1;
pos = sModuleName.ReverseFind('\\');
if(pos>=0)
sShortModuleName = sShortModuleName.Mid(pos+1);
/*DWORD64 dwLoadResult = */SymLoadModuleExW(
m_DumpData.m_hProcess,
NULL,
(PWSTR)szModuleName,
NULL,
dwBaseAddr,
(DWORD)dwImageSize,
NULL,
0);
IMAGEHLP_MODULE64 modinfo;
memset(&modinfo, 0, sizeof(IMAGEHLP_MODULE64));
modinfo.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
BOOL bModuleInfo = SymGetModuleInfo64(m_DumpData.m_hProcess,
dwBaseAddr,
&modinfo);
MdmpModule m;
if(!bModuleInfo)
{
m.m_bImageUnmatched = TRUE;
m.m_bNoSymbolInfo = TRUE;
m.m_bPdbUnmatched = TRUE;
m.m_pVersionInfo = NULL;
m.m_sImageName = sModuleName;
m.m_sModuleName = sShortModuleName;
m.m_uBaseAddr = dwBaseAddr;
m.m_uImageSize = dwImageSize;
}
else
{
m.m_uBaseAddr = modinfo.BaseOfImage;
m.m_uImageSize = modinfo.ImageSize;
m.m_sModuleName = sShortModuleName;
m.m_sImageName = modinfo.ImageName;
m.m_sLoadedImageName = modinfo.LoadedImageName;
m.m_sLoadedPdbName = modinfo.LoadedPdbName;
m.m_pVersionInfo = &pModule->VersionInfo;
m.m_bPdbUnmatched = modinfo.PdbUnmatched;
BOOL bTimeStampMatched = pModule->TimeDateStamp == modinfo.TimeDateStamp;
m.m_bImageUnmatched = !bTimeStampMatched;
m.m_bNoSymbolInfo = !modinfo.GlobalSymbols;
}
m_DumpData.m_Modules.push_back(m);
m_DumpData.m_ModuleIndex[m.m_uBaseAddr] = m_DumpData.m_Modules.size()-1;
CString sMsg;
if(m.m_bImageUnmatched)
sMsg.Format(_T("Loaded '*%s'"), sModuleName);
else
sMsg.Format(_T("Loaded '%s'"), m.m_sLoadedImageName);
if(m.m_bImageUnmatched)
sMsg += _T(", No matching binary found.");
else if(m.m_bPdbUnmatched)
sMsg += _T(", No matching PDB file found.");
else
{
if(m.m_bNoSymbolInfo)
sMsg += _T(", No symbols loaded.");
else
sMsg += _T(", Symbols loaded.");
}
m_DumpData.m_LoadLog.push_back(sMsg);
}
}
}
else
{
return 1;
}
return 0;
}
/***********************************************************************
* SymLoadModuleEx (DBGHELP.@)
*/
DWORD64 WINAPI SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
PCSTR ModuleName, DWORD64 BaseOfDll, DWORD DllSize,
PMODLOAD_DATA Data, DWORD Flags)
{
PWSTR wImageName, wModuleName;
unsigned len;
DWORD64 ret;
TRACE("(%p %p %s %s %s %08x %p %08x)\n",
hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
if (ImageName)
{
len = MultiByteToWideChar(CP_ACP, 0, ImageName, -1, NULL, 0);
wImageName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, ImageName, -1, wImageName, len);
}
else wImageName = NULL;
if (ModuleName)
{
len = MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, NULL, 0);
wModuleName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, ModuleName, -1, wModuleName, len);
}
else wModuleName = NULL;
ret = SymLoadModuleExW(hProcess, hFile, wImageName, wModuleName,
BaseOfDll, DllSize, Data, Flags);
HeapFree(GetProcessHeap(), 0, wImageName);
HeapFree(GetProcessHeap(), 0, wModuleName);
return ret;
}
DWORD64 WINAPI
MgwSymLoadModuleExW(HANDLE hProcess,
HANDLE hFile,
PCWSTR ImageName,
PCWSTR ModuleName,
DWORD64 BaseOfDll,
DWORD DllSize,
PMODLOAD_DATA Data,
DWORD Flags)
{
DWORD dwRet;
dwRet = SymLoadModuleExW(hProcess, hFile, ImageName, ModuleName, BaseOfDll, DllSize, Data, Flags);
if (BaseOfDll) {
char ImageNameBuf[MAX_PATH];
PCSTR ImageNameA;
if (ImageName) {
WideCharToMultiByte(CP_ACP, 0, ImageName, -1, ImageNameBuf, _countof(ImageNameBuf), NULL, NULL);
ImageNameA = ImageNameBuf;
} else {
ImageNameA = NULL;
}
mgwhelp_module_lookup(hProcess, hFile, ImageNameA, BaseOfDll);
}
return dwRet;
}
void InitializeSymbolLookup()
{
static bool bIsInitialized = false;
if( bIsInitialized )
{
return;
}
bIsInitialized = true;
hApplicationProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, ApplicationProcessId);
if( hApplicationProcess == NULL )
{
DWORD error = GetLastError();
DebugLog("OpenProcess failed: error = %d", error);
return;
}
DWORD SymOpts = 0;
SymOpts |= SYMOPT_ALLOW_ABSOLUTE_SYMBOLS;
// SymOpts |= SYMOPT_CASE_INSENSITIVE;
SymOpts |= SYMOPT_DEBUG;
SymOpts |= SYMOPT_DEFERRED_LOADS;
SymOpts |= SYMOPT_EXACT_SYMBOLS;
SymOpts |= SYMOPT_FAIL_CRITICAL_ERRORS;
SymOpts |= SYMOPT_LOAD_LINES;
SymOpts |= SYMOPT_UNDNAME;
SymSetOptions(SymOpts);
if( !SymInitialize(hApplicationProcess, NULL, TRUE) ) // defer the loading of process modules
{
DWORD error = GetLastError();
DebugLog("SymInitialize failed: error = %d", error);
return;
}
LoadModules();
DWORD FileSize = 0;
DWORD64 dwBaseAddress = 0;
DWORD64 result = SymLoadModuleExW(hApplicationProcess, NULL, app_filename, NULL, dwBaseAddress, FileSize, NULL, 0);
if( result == 0 )
{
DWORD error = GetLastError();
DebugLog("SymLoadModuleEx failed: error = %d", error);
SymUnloadModule64(hApplicationProcess, dwBaseAddress);
return;
}
}
BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size)
{
BOOL ret = SymLoadModuleExW(hProc, NULL, name, NULL, base, size, NULL, 0);
if (ret)
{
IMAGEHLP_MODULEW64 ihm;
ihm.SizeOfStruct = sizeof(ihm);
if (SymGetModuleInfoW64(hProc, base, &ihm) && (ihm.PdbUnmatched || ihm.DbgUnmatched))
dbg_printf("Loaded unmatched debug information for %s\n", wine_dbgstr_w(name));
}
return ret;
}
/**
* Loads modules for current process.
*/
static void LoadProcessModules(const FString &RemoteStorage)
{
int32 ErrorCode = 0;
HANDLE ProcessHandle = GetCurrentProcess();
// Enumerate process modules.
HMODULE* ModuleHandlePointer = GetProcessModules(ProcessHandle);
if (!ModuleHandlePointer)
{
ErrorCode = GetLastError();
return;
}
// Load the modules.
for( int32 ModuleIndex = 0; ModuleHandlePointer[ModuleIndex]; ModuleIndex++ )
{
MODULEINFO ModuleInfo = {0};
#if WINVER > 0x502
WCHAR ModuleName[FProgramCounterSymbolInfo::MAX_NAME_LENGHT] = {0};
WCHAR ImageName[FProgramCounterSymbolInfo::MAX_NAME_LENGHT] = {0};
#else
ANSICHAR ModuleName[FProgramCounterSymbolInfo::MAX_NAME_LENGHT] = { 0 };
ANSICHAR ImageName[FProgramCounterSymbolInfo::MAX_NAME_LENGHT] = { 0 };
#endif
#if PLATFORM_64BITS
static_assert(sizeof( MODULEINFO ) == 24, "Broken alignment for 64bit Windows include.");
#else
static_assert(sizeof( MODULEINFO ) == 12, "Broken alignment for 32bit Windows include.");
#endif
FGetModuleInformation( ProcessHandle, ModuleHandlePointer[ModuleIndex], &ModuleInfo, sizeof( ModuleInfo ) );
FGetModuleFileNameEx( ProcessHandle, ModuleHandlePointer[ModuleIndex], ImageName, FProgramCounterSymbolInfo::MAX_NAME_LENGHT );
FGetModuleBaseName( ProcessHandle, ModuleHandlePointer[ModuleIndex], ModuleName, FProgramCounterSymbolInfo::MAX_NAME_LENGHT );
// Set the search path to find PDBs in the same folder as the DLL.
#if WINVER > 0x502
WCHAR SearchPath[MAX_PATH] = {0};
WCHAR* FileName = NULL;
const auto Result = GetFullPathNameW( ImageName, MAX_PATH, SearchPath, &FileName );
#else
ANSICHAR SearchPath[MAX_PATH] = { 0 };
ANSICHAR* FileName = NULL;
const auto Result = GetFullPathNameA( ImageName, MAX_PATH, SearchPath, &FileName );
#endif
FString SearchPathList;
if (Result != 0 && Result < MAX_PATH)
{
*FileName = 0;
#if WINVER > 0x502
SearchPathList = SearchPath;
#else
SearchPathList = ANSI_TO_TCHAR(SearchPath);
#endif
}
if (!RemoteStorage.IsEmpty())
{
if (!SearchPathList.IsEmpty())
{
SearchPathList.AppendChar(';');
}
SearchPathList.Append(RemoteStorage);
}
#if WINVER > 0x502
SymSetSearchPathW(ProcessHandle, *SearchPathList);
// Load module.
const DWORD64 BaseAddress = SymLoadModuleExW( ProcessHandle, ModuleHandlePointer[ModuleIndex], ImageName, ModuleName, (DWORD64) ModuleInfo.lpBaseOfDll, (uint32) ModuleInfo.SizeOfImage, NULL, 0 );
if( !BaseAddress )
{
ErrorCode = GetLastError();
UE_LOG(LogWindows, Warning, TEXT("SymLoadModuleExW. Error: %d"), GetLastError());
}
#else
SymSetSearchPath(ProcessHandle, TCHAR_TO_ANSI(*SearchPathList));
// Load module.
const DWORD64 BaseAddress = SymLoadModuleEx( ProcessHandle, ModuleHandlePointer[ModuleIndex], ImageName, ModuleName, (DWORD64)ModuleInfo.lpBaseOfDll, (uint32)ModuleInfo.SizeOfImage, NULL, 0 );
if (!BaseAddress)
{
ErrorCode = GetLastError();
UE_LOG(LogWindows, Warning, TEXT("SymLoadModuleEx. Error: %d"), GetLastError());
}
#endif
}
// Free the module handle pointer allocated in case the static array was insufficient.
FMemory::Free(ModuleHandlePointer);
}
