// Copyright © 2025 CCP ehf.

#include "include/CCPCallstack.h"

namespace

{

void DumpPointerToFile( size_t codePointer, void* context )

{

fprintf( static_cast<FILE*>( context ), ", 0x%p", reinterpret_cast<void*>( codePointer ) );

}

void DumpPointerAndNameToFile( size_t codePointer, const char* name, void* context )

{

fprintf( static_cast<FILE*>( context ), ", 0x%p(%s)", reinterpret_cast<void*>( codePointer ), name );

}

}

#ifdef _MSC_VER

/// Pull in dbghelp to get symbols for callstack

/*

NB: VS2017 warns about the use of an ill-formed typedef in the <dbghelp.h> file,

but that's how it ships inside "Windows Kits\8.1" so guess we're stuck with it.

We can, at least, mute the warning...

*/

#pragma warning(push)

#pragma warning(disable:4091)

#include <dbghelp.h>

#pragma warning(pop)

///

/// The DbgHelp namespace wraps the functions provided in the DbgHelp DLL from Microsoft.

/// The DLL is loaded (and unloaded) as needed, to minimize runtime overhead.

///

namespace DbgHelp

{

typedef BOOL (__stdcall *SYMINITIALIZE)( HANDLE, LPSTR, BOOL );

typedef BOOL (__stdcall *SYMCLEANUP)( HANDLE );

typedef BOOL (__stdcall *SYMFROMADDR)( HANDLE, DWORD64, PDWORD64, PSYMBOL_INFO );

typedef DWORD (__stdcall *SYMSETOPTIONS)( DWORD );

typedef BOOL (__stdcall *STACKWALK64)( DWORD, HANDLE, HANDLE, LPSTACKFRAME64, LPVOID,PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64,PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64 );

typedef LPVOID (__stdcall *SYMFUNCTIONTABLEACCESS64)( HANDLE, DWORD64 );

typedef DWORD64 (__stdcall *SYMGETMODULEBASE64)( HANDLE, DWORD64 );

typedef BOOL (__stdcall *SYMSETSEARCHPATH)( HANDLE, PCTSTR );

typedef BOOL (__stdcall *SYMGETMODULEINFO64)( HANDLE, DWORD64, PIMAGEHLP_MODULE64 );

SYMINITIALIZE SymInitialize;

SYMCLEANUP SymCleanup;

SYMFROMADDR SymFromAddr;

SYMSETOPTIONS SymSetOptions;

STACKWALK64 StackWalk64;

SYMFUNCTIONTABLEACCESS64 SymFunctionTableAccess64;

SYMGETMODULEBASE64 SymGetModuleBase64;

SYMSETSEARCHPATH SymSetSearchPath;

SYMGETMODULEINFO64 SymGetModuleInfo64;

unsigned int s_initCount;

HMODULE s_moduleHandle;

bool Init()

{

if( s_initCount )

{

++s_initCount;

return true;

}

s_moduleHandle = LoadLibrary( "dbghelp.dll" );

if( s_moduleHandle )

{

SymInitialize = (SYMINITIALIZE)GetProcAddress( s_moduleHandle, "SymInitialize" );

SymCleanup = (SYMCLEANUP)GetProcAddress( s_moduleHandle, "SymCleanup" );

SymSetOptions = (SYMSETOPTIONS)GetProcAddress( s_moduleHandle, "SymSetOptions" );

SymFromAddr = (SYMFROMADDR)GetProcAddress( s_moduleHandle, "SymFromAddr" );

StackWalk64 = (STACKWALK64)GetProcAddress( s_moduleHandle, "StackWalk64" );

SymFunctionTableAccess64 = (SYMFUNCTIONTABLEACCESS64)GetProcAddress( s_moduleHandle, "SymFunctionTableAccess64" );

SymGetModuleBase64 = (SYMGETMODULEBASE64)GetProcAddress( s_moduleHandle, "SymGetModuleBase64" );

SymSetSearchPath = (SYMSETSEARCHPATH)GetProcAddress( s_moduleHandle, "SymSetSearchPath" );

SymGetModuleInfo64 = (SYMGETMODULEINFO64)GetProcAddress( s_moduleHandle, "SymGetModuleInfo64" );

DWORD flags = SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS;// | SYMOPT_LOAD_ANYTHING;

/// To see what DbgHelp attempts to load, enable the following line:

flags |= SYMOPT_DEBUG;

SymSetOptions( flags );

HANDLE hProcess = GetCurrentProcess();

// HACK: This path is hard-coded - figure out the right way to get the location

SymInitialize( hProcess, 0, true );

++s_initCount;

return true;

}

else

{

return false;

}

}

void Done()

{

if( s_initCount )

{

--s_initCount;

if( !s_initCount )

{

FreeLibrary( s_moduleHandle );

}

}

}

}

// _ReturnAddress should be prototyped before use

extern "C" void * _ReturnAddress(void);

#pragma intrinsic(_ReturnAddress)

#pragma auto_inline(off)

DWORD_PTR

GetProgramCounter()

{

return (DWORD_PTR)_ReturnAddress();

}

#pragma auto_inline(on)

#pragma warning (push)

#pragma warning (disable: 4748)

void CCPCallstack::Capture()

{

DbgHelp::Init();

m_depth = 0;

HANDLE hProcess = GetCurrentProcess();

HANDLE hThread = GetCurrentThread();

DWORD machineType;

CONTEXT context;

ZeroMemory( &context, sizeof( CONTEXT ) );

context.ContextFlags = CONTEXT_CONTROL;

STACKFRAME64 stackFrame;

ZeroMemory(&stackFrame, sizeof( STACKFRAME64 ) );

#ifdef _WIN64

RtlCaptureContext( &context );

#if _M_X64

machineType = IMAGE_FILE_MACHINE_AMD64;

stackFrame.AddrPC.Offset = context.Rip;

stackFrame.AddrPC.Mode = AddrModeFlat;

stackFrame.AddrFrame.Offset = context.Rsp;

stackFrame.AddrFrame.Mode = AddrModeFlat;

stackFrame.AddrStack.Offset = context.Rsp;

stackFrame.AddrStack.Mode = AddrModeFlat;

#elif _M_IA64

machineType = IMAGE_FILE_MACHINE_IA64;

stackFrame.AddrPC.Offset = context.StIIP;

stackFrame.AddrPC.Mode = AddrModeFlat;

stackFrame.AddrFrame.Offset = context.IntSp;

stackFrame.AddrFrame.Mode = AddrModeFlat;

stackFrame.AddrBStore.Offset= context.RsBSP;

stackFrame.AddrBStore.Mode = AddrModeFlat;

stackFrame.AddrStack.Offset = context.IntSp;

stackFrame.AddrStack.Mode = AddrModeFlat;

#else

#error "Unsupported platform"

#endif

#else

// 32 bit Windows

machineType = IMAGE_FILE_MACHINE_I386;

__asm

{

Label:

mov [context.Ebp], ebp;

mov [context.Esp], esp;

mov eax, [Label];

mov [context.Eip], eax;

}

stackFrame.AddrPC.Offset = context.Eip;

stackFrame.AddrPC.Mode = AddrModeFlat;

stackFrame.AddrStack.Offset = context.Esp;

stackFrame.AddrStack.Mode = AddrModeFlat;

stackFrame.AddrFrame.Offset = context.Ebp;

stackFrame.AddrFrame.Mode = AddrModeFlat;

#endif

while( m_depth < kMaxDepth )

{

BOOL result = DbgHelp::StackWalk64(

machineType,

hProcess,

hThread,

&stackFrame,

&context,

0,

DbgHelp::SymFunctionTableAccess64,

DbgHelp::SymGetModuleBase64,

0 );

if( !result )

{

break;

}

m_entries[m_depth] = (size_t)stackFrame.AddrPC.Offset;

++m_depth;

}

DbgHelp::Done();

}

#pragma warning (pop)

void CCPCallstack::LoadSymbols()

{

DbgHelp::Init();

}

void CCPCallstack::ReleaseSymbols()

{

DbgHelp::Done();

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, const char* functionName, void* context ), void* context ) const

{

DbgHelp::Init();

HANDLE hProcess = GetCurrentProcess();

for( unsigned int i = 0; i < m_depth; ++i )

{

DWORD64 dwDisplacement;

ULONG64 buffer[(sizeof(SYMBOL_INFO) +

MAX_SYM_NAME*sizeof(TCHAR) +

sizeof(ULONG64) - 1) /

sizeof(ULONG64)] = { 0 };

PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;

pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);

pSymbol->MaxNameLen = MAX_SYM_NAME;

char name[256];

if( DbgHelp::SymFromAddr( hProcess, m_entries[i], &dwDisplacement, pSymbol) )

{

_snprintf_s( name, 256, _TRUNCATE, "%s + 0x%I64X", pSymbol->Name, dwDisplacement );

}

else

{

name[0] = 0;

}

IMAGEHLP_MODULE64 moduleInfo;

moduleInfo.SizeOfStruct = sizeof( IMAGEHLP_MODULE64 );

DbgHelp::SymGetModuleInfo64( hProcess, m_entries[i], &moduleInfo );

callback( m_entries[i], name, context );

}

DbgHelp::Done();

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, void* context ), void* context ) const

{

DbgHelp::Init();

for( unsigned int i = 0; i < m_depth; ++i )

{

callback( m_entries[i], context );

}

DbgHelp::Done();

}

#elif defined(__ANDROID__)

void CCPCallstack::LoadSymbols()

{

}

void CCPCallstack::ReleaseSymbols()

{

}

void CCPCallstack::Capture()

{

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, void* context ), void* context ) const

{

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, const char* functionName, void* context ), void* context ) const

{

}

#else

#include <execinfo.h>

#include <cxxabi.h>

#include <string>

void CCPCallstack::LoadSymbols()

{

}

void CCPCallstack::ReleaseSymbols()

{

}

void CCPCallstack::Capture()

{

m_depth = backtrace( reinterpret_cast<void**>( m_entries ), kMaxDepth );

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, void* context ), void* context ) const

{

for( unsigned int i = 0; i < m_depth; ++i )

{

callback( m_entries[i], context );

}

}

namespace

{

void GetLastWord( const char* begin, const char* end, std::string& result )

{

while( end > begin )

{

if( !isspace( *end ) )

{

break;

}

--end;

}

const char* wordStart = end++;

while( wordStart > begin )

{

if( !isalnum( *wordStart ) && *wordStart != '_' )

{

break;

}

--wordStart;

}

result = std::string( ++wordStart, end );

}

void GetFirstWorld( const char* begin, std::string& result )

{

while( *begin && isspace( *begin ) )

{

++begin;

}

if( *begin )

{

const char* end = begin;

while( *end && isalnum( *end ) )

{

++end;

}

result = std::string( begin, end );

}

}

void DemangleName( std::string& name )

{

int status = 0;

char* buffer = abi::__cxa_demangle( name.c_str(), nullptr, 0, &status );

if( buffer )

{

name = buffer;

free( buffer );

}

}

}

void CCPCallstack::Enumerate( void ( *callback )( size_t codePointer, const char* functionName, void* context ), void* context ) const

{

char** lines = backtrace_symbols( reinterpret_cast<void* const *>( m_entries ), m_depth );

if( !lines )

{

return;

}

for( size_t i = 0; i < m_depth; ++i )

{

std::string record = lines[i];

const char* plus = strchr( lines[i], '+' );

if( *plus )

{

std::string name;

GetLastWord( lines[i], plus - 1, name );

if( !name.empty() )

{

DemangleName( name );

std::string offset;

GetFirstWorld( plus + 1, offset );

if( !offset.empty() )

{

name += "+";

name += offset;

}

record = name;

}

}

callback( m_entries[i], record.c_str(), context );

}

free( lines );

}

#endif // _MSC_VER

CCPCallstack::CCPCallstack()

: m_depth( 0 )

{

memset( m_entries, 0, sizeof( m_entries ) );

}

void CCPCallstack::DumpWithSymbols( FILE* fp ) const

{

Enumerate( &DumpPointerAndNameToFile, fp );

}

void CCPCallstack::DumpRaw( FILE* fp ) const

{

Enumerate( &DumpPointerToFile, fp );

}