cStackTrace.h

Go to the documentation of this file.

//
 
#ifndef _INC_cStackTrace_H
#define _INC_cStackTrace_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
 
#if defined(_MSC_VER) && ! USE_UNICODE && ! defined(UNDER_CE)
#include "GrayCore/include/cAppState.h"
#include "GrayCore/include/cString.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cStackTrace);
 
        class cStackTraceInternal;  // forward
        class GRAYLIB_LINK cStackTrace
        {
                // similar to the __linux__ backtrace()
                // similar to .NET System.Diagnostics.StackTrace
 
                friend class cStackTraceInternal;
        public:
                enum StackTraceOptions
                {
                        // RetrieveNone,                                // No addition info will be retrieved (only the address is available)
                        RetrieveSymbol=1,                               // Try to get the symbol-name
                        RetrieveLine=2,                         // Try to get the line for this symbol
                        RetrieveModuleInfo = 4,         // Try to retrieve the module-infos
                        RetrieveFileVersion = 8,        // Also retrieve the version for the DLL/EXE
                        RetrieveVerbose = 0xF,          // Contains all the above
                        BuildSymPath = 0x10,            // Generate a "good" symbol-search-path
                        // SymUseSymSrv = 0x20,         // Also use the public Microsoft-Symbol-Server
                        SymAll = 0x30,                          // Contains all the above "Sym"-options
                        OptionsAll = 0x3F                       // Contains all options (default)
                };
 
                cStackTrace(
                        UINT options = OptionsAll, // 'int' is by design, to combine the enum-flags
                        const char* pszSymPath = nullptr,
                        PROCESSID_t dwProcessId = cAppState::get_CurrentProcessId(),
                        HANDLE hProcess = ::GetCurrentProcess()
                        );
                cStackTrace(PROCESSID_t dwProcessId, HANDLE hProcess);
                virtual ~cStackTrace();
 
                typedef BOOL (__stdcall *PReadProcessMemoryRoutine)(
                        HANDLE      hProcess,
                        UINT_PTR     qwBaseAddress,
                        PVOID       lpBuffer,
                        DWORD       nSize,
                        LPDWORD     lpNumberOfBytesRead,
                        LPVOID      pUserData  // optional data, which was passed in "ShowCallstack"
                        );
 
                BOOL LoadModules();
 
                BOOL ShowCallstack(
                        HANDLE hThread = ::GetCurrentThread(),
                        const CONTEXT *context = nullptr,       // registers etc.
                        PReadProcessMemoryRoutine readMemoryFunction = nullptr,
                        LPVOID pUserData = nullptr  // optional to identify some data in the 'readMemoryFunction'-callback
                        );
 
                UNITTEST2_PREDEF(cStackTrace);
 
                enum { StackTrace_MAX_NAMELEN = 1024 }; // max name length for found symbols
 
        protected:
                // Entry for each Callstack-Entry
                struct StackFrameA
                {
                        // Similar to System.Diagnostics.StackFrame
                        UINT_PTR offset;  // if 0, we have no valid entry
                        char name[StackTrace_MAX_NAMELEN];
                        char undName[StackTrace_MAX_NAMELEN];
                        char undFullName[StackTrace_MAX_NAMELEN];
                        UINT_PTR offsetFromSmybol;
                        DWORD offsetFromLine;
                        DWORD lineNumber;
                        char lineFileName[StackTrace_MAX_NAMELEN];
                        DWORD symType;
                        const char* symTypeString;
                        char moduleName[StackTrace_MAX_NAMELEN];
                        UINT_PTR baseOfImage;
                        char loadedImageName[StackTrace_MAX_NAMELEN];
                };
 
                enum CallstackEntryType {firstEntry, nextEntry, lastEntry};
 
                virtual void OnSymInit(const char* szSearchPath, DWORD symOptions, const char* szUserName);
                virtual void OnLoadModule(const FILECHAR_t* img, const char* mod, UINT_PTR baseAddr, DWORD size, const char* symType, const char* pdbName, ULONGLONG fileVersion);
                virtual void OnCallstackEntry(CallstackEntryType eType, StackFrameA &entry);
                virtual void OnDbgHelpErr(const char* szFuncName, HRESULT gle, UINT_PTR addr);
                virtual void OnOutput(const char* szText);
 
                cStackTraceInternal* m_sw;              // my internal helper hides dynamic bindings to the debug modules.
                HANDLE m_hProcess;                      // cOSHandle.
                PROCESSID_t m_dwProcessId;
                bool m_bLoadModules;
                cStringF m_sSymPath;
 
                UINT m_options; // StackTraceOptions
 
                // PREAD_PROCESS_MEMORY_ROUTINE
#ifdef USE_64BIT
                static BOOL __stdcall myReadProcMem(HANDLE hProcess, UINT_PTR qwBaseAddress, PVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);
#else
                static BOOL __stdcall myReadProcMem(HANDLE hProcess, DWORD qwBaseAddress, PVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);
#endif
 
        };
};
#endif // defined(_MSC_VER) && !USE_UNICODE
#endif // _INC_cStackTrace_H