diff --git a/upstream_utils/stack_walker_patches/0001-Apply-PR-35.patch b/upstream_utils/stack_walker_patches/0001-Apply-PR-35.patch new file mode 100644 index 0000000000..6220486c5f --- /dev/null +++ b/upstream_utils/stack_walker_patches/0001-Apply-PR-35.patch @@ -0,0 +1,1356 @@ +From 6e2f70b7bb7c59fe99b7469bf3e3a257876403dc Mon Sep 17 00:00:00 2001 +From: PJ Reiniger +Date: Sun, 22 May 2022 23:58:57 -0400 +Subject: [PATCH 1/3] Apply PR #35 + +--- + .gitignore | 9 + + Main/StackWalker/StackWalker.cpp | 642 ++++++++++-------------- + Main/StackWalker/StackWalker.h | 40 +- + Main/StackWalker/StackWalker_VC2017.sln | 16 +- + Main/StackWalker/main.cpp | 2 +- + 5 files changed, 306 insertions(+), 403 deletions(-) + create mode 100644 .gitignore + +diff --git a/.gitignore b/.gitignore +new file mode 100644 +index 0000000..5d102c5 +--- /dev/null ++++ b/.gitignore +@@ -0,0 +1,9 @@ ++################################################################################ ++# This .gitignore file was automatically created by Microsoft(R) Visual Studio. ++################################################################################ ++ ++*.suo ++*.db ++*.sqlite ++/Main/StackWalker/_ReSharper.Caches/* ++/.vs/* +diff --git a/Main/StackWalker/StackWalker.cpp b/Main/StackWalker/StackWalker.cpp +index 7008ac6..48c7c57 100644 +--- a/Main/StackWalker/StackWalker.cpp ++++ b/Main/StackWalker/StackWalker.cpp +@@ -1,4 +1,4 @@ +-/********************************************************************** ++/********************************************************************** + * + * StackWalker.cpp + * https://github.com/JochenKalmbach/StackWalker +@@ -87,162 +87,36 @@ + #include + #include + #include +-#include + #pragma comment(lib, "version.lib") // for "VerQueryValue" + #pragma warning(disable : 4826) + ++#ifdef UNICODE ++ #define DBGHELP_TRANSLATE_TCHAR + +-// If VC7 and later, then use the shipped 'dbghelp.h'-file ++#endif + #pragma pack(push, 8) +-#if _MSC_VER >= 1300 + #include +-#else +-// inline the important dbghelp.h-declarations... +-typedef enum +-{ +- SymNone = 0, +- SymCoff, +- SymCv, +- SymPdb, +- SymExport, +- SymDeferred, +- SymSym, +- SymDia, +- SymVirtual, +- NumSymTypes +-} SYM_TYPE; +-typedef struct _IMAGEHLP_LINE64 +-{ +- DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64) +- PVOID Key; // internal +- DWORD LineNumber; // line number in file +- PCHAR FileName; // full filename +- DWORD64 Address; // first instruction of line +-} IMAGEHLP_LINE64, *PIMAGEHLP_LINE64; +-typedef struct _IMAGEHLP_MODULE64 +-{ +- DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64) +- DWORD64 BaseOfImage; // base load address of module +- DWORD ImageSize; // virtual size of the loaded module +- DWORD TimeDateStamp; // date/time stamp from pe header +- DWORD CheckSum; // checksum from the pe header +- DWORD NumSyms; // number of symbols in the symbol table +- SYM_TYPE SymType; // type of symbols loaded +- CHAR ModuleName[32]; // module name +- CHAR ImageName[256]; // image name +- CHAR LoadedImageName[256]; // symbol file name +-} IMAGEHLP_MODULE64, *PIMAGEHLP_MODULE64; +-typedef struct _IMAGEHLP_SYMBOL64 +-{ +- DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL64) +- DWORD64 Address; // virtual address including dll base address +- DWORD Size; // estimated size of symbol, can be zero +- DWORD Flags; // info about the symbols, see the SYMF defines +- DWORD MaxNameLength; // maximum size of symbol name in 'Name' +- CHAR Name[1]; // symbol name (null terminated string) +-} IMAGEHLP_SYMBOL64, *PIMAGEHLP_SYMBOL64; +-typedef enum +-{ +- AddrMode1616, +- AddrMode1632, +- AddrModeReal, +- AddrModeFlat +-} ADDRESS_MODE; +-typedef struct _tagADDRESS64 +-{ +- DWORD64 Offset; +- WORD Segment; +- ADDRESS_MODE Mode; +-} ADDRESS64, *LPADDRESS64; +-typedef struct _KDHELP64 +-{ +- DWORD64 Thread; +- DWORD ThCallbackStack; +- DWORD ThCallbackBStore; +- DWORD NextCallback; +- DWORD FramePointer; +- DWORD64 KiCallUserMode; +- DWORD64 KeUserCallbackDispatcher; +- DWORD64 SystemRangeStart; +- DWORD64 Reserved[8]; +-} KDHELP64, *PKDHELP64; +-typedef struct _tagSTACKFRAME64 +-{ +- ADDRESS64 AddrPC; // program counter +- ADDRESS64 AddrReturn; // return address +- ADDRESS64 AddrFrame; // frame pointer +- ADDRESS64 AddrStack; // stack pointer +- ADDRESS64 AddrBStore; // backing store pointer +- PVOID FuncTableEntry; // pointer to pdata/fpo or NULL +- DWORD64 Params[4]; // possible arguments to the function +- BOOL Far; // WOW far call +- BOOL Virtual; // is this a virtual frame? +- DWORD64 Reserved[3]; +- KDHELP64 KdHelp; +-} STACKFRAME64, *LPSTACKFRAME64; +-typedef BOOL(__stdcall* PREAD_PROCESS_MEMORY_ROUTINE64)(HANDLE hProcess, +- DWORD64 qwBaseAddress, +- PVOID lpBuffer, +- DWORD nSize, +- LPDWORD lpNumberOfBytesRead); +-typedef PVOID(__stdcall* PFUNCTION_TABLE_ACCESS_ROUTINE64)(HANDLE hProcess, DWORD64 AddrBase); +-typedef DWORD64(__stdcall* PGET_MODULE_BASE_ROUTINE64)(HANDLE hProcess, DWORD64 Address); +-typedef DWORD64(__stdcall* PTRANSLATE_ADDRESS_ROUTINE64)(HANDLE hProcess, +- HANDLE hThread, +- LPADDRESS64 lpaddr); +- +-// clang-format off +-#define SYMOPT_CASE_INSENSITIVE 0x00000001 +-#define SYMOPT_UNDNAME 0x00000002 +-#define SYMOPT_DEFERRED_LOADS 0x00000004 +-#define SYMOPT_NO_CPP 0x00000008 +-#define SYMOPT_LOAD_LINES 0x00000010 +-#define SYMOPT_OMAP_FIND_NEAREST 0x00000020 +-#define SYMOPT_LOAD_ANYTHING 0x00000040 +-#define SYMOPT_IGNORE_CVREC 0x00000080 +-#define SYMOPT_NO_UNQUALIFIED_LOADS 0x00000100 +-#define SYMOPT_FAIL_CRITICAL_ERRORS 0x00000200 +-#define SYMOPT_EXACT_SYMBOLS 0x00000400 +-#define SYMOPT_ALLOW_ABSOLUTE_SYMBOLS 0x00000800 +-#define SYMOPT_IGNORE_NT_SYMPATH 0x00001000 +-#define SYMOPT_INCLUDE_32BIT_MODULES 0x00002000 +-#define SYMOPT_PUBLICS_ONLY 0x00004000 +-#define SYMOPT_NO_PUBLICS 0x00008000 +-#define SYMOPT_AUTO_PUBLICS 0x00010000 +-#define SYMOPT_NO_IMAGE_SEARCH 0x00020000 +-#define SYMOPT_SECURE 0x00040000 +-#define SYMOPT_DEBUG 0x80000000 +-#define UNDNAME_COMPLETE (0x0000) // Enable full undecoration +-#define UNDNAME_NAME_ONLY (0x1000) // Crack only the name for primary declaration; +-// clang-format on +- +-#endif // _MSC_VER < 1300 + #pragma pack(pop) + +-// Some missing defines (for VC5/6): +-#ifndef INVALID_FILE_ATTRIBUTES +-#define INVALID_FILE_ATTRIBUTES ((DWORD)-1) +-#endif + +-// secure-CRT_functions are only available starting with VC8 +-#if _MSC_VER < 1400 +-#define strcpy_s(dst, len, src) strcpy(dst, src) +-#define strncpy_s(dst, len, src, maxLen) strncpy(dst, len, src) +-#define strcat_s(dst, len, src) strcat(dst, src) +-#define _snprintf_s _snprintf +-#define _tcscat_s _tcscat +-#endif +- +-static void MyStrCpy(char* szDest, size_t nMaxDestSize, const char* szSrc) ++static void MyStrCpy(TCHAR* szDest, size_t nMaxDestSize, const TCHAR* szSrc) + { + if (nMaxDestSize <= 0) + return; +- strncpy_s(szDest, nMaxDestSize, szSrc, _TRUNCATE); ++ _tcsncpy_s(szDest, nMaxDestSize, szSrc, _TRUNCATE); + // INFO: _TRUNCATE will ensure that it is null-terminated; + // but with older compilers (<1400) it uses "strncpy" and this does not!) + szDest[nMaxDestSize - 1] = 0; + } // MyStrCpy + ++#ifdef _UNICODE ++ typedef SYMBOL_INFOW tSymbolInfo; ++ typedef IMAGEHLP_LINEW64 tImageHelperLine; ++#else ++ typedef SYMBOL_INFO tSymbolInfo; ++ typedef IMAGEHLP_LINE64 tImageHelperLine; ++#endif ++ + // Normally it should be enough to use 'CONTEXT_FULL' (better would be 'CONTEXT_ALL') + #define USED_CONTEXT_FLAGS CONTEXT_FULL + +@@ -253,26 +127,26 @@ public: + { + m_parent = parent; + m_hDbhHelp = NULL; +- pSC = NULL; ++ symCleanup = NULL; + m_hProcess = hProcess; + m_szSymPath = NULL; +- pSFTA = NULL; +- pSGLFA = NULL; +- pSGMB = NULL; +- pSGMI = NULL; +- pSGO = NULL; +- pSGSFA = NULL; +- pSI = NULL; +- pSLM = NULL; +- pSSO = NULL; +- pSW = NULL; +- pUDSN = NULL; +- pSGSP = NULL; ++ symFunctionTableAccess64 = NULL; ++ symGetLineFromAddr64 = NULL; ++ symGetModuleBase64 = NULL; ++ symGetModuleInfo64 = NULL; ++ symGetOptions = NULL; ++ symFromAddr = NULL; ++ symInitialize = NULL; ++ symLoadModuleEx = NULL; ++ symSetOptions = NULL; ++ stackWalk64 = NULL; ++ unDecorateSymbolName = NULL; ++ symGetSearchPath = NULL; + } + ~StackWalkerInternal() + { +- if (pSC != NULL) +- pSC(m_hProcess); // SymCleanup ++ if (symCleanup != NULL) ++ symCleanup(m_hProcess); // SymCleanup + if (m_hDbhHelp != NULL) + FreeLibrary(m_hDbhHelp); + m_hDbhHelp = NULL; +@@ -281,7 +155,7 @@ public: + free(m_szSymPath); + m_szSymPath = NULL; + } +- BOOL Init(LPCSTR szSymPath) ++ BOOL Init(LPCTSTR szSymPath) + { + if (m_parent == NULL) + return FALSE; +@@ -354,54 +228,72 @@ public: + m_hDbhHelp = LoadLibrary(_T("dbghelp.dll")); + if (m_hDbhHelp == NULL) + return FALSE; +- pSI = (tSI)GetProcAddress(m_hDbhHelp, "SymInitialize"); +- pSC = (tSC)GetProcAddress(m_hDbhHelp, "SymCleanup"); +- +- pSW = (tSW)GetProcAddress(m_hDbhHelp, "StackWalk64"); +- pSGO = (tSGO)GetProcAddress(m_hDbhHelp, "SymGetOptions"); +- pSSO = (tSSO)GetProcAddress(m_hDbhHelp, "SymSetOptions"); +- +- pSFTA = (tSFTA)GetProcAddress(m_hDbhHelp, "SymFunctionTableAccess64"); +- pSGLFA = (tSGLFA)GetProcAddress(m_hDbhHelp, "SymGetLineFromAddr64"); +- pSGMB = (tSGMB)GetProcAddress(m_hDbhHelp, "SymGetModuleBase64"); +- pSGMI = (tSGMI)GetProcAddress(m_hDbhHelp, "SymGetModuleInfo64"); +- pSGSFA = (tSGSFA)GetProcAddress(m_hDbhHelp, "SymGetSymFromAddr64"); +- pUDSN = (tUDSN)GetProcAddress(m_hDbhHelp, "UnDecorateSymbolName"); +- pSLM = (tSLM)GetProcAddress(m_hDbhHelp, "SymLoadModule64"); +- pSGSP = (tSGSP)GetProcAddress(m_hDbhHelp, "SymGetSearchPath"); +- +- if (pSC == NULL || pSFTA == NULL || pSGMB == NULL || pSGMI == NULL || pSGO == NULL || +- pSGSFA == NULL || pSI == NULL || pSSO == NULL || pSW == NULL || pUDSN == NULL || +- pSLM == NULL) ++ ++#ifdef _UNICODE ++ static const char strSymInitialize[] = "SymInitializeW"; ++ static const char strUnDecorateSymbolName[] = "UnDecorateSymbolNameW"; ++ static const char strSymGetSearchPath[] = "SymGetSearchPathW"; ++ static const char strSymLoadModuleEx[] = "SymLoadModuleExW"; ++ static const char strSymGetLineFromAddr64[] = "SymGetLineFromAddrW64"; ++ static const char strSymGetModuleInfo64[] = "SymGetModuleInfoW64"; ++ static const char strSymFromAddr[] = "SymFromAddrW"; ++#else ++ static const char strSymInitialize[] = "SymInitialize"; ++ static const char strUnDecorateSymbolName[] = "UnDecorateSymbolName"; ++ static const char strSymGetSearchPath[] = "SymGetSearchPath"; ++ static const char strSymLoadModuleEx[] = "SymLoadModuleEx"; ++ static const char strSymGetLineFromAddr64[] = "SymGetLineFromAddr64"; ++ static const char strSymGetModuleInfo64[] = "SymGetModuleInfo64"; ++ static const char strSymFromAddr[] = "SymFromAddr"; ++#endif ++ symInitialize = (tSI)GetProcAddress(m_hDbhHelp, strSymInitialize); ++ symCleanup = (tSC)GetProcAddress(m_hDbhHelp, "SymCleanup"); ++ ++ stackWalk64 = (tSW)GetProcAddress(m_hDbhHelp, "StackWalk64"); ++ symGetOptions = (tSGO)GetProcAddress(m_hDbhHelp, "SymGetOptions"); ++ symSetOptions = (tSSO)GetProcAddress(m_hDbhHelp, "SymSetOptions"); ++ ++ symFunctionTableAccess64 = (tSFTA)GetProcAddress(m_hDbhHelp, "SymFunctionTableAccess64"); ++ symGetLineFromAddr64 = (tSGLFA)GetProcAddress(m_hDbhHelp, strSymGetLineFromAddr64); ++ symGetModuleBase64 = (tSGMB)GetProcAddress(m_hDbhHelp, "SymGetModuleBase64"); ++ symGetModuleInfo64 = (tSGMI)GetProcAddress(m_hDbhHelp, strSymGetModuleInfo64); ++ symFromAddr = (tSFA)GetProcAddress(m_hDbhHelp, strSymFromAddr); ++ unDecorateSymbolName = (tUDSN)GetProcAddress(m_hDbhHelp, strUnDecorateSymbolName); ++ symLoadModuleEx = (tSLM)GetProcAddress(m_hDbhHelp, strSymLoadModuleEx); ++ symGetSearchPath = (tSGSP)GetProcAddress(m_hDbhHelp, strSymGetSearchPath); ++ ++ if (symCleanup == NULL || symFunctionTableAccess64 == NULL || symGetModuleBase64 == NULL || symGetModuleInfo64 == NULL || symGetOptions == NULL || ++ symFromAddr == NULL || symInitialize == NULL || symSetOptions == NULL || stackWalk64 == NULL || unDecorateSymbolName == NULL || ++ symLoadModuleEx == NULL) + { + FreeLibrary(m_hDbhHelp); + m_hDbhHelp = NULL; +- pSC = NULL; ++ symCleanup = NULL; + return FALSE; + } + + // SymInitialize + if (szSymPath != NULL) +- m_szSymPath = _strdup(szSymPath); +- if (this->pSI(m_hProcess, m_szSymPath, FALSE) == FALSE) +- this->m_parent->OnDbgHelpErr("SymInitialize", GetLastError(), 0); ++ m_szSymPath = _tcsdup(szSymPath); ++ if (this->symInitialize(m_hProcess, m_szSymPath, FALSE) == FALSE) ++ this->m_parent->OnDbgHelpErr(_T("SymInitialize"), GetLastError(), 0); + +- DWORD symOptions = this->pSGO(); // SymGetOptions ++ DWORD symOptions = this->symGetOptions(); // SymGetOptions + symOptions |= SYMOPT_LOAD_LINES; + symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS; + //symOptions |= SYMOPT_NO_PROMPTS; + // SymSetOptions +- symOptions = this->pSSO(symOptions); ++ symOptions = this->symSetOptions(symOptions); + +- char buf[StackWalker::STACKWALK_MAX_NAMELEN] = {0}; +- if (this->pSGSP != NULL) ++ TCHAR buf[StackWalker::STACKWALK_MAX_NAMELEN] = {0}; ++ if (this->symGetSearchPath != NULL) + { +- if (this->pSGSP(m_hProcess, buf, StackWalker::STACKWALK_MAX_NAMELEN) == FALSE) +- this->m_parent->OnDbgHelpErr("SymGetSearchPath", GetLastError(), 0); ++ if (this->symGetSearchPath(m_hProcess, buf, StackWalker::STACKWALK_MAX_NAMELEN) == FALSE) ++ this->m_parent->OnDbgHelpErr(_T("SymGetSearchPath"), GetLastError(), 0); + } +- char szUserName[1024] = {0}; ++ TCHAR szUserName[1024] = {0}; + DWORD dwSize = 1024; +- GetUserNameA(szUserName, &dwSize); ++ GetUserName(szUserName, &dwSize); + this->m_parent->OnSymInit(buf, symOptions, szUserName); + + return TRUE; +@@ -411,7 +303,7 @@ public: + + HMODULE m_hDbhHelp; + HANDLE m_hProcess; +- LPSTR m_szSymPath; ++ LPTSTR m_szSymPath; + + #pragma pack(push, 8) + typedef struct IMAGEHLP_MODULE64_V3 +@@ -423,13 +315,13 @@ public: + DWORD CheckSum; // checksum from the pe header + DWORD NumSyms; // number of symbols in the symbol table + SYM_TYPE SymType; // type of symbols loaded +- CHAR ModuleName[32]; // module name +- CHAR ImageName[256]; // image name +- CHAR LoadedImageName[256]; // symbol file name ++ TCHAR ModuleName[32]; // module name ++ TCHAR ImageName[256]; // image name ++ TCHAR LoadedImageName[256]; // symbol file name + // new elements: 07-Jun-2002 +- CHAR LoadedPdbName[256]; // pdb file name ++ TCHAR LoadedPdbName[256]; // pdb file name + DWORD CVSig; // Signature of the CV record in the debug directories +- CHAR CVData[MAX_PATH * 3]; // Contents of the CV record ++ TCHAR CVData[MAX_PATH * 3]; // Contents of the CV record + DWORD PdbSig; // Signature of PDB + GUID PdbSig70; // Signature of PDB (VC 7 and up) + DWORD PdbAge; // DBI age of pdb +@@ -460,56 +352,59 @@ public: + + // SymCleanup() + typedef BOOL(__stdcall* tSC)(IN HANDLE hProcess); +- tSC pSC; ++ tSC symCleanup; + + // SymFunctionTableAccess64() + typedef PVOID(__stdcall* tSFTA)(HANDLE hProcess, DWORD64 AddrBase); +- tSFTA pSFTA; ++ tSFTA symFunctionTableAccess64; + + // SymGetLineFromAddr64() + typedef BOOL(__stdcall* tSGLFA)(IN HANDLE hProcess, + IN DWORD64 dwAddr, + OUT PDWORD pdwDisplacement, +- OUT PIMAGEHLP_LINE64 Line); +- tSGLFA pSGLFA; ++ OUT tImageHelperLine* Line); ++ tSGLFA symGetLineFromAddr64; + + // SymGetModuleBase64() + typedef DWORD64(__stdcall* tSGMB)(IN HANDLE hProcess, IN DWORD64 dwAddr); +- tSGMB pSGMB; ++ tSGMB symGetModuleBase64; + + // SymGetModuleInfo64() + typedef BOOL(__stdcall* tSGMI)(IN HANDLE hProcess, + IN DWORD64 dwAddr, + OUT IMAGEHLP_MODULE64_V3* ModuleInfo); +- tSGMI pSGMI; ++ tSGMI symGetModuleInfo64; + + // SymGetOptions() + typedef DWORD(__stdcall* tSGO)(VOID); +- tSGO pSGO; ++ tSGO symGetOptions; ++ + + // SymGetSymFromAddr64() +- typedef BOOL(__stdcall* tSGSFA)(IN HANDLE hProcess, +- IN DWORD64 dwAddr, ++ typedef BOOL(__stdcall* tSFA)(IN HANDLE hProcess, ++ IN DWORD64 Address, + OUT PDWORD64 pdwDisplacement, +- OUT PIMAGEHLP_SYMBOL64 Symbol); +- tSGSFA pSGSFA; ++ OUT tSymbolInfo* Symbol); ++ tSFA symFromAddr; + + // SymInitialize() +- typedef BOOL(__stdcall* tSI)(IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess); +- tSI pSI; ++ typedef BOOL(__stdcall* tSI)(IN HANDLE hProcess, IN PTSTR UserSearchPath, IN BOOL fInvadeProcess); ++ tSI symInitialize; + + // SymLoadModule64() + typedef DWORD64(__stdcall* tSLM)(IN HANDLE hProcess, + IN HANDLE hFile, +- IN PSTR ImageName, +- IN PSTR ModuleName, ++ IN PTSTR ImageName, ++ IN PTSTR ModuleName, + IN DWORD64 BaseOfDll, +- IN DWORD SizeOfDll); +- tSLM pSLM; ++ IN DWORD SizeOfDll, ++ IN PMODLOAD_DATA Data, ++ IN DWORD Flags); ++ tSLM symLoadModuleEx; + + // SymSetOptions() + typedef DWORD(__stdcall* tSSO)(IN DWORD SymOptions); +- tSSO pSSO; ++ tSSO symSetOptions; + + // StackWalk64() + typedef BOOL(__stdcall* tSW)(DWORD MachineType, +@@ -521,17 +416,17 @@ public: + PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, + PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, + PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); +- tSW pSW; ++ tSW stackWalk64; + + // UnDecorateSymbolName() +- typedef DWORD(__stdcall WINAPI* tUDSN)(PCSTR DecoratedName, +- PSTR UnDecoratedName, ++ typedef DWORD(__stdcall WINAPI* tUDSN)(PCTSTR DecoratedName, ++ PTSTR UnDecoratedName, + DWORD UndecoratedLength, + DWORD Flags); +- tUDSN pUDSN; ++ tUDSN unDecorateSymbolName; + +- typedef BOOL(__stdcall WINAPI* tSGSP)(HANDLE hProcess, PSTR SearchPath, DWORD SearchPathLength); +- tSGSP pSGSP; ++ typedef BOOL(__stdcall WINAPI* tSGSP)(HANDLE hProcess, PTSTR SearchPath, DWORD SearchPathLength); ++ tSGSP symGetSearchPath; + + private: + // **************************************** ToolHelp32 ************************ +@@ -548,8 +443,8 @@ private: + BYTE* modBaseAddr; // Base address of module in th32ProcessID's context + DWORD modBaseSize; // Size in bytes of module starting at modBaseAddr + HMODULE hModule; // The hModule of this module in th32ProcessID's context +- char szModule[MAX_MODULE_NAME32 + 1]; +- char szExePath[MAX_PATH]; ++ TCHAR szModule[MAX_MODULE_NAME32 + 1]; ++ TCHAR szExePath[MAX_PATH]; + } MODULEENTRY32; + typedef MODULEENTRY32* PMODULEENTRY32; + typedef MODULEENTRY32* LPMODULEENTRY32; +@@ -567,25 +462,31 @@ private: + // try both dlls... + const TCHAR* dllname[] = {_T("kernel32.dll"), _T("tlhelp32.dll")}; + HINSTANCE hToolhelp = NULL; +- tCT32S pCT32S = NULL; +- tM32F pM32F = NULL; +- tM32N pM32N = NULL; ++ tCT32S createToolhelp32Snapshot = NULL; ++ tM32F module32First = NULL; ++ tM32N module32Next = NULL; + + HANDLE hSnap; +- MODULEENTRY32 me; +- me.dwSize = sizeof(me); ++ MODULEENTRY32 moduleEntry32; ++ moduleEntry32.dwSize = sizeof(moduleEntry32); + BOOL keepGoing; +- size_t i; + +- for (i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++) ++#ifdef _UNICODE ++ static const char strModule32First[] = "Module32FirstW"; ++ static const char strModule32Next[] = "Module32NextW"; ++ #else ++ static const char strModule32First[] = "Module32First"; ++ static const char strModule32Next[] = "Module32Next"; ++#endif ++ for (size_t i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++) + { + hToolhelp = LoadLibrary(dllname[i]); + if (hToolhelp == NULL) + continue; +- pCT32S = (tCT32S)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot"); +- pM32F = (tM32F)GetProcAddress(hToolhelp, "Module32First"); +- pM32N = (tM32N)GetProcAddress(hToolhelp, "Module32Next"); +- if ((pCT32S != NULL) && (pM32F != NULL) && (pM32N != NULL)) ++ createToolhelp32Snapshot = (tCT32S)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot"); ++ module32First = (tM32F)GetProcAddress(hToolhelp, strModule32First); ++ module32Next = (tM32N)GetProcAddress(hToolhelp, strModule32Next); ++ if ((createToolhelp32Snapshot != NULL) && (module32First != NULL) && (module32Next != NULL)) + break; // found the functions! + FreeLibrary(hToolhelp); + hToolhelp = NULL; +@@ -594,21 +495,21 @@ private: + if (hToolhelp == NULL) + return FALSE; + +- hSnap = pCT32S(TH32CS_SNAPMODULE, pid); ++ hSnap = createToolhelp32Snapshot(TH32CS_SNAPMODULE, pid); + if (hSnap == (HANDLE)-1) + { + FreeLibrary(hToolhelp); + return FALSE; + } + +- keepGoing = !!pM32F(hSnap, &me); ++ keepGoing = !!module32First(hSnap, &moduleEntry32); + int cnt = 0; + while (keepGoing) + { +- this->LoadModule(hProcess, me.szExePath, me.szModule, (DWORD64)me.modBaseAddr, +- me.modBaseSize); ++ this->LoadModule(hProcess, moduleEntry32.szExePath, moduleEntry32.szModule, (DWORD64)moduleEntry32.modBaseAddr, ++ moduleEntry32.modBaseSize); + cnt++; +- keepGoing = !!pM32N(hSnap, &me); ++ keepGoing = !!module32Next(hSnap, &moduleEntry32); + } + CloseHandle(hSnap); + FreeLibrary(hToolhelp); +@@ -631,39 +532,41 @@ private: + typedef BOOL(__stdcall * tEPM)(HANDLE hProcess, HMODULE * lphModule, DWORD cb, + LPDWORD lpcbNeeded); + // GetModuleFileNameEx() +- typedef DWORD(__stdcall * tGMFNE)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, ++ typedef DWORD(__stdcall * tGMFNE)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, + DWORD nSize); + // GetModuleBaseName() +- typedef DWORD(__stdcall * tGMBN)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename, ++ typedef DWORD(__stdcall * tGMBN)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, + DWORD nSize); + // GetModuleInformation() + typedef BOOL(__stdcall * tGMI)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize); + +- HINSTANCE hPsapi; +- tEPM pEPM; +- tGMFNE pGMFNE; +- tGMBN pGMBN; +- tGMI pGMI; +- +- DWORD i; +- //ModuleEntry e; ++ //ModuleEntry e; + DWORD cbNeeded; + MODULEINFO mi; + HMODULE* hMods = 0; +- char* tt = NULL; +- char* tt2 = NULL; ++ TCHAR* tt = NULL; ++ TCHAR* tt2 = NULL; + const SIZE_T TTBUFLEN = 8096; + int cnt = 0; + +- hPsapi = LoadLibrary(_T("psapi.dll")); ++ HINSTANCE hPsapi = LoadLibrary(_T("psapi.dll")); + if (hPsapi == NULL) + return FALSE; + +- pEPM = (tEPM)GetProcAddress(hPsapi, "EnumProcessModules"); +- pGMFNE = (tGMFNE)GetProcAddress(hPsapi, "GetModuleFileNameExA"); +- pGMBN = (tGMFNE)GetProcAddress(hPsapi, "GetModuleBaseNameA"); +- pGMI = (tGMI)GetProcAddress(hPsapi, "GetModuleInformation"); +- if ((pEPM == NULL) || (pGMFNE == NULL) || (pGMBN == NULL) || (pGMI == NULL)) ++#ifdef _UNICODE ++ static const char strGetModuleFileName[] = "GetModuleFileNameExW"; ++ static const char strGetModuleBaseName[] = "GetModuleBaseNameW"; ++#else ++ static const char strGetModuleFileName[] = "GetModulefileNameExA"; ++ static const char strGetModuleBaseName[] = "GetModuleBaseNameA"; ++#endif ++ ++ tEPM enumProcessModules = (tEPM)GetProcAddress(hPsapi, "EnumProcessModules"); ++ tGMFNE getModuleFileNameEx = (tGMFNE)GetProcAddress(hPsapi, strGetModuleFileName); ++ tGMBN getModuleBaseName = (tGMFNE)GetProcAddress(hPsapi, strGetModuleBaseName); ++ tGMI getModuleInformation = (tGMI)GetProcAddress(hPsapi, "GetModuleInformation"); ++ if ((enumProcessModules == NULL) || (getModuleFileNameEx == NULL) || ++ (getModuleBaseName == NULL) || (getModuleInformation == NULL)) + { + // we couldn't find all functions + FreeLibrary(hPsapi); +@@ -671,12 +574,12 @@ private: + } + + hMods = (HMODULE*)malloc(sizeof(HMODULE) * (TTBUFLEN / sizeof(HMODULE))); +- tt = (char*)malloc(sizeof(char) * TTBUFLEN); +- tt2 = (char*)malloc(sizeof(char) * TTBUFLEN); ++ tt = (TCHAR*)malloc(sizeof(TCHAR) * TTBUFLEN); ++ tt2 = (TCHAR*)malloc(sizeof(TCHAR) * TTBUFLEN); + if ((hMods == NULL) || (tt == NULL) || (tt2 == NULL)) + goto cleanup; + +- if (!pEPM(hProcess, hMods, TTBUFLEN, &cbNeeded)) ++ if (!enumProcessModules(hProcess, hMods, TTBUFLEN, &cbNeeded)) + { + //_ftprintf(fLogFile, _T("%lu: EPM failed, GetLastError = %lu\n"), g_dwShowCount, gle ); + goto cleanup; +@@ -688,20 +591,20 @@ private: + goto cleanup; + } + +- for (i = 0; i < cbNeeded / sizeof(hMods[0]); i++) ++ for (DWORD i = 0; i < cbNeeded / sizeof(hMods[0]); i++) + { + // base address, size +- pGMI(hProcess, hMods[i], &mi, sizeof(mi)); ++ getModuleInformation(hProcess, hMods[i], &mi, sizeof(mi)); + // image file name + tt[0] = 0; +- pGMFNE(hProcess, hMods[i], tt, TTBUFLEN); ++ getModuleFileNameEx(hProcess, hMods[i], tt, TTBUFLEN); + // module name + tt2[0] = 0; +- pGMBN(hProcess, hMods[i], tt2, TTBUFLEN); ++ getModuleBaseName(hProcess, hMods[i], tt2, TTBUFLEN); + + DWORD dwRes = this->LoadModule(hProcess, tt, tt2, (DWORD64)mi.lpBaseOfDll, mi.SizeOfImage); + if (dwRes != ERROR_SUCCESS) +- this->m_parent->OnDbgHelpErr("LoadModule", dwRes, 0); ++ this->m_parent->OnDbgHelpErr(_T("LoadModule"), dwRes, 0); + cnt++; + } + +@@ -718,16 +621,16 @@ private: + return cnt != 0; + } // GetModuleListPSAPI + +- DWORD LoadModule(HANDLE hProcess, LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size) ++ DWORD LoadModule(HANDLE hProcess, LPCTSTR img, LPCTSTR mod, DWORD64 baseAddr, DWORD size) + { +- CHAR* szImg = _strdup(img); +- CHAR* szMod = _strdup(mod); ++ TCHAR* szImg = _tcsdup(img); ++ TCHAR* szMod = _tcsdup(mod); + DWORD result = ERROR_SUCCESS; + if ((szImg == NULL) || (szMod == NULL)) + result = ERROR_NOT_ENOUGH_MEMORY; + else + { +- if (pSLM(hProcess, 0, szImg, szMod, baseAddr, size) == 0) ++ if (symLoadModuleEx(hProcess, 0, szImg, szMod, baseAddr, size, 0, 0) == 0) + result = GetLastError(); + } + ULONGLONG fileVersion = 0; +@@ -738,13 +641,13 @@ private: + { + VS_FIXEDFILEINFO* fInfo = NULL; + DWORD dwHandle; +- DWORD dwSize = GetFileVersionInfoSizeA(szImg, &dwHandle); ++ DWORD dwSize = GetFileVersionInfoSize(szImg, &dwHandle); + if (dwSize > 0) + { + LPVOID vData = malloc(dwSize); + if (vData != NULL) + { +- if (GetFileVersionInfoA(szImg, dwHandle, dwSize, vData) != 0) ++ if (GetFileVersionInfo(szImg, dwHandle, dwSize, vData) != 0) + { + UINT len; + TCHAR szSubBlock[] = _T("\\"); +@@ -763,41 +666,41 @@ private: + + // Retrieve some additional-infos about the module + IMAGEHLP_MODULE64_V3 Module; +- const char* szSymType = "-unknown-"; ++ const TCHAR* szSymType = _T("-unknown-"); + if (this->GetModuleInfo(hProcess, baseAddr, &Module) != FALSE) + { + switch (Module.SymType) + { + case SymNone: +- szSymType = "-nosymbols-"; ++ szSymType = _T("-nosymbols-"); + break; + case SymCoff: // 1 +- szSymType = "COFF"; ++ szSymType = _T("COFF"); + break; + case SymCv: // 2 +- szSymType = "CV"; ++ szSymType = _T("CV"); + break; + case SymPdb: // 3 +- szSymType = "PDB"; ++ szSymType = _T("PDB"); + break; + case SymExport: // 4 +- szSymType = "-exported-"; ++ szSymType = _T("-exported-"); + break; + case SymDeferred: // 5 +- szSymType = "-deferred-"; ++ szSymType = _T("-deferred-"); + break; + case SymSym: // 6 +- szSymType = "SYM"; ++ szSymType = _T("SYM"); + break; + case 7: // SymDia: +- szSymType = "DIA"; ++ szSymType = _T("DIA"); + break; + case 8: //SymVirtual: +- szSymType = "Virtual"; ++ szSymType = _T("Virtual"); + break; + } + } +- LPCSTR pdbName = Module.LoadedImageName; ++ LPCTSTR pdbName = Module.LoadedImageName; + if (Module.LoadedPdbName[0] != 0) + pdbName = Module.LoadedPdbName; + this->m_parent->OnLoadModule(img, mod, baseAddr, size, result, szSymType, pdbName, +@@ -823,7 +726,7 @@ public: + BOOL GetModuleInfo(HANDLE hProcess, DWORD64 baseAddr, IMAGEHLP_MODULE64_V3* pModuleInfo) + { + memset(pModuleInfo, 0, sizeof(IMAGEHLP_MODULE64_V3)); +- if (this->pSGMI == NULL) ++ if (this->symGetModuleInfo64 == NULL) + { + SetLastError(ERROR_DLL_INIT_FAILED); + return FALSE; +@@ -841,7 +744,7 @@ public: + static bool s_useV3Version = true; + if (s_useV3Version) + { +- if (this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE) ++ if (this->symGetModuleInfo64(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE) + { + // only copy as much memory as is reserved... + memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V3)); +@@ -855,7 +758,7 @@ public: + // could not retrieve the bigger structure, try with the smaller one (as defined in VC7.1)... + pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2); + memcpy(pData, pModuleInfo, sizeof(IMAGEHLP_MODULE64_V2)); +- if (this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE) ++ if (this->symGetModuleInfo64(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE) + { + // only copy as much memory as is reserved... + memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V2)); +@@ -880,7 +783,7 @@ StackWalker::StackWalker(DWORD dwProcessId, HANDLE hProcess) + this->m_szSymPath = NULL; + this->m_MaxRecursionCount = 1000; + } +-StackWalker::StackWalker(int options, LPCSTR szSymPath, DWORD dwProcessId, HANDLE hProcess) ++StackWalker::StackWalker(int options, LPCTSTR szSymPath, DWORD dwProcessId, HANDLE hProcess) + { + this->m_options = options; + this->m_modulesLoaded = FALSE; +@@ -889,7 +792,7 @@ StackWalker::StackWalker(int options, LPCSTR szSymPath, DWORD dwProcessId, HANDL + this->m_dwProcessId = dwProcessId; + if (szSymPath != NULL) + { +- this->m_szSymPath = _strdup(szSymPath); ++ this->m_szSymPath = _tcsdup(szSymPath); + this->m_options |= SymBuildPath; + } + else +@@ -918,11 +821,11 @@ BOOL StackWalker::LoadModules() + return TRUE; + + // Build the sym-path: +- char* szSymPath = NULL; ++ TCHAR* szSymPath = NULL; + if ((this->m_options & SymBuildPath) != 0) + { + const size_t nSymPathLen = 4096; +- szSymPath = (char*)malloc(nSymPathLen); ++ szSymPath = (TCHAR*)malloc(nSymPathLen * sizeof(TCHAR)); + if (szSymPath == NULL) + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); +@@ -932,27 +835,27 @@ BOOL StackWalker::LoadModules() + // Now first add the (optional) provided sympath: + if (this->m_szSymPath != NULL) + { +- strcat_s(szSymPath, nSymPathLen, this->m_szSymPath); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, this->m_szSymPath); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } + +- strcat_s(szSymPath, nSymPathLen, ".;"); ++ _tcscat_s(szSymPath, nSymPathLen, _T(".;")); + + const size_t nTempLen = 1024; +- char szTemp[nTempLen]; ++ TCHAR szTemp[nTempLen]; + // Now add the current directory: +- if (GetCurrentDirectoryA(nTempLen, szTemp) > 0) ++ if (GetCurrentDirectory(nTempLen, szTemp) > 0) + { + szTemp[nTempLen - 1] = 0; +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } + + // Now add the path for the main-module: +- if (GetModuleFileNameA(NULL, szTemp, nTempLen) > 0) ++ if (GetModuleFileName(NULL, szTemp, nTempLen) > 0) + { + szTemp[nTempLen - 1] = 0; +- for (char* p = (szTemp + strlen(szTemp) - 1); p >= szTemp; --p) ++ for (TCHAR* p = (szTemp + _tcslen(szTemp) - 1); p >= szTemp; --p) + { + // locate the rightmost path separator + if ((*p == '\\') || (*p == '/') || (*p == ':')) +@@ -961,48 +864,48 @@ BOOL StackWalker::LoadModules() + break; + } + } // for (search for path separator...) +- if (strlen(szTemp) > 0) ++ if (_tcslen(szTemp) > 0) + { +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } + } +- if (GetEnvironmentVariableA("_NT_SYMBOL_PATH", szTemp, nTempLen) > 0) ++ if (GetEnvironmentVariable(_T("_NT_SYMBOL_PATH"), szTemp, nTempLen) > 0) + { + szTemp[nTempLen - 1] = 0; +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } +- if (GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", szTemp, nTempLen) > 0) ++ if (GetEnvironmentVariable(_T("_NT_ALTERNATE_SYMBOL_PATH"), szTemp, nTempLen) > 0) + { + szTemp[nTempLen - 1] = 0; +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } +- if (GetEnvironmentVariableA("SYSTEMROOT", szTemp, nTempLen) > 0) ++ if (GetEnvironmentVariable(_T("SYSTEMROOT"), szTemp, nTempLen) > 0) + { + szTemp[nTempLen - 1] = 0; +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + // also add the "system32"-directory: +- strcat_s(szTemp, nTempLen, "\\system32"); +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, ";"); ++ _tcscat_s(szTemp, nTempLen, _T("\\system32")); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T(";")); + } + + if ((this->m_options & SymUseSymSrv) != 0) + { +- if (GetEnvironmentVariableA("SYSTEMDRIVE", szTemp, nTempLen) > 0) ++ if (GetEnvironmentVariable(_T("SYSTEMDRIVE"), szTemp, nTempLen) > 0) + { + szTemp[nTempLen - 1] = 0; +- strcat_s(szSymPath, nSymPathLen, "SRV*"); +- strcat_s(szSymPath, nSymPathLen, szTemp); +- strcat_s(szSymPath, nSymPathLen, "\\websymbols"); +- strcat_s(szSymPath, nSymPathLen, "*http://msdl.microsoft.com/download/symbols;"); ++ _tcscat_s(szSymPath, nSymPathLen, _T("SRV*")); ++ _tcscat_s(szSymPath, nSymPathLen, szTemp); ++ _tcscat_s(szSymPath, nSymPathLen, _T("\\websymbols")); ++ _tcscat_s(szSymPath, nSymPathLen, _T("*http://msdl.microsoft.com/download/symbols;")); + } + else +- strcat_s(szSymPath, nSymPathLen, +- "SRV*c:\\websymbols*http://msdl.microsoft.com/download/symbols;"); ++ _tcscat_s(szSymPath, nSymPathLen, ++ _T("SRV*c:\\websymbols*http://msdl.microsoft.com/download/symbols;")); + } + } // if SymBuildPath + +@@ -1013,7 +916,7 @@ BOOL StackWalker::LoadModules() + szSymPath = NULL; + if (bRet == FALSE) + { +- this->OnDbgHelpErr("Error while initializing dbghelp.dll", 0, 0); ++ this->OnDbgHelpErr(_T("Error while initializing dbghelp.dll"), 0, 0); + SetLastError(ERROR_DLL_INIT_FAILED); + return FALSE; + } +@@ -1038,9 +941,10 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + { + CONTEXT c; + CallstackEntry csEntry; +- IMAGEHLP_SYMBOL64* pSym = NULL; ++ ++ tSymbolInfo* pSym = NULL; + StackWalkerInternal::IMAGEHLP_MODULE64_V3 Module; +- IMAGEHLP_LINE64 Line; ++ tImageHelperLine Line; + int frameNum; + bool bLastEntryCalled = true; + int curRecursionCount = 0; +@@ -1125,12 +1029,12 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + #error "Platform not supported!" + #endif + +- pSym = (IMAGEHLP_SYMBOL64*)malloc(sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN); ++ pSym = (tSymbolInfo*)malloc(sizeof(tSymbolInfo) + STACKWALK_MAX_NAMELEN*sizeof(TCHAR)); + if (!pSym) + goto cleanup; // not enough memory... +- memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN); +- pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64); +- pSym->MaxNameLength = STACKWALK_MAX_NAMELEN; ++ memset(pSym, 0, sizeof(tSymbolInfo) + STACKWALK_MAX_NAMELEN*sizeof(TCHAR)); ++ pSym->SizeOfStruct = sizeof(tSymbolInfo); ++ pSym->MaxNameLen = STACKWALK_MAX_NAMELEN; + + memset(&Line, 0, sizeof(Line)); + Line.SizeOfStruct = sizeof(Line); +@@ -1145,11 +1049,11 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + // assume that either you are done, or that the stack is so hosed that the next + // deeper frame could not be found. + // CONTEXT need not to be supplied if imageTyp is IMAGE_FILE_MACHINE_I386! +- if (!this->m_sw->pSW(imageType, this->m_hProcess, hThread, &s, &c, myReadProcMem, +- this->m_sw->pSFTA, this->m_sw->pSGMB, NULL)) ++ if (!this->m_sw->stackWalk64(imageType, this->m_hProcess, hThread, &s, &c, myReadProcMem, ++ this->m_sw->symFunctionTableAccess64, this->m_sw->symGetModuleBase64, NULL)) + { + // INFO: "StackWalk64" does not set "GetLastError"... +- this->OnDbgHelpErr("StackWalk64", 0, s.AddrPC.Offset); ++ this->OnDbgHelpErr(_T("StackWalk64"), 0, s.AddrPC.Offset); + break; + } + +@@ -1167,7 +1071,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + { + if ((this->m_MaxRecursionCount > 0) && (curRecursionCount > m_MaxRecursionCount)) + { +- this->OnDbgHelpErr("StackWalk64-Endless-Callstack!", 0, s.AddrPC.Offset); ++ this->OnDbgHelpErr(_T("StackWalk64-Endless-Callstack!"), 0, s.AddrPC.Offset); + break; + } + curRecursionCount++; +@@ -1178,23 +1082,23 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + { + // we seem to have a valid PC + // show procedure info (SymGetSymFromAddr64()) +- if (this->m_sw->pSGSFA(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromSmybol), ++ if (this->m_sw->symFromAddr(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromSmybol), + pSym) != FALSE) + { + MyStrCpy(csEntry.name, STACKWALK_MAX_NAMELEN, pSym->Name); + // UnDecorateSymbolName() +- this->m_sw->pUDSN(pSym->Name, csEntry.undName, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY); +- this->m_sw->pUDSN(pSym->Name, csEntry.undFullName, STACKWALK_MAX_NAMELEN, UNDNAME_COMPLETE); ++ DWORD res = this->m_sw->unDecorateSymbolName(pSym->Name, csEntry.undName, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY); ++ res = this->m_sw->unDecorateSymbolName(pSym->Name, csEntry.undFullName, STACKWALK_MAX_NAMELEN, UNDNAME_COMPLETE); + } + else + { +- this->OnDbgHelpErr("SymGetSymFromAddr64", GetLastError(), s.AddrPC.Offset); ++ this->OnDbgHelpErr(_T("SymGetSymFromAddr64"), GetLastError(), s.AddrPC.Offset); + } + + // show line number info, NT5.0-method (SymGetLineFromAddr64()) +- if (this->m_sw->pSGLFA != NULL) ++ if (this->m_sw->symGetLineFromAddr64 != NULL) + { // yes, we have SymGetLineFromAddr64() +- if (this->m_sw->pSGLFA(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromLine), ++ if (this->m_sw->symGetLineFromAddr64(this->m_hProcess, s.AddrPC.Offset, &(csEntry.offsetFromLine), + &Line) != FALSE) + { + csEntry.lineNumber = Line.LineNumber; +@@ -1202,7 +1106,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + } + else + { +- this->OnDbgHelpErr("SymGetLineFromAddr64", GetLastError(), s.AddrPC.Offset); ++ this->OnDbgHelpErr(_T("SymGetLineFromAddr64"), GetLastError(), s.AddrPC.Offset); + } + } // yes, we have SymGetLineFromAddr64() + +@@ -1252,7 +1156,7 @@ BOOL StackWalker::ShowCallstack(HANDLE hThread, + } // got module info OK + else + { +- this->OnDbgHelpErr("SymGetModuleInfo64", GetLastError(), s.AddrPC.Offset); ++ this->OnDbgHelpErr(_T("SymGetModuleInfo64"), GetLastError(), s.AddrPC.Offset); + } + } // we seem to have a valid PC + +@@ -1298,20 +1202,20 @@ BOOL StackWalker::ShowObject(LPVOID pObject) + } + + // SymGetSymFromAddr64() is required +- if (this->m_sw->pSGSFA == NULL) ++ if (this->m_sw->symFromAddr == NULL) + return FALSE; + + // Show object info (SymGetSymFromAddr64()) + DWORD64 dwAddress = DWORD64(pObject); + DWORD64 dwDisplacement = 0; +- IMAGEHLP_SYMBOL64* pSym = +- (IMAGEHLP_SYMBOL64*)malloc(sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN); +- memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN); +- pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64); +- pSym->MaxNameLength = STACKWALK_MAX_NAMELEN; +- if (this->m_sw->pSGSFA(this->m_hProcess, dwAddress, &dwDisplacement, pSym) == FALSE) ++ tSymbolInfo* pSym = ++ (tSymbolInfo*)malloc(sizeof(tSymbolInfo) + STACKWALK_MAX_NAMELEN*sizeof(TCHAR)); ++ memset(pSym, 0, sizeof(tSymbolInfo) + STACKWALK_MAX_NAMELEN*sizeof(TCHAR)); ++ pSym->SizeOfStruct = sizeof(tSymbolInfo); ++ pSym->MaxNameLen = STACKWALK_MAX_NAMELEN; ++ if (this->m_sw->symFromAddr(this->m_hProcess, dwAddress, &dwDisplacement, pSym) == FALSE) + { +- this->OnDbgHelpErr("SymGetSymFromAddr64", GetLastError(), dwAddress); ++ this->OnDbgHelpErr(_T("SymGetSymFromAddr64"), GetLastError(), dwAddress); + return FALSE; + } + // Object name output +@@ -1342,22 +1246,22 @@ BOOL __stdcall StackWalker::myReadProcMem(HANDLE hProcess, + } + } + +-void StackWalker::OnLoadModule(LPCSTR img, +- LPCSTR mod, ++void StackWalker::OnLoadModule(LPCTSTR img, ++ LPCTSTR mod, + DWORD64 baseAddr, + DWORD size, + DWORD result, +- LPCSTR symType, +- LPCSTR pdbName, ++ LPCTSTR symType, ++ LPCTSTR pdbName, + ULONGLONG fileVersion) + { +- CHAR buffer[STACKWALK_MAX_NAMELEN]; ++ TCHAR buffer[STACKWALK_MAX_NAMELEN]; + size_t maxLen = STACKWALK_MAX_NAMELEN; + #if _MSC_VER >= 1400 + maxLen = _TRUNCATE; + #endif + if (fileVersion == 0) +- _snprintf_s(buffer, maxLen, "%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s'\n", ++ _sntprintf_s(buffer, maxLen, _T("%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s'\n"), + img, mod, (LPVOID)baseAddr, size, result, symType, pdbName); + else + { +@@ -1365,9 +1269,9 @@ void StackWalker::OnLoadModule(LPCSTR img, + DWORD v3 = (DWORD)((fileVersion >> 16) & 0xFFFF); + DWORD v2 = (DWORD)((fileVersion >> 32) & 0xFFFF); + DWORD v1 = (DWORD)((fileVersion >> 48) & 0xFFFF); +- _snprintf_s( ++ _sntprintf_s( + buffer, maxLen, +- "%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s', fileVersion: %d.%d.%d.%d\n", ++ _T("%s:%s (%p), size: %d (result: %d), SymType: '%s', PDB: '%s', fileVersion: %d.%d.%d.%d\n"), + img, mod, (LPVOID)baseAddr, size, result, symType, pdbName, v1, v2, v3, v4); + } + buffer[STACKWALK_MAX_NAMELEN - 1] = 0; // be sure it is NULL terminated +@@ -1376,7 +1280,7 @@ void StackWalker::OnLoadModule(LPCSTR img, + + void StackWalker::OnCallstackEntry(CallstackEntryType eType, CallstackEntry& entry) + { +- CHAR buffer[STACKWALK_MAX_NAMELEN]; ++ TCHAR buffer[STACKWALK_MAX_NAMELEN]; + size_t maxLen = STACKWALK_MAX_NAMELEN; + #if _MSC_VER >= 1400 + maxLen = _TRUNCATE; +@@ -1384,48 +1288,48 @@ void StackWalker::OnCallstackEntry(CallstackEntryType eType, CallstackEntry& ent + if ((eType != lastEntry) && (entry.offset != 0)) + { + if (entry.name[0] == 0) +- MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, "(function-name not available)"); ++ MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, _T("(function-name not available)")); + if (entry.undName[0] != 0) + MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, entry.undName); + if (entry.undFullName[0] != 0) + MyStrCpy(entry.name, STACKWALK_MAX_NAMELEN, entry.undFullName); + if (entry.lineFileName[0] == 0) + { +- MyStrCpy(entry.lineFileName, STACKWALK_MAX_NAMELEN, "(filename not available)"); ++ MyStrCpy(entry.lineFileName, STACKWALK_MAX_NAMELEN, _T("(filename not available)")); + if (entry.moduleName[0] == 0) +- MyStrCpy(entry.moduleName, STACKWALK_MAX_NAMELEN, "(module-name not available)"); +- _snprintf_s(buffer, maxLen, "%p (%s): %s: %s\n", (LPVOID)entry.offset, entry.moduleName, ++ MyStrCpy(entry.moduleName, STACKWALK_MAX_NAMELEN, _T("(module-name not available)")); ++ _sntprintf_s(buffer, maxLen, _T("%p (%s): %s: %s\n"), (LPVOID)entry.offset, entry.moduleName, + entry.lineFileName, entry.name); + } + else +- _snprintf_s(buffer, maxLen, "%s (%d): %s\n", entry.lineFileName, entry.lineNumber, ++ _sntprintf_s(buffer, maxLen, _T("%s (%d): %s\n"), entry.lineFileName, entry.lineNumber, + entry.name); + buffer[STACKWALK_MAX_NAMELEN - 1] = 0; + OnOutput(buffer); + } + } + +-void StackWalker::OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr) ++void StackWalker::OnDbgHelpErr(LPCTSTR szFuncName, DWORD gle, DWORD64 addr) + { +- CHAR buffer[STACKWALK_MAX_NAMELEN]; ++ TCHAR buffer[STACKWALK_MAX_NAMELEN]; + size_t maxLen = STACKWALK_MAX_NAMELEN; + #if _MSC_VER >= 1400 + maxLen = _TRUNCATE; + #endif +- _snprintf_s(buffer, maxLen, "ERROR: %s, GetLastError: %d (Address: %p)\n", szFuncName, gle, ++ _sntprintf_s(buffer, maxLen, _T("ERROR: %s, GetLastError: %d (Address: %p)\n"), szFuncName, gle, + (LPVOID)addr); + buffer[STACKWALK_MAX_NAMELEN - 1] = 0; + OnOutput(buffer); + } + +-void StackWalker::OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName) ++void StackWalker::OnSymInit(LPCTSTR szSearchPath, DWORD symOptions, LPCTSTR szUserName) + { +- CHAR buffer[STACKWALK_MAX_NAMELEN]; ++ TCHAR buffer[STACKWALK_MAX_NAMELEN]; + size_t maxLen = STACKWALK_MAX_NAMELEN; + #if _MSC_VER >= 1400 + maxLen = _TRUNCATE; + #endif +- _snprintf_s(buffer, maxLen, "SymInit: Symbol-SearchPath: '%s', symOptions: %d, UserName: '%s'\n", ++ _sntprintf_s(buffer, maxLen, _T("SymInit: Symbol-SearchPath: '%s', symOptions: %d, UserName: '%s'\n"), + szSearchPath, symOptions, szUserName); + buffer[STACKWALK_MAX_NAMELEN - 1] = 0; + OnOutput(buffer); +@@ -1442,16 +1346,16 @@ void StackWalker::OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUser + OnOutput(buffer); + } + #else +- OSVERSIONINFOEXA ver; +- ZeroMemory(&ver, sizeof(OSVERSIONINFOEXA)); ++ OSVERSIONINFOEX ver; ++ ZeroMemory(&ver, sizeof(OSVERSIONINFOEX)); + ver.dwOSVersionInfoSize = sizeof(ver); + #if _MSC_VER >= 1900 + #pragma warning(push) + #pragma warning(disable : 4996) + #endif +- if (GetVersionExA((OSVERSIONINFOA*)&ver) != FALSE) ++ if (GetVersionEx((OSVERSIONINFO*)&ver) != FALSE) + { +- _snprintf_s(buffer, maxLen, "OS-Version: %d.%d.%d (%s) 0x%x-0x%x\n", ver.dwMajorVersion, ++ _sntprintf_s(buffer, maxLen, _T("OS-Version: %d.%d.%d (%s) 0x%x-0x%x\n"), ver.dwMajorVersion, + ver.dwMinorVersion, ver.dwBuildNumber, ver.szCSDVersion, ver.wSuiteMask, + ver.wProductType); + buffer[STACKWALK_MAX_NAMELEN - 1] = 0; +@@ -1463,7 +1367,7 @@ void StackWalker::OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUser + #endif + } + +-void StackWalker::OnOutput(LPCSTR buffer) ++void StackWalker::OnOutput(LPCTSTR buffer) + { +- OutputDebugStringA(buffer); ++ OutputDebugString(buffer); + } +diff --git a/Main/StackWalker/StackWalker.h b/Main/StackWalker/StackWalker.h +index 0a004d9..03efcec 100644 +--- a/Main/StackWalker/StackWalker.h ++++ b/Main/StackWalker/StackWalker.h +@@ -47,16 +47,6 @@ + #pragma warning(disable : 4091) + #endif + +-// special defines for VC5/6 (if no actual PSDK is installed): +-#if _MSC_VER < 1300 +-typedef unsigned __int64 DWORD64, *PDWORD64; +-#if defined(_WIN64) +-typedef unsigned __int64 SIZE_T, *PSIZE_T; +-#else +-typedef unsigned long SIZE_T, *PSIZE_T; +-#endif +-#endif // _MSC_VER < 1300 +- + class StackWalkerInternal; // forward + class StackWalker + { +@@ -96,7 +86,7 @@ public: + } StackWalkOptions; + + StackWalker(int options = OptionsAll, // 'int' is by design, to combine the enum-flags +- LPCSTR szSymPath = NULL, ++ LPCTSTR szSymPath = NULL, + DWORD dwProcessId = GetCurrentProcessId(), + HANDLE hProcess = GetCurrentProcess()); + StackWalker(DWORD dwProcessId, HANDLE hProcess); +@@ -137,18 +127,18 @@ protected: + typedef struct CallstackEntry + { + DWORD64 offset; // if 0, we have no valid entry +- CHAR name[STACKWALK_MAX_NAMELEN]; +- CHAR undName[STACKWALK_MAX_NAMELEN]; +- CHAR undFullName[STACKWALK_MAX_NAMELEN]; ++ TCHAR name[STACKWALK_MAX_NAMELEN]; ++ TCHAR undName[STACKWALK_MAX_NAMELEN]; ++ TCHAR undFullName[STACKWALK_MAX_NAMELEN]; + DWORD64 offsetFromSmybol; + DWORD offsetFromLine; + DWORD lineNumber; +- CHAR lineFileName[STACKWALK_MAX_NAMELEN]; ++ TCHAR lineFileName[STACKWALK_MAX_NAMELEN]; + DWORD symType; + LPCSTR symTypeString; +- CHAR moduleName[STACKWALK_MAX_NAMELEN]; ++ TCHAR moduleName[STACKWALK_MAX_NAMELEN]; + DWORD64 baseOfImage; +- CHAR loadedImageName[STACKWALK_MAX_NAMELEN]; ++ TCHAR loadedImageName[STACKWALK_MAX_NAMELEN]; + } CallstackEntry; + + typedef enum CallstackEntryType +@@ -158,24 +148,24 @@ protected: + lastEntry + } CallstackEntryType; + +- virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName); +- virtual void OnLoadModule(LPCSTR img, +- LPCSTR mod, ++ virtual void OnSymInit(LPCTSTR szSearchPath, DWORD symOptions, LPCTSTR szUserName); ++ virtual void OnLoadModule(LPCTSTR img, ++ LPCTSTR mod, + DWORD64 baseAddr, + DWORD size, + DWORD result, +- LPCSTR symType, +- LPCSTR pdbName, ++ LPCTSTR symType, ++ LPCTSTR pdbName, + ULONGLONG fileVersion); + virtual void OnCallstackEntry(CallstackEntryType eType, CallstackEntry& entry); +- virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr); +- virtual void OnOutput(LPCSTR szText); ++ virtual void OnDbgHelpErr(LPCTSTR szFuncName, DWORD gle, DWORD64 addr); ++ virtual void OnOutput(LPCTSTR szText); + + StackWalkerInternal* m_sw; + HANDLE m_hProcess; + DWORD m_dwProcessId; + BOOL m_modulesLoaded; +- LPSTR m_szSymPath; ++ LPTSTR m_szSymPath; + + int m_options; + int m_MaxRecursionCount; +diff --git a/Main/StackWalker/StackWalker_VC2017.sln b/Main/StackWalker/StackWalker_VC2017.sln +index 790d550..2209e23 100644 +--- a/Main/StackWalker/StackWalker_VC2017.sln ++++ b/Main/StackWalker/StackWalker_VC2017.sln +@@ -16,18 +16,18 @@ Global + Release_VC2017-UNICODE|x64 = Release_VC2017-UNICODE|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|Win32.ActiveCfg = Debug_VC2017-UNICODE|Win32 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|Win32.Build.0 = Debug_VC2017-UNICODE|Win32 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|x64.ActiveCfg = Debug_VC2017-UNICODE|x64 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|x64.Build.0 = Debug_VC2017-UNICODE|x64 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|Win32.ActiveCfg = Debug_VC2017|Win32 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|Win32.Build.0 = Debug_VC2017|Win32 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|x64.ActiveCfg = Debug_VC2017|x64 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017|x64.Build.0 = Debug_VC2017|x64 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017-UNICODE|Win32.ActiveCfg = Debug_VC2017-UNICODE|Win32 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017-UNICODE|Win32.Build.0 = Debug_VC2017-UNICODE|Win32 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017-UNICODE|x64.ActiveCfg = Debug_VC2017-UNICODE|x64 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Debug_VC2017-UNICODE|x64.Build.0 = Debug_VC2017-UNICODE|x64 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|Win32.ActiveCfg = Release_VC2017-UNICODE|Win32 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|Win32.Build.0 = Release_VC2017-UNICODE|Win32 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|x64.ActiveCfg = Release_VC2017-UNICODE|x64 +- {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|x64.Build.0 = Release_VC2017-UNICODE|x64 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|Win32.ActiveCfg = Release_VC2017|Win32 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|Win32.Build.0 = Release_VC2017|Win32 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|x64.ActiveCfg = Release_VC2017|x64 ++ {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017|x64.Build.0 = Release_VC2017|x64 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017-UNICODE|Win32.ActiveCfg = Release_VC2017-UNICODE|Win32 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017-UNICODE|Win32.Build.0 = Release_VC2017-UNICODE|Win32 + {89B2BD42-B130-4811-9043-71A8EBC40DE5}.Release_VC2017-UNICODE|x64.ActiveCfg = Release_VC2017-UNICODE|x64 +diff --git a/Main/StackWalker/main.cpp b/Main/StackWalker/main.cpp +index 220c97b..496021e 100644 +--- a/Main/StackWalker/main.cpp ++++ b/Main/StackWalker/main.cpp +@@ -33,7 +33,7 @@ void (*pGlobalFuncPtr)() = 0; + class StackWalkerToConsole : public StackWalker + { + protected: +- virtual void OnOutput(LPCSTR szText) { printf("%s", szText); } ++ virtual void OnOutput(LPCTSTR szText) { _tprintf(_T("%s"), szText); } + }; + + void Func5() +-- +2.20.1.windows.1 + diff --git a/upstream_utils/stack_walker_patches/0002-Remove-_M_IX86-checks.patch b/upstream_utils/stack_walker_patches/0002-Remove-_M_IX86-checks.patch new file mode 100644 index 0000000000..18a00c2969 --- /dev/null +++ b/upstream_utils/stack_walker_patches/0002-Remove-_M_IX86-checks.patch @@ -0,0 +1,82 @@ +From 238eda525de70b57bade634447c967f4f92bc96d Mon Sep 17 00:00:00 2001 +From: PJ Reiniger +Date: Mon, 23 May 2022 00:06:45 -0400 +Subject: [PATCH 2/3] Remove _M_IX86 checks + +--- + Main/StackWalker/StackWalker.h | 52 ---------------------------------- + 1 file changed, 52 deletions(-) + +diff --git a/Main/StackWalker/StackWalker.h b/Main/StackWalker/StackWalker.h +index 03efcec..89be951 100644 +--- a/Main/StackWalker/StackWalker.h ++++ b/Main/StackWalker/StackWalker.h +@@ -179,57 +179,6 @@ protected: + friend StackWalkerInternal; + }; // class StackWalker + +-// The "ugly" assembler-implementation is needed for systems before XP +-// If you have a new PSDK and you only compile for XP and later, then you can use +-// the "RtlCaptureContext" +-// Currently there is no define which determines the PSDK-Version... +-// So we just use the compiler-version (and assumes that the PSDK is +-// the one which was installed by the VS-IDE) +- +-// INFO: If you want, you can use the RtlCaptureContext if you only target XP and later... +-// But I currently use it in x64/IA64 environments... +-//#if defined(_M_IX86) && (_WIN32_WINNT <= 0x0500) && (_MSC_VER < 1400) +- +-#if defined(_M_IX86) +-#ifdef CURRENT_THREAD_VIA_EXCEPTION +-// TODO: The following is not a "good" implementation, +-// because the callstack is only valid in the "__except" block... +-#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \ +- do \ +- { \ +- memset(&c, 0, sizeof(CONTEXT)); \ +- EXCEPTION_POINTERS* pExp = NULL; \ +- __try \ +- { \ +- throw 0; \ +- } \ +- __except (((pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER \ +- : EXCEPTION_EXECUTE_HANDLER)) \ +- { \ +- } \ +- if (pExp != NULL) \ +- memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \ +- c.ContextFlags = contextFlags; \ +- } while (0); +-#else +-// clang-format off +-// The following should be enough for walking the callstack... +-#define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \ +- do \ +- { \ +- memset(&c, 0, sizeof(CONTEXT)); \ +- c.ContextFlags = contextFlags; \ +- __asm call x \ +- __asm x: pop eax \ +- __asm mov c.Eip, eax \ +- __asm mov c.Ebp, ebp \ +- __asm mov c.Esp, esp \ +- } while (0) +-// clang-format on +-#endif +- +-#else +- + // The following is defined for x86 (XP and higher), x64 and IA64: + #define GET_CURRENT_CONTEXT_STACKWALKER_CODEPLEX(c, contextFlags) \ + do \ +@@ -238,7 +187,6 @@ protected: + c.ContextFlags = contextFlags; \ + RtlCaptureContext(&c); \ + } while (0); +-#endif + + #endif //defined(_MSC_VER) + +-- +2.20.1.windows.1 + diff --git a/upstream_utils/stack_walker_patches/0003-Add-advapi-pragma.patch b/upstream_utils/stack_walker_patches/0003-Add-advapi-pragma.patch new file mode 100644 index 0000000000..89e3408d90 --- /dev/null +++ b/upstream_utils/stack_walker_patches/0003-Add-advapi-pragma.patch @@ -0,0 +1,24 @@ +From 61646f76602a77059c18298caa575b95b702c94c Mon Sep 17 00:00:00 2001 +From: PJ Reiniger +Date: Tue, 24 May 2022 01:24:31 -0400 +Subject: [PATCH 3/3] Add advapi pragma + +--- + Main/StackWalker/StackWalker.cpp | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/Main/StackWalker/StackWalker.cpp b/Main/StackWalker/StackWalker.cpp +index 48c7c57..6f0fbf2 100644 +--- a/Main/StackWalker/StackWalker.cpp ++++ b/Main/StackWalker/StackWalker.cpp +@@ -88,6 +88,7 @@ + #include + #include + #pragma comment(lib, "version.lib") // for "VerQueryValue" ++#pragma comment(lib, "Advapi32.lib") // for "GetUserName" + #pragma warning(disable : 4826) + + #ifdef UNICODE +-- +2.20.1.windows.1 + diff --git a/upstream_utils/update_stack_walker.py b/upstream_utils/update_stack_walker.py index 8f23f415b8..128fed5d4e 100755 --- a/upstream_utils/update_stack_walker.py +++ b/upstream_utils/update_stack_walker.py @@ -2,31 +2,48 @@ import os import shutil -import re -import requests -import tempfile -import urllib import subprocess from upstream_utils import setup_upstream_repo, comment_out_invalid_includes, walk_cwd_and_copy_if, am_patches, walk_if, copy_to +def crlf_to_lf(stackwalker_dir): + for root, _, files in os.walk(stackwalker_dir): + if ".git" in root: + continue + + for fname in files: + filename = os.path.join(root, fname) + print(f"Converting CRLF -> LF for {filename}") + with open(filename, 'rb') as f: + content = f.read() + content = content.replace(b'\r\n', b'\n') + + with open(filename, 'wb') as f: + f.write(content) + + subprocess.check_call(["git", "add", "-A"]) + subprocess.check_call(["git", "commit", "-m", "Fix line endings"]) + + def main(): root, repo = setup_upstream_repo( "https://github.com/JochenKalmbach/StackWalker", - "42e7a6e056a9e7aca911a7e9e54e2e4f90bc2652") + "42e7a6e056a9e7aca911a7e9e54e2e4f90bc2652", + shallow=False) wpiutil = os.path.join(root, "wpiutil") - pr35_url = "http://patch-diff.githubusercontent.com/raw/JochenKalmbach/StackWalker/pull/35.patch" - pr35_patch_download_path = os.path.join(tempfile.gettempdir(), - "stackwalker.patch") + # Run CRLF -> LF before trying any patches + crlf_to_lf(repo) - response = urllib.request.urlopen(pr35_url) - - with open(pr35_patch_download_path, 'wb') as f: - f.write(response.read()) - - am_patches(repo, [pr35_patch_download_path]) + # Apply patches to original git repo + patch_dir = os.path.join(root, "upstream_utils/stack_walker_patches") + am_patches(repo, [ + os.path.join(patch_dir, "0001-Apply-PR-35.patch"), + os.path.join(patch_dir, "0002-Remove-_M_IX86-checks.patch"), + os.path.join(patch_dir, "0003-Add-advapi-pragma.patch"), + ], + ignore_whitespce=True) shutil.copy(os.path.join("Main", "StackWalker", "StackWalker.h"), os.path.join(wpiutil, "src/main/native/windows/StackWalker.h")) diff --git a/upstream_utils/upstream_utils.py b/upstream_utils/upstream_utils.py index 062c21e2dd..f7b5edf7e0 100644 --- a/upstream_utils/upstream_utils.py +++ b/upstream_utils/upstream_utils.py @@ -62,7 +62,7 @@ def get_repo_root(): return "" -def setup_upstream_repo(url, treeish): +def setup_upstream_repo(url, treeish, shallow=True): """Clones the given upstream repository, then returns the root of the destination Git repository as well as the cloned upstream Git repository. @@ -78,7 +78,7 @@ def setup_upstream_repo(url, treeish): repo -- root directory of cloned upstream Git repository """ root = get_repo_root() - clone_repo(url, treeish) + clone_repo(url, treeish, shallow=shallow) return root, os.getcwd() @@ -208,7 +208,7 @@ def apply_patches(root, patches): subprocess.check_output(["git", "apply", patch]) -def am_patches(root, patches, use_threeway=False): +def am_patches(root, patches, use_threeway=False, ignore_whitespce=False): """Apply list of patches to the destination Git repository using "git am". Keyword arguments: @@ -219,6 +219,8 @@ def am_patches(root, patches, use_threeway=False): args = ["git", "am"] if use_threeway: args.append("-3") + if ignore_whitespce: + args.append("--ignore-whitespace") for patch in patches: subprocess.check_output(args + [patch]) diff --git a/wpiutil/src/main/native/windows/StackWalker.cpp b/wpiutil/src/main/native/windows/StackWalker.cpp index 237360a793..6f0fbf28a6 100644 --- a/wpiutil/src/main/native/windows/StackWalker.cpp +++ b/wpiutil/src/main/native/windows/StackWalker.cpp @@ -1,4 +1,4 @@ -/********************************************************************** +/********************************************************************** * * StackWalker.cpp * https://github.com/JochenKalmbach/StackWalker @@ -485,8 +485,8 @@ private: if (hToolhelp == NULL) continue; createToolhelp32Snapshot = (tCT32S)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot"); - module32First = (tM32F)GetProcAddress(hToolhelp, strModule32First); - module32Next = (tM32N)GetProcAddress(hToolhelp, strModule32Next); + module32First = (tM32F)GetProcAddress(hToolhelp, strModule32First); + module32Next = (tM32N)GetProcAddress(hToolhelp, strModule32Next); if ((createToolhelp32Snapshot != NULL) && (module32First != NULL) && (module32Next != NULL)) break; // found the functions! FreeLibrary(hToolhelp); diff --git a/wpiutil/src/main/native/windows/StackWalker.h b/wpiutil/src/main/native/windows/StackWalker.h index 750de96d8d..89be951624 100644 --- a/wpiutil/src/main/native/windows/StackWalker.h +++ b/wpiutil/src/main/native/windows/StackWalker.h @@ -1,3 +1,8 @@ +#ifndef __STACKWALKER_H__ +#define __STACKWALKER_H__ + +#if defined(_MSC_VER) + /********************************************************************** * * StackWalker.h @@ -32,6 +37,8 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * **********************************************************************/ +// #pragma once is supported starting with _MSC_VER 1000, +// so we need not to check the version (because we only support _MSC_VER >= 1100)! #pragma once #include @@ -105,7 +112,11 @@ public: BOOL ShowObject(LPVOID pObject); +#if _MSC_VER >= 1300 + // due to some reasons, the "STACKWALK_MAX_NAMELEN" must be declared as "public" + // in older compilers in order to use it... starting with VC7 we can declare it as "protected" protected: +#endif enum { STACKWALK_MAX_NAMELEN = 1024 @@ -176,3 +187,7 @@ protected: c.ContextFlags = contextFlags; \ RtlCaptureContext(&c); \ } while (0); + +#endif //defined(_MSC_VER) + +#endif // __STACKWALKER_H__