tools/build/src/engine/boehm_gc/msvc_dbg.c

   1 /*
   2   Copyright (c) 2004 Andrei Polushin
   3
   4   Permission is hereby granted, free of charge,  to any person obtaining a copy
   5   of this software and associated documentation files (the "Software"), to deal
   6   in the Software without restriction,  including without limitation the rights
   7   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8   copies of the Software, and to permit persons to whom the Software is
   9   furnished to do so, subject to the following conditions:
  10
  11   The above copyright notice and this permission notice shall be included in
  12   all copies or substantial portions of the Software.
  13
  14   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20   THE SOFTWARE.
  21 */
  22 #ifndef _M_AMD64
  23
  24 /* X86_64 is ccurrently missing some meachine-dependent code below. */
  25
  26 #include "private/msvc_dbg.h"
  27
  28 #define WIN32_LEAN_AND_MEAN
  29 #include <windows.h>
  30
  31 #pragma pack(push, 8)
  32 #include <imagehlp.h>
  33 #pragma pack(pop)
  34
  35 #pragma comment(lib, "dbghelp.lib")
  36 #pragma optimize("gy", off)
  37
  38 #ifdef _WIN64
  39         typedef ULONG_PTR ULONG_ADDR;
  40 #else
  41         typedef ULONG     ULONG_ADDR;
  42 #endif
  43
  44 static HANDLE GetSymHandle()
  45 {
  46         static HANDLE symHandle = NULL;
  47         if (!symHandle) {
  48                 BOOL bRet = SymInitialize(symHandle = GetCurrentProcess(), NULL, FALSE);
  49                 if (bRet) {
  50                         DWORD dwOptions = SymGetOptions();
  51                         dwOptions &= ~SYMOPT_UNDNAME;
  52                         dwOptions |= SYMOPT_LOAD_LINES;
  53                         SymSetOptions(dwOptions);
  54                 }
  55         }
  56         return symHandle;
  57 }
  58
  59 static void* CALLBACK FunctionTableAccess(HANDLE hProcess, ULONG_ADDR dwAddrBase)
  60 {
  61         return SymFunctionTableAccess(hProcess, dwAddrBase);
  62 }
  63
  64 static ULONG_ADDR CALLBACK GetModuleBase(HANDLE hProcess, ULONG_ADDR dwAddress)
  65 {
  66         MEMORY_BASIC_INFORMATION memoryInfo;
  67         ULONG_ADDR dwAddrBase = SymGetModuleBase(hProcess, dwAddress);
  68         if (dwAddrBase) {
  69                 return dwAddrBase;
  70         }
  71         if (VirtualQueryEx(hProcess, (void*)(ULONG_PTR)dwAddress, &memoryInfo, sizeof(memoryInfo))) {
  72                 char filePath[_MAX_PATH];
  73                 char curDir[_MAX_PATH];
  74                 char exePath[_MAX_PATH];
  75                 DWORD size = GetModuleFileNameA((HINSTANCE)memoryInfo.AllocationBase, filePath, sizeof(filePath));
  76
  77                 // Save and restore current directory around SymLoadModule, see KB article Q189780
  78                 GetCurrentDirectoryA(sizeof(curDir), curDir);
  79                 GetModuleFileNameA(NULL, exePath, sizeof(exePath));
  80                 strcat_s(exePath, sizeof(exePath), "\\..");
  81                 SetCurrentDirectoryA(exePath);
  82 #ifdef _DEBUG
  83                 GetCurrentDirectoryA(sizeof(exePath), exePath);
  84 #endif
  85                 SymLoadModule(hProcess, NULL, size ? filePath : NULL, NULL, (ULONG_ADDR)(ULONG_PTR)memoryInfo.AllocationBase, 0);
  86                 SetCurrentDirectoryA(curDir);
  87         }
  88         return (ULONG_ADDR)(ULONG_PTR)memoryInfo.AllocationBase;
  89 }
  90
  91 static ULONG_ADDR CheckAddress(void* address)
  92 {
  93         ULONG_ADDR dwAddress = (ULONG_ADDR)(ULONG_PTR)address;
  94         GetModuleBase(GetSymHandle(), dwAddress);
  95         return dwAddress;
  96 }
  97
  98 size_t GetStackFrames(size_t skip, void* frames[], size_t maxFrames)
  99 {
 100         HANDLE hProcess = GetSymHandle();
 101         HANDLE hThread = GetCurrentThread();
 102         CONTEXT context;
 103         context.ContextFlags = CONTEXT_FULL;
 104         if (!GetThreadContext(hThread, &context)) {
 105                 return 0;
 106         }
 107         // GetThreadContext might return invalid context for the current thread
 108 #if defined(_M_IX86)
 109     __asm mov context.Ebp, ebp
 110 #endif
 111         return GetStackFramesFromContext(hProcess, hThread, &context, skip + 1, frames, maxFrames);
 112 }
 113
 114 size_t GetStackFramesFromContext(HANDLE hProcess, HANDLE hThread, CONTEXT* context, size_t skip, void* frames[], size_t maxFrames)
 115 {
 116         size_t frameIndex;
 117         DWORD machineType;
 118         STACKFRAME stackFrame = { 0 };
 119         stackFrame.AddrPC.Mode      = AddrModeFlat;
 120 #if defined(_M_IX86)
 121         machineType                 = IMAGE_FILE_MACHINE_I386;
 122         stackFrame.AddrPC.Offset    = context->Eip;
 123         stackFrame.AddrStack.Mode   = AddrModeFlat;
 124         stackFrame.AddrStack.Offset = context->Esp;
 125         stackFrame.AddrFrame.Mode   = AddrModeFlat;
 126         stackFrame.AddrFrame.Offset = context->Ebp;
 127 #elif defined(_M_MRX000)
 128         machineType                 = IMAGE_FILE_MACHINE_R4000;
 129         stackFrame.AddrPC.Offset    = context->Fir;
 130 #elif defined(_M_ALPHA)
 131         machineType                 = IMAGE_FILE_MACHINE_ALPHA;
 132         stackFrame.AddrPC.Offset    = (unsigned long)context->Fir;
 133 #elif defined(_M_PPC)
 134         machineType                 = IMAGE_FILE_MACHINE_POWERPC;
 135         stackFrame.AddrPC.Offset    = context->Iar;
 136 #elif defined(_M_IA64)
 137         machineType                 = IMAGE_FILE_MACHINE_IA64;
 138         stackFrame.AddrPC.Offset    = context->StIIP;
 139 #elif defined(_M_ALPHA64)
 140         machineType                 = IMAGE_FILE_MACHINE_ALPHA64;
 141         stackFrame.AddrPC.Offset    = context->Fir;
 142 #else
 143 #error Unknown CPU
 144 #endif
 145         for (frameIndex = 0; frameIndex < maxFrames; ) {
 146                 BOOL bRet = StackWalk(machineType, hProcess, hThread, &stackFrame, &context, NULL, FunctionTableAccess, GetModuleBase, NULL);
 147                 if (!bRet) {
 148                         break;
 149                 }
 150                 if (skip) {
 151                         skip--;
 152                 } else {
 153                         frames[frameIndex++] = (void*)(ULONG_PTR)stackFrame.AddrPC.Offset;
 154                 }
 155         }
 156         return frameIndex;
 157 }
 158
 159 size_t GetModuleNameFromAddress(void* address, char* moduleName, size_t size)
 160 {
 161         if (size) *moduleName = 0;
 162         {
 163                 const char* sourceName;
 164                 IMAGEHLP_MODULE moduleInfo = { sizeof (moduleInfo) };
 165                 if (!SymGetModuleInfo(GetSymHandle(), CheckAddress(address), &moduleInfo)) {
 166                         return 0;
 167                 }
 168                 sourceName = strrchr(moduleInfo.ImageName, '\\');
 169                 if (sourceName) {
 170                         sourceName++;
 171                 } else {
 172                         sourceName = moduleInfo.ImageName;
 173                 }
 174                 if (size) {
 175                         strncpy(moduleName, sourceName, size)[size - 1] = 0;
 176                 }
 177                 return strlen(sourceName);
 178         }
 179 }
 180
 181 size_t GetModuleNameFromStack(size_t skip, char* moduleName, size_t size)
 182 {
 183         void* address = NULL;
 184         GetStackFrames(skip + 1, &address, 1);
 185         if (address) {
 186                 return GetModuleNameFromAddress(address, moduleName, size);
 187         }
 188         return 0;
 189 }
 190
 191 size_t GetSymbolNameFromAddress(void* address, char* symbolName, size_t size, size_t* offsetBytes)
 192 {
 193         if (size) *symbolName = 0;
 194         if (offsetBytes) *offsetBytes = 0;
 195         __try {
 196                 ULONG_ADDR dwOffset = 0;
 197                 union {
 198                         IMAGEHLP_SYMBOL sym;
 199                         char symNameBuffer[sizeof(IMAGEHLP_SYMBOL) + MAX_SYM_NAME];
 200                 } u;
 201                 u.sym.SizeOfStruct  = sizeof(u.sym);
 202                 u.sym.MaxNameLength = sizeof(u.symNameBuffer) - sizeof(u.sym);
 203
 204                 if (!SymGetSymFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset, &u.sym)) {
 205                         return 0;
 206                 } else {
 207                         const char* sourceName = u.sym.Name;
 208                         char undName[1024];
 209                         if (UnDecorateSymbolName(u.sym.Name, undName, sizeof(undName), UNDNAME_NO_MS_KEYWORDS | UNDNAME_NO_ACCESS_SPECIFIERS)) {
 210                                 sourceName = undName;
 211                         } else if (SymUnDName(&u.sym, undName, sizeof(undName))) {
 212                                 sourceName = undName;
 213                         }
 214                         if (offsetBytes) {
 215                                 *offsetBytes = dwOffset;
 216                         }
 217                         if (size) {
 218                                 strncpy(symbolName, sourceName, size)[size - 1] = 0;
 219                         }
 220                         return strlen(sourceName);
 221                 }
 222         } __except (EXCEPTION_EXECUTE_HANDLER) {
 223                 SetLastError(GetExceptionCode());
 224         }
 225         return 0;
 226 }
 227
 228 size_t GetSymbolNameFromStack(size_t skip, char* symbolName, size_t size, size_t* offsetBytes)
 229 {
 230         void* address = NULL;
 231         GetStackFrames(skip + 1, &address, 1);
 232         if (address) {
 233                 return GetSymbolNameFromAddress(address, symbolName, size, offsetBytes);
 234         }
 235         return 0;
 236 }
 237
 238 size_t GetFileLineFromAddress(void* address, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes)
 239 {
 240         if (size) *fileName = 0;
 241         if (lineNumber) *lineNumber = 0;
 242         if (offsetBytes) *offsetBytes = 0;
 243         {
 244                 char* sourceName;
 245                 IMAGEHLP_LINE line = { sizeof (line) };
 246                 ULONG_PTR dwOffset = 0;
 247                 if (!SymGetLineFromAddr(GetSymHandle(), CheckAddress(address), &dwOffset, &line)) {
 248                         return 0;
 249                 }
 250                 if (lineNumber) {
 251                         *lineNumber = line.LineNumber;
 252                 }
 253                 if (offsetBytes) {
 254                         *offsetBytes = dwOffset;
 255                 }
 256                 sourceName = line.FileName;
 257                 // TODO: resolve relative filenames, found in 'source directories' registered with MSVC IDE.
 258                 if (size) {
 259                         strncpy(fileName, sourceName, size)[size - 1] = 0;
 260                 }
 261                 return strlen(sourceName);
 262         }
 263 }
 264
 265 size_t GetFileLineFromStack(size_t skip, char* fileName, size_t size, size_t* lineNumber, size_t* offsetBytes)
 266 {
 267         void* address = NULL;
 268         GetStackFrames(skip + 1, &address, 1);
 269         if (address) {
 270                 return GetFileLineFromAddress(address, fileName, size, lineNumber, offsetBytes);
 271         }
 272         return 0;
 273 }
 274
 275 size_t GetDescriptionFromAddress(void* address, const char* format, char* buffer, size_t size)
 276 {
 277         char*const begin = buffer;
 278         char*const end = buffer + size;
 279         size_t line_number = 0;
 280         char   str[128];
 281
 282         if (size) {
 283                 *buffer = 0;
 284         }
 285         buffer += GetFileLineFromAddress(address, buffer, size, &line_number, NULL);
 286         size = end < buffer ? 0 : end - buffer;
 287
 288         if (line_number) {
 289                 wsprintf(str, "(%d) : ", line_number);
 290                 if (size) {
 291                         strncpy(buffer, str, size)[size - 1] = 0;
 292                 }
 293                 buffer += strlen(str);
 294                 size = end < buffer ? 0 : end - buffer;
 295         }
 296
 297         if (size) {
 298                 strncpy(buffer, "at ", size)[size - 1] = 0;
 299         }
 300         buffer += strlen("at ");
 301         size = end < buffer ? 0 : end - buffer;
 302
 303         buffer += GetSymbolNameFromAddress(address, buffer, size, NULL);
 304         size = end < buffer ? 0 : end - buffer;
 305
 306         if (size) {
 307                 strncpy(buffer, " in ", size)[size - 1] = 0;
 308         }
 309         buffer += strlen(" in ");
 310         size = end < buffer ? 0 : end - buffer;
 311
 312         buffer += GetModuleNameFromAddress(address, buffer, size);
 313         size = end < buffer ? 0 : end - buffer;
 314
 315         return buffer - begin;
 316 }
 317
 318 size_t GetDescriptionFromStack(void*const frames[], size_t count, const char* format, char* description[], size_t size)
 319 {
 320         char*const begin = (char*)description;
 321         char*const end = begin + size;
 322         char* buffer = begin + (count + 1) * sizeof(char*);
 323         size_t i;
 324         for (i = 0; i < count; ++i) {
 325                 if (description) description[i] = buffer;
 326                 size = end < buffer ? 0 : end - buffer;
 327                 buffer += 1 + GetDescriptionFromAddress(frames[i], NULL, buffer, size);
 328         }
 329         if (description) description[count] = NULL;
 330         return buffer - begin;
 331 }
 332
 333 /* Compatibility with <execinfo.h> */
 334
 335 int backtrace(void* addresses[], int count)
 336 {
 337         return GetStackFrames(1, addresses, count);
 338 }
 339
 340 char** backtrace_symbols(void*const* addresses, int count)
 341 {
 342         size_t size = GetDescriptionFromStack(addresses, count, NULL, NULL, 0);
 343         char** symbols = (char**)malloc(size);
 344         GetDescriptionFromStack(addresses, count, NULL, symbols, size);
 345         return symbols;
 346 }
 347
 348 #endif /* !_M_AMD64 */