CBaseException Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/dev-utils/BaseException.h>

Inheritance diagram for CBaseException:

Collaboration diagram for CBaseException:

Public Member Functions
	CBaseException (HANDLE hProcess=GetCurrentProcess(), WORD wPID=GetCurrentProcessId(), LPCTSTR lpSymbolPath=NULL, PEXCEPTION_POINTERS pEp=NULL)
	~CBaseException (void)
virtual void	OutputString (LPCTSTR lpszFormat,...)
virtual void	ShowLoadModules ()
virtual void	ShowCallstack (HANDLE hThread=GetCurrentThread(), const CONTEXT *context=NULL)
virtual void	ShowExceptionResoult (DWORD dwExceptionCode)
virtual BOOL	GetLogicalAddress (PVOID addr, PTSTR szModule, DWORD len, DWORD &section, DWORD &offset)
virtual void	ShowRegistorInformation (PCONTEXT pCtx)
virtual void	ShowExceptionInformation ()
BOOL	LoadSymbol ()
LPMODULE_INFO	GetLoadModules ()
void	GetModuleInformation (LPMODULE_INFO pmi)
void	FreeModuleInformations (LPMODULE_INFO pmi)
LPSTACKINFO	StackWalker (HANDLE hThread=GetCurrentThread(), const CONTEXT *context=NULL)
void	FreeStackInformations (LPSTACKINFO psi)

Static Public Member Functions
static LONG WINAPI	UnhandledExceptionFilter (PEXCEPTION_POINTERS pExceptionInfo)
static LONG WINAPI	UnhandledExceptionFilter2 (PEXCEPTION_POINTERS pExceptionInfo)
static void	STF (unsigned int ui, PEXCEPTION_POINTERS pEp)
static void	set_log_folder (std::string log_folder)

Protected Member Functions
LPMODULE_INFO	GetModulesTH32 ()
LPMODULE_INFO	GetModulesPSAPI ()

Protected Attributes
PEXCEPTION_POINTERS	m_pEp
boost::nowide::ofstream *	output_file
HANDLE	m_hProcess
WORD	m_wPID
LPTSTR	m_lpszSymbolPath
BOOL	m_bSymbolLoaded

Detailed Description

Constructor & Destructor Documentation

CBaseException()

CBaseException::CBaseException	(	HANDLE	hProcess = GetCurrentProcess(),
		WORD	wPID = GetCurrentProcessId(),
		LPCTSTR	lpSymbolPath = NULL,
		PEXCEPTION_POINTERS	pEp = NULL )

                                                                                                       :
  CStackWalker(hProcess, wPID, lpSymbolPath)
{
  if (NULL != pEp)
  {
    m_pEp = new EXCEPTION_POINTERS;
    CopyMemory(m_pEp, pEp, sizeof(EXCEPTION_POINTERS));
  }
  output_file = new boost::nowide::ofstream();
  std::time_t t = std::time(0);
  std::tm* now_time = std::localtime(&t);
  std::stringstream buf;
 
  if (!g_log_folder.empty()) {
    buf << std::put_time(now_time, "crash_%a_%b_%d_%H_%M_%S_") <<g_crash_log_count++ <<".log";
    auto log_folder = (boost::filesystem::path(g_log_folder) / "log").make_preferred();
    if (!boost::filesystem::exists(log_folder)) {
        boost::filesystem::create_directory(log_folder);
      }
    auto crash_log_path = boost::filesystem::path(log_folder / buf.str()).make_preferred();
    std::string log_filename = crash_log_path.string();
    output_file->open(log_filename, std::ios::out | std::ios::app);
 
    // Output app build info in crash log so we could look for the correct PDB files
        OutputString(_T("%s\n\n"), _T(SLIC3R_APP_NAME " " SoftFever_VERSION " Build " GIT_COMMIT_HASH GIT_COMMIT_SUFFIX));
  }
}

References CStackWalker::CStackWalker(), g_crash_log_count, g_log_folder, m_pEp, output_file, and OutputString().

Referenced by STF(), UnhandledExceptionFilter(), and UnhandledExceptionFilter2().

Here is the call graph for this function:

Here is the caller graph for this function:

~CBaseException()

CBaseException::~CBaseException

(

void

)

{
  if (output_file) {
    output_file->close();
    delete output_file;
  }
}

References output_file.

Member Function Documentation

FreeModuleInformations()

void CStackWalker::FreeModuleInformations ( LPMODULE_INFO pmi )

inherited

{
  LPMODULE_INFO head = pmi;
  while (NULL != head)
  {
    pmi = pmi->pNext;
    delete head;
    head = pmi;
  }
}

References _tag_MODULE_INFO::pNext.

Referenced by CBaseException::ShowLoadModules().

Here is the caller graph for this function:

FreeStackInformations()

void CStackWalker::FreeStackInformations ( LPSTACKINFO psi )

inherited

{
  LPSTACKINFO head = psi;
  while (NULL != head)
  {
    psi = psi->pNext;
    delete head;
    head = psi;
  }
 
}

References tagSTACKINFO::pNext.

Referenced by CBaseException::ShowCallstack().

Here is the caller graph for this function:

GetLoadModules()

LPMODULE_INFO CStackWalker::GetLoadModules ( )

inherited

{
  LPMODULE_INFO pHead = GetModulesTH32();
  if (NULL == pHead)
  {
    pHead = GetModulesPSAPI();
  }
 
  return pHead;
}

References GetModulesPSAPI(), and GetModulesTH32().

Referenced by CBaseException::ShowLoadModules().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLogicalAddress()

BOOL CBaseException::GetLogicalAddress ( PVOID addr, PTSTR szModule, DWORD len, DWORD & section, DWORD & offset )

virtual

{
  MEMORY_BASIC_INFORMATION mbi;
 
  if ( !VirtualQuery( addr, &mbi, sizeof(mbi) ) )
    return FALSE;
 
  DWORD_PTR hMod = (DWORD_PTR)mbi.AllocationBase;
 
  if ( !GetModuleFileName( (HMODULE)hMod, szModule, len ) )
    return FALSE;
 
  if (!hMod)
    return FALSE;
 
  PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)hMod;
  PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(hMod + pDosHdr->e_lfanew);
  PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION( pNtHdr );
 
  DWORD_PTR rva = (DWORD_PTR)addr - hMod;
 
  //���㵱ǰ��ַ�ڵڼ�����
  for (unsigned i = 0; i < pNtHdr->FileHeader.NumberOfSections; i++, pSection++ )
  {
    DWORD sectionStart = pSection->VirtualAddress;
    DWORD sectionEnd = sectionStart + std::max(pSection->SizeOfRawData, pSection->Misc.VirtualSize);
 
    if ( (rva >= sectionStart) && (rva <= sectionEnd) )
    {
      section = i+1;
      offset = rva - sectionStart;
      return TRUE;
    }
  }
 
  return FALSE;   // Should never get here!
}

Referenced by ShowCallstack(), and ShowExceptionInformation().

Here is the caller graph for this function:

GetModuleInformation()

void CStackWalker::GetModuleInformation ( LPMODULE_INFO pmi )

inherited

{
  //USES_CONVERSION;
  IMAGEHLP_MODULE64  im = {0};
  im.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
 
  VS_FIXEDFILEINFO* pvfi = NULL;
  DWORD dwHandle = 0;
  DWORD dwInfoSize = 0;
  dwInfoSize = GetFileVersionInfoSize(pmi->szModulePath, &dwHandle);
 
  if (dwInfoSize > 0)
  {
    byte *lpData = new byte[dwInfoSize];
    ZeroMemory(lpData, dwInfoSize * sizeof(byte));
 
    if (GetFileVersionInfo(pmi->szModulePath, dwHandle, dwInfoSize, lpData) > 0 )
    {
      TCHAR szBlock[] = _T("\\");
      UINT  len;
      if (VerQueryValue(lpData, szBlock, (LPVOID*)&pvfi, &len))
      {
        WORD v1 = HIWORD(pvfi->dwFileVersionMS);
        WORD v2 = LOWORD(pvfi->dwFileVersionMS);
        WORD v3 = HIWORD(pvfi->dwFileVersionLS);
        WORD v4 = LOWORD(pvfi->dwFileVersionLS);
        _stprintf_s(pmi->szVersion, MAX_VERSION_LENGTH, _T("%d.%d.%d.%d"), v1, v2, v3, v4);
      }
    }
 
    delete[] lpData;
  }
 
  SymGetModuleInfo64(m_hProcess, pmi->ModuleAddress, &im);
  StringCchCopy(pmi->szSymbolPath, MAX_PATH, textconv_helper::A2T_(im.LoadedPdbName));
}

References m_hProcess, MAX_VERSION_LENGTH, _tag_MODULE_INFO::ModuleAddress, _tag_MODULE_INFO::szModulePath, _tag_MODULE_INFO::szSymbolPath, and _tag_MODULE_INFO::szVersion.

Referenced by GetModulesPSAPI(), and GetModulesTH32().

Here is the caller graph for this function:

GetModulesPSAPI()

LPMODULE_INFO CStackWalker::GetModulesPSAPI ( )

protectedinherited

{
  LPMODULE_INFO pHead = NULL;
  LPMODULE_INFO pTail = pHead;
  typedef BOOL(WINAPI *pfnEnumProcessModules)(HANDLE hProcess, HMODULE * lphModule, DWORD cb,LPDWORD lpcbNeeded);
  typedef DWORD(WINAPI *pfnGetModuleFileNameEx)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize);
  typedef DWORD(WINAPI *pfnGetModuleBaseName)(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize);
  typedef BOOL(WINAPI *pfnGetModuleInformation)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize);
 
  HINSTANCE hPsapi;
  pfnEnumProcessModules EnumProcessModules = NULL;
  pfnGetModuleFileNameEx GetModuleFileNameEx = NULL;
  pfnGetModuleBaseName GetModuleBaseName = NULL;
  pfnGetModuleInformation GetModuleInformation = NULL;
 
  DWORD i;
  //ModuleEntry e;
  DWORD        cbNeeded;
  MODULEINFO   mi;
  HMODULE*     hMods = NULL;
  TCHAR szModuleName[MAX_MODULE_NAME32 + 1] = _T("");
  TCHAR szModulePath[MAX_PATH] = _T("");
 
  hPsapi = LoadLibrary(_T("psapi.dll"));
  if (hPsapi == NULL)
  {
    return pHead;
  }
 
  EnumProcessModules = (pfnEnumProcessModules)GetProcAddress(hPsapi, "EnumProcessModules");
#ifdef UNICODE
  GetModuleFileNameEx = (pfnGetModuleFileNameEx)GetProcAddress(hPsapi, "GetModuleFileNameExW");
  GetModuleBaseName = (pfnGetModuleBaseName)GetProcAddress(hPsapi, "GetModuleBaseNameW");
#else
  GetModuleFileNameEx = (pfnGetModuleFileNameEx)GetProcAddress(hPsapi, "GetModuleFileNameExA");
  GetModuleBaseName = (pfnGetModuleBaseName)GetProcAddress(hPsapi, "GetModuleBaseNameA");
#endif
  GetModuleInformation = (pfnGetModuleInformation)GetProcAddress(hPsapi, "GetModuleInformation");
  if ((EnumProcessModules == NULL) || (GetModuleFileNameEx == NULL) || (GetModuleBaseName == NULL) || (GetModuleInformation == NULL))
  {
    FreeLibrary(hPsapi);
    return pHead;
  }
  
  EnumProcessModules(m_hProcess, hMods, 0, &cbNeeded);
  hMods = new HMODULE[cbNeeded / sizeof(HMODULE)];
  ASSERT(NULL != hMods);
  ZeroMemory(hMods, cbNeeded);
 
  if (!EnumProcessModules(m_hProcess, hMods, cbNeeded, &cbNeeded))
  {
    goto cleanup;
  }
 
  for (i = 0; i < cbNeeded / sizeof(HMODULE); i++)
  {
    GetModuleInformation(m_hProcess, hMods[i], &mi, sizeof(mi));
    GetModuleFileNameEx(m_hProcess, hMods[i], szModulePath, MAX_PATH);
    GetModuleBaseName(m_hProcess, hMods[i], szModuleName, MAX_MODULE_NAME32);
    LPMODULE_INFO pmi = new MODULE_INFO;
    ZeroMemory(pmi, sizeof(MODULE_INFO));
    pmi->dwModSize = mi.SizeOfImage;
    pmi->ModuleAddress = (DWORD64)mi.lpBaseOfDll;
    StringCchCopy(pmi->szModuleName, MAX_MODULE_NAME32, szModuleName);
    StringCchCopy(pmi->szModulePath, MAX_PATH, szModulePath);
    this->GetModuleInformation(pmi);
    if (pHead == NULL)
    {
      pHead = pmi;
      pTail = pHead;
    }else
    {
      pTail->pNext = pmi;
      pTail = pmi;
    }
  }
 
cleanup:
  if (hPsapi != NULL)
  {
    FreeLibrary(hPsapi);
  }
  if (hMods != NULL)
  {
    delete[] hMods;
  }
 
  return pHead;
}

References ASSERT, _tag_MODULE_INFO::dwModSize, GetModuleInformation(), _MODULEINFO::lpBaseOfDll, m_hProcess, MAX_MODULE_NAME32, _tag_MODULE_INFO::ModuleAddress, _tag_MODULE_INFO::pNext, _MODULEINFO::SizeOfImage, _tag_MODULE_INFO::szModuleName, and _tag_MODULE_INFO::szModulePath.

Referenced by GetLoadModules().

Here is the call graph for this function:

Here is the caller graph for this function:

GetModulesTH32()

LPMODULE_INFO CStackWalker::GetModulesTH32 ( )

protectedinherited

{
  //这里为了防止加载Toolhelp.dll 影响最终结果，所以采用动态加载的方式
  LPMODULE_INFO pHead = NULL;
  LPMODULE_INFO pTail = pHead;
 
  typedef HANDLE (WINAPI *pfnCreateToolhelp32Snapshot)(DWORD dwFlags, DWORD th32ProcessID);
  typedef BOOL (WINAPI *pfnModule32First)(HANDLE hSnapshot, LPMODULEENTRY32 lpme );
  typedef BOOL (WINAPI *pfnModule32Next)(HANDLE hSnapshot, LPMODULEENTRY32 lpme );
 
  const TCHAR* dllname[] = {_T("kernel32.dll"), _T("tlhelp32.dll")};
  HINSTANCE    hToolhelp = NULL;
 
  pfnCreateToolhelp32Snapshot CreateToolhelp32Snapshot = NULL;
  pfnModule32First Module32First = NULL;
  pfnModule32Next Module32Next = NULL;
 
  HANDLE        hSnap;
  MODULEENTRY32 me;
  me.dwSize = sizeof(me);
  BOOL   keepGoing;
  size_t i;
 
  for (i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++)
  {
    hToolhelp = LoadLibrary(dllname[i]);
    if (hToolhelp == NULL)
      continue;
    CreateToolhelp32Snapshot = (pfnCreateToolhelp32Snapshot)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
#ifdef UNICODE
    Module32First = (pfnModule32First)GetProcAddress(hToolhelp, "Module32FirstW");
    Module32Next = (pfnModule32Next)GetProcAddress(hToolhelp, "Module32NextW");
#else
    Module32First = (pfnModule32First)GetProcAddress(hToolhelp, "Module32FirstA");
    Module32Next = (pfnModule32Next)GetProcAddress(hToolhelp, "Module32NextA");
#endif
 
    if ((CreateToolhelp32Snapshot != NULL) && (Module32First != NULL) && (Module32Next != NULL))
      break;
 
    FreeLibrary(hToolhelp);
    hToolhelp = NULL;
  }
 
  if (hToolhelp == NULL)
    return pHead;
 
  hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, m_wPID);
 
  if (hSnap == INVALID_HANDLE_VALUE)
  {
    FreeLibrary(hToolhelp);
    return pHead;
  }
 
  keepGoing = Module32First(hSnap, &me);
 
  while (keepGoing)
  {
    LPMODULE_INFO pmi = new MODULE_INFO;
    ZeroMemory(pmi, sizeof(MODULE_INFO));
 
    pmi->dwModSize = me.modBaseSize;
    pmi->ModuleAddress = (DWORD64)me.modBaseAddr;
    StringCchCopy(pmi->szModuleName, MAX_MODULE_NAME32, me.szModule);
    StringCchCopy(pmi->szModulePath, MAX_PATH, me.szExePath);
    GetModuleInformation(pmi);
    if (pHead == NULL)
    {
      pHead = pmi;
      pTail = pHead;
    }else
    {
      pTail->pNext = pmi;
      pTail = pmi;
    }
 
    keepGoing = Module32Next(hSnap, &me);
  }
 
  CloseHandle(hSnap);
  FreeLibrary(hToolhelp);
  return pHead;
}

References _tag_MODULE_INFO::dwModSize, tagMODULEENTRY32::dwSize, GetModuleInformation(), m_wPID, MAX_MODULE_NAME32, tagMODULEENTRY32::modBaseAddr, tagMODULEENTRY32::modBaseSize, _tag_MODULE_INFO::ModuleAddress, _tag_MODULE_INFO::pNext, tagMODULEENTRY32::szExePath, tagMODULEENTRY32::szModule, _tag_MODULE_INFO::szModuleName, _tag_MODULE_INFO::szModulePath, and TH32CS_SNAPMODULE.

Referenced by GetLoadModules().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadSymbol()

BOOL CStackWalker::LoadSymbol ( )

inherited

{
  //USES_CONVERSION;
  //只加载一次
  if(m_bSymbolLoaded)
  {
    return m_bSymbolLoaded;
  }
 
  if (NULL != m_lpszSymbolPath)
  {
    
    m_bSymbolLoaded = SymInitialize(m_hProcess, textconv_helper::T2A_(m_lpszSymbolPath), FALSE);
    return m_bSymbolLoaded;
  }
  
  //添加当前程序路径
  TCHAR szSymbolPath[MAX_SYMBOL_PATH] = _T("");
  StringCchCopy(szSymbolPath, MAX_SYMBOL_PATH, _T(".;"));
 
  //添加程序所在目录
  TCHAR szTemp[MAX_PATH] = _T("");
  if (GetCurrentDirectory(MAX_PATH, szTemp) > 0)
  {
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
  }
 
  //添加程序主模块所在路径
  ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
  if (GetModuleFileName(NULL, szTemp, MAX_PATH) > 0)
  {
    size_t sLength = 0;
    StringCchLength(szTemp, MAX_PATH, &sLength);
    for (int i = sLength; i >= 0; i--)
    {
      if (szTemp[i] == _T('\\') || szTemp[i] == _T('/') || szTemp[i] == _T(':'))
      {
        szTemp[i] = _T('\0');
        break;
      }
    }
  }
 
  StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
  StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
  
  ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
  if (GetEnvironmentVariable(_T("_NT_SYMBOL_PATH"), szTemp, MAX_PATH) > 0)
  {
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
  }
 
  ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
  if (GetEnvironmentVariable(_T("_NT_ALTERNATE_SYMBOL_PATH"), szTemp, MAX_PATH) > 0)
  {
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
  }
 
  ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
  if (GetEnvironmentVariable(_T("SYSTEMROOT"), szTemp, MAX_PATH) > 0)
  {
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
    // also add the "system32"-directory:
    StringCchCat(szTemp, MAX_PATH, _T("\\system32"));
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T(";"));
  }
 
  ZeroMemory(szTemp, MAX_PATH * sizeof(TCHAR));
  if (GetEnvironmentVariable(_T("SYSTEMDRIVE"), szTemp, MAX_PATH) > 0)
  {
      StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("SRV*"));
      StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, szTemp);
      StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("\\websymbols"));
      StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("*http://msdl.microsoft.com/download/symbols;"));
  }
  else
  {
    StringCchCat(szSymbolPath, MAX_SYMBOL_PATH, _T("SRV*c:\\websymbols*http://msdl.microsoft.com/download/symbols;"));
  }
 
  size_t sLength = 0;
  StringCchLength(szSymbolPath, MAX_SYMBOL_PATH, &sLength);
  if (sLength > 0)
  {
    m_lpszSymbolPath = new TCHAR[sLength + 1];
    ZeroMemory(m_lpszSymbolPath, sizeof(TCHAR) * (sLength + 1));
    StringCchCopy(m_lpszSymbolPath, sLength, szSymbolPath);
  }
 
  if (NULL != m_lpszSymbolPath)
  {
    m_bSymbolLoaded = SymInitialize(m_hProcess, textconv_helper::T2A_(m_lpszSymbolPath), TRUE); //这里设置为TRUE，让它在初始化符号表的同时加载符号表
  }
 
  DWORD symOptions = SymGetOptions();
  symOptions |= SYMOPT_LOAD_LINES;
  symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;
  symOptions |= SYMOPT_DEBUG;
  SymSetOptions(symOptions);
 
  return m_bSymbolLoaded;
}

References m_bSymbolLoaded, m_hProcess, m_lpszSymbolPath, and MAX_SYMBOL_PATH.

Referenced by CBaseException::ShowLoadModules(), and StackWalker().

Here is the caller graph for this function:

OutputString()

void CBaseException::OutputString ( LPCTSTR lpszFormat, ... )

virtual

Reimplemented from CStackWalker.

{
  TCHAR szBuf[2048] = _T("");
  va_list args;
  va_start(args, lpszFormat);
  _vsntprintf_s(szBuf, 2048, lpszFormat, args);
  va_end(args);
 
  //WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), szBuf, _tcslen(szBuf), NULL, NULL);
 
  //output it to the current directory of binary
    std::string output_str = static_cast<const char*>(textconv_helper::T2A_(szBuf));
  *output_file << output_str;
  output_file->flush();
}

References output_file.

Referenced by CBaseException(), ShowCallstack(), ShowExceptionInformation(), ShowExceptionResoult(), ShowLoadModules(), and ShowRegistorInformation().

Here is the caller graph for this function:

set_log_folder()

void CBaseException::set_log_folder ( std::string log_folder )

static

{
  g_log_folder = log_folder;
}

References g_log_folder.

Referenced by Slic3r::GUI::GUI_App::on_init_inner().

Here is the caller graph for this function:

ShowCallstack()

void CBaseException::ShowCallstack ( HANDLE hThread = GetCurrentThread(), const CONTEXT * context = NULL )

virtual

{
  OutputString(_T("Show CallStack:\n"));
    LPSTACKINFO phead = StackWalker(hThread, context);
 
  // Show RVA of each call stack, so we can locate the symbol using pdb file
  // To show the symbol, load the <szFaultingModule> in WinDBG with pdb file, then type the following commands:
  // > lm                                                                   which gives you the start address of each module, as well as module names
  // > !dh <module name>                                                    list all module headers. Find the <virtual address> of the section given by
  //                                                                        the <section> output in the crash log
  // > ln <module start address> + <section virtual address> + <offset>     reveals the debug symbol
    OutputString(_T("\nLogical Address:\n"));
    TCHAR szFaultingModule[MAX_PATH];
    DWORD section, offset;
    for (LPSTACKINFO ps = phead; ps != nullptr; ps = ps->pNext) {
        if (GetLogicalAddress((PVOID) ps->szFncAddr, szFaultingModule, sizeof(szFaultingModule), section, offset)) {
            OutputString(_T("0x%X 0x%X:0x%X %s\n"), ps->szFncAddr, section, offset, szFaultingModule);
        } else {
            OutputString(_T("0x%X Unknown\n"), ps->szFncAddr);
        }
    }
 
  FreeStackInformations(phead);
}

References CStackWalker::FreeStackInformations(), GetLogicalAddress(), OutputString(), tagSTACKINFO::pNext, and CStackWalker::StackWalker().

Referenced by ShowExceptionInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowExceptionInformation()

void CBaseException::ShowExceptionInformation ( )

virtual

{
  OutputString(_T("Exceptions:\r\n"));
  ShowExceptionResoult(m_pEp->ExceptionRecord->ExceptionCode);
 
  OutputString(_T("Exception Flag :0x%x "), m_pEp->ExceptionRecord->ExceptionFlags);
  OutputString(_T("NumberParameters :%ld \n"), m_pEp->ExceptionRecord->NumberParameters);
  for (int i = 0; i < m_pEp->ExceptionRecord->NumberParameters; i++)
  {
    OutputString(_T("Param %d :0x%x \n"), i, m_pEp->ExceptionRecord->ExceptionInformation[i]);
  }
  OutputString(_T("Context :%p \n"), m_pEp->ContextRecord);
#if defined(_M_ARM64)
    OutputString(_T("ContextFlag : 0x%x, Cpsr: 0x%x \n"), m_pEp->ContextRecord->ContextFlags, m_pEp->ContextRecord->Cpsr);
#else
    OutputString(_T("ContextFlag : 0x%x, EFlags: 0x%x \n"), m_pEp->ContextRecord->ContextFlags, m_pEp->ContextRecord->EFlags);
#endif
 
  TCHAR szFaultingModule[MAX_PATH];
  DWORD section, offset;
  GetLogicalAddress(m_pEp->ExceptionRecord->ExceptionAddress, szFaultingModule, sizeof(szFaultingModule), section, offset );
  OutputString( _T("Fault address:  0x%X 0x%X:0x%X %s\r\n"), m_pEp->ExceptionRecord->ExceptionAddress, section, offset, szFaultingModule );
 
  ShowRegistorInformation(m_pEp->ContextRecord);
 
  ShowCallstack(GetCurrentThread(), m_pEp->ContextRecord);
}

References GetLogicalAddress(), m_pEp, OutputString(), ShowCallstack(), ShowExceptionResoult(), and ShowRegistorInformation().

Referenced by UnhandledExceptionFilter(), and UnhandledExceptionFilter2().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowExceptionResoult()

void CBaseException::ShowExceptionResoult ( DWORD dwExceptionCode )

virtual

{
  OutputString(_T("Exception Code :%08x "), dwExceptionCode);
// BBS: to be checked
#if 1
  switch (dwExceptionCode)
  {
  case EXCEPTION_ACCESS_VIOLATION:
    {
      //OutputString(_T("ACCESS_VIOLATION(%s)\r\n"), _T("��д�Ƿ��ڴ�"));
      OutputString(_T("ACCESS_VIOLATION\r\n"));
    }
    return ;
  case EXCEPTION_DATATYPE_MISALIGNMENT:
    {
      //OutputString(_T("DATATYPE_MISALIGNMENT(%s)\r\n"), _T("�߳���ͼ�ڲ�֧�ֶ����Ӳ���϶�дδ���������"));
      OutputString(_T("DATATYPE_MISALIGNMENT\r\n"));
    }
    return ;
  case EXCEPTION_BREAKPOINT:
    {
      //OutputString(_T("BREAKPOINT(%s)\r\n"), _T("����һ���ϵ�"));
      OutputString(_T("BREAKPOINT\r\n"));
    }
    return ;
  case EXCEPTION_SINGLE_STEP:
    {
      //OutputString(_T("SINGLE_STEP(%s)\r\n"), _T("����")); //һ���Ƿ����ڵ����¼���
      OutputString(_T("SINGLE_STEP\r\n"));
    }
    return ;
  case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
    {
      //OutputString(_T("ARRAY_BOUNDS_EXCEEDED(%s)\r\n"), _T("�������Խ��"));
      OutputString(_T("ARRAY_BOUNDS_EXCEEDED\r\n"));
    }
    return ;
  case EXCEPTION_FLT_DENORMAL_OPERAND:
    {
      //OutputString(_T("FLT_DENORMAL_OPERAND(%s)\r\n"), _T("���������һ�������������棬�����ĸ������޷���ʾ")); //������������
      OutputString(_T("FLT_DENORMAL_OPERAND\r\n"));
    }
    return ;
  case EXCEPTION_FLT_DIVIDE_BY_ZERO:
    {
      //OutputString(_T("FLT_DIVIDE_BY_ZERO(%s)\r\n"), _T("��������0����"));
      OutputString(_T("FLT_DIVIDE_BY_ZERO\r\n"));
    }
    return ;
  case EXCEPTION_FLT_INEXACT_RESULT:
    {
      //OutputString(_T("FLT_INEXACT_RESULT(%s)\r\n"), _T("�����������Ľ���޷���ʾ")); //�޷���ʾһ��������̫С��������������ʾ�ķ�Χ, ����֮������Ľ���쳣
      OutputString(_T("FLT_INEXACT_RESULT\r\n"));
    }
    return ;
  case EXCEPTION_FLT_INVALID_OPERATION:
    {
      //OutputString(_T("FLT_INVALID_OPERATION(%s)\r\n"), _T("�����������쳣"));
      OutputString(_T("FLT_INVALID_OPERATION\r\n"));
    }
    return ;
  case EXCEPTION_FLT_OVERFLOW:
    {
      //OutputString(_T("FLT_OVERFLOW(%s)\r\n"), _T("���������ָ����������Ӧ���͵����ֵ"));
      OutputString(_T("FLT_OVERFLOW\r\n"));
    }
    return ;
  case EXCEPTION_FLT_STACK_CHECK:
    {
      //OutputString(_T("STACK_CHECK(%s)\r\n"), _T("ջԽ�����ջ�������"));
      OutputString(_T("STACK_CHECK\r\n"));
    }
    return ;
  case EXCEPTION_INT_DIVIDE_BY_ZERO:
    {
      //OutputString(_T("INT_DIVIDE_BY_ZERO(%s)\r\n"), _T("������0�쳣"));
      OutputString(_T("INT_DIVIDE_BY_ZERO\r\n"));
    }
    return ;
  case EXCEPTION_INVALID_HANDLE:
    {
      //OutputString(_T("INVALID_HANDLE(%s)\r\n"), _T("�����Ч"));
      OutputString(_T("INVALID_HANDLE\r\n"));
    }
    return ;
  case EXCEPTION_PRIV_INSTRUCTION:
    {
      //OutputString(_T("PRIV_INSTRUCTION(%s)\r\n"), _T("�߳���ͼִ�е�ǰ����ģʽ��֧�ֵ�ָ��"));
      OutputString(_T("PRIV_INSTRUCTION\r\n"));
    }
    return ;
  case EXCEPTION_IN_PAGE_ERROR:
    {
      //OutputString(_T("IN_PAGE_ERROR(%s)\r\n"), _T("�߳���ͼ����δ���ص������ڴ�ҳ���߲��ܼ��ص������ڴ�ҳ"));
      OutputString(_T("IN_PAGE_ERROR\r\n"));
    }
    return ;
  case EXCEPTION_ILLEGAL_INSTRUCTION:
    {
      //OutputString(_T("ILLEGAL_INSTRUCTION(%s)\r\n"), _T("�߳���ͼִ����Чָ��"));
      OutputString(_T("ILLEGAL_INSTRUCTION\r\n"));
    }
    return ;
  case EXCEPTION_NONCONTINUABLE_EXCEPTION:
    {
      //OutputString(_T("NONCONTINUABLE_EXCEPTION(%s)\r\n"), _T("�߳���ͼ��һ�����ɼ���ִ�е��쳣���������ִ��"));
      OutputString(_T("NONCONTINUABLE_EXCEPTION\r\n"));
    }
    return ;
  case EXCEPTION_STACK_OVERFLOW:
    {
      //OutputString(_T("STACK_OVERFLOW(%s)\r\n"), _T("ջ���"));
      OutputString(_T("STACK_OVERFLOW\r\n"));
    }
    return ;
  case EXCEPTION_INVALID_DISPOSITION:
    {
      //OutputString(_T("INVALID_DISPOSITION(%s)\r\n"), _T("�쳣���������쳣������������һ����Ч����")); //ʹ�ø߼����Ա�д�ij�����Զ������������쳣
      OutputString(_T("INVALID_DISPOSITION\r\n"));
    }
    return ;
  case EXCEPTION_FLT_UNDERFLOW:
    {
      //OutputString(_T("FLT_UNDERFLOW(%s)\r\n"), _T("������������ָ��С����Ӧ���͵���Сֵ"));
      OutputString(_T("FLT_UNDERFLOW\r\n"));
    }
    return ;
  case EXCEPTION_INT_OVERFLOW:
    {
      //OutputString(_T("INT_OVERFLOW(%s)\r\n"), _T("��������Խ��"));
      OutputString(_T("INT_OVERFLOW\r\n"));
    }
    return ;
  }
 
  TCHAR szBuffer[512] = { 0 };
 
  FormatMessage(  FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_HMODULE,
    GetModuleHandle( _T("NTDLL.DLL") ),
    dwExceptionCode, 0, szBuffer, sizeof( szBuffer ), 0 );
 
  OutputString(_T("%s"), szBuffer);
  OutputString(_T("\r\n"));
#endif
}

References OutputString().

Referenced by ShowExceptionInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

ShowLoadModules()

void CBaseException::ShowLoadModules ( )

virtual

{
  LoadSymbol();
  LPMODULE_INFO pHead = GetLoadModules();
  LPMODULE_INFO pmi = pHead;
 
  TCHAR szBuf[MAX_COMPUTERNAME_LENGTH] = _T("");
  DWORD dwSize = MAX_COMPUTERNAME_LENGTH;
  GetUserName(szBuf, &dwSize);
  OutputString(_T("Current User:%s\r\n"), szBuf);
  OutputString(_T("BaseAddress:\tSize:\tName\tPath\tSymbolPath\tVersion\r\n"));
  while (NULL != pmi)
  {
    OutputString(_T("%08x\t%d\t%s\t%s\t%s\t%s\r\n"), (unsigned long)(pmi->ModuleAddress), pmi->dwModSize, pmi->szModuleName, pmi->szModulePath, pmi->szSymbolPath, pmi->szVersion);
    pmi = pmi->pNext;
  }
 
  FreeModuleInformations(pHead);
}

References _tag_MODULE_INFO::dwModSize, CStackWalker::FreeModuleInformations(), CStackWalker::GetLoadModules(), CStackWalker::LoadSymbol(), _tag_MODULE_INFO::ModuleAddress, OutputString(), _tag_MODULE_INFO::pNext, _tag_MODULE_INFO::szModuleName, _tag_MODULE_INFO::szModulePath, _tag_MODULE_INFO::szSymbolPath, and _tag_MODULE_INFO::szVersion.

Here is the call graph for this function:

ShowRegistorInformation()

void CBaseException::ShowRegistorInformation ( PCONTEXT pCtx )

virtual

{
#if defined(_M_IX86) // Intel Only!
  OutputString( _T("\nRegisters:\r\n") );
 
  OutputString(_T("EAX:%08X\r\nEBX:%08X\r\nECX:%08X\r\nEDX:%08X\r\nESI:%08X\r\nEDI:%08X\r\n"),
    pCtx->Eax, pCtx->Ebx, pCtx->Ecx, pCtx->Edx, pCtx->Esi, pCtx->Edi );
 
  OutputString( _T("CS:EIP:%04X:%08X\r\n"), pCtx->SegCs, pCtx->Eip );
  OutputString( _T("SS:ESP:%04X:%08X  EBP:%08X\r\n"),pCtx->SegSs, pCtx->Esp, pCtx->Ebp );
  OutputString( _T("DS:%04X  ES:%04X  FS:%04X  GS:%04X\r\n"), pCtx->SegDs, pCtx->SegEs, pCtx->SegFs, pCtx->SegGs );
  OutputString( _T("Flags:%08X\r\n"), pCtx->EFlags );
#elif defined(_M_X64)
    OutputString(_T("\nRegisters:\r\n"));
 
  OutputString(_T("RAX:%016llX\r\nRBX:%016llX\r\nRCX:%016llX\r\nRDX:%016llX\r\nRSI:%016llX\r\nRDI:%016llX\r\n"),
    pCtx->Rax, pCtx->Rbx, pCtx->Rcx, pCtx->Rdx, pCtx->Rsi, pCtx->Rdi );
 
  OutputString(_T("R8:%016llX\r\nR9:%016llX\r\nR10:%016llX\r\nR11:%016llX\r\nR12:%016llX\r\nR13:%016llX\r\nR14:%016llX\r\nR15:%016llX\r\n"),
    pCtx->R8, pCtx->R9, pCtx->R10, pCtx->R11, pCtx->R12, pCtx->R13, pCtx->R14, pCtx->R15 );
 
    OutputString(_T("CS:RIP:%04X:%016llX\r\n"), pCtx->SegCs, pCtx->Rip);
    OutputString(_T("SS:RSP:%04X:%016llX  RBP:%016llX\r\n"), pCtx->SegSs, pCtx->Rsp, pCtx->Rbp);
    OutputString(_T("DS:%04X  ES:%04X  FS:%04X  GS:%04X\r\n"), pCtx->SegDs, pCtx->SegEs, pCtx->SegFs, pCtx->SegGs);
    OutputString(_T("Flags:%08X\r\n"), pCtx->EFlags);
#elif defined(_M_ARM64)
    OutputString(_T("\nRegisters:\r\n"));
    OutputString(_T("PC:%016llX  SP:%016llX  FP:%016llX  LR:%016llX\r\n"),
        (unsigned long long)pCtx->Pc, (unsigned long long)pCtx->Sp,
        (unsigned long long)pCtx->Fp, (unsigned long long)pCtx->Lr);
    OutputString(_T("Cpsr:%08X\r\n"), pCtx->Cpsr);
#endif
 
  OutputString( _T("\r\n") );
}

References OutputString().

Referenced by ShowExceptionInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

StackWalker()

LPSTACKINFO CStackWalker::StackWalker ( HANDLE hThread = GetCurrentThread(), const CONTEXT * context = NULL )

inherited

{
  //USES_CONVERSION;
  //加载符号表
  LoadSymbol();
 
  LPSTACKINFO pHead = NULL;
  LPSTACKINFO pTail = pHead;
 
  //获取当前线程的上下文环境
  CONTEXT c = {0};
  if (context == NULL)
  {
#if _WIN32_WINNT <= 0x0501
    if (hThread == GetCurrentThread())
#else
    if (GetThreadId(hThread) == GetCurrentThreadId())
#endif
    {
      GET_CURRENT_THREAD_CONTEXT(c, CONTEXT_FULL);
    }
    else
    {
      //如果不是当前线程，需要停止目标线程，以便取出正确的堆栈信息
      SuspendThread(hThread);
      memset(&c, 0, sizeof(CONTEXT));
      c.ContextFlags = CONTEXT_FULL;
      if (GetThreadContext(hThread, &c) == FALSE)
      {
        ResumeThread(hThread);
        return NULL;
      }
    }
  }
  else
    c = *context;
 
  STACKFRAME64 sf = {};
  DWORD imageType;
 
//intel X86
#ifdef _M_IX86
  imageType = IMAGE_FILE_MACHINE_I386;
  sf.AddrPC.Offset = c.Eip;
  sf.AddrPC.Mode = AddrModeFlat;
  sf.AddrFrame.Offset = c.Ebp;
  sf.AddrFrame.Mode = AddrModeFlat;
  sf.AddrStack.Offset = c.Esp;
  sf.AddrStack.Mode = AddrModeFlat;
  // AMD
#elif _M_X64
  imageType = IMAGE_FILE_MACHINE_AMD64;
  sf.AddrPC.Offset = c.Rip;
  sf.AddrPC.Mode = AddrModeFlat;
  sf.AddrFrame.Offset = c.Rsp;
  sf.AddrFrame.Mode = AddrModeFlat;
  sf.AddrStack.Offset = c.Rsp;
  sf.AddrStack.Mode = AddrModeFlat;
#elif _M_IA64
  imageType = IMAGE_FILE_MACHINE_IA64;
  sf.AddrPC.Offset = c.StIIP;
  sf.AddrPC.Mode = AddrModeFlat;
  sf.AddrFrame.Offset = c.IntSp;
  sf.AddrFrame.Mode = AddrModeFlat;
  sf.AddrBStore.Offset = c.RsBSP;
  sf.AddrBStore.Mode = AddrModeFlat;
  sf.AddrStack.Offset = c.IntSp;
  sf.AddrStack.Mode = AddrModeFlat;
  // ARM64
#elif defined(_M_ARM64)
  imageType = IMAGE_FILE_MACHINE_ARM64;
  sf.AddrPC.Offset = c.Pc;
  sf.AddrPC.Mode = AddrModeFlat;
  sf.AddrFrame.Offset = c.Fp;
  sf.AddrFrame.Mode = AddrModeFlat;
  sf.AddrStack.Offset = c.Sp;
  sf.AddrStack.Mode = AddrModeFlat;
#else
#error "Platform not supported!"
#endif
 
  
  DWORD64 dwDisplayment = 0;
  PIMAGEHLP_SYMBOL64 pSym = (PIMAGEHLP_SYMBOL64)new BYTE[sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN];
  PIMAGEHLP_LINE64 pLine = new IMAGEHLP_LINE64;
  while (StackWalk64(imageType, m_hProcess, hThread, &sf, &c, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
  {
    ZeroMemory(pSym, sizeof(IMAGEHLP_SYMBOL64) + STACKWALK_MAX_NAMELEN);
    ZeroMemory(pLine, sizeof(IMAGEHLP_LINE64));
 
    pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
    pSym->MaxNameLength = STACKWALK_MAX_NAMELEN;
    pLine->SizeOfStruct = sizeof(IMAGEHLP_LINE64);
 
    LPSTACKINFO pCallStack = new STACKINFO;
    ZeroMemory(pCallStack, sizeof(STACKINFO));
    pCallStack->szFncAddr = sf.AddrPC.Offset;
    if (sf.AddrPC.Offset != 0)
    {
      if(SymGetSymFromAddr64(m_hProcess, sf.AddrPC.Offset, &dwDisplayment, pSym))
      {
        char szName[STACKWALK_MAX_NAMELEN] = "";
        StringCchCopy(pCallStack->szFncName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(pSym->Name));
        UnDecorateSymbolName(pSym->Name, szName, STACKWALK_MAX_NAMELEN, UNDNAME_COMPLETE);
        StringCchCopy(pCallStack->undFullName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(szName));
        ZeroMemory(szName, STACKWALK_MAX_NAMELEN * sizeof(char));
        UnDecorateSymbolName(pSym->Name, szName, STACKWALK_MAX_NAMELEN, UNDNAME_NAME_ONLY);
        StringCchCopy(pCallStack->undName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_(szName));
      }else
      {
        //调用错误一般是487(地址无效或者没有访问的权限、在符号表中未找到指定地址的相关信息)
        //this->OutputString(_T("Call SymGetSymFromAddr64 ,Address %08x Error:%08x\n"), sf.AddrPC.Offset, GetLastError());
 
                StringCchCopy(pCallStack->undFullName, STACKWALK_MAX_NAMELEN, textconv_helper::A2T_("Unknown"));
      }
 
      if (SymGetLineFromAddr64(m_hProcess, sf.AddrPC.Offset, (DWORD*)&dwDisplayment, pLine))
      {
        StringCchCopy(pCallStack->szFileName, MAX_PATH, textconv_helper::A2T_(pLine->FileName));
        pCallStack->uFileNum = pLine->LineNumber;
      }else
      {
        //this->OutputString(_T("Call SymGetLineFromAddr64 ,Address %08x Error:%08x\n"), sf.AddrPC.Offset, GetLastError());
 
                StringCchCopy(pCallStack->szFileName, MAX_PATH, textconv_helper::A2T_("Unknown file"));
                pCallStack->uFileNum = -1;
      }
      
      //这里为了将获取函数信息失败的情况与正常的情况一起输出，防止用户在查看时出现误解
      this->OutputString(_T("%08llx:%s [%s][%ld]\n"), pCallStack->szFncAddr, pCallStack->undFullName, pCallStack->szFileName, pCallStack->uFileNum);
      if (NULL == pHead)
      {
        pHead = pCallStack;
        pTail = pHead;
      }else
      {
        pTail->pNext = pCallStack;
        pTail = pCallStack;
      }
    }
  }
 
  delete[] pSym;
  delete pLine;
 
  return pHead;
}

References GET_CURRENT_THREAD_CONTEXT, LoadSymbol(), m_hProcess, OutputString(), tagSTACKINFO::pNext, STACKWALK_MAX_NAMELEN, tagSTACKINFO::szFileName, tagSTACKINFO::szFncAddr, tagSTACKINFO::szFncName, tagSTACKINFO::uFileNum, tagSTACKINFO::undFullName, and tagSTACKINFO::undName.

Referenced by CBaseException::ShowCallstack().

Here is the call graph for this function:

Here is the caller graph for this function:

STF()

void CBaseException::STF ( unsigned int ui, PEXCEPTION_POINTERS pEp )

static

{
  CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pEp);
  throw base;
}

References CBaseException().

Here is the call graph for this function:

UnhandledExceptionFilter()

LONG WINAPI CBaseException::UnhandledExceptionFilter ( PEXCEPTION_POINTERS pExceptionInfo )

static

{
  if (pExceptionInfo->ExceptionRecord->ExceptionCode < 0x80000000
    //BBS: Load project on computers with SDC may trigger this exception (in ShowModal()),
    //     It's not fatal and should be ignored, or there will be lots of meaningless crash logs
    || pExceptionInfo->ExceptionRecord->ExceptionCode==0xe0434352)
    //BBS: ignore the exception when copy preset
    //|| pExceptionInfo->ExceptionRecord->ExceptionCode==0xe06d7363)
  {
    //BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << boost::format(": got an ExceptionCode %1%, skip it!") % pExceptionInfo->ExceptionRecord->ExceptionCode;
    return EXCEPTION_CONTINUE_SEARCH;
  }
    g_dump_mutex.lock();
  CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pExceptionInfo);
  base.ShowExceptionInformation();
    g_dump_mutex.unlock();
 
  return EXCEPTION_CONTINUE_SEARCH;
}

References CBaseException(), g_dump_mutex, and ShowExceptionInformation().

Here is the call graph for this function:

UnhandledExceptionFilter2()

LONG WINAPI CBaseException::UnhandledExceptionFilter2 ( PEXCEPTION_POINTERS pExceptionInfo )

static

{
  CBaseException base(GetCurrentProcess(), GetCurrentProcessId(), NULL, pExceptionInfo);
  base.ShowExceptionInformation();
 
  return EXCEPTION_CONTINUE_SEARCH;
}

References CBaseException(), and ShowExceptionInformation().

Here is the call graph for this function:

Member Data Documentation

m_bSymbolLoaded

BOOL CStackWalker::m_bSymbolLoaded

protectedinherited

Referenced by CStackWalker(), ~CStackWalker(), and LoadSymbol().

m_hProcess

HANDLE CStackWalker::m_hProcess

protectedinherited

Referenced by CStackWalker(), ~CStackWalker(), GetModuleInformation(), GetModulesPSAPI(), LoadSymbol(), and StackWalker().

m_lpszSymbolPath

LPTSTR CStackWalker::m_lpszSymbolPath

protectedinherited

Referenced by CStackWalker(), ~CStackWalker(), and LoadSymbol().

m_pEp

PEXCEPTION_POINTERS CBaseException::m_pEp

protected

Referenced by CBaseException(), and ShowExceptionInformation().

m_wPID

WORD CStackWalker::m_wPID

protectedinherited

Referenced by CStackWalker(), and GetModulesTH32().

output_file

boost::nowide::ofstream* CBaseException::output_file

protected

Referenced by CBaseException(), ~CBaseException(), and OutputString().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/dev-utils/BaseException.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/dev-utils/BaseException.cpp